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