drivers/staging/csr/csr_wifi_router_serialize.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2011
   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 /* Note: this is an auto-generated file. */
  12 #include <linux/slab.h>
  13 #include "csr_msgconv.h"
  14 #include "csr_unicode.h"
  15
  16
  17 #include "csr_wifi_router_prim.h"
  18 #include "csr_wifi_router_serialize.h"
  19
  20 void CsrWifiRouterPfree(void *ptr)
  21 {
  22     kfree(ptr);
  23 }
  24
  25
  26 size_t CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
  27 {
  28     size_t bufferSize = 2;
  29
  30     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
  31     bufferSize += 2; /* u16 primitive->interfaceTag */
  32     bufferSize += 1; /* CsrWifiRouterEncapsulation primitive->encapsulation */
  33     bufferSize += 2; /* u16 primitive->protocol */
  34     bufferSize += 4; /* u32 primitive->oui */
  35     return bufferSize;
  36 }
  37
  38
  39 u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, size_t *len, void *msg)
  40 {
  41     CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
  42     *len = 0;
  43     CsrUint16Ser(ptr, len, primitive->common.type);
  44     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
  45     CsrUint8Ser(ptr, len, (u8) primitive->encapsulation);
  46     CsrUint16Ser(ptr, len, (u16) primitive->protocol);
  47     CsrUint32Ser(ptr, len, (u32) primitive->oui);
  48     return(ptr);
  49 }
  50
  51
  52 void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, size_t length)
  53 {
  54     CsrWifiRouterMaPacketSubscribeReq *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketSubscribeReq), GFP_KERNEL);
  55     size_t offset;
  56     offset = 0;
  57
  58     CsrUint16Des(&primitive->common.type, buffer, &offset);
  59     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
  60     CsrUint8Des((u8 *) &primitive->encapsulation, buffer, &offset);
  61     CsrUint16Des((u16 *) &primitive->protocol, buffer, &offset);
  62     CsrUint32Des((u32 *) &primitive->oui, buffer, &offset);
  63
  64     return primitive;
  65 }
  66
  67
  68 size_t CsrWifiRouterMaPacketReqSizeof(void *msg)
  69 {
  70     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) msg;
  71     size_t bufferSize = 2;
  72
  73     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
  74     bufferSize += 2;                      /* u16 primitive->interfaceTag */
  75     bufferSize += 1;                      /* u8 primitive->subscriptionHandle */
  76     bufferSize += 2;                      /* u16 primitive->frameLength */
  77     bufferSize += primitive->frameLength; /* u8 primitive->frame */
  78     bufferSize += 4;                      /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
  79     bufferSize += 2;                      /* CsrWifiRouterPriority primitive->priority */
  80     bufferSize += 4;                      /* u32 primitive->hostTag */
  81     bufferSize += 1;                      /* u8 primitive->cfmRequested */
  82     return bufferSize;
  83 }
  84
  85
  86 u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, size_t *len, void *msg)
  87 {
  88     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
  89     *len = 0;
  90     CsrUint16Ser(ptr, len, primitive->common.type);
  91     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
  92     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
  93     CsrUint16Ser(ptr, len, (u16) primitive->frameLength);
  94     if (primitive->frameLength)
  95     {
  96         CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((u16) (primitive->frameLength)));
  97     }
  98     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
  99     CsrUint16Ser(ptr, len, (u16) primitive->priority);
 100     CsrUint32Ser(ptr, len, (u32) primitive->hostTag);
 101     CsrUint8Ser(ptr, len, (u8) primitive->cfmRequested);
 102     return(ptr);
 103 }
 104
 105
 106 void* CsrWifiRouterMaPacketReqDes(u8 *buffer, size_t length)
 107 {
 108     CsrWifiRouterMaPacketReq *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketReq), GFP_KERNEL);
 109     size_t offset;
 110     offset = 0;
 111
 112     CsrUint16Des(&primitive->common.type, buffer, &offset);
 113     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 114     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
 115     CsrUint16Des((u16 *) &primitive->frameLength, buffer, &offset);
 116     if (primitive->frameLength)
 117     {
 118         primitive->frame = kmalloc(primitive->frameLength, GFP_KERNEL);
 119         CsrMemCpyDes(primitive->frame, buffer, &offset, ((u16) (primitive->frameLength)));
 120     }
 121     else
 122     {
 123         primitive->frame = NULL;
 124     }
 125     primitive->freeFunction = NULL; /* Special for Function Pointers... */
 126     offset += 4;
 127     CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
 128     CsrUint32Des((u32 *) &primitive->hostTag, buffer, &offset);
 129     CsrUint8Des((u8 *) &primitive->cfmRequested, buffer, &offset);
 130
 131     return primitive;
 132 }
 133
 134
 135 void CsrWifiRouterMaPacketReqSerFree(void *voidPrimitivePointer)
 136 {
 137     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) voidPrimitivePointer;
 138     kfree(primitive->frame);
 139     kfree(primitive);
 140 }
 141
 142
 143 size_t CsrWifiRouterMaPacketResSizeof(void *msg)
 144 {
 145     size_t bufferSize = 2;
 146
 147     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
 148     bufferSize += 2; /* u16 primitive->interfaceTag */
 149     bufferSize += 1; /* u8 primitive->subscriptionHandle */
 150     bufferSize += 2; /* CsrResult primitive->result */
 151     return bufferSize;
 152 }
 153
 154
 155 u8* CsrWifiRouterMaPacketResSer(u8 *ptr, size_t *len, void *msg)
 156 {
 157     CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
 158     *len = 0;
 159     CsrUint16Ser(ptr, len, primitive->common.type);
 160     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 161     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
 162     CsrUint16Ser(ptr, len, (u16) primitive->result);
 163     return(ptr);
 164 }
 165
 166
 167 void* CsrWifiRouterMaPacketResDes(u8 *buffer, size_t length)
 168 {
 169     CsrWifiRouterMaPacketRes *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketRes), GFP_KERNEL);
 170     size_t offset;
 171     offset = 0;
 172
 173     CsrUint16Des(&primitive->common.type, buffer, &offset);
 174     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 175     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
 176     CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
 177
 178     return primitive;
 179 }
 180
 181
 182 size_t CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
 183 {
 184     size_t bufferSize = 2;
 185
 186     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
 187     bufferSize += 2; /* u16 primitive->interfaceTag */
 188     bufferSize += 4; /* u32 primitive->hostTag */
 189     bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
 190     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
 191     return bufferSize;
 192 }
 193
 194
 195 u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, size_t *len, void *msg)
 196 {
 197     CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
 198     *len = 0;
 199     CsrUint16Ser(ptr, len, primitive->common.type);
 200     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 201     CsrUint32Ser(ptr, len, (u32) primitive->hostTag);
 202     CsrUint16Ser(ptr, len, (u16) primitive->priority);
 203     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
 204     return(ptr);
 205 }
 206
 207
 208 void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, size_t length)
 209 {
 210     CsrWifiRouterMaPacketCancelReq *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketCancelReq), GFP_KERNEL);
 211     size_t offset;
 212     offset = 0;
 213
 214     CsrUint16Des(&primitive->common.type, buffer, &offset);
 215     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 216     CsrUint32Des((u32 *) &primitive->hostTag, buffer, &offset);
 217     CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
 218     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 219
 220     return primitive;
 221 }
 222
 223
 224 size_t CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
 225 {
 226     size_t bufferSize = 2;
 227
 228     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
 229     bufferSize += 2; /* u16 primitive->interfaceTag */
 230     bufferSize += 1; /* u8 primitive->subscriptionHandle */
 231     bufferSize += 2; /* CsrResult primitive->status */
 232     bufferSize += 2; /* u16 primitive->allocOffset */
 233     return bufferSize;
 234 }
 235
 236
 237 u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, size_t *len, void *msg)
 238 {
 239     CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
 240     *len = 0;
 241     CsrUint16Ser(ptr, len, primitive->common.type);
 242     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 243     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
 244     CsrUint16Ser(ptr, len, (u16) primitive->status);
 245     CsrUint16Ser(ptr, len, (u16) primitive->allocOffset);
 246     return(ptr);
 247 }
 248
 249
 250 void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, size_t length)
 251 {
 252     CsrWifiRouterMaPacketSubscribeCfm *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm), GFP_KERNEL);
 253     size_t offset;
 254     offset = 0;
 255
 256     CsrUint16Des(&primitive->common.type, buffer, &offset);
 257     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 258     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
 259     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 260     CsrUint16Des((u16 *) &primitive->allocOffset, buffer, &offset);
 261
 262     return primitive;
 263 }
 264
 265
 266 size_t CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
 267 {
 268     size_t bufferSize = 2;
 269
 270     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
 271     bufferSize += 2; /* u16 primitive->interfaceTag */
 272     bufferSize += 2; /* CsrResult primitive->status */
 273     return bufferSize;
 274 }
 275
 276
 277 u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, size_t *len, void *msg)
 278 {
 279     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
 280     *len = 0;
 281     CsrUint16Ser(ptr, len, primitive->common.type);
 282     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 283     CsrUint16Ser(ptr, len, (u16) primitive->status);
 284     return(ptr);
 285 }
 286
 287
 288 void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, size_t length)
 289 {
 290     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm), GFP_KERNEL);
 291     size_t offset;
 292     offset = 0;
 293
 294     CsrUint16Des(&primitive->common.type, buffer, &offset);
 295     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 296     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 297
 298     return primitive;
 299 }
 300
 301
 302 size_t CsrWifiRouterMaPacketCfmSizeof(void *msg)
 303 {
 304     size_t bufferSize = 2;
 305
 306     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
 307     bufferSize += 2; /* u16 primitive->interfaceTag */
 308     bufferSize += 2; /* CsrResult primitive->result */
 309     bufferSize += 4; /* u32 primitive->hostTag */
 310     bufferSize += 2; /* u16 primitive->rate */
 311     return bufferSize;
 312 }
 313
 314
 315 u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, size_t *len, void *msg)
 316 {
 317     CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
 318     *len = 0;
 319     CsrUint16Ser(ptr, len, primitive->common.type);
 320     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 321     CsrUint16Ser(ptr, len, (u16) primitive->result);
 322     CsrUint32Ser(ptr, len, (u32) primitive->hostTag);
 323     CsrUint16Ser(ptr, len, (u16) primitive->rate);
 324     return(ptr);
 325 }
 326
 327
 328 void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, size_t length)
 329 {
 330     CsrWifiRouterMaPacketCfm *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketCfm), GFP_KERNEL);
 331     size_t offset;
 332     offset = 0;
 333
 334     CsrUint16Des(&primitive->common.type, buffer, &offset);
 335     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 336     CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
 337     CsrUint32Des((u32 *) &primitive->hostTag, buffer, &offset);
 338     CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
 339
 340     return primitive;
 341 }
 342
 343
 344 size_t CsrWifiRouterMaPacketIndSizeof(void *msg)
 345 {
 346     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) msg;
 347     size_t bufferSize = 2;
 348
 349     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
 350     bufferSize += 2;                      /* u16 primitive->interfaceTag */
 351     bufferSize += 1;                      /* u8 primitive->subscriptionHandle */
 352     bufferSize += 2;                      /* CsrResult primitive->result */
 353     bufferSize += 2;                      /* u16 primitive->frameLength */
 354     bufferSize += primitive->frameLength; /* u8 primitive->frame */
 355     bufferSize += 4;                      /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
 356     bufferSize += 2;                      /* s16 primitive->rssi */
 357     bufferSize += 2;                      /* s16 primitive->snr */
 358     bufferSize += 2;                      /* u16 primitive->rate */
 359     return bufferSize;
 360 }
 361
 362
 363 u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, size_t *len, void *msg)
 364 {
 365     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
 366     *len = 0;
 367     CsrUint16Ser(ptr, len, primitive->common.type);
 368     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 369     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
 370     CsrUint16Ser(ptr, len, (u16) primitive->result);
 371     CsrUint16Ser(ptr, len, (u16) primitive->frameLength);
 372     if (primitive->frameLength)
 373     {
 374         CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((u16) (primitive->frameLength)));
 375     }
 376     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
 377     CsrUint16Ser(ptr, len, (u16) primitive->rssi);
 378     CsrUint16Ser(ptr, len, (u16) primitive->snr);
 379     CsrUint16Ser(ptr, len, (u16) primitive->rate);
 380     return(ptr);
 381 }
 382
 383
 384 void* CsrWifiRouterMaPacketIndDes(u8 *buffer, size_t length)
 385 {
 386     CsrWifiRouterMaPacketInd *primitive = kmalloc(sizeof(CsrWifiRouterMaPacketInd), GFP_KERNEL);
 387     size_t offset;
 388     offset = 0;
 389
 390     CsrUint16Des(&primitive->common.type, buffer, &offset);
 391     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 392     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
 393     CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
 394     CsrUint16Des((u16 *) &primitive->frameLength, buffer, &offset);
 395     if (primitive->frameLength)
 396     {
 397         primitive->frame = kmalloc(primitive->frameLength, GFP_KERNEL);
 398         CsrMemCpyDes(primitive->frame, buffer, &offset, ((u16) (primitive->frameLength)));
 399     }
 400     else
 401     {
 402         primitive->frame = NULL;
 403     }
 404     primitive->freeFunction = NULL; /* Special for Function Pointers... */
 405     offset += 4;
 406     CsrUint16Des((u16 *) &primitive->rssi, buffer, &offset);
 407     CsrUint16Des((u16 *) &primitive->snr, buffer, &offset);
 408     CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
 409
 410     return primitive;
 411 }
 412
 413
 414 void CsrWifiRouterMaPacketIndSerFree(void *voidPrimitivePointer)
 415 {
 416     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) voidPrimitivePointer;
 417     kfree(primitive->frame);
 418     kfree(primitive);
 419 }
 420
 421