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