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