drivers/staging/csr/csr_wifi_nme_ap_serialize.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2012
   4             All rights reserved and confidential information of CSR
   5
   6             Refer to LICENSE.txt included with this source for details
   7             on the license terms.
   8
   9 *****************************************************************************/
  10
  11 /* Note: this is an auto-generated file. */
  12 #include <linux/string.h>
  13 #include <linux/slab.h>
  14 #include "csr_pmem.h"
  15 #include "csr_msgconv.h"
  16 #include "csr_unicode.h"
  17
  18 #ifdef CSR_WIFI_NME_ENABLE
  19 #ifdef CSR_WIFI_AP_ENABLE
  20
  21 #include "csr_wifi_nme_ap_prim.h"
  22 #include "csr_wifi_nme_ap_serialize.h"
  23
  24 void CsrWifiNmeApPfree(void *ptr)
  25 {
  26     kfree(ptr);
  27 }
  28
  29
  30 size_t CsrWifiNmeApConfigSetReqSizeof(void *msg)
  31 {
  32     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) msg;
  33     size_t bufferSize = 2;
  34
  35     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 104) */
  36     bufferSize += 2;  /* u16 primitive->apConfig.apGroupkeyTimeout */
  37     bufferSize += 1;  /* u8 primitive->apConfig.apStrictGtkRekey */
  38     bufferSize += 2;  /* u16 primitive->apConfig.apGmkTimeout */
  39     bufferSize += 2;  /* u16 primitive->apConfig.apResponseTimeout */
  40     bufferSize += 1;  /* u8 primitive->apConfig.apRetransLimit */
  41     bufferSize += 1;  /* CsrWifiSmeApPhySupportMask primitive->apMacConfig.phySupportedBitmap */
  42     bufferSize += 2;  /* u16 primitive->apMacConfig.beaconInterval */
  43     bufferSize += 1;  /* u8 primitive->apMacConfig.dtimPeriod */
  44     bufferSize += 2;  /* u16 primitive->apMacConfig.maxListenInterval */
  45     bufferSize += 1;  /* u8 primitive->apMacConfig.supportedRatesCount */
  46     bufferSize += 20; /* u8 primitive->apMacConfig.supportedRates[20] */
  47     bufferSize += 1;  /* CsrWifiSmePreambleType primitive->apMacConfig.preamble */
  48     bufferSize += 1;  /* u8 primitive->apMacConfig.shortSlotTimeEnabled */
  49     bufferSize += 1;  /* CsrWifiSmeCtsProtectionType primitive->apMacConfig.ctsProtectionType */
  50     bufferSize += 1;  /* u8 primitive->apMacConfig.wmmEnabled */
  51     {
  52         u16 i2;
  53         for (i2 = 0; i2 < 4; i2++)
  54         {
  55             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMin */
  56             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMax */
  57             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].aifs */
  58             bufferSize += 2; /* u16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
  59             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory */
  60         }
  61     }
  62     {
  63         u16 i2;
  64         for (i2 = 0; i2 < 4; i2++)
  65         {
  66             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
  67             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
  68             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
  69             bufferSize += 2; /* u16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
  70             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory */
  71         }
  72     }
  73     bufferSize += 1;         /* CsrWifiSmeApAccessType primitive->apMacConfig.accessType */
  74     bufferSize += 1;         /* u8 primitive->apMacConfig.macAddressListCount */
  75     {
  76         u16 i2;
  77         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
  78         {
  79             bufferSize += 6; /* u8 primitive->apMacConfig.macAddressList[i2].a[6] */
  80         }
  81     }
  82     bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.greenfieldSupported */
  83     bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.shortGi20MHz */
  84     bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.rxStbc */
  85     bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.rifsModeAllowed */
  86     bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.htProtection */
  87     bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.dualCtsProtection */
  88     return bufferSize;
  89 }
  90
  91
  92 u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
  93 {
  94     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
  95     *len = 0;
  96     CsrUint16Ser(ptr, len, primitive->common.type);
  97     CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apGroupkeyTimeout);
  98     CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apStrictGtkRekey);
  99     CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apGmkTimeout);
 100     CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apResponseTimeout);
 101     CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apRetransLimit);
 102     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.phySupportedBitmap);
 103     CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.beaconInterval);
 104     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.dtimPeriod);
 105     CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.maxListenInterval);
 106     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.supportedRatesCount);
 107     CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((u16) (20)));
 108     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.preamble);
 109     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.shortSlotTimeEnabled);
 110     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.ctsProtectionType);
 111     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmEnabled);
 112     {
 113         u16 i2;
 114         for (i2 = 0; i2 < 4; i2++)
 115         {
 116             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMin);
 117             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMax);
 118             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].aifs);
 119             CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
 120             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
 121         }
 122     }
 123     {
 124         u16 i2;
 125         for (i2 = 0; i2 < 4; i2++)
 126         {
 127             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
 128             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
 129             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
 130             CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
 131             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
 132         }
 133     }
 134     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.accessType);
 135     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.macAddressListCount);
 136     {
 137         u16 i2;
 138         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
 139         {
 140             CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((u16) (6)));
 141         }
 142     }
 143     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.greenfieldSupported);
 144     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.shortGi20MHz);
 145     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.rxStbc);
 146     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.rifsModeAllowed);
 147     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.htProtection);
 148     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.dualCtsProtection);
 149     return(ptr);
 150 }
 151
 152
 153 void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, size_t length)
 154 {
 155     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq));
 156     size_t offset;
 157     offset = 0;
 158
 159     CsrUint16Des(&primitive->common.type, buffer, &offset);
 160     CsrUint16Des((u16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
 161     CsrUint8Des((u8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
 162     CsrUint16Des((u16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
 163     CsrUint16Des((u16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
 164     CsrUint8Des((u8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
 165     CsrUint8Des((u8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
 166     CsrUint16Des((u16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
 167     CsrUint8Des((u8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
 168     CsrUint16Des((u16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
 169     CsrUint8Des((u8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
 170     CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((u16) (20)));
 171     CsrUint8Des((u8 *) &primitive->apMacConfig.preamble, buffer, &offset);
 172     CsrUint8Des((u8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
 173     CsrUint8Des((u8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
 174     CsrUint8Des((u8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
 175     {
 176         u16 i2;
 177         for (i2 = 0; i2 < 4; i2++)
 178         {
 179             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
 180             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
 181             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
 182             CsrUint16Des((u16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
 183             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
 184         }
 185     }
 186     {
 187         u16 i2;
 188         for (i2 = 0; i2 < 4; i2++)
 189         {
 190             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
 191             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
 192             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
 193             CsrUint16Des((u16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
 194             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
 195         }
 196     }
 197     CsrUint8Des((u8 *) &primitive->apMacConfig.accessType, buffer, &offset);
 198     CsrUint8Des((u8 *) &primitive->apMacConfig.macAddressListCount, buffer, &offset);
 199     primitive->apMacConfig.macAddressList = NULL;
 200     if (primitive->apMacConfig.macAddressListCount)
 201     {
 202         primitive->apMacConfig.macAddressList = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->apMacConfig.macAddressListCount);
 203     }
 204     {
 205         u16 i2;
 206         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
 207         {
 208             CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((u16) (6)));
 209         }
 210     }
 211     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
 212     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.shortGi20MHz, buffer, &offset);
 213     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.rxStbc, buffer, &offset);
 214     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.rifsModeAllowed, buffer, &offset);
 215     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.htProtection, buffer, &offset);
 216     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.dualCtsProtection, buffer, &offset);
 217
 218     return primitive;
 219 }
 220
 221
 222 void CsrWifiNmeApConfigSetReqSerFree(void *voidPrimitivePointer)
 223 {
 224     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) voidPrimitivePointer;
 225     kfree(primitive->apMacConfig.macAddressList);
 226     kfree(primitive);
 227 }
 228
 229
 230 size_t CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
 231 {
 232     size_t bufferSize = 2;
 233
 234     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
 235     bufferSize += 2; /* u16 primitive->interfaceTag */
 236     bufferSize += 2; /* CsrWifiSmeWpsDpid primitive->selectedDevicePasswordId */
 237     bufferSize += 2; /* CsrWifiSmeWpsConfigType primitive->selectedConfigMethod */
 238     bufferSize += 8; /* u8 primitive->pin[8] */
 239     return bufferSize;
 240 }
 241
 242
 243 u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, size_t *len, void *msg)
 244 {
 245     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
 246     *len = 0;
 247     CsrUint16Ser(ptr, len, primitive->common.type);
 248     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 249     CsrUint16Ser(ptr, len, (u16) primitive->selectedDevicePasswordId);
 250     CsrUint16Ser(ptr, len, (u16) primitive->selectedConfigMethod);
 251     CsrMemCpySer(ptr, len, (const void *) primitive->pin, ((u16) (8)));
 252     return(ptr);
 253 }
 254
 255
 256 void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, size_t length)
 257 {
 258     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq));
 259     size_t offset;
 260     offset = 0;
 261
 262     CsrUint16Des(&primitive->common.type, buffer, &offset);
 263     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 264     CsrUint16Des((u16 *) &primitive->selectedDevicePasswordId, buffer, &offset);
 265     CsrUint16Des((u16 *) &primitive->selectedConfigMethod, buffer, &offset);
 266     CsrMemCpyDes(primitive->pin, buffer, &offset, ((u16) (8)));
 267
 268     return primitive;
 269 }
 270
 271
 272 size_t CsrWifiNmeApStartReqSizeof(void *msg)
 273 {
 274     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) msg;
 275     size_t bufferSize = 2;
 276
 277     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 112) */
 278     bufferSize += 2;  /* u16 primitive->interfaceTag */
 279     bufferSize += 1;  /* CsrWifiSmeApType primitive->apType */
 280     bufferSize += 1;  /* u8 primitive->cloakSsid */
 281     bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
 282     bufferSize += 1;  /* u8 primitive->ssid.length */
 283     bufferSize += 1;  /* CsrWifiSmeRadioIF primitive->ifIndex */
 284     bufferSize += 1;  /* u8 primitive->channel */
 285     bufferSize += 1;  /* CsrWifiSmeApAuthType primitive->apCredentials.authType */
 286     switch (primitive->apCredentials.authType)
 287     {
 288         case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
 289             bufferSize += 1; /* u8 primitive->apCredentials.nmeAuthType.openSystemEmpty.empty */
 290             break;
 291         case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
 292             bufferSize += 1; /* CsrWifiSmeWepCredentialType primitive->apCredentials.nmeAuthType.authwep.wepKeyType */
 293             switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
 294             {
 295                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
 296                     bufferSize += 1;  /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType */
 297                     bufferSize += 1;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey */
 298                     bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1[13] */
 299                     bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2[13] */
 300                     bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3[13] */
 301                     bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4[13] */
 302                     break;
 303                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
 304                     bufferSize += 1;  /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType */
 305                     bufferSize += 1;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey */
 306                     bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1[5] */
 307                     bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2[5] */
 308                     bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3[5] */
 309                     bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4[5] */
 310                     break;
 311                 default:
 312                     break;
 313             }
 314             break;
 315         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
 316             bufferSize += 1; /* CsrWifiSmeApAuthSupportMask primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport */
 317             bufferSize += 2; /* CsrWifiSmeApRsnCapabilitiesMask primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities */
 318             bufferSize += 2; /* CsrWifiSmeApWapiCapabilitiesMask primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities */
 319             bufferSize += 1; /* CsrWifiNmeApPersCredentialType primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase */
 320             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
 321             {
 322                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
 323                     bufferSize += 2;                                                                                                                                                                                                                      /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
 324                     bufferSize += 32;                                                                                                                                                                                                                     /* u8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
 325                     break;
 326                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
 327                     bufferSize += 2;                                                                                                                                                                                                                      /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
 328                     bufferSize += (primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase ? strlen(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase) : 0) + 1; /* char* primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase (0 byte len + 1 for NULL Term) */
 329                     break;
 330                 default:
 331                     break;
 332             }
 333             break;
 334         default:
 335             break;
 336     }
 337     bufferSize += 1; /* u8 primitive->maxConnections */
 338     bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->p2pGoParam.groupCapability */
 339     bufferSize += 3; /* u8 primitive->p2pGoParam.operatingChanList.country[3] */
 340     bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
 341     {
 342         u16 i3;
 343         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
 344         {
 345             bufferSize += 1;                                                                                  /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
 346             bufferSize += 1;                                                                                  /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount */
 347             bufferSize += primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel */
 348         }
 349     }
 350     bufferSize += 1;                                                                                          /* u8 primitive->p2pGoParam.opPsEnabled */
 351     bufferSize += 1;                                                                                          /* u8 primitive->p2pGoParam.ctWindow */
 352     bufferSize += 1;                                                                                          /* CsrWifiSmeP2pNoaConfigMethod primitive->p2pGoParam.noaConfigMethod */
 353     bufferSize += 1;                                                                                          /* u8 primitive->p2pGoParam.allowNoaWithNonP2pDevices */
 354     bufferSize += 1;                                                                                          /* u8 primitive->wpsEnabled */
 355     return bufferSize;
 356 }
 357
 358
 359 u8* CsrWifiNmeApStartReqSer(u8 *ptr, size_t *len, void *msg)
 360 {
 361     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
 362     *len = 0;
 363     CsrUint16Ser(ptr, len, primitive->common.type);
 364     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 365     CsrUint8Ser(ptr, len, (u8) primitive->apType);
 366     CsrUint8Ser(ptr, len, (u8) primitive->cloakSsid);
 367     CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
 368     CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
 369     CsrUint8Ser(ptr, len, (u8) primitive->ifIndex);
 370     CsrUint8Ser(ptr, len, (u8) primitive->channel);
 371     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.authType);
 372     switch (primitive->apCredentials.authType)
 373     {
 374         case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
 375             CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.openSystemEmpty.empty);
 376             break;
 377         case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
 378             CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepKeyType);
 379             switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
 380             {
 381                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
 382                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
 383                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
 384                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((u16) (13)));
 385                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((u16) (13)));
 386                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((u16) (13)));
 387                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((u16) (13)));
 388                     break;
 389                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
 390                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
 391                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
 392                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((u16) (5)));
 393                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((u16) (5)));
 394                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((u16) (5)));
 395                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, ((u16) (5)));
 396                     break;
 397                 default:
 398                     break;
 399             }
 400             break;
 401         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
 402             CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
 403             CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
 404             CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
 405             CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
 406             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
 407             {
 408                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
 409                     CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode);
 410                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, ((u16) (32)));
 411                     break;
 412                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
 413                     CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode);
 414                     CsrCharStringSer(ptr, len, primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
 415                     break;
 416                 default:
 417                     break;
 418             }
 419             break;
 420         default:
 421             break;
 422     }
 423     CsrUint8Ser(ptr, len, (u8) primitive->maxConnections);
 424     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.groupCapability);
 425     CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((u16) (3)));
 426     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
 427     {
 428         u16 i3;
 429         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
 430         {
 431             CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
 432             CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
 433             if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
 434             {
 435                 CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((u16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
 436             }
 437         }
 438     }
 439     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.opPsEnabled);
 440     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.ctWindow);
 441     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.noaConfigMethod);
 442     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.allowNoaWithNonP2pDevices);
 443     CsrUint8Ser(ptr, len, (u8) primitive->wpsEnabled);
 444     return(ptr);
 445 }
 446
 447
 448 void* CsrWifiNmeApStartReqDes(u8 *buffer, size_t length)
 449 {
 450     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq));
 451     size_t offset;
 452     offset = 0;
 453
 454     CsrUint16Des(&primitive->common.type, buffer, &offset);
 455     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 456     CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
 457     CsrUint8Des((u8 *) &primitive->cloakSsid, buffer, &offset);
 458     CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
 459     CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
 460     CsrUint8Des((u8 *) &primitive->ifIndex, buffer, &offset);
 461     CsrUint8Des((u8 *) &primitive->channel, buffer, &offset);
 462     CsrUint8Des((u8 *) &primitive->apCredentials.authType, buffer, &offset);
 463     switch (primitive->apCredentials.authType)
 464     {
 465         case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
 466             CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.openSystemEmpty.empty, buffer, &offset);
 467             break;
 468         case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
 469             CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepKeyType, buffer, &offset);
 470             switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
 471             {
 472                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
 473                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
 474                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
 475                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((u16) (13)));
 476                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((u16) (13)));
 477                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((u16) (13)));
 478                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((u16) (13)));
 479                     break;
 480                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
 481                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
 482                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
 483                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((u16) (5)));
 484                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((u16) (5)));
 485                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((u16) (5)));
 486                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, buffer, &offset, ((u16) (5)));
 487                     break;
 488                 default:
 489                     break;
 490             }
 491             break;
 492         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
 493             CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
 494             CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
 495             CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
 496             CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, buffer, &offset);
 497             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
 498             {
 499                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
 500                     CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode, buffer, &offset);
 501                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, buffer, &offset, ((u16) (32)));
 502                     break;
 503                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
 504                     CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode, buffer, &offset);
 505                     CsrCharStringDes(&primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase, buffer, &offset);
 506                     break;
 507                 default:
 508                     break;
 509             }
 510             break;
 511         default:
 512             break;
 513     }
 514     CsrUint8Des((u8 *) &primitive->maxConnections, buffer, &offset);
 515     CsrUint8Des((u8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
 516     CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((u16) (3)));
 517     CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
 518     primitive->p2pGoParam.operatingChanList.channelEntryList = NULL;
 519     if (primitive->p2pGoParam.operatingChanList.channelEntryListCount)
 520     {
 521         primitive->p2pGoParam.operatingChanList.channelEntryList = (CsrWifiSmeApP2pOperatingChanEntry *)CsrPmemAlloc(sizeof(CsrWifiSmeApP2pOperatingChanEntry) * primitive->p2pGoParam.operatingChanList.channelEntryListCount);
 522     }
 523     {
 524         u16 i3;
 525         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
 526         {
 527             CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
 528             CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount, buffer, &offset);
 529             if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
 530             {
 531                 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (u8 *)CsrPmemAlloc(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
 532                 CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((u16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
 533             }
 534             else
 535             {
 536                 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = NULL;
 537             }
 538         }
 539     }
 540     CsrUint8Des((u8 *) &primitive->p2pGoParam.opPsEnabled, buffer, &offset);
 541     CsrUint8Des((u8 *) &primitive->p2pGoParam.ctWindow, buffer, &offset);
 542     CsrUint8Des((u8 *) &primitive->p2pGoParam.noaConfigMethod, buffer, &offset);
 543     CsrUint8Des((u8 *) &primitive->p2pGoParam.allowNoaWithNonP2pDevices, buffer, &offset);
 544     CsrUint8Des((u8 *) &primitive->wpsEnabled, buffer, &offset);
 545
 546     return primitive;
 547 }
 548
 549
 550 void CsrWifiNmeApStartReqSerFree(void *voidPrimitivePointer)
 551 {
 552     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) voidPrimitivePointer;
 553     switch (primitive->apCredentials.authType)
 554     {
 555         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
 556             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
 557             {
 558                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
 559                     kfree(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
 560                     break;
 561                 default:
 562                     break;
 563             }
 564             break;
 565         default:
 566             break;
 567     }
 568     {
 569         u16 i3;
 570         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
 571         {
 572             kfree(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
 573         }
 574     }
 575     kfree(primitive->p2pGoParam.operatingChanList.channelEntryList);
 576     kfree(primitive);
 577 }
 578
 579
 580 size_t CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
 581 {
 582     size_t bufferSize = 2;
 583
 584     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 51) */
 585     {
 586         u16 i1;
 587         for (i1 = 0; i1 < 4; i1++)
 588         {
 589             bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMin */
 590             bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMax */
 591             bufferSize += 1; /* u8 primitive->wmmApParams[i1].aifs */
 592             bufferSize += 2; /* u16 primitive->wmmApParams[i1].txopLimit */
 593             bufferSize += 1; /* u8 primitive->wmmApParams[i1].admissionControlMandatory */
 594         }
 595     }
 596     {
 597         u16 i1;
 598         for (i1 = 0; i1 < 4; i1++)
 599         {
 600             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMin */
 601             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMax */
 602             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].aifs */
 603             bufferSize += 2; /* u16 primitive->wmmApBcParams[i1].txopLimit */
 604             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].admissionControlMandatory */
 605         }
 606     }
 607     return bufferSize;
 608 }
 609
 610
 611 u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, size_t *len, void *msg)
 612 {
 613     CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *)msg;
 614     *len = 0;
 615     CsrUint16Ser(ptr, len, primitive->common.type);
 616     {
 617         u16 i1;
 618         for (i1 = 0; i1 < 4; i1++)
 619         {
 620             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMin);
 621             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMax);
 622             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].aifs);
 623             CsrUint16Ser(ptr, len, (u16) primitive->wmmApParams[i1].txopLimit);
 624             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].admissionControlMandatory);
 625         }
 626     }
 627     {
 628         u16 i1;
 629         for (i1 = 0; i1 < 4; i1++)
 630         {
 631             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMin);
 632             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMax);
 633             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].aifs);
 634             CsrUint16Ser(ptr, len, (u16) primitive->wmmApBcParams[i1].txopLimit);
 635             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].admissionControlMandatory);
 636         }
 637     }
 638     return(ptr);
 639 }
 640
 641
 642 void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, size_t length)
 643 {
 644     CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq));
 645     size_t offset;
 646     offset = 0;
 647
 648     CsrUint16Des(&primitive->common.type, buffer, &offset);
 649     {
 650         u16 i1;
 651         for (i1 = 0; i1 < 4; i1++)
 652         {
 653             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
 654             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
 655             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
 656             CsrUint16Des((u16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
 657             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
 658         }
 659     }
 660     {
 661         u16 i1;
 662         for (i1 = 0; i1 < 4; i1++)
 663         {
 664             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
 665             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
 666             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
 667             CsrUint16Des((u16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
 668             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
 669         }
 670     }
 671
 672     return primitive;
 673 }
 674
 675
 676 size_t CsrWifiNmeApStaRemoveReqSizeof(void *msg)
 677 {
 678     size_t bufferSize = 2;
 679
 680     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
 681     bufferSize += 2; /* u16 primitive->interfaceTag */
 682     bufferSize += 6; /* u8 primitive->staMacAddress.a[6] */
 683     bufferSize += 1; /* u8 primitive->keepBlocking */
 684     return bufferSize;
 685 }
 686
 687
 688 u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, size_t *len, void *msg)
 689 {
 690     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
 691     *len = 0;
 692     CsrUint16Ser(ptr, len, primitive->common.type);
 693     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 694     CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((u16) (6)));
 695     CsrUint8Ser(ptr, len, (u8) primitive->keepBlocking);
 696     return(ptr);
 697 }
 698
 699
 700 void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, size_t length)
 701 {
 702     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq));
 703     size_t offset;
 704     offset = 0;
 705
 706     CsrUint16Des(&primitive->common.type, buffer, &offset);
 707     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 708     CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((u16) (6)));
 709     CsrUint8Des((u8 *) &primitive->keepBlocking, buffer, &offset);
 710
 711     return primitive;
 712 }
 713
 714
 715 size_t CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
 716 {
 717     size_t bufferSize = 2;
 718
 719     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
 720     bufferSize += 2; /* u16 primitive->interfaceTag */
 721     bufferSize += 2; /* CsrResult primitive->status */
 722     return bufferSize;
 723 }
 724
 725
 726 u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, size_t *len, void *msg)
 727 {
 728     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
 729     *len = 0;
 730     CsrUint16Ser(ptr, len, primitive->common.type);
 731     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 732     CsrUint16Ser(ptr, len, (u16) primitive->status);
 733     return(ptr);
 734 }
 735
 736
 737 void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, size_t length)
 738 {
 739     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm));
 740     size_t offset;
 741     offset = 0;
 742
 743     CsrUint16Des(&primitive->common.type, buffer, &offset);
 744     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 745     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 746
 747     return primitive;
 748 }
 749
 750
 751 size_t CsrWifiNmeApStartCfmSizeof(void *msg)
 752 {
 753     size_t bufferSize = 2;
 754
 755     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
 756     bufferSize += 2;  /* u16 primitive->interfaceTag */
 757     bufferSize += 2;  /* CsrResult primitive->status */
 758     bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
 759     bufferSize += 1;  /* u8 primitive->ssid.length */
 760     return bufferSize;
 761 }
 762
 763
 764 u8* CsrWifiNmeApStartCfmSer(u8 *ptr, size_t *len, void *msg)
 765 {
 766     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
 767     *len = 0;
 768     CsrUint16Ser(ptr, len, primitive->common.type);
 769     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 770     CsrUint16Ser(ptr, len, (u16) primitive->status);
 771     CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
 772     CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
 773     return(ptr);
 774 }
 775
 776
 777 void* CsrWifiNmeApStartCfmDes(u8 *buffer, size_t length)
 778 {
 779     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm));
 780     size_t offset;
 781     offset = 0;
 782
 783     CsrUint16Des(&primitive->common.type, buffer, &offset);
 784     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 785     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 786     CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
 787     CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
 788
 789     return primitive;
 790 }
 791
 792
 793 size_t CsrWifiNmeApStopCfmSizeof(void *msg)
 794 {
 795     size_t bufferSize = 2;
 796
 797     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
 798     bufferSize += 2; /* u16 primitive->interfaceTag */
 799     bufferSize += 2; /* CsrResult primitive->status */
 800     return bufferSize;
 801 }
 802
 803
 804 u8* CsrWifiNmeApStopCfmSer(u8 *ptr, size_t *len, void *msg)
 805 {
 806     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
 807     *len = 0;
 808     CsrUint16Ser(ptr, len, primitive->common.type);
 809     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 810     CsrUint16Ser(ptr, len, (u16) primitive->status);
 811     return(ptr);
 812 }
 813
 814
 815 void* CsrWifiNmeApStopCfmDes(u8 *buffer, size_t length)
 816 {
 817     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm));
 818     size_t offset;
 819     offset = 0;
 820
 821     CsrUint16Des(&primitive->common.type, buffer, &offset);
 822     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 823     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 824
 825     return primitive;
 826 }
 827
 828
 829 size_t CsrWifiNmeApStopIndSizeof(void *msg)
 830 {
 831     size_t bufferSize = 2;
 832
 833     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
 834     bufferSize += 2; /* u16 primitive->interfaceTag */
 835     bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
 836     bufferSize += 2; /* CsrResult primitive->status */
 837     return bufferSize;
 838 }
 839
 840
 841 u8* CsrWifiNmeApStopIndSer(u8 *ptr, size_t *len, void *msg)
 842 {
 843     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
 844     *len = 0;
 845     CsrUint16Ser(ptr, len, primitive->common.type);
 846     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 847     CsrUint8Ser(ptr, len, (u8) primitive->apType);
 848     CsrUint16Ser(ptr, len, (u16) primitive->status);
 849     return(ptr);
 850 }
 851
 852
 853 void* CsrWifiNmeApStopIndDes(u8 *buffer, size_t length)
 854 {
 855     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd));
 856     size_t offset;
 857     offset = 0;
 858
 859     CsrUint16Des(&primitive->common.type, buffer, &offset);
 860     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 861     CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
 862     CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 863
 864     return primitive;
 865 }
 866
 867
 868 size_t CsrWifiNmeApStationIndSizeof(void *msg)
 869 {
 870     size_t bufferSize = 2;
 871
 872     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
 873     bufferSize += 2; /* u16 primitive->interfaceTag */
 874     bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
 875     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
 876     bufferSize += 6; /* u8 primitive->peerDeviceAddress.a[6] */
 877     return bufferSize;
 878 }
 879
 880
 881 u8* CsrWifiNmeApStationIndSer(u8 *ptr, size_t *len, void *msg)
 882 {
 883     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
 884     *len = 0;
 885     CsrUint16Ser(ptr, len, primitive->common.type);
 886     CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
 887     CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
 888     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
 889     CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((u16) (6)));
 890     return(ptr);
 891 }
 892
 893
 894 void* CsrWifiNmeApStationIndDes(u8 *buffer, size_t length)
 895 {
 896     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd));
 897     size_t offset;
 898     offset = 0;
 899
 900     CsrUint16Des(&primitive->common.type, buffer, &offset);
 901     CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
 902     CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
 903     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 904     CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((u16) (6)));
 905
 906     return primitive;
 907 }
 908
 909
 910 #endif /* CSR_WIFI_NME_ENABLE */
 911 #endif /* CSR_WIFI_AP_ENABLE */