Skip to content

L
linux
Commit 9e16d457 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files
Options

staging: csr: remove csr_utf16.c 

Only one function was being used in the file, so move it to where it was
being called and delete the rest of the file, and csr_unicode.h as it's
no longer needed as well.

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 eaae2e92
Show whitespace changes
Inline Side-by-side
Showing with 28 additions and 1155 deletions
drivers/staging/csr/Makefile
View file @ 9e16d457
......@@ -71,6 +71,5 @@ csr_helper-y := csr_time.o \
csr_framework_ext.o \
csr_wifi_serialize_primitive_types.o \
csr_serialize_primitive_types.o \
csr_utf16.o \
csr_msgconv.o \
csr_panic.o
drivers/staging/csr/csr_msgconv.h
View file @ 9e16d457
......@@ -14,7 +14,6 @@
#include <linux/types.h>
#include "csr_prim_defs.h"
#include "csr_sched.h"
#include "csr_unicode.h"
#ifdef __cplusplus
extern "C" {
......
drivers/staging/csr/csr_serialize_primitive_types.c
View file @ 9e16d457
......@@ -15,6 +15,34 @@
#include "csr_macro.h"
#include "csr_lib.h"
/********************************************************************************
*
* Name: CsrUtf16StrLen
*
* Description: The function returns the number of 16 bit elements present
* in the 0-terminated string.
*
* Input: 0-terminated string of 16 bit unicoded characters.
*
* Output: The number of 16 bit elements in the string.
*
*********************************************************************************/
static u32 CsrUtf16StrLen(const u16 *unicodeString)
{
u32 length;
length = 0;
if (unicodeString != NULL)
{
while (*unicodeString)
{
length++;
unicodeString++;
}
}
return length;
}
void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset)
{
*value = buffer[*offset];
......
drivers/staging/csr/csr_unicode.h deleted 100644 → 0
View file @ eaae2e92
#ifndef CSR_UNICODE_H__
#define CSR_UNICODE_H__
/*****************************************************************************
(c) Cambridge Silicon Radio Limited 2010
All rights reserved and confidential information of CSR
Refer to LICENSE.txt included with this source for details
on the license terms.
*****************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
u16 *CsrUint32ToUtf16String(u32 number);
u32 CsrUtf16StringToUint32(const u16 *unicodeString);
u32 CsrUtf16StrLen(const u16 *unicodeString);
u8 *CsrUtf16String2Utf8(const u16 *source);
u16 *CsrUtf82Utf16String(const u8 *utf8String);
u16 *CsrUtf16StrCpy(u16 *target, const u16 *source);
u16 *CsrUtf16StringDuplicate(const u16 *source);
u16 CsrUtf16StrICmp(const u16 *string1, const u16 *string2);
u16 CsrUtf16StrNICmp(const u16 *string1, const u16 *string2, u32 count);
u16 *CsrUtf16MemCpy(u16 *dest, const u16 *src, u32 count);
u16 *CsrUtf16ConcatenateTexts(const u16 *inputText1, const u16 *inputText2,
const u16 *inputText3, const u16 *inputText4);
u16 *CsrUtf16String2XML(u16 *str);
u16 *CsrXML2Utf16String(u16 *str);
u32 CsrUtf8StringLengthInBytes(const u8 *string);
/*******************************************************************************
NAME
CsrUtf8StrTruncate
DESCRIPTION
In-place truncate a string on a UTF-8 character boundary by writing a
null character somewhere in the range target[count - 3]:target[count].
Please note that memory passed must be at least of length count + 1, to
ensure space for a full length string that is terminated at
target[count], in the event that target[count - 1] is the final byte of
a UTF-8 character.
PARAMETERS
target - Target string to truncate.
count - The desired length, in bytes, of the resulting string. Depending
on the contents, the resulting string length will be between
count - 3 and count.
RETURNS
Returns target
*******************************************************************************/
u8 *CsrUtf8StrTruncate(u8 *target, size_t count);
/*
* UCS2
*
* D-13157
*/
typedef u8 CsrUcs2String;
size_t CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
size_t CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String);
u8 *CsrUtf16String2Ucs2ByteString(const u16 *source);
u16 *CsrUcs2ByteString2Utf16String(const u8 *source);
#ifdef __cplusplus
}
#endif
#endif
drivers/staging/csr/csr_utf16.c deleted 100644 → 0
View file @ eaae2e92
/*****************************************************************************
(c) Cambridge Silicon Radio Limited 2010
All rights reserved and confidential information of CSR
Refer to LICENSE.txt included with this source for details
on the license terms.
*****************************************************************************/
#include <linux/module.h>
#include <linux/slab.h>
#include "csr_unicode.h"
#include "csr_macro.h"
#define UNI_SUR_HIGH_START ((u32) 0xD800)
#define UNI_SUR_HIGH_END ((u32) 0xDBFF)
#define UNI_SUR_LOW_START ((u32) 0xDC00)
#define UNI_SUR_LOW_END ((u32) 0xDFFF)
#define UNI_REPLACEMENT_CHAR ((u32) 0xFFFD)
#define UNI_HALF_SHIFT ((u8) 10) /* used for shifting by 10 bits */
#define UNI_HALF_BASE ((u32) 0x00010000)
#define UNI_BYTEMASK ((u32) 0xBF)
#define UNI_BYTEMARK ((u32) 0x80)
#define CAPITAL(x) ((x >= 'a') && (x <= 'z') ? ((x) & 0x00DF) : (x))
/*
* Index into the table with the first byte to get the number of trailing bytes in a utf-8 character.
* -1 if the byte has an invalid value.
*
* Legal sequences are:
*
* byte 1st 2nd 3rd 4th
*
* 00-7F
* C2-DF 80-BF
* E0 A0-BF 80-BF
* E1-EC 80-BF 80-BF
* ED 80-9F 80-BF
* EE-EF 80-BF 80-BF
* F0 90-BF 80-BF 80-BF
* F1-F3 80-BF 80-BF 80-BF
* F4 80-8F 80-BF 80-BF
*/
static const s8 trailingBytesForUtf8[256] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x1F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x3F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x5F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x7F */
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x80 - 0x9F */
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xA0 - 0xBF */
-1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xC0 - 0xDF */
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xE0 - 0xFF */
};
/* Values to be substracted from a u32 when converting from UTF8 to UTF16 */
static const u32 offsetsFromUtf8[4] =
{
0x00000000, 0x00003080, 0x000E2080, 0x03C82080
};
/********************************************************************************
*
* Name: CsrUint32ToUtf16String
*
* Description: The function converts an 32 bit number to an UTF-16 string
* that is allocated and 0-terminated.
*
* Input: 32 bit number.
*
* Output: A string of UTF-16 characters.
*
*********************************************************************************/
u16 *CsrUint32ToUtf16String(u32 number)
{
u16 count, noOfDigits;
u16 *output;
u32 tempNumber;
/* calculate the number of digits in the output */
tempNumber = number;
noOfDigits = 1;
while (tempNumber >= 10)
{
tempNumber = tempNumber / 10;
noOfDigits++;
}
output = kmalloc(sizeof(u16) * (noOfDigits + 1), GFP_KERNEL); /*add space for 0-termination*/
tempNumber = number;
for (count = noOfDigits; count > 0; count--)
{
output[count - 1] = (u16) ((tempNumber % 10) + '0');
tempNumber = tempNumber / 10;
}
output[noOfDigits] = '\0';
return output;
}
/********************************************************************************
*
* Name: CsrUtf16StringToUint32
*
* Description: The function converts an UTF-16 string that is
* 0-terminated into a 32 bit number.
*
* Input: A string of UTF-16 characters containig a number.
*
* Output: 32 bit number.
*
*********************************************************************************/
u32 CsrUtf16StringToUint32(const u16 *unicodeString)
{
u16 numLen, count;
u32 newNumber = 0;
numLen = (u16) CsrUtf16StrLen(unicodeString);
if ((numLen > 10) || (numLen == 0) || (unicodeString == NULL)) /*CSRMAX number is 4.294.967.295 */
{
return 0;
}
for (count = 0; count < numLen; count++)
{
u16 input = unicodeString[count];
if ((input < 0x30) || (input > 0x39) || ((newNumber == 0x19999999) && (input > 0x35)) || (newNumber > 0x19999999)) /* chars are present or number is too large now causing number to get to large when *10 */
{
return 0;
}
newNumber = (newNumber * 10) + (input - 0x30);
}
return newNumber;
}
/********************************************************************************
*
* Name: CsrUtf16MemCpy
*
* Description: The function copies count number of 16 bit data elements
* from srv to dest.
*
* Input: A pointer to an unicoded string.
*
* Output: A pointer to an unicoded string.
*
*********************************************************************************/
u16 *CsrUtf16MemCpy(u16 *dest, const u16 *src, u32 count)
{
return memcpy((u8 *) dest, (u8 *) src, count * sizeof(u16));
}
/********************************************************************************
*
* Name: CsrUtf16ConcatenateTexts
*
* Description: The function merge the contents of 4 unicoded input pointers
* into a new string.
*
* Input: 4 unicoded input strings (UTF-16).
*
* Output: A new unicoded string (UTF-16) containing the combined strings.
*
*********************************************************************************/
u16 *CsrUtf16ConcatenateTexts(const u16 *inputText1, const u16 *inputText2,
const u16 *inputText3, const u16 *inputText4)
{
u16 *outputText;
u32 textLen, textLen1, textLen2, textLen3, textLen4;
textLen1 = CsrUtf16StrLen(inputText1);
textLen2 = CsrUtf16StrLen(inputText2);
textLen3 = CsrUtf16StrLen(inputText3);
textLen4 = CsrUtf16StrLen(inputText4);
textLen = textLen1 + textLen2 + textLen3 + textLen4;
if (textLen == 0) /*stop here is all lengths are 0*/
{
return NULL;
}
outputText = kmalloc((textLen + 1) * sizeof(u16), GFP_KERNEL); /* add space for 0-termination*/
if (inputText1 != NULL)
{
CsrUtf16MemCpy(outputText, inputText1, textLen1);
}
if (inputText2 != NULL)
{
CsrUtf16MemCpy(&(outputText[textLen1]), inputText2, textLen2);
}
if (inputText3 != NULL)
{
CsrUtf16MemCpy(&(outputText[textLen1 + textLen2]), inputText3, textLen3);
}
if (inputText4 != NULL)
{
CsrUtf16MemCpy(&(outputText[textLen1 + textLen2 + textLen3]), inputText4, textLen4);
}
outputText[textLen] = '\0';
return outputText;
}
/********************************************************************************
*
* Name: CsrUtf16StrLen
*
* Description: The function returns the number of 16 bit elements present
* in the 0-terminated string.
*
* Input: 0-terminated string of 16 bit unicoded characters.
*
* Output: The number of 16 bit elements in the string.
*
*********************************************************************************/
u32 CsrUtf16StrLen(const u16 *unicodeString)
{
u32 length;
length = 0;
if (unicodeString != NULL)
{
while (*unicodeString)
{
length++;
unicodeString++;
}
}
return length;
}
/********************************************************************************
*
* Name: CsrUtf16String2Utf8
*
* Description: The function decodes an UTF-16 string into an UTF8 byte
* oriented string.
*
* Input: 0-terminated UTF-16 string characters.
*
* Output: 0-terminated string of byte oriented UTF8 coded characters.
*
*********************************************************************************/
u8 *CsrUtf16String2Utf8(const u16 *source)
{
u8 *dest, *destStart = NULL;
u32 i;
u32 ch;
u32 length;
u32 sourceLength;
u8 bytes;
u8 appendNull = FALSE;
u8 firstByteMark[5] = {0x00, 0x00, 0xC0, 0xE0, 0xF0};
if (!source)
{
return NULL;
}
length = 0;
sourceLength = CsrUtf16StrLen(source) + 1;
for (i = 0; i < sourceLength; i++)
{
ch = source[i];
if ((ch >= UNI_SUR_HIGH_START) && (ch <= UNI_SUR_HIGH_END)) /* This is a high surrogate */
{
if (i + 1 < sourceLength) /* The low surrogate is in the source */
{
u32 ch2 = source[++i];
if ((ch2 >= UNI_SUR_LOW_START) && (ch2 <= UNI_SUR_LOW_END)) /* And it is a legal low surrogate */
{
length += 4;
}
else /* It is not a low surrogate, instead put a Unicode
'REPLACEMENT CHARACTER' (U+FFFD) */
{
length += 3;
i--; /* Substract 1 again as the conversion must continue after the ill-formed code unit */
}
}
else /* The low surrogate does not exist, instead put a Unicode
'REPLACEMENT CHARACTER' (U+FFFD), and the null terminated character */
{
length += 4;
}
}
else if ((ch >= UNI_SUR_LOW_START) && (ch <= UNI_SUR_LOW_END)) /* The value of UTF-16 is not allowed to be in this range, instead put
a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
{
length += 3;
}
else /* Figure out how many bytes that are required */
{
if (ch < 0x0080)
{
length++;
}
else if (ch < 0x0800)
{
length += 2;
}
else
{
length += 3;
}
}
}
dest = kmalloc(length, GFP_KERNEL);
destStart = dest;
for (i = 0; i < sourceLength; i++)
{
ch = source[i];
if ((ch >= UNI_SUR_HIGH_START) && (ch <= UNI_SUR_HIGH_END)) /* This is a high surrogate */
{
if (i + 1 < sourceLength) /* The low surrogate is in the source */
{
u32 ch2 = source[++i];
if ((ch2 >= UNI_SUR_LOW_START) && (ch2 <= UNI_SUR_LOW_END)) /* And it is a legal low surrogate, convert to UTF-32 */
{
ch = ((ch - UNI_SUR_HIGH_START) << UNI_HALF_SHIFT) + (ch2 - UNI_SUR_LOW_START) + UNI_HALF_BASE;
}
else /* It is not a low surrogate, instead put a Unicode
'REPLACEMENT CHARACTER' (U+FFFD) */
{
ch = UNI_REPLACEMENT_CHAR;
i--; /* Substract 1 again as the conversion must continue after the ill-formed code unit */
}
}
else /* The low surrogate does not exist, instead put a Unicode
'REPLACEMENT CHARACTER' (U+FFFD), and the null terminated character */
{
ch = UNI_REPLACEMENT_CHAR;
appendNull = TRUE;
}
}
else if ((ch >= UNI_SUR_LOW_START) && (ch <= UNI_SUR_LOW_END)) /* The value of UTF-16 is not allowed to be in this range, instead put
a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
{
ch = UNI_REPLACEMENT_CHAR;
}
/* Figure out how many bytes that are required */
if (ch < (u32) 0x80)
{
bytes = 1;
}
else if (ch < (u32) 0x800)
{
bytes = 2;
}
else if (ch < (u32) 0x10000)
{
bytes = 3;
}
else if (ch < (u32) 0x110000)
{
bytes = 4;
}
else
{
bytes = 3;
ch = UNI_REPLACEMENT_CHAR;
}
dest += bytes;
switch (bytes) /* Convert character to UTF-8. Note: everything falls through. */
{
case 4:
{
*--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
ch >>= 6;
}
/* FALLTHROUGH */
case 3:
{
*--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
ch >>= 6;
}
/* FALLTHROUGH */
case 2:
{
*--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
ch >>= 6;
}
/* FALLTHROUGH */
case 1:
{
*--dest = (u8) (ch | firstByteMark[bytes]);
}
/* FALLTHROUGH */
default:
{
break;
}
}
dest += bytes;
}
if (appendNull) /* Append the \0 character */
{
*dest = '\0';
}
return destStart;
}
/*****************************************************************************
NAME
isLegalUtf8
DESCRIPTION
Returns TRUE if the given UFT-8 code unit is legal as defined by the
Unicode standard (see Chapter 3: Conformance, Section 3.9: Unicode
Encoding Forms, UTF-8).
This function assumes that the length parameter is unconditionally
correct and that the first byte is already validated by looking it up
in the trailingBytesForUtf8 array, which also reveals the number of
trailing bytes.
Legal code units are composed of one of the following byte sequences:
1st 2nd 3rd 4th
--------------------------------
00-7F
C2-DF 80-BF
E0 A0-BF 80-BF
E1-EC 80-BF 80-BF
ED 80-9F 80-BF
EE-EF 80-BF 80-BF
F0 90-BF 80-BF 80-BF
F1-F3 80-BF 80-BF 80-BF
F4 80-8F 80-BF 80-BF
Please note that this function only checks whether the 2nd, 3rd and
4th bytes fall into the valid ranges.
PARAMETERS
codeUnit - pointer to the first byte of the byte sequence composing
the code unit to test.
length - the number of bytes in the code unit. Valid range is 1 to 4.
RETURNS
TRUE if the given code unit is legal.
*****************************************************************************/
static u8 isLegalUtf8(const u8 *codeUnit, u32 length)
{
const u8 *srcPtr = codeUnit + length;
u8 byte;
switch (length) /* Everything falls through except case 1 */
{
case 4:
{
byte = *--srcPtr;
if ((byte < 0x80) || (byte > 0xBF))
{
return FALSE;
}
}
/* Fallthrough */
case 3:
{
byte = *--srcPtr;
if ((byte < 0x80) || (byte > 0xBF))
{
return FALSE;
}
}
/* Fallthrough */
case 2:
{
byte = *--srcPtr;
if (byte > 0xBF)
{
return FALSE;
}
switch (*codeUnit) /* No fallthrough */
{
case 0xE0:
{
if (byte < 0xA0)
{
return FALSE;
}
break;
}
case 0xED:
{
if ((byte < 0x80) || (byte > 0x9F))
{
return FALSE;
}
break;
}
case 0xF0:
{
if (byte < 0x90)
{
return FALSE;
}
break;
}
case 0xF4:
{
if ((byte < 0x80) || (byte > 0x8F))
{
return FALSE;
}
break;
}
default:
{
if (byte < 0x80)
{
return FALSE;
}
break;
}
}
}
/* Fallthrough */
case 1:
default:
/* The 1st byte and length are assumed correct */
break;
}
return TRUE;
}
/********************************************************************************
*
* Name: CsrUtf82Utf16String
*
* Description: The function decodes an UTF8 byte oriented string into a
* UTF-16string.
*
* Input: 0-terminated string of byte oriented UTF8 coded characters.
*
* Output: 0-terminated string of UTF-16 characters.
*
*********************************************************************************/
u16 *CsrUtf82Utf16String(const u8 *utf8String)
{
size_t i, length = 0;
size_t sourceLength;
u16 *dest = NULL;
u16 *destStart = NULL;
s8 extraBytes2Read;
if (!utf8String)
{
return NULL;
}
sourceLength = strlen((char *)utf8String);
for (i = 0; i < sourceLength; i++)
{
extraBytes2Read = trailingBytesForUtf8[utf8String[i]];
if (extraBytes2Read == -1) /* Illegal byte value, instead put a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
{
length += 1;
}
else if (i + extraBytes2Read > sourceLength) /* The extra bytes does not exist, instead put a Unicode 'REPLACEMENT
CHARACTER' (U+FFFD), and the null terminated character */
{
length += 2;
break;
}
else if (isLegalUtf8(&utf8String[i], extraBytes2Read + 1) == FALSE) /* It is not a legal utf-8 character, instead put a Unicode 'REPLACEMENT
CHARACTER' (U+FFFD) */
{
length += 1;
}
else
{
if (utf8String[i] > 0xEF) /* Needs a high and a low surrogate */
{
length += 2;
}
else
{
length += 1;
}
i += extraBytes2Read;
}
}
/* Create space for the null terminated character */
dest = kmalloc((1 + length) * sizeof(u16), GFP_KERNEL);
destStart = dest;
for (i = 0; i < sourceLength; i++)
{
extraBytes2Read = trailingBytesForUtf8[utf8String[i]];
if (extraBytes2Read == -1) /* Illegal byte value, instead put a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
{
*dest++ = UNI_REPLACEMENT_CHAR;
}
else if (i + extraBytes2Read > sourceLength) /* The extra bytes does not exist, instead put a Unicode 'REPLACEMENT
CHARACTER' (U+FFFD), and the null terminated character */
{
*dest++ = UNI_REPLACEMENT_CHAR;
*dest++ = '\0';
break;
}
else if (isLegalUtf8(&utf8String[i], extraBytes2Read + 1) == FALSE) /* It is not a legal utf-8 character, instead put a Unicode 'REPLACEMENT
CHARACTER' (U+FFFD) */
{
*dest++ = UNI_REPLACEMENT_CHAR;
}
else /* It is legal, convert the character to an u32 */
{
u32 ch = 0;
switch (extraBytes2Read) /* Everything falls through */
{
case 3:
{
ch += utf8String[i];
ch <<= 6;
i++;
}
/* FALLTHROUGH */
case 2:
{
ch += utf8String[i];
ch <<= 6;
i++;
}
/* FALLTHROUGH */
case 1:
{
ch += utf8String[i];
ch <<= 6;
i++;
}
/* FALLTHROUGH */
case 0:
{
ch += utf8String[i];
}
/* FALLTHROUGH */
default:
{
break;
}
}
ch -= offsetsFromUtf8[extraBytes2Read];
if (ch <= 0xFFFF) /* Character can be encoded in one u16 */
{
*dest++ = (u16) ch;
}
else /* The character needs two u16 */
{
ch -= UNI_HALF_BASE;
*dest++ = (u16) ((ch >> UNI_HALF_SHIFT) | UNI_SUR_HIGH_START);
*dest++ = (u16) ((ch & 0x03FF) | UNI_SUR_LOW_START);
}
}
}
destStart[length] = 0x00;
return destStart;
}
/********************************************************************************
*
* Name: CsrUtf16StrCpy
*
* Description: The function copies the contents from one UTF-16 string
* to another UTF-16 string.
*
* Input: 0-terminated UTF-16 string.
*
* Output: 0-terminated UTF-16 string.
*
*********************************************************************************/
u16 *CsrUtf16StrCpy(u16 *target, const u16 *source)
{
if (source) /* if source is not NULL*/
{
memcpy(target, source, (CsrUtf16StrLen(source) + 1) * sizeof(u16));
return target;
}
else
{
return NULL;
}
}
/********************************************************************************
*
* Name: CsrUtf16StringDuplicate
*
* Description: The function allocates a new pointer and copies the input to
* the new pointer.
*
* Input: 0-terminated UTF-16 string.
*
* Output: Allocated variable0-terminated UTF-16 string.
*
*********************************************************************************/
u16 *CsrUtf16StringDuplicate(const u16 *source)
{
u16 *target = NULL;
u32 length;
if (source) /* if source is not NULL*/
{
length = (CsrUtf16StrLen(source) + 1) * sizeof(u16);
target = kmalloc(length, GFP_KERNEL);
memcpy(target, source, length);
}
return target;
}
/********************************************************************************
*
* Name: CsrUtf16StrICmp
*
* Description: The function compares two UTF-16 strings.
*
* Input: Two 0-terminated UTF-16 string.
*
* Output: 0: if the strings are identical.
*
*********************************************************************************/
u16 CsrUtf16StrICmp(const u16 *string1, const u16 *string2)
{
while (*string1 || *string2)
{
if (CAPITAL(*string1) != CAPITAL(*string2))
{
return *string1 - *string2;
}
string1++;
string2++;
}
return 0;
}
/********************************************************************************
*
* Name: CsrUtf16StrNICmp
*
* Description: The function compares upto count number of elements in the
* two UTF-16 string.
*
* Input: Two 0-terminated UTF-16 string and a maximum
* number of elements to check.
*
* Output: 0: if the strings are identical.
*
*********************************************************************************/
u16 CsrUtf16StrNICmp(const u16 *string1, const u16 *string2, u32 count)
{
while ((*string1 || *string2) && count--)
{
if (CAPITAL(*string1) != CAPITAL(*string2))
{
return *string1 - *string2;
}
string1++;
string2++;
}
return 0;
}
/********************************************************************************
*
* Name: CsrUtf16String2XML
*
* Description: The function converts an unicoded string (UTF-16) into an unicoded XML
* string where some special characters are encoded according to
* the XML spec.
*
* Input: A unicoded string (UTF-16) which is freed.
*
* Output: A new unicoded string (UTF-16) containing the converted output.
*
*********************************************************************************/
u16 *CsrUtf16String2XML(u16 *str)
{
u16 *scanString;
u16 *outputString = NULL;
u16 *resultString = str;
u32 stringLength = 0;
u8 encodeChars = FALSE;
scanString = str;
if (scanString)
{
while (*scanString)
{
if (*scanString == L'&')
{
stringLength += 5;
encodeChars = TRUE;
}
else if ((*scanString == L'<') || (*scanString == L'>'))
{
stringLength += 4;
encodeChars = TRUE;
}
else
{
stringLength++;
}
scanString++;
}
stringLength++;
if (encodeChars)
{
resultString = outputString = kmalloc(stringLength * sizeof(u16), GFP_KERNEL);
scanString = str;
while (*scanString)
{
if (*scanString == L'&')
{
*outputString++ = '&';
*outputString++ = 'a';
*outputString++ = 'm';
*outputString++ = 'p';
*outputString++ = ';';
}
else if (*scanString == L'<')
{
*outputString++ = '&';
*outputString++ = 'l';
*outputString++ = 't';
*outputString++ = ';';
}
else if (*scanString == L'>')
{
*outputString++ = '&';
*outputString++ = 'g';
*outputString++ = 't';
*outputString++ = ';';
}
else
{
*outputString++ = *scanString;
}
scanString++;
}
*outputString++ = 0;
kfree(str);
}
}
return resultString;
}
/********************************************************************************
*
* Name: CsrXML2Utf16String
*
* Description: The function converts an unicoded XML string into an unicoded
* string (UTF-16) where some special XML characters are decoded according to
* the XML spec.
*
* Input: A unicoded XML string which is freed.
*
* Output: A new unicoded pointer containing the decoded output.
*
*********************************************************************************/
u16 *CsrXML2Utf16String(u16 *str)
{
u16 *scanString;
u16 *outputString = NULL;
u16 *resultString = str;
u32 stringLength = 0;
u8 encodeChars = FALSE;
scanString = str;
if (scanString)
{
while (*scanString)
{
if (*scanString == (u16) L'&')
{
scanString++;
if (!CsrUtf16StrNICmp(scanString, (u16 *) L"AMP;", 4))
{
scanString += 3;
encodeChars = TRUE;
}
else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"LT;", 3))
{
scanString += 2;
encodeChars = TRUE;
}
else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"GT;", 3))
{
scanString += 2;
encodeChars = TRUE;
}
if (!CsrUtf16StrNICmp(scanString, (u16 *) L"APOS;", 5))
{
scanString += 4;
encodeChars = TRUE;
}
if (!CsrUtf16StrNICmp(scanString, (u16 *) L"QUOT;", 5))
{
scanString += 4;
encodeChars = TRUE;
}
else
{
scanString--;
}
}
stringLength++;
scanString++;
}
stringLength++;
if (encodeChars)
{
resultString = outputString = kmalloc(stringLength * sizeof(u16), GFP_KERNEL);
scanString = str;
while (*scanString)
{
if (*scanString == L'&')
{
scanString++;
if (!CsrUtf16StrNICmp(scanString, (u16 *) L"AMP;", 4))
{
*outputString++ = L'&';
scanString += 3;
}
else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"LT;", 3))
{
*outputString++ = L'<';
scanString += 2;
}
else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"GT;", 3))
{
*outputString++ = L'>';
scanString += 2;
}
else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"APOS;", 5))
{
*outputString++ = L'\'';
scanString += 4;
}
else if (!CsrUtf16StrNICmp(scanString, (u16 *) L"QUOT;", 5))
{
*outputString++ = L'\"';
scanString += 4;
}
else
{
*outputString++ = L'&';
scanString--;
}
}
else
{
*outputString++ = *scanString;
}
scanString++;
}
*outputString++ = 0;
kfree(str);
}
}
return resultString;
}
u32 CsrUtf8StringLengthInBytes(const u8 *string)
{
size_t length = 0;
if (string)
{
length = strlen((const char *)string);
}
return (u32) length;
}
u8 *CsrUtf8StrTruncate(u8 *target, size_t count)
{
size_t lastByte = count - 1;
target[count] = '\0';
if (count && (target[lastByte] & 0x80))
{
/* the last byte contains non-ascii char */
if (target[lastByte] & 0x40)
{
/* multi-byte char starting just before truncation */
target[lastByte] = '\0';
}
else if ((target[lastByte - 1] & 0xE0) == 0xE0)
{
/* 3-byte char starting 2 bytes before truncation */
target[lastByte - 1] = '\0';
}
else if ((target[lastByte - 2] & 0xF0) == 0xF0)
{
/* 4-byte char starting 3 bytes before truncation */
target[lastByte - 2] = '\0';
}
}
return target;
}
drivers/staging/csr/csr_wifi_msgconv.h
View file @ 9e16d457
......@@ -13,7 +13,6 @@
#include "csr_prim_defs.h"
#include "csr_sched.h"
#include "csr_unicode.h"
#ifdef __cplusplus
extern "C" {
......
drivers/staging/csr/csr_wifi_nme_ap_serialize.c
View file @ 9e16d457
......@@ -12,7 +12,6 @@
#include <linux/string.h>
#include <linux/slab.h>
#include "csr_msgconv.h"
#include "csr_unicode.h"
#ifdef CSR_WIFI_NME_ENABLE
#ifdef CSR_WIFI_AP_ENABLE
......
drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
View file @ 9e16d457
......@@ -12,9 +12,6 @@
#include <linux/string.h>
#include <linux/slab.h>
#include "csr_msgconv.h"
#include "csr_unicode.h"
#include "csr_wifi_router_ctrl_prim.h"
#include "csr_wifi_router_ctrl_serialize.h"
......
drivers/staging/csr/csr_wifi_router_serialize.c
View file @ 9e16d457
......@@ -11,9 +11,6 @@
/* Note: this is an auto-generated file. */
#include <linux/slab.h>
#include "csr_msgconv.h"
#include "csr_unicode.h"
#include "csr_wifi_router_prim.h"
#include "csr_wifi_router_serialize.h"
......
drivers/staging/csr/csr_wifi_sme_serialize.c
View file @ 9e16d457
......@@ -12,9 +12,6 @@
#include <linux/string.h>
#include <linux/slab.h>
#include "csr_msgconv.h"
#include "csr_unicode.h"
#include "csr_wifi_sme_prim.h"
#include "csr_wifi_sme_serialize.h"
......
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