cc3100_wlan.cpp

00001 /*
00002 * wlan.c - CC31xx/CC32xx Host Driver Implementation
00003 *
00004 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/ 
00005 * 
00006 * 
00007 *  Redistribution and use in source and binary forms, with or without 
00008 *  modification, are permitted provided that the following conditions 
00009 *  are met:
00010 *
00011 *    Redistributions of source code must retain the above copyright 
00012 *    notice, this list of conditions and the following disclaimer.
00013 *
00014 *    Redistributions in binary form must reproduce the above copyright
00015 *    notice, this list of conditions and the following disclaimer in the 
00016 *    documentation and/or other materials provided with the   
00017 *    distribution.
00018 *
00019 *    Neither the name of Texas Instruments Incorporated nor the names of
00020 *    its contributors may be used to endorse or promote products derived
00021 *    from this software without specific prior written permission.
00022 *
00023 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
00024 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
00025 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00026 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
00027 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
00028 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
00029 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00030 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00031 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
00032 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
00033 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034 *
00035 */
00036 
00037 
00038 
00039 /*****************************************************************************/
00040 /* Include files                                                             */
00041 /*****************************************************************************/
00042 #include "cc3100_simplelink.h"
00043 #include "cc3100_protocol.h"
00044 #include "cc3100_driver.h"
00045 
00046 /*****************************************************************************/
00047 /* Macro declarations                                                        */
00048 /*****************************************************************************/
00049 #define MAX_SSID_LEN           (32)
00050 #define MAX_KEY_LEN            (63)
00051 #define MAX_USER_LEN           (32)
00052 #define MAX_ANON_USER_LEN      (32)
00053 #define MAX_SMART_CONFIG_KEY   (16)
00054 
00055 
00056 /*****************************************************************************
00057 sl_WlanConnect
00058 *****************************************************************************/
00059 typedef struct 
00060 {
00061     _WlanConnectEapCommand_t    Args;
00062     _i8                        Strings[MAX_SSID_LEN + MAX_KEY_LEN + MAX_USER_LEN + MAX_ANON_USER_LEN];
00063 }_WlanConnectCmd_t;
00064 
00065 typedef union
00066 {
00067     _WlanConnectCmd_t   Cmd;
00068     _BasicResponse_t    Rsp;
00069 }_SlWlanConnectMsg_u;
00070 
00071 
00072 #if _SL_INCLUDE_FUNC(sl_WlanConnect)
00073 _i16 sl_WlanConnect(_i8*  pName, _i16 NameLen, _u8 *pMacAddr, SlSecParams_t* pSecParams , SlSecParamsExt_t* pSecExtParams)
00074 {
00075     _SlWlanConnectMsg_u    Msg = {0};
00076     _SlCmdCtrl_t           CmdCtrl = {0};
00077 
00078     CmdCtrl.TxDescLen = 0;/* init */
00079     CmdCtrl.RxDescLen = sizeof(_BasicResponse_t);
00080 
00081     /* verify SSID length */
00082     VERIFY_PROTOCOL(NameLen <= MAX_SSID_LEN);
00083     /* update SSID length */
00084     Msg.Cmd.Args.Common.SsidLen = (_u8)NameLen;
00085 
00086     /* Profile with no security */
00087     /* Enterprise security profile */
00088     if (NULL != pSecExtParams)
00089     {
00090         /* Update command opcode */
00091         CmdCtrl.Opcode = SL_OPCODE_WLAN_WLANCONNECTEAPCOMMAND;
00092         CmdCtrl.TxDescLen += sizeof(_WlanConnectEapCommand_t);
00093         /* copy SSID */
00094         sl_Memcpy(EAP_SSID_STRING(&Msg), pName, NameLen);
00095         CmdCtrl.TxDescLen += NameLen;
00096         /* Copy password if supplied */
00097         if ((NULL != pSecParams) && (pSecParams->KeyLen > 0))
00098         {
00099             /* update security type */
00100             Msg.Cmd.Args.Common.SecType = pSecParams->Type;
00101             /* verify key length */
00102             if (pSecParams->KeyLen > MAX_KEY_LEN)
00103             {
00104                 return SL_INVALPARAM;
00105             }
00106             /* update key length */
00107             Msg.Cmd.Args.Common.PasswordLen = pSecParams->KeyLen;
00108             ARG_CHECK_PTR(pSecParams->Key);
00109             /* copy key      */
00110             sl_Memcpy(EAP_PASSWORD_STRING(&Msg), pSecParams->Key, pSecParams->KeyLen);
00111             CmdCtrl.TxDescLen += pSecParams->KeyLen;
00112         }
00113         else
00114         {
00115             Msg.Cmd.Args.Common.PasswordLen = 0;
00116         }
00117 
00118         ARG_CHECK_PTR(pSecExtParams);
00119         /* Update Eap bitmask */
00120         Msg.Cmd.Args.EapBitmask = pSecExtParams->EapMethod;
00121         /* Update Certificate file ID index - currently not supported */
00122         Msg.Cmd.Args.CertIndex = pSecExtParams->CertIndex;
00123         /* verify user length */
00124         if (pSecExtParams->UserLen > MAX_USER_LEN)
00125         {
00126             return SL_INVALPARAM;
00127         }
00128         Msg.Cmd.Args.UserLen = pSecExtParams->UserLen;
00129         /* copy user name (identity) */
00130         if(pSecExtParams->UserLen > 0)
00131         {
00132             sl_Memcpy(EAP_USER_STRING(&Msg), pSecExtParams->User, pSecExtParams->UserLen);
00133             CmdCtrl.TxDescLen += pSecExtParams->UserLen;
00134         }
00135         /* verify Anonymous user length  */
00136         if (pSecExtParams->AnonUserLen > MAX_ANON_USER_LEN)
00137         {
00138             return SL_INVALPARAM;
00139         }
00140         Msg.Cmd.Args.AnonUserLen = pSecExtParams->AnonUserLen;
00141         /* copy Anonymous user */
00142         if(pSecExtParams->AnonUserLen > 0)
00143         {
00144             sl_Memcpy(EAP_ANON_USER_STRING(&Msg), pSecExtParams->AnonUser, pSecExtParams->AnonUserLen);
00145             CmdCtrl.TxDescLen += pSecExtParams->AnonUserLen;
00146         }
00147 
00148     }
00149 
00150     /* Regular or open security profile */
00151     else
00152     {
00153         /* Update command opcode */
00154         CmdCtrl.Opcode = SL_OPCODE_WLAN_WLANCONNECTCOMMAND;
00155         CmdCtrl.TxDescLen += sizeof(_WlanConnectCommon_t);
00156         /* copy SSID */
00157         sl_Memcpy(SSID_STRING(&Msg), pName, NameLen);   
00158         CmdCtrl.TxDescLen += NameLen;
00159         /* Copy password if supplied */
00160         if( NULL != pSecParams )
00161         {
00162             /* update security type */
00163             Msg.Cmd.Args.Common.SecType = pSecParams->Type;
00164             /* verify key length is valid */
00165             if (pSecParams->KeyLen > MAX_KEY_LEN)
00166             {
00167                 return SL_INVALPARAM;
00168             }
00169             /* update key length */
00170             Msg.Cmd.Args.Common.PasswordLen = pSecParams->KeyLen;
00171             CmdCtrl.TxDescLen += pSecParams->KeyLen;
00172             /* copy key (could be no key in case of WPS pin) */
00173             if( NULL != pSecParams->Key )
00174             {
00175                 sl_Memcpy(PASSWORD_STRING(&Msg), pSecParams->Key, pSecParams->KeyLen);
00176             }
00177         }
00178         /* Profile with no security */
00179         else
00180         {
00181             Msg.Cmd.Args.Common.PasswordLen = 0;
00182             Msg.Cmd.Args.Common.SecType = SL_SEC_TYPE_OPEN;
00183         }   
00184     }
00185     /* If BSSID is not null, copy to buffer, otherwise set to 0 */
00186     if(NULL != pMacAddr)
00187     {
00188         sl_Memcpy(Msg.Cmd.Args.Common.Bssid, pMacAddr, sizeof(Msg.Cmd.Args.Common.Bssid));
00189     }
00190     else
00191     {
00192         sl_Memset(Msg.Cmd.Args.Common.Bssid, 0, sizeof(Msg.Cmd.Args.Common.Bssid));
00193     }
00194 
00195 
00196     VERIFY_RET_OK ( _SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
00197 
00198     return (_i16)Msg.Rsp.status;
00199 }
00200 #endif
00201 
00202 /*******************************************************************************/
00203 /*   sl_Disconnect  */
00204 /* ******************************************************************************/
00205 #if _SL_INCLUDE_FUNC(sl_WlanDisconnect)
00206 _i16 sl_WlanDisconnect(void)
00207 {
00208     return _SlDrvBasicCmd(SL_OPCODE_WLAN_WLANDISCONNECTCOMMAND);
00209 }
00210 #endif
00211 
00212 /******************************************************************************/
00213 /*  sl_PolicySet  */
00214 /******************************************************************************/
00215 typedef union
00216 {
00217     _WlanPoliciySetGet_t    Cmd;
00218     _BasicResponse_t        Rsp;
00219 }_SlPolicyMsg_u;
00220 
00221 const _SlCmdCtrl_t _SlPolicySetCmdCtrl =
00222 {
00223     SL_OPCODE_WLAN_POLICYSETCOMMAND,
00224     sizeof(_WlanPoliciySetGet_t),
00225     sizeof(_BasicResponse_t)
00226 };
00227 
00228 #if _SL_INCLUDE_FUNC(sl_WlanPolicySet)
00229 _i16 sl_WlanPolicySet(_u8 Type , const _u8 Policy, _u8 *pVal,_u8 ValLen)
00230 {
00231     _SlPolicyMsg_u         Msg;
00232     _SlCmdExt_t            CmdExt;
00233 
00234     CmdExt.TxPayloadLen = ValLen;
00235     CmdExt.RxPayloadLen = 0;
00236     CmdExt.pTxPayload = (_u8 *)pVal;
00237     CmdExt.pRxPayload = NULL;
00238 
00239 
00240     Msg.Cmd.PolicyType        = Type;
00241     Msg.Cmd.PolicyOption      = Policy;
00242     Msg.Cmd.PolicyOptionLen   = ValLen;
00243 
00244     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlPolicySetCmdCtrl, &Msg, &CmdExt));
00245 
00246     return (_i16)Msg.Rsp.status;
00247 }
00248 #endif
00249 
00250 
00251 /******************************************************************************/
00252 /*  sl_PolicyGet  */
00253 /******************************************************************************/
00254 typedef union
00255 {
00256     _WlanPoliciySetGet_t        Cmd;
00257     _WlanPoliciySetGet_t        Rsp;
00258 }_SlPolicyGetMsg_u;
00259 
00260 const _SlCmdCtrl_t _SlPolicyGetCmdCtrl =
00261 {
00262     SL_OPCODE_WLAN_POLICYGETCOMMAND,
00263     sizeof(_WlanPoliciySetGet_t),
00264     sizeof(_WlanPoliciySetGet_t)
00265 };
00266 
00267 #if _SL_INCLUDE_FUNC(sl_WlanPolicyGet)
00268 _i16 sl_WlanPolicyGet(_u8 Type , _u8 Policy,_u8 *pVal,_u8 *pValLen)
00269 {
00270     _SlPolicyGetMsg_u      Msg;
00271     _SlCmdExt_t            CmdExt;
00272 
00273     if (*pValLen == 0)
00274     {
00275         return SL_EZEROLEN;
00276     }
00277     CmdExt.TxPayloadLen = 0;
00278     CmdExt.RxPayloadLen = *pValLen;
00279     CmdExt.pTxPayload = NULL;
00280     CmdExt.pRxPayload = pVal;
00281     CmdExt.ActualRxPayloadLen = 0;
00282 
00283 
00284     Msg.Cmd.PolicyType = Type;
00285     Msg.Cmd.PolicyOption = Policy;
00286     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlPolicyGetCmdCtrl, &Msg, &CmdExt));
00287 
00288 
00289     if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen) 
00290     {
00291         *pValLen = Msg.Rsp.PolicyOptionLen;
00292         return SL_ESMALLBUF;
00293     }
00294     else
00295     {
00296         /*  no pointer valus, fill the results into _i8 */
00297         *pValLen = (_u8)CmdExt.ActualRxPayloadLen;
00298         if( 0 == CmdExt.ActualRxPayloadLen )
00299         {
00300             *pValLen = 1;
00301             pVal[0] = Msg.Rsp.PolicyOption;
00302         }
00303     }
00304     return (_i16)SL_OS_RET_CODE_OK;
00305 }
00306 #endif
00307 
00308 
00309 /*******************************************************************************/
00310 /*  sl_ProfileAdd  */
00311 /*******************************************************************************/
00312 typedef struct
00313 {
00314     _WlanAddGetEapProfile_t Args;
00315     _i8                    Strings[MAX_SSID_LEN + MAX_KEY_LEN + MAX_USER_LEN + MAX_ANON_USER_LEN];
00316 }_SlProfileParams_t;
00317 
00318 typedef union
00319 {
00320     _SlProfileParams_t      Cmd;
00321     _BasicResponse_t        Rsp;
00322 }_SlProfileAddMsg_u;
00323 
00324 
00325 
00326 #if _SL_INCLUDE_FUNC(sl_WlanProfileAdd)
00327 _i16 sl_WlanProfileAdd(_i8*  pName, _i16 NameLen, _u8 *pMacAddr, SlSecParams_t* pSecParams , SlSecParamsExt_t* pSecExtParams, _u32  Priority, _u32  Options)
00328 {
00329     _SlProfileAddMsg_u      Msg;
00330     _SlCmdCtrl_t           CmdCtrl = {0};
00331     CmdCtrl.TxDescLen = 0;/* init */
00332     CmdCtrl.RxDescLen = sizeof(_BasicResponse_t);
00333 
00334     /* update priority */
00335     Msg.Cmd.Args.Common.Priority = (_u8)Priority; 
00336     /* verify SSID length */
00337     VERIFY_PROTOCOL(NameLen <= MAX_SSID_LEN);
00338     /* update SSID length */
00339     Msg.Cmd.Args.Common.SsidLen = (_u8)NameLen;
00340 
00341 
00342     /* Enterprise security profile */
00343     if  (NULL != pSecExtParams)
00344     {
00345         /* Update command opcode */
00346         CmdCtrl.Opcode = SL_OPCODE_WLAN_EAP_PROFILEADDCOMMAND;
00347         CmdCtrl.TxDescLen += sizeof(_WlanAddGetEapProfile_t);
00348 
00349         /* copy SSID */
00350         sl_Memcpy(EAP_PROFILE_SSID_STRING(&Msg), pName, NameLen);   
00351         CmdCtrl.TxDescLen += NameLen;
00352 
00353         /* Copy password if supplied */
00354         if ((NULL != pSecParams) && (pSecParams->KeyLen > 0))
00355         {
00356             /* update security type */
00357             Msg.Cmd.Args.Common.SecType = pSecParams->Type;
00358 
00359             if( SL_SEC_TYPE_WEP == Msg.Cmd.Args.Common.SecType )
00360             {
00361                 Msg.Cmd.Args.Common.WepKeyId = 0;
00362             }
00363 
00364             /* verify key length */
00365             if (pSecParams->KeyLen > MAX_KEY_LEN)
00366             {
00367                 return SL_INVALPARAM;
00368             }
00369             VERIFY_PROTOCOL(pSecParams->KeyLen <= MAX_KEY_LEN);
00370             /* update key length */
00371             Msg.Cmd.Args.Common.PasswordLen = pSecParams->KeyLen;   
00372             CmdCtrl.TxDescLen += pSecParams->KeyLen;
00373             ARG_CHECK_PTR(pSecParams->Key);
00374             /* copy key  */
00375             sl_Memcpy(EAP_PROFILE_PASSWORD_STRING(&Msg), pSecParams->Key, pSecParams->KeyLen);
00376         }
00377         else
00378         {
00379             Msg.Cmd.Args.Common.PasswordLen = 0;
00380         }
00381 
00382         ARG_CHECK_PTR(pSecExtParams);
00383         /* Update Eap bitmask */
00384         Msg.Cmd.Args.EapBitmask = pSecExtParams->EapMethod;
00385         /* Update Certificate file ID index - currently not supported */
00386         Msg.Cmd.Args.CertIndex = pSecExtParams->CertIndex;
00387         /* verify user length */
00388         if (pSecExtParams->UserLen > MAX_USER_LEN)
00389         {
00390             return SL_INVALPARAM;
00391         }
00392         Msg.Cmd.Args.UserLen = pSecExtParams->UserLen;
00393         /* copy user name (identity) */
00394         if(pSecExtParams->UserLen > 0)
00395         {
00396             sl_Memcpy(EAP_PROFILE_USER_STRING(&Msg), pSecExtParams->User, pSecExtParams->UserLen);
00397             CmdCtrl.TxDescLen += pSecExtParams->UserLen;
00398         }
00399 
00400         /* verify Anonymous user length (for tunneled) */
00401         if (pSecExtParams->AnonUserLen > MAX_ANON_USER_LEN)
00402         {
00403             return SL_INVALPARAM;
00404         }
00405         Msg.Cmd.Args.AnonUserLen = pSecExtParams->AnonUserLen;
00406 
00407         /* copy Anonymous user */
00408         if(pSecExtParams->AnonUserLen > 0)
00409         {
00410             sl_Memcpy(EAP_PROFILE_ANON_USER_STRING(&Msg), pSecExtParams->AnonUser, pSecExtParams->AnonUserLen);
00411             CmdCtrl.TxDescLen += pSecExtParams->AnonUserLen;
00412         }
00413 
00414     }
00415     /* Regular or open security profile */
00416     else
00417     {
00418         /* Update command opcode */
00419         CmdCtrl.Opcode = SL_OPCODE_WLAN_PROFILEADDCOMMAND;
00420         /* update commnad length */
00421         CmdCtrl.TxDescLen += sizeof(_WlanAddGetProfile_t);
00422 
00423         if (NULL != pName)
00424         {
00425             /* copy SSID */
00426             sl_Memcpy(PROFILE_SSID_STRING(&Msg), pName, NameLen);
00427             CmdCtrl.TxDescLen += NameLen;
00428         }
00429 
00430         /* Copy password if supplied */
00431         if( NULL != pSecParams )
00432         {
00433             /* update security type */
00434             Msg.Cmd.Args.Common.SecType = pSecParams->Type;
00435 
00436             if( SL_SEC_TYPE_WEP == Msg.Cmd.Args.Common.SecType )
00437             {
00438                 Msg.Cmd.Args.Common.WepKeyId = 0;
00439             }
00440 
00441             /* verify key length */
00442             if (pSecParams->KeyLen > MAX_KEY_LEN)
00443             {
00444                 return SL_INVALPARAM;
00445             }
00446             /* update key length */
00447             Msg.Cmd.Args.Common.PasswordLen = pSecParams->KeyLen;
00448             CmdCtrl.TxDescLen += pSecParams->KeyLen;
00449             /* copy key (could be no key in case of WPS pin) */
00450             if( NULL != pSecParams->Key )
00451             {
00452                 sl_Memcpy(PROFILE_PASSWORD_STRING(&Msg), pSecParams->Key, pSecParams->KeyLen);
00453             }
00454         }
00455         else
00456         {
00457             Msg.Cmd.Args.Common.SecType = SL_SEC_TYPE_OPEN;
00458             Msg.Cmd.Args.Common.PasswordLen = 0;
00459         }
00460 
00461     }
00462 
00463 
00464     /* If BSSID is not null, copy to buffer, otherwise set to 0  */
00465     if(NULL != pMacAddr)
00466     {
00467         sl_Memcpy(Msg.Cmd.Args.Common.Bssid, pMacAddr, sizeof(Msg.Cmd.Args.Common.Bssid));
00468     }
00469     else
00470     {
00471         sl_Memset(Msg.Cmd.Args.Common.Bssid, 0, sizeof(Msg.Cmd.Args.Common.Bssid));
00472     }
00473 
00474     VERIFY_RET_OK(_SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
00475 
00476     return (_i16)Msg.Rsp.status;
00477 }
00478 #endif
00479 /*******************************************************************************/
00480 /*   sl_ProfileGet */
00481 /*******************************************************************************/
00482 typedef union
00483 {
00484     _WlanProfileDelGetCommand_t Cmd;
00485     _SlProfileParams_t          Rsp;
00486 }_SlProfileGetMsg_u;
00487 
00488 const _SlCmdCtrl_t _SlProfileGetCmdCtrl =
00489 {
00490     SL_OPCODE_WLAN_PROFILEGETCOMMAND,
00491     sizeof(_WlanProfileDelGetCommand_t),
00492     sizeof(_SlProfileParams_t)
00493 };
00494 
00495 #if _SL_INCLUDE_FUNC(sl_WlanProfileGet)
00496 _i16 sl_WlanProfileGet(_i16 Index,_i8*  pName, _i16 *pNameLen, _u8 *pMacAddr, SlSecParams_t* pSecParams, SlGetSecParamsExt_t* pEntParams, _u32 *pPriority)
00497 {
00498     _SlProfileGetMsg_u      Msg;
00499     Msg.Cmd.index = (_u8)Index;
00500 
00501     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlProfileGetCmdCtrl, &Msg, NULL));
00502 
00503     pSecParams->Type = Msg.Rsp.Args.Common.SecType;
00504     /* since password is not transferred in getprofile, password length should always be zero */
00505     pSecParams->KeyLen = Msg.Rsp.Args.Common.PasswordLen;
00506     if (NULL != pEntParams)
00507     {
00508         pEntParams->UserLen = Msg.Rsp.Args.UserLen;
00509         /* copy user name */
00510         if (pEntParams->UserLen > 0)
00511         {    
00512             sl_Memcpy(pEntParams->User, EAP_PROFILE_USER_STRING(&Msg), pEntParams->UserLen);
00513         }
00514         pEntParams->AnonUserLen = Msg.Rsp.Args.AnonUserLen;
00515         /* copy anonymous user name */
00516         if (pEntParams->AnonUserLen > 0)
00517         {
00518             sl_Memcpy(pEntParams->AnonUser, EAP_PROFILE_ANON_USER_STRING(&Msg), pEntParams->AnonUserLen);
00519         }
00520     }
00521 
00522     *pNameLen  = Msg.Rsp.Args.Common.SsidLen;      
00523     *pPriority = Msg.Rsp.Args.Common.Priority;       
00524 
00525     if (NULL != Msg.Rsp.Args.Common.Bssid)
00526     {
00527         sl_Memcpy(pMacAddr, Msg.Rsp.Args.Common.Bssid, sizeof(Msg.Rsp.Args.Common.Bssid));
00528     }
00529 
00530     sl_Memcpy(pName, EAP_PROFILE_SSID_STRING(&Msg), *pNameLen);
00531 
00532     return (_i16)Msg.Rsp.Args.Common.SecType;
00533 
00534 }
00535 #endif
00536 /*******************************************************************************/
00537 /*   sl_ProfileDel  */
00538 /*******************************************************************************/
00539 typedef union
00540 {
00541     _WlanProfileDelGetCommand_t     Cmd;
00542     _BasicResponse_t                Rsp;
00543 }_SlProfileDelMsg_u;
00544 
00545 const _SlCmdCtrl_t _SlProfileDelCmdCtrl =
00546 {
00547     SL_OPCODE_WLAN_PROFILEDELCOMMAND,
00548     sizeof(_WlanProfileDelGetCommand_t),
00549     sizeof(_BasicResponse_t)
00550 };
00551 
00552 #if _SL_INCLUDE_FUNC(sl_WlanProfileDel)
00553 _i16 sl_WlanProfileDel(_i16 Index)
00554 {
00555     _SlProfileDelMsg_u Msg;
00556 
00557     Msg.Cmd.index = (_u8)Index;
00558 
00559     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlProfileDelCmdCtrl, &Msg, NULL));
00560 
00561     return (_i16)Msg.Rsp.status;
00562 }
00563 #endif
00564 
00565 
00566 /******************************************************************************/
00567 /*  sl_WlanGetNetworkList  */
00568 /******************************************************************************/
00569 typedef union
00570 {
00571     _WlanGetNetworkListCommand_t    Cmd;
00572     _WlanGetNetworkListResponse_t   Rsp;
00573 }_SlWlanGetNetworkListMsg_u;
00574 
00575 const _SlCmdCtrl_t _SlWlanGetNetworkListCtrl =
00576 {
00577     SL_OPCODE_WLAN_SCANRESULTSGETCOMMAND,
00578     sizeof(_WlanGetNetworkListCommand_t),
00579     sizeof(_WlanGetNetworkListResponse_t)
00580 };
00581 
00582 
00583 #if _SL_INCLUDE_FUNC(sl_WlanGetNetworkList)
00584 _i16 sl_WlanGetNetworkList(_u8 Index, _u8 Count, Sl_WlanNetworkEntry_t *pEntries)
00585 {
00586     _i16 retVal = 0;
00587     _SlWlanGetNetworkListMsg_u Msg;
00588     _SlCmdExt_t    CmdExt;
00589 
00590     if (Count == 0)
00591     {
00592         return SL_EZEROLEN;
00593     }
00594     CmdExt.TxPayloadLen = 0;
00595     CmdExt.RxPayloadLen = sizeof(Sl_WlanNetworkEntry_t)*(Count);
00596     CmdExt.pTxPayload = NULL;
00597     CmdExt.pRxPayload = (_u8 *)pEntries; 
00598 
00599     Msg.Cmd.index = Index;
00600     Msg.Cmd.count = Count;
00601 
00602     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlWlanGetNetworkListCtrl, &Msg, &CmdExt));
00603     retVal = Msg.Rsp.status;
00604 
00605     return (_i16)retVal;
00606 }
00607 #endif
00608 
00609 
00610 
00611 
00612 
00613 /******************************************************************************/
00614 /*     RX filters message command response structures  */
00615 /******************************************************************************/
00616 
00617 /* Set command */
00618 typedef union
00619 {
00620     _WlanRxFilterAddCommand_t             Cmd;
00621     _WlanRxFilterAddCommandReponse_t      Rsp;
00622 }_SlrxFilterAddMsg_u;
00623 
00624 const _SlCmdCtrl_t _SlRxFilterAddtCmdCtrl =
00625 {
00626     SL_OPCODE_WLAN_WLANRXFILTERADDCOMMAND,
00627     sizeof(_WlanRxFilterAddCommand_t),
00628     sizeof(_WlanRxFilterAddCommandReponse_t)
00629 };
00630 
00631 
00632 /* Set command */
00633 typedef union _SlRxFilterSetMsg_u
00634 {
00635     _WlanRxFilterSetCommand_t               Cmd;
00636     _WlanRxFilterSetCommandReponse_t        Rsp;
00637 }_SlRxFilterSetMsg_u;
00638 
00639 
00640 const _SlCmdCtrl_t _SlRxFilterSetCmdCtrl =
00641 {
00642     SL_OPCODE_WLAN_WLANRXFILTERSETCOMMAND,
00643     sizeof(_WlanRxFilterSetCommand_t),
00644     sizeof(_WlanRxFilterSetCommandReponse_t)
00645 };
00646 
00647 /* Get command */
00648 typedef union _SlRxFilterGetMsg_u
00649 {
00650     _WlanRxFilterGetCommand_t               Cmd;
00651     _WlanRxFilterGetCommandReponse_t        Rsp;
00652 }_SlRxFilterGetMsg_u;
00653 
00654 
00655 const _SlCmdCtrl_t _SlRxFilterGetCmdCtrl =
00656 {
00657     SL_OPCODE_WLAN_WLANRXFILTERGETCOMMAND,
00658     sizeof(_WlanRxFilterGetCommand_t),
00659     sizeof(_WlanRxFilterGetCommandReponse_t)
00660 };
00661 
00662 
00663 /*******************************************************************************/
00664 /*     RX filters  */
00665 /*******************************************************************************/
00666 
00667 #if _SL_INCLUDE_FUNC(sl_WlanRxFilterAdd)
00668 SlrxFilterID_t sl_WlanRxFilterAdd(  SlrxFilterRuleType_t                RuleType,
00669     SlrxFilterFlags_t                   FilterFlags,
00670     const SlrxFilterRule_t* const       Rule,
00671     const SlrxFilterTrigger_t* const    Trigger,
00672     const SlrxFilterAction_t* const     Action,
00673     SlrxFilterID_t*                     pFilterId)
00674 {
00675 
00676 
00677     _SlrxFilterAddMsg_u Msg;
00678     Msg.Cmd.RuleType = RuleType;
00679     /* filterId is zero */
00680     Msg.Cmd.FilterId = 0;
00681     Msg.Cmd.FilterFlags = FilterFlags;
00682     sl_Memcpy( &(Msg.Cmd.Rule), Rule, sizeof(SlrxFilterRule_t) );
00683     sl_Memcpy( &(Msg.Cmd.Trigger), Trigger, sizeof(SlrxFilterTrigger_t) );
00684     sl_Memcpy( &(Msg.Cmd.Action), Action, sizeof(SlrxFilterAction_t) );
00685     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlRxFilterAddtCmdCtrl, &Msg, NULL) );
00686     *pFilterId = Msg.Rsp.FilterId;
00687     return (_i16)Msg.Rsp.Status;
00688 
00689 }
00690 #endif
00691 
00692 
00693 
00694 /*******************************************************************************/
00695 /*     RX filters    */
00696 /*******************************************************************************/
00697 #if _SL_INCLUDE_FUNC(sl_WlanRxFilterSet)
00698 _i16 sl_WlanRxFilterSet(const SLrxFilterOperation_t RxFilterOperation,
00699     const _u8*  const pInputBuffer,
00700     _u16 InputbufferLength)
00701 {
00702     _SlRxFilterSetMsg_u   Msg;
00703     _SlCmdExt_t           CmdExt;
00704 
00705     CmdExt.TxPayloadLen = InputbufferLength;
00706     CmdExt.pTxPayload   = (_u8 *)pInputBuffer;
00707     CmdExt.RxPayloadLen = 0;
00708     CmdExt.pRxPayload   = (_u8 *)NULL;
00709 
00710     Msg.Cmd.RxFilterOperation = RxFilterOperation;
00711     Msg.Cmd.InputBufferLength = InputbufferLength;
00712 
00713 
00714     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlRxFilterSetCmdCtrl, &Msg, &CmdExt) );
00715 
00716 
00717     return (_i16)Msg.Rsp.Status;
00718 }
00719 #endif
00720 
00721 /******************************************************************************/
00722 /*     RX filters  */
00723 /******************************************************************************/
00724 #if _SL_INCLUDE_FUNC(sl_WlanRxFilterGet)
00725 _i16 sl_WlanRxFilterGet(const SLrxFilterOperation_t RxFilterOperation,
00726     _u8*  pOutputBuffer,
00727     _u16 OutputbufferLength)
00728 {
00729     _SlRxFilterGetMsg_u   Msg;
00730     _SlCmdExt_t           CmdExt;
00731 
00732     if (OutputbufferLength == 0)
00733     {
00734         return SL_EZEROLEN;
00735     }
00736     CmdExt.TxPayloadLen = 0;
00737     CmdExt.pTxPayload   = NULL;
00738     CmdExt.RxPayloadLen = OutputbufferLength;
00739     CmdExt.pRxPayload   = (_u8 *)pOutputBuffer;
00740     CmdExt.ActualRxPayloadLen = 0;
00741 
00742     Msg.Cmd.RxFilterOperation = RxFilterOperation;
00743     Msg.Cmd.OutputBufferLength = OutputbufferLength;
00744 
00745 
00746     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlRxFilterGetCmdCtrl, &Msg, &CmdExt) );
00747 
00748     if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen) 
00749     {
00750         return SL_ESMALLBUF;
00751     }
00752 
00753     return (_i16)Msg.Rsp.Status;
00754 }
00755 #endif
00756 
00757 /*******************************************************************************/
00758 /*             sl_WlanRxStatStart                                              */
00759 /*******************************************************************************/
00760 #if _SL_INCLUDE_FUNC(sl_WlanRxStatStart)
00761 _i16 sl_WlanRxStatStart(void)
00762 {
00763     return _SlDrvBasicCmd(SL_OPCODE_WLAN_STARTRXSTATCOMMAND);
00764 }
00765 #endif
00766 
00767 #if _SL_INCLUDE_FUNC(sl_WlanRxStatStop)
00768 _i16 sl_WlanRxStatStop(void)
00769 {
00770     return _SlDrvBasicCmd(SL_OPCODE_WLAN_STOPRXSTATCOMMAND);
00771 }
00772 #endif
00773 
00774 #if _SL_INCLUDE_FUNC(sl_WlanRxStatGet)
00775 _i16 sl_WlanRxStatGet(SlGetRxStatResponse_t *pRxStat,_u32 Flags)
00776 {
00777     _SlCmdCtrl_t            CmdCtrl = {SL_OPCODE_WLAN_GETRXSTATCOMMAND, 0, sizeof(SlGetRxStatResponse_t)};
00778     sl_Memset(pRxStat,0,sizeof(SlGetRxStatResponse_t));
00779     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, pRxStat, NULL)); 
00780 
00781     return 0;
00782 }
00783 #endif
00784 
00785 
00786 
00787 /******************************************************************************/
00788 /*   sl_WlanSmartConfigStop                                                   */
00789 /******************************************************************************/
00790 #if _SL_INCLUDE_FUNC(sl_WlanSmartConfigStop)
00791 _i16 sl_WlanSmartConfigStop(void)
00792 {
00793     return _SlDrvBasicCmd(SL_OPCODE_WLAN_SMART_CONFIG_STOP_COMMAND);
00794 }
00795 #endif
00796 
00797 
00798 /******************************************************************************/
00799 /*   sl_WlanSmartConfigStart                                                  */
00800 /******************************************************************************/
00801 
00802 
00803 typedef struct
00804 {
00805     _WlanSmartConfigStartCommand_t  Args;
00806     _i8                            Strings[3 * MAX_SMART_CONFIG_KEY]; /* public key + groupId1 key + groupId2 key */
00807 }_SlSmartConfigStart_t;
00808 
00809 typedef union
00810 {
00811     _SlSmartConfigStart_t       Cmd;
00812     _BasicResponse_t            Rsp;
00813 }_SlSmartConfigStartMsg_u;
00814 
00815 const _SlCmdCtrl_t _SlSmartConfigStartCmdCtrl =
00816 {
00817     SL_OPCODE_WLAN_SMART_CONFIG_START_COMMAND,
00818     sizeof(_SlSmartConfigStart_t),
00819     sizeof(_BasicResponse_t)
00820 };
00821 
00822 #if _SL_INCLUDE_FUNC(sl_WlanSmartConfigStart)
00823 _i16 sl_WlanSmartConfigStart( const _u32    groupIdBitmask,
00824     const _u8    cipher,
00825     const _u8    publicKeyLen,
00826     const _u8    group1KeyLen,
00827     const _u8    group2KeyLen,
00828     const _u8*    pPublicKey,
00829     const _u8*    pGroup1Key,
00830     const _u8*    pGroup2Key)
00831 {
00832     _SlSmartConfigStartMsg_u      Msg;
00833 
00834     Msg.Cmd.Args.groupIdBitmask = (_u8)groupIdBitmask;
00835     Msg.Cmd.Args.cipher         = (_u8)cipher;
00836     Msg.Cmd.Args.publicKeyLen   = (_u8)publicKeyLen;
00837     Msg.Cmd.Args.group1KeyLen   = (_u8)group1KeyLen;
00838     Msg.Cmd.Args.group2KeyLen   = (_u8)group2KeyLen;
00839 
00840     /* copy keys (if exist) after command (one after another) */
00841     sl_Memcpy(SMART_CONFIG_START_PUBLIC_KEY_STRING(&Msg), pPublicKey, publicKeyLen);
00842     sl_Memcpy(SMART_CONFIG_START_GROUP1_KEY_STRING(&Msg), pGroup1Key, group1KeyLen);
00843     sl_Memcpy(SMART_CONFIG_START_GROUP2_KEY_STRING(&Msg), pGroup2Key, group2KeyLen);
00844 
00845     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSmartConfigStartCmdCtrl , &Msg, NULL));
00846 
00847     return (_i16)Msg.Rsp.status;
00848 
00849 
00850 }
00851 #endif
00852 
00853 
00854 /*******************************************************************************/
00855 /*   sl_WlanSetMode  */
00856 /*******************************************************************************/
00857 typedef union
00858 {
00859     _WlanSetMode_t          Cmd;
00860     _BasicResponse_t        Rsp;
00861 }_SlwlanSetModeMsg_u;
00862 
00863 const _SlCmdCtrl_t _SlWlanSetModeCmdCtrl =
00864 {
00865     SL_OPCODE_WLAN_SET_MODE,
00866     sizeof(_WlanSetMode_t),
00867     sizeof(_BasicResponse_t)
00868 };
00869 
00870 /* possible values are: 
00871 WLAN_SET_STA_MODE   =   1
00872 WLAN_SET_AP_MODE    =   2
00873 WLAN_SET_P2P_MODE   =   3  */
00874 
00875 #if _SL_INCLUDE_FUNC(sl_WlanSetMode)
00876 _i16 sl_WlanSetMode(const _u8    mode)
00877 {
00878     _SlwlanSetModeMsg_u      Msg;
00879 
00880     Msg.Cmd.mode  = mode;
00881 
00882     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlWlanSetModeCmdCtrl , &Msg, NULL));
00883 
00884     return (_i16)Msg.Rsp.status;
00885 
00886 }
00887 #endif
00888 
00889 
00890 
00891 
00892 /*******************************************************************************/
00893 /*   sl_WlanSet  */
00894 /* ******************************************************************************/
00895 typedef union
00896 {
00897     _WlanCfgSetGet_t        Cmd;
00898     _BasicResponse_t        Rsp;
00899 }_SlWlanCfgSetMsg_u;
00900 
00901 const _SlCmdCtrl_t _SlWlanCfgSetCmdCtrl =
00902 {
00903     SL_OPCODE_WLAN_CFG_SET,
00904     sizeof(_WlanCfgSetGet_t),
00905     sizeof(_BasicResponse_t)
00906 };
00907 
00908 
00909 #if _SL_INCLUDE_FUNC(sl_WlanSet)
00910 _i16 sl_WlanSet(_u16 ConfigId ,_u16 ConfigOpt,_u16 ConfigLen, _u8 *pValues)
00911 {
00912     _SlWlanCfgSetMsg_u         Msg;
00913     _SlCmdExt_t                CmdExt;
00914 
00915     CmdExt.TxPayloadLen = (ConfigLen+3) & (~3);
00916     CmdExt.RxPayloadLen = 0;
00917     CmdExt.pTxPayload = (_u8 *)pValues;
00918     CmdExt.pRxPayload = NULL;
00919 
00920 
00921     Msg.Cmd.ConfigId    = ConfigId;
00922     Msg.Cmd.ConfigLen   = ConfigLen;
00923     Msg.Cmd.ConfigOpt   = ConfigOpt;
00924 
00925     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlWlanCfgSetCmdCtrl, &Msg, &CmdExt));
00926 
00927     return (_i16)Msg.Rsp.status;
00928 }
00929 #endif
00930 
00931 
00932 /******************************************************************************/
00933 /*  sl_WlanGet  */
00934 /******************************************************************************/
00935 typedef union
00936 {
00937     _WlanCfgSetGet_t        Cmd;
00938     _WlanCfgSetGet_t        Rsp;
00939 }_SlWlanCfgMsgGet_u;
00940 
00941 const _SlCmdCtrl_t _SlWlanCfgGetCmdCtrl =
00942 {
00943     SL_OPCODE_WLAN_CFG_GET,
00944     sizeof(_WlanCfgSetGet_t),
00945     sizeof(_WlanCfgSetGet_t)
00946 };
00947 
00948 #if _SL_INCLUDE_FUNC(sl_WlanGet)
00949 _i16 sl_WlanGet(_u16 ConfigId, _u16 *pConfigOpt,_u16 *pConfigLen, _u8 *pValues)
00950 {
00951     _SlWlanCfgMsgGet_u        Msg;
00952     _SlCmdExt_t               CmdExt;
00953 
00954     if (*pConfigLen == 0)
00955     {
00956         return SL_EZEROLEN;
00957     }
00958     CmdExt.TxPayloadLen = 0;
00959     CmdExt.RxPayloadLen = *pConfigLen;
00960     CmdExt.pTxPayload = NULL;
00961     CmdExt.pRxPayload = (_u8 *)pValues;
00962     CmdExt.ActualRxPayloadLen = 0;
00963 
00964     Msg.Cmd.ConfigId    = ConfigId;
00965     if( pConfigOpt )
00966     {
00967         Msg.Cmd.ConfigOpt   = (_u16)*pConfigOpt;
00968     }
00969     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlWlanCfgGetCmdCtrl, &Msg, &CmdExt));
00970 
00971     if( pConfigOpt )
00972     {
00973         *pConfigOpt = (_u8)Msg.Rsp.ConfigOpt;
00974     }
00975     if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen) 
00976     {
00977         *pConfigLen = (_u8)CmdExt.RxPayloadLen;
00978         return SL_ESMALLBUF;
00979     }
00980     else
00981     {
00982         *pConfigLen = (_u8)CmdExt.ActualRxPayloadLen;
00983     }
00984 
00985 
00986     return (_i16)Msg.Rsp.Status;
00987 }
00988 #endif
00989