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