Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7f5393ea authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

staging: csr: remove CsrUtf8String typedef 



Use the in-kernel u8 type 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: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent f58bfd88

drivers/staging/csr/csr_msgconv.h

+3 −3
Original line number Diff line number Diff line
@@ -74,7 +74,7 @@ void CsrMsgConvDeinit(void); 
/* SHOULD BE INTERNAL TO FRAMEWORK AKA DEPRECATED */



u32 CsrCharStringSerLen(const CsrCharString *str);

u32 CsrUtf8StringSerLen(const CsrUtf8String *str);

u32 CsrUtf8StringSerLen(const u8 *str);

u32 CsrUtf16StringSerLen(const u16 *str);



/* Prototypes for primitive type serializers */
@@ -83,7 +83,7 @@ void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value); 
void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value);

void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);

void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);

void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *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);
@@ -93,7 +93,7 @@ void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset); 
void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset);

void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);

void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);

void CsrUtf8StringDes(CsrUtf8String **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);

drivers/staging/csr/csr_serialize_primitive_types.c

+4 −4
Original line number Diff line number Diff line
@@ -55,9 +55,9 @@ void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset) 
}

EXPORT_SYMBOL_GPL(CsrCharStringDes);



void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset)

void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset)

{

    *value = (CsrUtf8String *) CsrStrDup((CsrCharString *) &buffer[*offset]);

    *value = (u8 *) CsrStrDup((CsrCharString *) &buffer[*offset]);

    *offset += CsrStrLen((CsrCharString *) *value) + 1;

}
@@ -134,7 +134,7 @@ void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value) 
}

EXPORT_SYMBOL_GPL(CsrCharStringSer);



void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value)

void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value)

{

    CsrCharStringSer(buffer, offset, (CsrCharString *) value);

}
@@ -185,7 +185,7 @@ u32 CsrCharStringSerLen(const CsrCharString *str) 
    }

}



u32 CsrUtf8StringSerLen(const CsrUtf8String *str)

u32 CsrUtf8StringSerLen(const u8 *str)

{

    if (str)

    {

drivers/staging/csr/csr_types.h

+0 −1
Original line number Diff line number Diff line
@@ -37,7 +37,6 @@ typedef u8 CsrBool; 


/* String types */

typedef char CsrCharString;

typedef u8 CsrUtf8String;



/*

 * 64-bit integers

drivers/staging/csr/csr_unicode.h

+11 −11
Original line number Diff line number Diff line
@@ -21,9 +21,9 @@ u16 *CsrUint32ToUtf16String(u32 number); 
u32 CsrUtf16StringToUint32(const u16 *unicodeString);

u32 CsrUtf16StrLen(const u16 *unicodeString);



CsrUtf8String *CsrUtf16String2Utf8(const u16 *source);

u8 *CsrUtf16String2Utf8(const u16 *source);



u16 *CsrUtf82Utf16String(const CsrUtf8String *utf8String);

u16 *CsrUtf82Utf16String(const u8 *utf8String);



u16 *CsrUtf16StrCpy(u16 *target, const u16 *source);

u16 *CsrUtf16StringDuplicate(const u16 *source);
@@ -38,9 +38,9 @@ u16 *CsrUtf16ConcatenateTexts(const u16 *inputText1, const u16 *inputText2, 
u16 *CsrUtf16String2XML(u16 *str);

u16 *CsrXML2Utf16String(u16 *str);



s32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2);

s32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count);

u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string);

s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2);

s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count);

u32 CsrUtf8StringLengthInBytes(const u8 *string);



/*******************************************************************************
@@ -66,7 +66,7 @@ u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string); 
        Returns target



*******************************************************************************/

CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count);

u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count);



/*******************************************************************************
@@ -90,7 +90,7 @@ CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count); 
        Returns target



*******************************************************************************/

CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source);

u8 *CsrUtf8StrCpy(u8 *target, const u8 *source);



/*******************************************************************************
@@ -116,7 +116,7 @@ CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source) 
        Returns target



*******************************************************************************/

CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count);

u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count);



/*******************************************************************************
@@ -143,7 +143,7 @@ CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source 
        Returns target



*******************************************************************************/

CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count);

u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count);



/*******************************************************************************
@@ -163,9 +163,9 @@ CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *so 
        Returns a duplicate of source.



*******************************************************************************/

CsrUtf8String *CsrUtf8StrDup(const CsrUtf8String *source);

u8 *CsrUtf8StrDup(const u8 *source);



CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4);

u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4);



/*

 * UCS2

drivers/staging/csr/csr_utf16.c

+19 −19
Original line number Diff line number Diff line
@@ -253,9 +253,9 @@ u32 CsrUtf16StrLen(const u16 *unicodeString) 
*   Output:         0-terminated string of byte oriented UTF8 coded characters.

*

*********************************************************************************/

CsrUtf8String *CsrUtf16String2Utf8(const u16 *source)

u8 *CsrUtf16String2Utf8(const u16 *source)

{

    CsrUtf8String *dest, *destStart = NULL;

    u8 *dest, *destStart = NULL;

    u32 i;

    u32 ch;

    u32 length;
@@ -463,9 +463,9 @@ CsrUtf8String *CsrUtf16String2Utf8(const u16 *source) 
        TRUE if the given code unit is legal.



*****************************************************************************/

static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, u32 length)

static CsrBool isLegalUtf8(const u8 *codeUnit, u32 length)

{

    const CsrUtf8String *srcPtr = codeUnit + length;

    const u8 *srcPtr = codeUnit + length;

    u8 byte;



    switch (length) /* Everything falls through except case 1 */
@@ -562,7 +562,7 @@ static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, u32 length) 
*   Output:         0-terminated string of UTF-16 characters.

*

*********************************************************************************/

u16 *CsrUtf82Utf16String(const CsrUtf8String *utf8String)

u16 *CsrUtf82Utf16String(const u8 *utf8String)

{

    CsrSize i, length = 0;

    CsrSize sourceLength;
@@ -1016,17 +1016,17 @@ u16 *CsrXML2Utf16String(u16 *str) 
    return resultString;

}



s32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2)

s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2)

{

    return CsrStrCmp((const CsrCharString *) string1, (const CsrCharString *) string2);

}



s32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count)

s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count)

{

    return CsrStrNCmp((const CsrCharString *) string1, (const CsrCharString *) string2, count);

}



u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string)

u32 CsrUtf8StringLengthInBytes(const u8 *string)

{

    CsrSize length = 0;

    if (string)
@@ -1036,12 +1036,12 @@ u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string) 
    return (u32) length;

}



CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source)

u8 *CsrUtf8StrCpy(u8 *target, const u8 *source)

{

    return (CsrUtf8String *) CsrStrCpy((CsrCharString *) target, (const CsrCharString *) source);

    return (u8 *) CsrStrCpy((CsrCharString *) target, (const CsrCharString *) source);

}



CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count)

u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)

{

    CsrSize lastByte = count - 1;
@@ -1070,12 +1070,12 @@ CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count) 
    return target;

}



CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count)

u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count)

{

    return (CsrUtf8String *) CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);

    return (u8 *) CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);

}



CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count)

u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count)

{

    CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);

    if (target[count - 1] != '\0')
@@ -1085,14 +1085,14 @@ CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *so 
    return target;

}



CsrUtf8String *CsrUtf8StrDup(const CsrUtf8String *source)

u8 *CsrUtf8StrDup(const u8 *source)

{

    return (CsrUtf8String *) CsrStrDup((const CsrCharString *) source);

    return (u8 *) CsrStrDup((const CsrCharString *) source);

}



CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4)

u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4)

{

    CsrUtf8String *outputText;

    u8 *outputText;

    u32 textLen, textLen1, textLen2, textLen3, textLen4;



    textLen1 = CsrUtf8StringLengthInBytes(inputText1);
@@ -1107,7 +1107,7 @@ CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, co 
        return NULL;

    }



    outputText = (CsrUtf8String *) CsrPmemAlloc((textLen + 1) * sizeof(CsrUtf8String)); /* add space for 0-termination*/

    outputText = (u8 *) CsrPmemAlloc((textLen + 1) * sizeof(u8)); /* add space for 0-termination*/





    if (inputText1 != NULL)