1 /*****************************************************************************
3 (c) Cambridge Silicon Radio Limited 2012
4 All rights reserved and confidential information of CSR
6 Refer to LICENSE.txt included with this source for details
9 *****************************************************************************/
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_wifi_router_ctrl_prim.h"
16 #include "csr_wifi_router_ctrl_serialize.h"
18 void CsrWifiRouterCtrlPfree(void *ptr)
24 size_t CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
26 size_t bufferSize = 2;
28 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
29 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
30 bufferSize += 2; /* CsrWifiRouterCtrlLowPowerMode primitive->mode */
31 bufferSize += 1; /* u8 primitive->wakeHost */
36 u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, size_t *len, void *msg)
38 CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
40 CsrUint16Ser(ptr, len, primitive->common.type);
41 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
42 CsrUint16Ser(ptr, len, (u16) primitive->mode);
43 CsrUint8Ser(ptr, len, (u8) primitive->wakeHost);
48 void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, size_t length)
50 CsrWifiRouterCtrlConfigurePowerModeReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq), GFP_KERNEL);
54 CsrUint16Des(&primitive->common.type, buffer, &offset);
55 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
56 CsrUint16Des((u16 *) &primitive->mode, buffer, &offset);
57 CsrUint8Des((u8 *) &primitive->wakeHost, buffer, &offset);
63 size_t CsrWifiRouterCtrlHipReqSizeof(void *msg)
65 CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) msg;
66 size_t bufferSize = 2;
68 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
69 bufferSize += 2; /* u16 primitive->mlmeCommandLength */
70 bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
71 bufferSize += 2; /* u16 primitive->dataRef1Length */
72 bufferSize += primitive->dataRef1Length; /* u8 primitive->dataRef1 */
73 bufferSize += 2; /* u16 primitive->dataRef2Length */
74 bufferSize += primitive->dataRef2Length; /* u8 primitive->dataRef2 */
79 u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, size_t *len, void *msg)
81 CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
83 CsrUint16Ser(ptr, len, primitive->common.type);
84 CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
85 if (primitive->mlmeCommandLength)
87 CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
89 CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
90 if (primitive->dataRef1Length)
92 CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
94 CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
95 if (primitive->dataRef2Length)
97 CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
103 void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, size_t length)
105 CsrWifiRouterCtrlHipReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlHipReq), GFP_KERNEL);
109 CsrUint16Des(&primitive->common.type, buffer, &offset);
110 CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
111 if (primitive->mlmeCommandLength)
113 primitive->mlmeCommand = kmalloc(primitive->mlmeCommandLength, GFP_KERNEL);
114 CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
118 primitive->mlmeCommand = NULL;
120 CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
121 if (primitive->dataRef1Length)
123 primitive->dataRef1 = kmalloc(primitive->dataRef1Length, GFP_KERNEL);
124 CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
128 primitive->dataRef1 = NULL;
130 CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
131 if (primitive->dataRef2Length)
133 primitive->dataRef2 = kmalloc(primitive->dataRef2Length, GFP_KERNEL);
134 CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
138 primitive->dataRef2 = NULL;
145 void CsrWifiRouterCtrlHipReqSerFree(void *voidPrimitivePointer)
147 CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) voidPrimitivePointer;
148 kfree(primitive->mlmeCommand);
149 kfree(primitive->dataRef1);
150 kfree(primitive->dataRef2);
155 size_t CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
157 size_t bufferSize = 2;
159 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
160 bufferSize += 2; /* u16 primitive->interfaceTag */
161 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
162 bufferSize += 1; /* CsrWifiRouterCtrlMediaStatus primitive->mediaStatus */
167 u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, size_t *len, void *msg)
169 CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
171 CsrUint16Ser(ptr, len, primitive->common.type);
172 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
173 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
174 CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
179 void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, size_t length)
181 CsrWifiRouterCtrlMediaStatusReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMediaStatusReq), GFP_KERNEL);
185 CsrUint16Des(&primitive->common.type, buffer, &offset);
186 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
187 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
188 CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
194 size_t CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
196 CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) msg;
197 size_t bufferSize = 2;
199 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
200 bufferSize += 2; /* u16 primitive->interfaceTag */
201 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
202 bufferSize += 2; /* CsrResult primitive->status */
203 bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
204 bufferSize += 1; /* u8 primitive->getAddressesCount */
207 for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
209 bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
216 u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, size_t *len, void *msg)
218 CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
220 CsrUint16Ser(ptr, len, primitive->common.type);
221 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
222 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
223 CsrUint16Ser(ptr, len, (u16) primitive->status);
224 CsrUint8Ser(ptr, len, (u8) primitive->action);
225 CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
228 for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
230 CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
237 void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, size_t length)
239 CsrWifiRouterCtrlMulticastAddressRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes), GFP_KERNEL);
243 CsrUint16Des(&primitive->common.type, buffer, &offset);
244 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
245 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
246 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
247 CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
248 CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
249 primitive->getAddresses = NULL;
250 if (primitive->getAddressesCount)
252 primitive->getAddresses = kmalloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount, GFP_KERNEL);
256 for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
258 CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
266 void CsrWifiRouterCtrlMulticastAddressResSerFree(void *voidPrimitivePointer)
268 CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) voidPrimitivePointer;
269 kfree(primitive->getAddresses);
274 size_t CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
276 size_t bufferSize = 2;
278 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
279 bufferSize += 2; /* u16 primitive->interfaceTag */
280 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
281 bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
282 bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
283 bufferSize += 6; /* u8 primitive->macAddress.a[6] */
284 bufferSize += 1; /* u8 primitive->setProtection */
289 u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, size_t *len, void *msg)
291 CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
293 CsrUint16Ser(ptr, len, primitive->common.type);
294 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
295 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
296 CsrUint16Ser(ptr, len, (u16) primitive->uncontrolledPortAction);
297 CsrUint16Ser(ptr, len, (u16) primitive->controlledPortAction);
298 CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
299 CsrUint8Ser(ptr, len, (u8) primitive->setProtection);
304 void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, size_t length)
306 CsrWifiRouterCtrlPortConfigureReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPortConfigureReq), GFP_KERNEL);
310 CsrUint16Des(&primitive->common.type, buffer, &offset);
311 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
312 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
313 CsrUint16Des((u16 *) &primitive->uncontrolledPortAction, buffer, &offset);
314 CsrUint16Des((u16 *) &primitive->controlledPortAction, buffer, &offset);
315 CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
316 CsrUint8Des((u8 *) &primitive->setProtection, buffer, &offset);
322 size_t CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
324 size_t bufferSize = 2;
326 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
327 bufferSize += 2; /* u16 primitive->interfaceTag */
328 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
329 bufferSize += 2; /* CsrWifiRouterCtrlQoSControl primitive->control */
330 bufferSize += 1; /* CsrWifiRouterCtrlQueueConfigMask primitive->queueConfig */
335 u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, size_t *len, void *msg)
337 CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
339 CsrUint16Ser(ptr, len, primitive->common.type);
340 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
341 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
342 CsrUint16Ser(ptr, len, (u16) primitive->control);
343 CsrUint8Ser(ptr, len, (u8) primitive->queueConfig);
348 void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, size_t length)
350 CsrWifiRouterCtrlQosControlReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlQosControlReq), GFP_KERNEL);
354 CsrUint16Des(&primitive->common.type, buffer, &offset);
355 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
356 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
357 CsrUint16Des((u16 *) &primitive->control, buffer, &offset);
358 CsrUint8Des((u8 *) &primitive->queueConfig, buffer, &offset);
364 size_t CsrWifiRouterCtrlSuspendResSizeof(void *msg)
366 size_t bufferSize = 2;
368 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
369 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
370 bufferSize += 2; /* CsrResult primitive->status */
375 u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, size_t *len, void *msg)
377 CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
379 CsrUint16Ser(ptr, len, primitive->common.type);
380 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
381 CsrUint16Ser(ptr, len, (u16) primitive->status);
386 void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, size_t length)
388 CsrWifiRouterCtrlSuspendRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlSuspendRes), GFP_KERNEL);
392 CsrUint16Des(&primitive->common.type, buffer, &offset);
393 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
394 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
400 size_t CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
402 CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) msg;
403 size_t bufferSize = 2;
405 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
406 bufferSize += 2; /* u16 primitive->interfaceTag */
407 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
408 bufferSize += 2; /* u16 primitive->tclasLength */
409 bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
414 u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, size_t *len, void *msg)
416 CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
418 CsrUint16Ser(ptr, len, primitive->common.type);
419 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
420 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
421 CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
422 if (primitive->tclasLength)
424 CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
430 void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, size_t length)
432 CsrWifiRouterCtrlTclasAddReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasAddReq), GFP_KERNEL);
436 CsrUint16Des(&primitive->common.type, buffer, &offset);
437 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
438 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
439 CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
440 if (primitive->tclasLength)
442 primitive->tclas = kmalloc(primitive->tclasLength, GFP_KERNEL);
443 CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
447 primitive->tclas = NULL;
454 void CsrWifiRouterCtrlTclasAddReqSerFree(void *voidPrimitivePointer)
456 CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) voidPrimitivePointer;
457 kfree(primitive->tclas);
462 size_t CsrWifiRouterCtrlResumeResSizeof(void *msg)
464 size_t bufferSize = 2;
466 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
467 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
468 bufferSize += 2; /* CsrResult primitive->status */
473 u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, size_t *len, void *msg)
475 CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
477 CsrUint16Ser(ptr, len, primitive->common.type);
478 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
479 CsrUint16Ser(ptr, len, (u16) primitive->status);
484 void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, size_t length)
486 CsrWifiRouterCtrlResumeRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlResumeRes), GFP_KERNEL);
490 CsrUint16Des(&primitive->common.type, buffer, &offset);
491 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
492 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
498 size_t CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
500 CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) msg;
501 size_t bufferSize = 2;
503 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
504 bufferSize += 2; /* u16 primitive->interfaceTag */
505 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
506 bufferSize += 2; /* u16 primitive->tclasLength */
507 bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
512 u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, size_t *len, void *msg)
514 CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
516 CsrUint16Ser(ptr, len, primitive->common.type);
517 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
518 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
519 CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
520 if (primitive->tclasLength)
522 CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
528 void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, size_t length)
530 CsrWifiRouterCtrlTclasDelReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasDelReq), GFP_KERNEL);
534 CsrUint16Des(&primitive->common.type, buffer, &offset);
535 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
536 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
537 CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
538 if (primitive->tclasLength)
540 primitive->tclas = kmalloc(primitive->tclasLength, GFP_KERNEL);
541 CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
545 primitive->tclas = NULL;
552 void CsrWifiRouterCtrlTclasDelReqSerFree(void *voidPrimitivePointer)
554 CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) voidPrimitivePointer;
555 kfree(primitive->tclas);
560 size_t CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
562 size_t bufferSize = 2;
564 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
565 bufferSize += 2; /* u16 primitive->interfaceTag */
566 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
567 bufferSize += 1; /* CsrWifiRouterCtrlTrafficType primitive->trafficType */
568 bufferSize += 2; /* u16 primitive->period */
573 u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, size_t *len, void *msg)
575 CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
577 CsrUint16Ser(ptr, len, primitive->common.type);
578 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
579 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
580 CsrUint8Ser(ptr, len, (u8) primitive->trafficType);
581 CsrUint16Ser(ptr, len, (u16) primitive->period);
586 void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, size_t length)
588 CsrWifiRouterCtrlTrafficClassificationReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq), GFP_KERNEL);
592 CsrUint16Des(&primitive->common.type, buffer, &offset);
593 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
594 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
595 CsrUint8Des((u8 *) &primitive->trafficType, buffer, &offset);
596 CsrUint16Des((u16 *) &primitive->period, buffer, &offset);
602 size_t CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
604 size_t bufferSize = 2;
606 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
607 bufferSize += 2; /* u16 primitive->interfaceTag */
608 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
609 bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
610 bufferSize += 2; /* u16 primitive->config.packetFilter */
611 bufferSize += 4; /* u32 primitive->config.customFilter.etherType */
612 bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
613 bufferSize += 4; /* u32 primitive->config.customFilter.udpSourcePort */
614 bufferSize += 4; /* u32 primitive->config.customFilter.udpDestPort */
619 u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, size_t *len, void *msg)
621 CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
623 CsrUint16Ser(ptr, len, primitive->common.type);
624 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
625 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
626 CsrUint16Ser(ptr, len, (u16) primitive->trafficConfigType);
627 CsrUint16Ser(ptr, len, (u16) primitive->config.packetFilter);
628 CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.etherType);
629 CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
630 CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.udpSourcePort);
631 CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.udpDestPort);
636 void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, size_t length)
638 CsrWifiRouterCtrlTrafficConfigReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq), GFP_KERNEL);
642 CsrUint16Des(&primitive->common.type, buffer, &offset);
643 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
644 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
645 CsrUint16Des((u16 *) &primitive->trafficConfigType, buffer, &offset);
646 CsrUint16Des((u16 *) &primitive->config.packetFilter, buffer, &offset);
647 CsrUint32Des((u32 *) &primitive->config.customFilter.etherType, buffer, &offset);
648 CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
649 CsrUint32Des((u32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
650 CsrUint32Des((u32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
656 size_t CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
658 CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) msg;
659 size_t bufferSize = 2;
661 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
662 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
663 bufferSize += 4; /* u32 primitive->dataLength */
664 bufferSize += primitive->dataLength; /* u8 primitive->data */
669 u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, size_t *len, void *msg)
671 CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
673 CsrUint16Ser(ptr, len, primitive->common.type);
674 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
675 CsrUint32Ser(ptr, len, (u32) primitive->dataLength);
676 if (primitive->dataLength)
678 CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
684 void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, size_t length)
686 CsrWifiRouterCtrlWifiOnReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnReq), GFP_KERNEL);
690 CsrUint16Des(&primitive->common.type, buffer, &offset);
691 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
692 CsrUint32Des((u32 *) &primitive->dataLength, buffer, &offset);
693 if (primitive->dataLength)
695 primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
696 CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
700 primitive->data = NULL;
707 void CsrWifiRouterCtrlWifiOnReqSerFree(void *voidPrimitivePointer)
709 CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) voidPrimitivePointer;
710 kfree(primitive->data);
715 size_t CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
717 CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) msg;
718 size_t bufferSize = 2;
720 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 30) */
721 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
722 bufferSize += 2; /* CsrResult primitive->status */
723 bufferSize += 2; /* u16 primitive->numInterfaceAddress */
726 for (i1 = 0; i1 < 2; i1++)
728 bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
731 bufferSize += 4; /* u32 primitive->smeVersions.firmwarePatch */
732 bufferSize += (primitive->smeVersions.smeBuild ? strlen(primitive->smeVersions.smeBuild) : 0) + 1; /* char* primitive->smeVersions.smeBuild (0 byte len + 1 for NULL Term) */
733 bufferSize += 4; /* u32 primitive->smeVersions.smeHip */
734 bufferSize += 1; /* u8 primitive->scheduledInterrupt */
739 u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, size_t *len, void *msg)
741 CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
743 CsrUint16Ser(ptr, len, primitive->common.type);
744 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
745 CsrUint16Ser(ptr, len, (u16) primitive->status);
746 CsrUint16Ser(ptr, len, (u16) primitive->numInterfaceAddress);
749 for (i1 = 0; i1 < 2; i1++)
751 CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
754 CsrUint32Ser(ptr, len, (u32) primitive->smeVersions.firmwarePatch);
755 CsrCharStringSer(ptr, len, primitive->smeVersions.smeBuild);
756 CsrUint32Ser(ptr, len, (u32) primitive->smeVersions.smeHip);
757 CsrUint8Ser(ptr, len, (u8) primitive->scheduledInterrupt);
762 void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, size_t length)
764 CsrWifiRouterCtrlWifiOnRes *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnRes), GFP_KERNEL);
768 CsrUint16Des(&primitive->common.type, buffer, &offset);
769 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
770 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
771 CsrUint16Des((u16 *) &primitive->numInterfaceAddress, buffer, &offset);
774 for (i1 = 0; i1 < 2; i1++)
776 CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
779 CsrUint32Des((u32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
780 CsrCharStringDes(&primitive->smeVersions.smeBuild, buffer, &offset);
781 CsrUint32Des((u32 *) &primitive->smeVersions.smeHip, buffer, &offset);
782 CsrUint8Des((u8 *) &primitive->scheduledInterrupt, buffer, &offset);
788 void CsrWifiRouterCtrlWifiOnResSerFree(void *voidPrimitivePointer)
790 CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) voidPrimitivePointer;
791 kfree(primitive->smeVersions.smeBuild);
796 size_t CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
798 size_t bufferSize = 2;
800 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
801 bufferSize += 2; /* u16 primitive->interfaceTag */
802 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
807 u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, size_t *len, void *msg)
809 CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
811 CsrUint16Ser(ptr, len, primitive->common.type);
812 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
813 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
818 void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, size_t length)
820 CsrWifiRouterCtrlM4TransmitReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlM4TransmitReq), GFP_KERNEL);
824 CsrUint16Des(&primitive->common.type, buffer, &offset);
825 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
826 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
832 size_t CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
834 size_t bufferSize = 2;
836 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
837 bufferSize += 2; /* u16 primitive->interfaceTag */
838 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
839 bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
840 bufferSize += 6; /* u8 primitive->bssid.a[6] */
841 bufferSize += 1; /* u8 primitive->protection */
842 bufferSize += 1; /* u8 primitive->intraBssDistEnabled */
847 u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, size_t *len, void *msg)
849 CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
851 CsrUint16Ser(ptr, len, primitive->common.type);
852 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
853 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
854 CsrUint8Ser(ptr, len, (u8) primitive->mode);
855 CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((u16) (6)));
856 CsrUint8Ser(ptr, len, (u8) primitive->protection);
857 CsrUint8Ser(ptr, len, (u8) primitive->intraBssDistEnabled);
862 void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, size_t length)
864 CsrWifiRouterCtrlModeSetReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlModeSetReq), GFP_KERNEL);
868 CsrUint16Des(&primitive->common.type, buffer, &offset);
869 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
870 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
871 CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
872 CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((u16) (6)));
873 CsrUint8Des((u8 *) &primitive->protection, buffer, &offset);
874 CsrUint8Des((u8 *) &primitive->intraBssDistEnabled, buffer, &offset);
880 size_t CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
882 size_t bufferSize = 2;
884 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
885 bufferSize += 2; /* u16 primitive->interfaceTag */
886 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
887 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
888 bufferSize += 2; /* u16 primitive->associationId */
889 bufferSize += 1; /* u8 primitive->staInfo.wmmOrQosEnabled */
890 bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
891 bufferSize += 1; /* u8 primitive->staInfo.maxSpLength */
892 bufferSize += 2; /* u16 primitive->staInfo.listenIntervalInTus */
897 u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, size_t *len, void *msg)
899 CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
901 CsrUint16Ser(ptr, len, primitive->common.type);
902 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
903 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
904 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
905 CsrUint16Ser(ptr, len, (u16) primitive->associationId);
906 CsrUint8Ser(ptr, len, (u8) primitive->staInfo.wmmOrQosEnabled);
907 CsrUint16Ser(ptr, len, (u16) primitive->staInfo.powersaveMode);
908 CsrUint8Ser(ptr, len, (u8) primitive->staInfo.maxSpLength);
909 CsrUint16Ser(ptr, len, (u16) primitive->staInfo.listenIntervalInTus);
914 void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, size_t length)
916 CsrWifiRouterCtrlPeerAddReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerAddReq), GFP_KERNEL);
920 CsrUint16Des(&primitive->common.type, buffer, &offset);
921 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
922 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
923 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
924 CsrUint16Des((u16 *) &primitive->associationId, buffer, &offset);
925 CsrUint8Des((u8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
926 CsrUint16Des((u16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
927 CsrUint8Des((u8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
928 CsrUint16Des((u16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
934 size_t CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
936 size_t bufferSize = 2;
938 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
939 bufferSize += 2; /* u16 primitive->interfaceTag */
940 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
941 bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
946 u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, size_t *len, void *msg)
948 CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
950 CsrUint16Ser(ptr, len, primitive->common.type);
951 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
952 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
953 CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
958 void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, size_t length)
960 CsrWifiRouterCtrlPeerDelReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerDelReq), GFP_KERNEL);
964 CsrUint16Des(&primitive->common.type, buffer, &offset);
965 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
966 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
967 CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
973 size_t CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
975 size_t bufferSize = 2;
977 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
978 bufferSize += 2; /* u16 primitive->interfaceTag */
979 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
980 bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
981 bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->powersaveMode */
986 u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, size_t *len, void *msg)
988 CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
990 CsrUint16Ser(ptr, len, primitive->common.type);
991 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
992 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
993 CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
994 CsrUint16Ser(ptr, len, (u16) primitive->powersaveMode);
999 void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, size_t length)
1001 CsrWifiRouterCtrlPeerUpdateReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq), GFP_KERNEL);
1005 CsrUint16Des(&primitive->common.type, buffer, &offset);
1006 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1007 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1008 CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
1009 CsrUint16Des((u16 *) &primitive->powersaveMode, buffer, &offset);
1015 size_t CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
1017 size_t bufferSize = 2;
1019 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
1020 bufferSize += 2; /* u16 primitive->interfaceTag */
1021 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1022 bufferSize += 6; /* u8 primitive->macAddress.a[6] */
1023 bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
1024 bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
1025 bufferSize += 2; /* u16 primitive->bufferSize */
1026 bufferSize += 2; /* u16 primitive->timeout */
1027 bufferSize += 2; /* u16 primitive->ssn */
1032 u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, size_t *len, void *msg)
1034 CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
1036 CsrUint16Ser(ptr, len, primitive->common.type);
1037 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1038 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1039 CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
1040 CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
1041 CsrUint8Ser(ptr, len, (u8) primitive->role);
1042 CsrUint16Ser(ptr, len, (u16) primitive->bufferSize);
1043 CsrUint16Ser(ptr, len, (u16) primitive->timeout);
1044 CsrUint16Ser(ptr, len, (u16) primitive->ssn);
1049 void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, size_t length)
1051 CsrWifiRouterCtrlBlockAckEnableReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq), GFP_KERNEL);
1055 CsrUint16Des(&primitive->common.type, buffer, &offset);
1056 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1057 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1058 CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
1059 CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
1060 CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
1061 CsrUint16Des((u16 *) &primitive->bufferSize, buffer, &offset);
1062 CsrUint16Des((u16 *) &primitive->timeout, buffer, &offset);
1063 CsrUint16Des((u16 *) &primitive->ssn, buffer, &offset);
1069 size_t CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
1071 size_t bufferSize = 2;
1073 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1074 bufferSize += 2; /* u16 primitive->interfaceTag */
1075 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1076 bufferSize += 6; /* u8 primitive->macAddress.a[6] */
1077 bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
1078 bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
1083 u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, size_t *len, void *msg)
1085 CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
1087 CsrUint16Ser(ptr, len, primitive->common.type);
1088 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1089 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1090 CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
1091 CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
1092 CsrUint8Ser(ptr, len, (u8) primitive->role);
1097 void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, size_t length)
1099 CsrWifiRouterCtrlBlockAckDisableReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq), GFP_KERNEL);
1103 CsrUint16Des(&primitive->common.type, buffer, &offset);
1104 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1105 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1106 CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
1107 CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
1108 CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
1114 size_t CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
1116 CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) msg;
1117 size_t bufferSize = 2;
1119 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
1120 bufferSize += 2; /* u16 primitive->interfaceTag */
1121 bufferSize += 2; /* u16 primitive->signalLength */
1122 bufferSize += primitive->signalLength; /* u8 primitive->signal */
1123 bufferSize += 2; /* u16 primitive->dataLength */
1124 bufferSize += primitive->dataLength; /* u8 primitive->data */
1129 u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, size_t *len, void *msg)
1131 CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
1133 CsrUint16Ser(ptr, len, primitive->common.type);
1134 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1135 CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
1136 if (primitive->signalLength)
1138 CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
1140 CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
1141 if (primitive->dataLength)
1143 CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
1149 void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, size_t length)
1151 CsrWifiRouterCtrlWapiRxPktReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq), GFP_KERNEL);
1155 CsrUint16Des(&primitive->common.type, buffer, &offset);
1156 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1157 CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
1158 if (primitive->signalLength)
1160 primitive->signal = kmalloc(primitive->signalLength, GFP_KERNEL);
1161 CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
1165 primitive->signal = NULL;
1167 CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
1168 if (primitive->dataLength)
1170 primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
1171 CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
1175 primitive->data = NULL;
1182 void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *voidPrimitivePointer)
1184 CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) voidPrimitivePointer;
1185 kfree(primitive->signal);
1186 kfree(primitive->data);
1191 size_t CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
1193 CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) msg;
1194 size_t bufferSize = 2;
1196 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
1197 bufferSize += 2; /* u16 primitive->interfaceTag */
1198 bufferSize += 2; /* u16 primitive->dataLength */
1199 bufferSize += primitive->dataLength; /* u8 primitive->data */
1204 u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, size_t *len, void *msg)
1206 CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
1208 CsrUint16Ser(ptr, len, primitive->common.type);
1209 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1210 CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
1211 if (primitive->dataLength)
1213 CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
1219 void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, size_t length)
1221 CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq), GFP_KERNEL);
1225 CsrUint16Des(&primitive->common.type, buffer, &offset);
1226 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1227 CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
1228 if (primitive->dataLength)
1230 primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
1231 CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
1235 primitive->data = NULL;
1242 void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *voidPrimitivePointer)
1244 CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) voidPrimitivePointer;
1245 kfree(primitive->data);
1250 size_t CsrWifiRouterCtrlHipIndSizeof(void *msg)
1252 CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) msg;
1253 size_t bufferSize = 2;
1255 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
1256 bufferSize += 2; /* u16 primitive->mlmeCommandLength */
1257 bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
1258 bufferSize += 2; /* u16 primitive->dataRef1Length */
1259 bufferSize += primitive->dataRef1Length; /* u8 primitive->dataRef1 */
1260 bufferSize += 2; /* u16 primitive->dataRef2Length */
1261 bufferSize += primitive->dataRef2Length; /* u8 primitive->dataRef2 */
1266 u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, size_t *len, void *msg)
1268 CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
1270 CsrUint16Ser(ptr, len, primitive->common.type);
1271 CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
1272 if (primitive->mlmeCommandLength)
1274 CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
1276 CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
1277 if (primitive->dataRef1Length)
1279 CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
1281 CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
1282 if (primitive->dataRef2Length)
1284 CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
1290 void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, size_t length)
1292 CsrWifiRouterCtrlHipInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlHipInd), GFP_KERNEL);
1296 CsrUint16Des(&primitive->common.type, buffer, &offset);
1297 CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
1298 if (primitive->mlmeCommandLength)
1300 primitive->mlmeCommand = kmalloc(primitive->mlmeCommandLength, GFP_KERNEL);
1301 CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
1305 primitive->mlmeCommand = NULL;
1307 CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
1308 if (primitive->dataRef1Length)
1310 primitive->dataRef1 = kmalloc(primitive->dataRef1Length, GFP_KERNEL);
1311 CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
1315 primitive->dataRef1 = NULL;
1317 CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
1318 if (primitive->dataRef2Length)
1320 primitive->dataRef2 = kmalloc(primitive->dataRef2Length, GFP_KERNEL);
1321 CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
1325 primitive->dataRef2 = NULL;
1332 void CsrWifiRouterCtrlHipIndSerFree(void *voidPrimitivePointer)
1334 CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) voidPrimitivePointer;
1335 kfree(primitive->mlmeCommand);
1336 kfree(primitive->dataRef1);
1337 kfree(primitive->dataRef2);
1342 size_t CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
1344 CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) msg;
1345 size_t bufferSize = 2;
1347 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1348 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1349 bufferSize += 2; /* u16 primitive->interfaceTag */
1350 bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
1351 bufferSize += 1; /* u8 primitive->setAddressesCount */
1354 for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
1356 bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
1363 u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, size_t *len, void *msg)
1365 CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
1367 CsrUint16Ser(ptr, len, primitive->common.type);
1368 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1369 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1370 CsrUint8Ser(ptr, len, (u8) primitive->action);
1371 CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
1374 for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
1376 CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
1383 void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, size_t length)
1385 CsrWifiRouterCtrlMulticastAddressInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd), GFP_KERNEL);
1389 CsrUint16Des(&primitive->common.type, buffer, &offset);
1390 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1391 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1392 CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
1393 CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
1394 primitive->setAddresses = NULL;
1395 if (primitive->setAddressesCount)
1397 primitive->setAddresses = kmalloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount, GFP_KERNEL);
1401 for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
1403 CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
1411 void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *voidPrimitivePointer)
1413 CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) voidPrimitivePointer;
1414 kfree(primitive->setAddresses);
1419 size_t CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
1421 size_t bufferSize = 2;
1423 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1424 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1425 bufferSize += 2; /* u16 primitive->interfaceTag */
1426 bufferSize += 2; /* CsrResult primitive->status */
1427 bufferSize += 6; /* u8 primitive->macAddress.a[6] */
1432 u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, size_t *len, void *msg)
1434 CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
1436 CsrUint16Ser(ptr, len, primitive->common.type);
1437 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1438 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1439 CsrUint16Ser(ptr, len, (u16) primitive->status);
1440 CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
1445 void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, size_t length)
1447 CsrWifiRouterCtrlPortConfigureCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm), GFP_KERNEL);
1451 CsrUint16Des(&primitive->common.type, buffer, &offset);
1452 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1453 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1454 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1455 CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
1461 size_t CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
1463 size_t bufferSize = 2;
1465 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
1466 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1467 bufferSize += 1; /* u8 primitive->hardSuspend */
1468 bufferSize += 1; /* u8 primitive->d3Suspend */
1473 u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, size_t *len, void *msg)
1475 CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
1477 CsrUint16Ser(ptr, len, primitive->common.type);
1478 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1479 CsrUint8Ser(ptr, len, (u8) primitive->hardSuspend);
1480 CsrUint8Ser(ptr, len, (u8) primitive->d3Suspend);
1485 void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, size_t length)
1487 CsrWifiRouterCtrlSuspendInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlSuspendInd), GFP_KERNEL);
1491 CsrUint16Des(&primitive->common.type, buffer, &offset);
1492 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1493 CsrUint8Des((u8 *) &primitive->hardSuspend, buffer, &offset);
1494 CsrUint8Des((u8 *) &primitive->d3Suspend, buffer, &offset);
1500 size_t CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
1502 size_t bufferSize = 2;
1504 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
1505 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1506 bufferSize += 2; /* u16 primitive->interfaceTag */
1507 bufferSize += 2; /* CsrResult primitive->status */
1512 u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, size_t *len, void *msg)
1514 CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
1516 CsrUint16Ser(ptr, len, primitive->common.type);
1517 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1518 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1519 CsrUint16Ser(ptr, len, (u16) primitive->status);
1524 void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, size_t length)
1526 CsrWifiRouterCtrlTclasAddCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasAddCfm), GFP_KERNEL);
1530 CsrUint16Des(&primitive->common.type, buffer, &offset);
1531 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1532 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1533 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1539 size_t CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
1541 size_t bufferSize = 2;
1543 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
1544 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1545 bufferSize += 2; /* CsrResult primitive->result */
1550 u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, size_t *len, void *msg)
1552 CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
1554 CsrUint16Ser(ptr, len, primitive->common.type);
1555 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1556 CsrUint16Ser(ptr, len, (u16) primitive->result);
1561 void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, size_t length)
1563 CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm), GFP_KERNEL);
1567 CsrUint16Des(&primitive->common.type, buffer, &offset);
1568 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1569 CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
1575 size_t CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
1577 size_t bufferSize = 2;
1579 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
1580 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1581 bufferSize += 2; /* CsrResult primitive->result */
1582 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteRead primitive->byteRead */
1583 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteWrite primitive->byteWrite */
1584 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioFirmwareDownload primitive->firmwareDownload */
1585 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioReset primitive->reset */
1586 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioCoreDumpPrepare primitive->coreDumpPrepare */
1587 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteBlockRead primitive->byteBlockRead */
1588 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioGpRead16 primitive->gpRead16 */
1589 bufferSize += 4; /* CsrWifiRouterCtrlRawSdioGpWrite16 primitive->gpWrite16 */
1594 u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, size_t *len, void *msg)
1596 CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
1598 CsrUint16Ser(ptr, len, primitive->common.type);
1599 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1600 CsrUint16Ser(ptr, len, (u16) primitive->result);
1601 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteRead */
1602 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteWrite */
1603 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->firmwareDownload */
1604 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->reset */
1605 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->coreDumpPrepare */
1606 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteBlockRead */
1607 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->gpRead16 */
1608 CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->gpWrite16 */
1613 void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, size_t length)
1615 CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm), GFP_KERNEL);
1619 CsrUint16Des(&primitive->common.type, buffer, &offset);
1620 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1621 CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
1622 primitive->byteRead = NULL; /* Special for Function Pointers... */
1624 primitive->byteWrite = NULL; /* Special for Function Pointers... */
1626 primitive->firmwareDownload = NULL; /* Special for Function Pointers... */
1628 primitive->reset = NULL; /* Special for Function Pointers... */
1630 primitive->coreDumpPrepare = NULL; /* Special for Function Pointers... */
1632 primitive->byteBlockRead = NULL; /* Special for Function Pointers... */
1634 primitive->gpRead16 = NULL; /* Special for Function Pointers... */
1636 primitive->gpWrite16 = NULL; /* Special for Function Pointers... */
1643 size_t CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
1645 size_t bufferSize = 2;
1647 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
1648 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1649 bufferSize += 2; /* u16 primitive->interfaceTag */
1650 bufferSize += 2; /* CsrResult primitive->status */
1655 u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, size_t *len, void *msg)
1657 CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
1659 CsrUint16Ser(ptr, len, primitive->common.type);
1660 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1661 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1662 CsrUint16Ser(ptr, len, (u16) primitive->status);
1667 void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, size_t length)
1669 CsrWifiRouterCtrlTclasDelCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTclasDelCfm), GFP_KERNEL);
1673 CsrUint16Des(&primitive->common.type, buffer, &offset);
1674 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1675 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1676 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1682 size_t CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
1684 size_t bufferSize = 2;
1686 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
1687 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1688 bufferSize += 2; /* u16 primitive->interfaceTag */
1689 bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
1690 bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
1691 bufferSize += 6; /* u8 primitive->srcAddress.a[6] */
1696 u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, size_t *len, void *msg)
1698 CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
1700 CsrUint16Ser(ptr, len, primitive->common.type);
1701 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1702 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1703 CsrUint16Ser(ptr, len, (u16) primitive->packetType);
1704 CsrUint16Ser(ptr, len, (u16) primitive->direction);
1705 CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((u16) (6)));
1710 void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, size_t length)
1712 CsrWifiRouterCtrlTrafficProtocolInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd), GFP_KERNEL);
1716 CsrUint16Des(&primitive->common.type, buffer, &offset);
1717 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1718 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1719 CsrUint16Des((u16 *) &primitive->packetType, buffer, &offset);
1720 CsrUint16Des((u16 *) &primitive->direction, buffer, &offset);
1721 CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((u16) (6)));
1727 size_t CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
1729 size_t bufferSize = 2;
1731 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
1732 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1733 bufferSize += 2; /* u16 primitive->interfaceTag */
1734 bufferSize += 4; /* u32 primitive->stats.rxMeanRate */
1735 bufferSize += 4; /* u32 primitive->stats.rxFramesNum */
1736 bufferSize += 4; /* u32 primitive->stats.txFramesNum */
1737 bufferSize += 4; /* u32 primitive->stats.rxBytesCount */
1738 bufferSize += 4; /* u32 primitive->stats.txBytesCount */
1739 bufferSize += 11; /* u8 primitive->stats.intervals[11] */
1744 u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, size_t *len, void *msg)
1746 CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
1748 CsrUint16Ser(ptr, len, primitive->common.type);
1749 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1750 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1751 CsrUint32Ser(ptr, len, (u32) primitive->stats.rxMeanRate);
1752 CsrUint32Ser(ptr, len, (u32) primitive->stats.rxFramesNum);
1753 CsrUint32Ser(ptr, len, (u32) primitive->stats.txFramesNum);
1754 CsrUint32Ser(ptr, len, (u32) primitive->stats.rxBytesCount);
1755 CsrUint32Ser(ptr, len, (u32) primitive->stats.txBytesCount);
1756 CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((u16) (11)));
1761 void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, size_t length)
1763 CsrWifiRouterCtrlTrafficSampleInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd), GFP_KERNEL);
1767 CsrUint16Des(&primitive->common.type, buffer, &offset);
1768 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1769 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1770 CsrUint32Des((u32 *) &primitive->stats.rxMeanRate, buffer, &offset);
1771 CsrUint32Des((u32 *) &primitive->stats.rxFramesNum, buffer, &offset);
1772 CsrUint32Des((u32 *) &primitive->stats.txFramesNum, buffer, &offset);
1773 CsrUint32Des((u32 *) &primitive->stats.rxBytesCount, buffer, &offset);
1774 CsrUint32Des((u32 *) &primitive->stats.txBytesCount, buffer, &offset);
1775 CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((u16) (11)));
1781 size_t CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
1783 CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) msg;
1784 size_t bufferSize = 2;
1786 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 27) */
1787 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1788 bufferSize += 2; /* CsrResult primitive->status */
1789 bufferSize += 4; /* u32 primitive->versions.chipId */
1790 bufferSize += 4; /* u32 primitive->versions.chipVersion */
1791 bufferSize += 4; /* u32 primitive->versions.firmwareBuild */
1792 bufferSize += 4; /* u32 primitive->versions.firmwareHip */
1793 bufferSize += (primitive->versions.routerBuild ? strlen(primitive->versions.routerBuild) : 0) + 1; /* char* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
1794 bufferSize += 4; /* u32 primitive->versions.routerHip */
1799 u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, size_t *len, void *msg)
1801 CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
1803 CsrUint16Ser(ptr, len, primitive->common.type);
1804 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1805 CsrUint16Ser(ptr, len, (u16) primitive->status);
1806 CsrUint32Ser(ptr, len, (u32) primitive->versions.chipId);
1807 CsrUint32Ser(ptr, len, (u32) primitive->versions.chipVersion);
1808 CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareBuild);
1809 CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareHip);
1810 CsrCharStringSer(ptr, len, primitive->versions.routerBuild);
1811 CsrUint32Ser(ptr, len, (u32) primitive->versions.routerHip);
1816 void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, size_t length)
1818 CsrWifiRouterCtrlWifiOnInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnInd), GFP_KERNEL);
1822 CsrUint16Des(&primitive->common.type, buffer, &offset);
1823 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1824 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1825 CsrUint32Des((u32 *) &primitive->versions.chipId, buffer, &offset);
1826 CsrUint32Des((u32 *) &primitive->versions.chipVersion, buffer, &offset);
1827 CsrUint32Des((u32 *) &primitive->versions.firmwareBuild, buffer, &offset);
1828 CsrUint32Des((u32 *) &primitive->versions.firmwareHip, buffer, &offset);
1829 CsrCharStringDes(&primitive->versions.routerBuild, buffer, &offset);
1830 CsrUint32Des((u32 *) &primitive->versions.routerHip, buffer, &offset);
1836 void CsrWifiRouterCtrlWifiOnIndSerFree(void *voidPrimitivePointer)
1838 CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) voidPrimitivePointer;
1839 kfree(primitive->versions.routerBuild);
1844 size_t CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
1846 size_t bufferSize = 2;
1848 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
1849 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1850 bufferSize += 2; /* CsrResult primitive->status */
1855 u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, size_t *len, void *msg)
1857 CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
1859 CsrUint16Ser(ptr, len, primitive->common.type);
1860 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1861 CsrUint16Ser(ptr, len, (u16) primitive->status);
1866 void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, size_t length)
1868 CsrWifiRouterCtrlWifiOnCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWifiOnCfm), GFP_KERNEL);
1872 CsrUint16Des(&primitive->common.type, buffer, &offset);
1873 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1874 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1880 size_t CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
1882 size_t bufferSize = 2;
1884 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
1885 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1886 bufferSize += 2; /* u16 primitive->interfaceTag */
1887 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
1892 u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, size_t *len, void *msg)
1894 CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
1896 CsrUint16Ser(ptr, len, primitive->common.type);
1897 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1898 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1899 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
1904 void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, size_t length)
1906 CsrWifiRouterCtrlM4ReadyToSendInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd), GFP_KERNEL);
1910 CsrUint16Des(&primitive->common.type, buffer, &offset);
1911 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1912 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1913 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
1919 size_t CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
1921 size_t bufferSize = 2;
1923 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
1924 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1925 bufferSize += 2; /* u16 primitive->interfaceTag */
1926 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
1927 bufferSize += 2; /* CsrResult primitive->status */
1932 u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, size_t *len, void *msg)
1934 CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
1936 CsrUint16Ser(ptr, len, primitive->common.type);
1937 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1938 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1939 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
1940 CsrUint16Ser(ptr, len, (u16) primitive->status);
1945 void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, size_t length)
1947 CsrWifiRouterCtrlM4TransmittedInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd), GFP_KERNEL);
1951 CsrUint16Des(&primitive->common.type, buffer, &offset);
1952 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1953 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1954 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
1955 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
1961 size_t CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
1963 size_t bufferSize = 2;
1965 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
1966 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
1967 bufferSize += 2; /* u16 primitive->interfaceTag */
1968 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
1969 bufferSize += 1; /* u8 primitive->unicastPdu */
1974 u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, size_t *len, void *msg)
1976 CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
1978 CsrUint16Ser(ptr, len, primitive->common.type);
1979 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
1980 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
1981 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
1982 CsrUint8Ser(ptr, len, (u8) primitive->unicastPdu);
1987 void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, size_t length)
1989 CsrWifiRouterCtrlMicFailureInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlMicFailureInd), GFP_KERNEL);
1993 CsrUint16Des(&primitive->common.type, buffer, &offset);
1994 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
1995 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
1996 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
1997 CsrUint8Des((u8 *) &primitive->unicastPdu, buffer, &offset);
2003 size_t CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
2005 size_t bufferSize = 2;
2007 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
2008 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2009 bufferSize += 2; /* u16 primitive->interfaceTag */
2010 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2011 bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
2016 u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, size_t *len, void *msg)
2018 CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
2020 CsrUint16Ser(ptr, len, primitive->common.type);
2021 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2022 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2023 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2024 CsrUint8Ser(ptr, len, (u8) primitive->peerStatus);
2029 void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, size_t length)
2031 CsrWifiRouterCtrlConnectedInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlConnectedInd), GFP_KERNEL);
2035 CsrUint16Des(&primitive->common.type, buffer, &offset);
2036 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2037 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2038 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2039 CsrUint8Des((u8 *) &primitive->peerStatus, buffer, &offset);
2045 size_t CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
2047 size_t bufferSize = 2;
2049 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 19) */
2050 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2051 bufferSize += 2; /* u16 primitive->interfaceTag */
2052 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2053 bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
2054 bufferSize += 2; /* CsrResult primitive->status */
2059 u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, size_t *len, void *msg)
2061 CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
2063 CsrUint16Ser(ptr, len, primitive->common.type);
2064 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2065 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2066 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2067 CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
2068 CsrUint16Ser(ptr, len, (u16) primitive->status);
2073 void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, size_t length)
2075 CsrWifiRouterCtrlPeerAddCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerAddCfm), GFP_KERNEL);
2079 CsrUint16Des(&primitive->common.type, buffer, &offset);
2080 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2081 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2082 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2083 CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
2084 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2090 size_t CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
2092 size_t bufferSize = 2;
2094 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2095 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2096 bufferSize += 2; /* u16 primitive->interfaceTag */
2097 bufferSize += 2; /* CsrResult primitive->status */
2102 u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, size_t *len, void *msg)
2104 CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
2106 CsrUint16Ser(ptr, len, primitive->common.type);
2107 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2108 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2109 CsrUint16Ser(ptr, len, (u16) primitive->status);
2114 void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, size_t length)
2116 CsrWifiRouterCtrlPeerDelCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerDelCfm), GFP_KERNEL);
2120 CsrUint16Des(&primitive->common.type, buffer, &offset);
2121 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2122 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2123 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2129 size_t CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
2131 size_t bufferSize = 2;
2133 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
2134 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2135 bufferSize += 2; /* u16 primitive->interfaceTag */
2136 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2141 u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, size_t *len, void *msg)
2143 CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
2145 CsrUint16Ser(ptr, len, primitive->common.type);
2146 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2147 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2148 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2153 void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, size_t length)
2155 CsrWifiRouterCtrlUnexpectedFrameInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd), GFP_KERNEL);
2159 CsrUint16Des(&primitive->common.type, buffer, &offset);
2160 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2161 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2162 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2168 size_t CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
2170 size_t bufferSize = 2;
2172 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2173 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2174 bufferSize += 2; /* u16 primitive->interfaceTag */
2175 bufferSize += 2; /* CsrResult primitive->status */
2180 u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, size_t *len, void *msg)
2182 CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
2184 CsrUint16Ser(ptr, len, primitive->common.type);
2185 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2186 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2187 CsrUint16Ser(ptr, len, (u16) primitive->status);
2192 void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, size_t length)
2194 CsrWifiRouterCtrlPeerUpdateCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm), GFP_KERNEL);
2198 CsrUint16Des(&primitive->common.type, buffer, &offset);
2199 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2200 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2201 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2207 size_t CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
2209 size_t bufferSize = 2;
2211 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2212 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2213 bufferSize += 2; /* u16 primitive->commandQueueSize */
2214 bufferSize += 2; /* u16 primitive->trafficQueueSize */
2219 u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, size_t *len, void *msg)
2221 CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
2223 CsrUint16Ser(ptr, len, primitive->common.type);
2224 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2225 CsrUint16Ser(ptr, len, (u16) primitive->commandQueueSize);
2226 CsrUint16Ser(ptr, len, (u16) primitive->trafficQueueSize);
2231 void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, size_t length)
2233 CsrWifiRouterCtrlCapabilitiesCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm), GFP_KERNEL);
2237 CsrUint16Des(&primitive->common.type, buffer, &offset);
2238 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2239 CsrUint16Des((u16 *) &primitive->commandQueueSize, buffer, &offset);
2240 CsrUint16Des((u16 *) &primitive->trafficQueueSize, buffer, &offset);
2246 size_t CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
2248 size_t bufferSize = 2;
2250 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2251 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2252 bufferSize += 2; /* u16 primitive->interfaceTag */
2253 bufferSize += 2; /* CsrResult primitive->status */
2258 u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, size_t *len, void *msg)
2260 CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
2262 CsrUint16Ser(ptr, len, primitive->common.type);
2263 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2264 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2265 CsrUint16Ser(ptr, len, (u16) primitive->status);
2270 void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, size_t length)
2272 CsrWifiRouterCtrlBlockAckEnableCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm), GFP_KERNEL);
2276 CsrUint16Des(&primitive->common.type, buffer, &offset);
2277 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2278 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2279 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2285 size_t CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
2287 size_t bufferSize = 2;
2289 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
2290 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2291 bufferSize += 2; /* u16 primitive->interfaceTag */
2292 bufferSize += 2; /* CsrResult primitive->status */
2297 u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, size_t *len, void *msg)
2299 CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
2301 CsrUint16Ser(ptr, len, primitive->common.type);
2302 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2303 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2304 CsrUint16Ser(ptr, len, (u16) primitive->status);
2309 void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, size_t length)
2311 CsrWifiRouterCtrlBlockAckDisableCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm), GFP_KERNEL);
2315 CsrUint16Des(&primitive->common.type, buffer, &offset);
2316 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2317 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2318 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2324 size_t CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
2326 size_t bufferSize = 2;
2328 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
2329 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2330 bufferSize += 2; /* u16 primitive->interfaceTag */
2331 bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
2332 bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
2333 bufferSize += 2; /* CsrResult primitive->status */
2338 u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, size_t *len, void *msg)
2340 CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
2342 CsrUint16Ser(ptr, len, primitive->common.type);
2343 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2344 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2345 CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
2346 CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
2347 CsrUint16Ser(ptr, len, (u16) primitive->status);
2352 void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, size_t length)
2354 CsrWifiRouterCtrlBlockAckErrorInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd), GFP_KERNEL);
2358 CsrUint16Des(&primitive->common.type, buffer, &offset);
2359 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2360 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2361 CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
2362 CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
2363 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2369 size_t CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
2371 size_t bufferSize = 2;
2373 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
2374 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2375 bufferSize += 2; /* u16 primitive->interfaceTag */
2376 bufferSize += 6; /* u8 primitive->staAddress.a[6] */
2381 u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, size_t *len, void *msg)
2383 CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
2385 CsrUint16Ser(ptr, len, primitive->common.type);
2386 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2387 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2388 CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((u16) (6)));
2393 void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, size_t length)
2395 CsrWifiRouterCtrlStaInactiveInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlStaInactiveInd), GFP_KERNEL);
2399 CsrUint16Des(&primitive->common.type, buffer, &offset);
2400 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2401 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2402 CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((u16) (6)));
2408 size_t CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
2410 CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) msg;
2411 size_t bufferSize = 2;
2413 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
2414 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2415 bufferSize += 2; /* u16 primitive->interfaceTag */
2416 bufferSize += 2; /* u16 primitive->signalLength */
2417 bufferSize += primitive->signalLength; /* u8 primitive->signal */
2418 bufferSize += 2; /* u16 primitive->dataLength */
2419 bufferSize += primitive->dataLength; /* u8 primitive->data */
2424 u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, size_t *len, void *msg)
2426 CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
2428 CsrUint16Ser(ptr, len, primitive->common.type);
2429 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2430 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2431 CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
2432 if (primitive->signalLength)
2434 CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
2436 CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
2437 if (primitive->dataLength)
2439 CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
2445 void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, size_t length)
2447 CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd), GFP_KERNEL);
2451 CsrUint16Des(&primitive->common.type, buffer, &offset);
2452 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2453 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2454 CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
2455 if (primitive->signalLength)
2457 primitive->signal = kmalloc(primitive->signalLength, GFP_KERNEL);
2458 CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
2462 primitive->signal = NULL;
2464 CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
2465 if (primitive->dataLength)
2467 primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
2468 CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
2472 primitive->data = NULL;
2479 void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *voidPrimitivePointer)
2481 CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) voidPrimitivePointer;
2482 kfree(primitive->signal);
2483 kfree(primitive->data);
2488 size_t CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
2490 size_t bufferSize = 2;
2492 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
2493 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2494 bufferSize += 2; /* u16 primitive->interfaceTag */
2495 bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
2496 bufferSize += 2; /* CsrResult primitive->status */
2501 u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, size_t *len, void *msg)
2503 CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
2505 CsrUint16Ser(ptr, len, primitive->common.type);
2506 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2507 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2508 CsrUint8Ser(ptr, len, (u8) primitive->mode);
2509 CsrUint16Ser(ptr, len, (u16) primitive->status);
2514 void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, size_t length)
2516 CsrWifiRouterCtrlModeSetCfm *primitive = kmalloc(sizeof(CsrWifiRouterCtrlModeSetCfm), GFP_KERNEL);
2520 CsrUint16Des(&primitive->common.type, buffer, &offset);
2521 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2522 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2523 CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
2524 CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
2530 size_t CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
2532 CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) msg;
2533 size_t bufferSize = 2;
2535 /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
2536 bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
2537 bufferSize += 2; /* u16 primitive->interfaceTag */
2538 bufferSize += 2; /* u16 primitive->dataLength */
2539 bufferSize += primitive->dataLength; /* u8 primitive->data */
2544 u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, size_t *len, void *msg)
2546 CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
2548 CsrUint16Ser(ptr, len, primitive->common.type);
2549 CsrUint16Ser(ptr, len, (u16) primitive->clientData);
2550 CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
2551 CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
2552 if (primitive->dataLength)
2554 CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
2560 void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, size_t length)
2562 CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = kmalloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd), GFP_KERNEL);
2566 CsrUint16Des(&primitive->common.type, buffer, &offset);
2567 CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
2568 CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
2569 CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
2570 if (primitive->dataLength)
2572 primitive->data = kmalloc(primitive->dataLength, GFP_KERNEL);
2573 CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
2577 primitive->data = NULL;
2584 void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *voidPrimitivePointer)
2586 CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) voidPrimitivePointer;
2587 kfree(primitive->data);