drivers/staging/csr/csr_wifi_router_ctrl_serialize.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2012
   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/string.h>
  13 #include <linux/slab.h>
  14 #include "csr_pmem.h"
  15 #include "csr_msgconv.h"
  16 #include "csr_unicode.h"
  17
  18
  19 #include "csr_wifi_router_ctrl_prim.h"
  20 #include "csr_wifi_router_ctrl_serialize.h"
  21
  22 void CsrWifiRouterCtrlPfree(void *ptr)
  23 {
  24     kfree(ptr);
  25 }
  26
  27
  28 size_t CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
  29 {
  30     size_t bufferSize = 2;
  31
  32     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
  33     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
  34     bufferSize += 2; /* CsrWifiRouterCtrlLowPowerMode primitive->mode */
  35     bufferSize += 1; /* u8 primitive->wakeHost */
  36     return bufferSize;
  37 }
  38
  39
  40 u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, size_t *len, void *msg)
  41 {
  42     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
  43     *len = 0;
  44     CsrUint16Ser(ptr, len, primitive->common.type);
  45     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
  46     CsrUint16Ser(ptr, len, (u16) primitive->mode);
  47     CsrUint8Ser(ptr, len, (u8) primitive->wakeHost);
  48     return(ptr);
  49 }
  50
  51
  52 void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, size_t length)
  53 {
  54     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq), GFP_KERNEL);
  55     size_t offset;
  56     offset = 0;
  57
  58     CsrUint16Des(&primitive->common.type, buffer, &offset);
  59     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
  60     CsrUint16Des((u16 *) &primitive->mode, buffer, &offset);
  61     CsrUint8Des((u8 *) &primitive->wakeHost, buffer, &offset);
  62
  63     return primitive;
  64 }
  65
  66
  67 size_t CsrWifiRouterCtrlHipReqSizeof(void *msg)
  68 {
  69     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) msg;
  70     size_t bufferSize = 2;
  71
  72     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
  73     bufferSize += 2;                            /* u16 primitive->mlmeCommandLength */
  74     bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
  75     bufferSize += 2;                            /* u16 primitive->dataRef1Length */
  76     bufferSize += primitive->dataRef1Length;    /* u8 primitive->dataRef1 */
  77     bufferSize += 2;                            /* u16 primitive->dataRef2Length */
  78     bufferSize += primitive->dataRef2Length;    /* u8 primitive->dataRef2 */
  79     return bufferSize;
  80 }
  81
  82
  83 u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, size_t *len, void *msg)
  84 {
  85     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
  86     *len = 0;
  87     CsrUint16Ser(ptr, len, primitive->common.type);
  88     CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
  89     if (primitive->mlmeCommandLength)
  90     {
  91         CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
  92     }
  93     CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
  94     if (primitive->dataRef1Length)
  95     {
  96         CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
  97     }
  98     CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
  99     if (primitive->dataRef2Length)
 100     {
 101         CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
 102     }
 103     return(ptr);
 104 }
 105
 106
 107 void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, size_t length)
 108 {
 109     CsrWifiRouterCtrlHipReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlHipReq), GFP_KERNEL);
 110     size_t offset;
 111     offset = 0;
 112
 113     CsrUint16Des(&primitive->common.type, buffer, &offset);
 114     CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
 115     if (primitive->mlmeCommandLength)
 116     {
 117         primitive->mlmeCommand = kmalloc(primitive->mlmeCommandLength, GFP_KERNEL);
 118         CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
 119     }
 120     else
 121     {
 122         primitive->mlmeCommand = NULL;
 123     }
 124     CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
 125     if (primitive->dataRef1Length)
 126     {
 127         primitive->dataRef1 = kmalloc(primitive->dataRef1Length, GFP_KERNEL);
 128         CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
 129     }
 130     else
 131     {
 132         primitive->dataRef1 = NULL;
 133     }
 134     CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
 135     if (primitive->dataRef2Length)
 136     {
 137         primitive->dataRef2 = kmalloc(primitive->dataRef2Length, GFP_KERNEL);
 138         CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
 139     }
 140     else
 141     {
 142         primitive->dataRef2 = NULL;
 143     }
 144
 145     return primitive;
 146 }
 147
 148
 149 void CsrWifiRouterCtrlHipReqSerFree(void *voidPrimitivePointer)
 150 {
 151     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) voidPrimitivePointer;
 152     kfree(primitive->mlmeCommand);
 153     kfree(primitive->dataRef1);
 154     kfree(primitive->dataRef2);
 155     kfree(primitive);
 156 }
 157
 158
 159 size_t CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
 160 {
 161     size_t bufferSize = 2;
 162
 163     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
 164     bufferSize += 2; /* u16 primitive->interfaceTag */
 165     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 166     bufferSize += 1; /* CsrWifiRouterCtrlMediaStatus primitive->mediaStatus */
 167     return bufferSize;
 168 }
 169
 170
 171 u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, size_t *len, void *msg)
 172 {
 173     CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
 174     *len = 0;
 175     CsrUint16Ser(ptr, len, primitive->common.type);
 176     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 177     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 178     CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
 179     return(ptr);
 180 }
 181
 182
 183 void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, size_t length)
 184 {
 185     CsrWifiRouterCtrlMediaStatusReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMediaStatusReq), GFP_KERNEL);
 186     size_t offset;
 187     offset = 0;
 188
 189     CsrUint16Des(&primitive->common.type, buffer, &offset);
 190     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 191     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 192     CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
 193
 194     return primitive;
 195 }
 196
 197
 198 size_t CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
 199 {
 200     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) msg;
 201     size_t bufferSize = 2;
 202
 203     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
 204     bufferSize += 2; /* u16 primitive->interfaceTag */
 205     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 206     bufferSize += 2; /* CsrResult primitive->status */
 207     bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
 208     bufferSize += 1; /* u8 primitive->getAddressesCount */
 209     {
 210         u16 i1;
 211         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
 212         {
 213             bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
 214         }
 215     }
 216     return bufferSize;
 217 }
 218
 219
 220 u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, size_t *len, void *msg)
 221 {
 222     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
 223     *len = 0;
 224     CsrUint16Ser(ptr, len, primitive->common.type);
 225     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 226     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 227     CsrUint16Ser(ptr, len, (u16) primitive->status);
 228     CsrUint8Ser(ptr, len, (u8) primitive->action);
 229     CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
 230     {
 231         u16 i1;
 232         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
 233         {
 234             CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
 235         }
 236     }
 237     return(ptr);
 238 }
 239
 240
 241 void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, size_t length)
 242 {
 243     CsrWifiRouterCtrlMulticastAddressRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes), GFP_KERNEL);
 244     size_t offset;
 245     offset = 0;
 246
 247     CsrUint16Des(&primitive->common.type, buffer, &offset);
 248     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 249     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 250     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 251     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
 252     CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
 253     primitive->getAddresses = NULL;
 254     if (primitive->getAddressesCount)
 255     {
 256         primitive->getAddresses = kmalloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount, GFP_KERNEL);
 257     }
 258     {
 259         u16 i1;
 260         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
 261         {
 262             CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
 263         }
 264     }
 265
 266     return primitive;
 267 }
 268
 269
 270 void CsrWifiRouterCtrlMulticastAddressResSerFree(void *voidPrimitivePointer)
 271 {
 272     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) voidPrimitivePointer;
 273     kfree(primitive->getAddresses);
 274     kfree(primitive);
 275 }
 276
 277
 278 size_t CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
 279 {
 280     size_t bufferSize = 2;
 281
 282     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
 283     bufferSize += 2; /* u16 primitive->interfaceTag */
 284     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 285     bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
 286     bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
 287     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
 288     bufferSize += 1; /* u8 primitive->setProtection */
 289     return bufferSize;
 290 }
 291
 292
 293 u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, size_t *len, void *msg)
 294 {
 295     CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
 296     *len = 0;
 297     CsrUint16Ser(ptr, len, primitive->common.type);
 298     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 299     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 300     CsrUint16Ser(ptr, len, (u16) primitive->uncontrolledPortAction);
 301     CsrUint16Ser(ptr, len, (u16) primitive->controlledPortAction);
 302     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
 303     CsrUint8Ser(ptr, len, (u8) primitive->setProtection);
 304     return(ptr);
 305 }
 306
 307
 308 void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, size_t length)
 309 {
 310     CsrWifiRouterCtrlPortConfigureReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPortConfigureReq), GFP_KERNEL);
 311     size_t offset;
 312     offset = 0;
 313
 314     CsrUint16Des(&primitive->common.type, buffer, &offset);
 315     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 316     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 317     CsrUint16Des((u16 *) &primitive->uncontrolledPortAction, buffer, &offset);
 318     CsrUint16Des((u16 *) &primitive->controlledPortAction, buffer, &offset);
 319     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
 320     CsrUint8Des((u8 *) &primitive->setProtection, buffer, &offset);
 321
 322     return primitive;
 323 }
 324
 325
 326 size_t CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
 327 {
 328     size_t bufferSize = 2;
 329
 330     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
 331     bufferSize += 2; /* u16 primitive->interfaceTag */
 332     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 333     bufferSize += 2; /* CsrWifiRouterCtrlQoSControl primitive->control */
 334     bufferSize += 1; /* CsrWifiRouterCtrlQueueConfigMask primitive->queueConfig */
 335     return bufferSize;
 336 }
 337
 338
 339 u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, size_t *len, void *msg)
 340 {
 341     CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
 342     *len = 0;
 343     CsrUint16Ser(ptr, len, primitive->common.type);
 344     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 345     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 346     CsrUint16Ser(ptr, len, (u16) primitive->control);
 347     CsrUint8Ser(ptr, len, (u8) primitive->queueConfig);
 348     return(ptr);
 349 }
 350
 351
 352 void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, size_t length)
 353 {
 354     CsrWifiRouterCtrlQosControlReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlQosControlReq), GFP_KERNEL);
 355     size_t offset;
 356     offset = 0;
 357
 358     CsrUint16Des(&primitive->common.type, buffer, &offset);
 359     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 360     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 361     CsrUint16Des((u16 *) &primitive->control, buffer, &offset);
 362     CsrUint8Des((u8 *) &primitive->queueConfig, buffer, &offset);
 363
 364     return primitive;
 365 }
 366
 367
 368 size_t CsrWifiRouterCtrlSuspendResSizeof(void *msg)
 369 {
 370     size_t bufferSize = 2;
 371
 372     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
 373     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 374     bufferSize += 2; /* CsrResult primitive->status */
 375     return bufferSize;
 376 }
 377
 378
 379 u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, size_t *len, void *msg)
 380 {
 381     CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
 382     *len = 0;
 383     CsrUint16Ser(ptr, len, primitive->common.type);
 384     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 385     CsrUint16Ser(ptr, len, (u16) primitive->status);
 386     return(ptr);
 387 }
 388
 389
 390 void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, size_t length)
 391 {
 392     CsrWifiRouterCtrlSuspendRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlSuspendRes), GFP_KERNEL);
 393     size_t offset;
 394     offset = 0;
 395
 396     CsrUint16Des(&primitive->common.type, buffer, &offset);
 397     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 398     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 399
 400     return primitive;
 401 }
 402
 403
 404 size_t CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
 405 {
 406     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) msg;
 407     size_t bufferSize = 2;
 408
 409     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
 410     bufferSize += 2;                      /* u16 primitive->interfaceTag */
 411     bufferSize += 2;                      /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 412     bufferSize += 2;                      /* u16 primitive->tclasLength */
 413     bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
 414     return bufferSize;
 415 }
 416
 417
 418 u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, size_t *len, void *msg)
 419 {
 420     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
 421     *len = 0;
 422     CsrUint16Ser(ptr, len, primitive->common.type);
 423     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 424     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 425     CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
 426     if (primitive->tclasLength)
 427     {
 428         CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
 429     }
 430     return(ptr);
 431 }
 432
 433
 434 void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, size_t length)
 435 {
 436     CsrWifiRouterCtrlTclasAddReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasAddReq), GFP_KERNEL);
 437     size_t offset;
 438     offset = 0;
 439
 440     CsrUint16Des(&primitive->common.type, buffer, &offset);
 441     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 442     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 443     CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
 444     if (primitive->tclasLength)
 445     {
 446         primitive->tclas = kmalloc(primitive->tclasLength, GFP_KERNEL);
 447         CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
 448     }
 449     else
 450     {
 451         primitive->tclas = NULL;
 452     }
 453
 454     return primitive;
 455 }
 456
 457
 458 void CsrWifiRouterCtrlTclasAddReqSerFree(void *voidPrimitivePointer)
 459 {
 460     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) voidPrimitivePointer;
 461     kfree(primitive->tclas);
 462     kfree(primitive);
 463 }
 464
 465
 466 size_t CsrWifiRouterCtrlResumeResSizeof(void *msg)
 467 {
 468     size_t bufferSize = 2;
 469
 470     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
 471     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 472     bufferSize += 2; /* CsrResult primitive->status */
 473     return bufferSize;
 474 }
 475
 476
 477 u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, size_t *len, void *msg)
 478 {
 479     CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
 480     *len = 0;
 481     CsrUint16Ser(ptr, len, primitive->common.type);
 482     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 483     CsrUint16Ser(ptr, len, (u16) primitive->status);
 484     return(ptr);
 485 }
 486
 487
 488 void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, size_t length)
 489 {
 490     CsrWifiRouterCtrlResumeRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlResumeRes), GFP_KERNEL);
 491     size_t offset;
 492     offset = 0;
 493
 494     CsrUint16Des(&primitive->common.type, buffer, &offset);
 495     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 496     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 497
 498     return primitive;
 499 }
 500
 501
 502 size_t CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
 503 {
 504     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) msg;
 505     size_t bufferSize = 2;
 506
 507     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
 508     bufferSize += 2;                      /* u16 primitive->interfaceTag */
 509     bufferSize += 2;                      /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 510     bufferSize += 2;                      /* u16 primitive->tclasLength */
 511     bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
 512     return bufferSize;
 513 }
 514
 515
 516 u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, size_t *len, void *msg)
 517 {
 518     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
 519     *len = 0;
 520     CsrUint16Ser(ptr, len, primitive->common.type);
 521     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 522     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 523     CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
 524     if (primitive->tclasLength)
 525     {
 526         CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
 527     }
 528     return(ptr);
 529 }
 530
 531
 532 void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, size_t length)
 533 {
 534     CsrWifiRouterCtrlTclasDelReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasDelReq), GFP_KERNEL);
 535     size_t offset;
 536     offset = 0;
 537
 538     CsrUint16Des(&primitive->common.type, buffer, &offset);
 539     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 540     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 541     CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
 542     if (primitive->tclasLength)
 543     {
 544         primitive->tclas = kmalloc(primitive->tclasLength, GFP_KERNEL);
 545         CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
 546     }
 547     else
 548     {
 549         primitive->tclas = NULL;
 550     }
 551
 552     return primitive;
 553 }
 554
 555
 556 void CsrWifiRouterCtrlTclasDelReqSerFree(void *voidPrimitivePointer)
 557 {
 558     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) voidPrimitivePointer;
 559     kfree(primitive->tclas);
 560     kfree(primitive);
 561 }
 562
 563
 564 size_t CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
 565 {
 566     size_t bufferSize = 2;
 567
 568     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
 569     bufferSize += 2; /* u16 primitive->interfaceTag */
 570     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 571     bufferSize += 1; /* CsrWifiRouterCtrlTrafficType primitive->trafficType */
 572     bufferSize += 2; /* u16 primitive->period */
 573     return bufferSize;
 574 }
 575
 576
 577 u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, size_t *len, void *msg)
 578 {
 579     CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
 580     *len = 0;
 581     CsrUint16Ser(ptr, len, primitive->common.type);
 582     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 583     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 584     CsrUint8Ser(ptr, len, (u8) primitive->trafficType);
 585     CsrUint16Ser(ptr, len, (u16) primitive->period);
 586     return(ptr);
 587 }
 588
 589
 590 void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, size_t length)
 591 {
 592     CsrWifiRouterCtrlTrafficClassificationReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq), GFP_KERNEL);
 593     size_t offset;
 594     offset = 0;
 595
 596     CsrUint16Des(&primitive->common.type, buffer, &offset);
 597     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 598     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 599     CsrUint8Des((u8 *) &primitive->trafficType, buffer, &offset);
 600     CsrUint16Des((u16 *) &primitive->period, buffer, &offset);
 601
 602     return primitive;
 603 }
 604
 605
 606 size_t CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
 607 {
 608     size_t bufferSize = 2;
 609
 610     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
 611     bufferSize += 2; /* u16 primitive->interfaceTag */
 612     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 613     bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
 614     bufferSize += 2; /* u16 primitive->config.packetFilter */
 615     bufferSize += 4; /* u32 primitive->config.customFilter.etherType */
 616     bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
 617     bufferSize += 4; /* u32 primitive->config.customFilter.udpSourcePort */
 618     bufferSize += 4; /* u32 primitive->config.customFilter.udpDestPort */
 619     return bufferSize;
 620 }
 621
 622
 623 u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, size_t *len, void *msg)
 624 {
 625     CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
 626     *len = 0;
 627     CsrUint16Ser(ptr, len, primitive->common.type);
 628     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 629     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 630     CsrUint16Ser(ptr, len, (u16) primitive->trafficConfigType);
 631     CsrUint16Ser(ptr, len, (u16) primitive->config.packetFilter);
 632     CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.etherType);
 633     CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
 634     CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.udpSourcePort);
 635     CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.udpDestPort);
 636     return(ptr);
 637 }
 638
 639
 640 void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, size_t length)
 641 {
 642     CsrWifiRouterCtrlTrafficConfigReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq), GFP_KERNEL);
 643     size_t offset;
 644     offset = 0;
 645
 646     CsrUint16Des(&primitive->common.type, buffer, &offset);
 647     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 648     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 649     CsrUint16Des((u16 *) &primitive->trafficConfigType, buffer, &offset);
 650     CsrUint16Des((u16 *) &primitive->config.packetFilter, buffer, &offset);
 651     CsrUint32Des((u32 *) &primitive->config.customFilter.etherType, buffer, &offset);
 652     CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
 653     CsrUint32Des((u32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
 654     CsrUint32Des((u32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
 655
 656     return primitive;
 657 }
 658
 659
 660 size_t CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
 661 {
 662     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) msg;
 663     size_t bufferSize = 2;
 664
 665     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
 666     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 667     bufferSize += 4;                     /* u32 primitive->dataLength */
 668     bufferSize += primitive->dataLength; /* u8 primitive->data */
 669     return bufferSize;
 670 }
 671
 672
 673 u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, size_t *len, void *msg)
 674 {
 675     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
 676     *len = 0;
 677     CsrUint16Ser(ptr, len, primitive->common.type);
 678     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 679     CsrUint32Ser(ptr, len, (u32) primitive->dataLength);
 680     if (primitive->dataLength)
 681     {
 682         CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
 683     }
 684     return(ptr);
 685 }
 686
 687
 688 void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, size_t length)
 689 {
 690     CsrWifiRouterCtrlWifiOnReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnReq), GFP_KERNEL);
 691     size_t offset;
 692     offset = 0;
 693
 694     CsrUint16Des(&primitive->common.type, buffer, &offset);
 695     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 696     CsrUint32Des((u32 *) &primitive->dataLength, buffer, &offset);
 697     if (primitive->dataLength)
 698     {
 699         primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
 700         CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
 701     }
 702     else
 703     {
 704         primitive->data = NULL;
 705     }
 706
 707     return primitive;
 708 }
 709
 710
 711 void CsrWifiRouterCtrlWifiOnReqSerFree(void *voidPrimitivePointer)
 712 {
 713     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) voidPrimitivePointer;
 714     kfree(primitive->data);
 715     kfree(primitive);
 716 }
 717
 718
 719 size_t CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
 720 {
 721     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) msg;
 722     size_t bufferSize = 2;
 723
 724     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 30) */
 725     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 726     bufferSize += 2; /* CsrResult primitive->status */
 727     bufferSize += 2; /* u16 primitive->numInterfaceAddress */
 728     {
 729         u16 i1;
 730         for (i1 = 0; i1 < 2; i1++)
 731         {
 732             bufferSize += 6;                                                                            /* u8 primitive->stationMacAddress[i1].a[6] */
 733         }
 734     }
 735     bufferSize += 4;                                                                                    /* u32 primitive->smeVersions.firmwarePatch */
 736     bufferSize += (primitive->smeVersions.smeBuild ? strlen(primitive->smeVersions.smeBuild) : 0) + 1;  /* char* primitive->smeVersions.smeBuild (0 byte len + 1 for NULL Term) */
 737     bufferSize += 4;                                                                                    /* u32 primitive->smeVersions.smeHip */
 738     bufferSize += 1;                                                                                    /* u8 primitive->scheduledInterrupt */
 739     return bufferSize;
 740 }
 741
 742
 743 u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, size_t *len, void *msg)
 744 {
 745     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
 746     *len = 0;
 747     CsrUint16Ser(ptr, len, primitive->common.type);
 748     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 749     CsrUint16Ser(ptr, len, (u16) primitive->status);
 750     CsrUint16Ser(ptr, len, (u16) primitive->numInterfaceAddress);
 751     {
 752         u16 i1;
 753         for (i1 = 0; i1 < 2; i1++)
 754         {
 755             CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
 756         }
 757     }
 758     CsrUint32Ser(ptr, len, (u32) primitive->smeVersions.firmwarePatch);
 759     CsrCharStringSer(ptr, len, primitive->smeVersions.smeBuild);
 760     CsrUint32Ser(ptr, len, (u32) primitive->smeVersions.smeHip);
 761     CsrUint8Ser(ptr, len, (u8) primitive->scheduledInterrupt);
 762     return(ptr);
 763 }
 764
 765
 766 void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, size_t length)
 767 {
 768     CsrWifiRouterCtrlWifiOnRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnRes), GFP_KERNEL);
 769     size_t offset;
 770     offset = 0;
 771
 772     CsrUint16Des(&primitive->common.type, buffer, &offset);
 773     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 774     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 775     CsrUint16Des((u16 *) &primitive->numInterfaceAddress, buffer, &offset);
 776     {
 777         u16 i1;
 778         for (i1 = 0; i1 < 2; i1++)
 779         {
 780             CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
 781         }
 782     }
 783     CsrUint32Des((u32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
 784     CsrCharStringDes(&primitive->smeVersions.smeBuild, buffer, &offset);
 785     CsrUint32Des((u32 *) &primitive->smeVersions.smeHip, buffer, &offset);
 786     CsrUint8Des((u8 *) &primitive->scheduledInterrupt, buffer, &offset);
 787
 788     return primitive;
 789 }
 790
 791
 792 void CsrWifiRouterCtrlWifiOnResSerFree(void *voidPrimitivePointer)
 793 {
 794     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) voidPrimitivePointer;
 795     kfree(primitive->smeVersions.smeBuild);
 796     kfree(primitive);
 797 }
 798
 799
 800 size_t CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
 801 {
 802     size_t bufferSize = 2;
 803
 804     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
 805     bufferSize += 2; /* u16 primitive->interfaceTag */
 806     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 807     return bufferSize;
 808 }
 809
 810
 811 u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, size_t *len, void *msg)
 812 {
 813     CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
 814     *len = 0;
 815     CsrUint16Ser(ptr, len, primitive->common.type);
 816     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 817     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 818     return(ptr);
 819 }
 820
 821
 822 void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, size_t length)
 823 {
 824     CsrWifiRouterCtrlM4TransmitReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlM4TransmitReq), GFP_KERNEL);
 825     size_t offset;
 826     offset = 0;
 827
 828     CsrUint16Des(&primitive->common.type, buffer, &offset);
 829     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 830     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 831
 832     return primitive;
 833 }
 834
 835
 836 size_t CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
 837 {
 838     size_t bufferSize = 2;
 839
 840     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
 841     bufferSize += 2; /* u16 primitive->interfaceTag */
 842     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 843     bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
 844     bufferSize += 6; /* u8 primitive->bssid.a[6] */
 845     bufferSize += 1; /* u8 primitive->protection */
 846     bufferSize += 1; /* u8 primitive->intraBssDistEnabled */
 847     return bufferSize;
 848 }
 849
 850
 851 u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, size_t *len, void *msg)
 852 {
 853     CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
 854     *len = 0;
 855     CsrUint16Ser(ptr, len, primitive->common.type);
 856     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 857     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 858     CsrUint8Ser(ptr, len, (u8) primitive->mode);
 859     CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((u16) (6)));
 860     CsrUint8Ser(ptr, len, (u8) primitive->protection);
 861     CsrUint8Ser(ptr, len, (u8) primitive->intraBssDistEnabled);
 862     return(ptr);
 863 }
 864
 865
 866 void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, size_t length)
 867 {
 868     CsrWifiRouterCtrlModeSetReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlModeSetReq), GFP_KERNEL);
 869     size_t offset;
 870     offset = 0;
 871
 872     CsrUint16Des(&primitive->common.type, buffer, &offset);
 873     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 874     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 875     CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
 876     CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((u16) (6)));
 877     CsrUint8Des((u8 *) &primitive->protection, buffer, &offset);
 878     CsrUint8Des((u8 *) &primitive->intraBssDistEnabled, buffer, &offset);
 879
 880     return primitive;
 881 }
 882
 883
 884 size_t CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
 885 {
 886     size_t bufferSize = 2;
 887
 888     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
 889     bufferSize += 2; /* u16 primitive->interfaceTag */
 890     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 891     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
 892     bufferSize += 2; /* u16 primitive->associationId */
 893     bufferSize += 1; /* u8 primitive->staInfo.wmmOrQosEnabled */
 894     bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
 895     bufferSize += 1; /* u8 primitive->staInfo.maxSpLength */
 896     bufferSize += 2; /* u16 primitive->staInfo.listenIntervalInTus */
 897     return bufferSize;
 898 }
 899
 900
 901 u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, size_t *len, void *msg)
 902 {
 903     CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
 904     *len = 0;
 905     CsrUint16Ser(ptr, len, primitive->common.type);
 906     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 907     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 908     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
 909     CsrUint16Ser(ptr, len, (u16) primitive->associationId);
 910     CsrUint8Ser(ptr, len, (u8) primitive->staInfo.wmmOrQosEnabled);
 911     CsrUint16Ser(ptr, len, (u16) primitive->staInfo.powersaveMode);
 912     CsrUint8Ser(ptr, len, (u8) primitive->staInfo.maxSpLength);
 913     CsrUint16Ser(ptr, len, (u16) primitive->staInfo.listenIntervalInTus);
 914     return(ptr);
 915 }
 916
 917
 918 void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, size_t length)
 919 {
 920     CsrWifiRouterCtrlPeerAddReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerAddReq), GFP_KERNEL);
 921     size_t offset;
 922     offset = 0;
 923
 924     CsrUint16Des(&primitive->common.type, buffer, &offset);
 925     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 926     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 927     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 928     CsrUint16Des((u16 *) &primitive->associationId, buffer, &offset);
 929     CsrUint8Des((u8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
 930     CsrUint16Des((u16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
 931     CsrUint8Des((u8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
 932     CsrUint16Des((u16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
 933
 934     return primitive;
 935 }
 936
 937
 938 size_t CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
 939 {
 940     size_t bufferSize = 2;
 941
 942     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
 943     bufferSize += 2; /* u16 primitive->interfaceTag */
 944     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 945     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
 946     return bufferSize;
 947 }
 948
 949
 950 u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, size_t *len, void *msg)
 951 {
 952     CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
 953     *len = 0;
 954     CsrUint16Ser(ptr, len, primitive->common.type);
 955     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 956     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 957     CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
 958     return(ptr);
 959 }
 960
 961
 962 void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, size_t length)
 963 {
 964     CsrWifiRouterCtrlPeerDelReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerDelReq), GFP_KERNEL);
 965     size_t offset;
 966     offset = 0;
 967
 968     CsrUint16Des(&primitive->common.type, buffer, &offset);
 969     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 970     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 971     CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
 972
 973     return primitive;
 974 }
 975
 976
 977 size_t CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
 978 {
 979     size_t bufferSize = 2;
 980
 981     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
 982     bufferSize += 2; /* u16 primitive->interfaceTag */
 983     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
 984     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
 985     bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->powersaveMode */
 986     return bufferSize;
 987 }
 988
 989
 990 u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, size_t *len, void *msg)
 991 {
 992     CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
 993     *len = 0;
 994     CsrUint16Ser(ptr, len, primitive->common.type);
 995     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 996     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
 997     CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
 998     CsrUint16Ser(ptr, len, (u16) primitive->powersaveMode);
 999     return(ptr);
1000 }
1001
1002
1003 void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, size_t length)
1004 {
1005     CsrWifiRouterCtrlPeerUpdateReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq), GFP_KERNEL);
1006     size_t offset;
1007     offset = 0;
1008
1009     CsrUint16Des(&primitive->common.type, buffer, &offset);
1010     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1011     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1012     CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
1013     CsrUint16Des((u16 *) &primitive->powersaveMode, buffer, &offset);
1014
1015     return primitive;
1016 }
1017
1018
1019 size_t CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
1020 {
1021     size_t bufferSize = 2;
1022
1023     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
1024     bufferSize += 2; /* u16 primitive->interfaceTag */
1025     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1026     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
1027     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
1028     bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
1029     bufferSize += 2; /* u16 primitive->bufferSize */
1030     bufferSize += 2; /* u16 primitive->timeout */
1031     bufferSize += 2; /* u16 primitive->ssn */
1032     return bufferSize;
1033 }
1034
1035
1036 u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, size_t *len, void *msg)
1037 {
1038     CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
1039     *len = 0;
1040     CsrUint16Ser(ptr, len, primitive->common.type);
1041     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1042     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1043     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
1044     CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
1045     CsrUint8Ser(ptr, len, (u8) primitive->role);
1046     CsrUint16Ser(ptr, len, (u16) primitive->bufferSize);
1047     CsrUint16Ser(ptr, len, (u16) primitive->timeout);
1048     CsrUint16Ser(ptr, len, (u16) primitive->ssn);
1049     return(ptr);
1050 }
1051
1052
1053 void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, size_t length)
1054 {
1055     CsrWifiRouterCtrlBlockAckEnableReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq), GFP_KERNEL);
1056     size_t offset;
1057     offset = 0;
1058
1059     CsrUint16Des(&primitive->common.type, buffer, &offset);
1060     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1061     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1062     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
1063     CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
1064     CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
1065     CsrUint16Des((u16 *) &primitive->bufferSize, buffer, &offset);
1066     CsrUint16Des((u16 *) &primitive->timeout, buffer, &offset);
1067     CsrUint16Des((u16 *) &primitive->ssn, buffer, &offset);
1068
1069     return primitive;
1070 }
1071
1072
1073 size_t CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
1074 {
1075     size_t bufferSize = 2;
1076
1077     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1078     bufferSize += 2; /* u16 primitive->interfaceTag */
1079     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1080     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
1081     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
1082     bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
1083     return bufferSize;
1084 }
1085
1086
1087 u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, size_t *len, void *msg)
1088 {
1089     CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
1090     *len = 0;
1091     CsrUint16Ser(ptr, len, primitive->common.type);
1092     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1093     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1094     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
1095     CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
1096     CsrUint8Ser(ptr, len, (u8) primitive->role);
1097     return(ptr);
1098 }
1099
1100
1101 void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, size_t length)
1102 {
1103     CsrWifiRouterCtrlBlockAckDisableReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq), GFP_KERNEL);
1104     size_t offset;
1105     offset = 0;
1106
1107     CsrUint16Des(&primitive->common.type, buffer, &offset);
1108     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1109     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1110     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
1111     CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
1112     CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
1113
1114     return primitive;
1115 }
1116
1117
1118 size_t CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
1119 {
1120     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) msg;
1121     size_t bufferSize = 2;
1122
1123     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
1124     bufferSize += 2;                       /* u16 primitive->interfaceTag */
1125     bufferSize += 2;                       /* u16 primitive->signalLength */
1126     bufferSize += primitive->signalLength; /* u8 primitive->signal */
1127     bufferSize += 2;                       /* u16 primitive->dataLength */
1128     bufferSize += primitive->dataLength;   /* u8 primitive->data */
1129     return bufferSize;
1130 }
1131
1132
1133 u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, size_t *len, void *msg)
1134 {
1135     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
1136     *len = 0;
1137     CsrUint16Ser(ptr, len, primitive->common.type);
1138     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1139     CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
1140     if (primitive->signalLength)
1141     {
1142         CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
1143     }
1144     CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
1145     if (primitive->dataLength)
1146     {
1147         CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
1148     }
1149     return(ptr);
1150 }
1151
1152
1153 void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, size_t length)
1154 {
1155     CsrWifiRouterCtrlWapiRxPktReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq), GFP_KERNEL);
1156     size_t offset;
1157     offset = 0;
1158
1159     CsrUint16Des(&primitive->common.type, buffer, &offset);
1160     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1161     CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
1162     if (primitive->signalLength)
1163     {
1164         primitive->signal = kmalloc(primitive->signalLength, GFP_KERNEL);
1165         CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
1166     }
1167     else
1168     {
1169         primitive->signal = NULL;
1170     }
1171     CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
1172     if (primitive->dataLength)
1173     {
1174         primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
1175         CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
1176     }
1177     else
1178     {
1179         primitive->data = NULL;
1180     }
1181
1182     return primitive;
1183 }
1184
1185
1186 void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *voidPrimitivePointer)
1187 {
1188     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) voidPrimitivePointer;
1189     kfree(primitive->signal);
1190     kfree(primitive->data);
1191     kfree(primitive);
1192 }
1193
1194
1195 size_t CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
1196 {
1197     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) msg;
1198     size_t bufferSize = 2;
1199
1200     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
1201     bufferSize += 2;                     /* u16 primitive->interfaceTag */
1202     bufferSize += 2;                     /* u16 primitive->dataLength */
1203     bufferSize += primitive->dataLength; /* u8 primitive->data */
1204     return bufferSize;
1205 }
1206
1207
1208 u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, size_t *len, void *msg)
1209 {
1210     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
1211     *len = 0;
1212     CsrUint16Ser(ptr, len, primitive->common.type);
1213     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1214     CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
1215     if (primitive->dataLength)
1216     {
1217         CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
1218     }
1219     return(ptr);
1220 }
1221
1222
1223 void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, size_t length)
1224 {
1225     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq), GFP_KERNEL);
1226     size_t offset;
1227     offset = 0;
1228
1229     CsrUint16Des(&primitive->common.type, buffer, &offset);
1230     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1231     CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
1232     if (primitive->dataLength)
1233     {
1234         primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
1235         CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
1236     }
1237     else
1238     {
1239         primitive->data = NULL;
1240     }
1241
1242     return primitive;
1243 }
1244
1245
1246 void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *voidPrimitivePointer)
1247 {
1248     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) voidPrimitivePointer;
1249     kfree(primitive->data);
1250     kfree(primitive);
1251 }
1252
1253
1254 size_t CsrWifiRouterCtrlHipIndSizeof(void *msg)
1255 {
1256     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) msg;
1257     size_t bufferSize = 2;
1258
1259     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
1260     bufferSize += 2;                            /* u16 primitive->mlmeCommandLength */
1261     bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
1262     bufferSize += 2;                            /* u16 primitive->dataRef1Length */
1263     bufferSize += primitive->dataRef1Length;    /* u8 primitive->dataRef1 */
1264     bufferSize += 2;                            /* u16 primitive->dataRef2Length */
1265     bufferSize += primitive->dataRef2Length;    /* u8 primitive->dataRef2 */
1266     return bufferSize;
1267 }
1268
1269
1270 u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, size_t *len, void *msg)
1271 {
1272     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
1273     *len = 0;
1274     CsrUint16Ser(ptr, len, primitive->common.type);
1275     CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
1276     if (primitive->mlmeCommandLength)
1277     {
1278         CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
1279     }
1280     CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
1281     if (primitive->dataRef1Length)
1282     {
1283         CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
1284     }
1285     CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
1286     if (primitive->dataRef2Length)
1287     {
1288         CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
1289     }
1290     return(ptr);
1291 }
1292
1293
1294 void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, size_t length)
1295 {
1296     CsrWifiRouterCtrlHipInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlHipInd), GFP_KERNEL);
1297     size_t offset;
1298     offset = 0;
1299
1300     CsrUint16Des(&primitive->common.type, buffer, &offset);
1301     CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
1302     if (primitive->mlmeCommandLength)
1303     {
1304         primitive->mlmeCommand = kmalloc(primitive->mlmeCommandLength, GFP_KERNEL);
1305         CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
1306     }
1307     else
1308     {
1309         primitive->mlmeCommand = NULL;
1310     }
1311     CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
1312     if (primitive->dataRef1Length)
1313     {
1314         primitive->dataRef1 = kmalloc(primitive->dataRef1Length, GFP_KERNEL);
1315         CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
1316     }
1317     else
1318     {
1319         primitive->dataRef1 = NULL;
1320     }
1321     CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
1322     if (primitive->dataRef2Length)
1323     {
1324         primitive->dataRef2 = kmalloc(primitive->dataRef2Length, GFP_KERNEL);
1325         CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
1326     }
1327     else
1328     {
1329         primitive->dataRef2 = NULL;
1330     }
1331
1332     return primitive;
1333 }
1334
1335
1336 void CsrWifiRouterCtrlHipIndSerFree(void *voidPrimitivePointer)
1337 {
1338     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) voidPrimitivePointer;
1339     kfree(primitive->mlmeCommand);
1340     kfree(primitive->dataRef1);
1341     kfree(primitive->dataRef2);
1342     kfree(primitive);
1343 }
1344
1345
1346 size_t CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
1347 {
1348     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) msg;
1349     size_t bufferSize = 2;
1350
1351     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1352     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1353     bufferSize += 2; /* u16 primitive->interfaceTag */
1354     bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
1355     bufferSize += 1; /* u8 primitive->setAddressesCount */
1356     {
1357         u16 i1;
1358         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
1359         {
1360             bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
1361         }
1362     }
1363     return bufferSize;
1364 }
1365
1366
1367 u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, size_t *len, void *msg)
1368 {
1369     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
1370     *len = 0;
1371     CsrUint16Ser(ptr, len, primitive->common.type);
1372     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1373     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1374     CsrUint8Ser(ptr, len, (u8) primitive->action);
1375     CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
1376     {
1377         u16 i1;
1378         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
1379         {
1380             CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
1381         }
1382     }
1383     return(ptr);
1384 }
1385
1386
1387 void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, size_t length)
1388 {
1389     CsrWifiRouterCtrlMulticastAddressInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd), GFP_KERNEL);
1390     size_t offset;
1391     offset = 0;
1392
1393     CsrUint16Des(&primitive->common.type, buffer, &offset);
1394     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1395     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1396     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
1397     CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
1398     primitive->setAddresses = NULL;
1399     if (primitive->setAddressesCount)
1400     {
1401         primitive->setAddresses = kmalloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount, GFP_KERNEL);
1402     }
1403     {
1404         u16 i1;
1405         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
1406         {
1407             CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
1408         }
1409     }
1410
1411     return primitive;
1412 }
1413
1414
1415 void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *voidPrimitivePointer)
1416 {
1417     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) voidPrimitivePointer;
1418     kfree(primitive->setAddresses);
1419     kfree(primitive);
1420 }
1421
1422
1423 size_t CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
1424 {
1425     size_t bufferSize = 2;
1426
1427     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1428     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1429     bufferSize += 2; /* u16 primitive->interfaceTag */
1430     bufferSize += 2; /* CsrResult primitive->status */
1431     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
1432     return bufferSize;
1433 }
1434
1435
1436 u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, size_t *len, void *msg)
1437 {
1438     CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
1439     *len = 0;
1440     CsrUint16Ser(ptr, len, primitive->common.type);
1441     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1442     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1443     CsrUint16Ser(ptr, len, (u16) primitive->status);
1444     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
1445     return(ptr);
1446 }
1447
1448
1449 void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, size_t length)
1450 {
1451     CsrWifiRouterCtrlPortConfigureCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm), GFP_KERNEL);
1452     size_t offset;
1453     offset = 0;
1454
1455     CsrUint16Des(&primitive->common.type, buffer, &offset);
1456     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1457     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1458     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1459     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
1460
1461     return primitive;
1462 }
1463
1464
1465 size_t CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
1466 {
1467     size_t bufferSize = 2;
1468
1469     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
1470     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1471     bufferSize += 1; /* u8 primitive->hardSuspend */
1472     bufferSize += 1; /* u8 primitive->d3Suspend */
1473     return bufferSize;
1474 }
1475
1476
1477 u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, size_t *len, void *msg)
1478 {
1479     CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
1480     *len = 0;
1481     CsrUint16Ser(ptr, len, primitive->common.type);
1482     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1483     CsrUint8Ser(ptr, len, (u8) primitive->hardSuspend);
1484     CsrUint8Ser(ptr, len, (u8) primitive->d3Suspend);
1485     return(ptr);
1486 }
1487
1488
1489 void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, size_t length)
1490 {
1491     CsrWifiRouterCtrlSuspendInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlSuspendInd), GFP_KERNEL);
1492     size_t offset;
1493     offset = 0;
1494
1495     CsrUint16Des(&primitive->common.type, buffer, &offset);
1496     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1497     CsrUint8Des((u8 *) &primitive->hardSuspend, buffer, &offset);
1498     CsrUint8Des((u8 *) &primitive->d3Suspend, buffer, &offset);
1499
1500     return primitive;
1501 }
1502
1503
1504 size_t CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
1505 {
1506     size_t bufferSize = 2;
1507
1508     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
1509     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1510     bufferSize += 2; /* u16 primitive->interfaceTag */
1511     bufferSize += 2; /* CsrResult primitive->status */
1512     return bufferSize;
1513 }
1514
1515
1516 u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, size_t *len, void *msg)
1517 {
1518     CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
1519     *len = 0;
1520     CsrUint16Ser(ptr, len, primitive->common.type);
1521     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1522     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1523     CsrUint16Ser(ptr, len, (u16) primitive->status);
1524     return(ptr);
1525 }
1526
1527
1528 void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, size_t length)
1529 {
1530     CsrWifiRouterCtrlTclasAddCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasAddCfm), GFP_KERNEL);
1531     size_t offset;
1532     offset = 0;
1533
1534     CsrUint16Des(&primitive->common.type, buffer, &offset);
1535     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1536     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1537     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1538
1539     return primitive;
1540 }
1541
1542
1543 size_t CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
1544 {
1545     size_t bufferSize = 2;
1546
1547     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
1548     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1549     bufferSize += 2; /* CsrResult primitive->result */
1550     return bufferSize;
1551 }
1552
1553
1554 u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, size_t *len, void *msg)
1555 {
1556     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
1557     *len = 0;
1558     CsrUint16Ser(ptr, len, primitive->common.type);
1559     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1560     CsrUint16Ser(ptr, len, (u16) primitive->result);
1561     return(ptr);
1562 }
1563
1564
1565 void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, size_t length)
1566 {
1567     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm), GFP_KERNEL);
1568     size_t offset;
1569     offset = 0;
1570
1571     CsrUint16Des(&primitive->common.type, buffer, &offset);
1572     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1573     CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
1574
1575     return primitive;
1576 }
1577
1578
1579 size_t CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
1580 {
1581     size_t bufferSize = 2;
1582
1583     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
1584     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1585     bufferSize += 2; /* CsrResult primitive->result */
1586     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteRead primitive->byteRead */
1587     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteWrite primitive->byteWrite */
1588     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioFirmwareDownload primitive->firmwareDownload */
1589     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioReset primitive->reset */
1590     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioCoreDumpPrepare primitive->coreDumpPrepare */
1591     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteBlockRead primitive->byteBlockRead */
1592     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioGpRead16 primitive->gpRead16 */
1593     bufferSize += 4; /* CsrWifiRouterCtrlRawSdioGpWrite16 primitive->gpWrite16 */
1594     return bufferSize;
1595 }
1596
1597
1598 u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, size_t *len, void *msg)
1599 {
1600     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
1601     *len = 0;
1602     CsrUint16Ser(ptr, len, primitive->common.type);
1603     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1604     CsrUint16Ser(ptr, len, (u16) primitive->result);
1605     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteRead */
1606     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteWrite */
1607     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->firmwareDownload */
1608     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->reset */
1609     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->coreDumpPrepare */
1610     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteBlockRead */
1611     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->gpRead16 */
1612     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->gpWrite16 */
1613     return(ptr);
1614 }
1615
1616
1617 void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, size_t length)
1618 {
1619     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm), GFP_KERNEL);
1620     size_t offset;
1621     offset = 0;
1622
1623     CsrUint16Des(&primitive->common.type, buffer, &offset);
1624     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1625     CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
1626     primitive->byteRead = NULL;         /* Special for Function Pointers... */
1627     offset += 4;
1628     primitive->byteWrite = NULL;        /* Special for Function Pointers... */
1629     offset += 4;
1630     primitive->firmwareDownload = NULL; /* Special for Function Pointers... */
1631     offset += 4;
1632     primitive->reset = NULL;            /* Special for Function Pointers... */
1633     offset += 4;
1634     primitive->coreDumpPrepare = NULL;  /* Special for Function Pointers... */
1635     offset += 4;
1636     primitive->byteBlockRead = NULL;    /* Special for Function Pointers... */
1637     offset += 4;
1638     primitive->gpRead16 = NULL;         /* Special for Function Pointers... */
1639     offset += 4;
1640     primitive->gpWrite16 = NULL;        /* Special for Function Pointers... */
1641     offset += 4;
1642
1643     return primitive;
1644 }
1645
1646
1647 size_t CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
1648 {
1649     size_t bufferSize = 2;
1650
1651     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
1652     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1653     bufferSize += 2; /* u16 primitive->interfaceTag */
1654     bufferSize += 2; /* CsrResult primitive->status */
1655     return bufferSize;
1656 }
1657
1658
1659 u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, size_t *len, void *msg)
1660 {
1661     CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
1662     *len = 0;
1663     CsrUint16Ser(ptr, len, primitive->common.type);
1664     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1665     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1666     CsrUint16Ser(ptr, len, (u16) primitive->status);
1667     return(ptr);
1668 }
1669
1670
1671 void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, size_t length)
1672 {
1673     CsrWifiRouterCtrlTclasDelCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasDelCfm), GFP_KERNEL);
1674     size_t offset;
1675     offset = 0;
1676
1677     CsrUint16Des(&primitive->common.type, buffer, &offset);
1678     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1679     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1680     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1681
1682     return primitive;
1683 }
1684
1685
1686 size_t CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
1687 {
1688     size_t bufferSize = 2;
1689
1690     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
1691     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1692     bufferSize += 2; /* u16 primitive->interfaceTag */
1693     bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
1694     bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
1695     bufferSize += 6; /* u8 primitive->srcAddress.a[6] */
1696     return bufferSize;
1697 }
1698
1699
1700 u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, size_t *len, void *msg)
1701 {
1702     CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
1703     *len = 0;
1704     CsrUint16Ser(ptr, len, primitive->common.type);
1705     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1706     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1707     CsrUint16Ser(ptr, len, (u16) primitive->packetType);
1708     CsrUint16Ser(ptr, len, (u16) primitive->direction);
1709     CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((u16) (6)));
1710     return(ptr);
1711 }
1712
1713
1714 void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, size_t length)
1715 {
1716     CsrWifiRouterCtrlTrafficProtocolInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd), GFP_KERNEL);
1717     size_t offset;
1718     offset = 0;
1719
1720     CsrUint16Des(&primitive->common.type, buffer, &offset);
1721     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1722     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1723     CsrUint16Des((u16 *) &primitive->packetType, buffer, &offset);
1724     CsrUint16Des((u16 *) &primitive->direction, buffer, &offset);
1725     CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((u16) (6)));
1726
1727     return primitive;
1728 }
1729
1730
1731 size_t CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
1732 {
1733     size_t bufferSize = 2;
1734
1735     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
1736     bufferSize += 2;  /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1737     bufferSize += 2;  /* u16 primitive->interfaceTag */
1738     bufferSize += 4;  /* u32 primitive->stats.rxMeanRate */
1739     bufferSize += 4;  /* u32 primitive->stats.rxFramesNum */
1740     bufferSize += 4;  /* u32 primitive->stats.txFramesNum */
1741     bufferSize += 4;  /* u32 primitive->stats.rxBytesCount */
1742     bufferSize += 4;  /* u32 primitive->stats.txBytesCount */
1743     bufferSize += 11; /* u8 primitive->stats.intervals[11] */
1744     return bufferSize;
1745 }
1746
1747
1748 u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, size_t *len, void *msg)
1749 {
1750     CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
1751     *len = 0;
1752     CsrUint16Ser(ptr, len, primitive->common.type);
1753     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1754     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1755     CsrUint32Ser(ptr, len, (u32) primitive->stats.rxMeanRate);
1756     CsrUint32Ser(ptr, len, (u32) primitive->stats.rxFramesNum);
1757     CsrUint32Ser(ptr, len, (u32) primitive->stats.txFramesNum);
1758     CsrUint32Ser(ptr, len, (u32) primitive->stats.rxBytesCount);
1759     CsrUint32Ser(ptr, len, (u32) primitive->stats.txBytesCount);
1760     CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((u16) (11)));
1761     return(ptr);
1762 }
1763
1764
1765 void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, size_t length)
1766 {
1767     CsrWifiRouterCtrlTrafficSampleInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd), GFP_KERNEL);
1768     size_t offset;
1769     offset = 0;
1770
1771     CsrUint16Des(&primitive->common.type, buffer, &offset);
1772     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1773     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1774     CsrUint32Des((u32 *) &primitive->stats.rxMeanRate, buffer, &offset);
1775     CsrUint32Des((u32 *) &primitive->stats.rxFramesNum, buffer, &offset);
1776     CsrUint32Des((u32 *) &primitive->stats.txFramesNum, buffer, &offset);
1777     CsrUint32Des((u32 *) &primitive->stats.rxBytesCount, buffer, &offset);
1778     CsrUint32Des((u32 *) &primitive->stats.txBytesCount, buffer, &offset);
1779     CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((u16) (11)));
1780
1781     return primitive;
1782 }
1783
1784
1785 size_t CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
1786 {
1787     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) msg;
1788     size_t bufferSize = 2;
1789
1790     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 27) */
1791     bufferSize += 2;                                                                                    /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1792     bufferSize += 2;                                                                                    /* CsrResult primitive->status */
1793     bufferSize += 4;                                                                                    /* u32 primitive->versions.chipId */
1794     bufferSize += 4;                                                                                    /* u32 primitive->versions.chipVersion */
1795     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwareBuild */
1796     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwareHip */
1797     bufferSize += (primitive->versions.routerBuild ? strlen(primitive->versions.routerBuild) : 0) + 1;  /* char* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
1798     bufferSize += 4;                                                                                    /* u32 primitive->versions.routerHip */
1799     return bufferSize;
1800 }
1801
1802
1803 u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, size_t *len, void *msg)
1804 {
1805     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
1806     *len = 0;
1807     CsrUint16Ser(ptr, len, primitive->common.type);
1808     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1809     CsrUint16Ser(ptr, len, (u16) primitive->status);
1810     CsrUint32Ser(ptr, len, (u32) primitive->versions.chipId);
1811     CsrUint32Ser(ptr, len, (u32) primitive->versions.chipVersion);
1812     CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareBuild);
1813     CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareHip);
1814     CsrCharStringSer(ptr, len, primitive->versions.routerBuild);
1815     CsrUint32Ser(ptr, len, (u32) primitive->versions.routerHip);
1816     return(ptr);
1817 }
1818
1819
1820 void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, size_t length)
1821 {
1822     CsrWifiRouterCtrlWifiOnInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnInd), GFP_KERNEL);
1823     size_t offset;
1824     offset = 0;
1825
1826     CsrUint16Des(&primitive->common.type, buffer, &offset);
1827     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1828     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1829     CsrUint32Des((u32 *) &primitive->versions.chipId, buffer, &offset);
1830     CsrUint32Des((u32 *) &primitive->versions.chipVersion, buffer, &offset);
1831     CsrUint32Des((u32 *) &primitive->versions.firmwareBuild, buffer, &offset);
1832     CsrUint32Des((u32 *) &primitive->versions.firmwareHip, buffer, &offset);
1833     CsrCharStringDes(&primitive->versions.routerBuild, buffer, &offset);
1834     CsrUint32Des((u32 *) &primitive->versions.routerHip, buffer, &offset);
1835
1836     return primitive;
1837 }
1838
1839
1840 void CsrWifiRouterCtrlWifiOnIndSerFree(void *voidPrimitivePointer)
1841 {
1842     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) voidPrimitivePointer;
1843     kfree(primitive->versions.routerBuild);
1844     kfree(primitive);
1845 }
1846
1847
1848 size_t CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
1849 {
1850     size_t bufferSize = 2;
1851
1852     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
1853     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1854     bufferSize += 2; /* CsrResult primitive->status */
1855     return bufferSize;
1856 }
1857
1858
1859 u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, size_t *len, void *msg)
1860 {
1861     CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
1862     *len = 0;
1863     CsrUint16Ser(ptr, len, primitive->common.type);
1864     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1865     CsrUint16Ser(ptr, len, (u16) primitive->status);
1866     return(ptr);
1867 }
1868
1869
1870 void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, size_t length)
1871 {
1872     CsrWifiRouterCtrlWifiOnCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnCfm), GFP_KERNEL);
1873     size_t offset;
1874     offset = 0;
1875
1876     CsrUint16Des(&primitive->common.type, buffer, &offset);
1877     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1878     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1879
1880     return primitive;
1881 }
1882
1883
1884 size_t CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
1885 {
1886     size_t bufferSize = 2;
1887
1888     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
1889     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1890     bufferSize += 2; /* u16 primitive->interfaceTag */
1891     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
1892     return bufferSize;
1893 }
1894
1895
1896 u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, size_t *len, void *msg)
1897 {
1898     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
1899     *len = 0;
1900     CsrUint16Ser(ptr, len, primitive->common.type);
1901     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1902     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1903     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
1904     return(ptr);
1905 }
1906
1907
1908 void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, size_t length)
1909 {
1910     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd), GFP_KERNEL);
1911     size_t offset;
1912     offset = 0;
1913
1914     CsrUint16Des(&primitive->common.type, buffer, &offset);
1915     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1916     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1917     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
1918
1919     return primitive;
1920 }
1921
1922
1923 size_t CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
1924 {
1925     size_t bufferSize = 2;
1926
1927     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1928     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1929     bufferSize += 2; /* u16 primitive->interfaceTag */
1930     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
1931     bufferSize += 2; /* CsrResult primitive->status */
1932     return bufferSize;
1933 }
1934
1935
1936 u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, size_t *len, void *msg)
1937 {
1938     CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
1939     *len = 0;
1940     CsrUint16Ser(ptr, len, primitive->common.type);
1941     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1942     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1943     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
1944     CsrUint16Ser(ptr, len, (u16) primitive->status);
1945     return(ptr);
1946 }
1947
1948
1949 void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, size_t length)
1950 {
1951     CsrWifiRouterCtrlM4TransmittedInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd), GFP_KERNEL);
1952     size_t offset;
1953     offset = 0;
1954
1955     CsrUint16Des(&primitive->common.type, buffer, &offset);
1956     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1957     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1958     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
1959     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1960
1961     return primitive;
1962 }
1963
1964
1965 size_t CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
1966 {
1967     size_t bufferSize = 2;
1968
1969     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
1970     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1971     bufferSize += 2; /* u16 primitive->interfaceTag */
1972     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
1973     bufferSize += 1; /* u8 primitive->unicastPdu */
1974     return bufferSize;
1975 }
1976
1977
1978 u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, size_t *len, void *msg)
1979 {
1980     CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
1981     *len = 0;
1982     CsrUint16Ser(ptr, len, primitive->common.type);
1983     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1984     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1985     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
1986     CsrUint8Ser(ptr, len, (u8) primitive->unicastPdu);
1987     return(ptr);
1988 }
1989
1990
1991 void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, size_t length)
1992 {
1993     CsrWifiRouterCtrlMicFailureInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMicFailureInd), GFP_KERNEL);
1994     size_t offset;
1995     offset = 0;
1996
1997     CsrUint16Des(&primitive->common.type, buffer, &offset);
1998     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1999     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2000     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2001     CsrUint8Des((u8 *) &primitive->unicastPdu, buffer, &offset);
2002
2003     return primitive;
2004 }
2005
2006
2007 size_t CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
2008 {
2009     size_t bufferSize = 2;
2010
2011     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
2012     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2013     bufferSize += 2; /* u16 primitive->interfaceTag */
2014     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2015     bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
2016     return bufferSize;
2017 }
2018
2019
2020 u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, size_t *len, void *msg)
2021 {
2022     CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
2023     *len = 0;
2024     CsrUint16Ser(ptr, len, primitive->common.type);
2025     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2026     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2027     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2028     CsrUint8Ser(ptr, len, (u8) primitive->peerStatus);
2029     return(ptr);
2030 }
2031
2032
2033 void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, size_t length)
2034 {
2035     CsrWifiRouterCtrlConnectedInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlConnectedInd), GFP_KERNEL);
2036     size_t offset;
2037     offset = 0;
2038
2039     CsrUint16Des(&primitive->common.type, buffer, &offset);
2040     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2041     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2042     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2043     CsrUint8Des((u8 *) &primitive->peerStatus, buffer, &offset);
2044
2045     return primitive;
2046 }
2047
2048
2049 size_t CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
2050 {
2051     size_t bufferSize = 2;
2052
2053     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 19) */
2054     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2055     bufferSize += 2; /* u16 primitive->interfaceTag */
2056     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2057     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
2058     bufferSize += 2; /* CsrResult primitive->status */
2059     return bufferSize;
2060 }
2061
2062
2063 u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, size_t *len, void *msg)
2064 {
2065     CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
2066     *len = 0;
2067     CsrUint16Ser(ptr, len, primitive->common.type);
2068     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2069     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2070     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2071     CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
2072     CsrUint16Ser(ptr, len, (u16) primitive->status);
2073     return(ptr);
2074 }
2075
2076
2077 void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, size_t length)
2078 {
2079     CsrWifiRouterCtrlPeerAddCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerAddCfm), GFP_KERNEL);
2080     size_t offset;
2081     offset = 0;
2082
2083     CsrUint16Des(&primitive->common.type, buffer, &offset);
2084     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2085     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2086     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2087     CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
2088     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2089
2090     return primitive;
2091 }
2092
2093
2094 size_t CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
2095 {
2096     size_t bufferSize = 2;
2097
2098     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2099     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2100     bufferSize += 2; /* u16 primitive->interfaceTag */
2101     bufferSize += 2; /* CsrResult primitive->status */
2102     return bufferSize;
2103 }
2104
2105
2106 u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, size_t *len, void *msg)
2107 {
2108     CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
2109     *len = 0;
2110     CsrUint16Ser(ptr, len, primitive->common.type);
2111     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2112     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2113     CsrUint16Ser(ptr, len, (u16) primitive->status);
2114     return(ptr);
2115 }
2116
2117
2118 void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, size_t length)
2119 {
2120     CsrWifiRouterCtrlPeerDelCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerDelCfm), GFP_KERNEL);
2121     size_t offset;
2122     offset = 0;
2123
2124     CsrUint16Des(&primitive->common.type, buffer, &offset);
2125     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2126     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2127     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2128
2129     return primitive;
2130 }
2131
2132
2133 size_t CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
2134 {
2135     size_t bufferSize = 2;
2136
2137     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
2138     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2139     bufferSize += 2; /* u16 primitive->interfaceTag */
2140     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2141     return bufferSize;
2142 }
2143
2144
2145 u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, size_t *len, void *msg)
2146 {
2147     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
2148     *len = 0;
2149     CsrUint16Ser(ptr, len, primitive->common.type);
2150     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2151     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2152     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2153     return(ptr);
2154 }
2155
2156
2157 void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, size_t length)
2158 {
2159     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd), GFP_KERNEL);
2160     size_t offset;
2161     offset = 0;
2162
2163     CsrUint16Des(&primitive->common.type, buffer, &offset);
2164     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2165     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2166     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2167
2168     return primitive;
2169 }
2170
2171
2172 size_t CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
2173 {
2174     size_t bufferSize = 2;
2175
2176     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2177     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2178     bufferSize += 2; /* u16 primitive->interfaceTag */
2179     bufferSize += 2; /* CsrResult primitive->status */
2180     return bufferSize;
2181 }
2182
2183
2184 u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, size_t *len, void *msg)
2185 {
2186     CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
2187     *len = 0;
2188     CsrUint16Ser(ptr, len, primitive->common.type);
2189     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2190     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2191     CsrUint16Ser(ptr, len, (u16) primitive->status);
2192     return(ptr);
2193 }
2194
2195
2196 void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, size_t length)
2197 {
2198     CsrWifiRouterCtrlPeerUpdateCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm), GFP_KERNEL);
2199     size_t offset;
2200     offset = 0;
2201
2202     CsrUint16Des(&primitive->common.type, buffer, &offset);
2203     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2204     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2205     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2206
2207     return primitive;
2208 }
2209
2210
2211 size_t CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
2212 {
2213     size_t bufferSize = 2;
2214
2215     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2216     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2217     bufferSize += 2; /* u16 primitive->commandQueueSize */
2218     bufferSize += 2; /* u16 primitive->trafficQueueSize */
2219     return bufferSize;
2220 }
2221
2222
2223 u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, size_t *len, void *msg)
2224 {
2225     CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
2226     *len = 0;
2227     CsrUint16Ser(ptr, len, primitive->common.type);
2228     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2229     CsrUint16Ser(ptr, len, (u16) primitive->commandQueueSize);
2230     CsrUint16Ser(ptr, len, (u16) primitive->trafficQueueSize);
2231     return(ptr);
2232 }
2233
2234
2235 void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, size_t length)
2236 {
2237     CsrWifiRouterCtrlCapabilitiesCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm), GFP_KERNEL);
2238     size_t offset;
2239     offset = 0;
2240
2241     CsrUint16Des(&primitive->common.type, buffer, &offset);
2242     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2243     CsrUint16Des((u16 *) &primitive->commandQueueSize, buffer, &offset);
2244     CsrUint16Des((u16 *) &primitive->trafficQueueSize, buffer, &offset);
2245
2246     return primitive;
2247 }
2248
2249
2250 size_t CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
2251 {
2252     size_t bufferSize = 2;
2253
2254     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2255     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2256     bufferSize += 2; /* u16 primitive->interfaceTag */
2257     bufferSize += 2; /* CsrResult primitive->status */
2258     return bufferSize;
2259 }
2260
2261
2262 u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, size_t *len, void *msg)
2263 {
2264     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
2265     *len = 0;
2266     CsrUint16Ser(ptr, len, primitive->common.type);
2267     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2268     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2269     CsrUint16Ser(ptr, len, (u16) primitive->status);
2270     return(ptr);
2271 }
2272
2273
2274 void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, size_t length)
2275 {
2276     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm), GFP_KERNEL);
2277     size_t offset;
2278     offset = 0;
2279
2280     CsrUint16Des(&primitive->common.type, buffer, &offset);
2281     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2282     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2283     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2284
2285     return primitive;
2286 }
2287
2288
2289 size_t CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
2290 {
2291     size_t bufferSize = 2;
2292
2293     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2294     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2295     bufferSize += 2; /* u16 primitive->interfaceTag */
2296     bufferSize += 2; /* CsrResult primitive->status */
2297     return bufferSize;
2298 }
2299
2300
2301 u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, size_t *len, void *msg)
2302 {
2303     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
2304     *len = 0;
2305     CsrUint16Ser(ptr, len, primitive->common.type);
2306     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2307     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2308     CsrUint16Ser(ptr, len, (u16) primitive->status);
2309     return(ptr);
2310 }
2311
2312
2313 void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, size_t length)
2314 {
2315     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm), GFP_KERNEL);
2316     size_t offset;
2317     offset = 0;
2318
2319     CsrUint16Des(&primitive->common.type, buffer, &offset);
2320     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2321     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2322     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2323
2324     return primitive;
2325 }
2326
2327
2328 size_t CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
2329 {
2330     size_t bufferSize = 2;
2331
2332     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
2333     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2334     bufferSize += 2; /* u16 primitive->interfaceTag */
2335     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
2336     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2337     bufferSize += 2; /* CsrResult primitive->status */
2338     return bufferSize;
2339 }
2340
2341
2342 u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, size_t *len, void *msg)
2343 {
2344     CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
2345     *len = 0;
2346     CsrUint16Ser(ptr, len, primitive->common.type);
2347     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2348     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2349     CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
2350     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2351     CsrUint16Ser(ptr, len, (u16) primitive->status);
2352     return(ptr);
2353 }
2354
2355
2356 void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, size_t length)
2357 {
2358     CsrWifiRouterCtrlBlockAckErrorInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd), GFP_KERNEL);
2359     size_t offset;
2360     offset = 0;
2361
2362     CsrUint16Des(&primitive->common.type, buffer, &offset);
2363     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2364     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2365     CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
2366     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2367     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2368
2369     return primitive;
2370 }
2371
2372
2373 size_t CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
2374 {
2375     size_t bufferSize = 2;
2376
2377     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
2378     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2379     bufferSize += 2; /* u16 primitive->interfaceTag */
2380     bufferSize += 6; /* u8 primitive->staAddress.a[6] */
2381     return bufferSize;
2382 }
2383
2384
2385 u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, size_t *len, void *msg)
2386 {
2387     CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
2388     *len = 0;
2389     CsrUint16Ser(ptr, len, primitive->common.type);
2390     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2391     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2392     CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((u16) (6)));
2393     return(ptr);
2394 }
2395
2396
2397 void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, size_t length)
2398 {
2399     CsrWifiRouterCtrlStaInactiveInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlStaInactiveInd), GFP_KERNEL);
2400     size_t offset;
2401     offset = 0;
2402
2403     CsrUint16Des(&primitive->common.type, buffer, &offset);
2404     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2405     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2406     CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((u16) (6)));
2407
2408     return primitive;
2409 }
2410
2411
2412 size_t CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
2413 {
2414     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) msg;
2415     size_t bufferSize = 2;
2416
2417     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
2418     bufferSize += 2;                       /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2419     bufferSize += 2;                       /* u16 primitive->interfaceTag */
2420     bufferSize += 2;                       /* u16 primitive->signalLength */
2421     bufferSize += primitive->signalLength; /* u8 primitive->signal */
2422     bufferSize += 2;                       /* u16 primitive->dataLength */
2423     bufferSize += primitive->dataLength;   /* u8 primitive->data */
2424     return bufferSize;
2425 }
2426
2427
2428 u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, size_t *len, void *msg)
2429 {
2430     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
2431     *len = 0;
2432     CsrUint16Ser(ptr, len, primitive->common.type);
2433     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2434     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2435     CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
2436     if (primitive->signalLength)
2437     {
2438         CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
2439     }
2440     CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
2441     if (primitive->dataLength)
2442     {
2443         CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
2444     }
2445     return(ptr);
2446 }
2447
2448
2449 void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, size_t length)
2450 {
2451     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd), GFP_KERNEL);
2452     size_t offset;
2453     offset = 0;
2454
2455     CsrUint16Des(&primitive->common.type, buffer, &offset);
2456     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2457     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2458     CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
2459     if (primitive->signalLength)
2460     {
2461         primitive->signal = kmalloc(primitive->signalLength, GFP_KERNEL);
2462         CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
2463     }
2464     else
2465     {
2466         primitive->signal = NULL;
2467     }
2468     CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
2469     if (primitive->dataLength)
2470     {
2471         primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
2472         CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
2473     }
2474     else
2475     {
2476         primitive->data = NULL;
2477     }
2478
2479     return primitive;
2480 }
2481
2482
2483 void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *voidPrimitivePointer)
2484 {
2485     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) voidPrimitivePointer;
2486     kfree(primitive->signal);
2487     kfree(primitive->data);
2488     kfree(primitive);
2489 }
2490
2491
2492 size_t CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
2493 {
2494     size_t bufferSize = 2;
2495
2496     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
2497     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2498     bufferSize += 2; /* u16 primitive->interfaceTag */
2499     bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
2500     bufferSize += 2; /* CsrResult primitive->status */
2501     return bufferSize;
2502 }
2503
2504
2505 u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, size_t *len, void *msg)
2506 {
2507     CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
2508     *len = 0;
2509     CsrUint16Ser(ptr, len, primitive->common.type);
2510     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2511     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2512     CsrUint8Ser(ptr, len, (u8) primitive->mode);
2513     CsrUint16Ser(ptr, len, (u16) primitive->status);
2514     return(ptr);
2515 }
2516
2517
2518 void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, size_t length)
2519 {
2520     CsrWifiRouterCtrlModeSetCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlModeSetCfm), GFP_KERNEL);
2521     size_t offset;
2522     offset = 0;
2523
2524     CsrUint16Des(&primitive->common.type, buffer, &offset);
2525     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2526     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2527     CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
2528     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2529
2530     return primitive;
2531 }
2532
2533
2534 size_t CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
2535 {
2536     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) msg;
2537     size_t bufferSize = 2;
2538
2539     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
2540     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2541     bufferSize += 2;                     /* u16 primitive->interfaceTag */
2542     bufferSize += 2;                     /* u16 primitive->dataLength */
2543     bufferSize += primitive->dataLength; /* u8 primitive->data */
2544     return bufferSize;
2545 }
2546
2547
2548 u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, size_t *len, void *msg)
2549 {
2550     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
2551     *len = 0;
2552     CsrUint16Ser(ptr, len, primitive->common.type);
2553     CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2554     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2555     CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
2556     if (primitive->dataLength)
2557     {
2558         CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
2559     }
2560     return(ptr);
2561 }
2562
2563
2564 void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, size_t length)
2565 {
2566     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd), GFP_KERNEL);
2567     size_t offset;
2568     offset = 0;
2569
2570     CsrUint16Des(&primitive->common.type, buffer, &offset);
2571     CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2572     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2573     CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
2574     if (primitive->dataLength)
2575     {
2576         primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
2577         CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
2578     }
2579     else
2580     {
2581         primitive->data = NULL;
2582     }
2583
2584     return primitive;
2585 }
2586
2587
2588 void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *voidPrimitivePointer)
2589 {
2590     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) voidPrimitivePointer;
2591     kfree(primitive->data);
2592     kfree(primitive);
2593 }
2594
2595