drivers/staging/csr/csr_serialize_primitive_types.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2010
   4             All rights reserved and confidential information of CSR
   5
   6             Refer to LICENSE.txt included with this source for details
   7             on the license terms.
   8
   9 *****************************************************************************/
  10
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include "csr_prim_defs.h"
  14 #include "csr_msgconv.h"
  15 #include "csr_macro.h"
  16 #include "csr_lib.h"
  17
  18 /********************************************************************************
  19 *
  20 *   Name:           CsrUtf16StrLen
  21 *
  22 *   Description:    The function returns the number of 16 bit elements present
  23 *                   in the 0-terminated string.
  24 *
  25 *   Input:          0-terminated string of 16 bit unicoded characters.
  26 *
  27 *   Output:         The number of 16 bit elements in the string.
  28 *
  29 *********************************************************************************/
  30 static u32 CsrUtf16StrLen(const u16 *unicodeString)
  31 {
  32     u32 length;
  33
  34     length = 0;
  35     if (unicodeString != NULL)
  36     {
  37         while (*unicodeString)
  38         {
  39             length++;
  40             unicodeString++;
  41         }
  42     }
  43     return length;
  44 }
  45
  46 void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset)
  47 {
  48     *value = buffer[*offset];
  49     *offset += sizeof(*value);
  50 }
  51 EXPORT_SYMBOL_GPL(CsrUint8Des);
  52
  53 void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset)
  54 {
  55     *value = (buffer[*offset + 0] << 0) |
  56              (buffer[*offset + 1] << 8);
  57     *offset += sizeof(*value);
  58 }
  59 EXPORT_SYMBOL_GPL(CsrUint16Des);
  60
  61 void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset)
  62 {
  63     *value = (buffer[*offset + 0] << 0) |
  64              (buffer[*offset + 1] << 8) |
  65              (buffer[*offset + 2] << 16) |
  66              (buffer[*offset + 3] << 24);
  67     *offset += sizeof(*value);
  68 }
  69 EXPORT_SYMBOL_GPL(CsrUint32Des);
  70
  71 void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length)
  72 {
  73     memcpy(value, &buffer[*offset], length);
  74     *offset += length;
  75 }
  76 EXPORT_SYMBOL_GPL(CsrMemCpyDes);
  77
  78 void CsrCharStringDes(char **value, u8 *buffer, size_t *offset)
  79 {
  80     *value = kstrdup((char *) &buffer[*offset], GFP_KERNEL);
  81     *offset += strlen(*value) + 1;
  82 }
  83 EXPORT_SYMBOL_GPL(CsrCharStringDes);
  84
  85 void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset)
  86 {
  87     *value = (u8 *)kstrdup((char *) &buffer[*offset], GFP_KERNEL);
  88     *offset += strlen((char *) *value) + 1;
  89 }
  90
  91 void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset)
  92 {
  93     u32 length, i;
  94
  95     CsrUint32Des(&length, buffer, offset);
  96
  97     *value = kmalloc(length * sizeof(**value), GFP_KERNEL);
  98     for (i = 0; i < length; i++)
  99     {
 100         CsrUint16Des(&(*value)[i], buffer, offset);
 101     }
 102 }
 103
 104 void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset)
 105 {
 106     *value = (buffer[*offset + 0] << 0) |
 107              (buffer[*offset + 1] << 8) |
 108              (buffer[*offset + 2] << 16) |
 109              (buffer[*offset + 3] << 24);
 110     *offset += sizeof(*value);
 111 }
 112
 113 void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset)
 114 {
 115     CsrSizeDes((size_t *) value, buffer, offset);
 116 }
 117
 118 void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value)
 119 {
 120     buffer[*offset] = value;
 121     *offset += sizeof(value);
 122 }
 123 EXPORT_SYMBOL_GPL(CsrUint8Ser);
 124
 125 void CsrUint16Ser(u8 *buffer, size_t *offset, u16 value)
 126 {
 127     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
 128     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
 129     *offset += sizeof(value);
 130 }
 131 EXPORT_SYMBOL_GPL(CsrUint16Ser);
 132
 133 void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value)
 134 {
 135     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
 136     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
 137     buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
 138     buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
 139     *offset += sizeof(value);
 140 }
 141 EXPORT_SYMBOL_GPL(CsrUint32Ser);
 142
 143 void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length)
 144 {
 145     memcpy(&buffer[*offset], value, length);
 146     *offset += length;
 147 }
 148 EXPORT_SYMBOL_GPL(CsrMemCpySer);
 149
 150 void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value)
 151 {
 152     if (value)
 153     {
 154         strcpy(((char *) &buffer[*offset]), value);
 155         *offset += strlen(value) + 1;
 156     }
 157     else
 158     {
 159         CsrUint8Ser(buffer, offset, 0);
 160     }
 161 }
 162 EXPORT_SYMBOL_GPL(CsrCharStringSer);
 163
 164 void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value)
 165 {
 166     CsrCharStringSer(buffer, offset, (char *) value);
 167 }
 168
 169 void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value)
 170 {
 171     if (value)
 172     {
 173         u32 length = CsrUtf16StrLen(value) + 1;
 174         u32 i;
 175
 176         CsrUint32Ser(buffer, offset, length);
 177
 178         for (i = 0; i < length; i++)
 179         {
 180             CsrUint16Ser(buffer, offset, (u16) value[i]);
 181         }
 182     }
 183     else
 184     {
 185         CsrUint32Ser(buffer, offset, 0);
 186     }
 187 }
 188
 189 void CsrSizeSer(u8 *buffer, size_t *offset, size_t value)
 190 {
 191     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
 192     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
 193     buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
 194     buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
 195     *offset += sizeof(value);
 196 }
 197
 198 void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr)
 199 {
 200     CsrSizeSer(buffer, offset, (size_t) ptr);
 201 }
 202
 203 u32 CsrCharStringSerLen(const char *str)
 204 {
 205     if (str)
 206     {
 207         return (u32)(strlen(str) + sizeof(*str));
 208     }
 209     else
 210     {
 211         return sizeof(*str);
 212     }
 213 }
 214
 215 u32 CsrUtf8StringSerLen(const u8 *str)
 216 {
 217     if (str)
 218     {
 219         return (u32)(strlen((char *) str) + sizeof(*str));
 220     }
 221     else
 222     {
 223         return sizeof(*str);
 224     }
 225 }
 226
 227 u32 CsrUtf16StringSerLen(const u16 *str)
 228 {
 229     if (str)
 230     {
 231         /* We always write down the length of the string */
 232         return sizeof(u32) + (CsrUtf16StrLen(str) + 1) * sizeof(*str);
 233     }
 234     else
 235     {
 236         return sizeof(u32);
 237     }
 238 }
 239
 240 size_t CsrEventSizeof(void *msg)
 241 {
 242     return 2;
 243 }
 244
 245 u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg)
 246 {
 247     CsrEvent *primitive = (CsrEvent *) msg;
 248     *len = 0;
 249     CsrUint16Ser(ptr, len, primitive->type);
 250     return ptr;
 251 }
 252
 253 void *CsrEventDes(u8 *buffer, size_t length)
 254 {
 255     CsrEvent *primitive = kmalloc(sizeof(CsrEvent), GFP_KERNEL);
 256     size_t offset = 0;
 257     CsrUint16Des(&primitive->type, buffer, &offset);
 258
 259     return primitive;
 260 }
 261
 262 size_t CsrEventCsrUint8Sizeof(void *msg)
 263 {
 264     return 3;
 265 }
 266
 267 u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg)
 268 {
 269     CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
 270     *len = 0;
 271     CsrUint16Ser(ptr, len, primitive->type);
 272     CsrUint8Ser(ptr, len, primitive->value);
 273     return ptr;
 274 }
 275
 276 void *CsrEventCsrUint8Des(u8 *buffer, size_t length)
 277 {
 278     CsrEventCsrUint8 *primitive = kmalloc(sizeof(CsrEventCsrUint8), GFP_KERNEL);
 279
 280     size_t offset = 0;
 281     CsrUint16Des(&primitive->type, buffer, &offset);
 282     CsrUint8Des(&primitive->value, buffer, &offset);
 283
 284     return primitive;
 285 }
 286
 287 size_t CsrEventCsrUint16Sizeof(void *msg)
 288 {
 289     return 4;
 290 }
 291
 292 u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 293 {
 294     CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
 295     *len = 0;
 296     CsrUint16Ser(ptr, len, primitive->type);
 297     CsrUint16Ser(ptr, len, primitive->value);
 298     return ptr;
 299 }
 300
 301 void *CsrEventCsrUint16Des(u8 *buffer, size_t length)
 302 {
 303     CsrEventCsrUint16 *primitive = kmalloc(sizeof(CsrEventCsrUint16), GFP_KERNEL);
 304
 305     size_t offset = 0;
 306     CsrUint16Des(&primitive->type, buffer, &offset);
 307     CsrUint16Des(&primitive->value, buffer, &offset);
 308
 309     return primitive;
 310 }
 311
 312 size_t CsrEventCsrUint32Sizeof(void *msg)
 313 {
 314     return 6;
 315 }
 316
 317 u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg)
 318 {
 319     CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
 320     *len = 0;
 321     CsrUint16Ser(ptr, len, primitive->type);
 322     CsrUint32Ser(ptr, len, primitive->value);
 323     return ptr;
 324 }
 325
 326 void *CsrEventCsrUint32Des(u8 *buffer, size_t length)
 327 {
 328     CsrEventCsrUint32 *primitive = kmalloc(sizeof(CsrEventCsrUint32), GFP_KERNEL);
 329
 330     size_t offset = 0;
 331     CsrUint16Des(&primitive->type, buffer, &offset);
 332     CsrUint32Des(&primitive->value, buffer, &offset);
 333
 334     return primitive;
 335 }
 336
 337 size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg)
 338 {
 339     return 5;
 340 }
 341
 342 u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg)
 343 {
 344     CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
 345     *len = 0;
 346     CsrUint16Ser(ptr, len, primitive->type);
 347     CsrUint16Ser(ptr, len, primitive->value1);
 348     CsrUint8Ser(ptr, len, primitive->value2);
 349     return ptr;
 350 }
 351
 352 void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length)
 353 {
 354     CsrEventCsrUint16CsrUint8 *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrUint8), GFP_KERNEL);
 355
 356     size_t offset = 0;
 357     CsrUint16Des(&primitive->type, buffer, &offset);
 358     CsrUint16Des(&primitive->value1, buffer, &offset);
 359     CsrUint8Des(&primitive->value2, buffer, &offset);
 360
 361     return primitive;
 362 }
 363
 364 size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg)
 365 {
 366     return 6;
 367 }
 368
 369 u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 370 {
 371     CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
 372     *len = 0;
 373     CsrUint16Ser(ptr, len, primitive->type);
 374     CsrUint16Ser(ptr, len, primitive->value1);
 375     CsrUint16Ser(ptr, len, primitive->value2);
 376     return ptr;
 377 }
 378
 379 void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length)
 380 {
 381     CsrEventCsrUint16CsrUint16 *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrUint16), GFP_KERNEL);
 382
 383     size_t offset = 0;
 384     CsrUint16Des(&primitive->type, buffer, &offset);
 385     CsrUint16Des(&primitive->value1, buffer, &offset);
 386     CsrUint16Des(&primitive->value2, buffer, &offset);
 387
 388     return primitive;
 389 }
 390
 391 size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg)
 392 {
 393     return 8;
 394 }
 395
 396 u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg)
 397 {
 398     CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
 399     *len = 0;
 400     CsrUint16Ser(ptr, len, primitive->type);
 401     CsrUint16Ser(ptr, len, primitive->value1);
 402     CsrUint32Ser(ptr, len, primitive->value2);
 403     return ptr;
 404 }
 405
 406 void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length)
 407 {
 408     CsrEventCsrUint16CsrUint32 *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrUint32), GFP_KERNEL);
 409
 410     size_t offset = 0;
 411     CsrUint16Des(&primitive->type, buffer, &offset);
 412     CsrUint16Des(&primitive->value1, buffer, &offset);
 413     CsrUint32Des(&primitive->value2, buffer, &offset);
 414
 415     return primitive;
 416 }
 417
 418 size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg)
 419 {
 420     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
 421     return 4 + strlen(primitive->value2) + 1;
 422 }
 423
 424 u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
 425 {
 426     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
 427     *len = 0;
 428     CsrUint16Ser(ptr, len, primitive->type);
 429     CsrUint16Ser(ptr, len, primitive->value1);
 430     CsrCharStringSer(ptr, len, primitive->value2);
 431     return ptr;
 432 }
 433
 434 void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length)
 435 {
 436     CsrEventCsrUint16CsrCharString *primitive = kmalloc(sizeof(CsrEventCsrUint16CsrCharString), GFP_KERNEL);
 437
 438     size_t offset = 0;
 439     CsrUint16Des(&primitive->type, buffer, &offset);
 440     CsrUint16Des(&primitive->value1, buffer, &offset);
 441     CsrCharStringDes(&primitive->value2, buffer, &offset);
 442
 443     return primitive;
 444 }
 445
 446 size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg)
 447 {
 448     return 8;
 449 }
 450
 451 u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 452 {
 453     CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
 454     *len = 0;
 455     CsrUint16Ser(ptr, len, primitive->type);
 456     CsrUint32Ser(ptr, len, primitive->value1);
 457     CsrUint16Ser(ptr, len, primitive->value2);
 458     return ptr;
 459 }
 460
 461 void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length)
 462 {
 463     CsrEventCsrUint32CsrUint16 *primitive = kmalloc(sizeof(CsrEventCsrUint32CsrUint16), GFP_KERNEL);
 464
 465     size_t offset = 0;
 466     CsrUint16Des(&primitive->type, buffer, &offset);
 467     CsrUint32Des(&primitive->value1, buffer, &offset);
 468     CsrUint16Des(&primitive->value2, buffer, &offset);
 469
 470     return primitive;
 471 }
 472
 473 size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg)
 474 {
 475     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
 476     return 6 + strlen(primitive->value2) + 1;
 477 }
 478
 479 u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
 480 {
 481     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
 482     *len = 0;
 483     CsrUint16Ser(ptr, len, primitive->type);
 484     CsrUint32Ser(ptr, len, primitive->value1);
 485     CsrCharStringSer(ptr, len, primitive->value2);
 486     return ptr;
 487 }
 488
 489 void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length)
 490 {
 491     CsrEventCsrUint32CsrCharString *primitive = kmalloc(sizeof(CsrEventCsrUint32CsrCharString), GFP_KERNEL);
 492
 493     size_t offset = 0;
 494     CsrUint16Des(&primitive->type, buffer, &offset);
 495     CsrUint32Des(&primitive->value1, buffer, &offset);
 496     CsrCharStringDes(&primitive->value2, buffer, &offset);
 497
 498     return primitive;
 499 }