1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Handles type conversion between adaptation and core layers

    15 *

    16 */

    17 

    18 /*

    19 * %version: 82 %

    20 */

    21 

    22 #include <in_sock.h>

    23 #include <e32math.h>

    24 

    25 #include "wlanconversionutil.h"

    26 #include "wlmserver.h"

    27 #include "wlmtsparams.h"

    28 #include "am_debug.h"

    29 

    30 /**

    31  * Mappings from user priority to access class.

    32  */

    33 const TWlmAccessClass KWlmUserPriorityToAccessClass[] =

    34     {

    35     EWlmAccessClassBestEffort,

    36     EWlmAccessClassBackground,

    37     EWlmAccessClassBackground,

    38     EWlmAccessClassBestEffort,

    39     EWlmAccessClassVideo,

    40     EWlmAccessClassVideo,

    41     EWlmAccessClassVoice,

    42     EWlmAccessClassVoice    

    43     };

    44 

    45 // Compile time assert. Used to make sure that some core constants are matching with Symbian constants.

    46 #define COMPILE_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1] //lint --e{58,92,751,761,30,452,545}

    47 // 58  = Error -- Bad type

    48 // 92  = Negative array dimension or bit field length (-1)

    49 // 751 = local typedef '__C_ASSERT__' not referenced

    50 // 761 = Redundant typedef '__C_ASSERT__' previously declared at line x

    51 // 30  = Expected an integer constant, obtained an expression that could not be evaluated

    52 // 452 = typedef Symbol '__C_ASSERT__' redeclared (size) conflicts with line x

    53 // 545 = Suspicious use of &

    54 

    55 // ---------------------------------------------------------

    56 // TWlanConversionUtil::ConvertSSID()

    57 // ---------------------------------------------------------

    58 //

    59 void TWlanConversionUtil::ConvertSSID(

    60     core_ssid_s& aCoreSSID,

    61     const TSSID& aSSID )

    62     {

    63     Mem::Copy( aCoreSSID.ssid, aSSID.ssid, aSSID.ssidLength );

    64     aCoreSSID.length = aSSID.ssidLength;

    65     }

    66 

    67 // ---------------------------------------------------------

    68 // TWlanConversionUtil::ConvertSSID()

    69 // ---------------------------------------------------------

    70 //

    71 void TWlanConversionUtil::ConvertSSID(

    72     core_ssid_s& aCoreSSID,

    73     const TDesC& aSSID )

    74     {

    75     TBuf8<KMaxSSIDLength> ssidBuf;

    76     ssidBuf.Copy( aSSID );

    77     

    78     Mem::Copy( aCoreSSID.ssid, ssidBuf.Ptr(), ssidBuf.Length() );

    79     aCoreSSID.length = ssidBuf.Length();

    80     }

    81 

    82 // ---------------------------------------------------------

    83 // TWlanConversionUtil::ConvertSSID()

    84 // ---------------------------------------------------------

    85 //

    86 void TWlanConversionUtil::ConvertSSID(

    87     core_ssid_s& aCoreSSID,

    88     const TDesC8& aSSID )

    89     {

    90     Mem::Copy( aCoreSSID.ssid, aSSID.Ptr(), aSSID.Length() );

    91     aCoreSSID.length = aSSID.Length();

    92     }

    93 

    94 // ---------------------------------------------------------

    95 // TWlanConversionUtil::ConvertSSID()

    96 // ---------------------------------------------------------

    97 //

    98 void TWlanConversionUtil::ConvertSSID(

    99     TSSID& aAmSSID,

   100     const core_ssid_s& aCoreSSID )

   101     {

   102     Mem::Copy( aAmSSID.ssid, aCoreSSID.ssid, aCoreSSID.length );

   103     aAmSSID.ssidLength = aCoreSSID.length;

   104     }

   105 

   106 // ---------------------------------------------------------

   107 // TWlanConversionUtil::ConvertScanRate()

   108 // ---------------------------------------------------------

   109 //

   110 TRate TWlanConversionUtil::ConvertScanRate( int_t aCoreScanRate )

   111     {

   112     return static_cast<TRate>( aCoreScanRate );

   113     }

   114 

   115 // ---------------------------------------------------------

   116 // TWlanConversionUtil::ConvertSecurityMode()

   117 // ---------------------------------------------------------

   118 //

   119 TWlanSecurity TWlanConversionUtil::ConvertSecurityMode(

   120     const core_connection_security_mode_e& aCoreMode )

   121     {

   122     switch( aCoreMode )

   123         {

   124         case core_connection_security_mode_open:

   125             return EWlanSecurityOpen;

   126         case core_connection_security_mode_wep_open:

   127             return EWlanSecurityWepOpen;

   128         case core_connection_security_mode_wep_shared:

   129             return EWlanSecurityWepShared;

   130         case core_connection_security_mode_802d1x:

   131             return EWlanSecurity802d1x;

   132         case core_connection_security_mode_wpa:

   133             return EWlanSecurityWpa;

   134         case core_connection_security_mode_wpa_psk:

   135             return EWlanSecurityWpaPsk;

   136         case core_connection_security_mode_wpa2:

   137             return EWlanSecurityWpa2;

   138         case core_connection_security_mode_wpa2_psk:

   139             return EWlanSecurityWpa2Psk;

   140         case core_connection_security_mode_wapi:

   141             return EWlanSecurityWapi;

   142         case core_connection_security_mode_wapi_psk:

   143             return EWlanSecurityWapiPsk;

   144         default:

   145             return EWlanSecurityOpen;

   146         }

   147     }

   148 

   149 // ---------------------------------------------------------

   150 // TWlanConversionUtil::ConvertEncryptionMode()

   151 // ---------------------------------------------------------

   152 //

   153 TEncryptionStatus TWlanConversionUtil::ConvertEncryptionMode(

   154     const core_encryption_mode_e& aCoreEncryptionMode )

   155     {

   156     switch( aCoreEncryptionMode )

   157         {

   158         case core_encryption_mode_disabled:

   159             return EEncryptionDisabled;

   160         case core_encryption_mode_wep:

   161             return EEncryptionWep;

   162         case core_encryption_mode_802dot1x:

   163             return EEncryption802dot1x;

   164         case core_encryption_mode_wep_mixed_cell:

   165             return EEncryptionWepMixed;

   166         case core_encryption_mode_802dot1x_mixed_cell:

   167             return EEncryption802dot1xMixed;

   168         case core_encryption_mode_wpi:

   169             return EEncryptionWAPI;

   170         default: // instead of case core_encryption_mode_wpa:

   171             return EEncryptionWpa;

   172         }

   173     }

   174 

   175 // ---------------------------------------------------------

   176 // TWlanConversionUtil::ConvertConnectionState()

   177 // ---------------------------------------------------------

   178 //

   179 TWlanConnectionState TWlanConversionUtil::ConvertConnectionState(

   180     const core_connection_state_e& aCoreState )

   181     {

   182     switch( aCoreState )

   183         {

   184         case core_connection_state_notconnected:

   185             return EWlanStateNotConnected;

   186         case core_connection_state_infrastructure:

   187             return EWlanStateInfrastructure;

   188         case core_connection_state_searching:

   189             return EWlanStateSearchingAP;

   190         case core_connection_state_ibss: // fall through on purpose

   191         case core_connection_state_secureibss:

   192             return EWlanStateIBSS;

   193         case core_connection_state_secureinfra:

   194             return EWlanStateSecureInfra;

   195         default:

   196             return EConnectionStateUnknown;

   197         }

   198     }

   199 

   200 // ---------------------------------------------------------

   201 // TWlanConversionUtil::ConvertScanMode()

   202 // ---------------------------------------------------------

   203 //

   204 core_scan_mode_e TWlanConversionUtil::ConvertScanMode(

   205     const TScanMode& aAmScanMode )

   206     {

   207     switch( aAmScanMode )

   208         {

   209         case EActiveScan:

   210             return core_scan_mode_active;

   211         case EPassiveScan:

   212             return core_scan_mode_passive;

   213         default:

   214             return core_scan_mode_passive;

   215         }

   216     }

   217 

   218 // ---------------------------------------------------------

   219 // TWlanConversionUtil::ConvertScanMode()

   220 // ---------------------------------------------------------

   221 //

   222 TScanMode TWlanConversionUtil::ConvertScanMode(

   223     const core_scan_mode_e& aCoreScanMode )

   224     {

   225     switch( aCoreScanMode )

   226         {

   227         case core_scan_mode_active:

   228             return EActiveScan;

   229         case core_scan_mode_passive:

   230             return EPassiveScan;

   231         default:

   232             return EPassiveScan;

   233         }

   234     }

   235 

   236 // ---------------------------------------------------------

   237 // TWlanConversionUtil::ConvertConvertCipherKeyType()

   238 // ---------------------------------------------------------

   239 //

   240 TWlanCipherSuite TWlanConversionUtil::ConvertCipherKeyType(

   241     const core_cipher_key_type_e& aCoreCipherKeyType )

   242     {

   243     switch( aCoreCipherKeyType )

   244         {

   245         case core_cipher_key_type_none:

   246             return EWlanCipherSuiteNone;

   247         case core_cipher_key_type_tkip:

   248             return EWlanCipherSuiteTkip;

   249         case core_cipher_key_type_ccmp:

   250             return EWlanCipherSuiteCcmp;

   251         case core_cipher_key_type_wpi:

   252             return EWlanCipherSuiteWapi;

   253         default:

   254             return EWlanCipherSuiteWep;

   255         }

   256     }

   257 

   258 // ---------------------------------------------------------

   259 // TWlanConversionUtil::ConvertNotificationType()

   260 // ---------------------------------------------------------

   261 //

   262 TWlmNotify TWlanConversionUtil::ConvertNotificationType(

   263     const core_notification_e& aCoreNotificationType )

   264     {

   265     switch( aCoreNotificationType )

   266         {

   267         case core_notification_connection_state_changed:

   268             return EWlmNotifyConnectionStateChanged;

   269         case core_notification_bssid_changed:

   270             return EWlmNotifyBssidChanged;

   271         case core_notification_bss_lost:

   272             return EWlmNotifyBssLost;

   273         case core_notification_bss_regained:

   274             return EWlmNotifyBssRegained;

   275         case core_notification_tx_power_level_changed:

   276             return EWlmNotifyTransmitPowerChanged;

   277         case core_notification_rcp_changed:

   278             return EWlmNotifyRcpChanged;

   279         case core_notification_ts_status_changed:

   280             return EWlmNotifyTrafficStreamStatusChanged;

   281         case core_notification_ap_info_changed:

   282             return EWlmNotifyAccessPointInfoChanged;

   283         case core_notification_rcpi_roam_attempt_started:

   284             return EWlmNotifyRcpiRoamAttemptStarted;

   285         case core_notification_rcpi_roam_attempt_completed:

   286             return EWlmNotifyRcpiRoamAttemptCompleted;

   287         case core_notification_broken_power_save_test_failed:

   288             return EWlmNotifyBrokenPowerSaveTestFailed;

   289         case core_notification_ac_traffic_mode_changed:

   290             return EWlmNotifyAcTrafficModeChanged;

   291         case core_notification_ac_traffic_status_changed:

   292             return EWlmNotifyAcTrafficStatusChanged;

   293         default: // this should never happen

   294             return EWlmNotifyNone;

   295         }

   296     }

   297 

   298 // ---------------------------------------------------------

   299 // TWlanConversionUtil::ConvertConnectStatus()

   300 // ---------------------------------------------------------

   301 //

   302 TInt TWlanConversionUtil::ConvertConnectStatus(

   303     const core_connect_status_e& aCoreConnectStatus,

   304     core_security_mode_e security_mode )

   305     {

   306     switch( aCoreConnectStatus )

   307         {

   308         case core_connect_ok:

   309             return KErrNone;

   310         case core_connect_network_not_found:

   311         case core_connect_mode_infra_required_but_ibss_found:

   312         case core_connect_mode_ibss_required_but_infra_found:

   313         case core_connect_ap_full:

   314         case core_connect_ap_not_whitelisted:

   315         case core_connect_ap_permanently_blacklisted:

   316         case core_connect_ap_temporarily_blacklisted:

   317         case core_connect_ap_outside_defined_region:

   318         case core_connect_iap_open_but_ap_requires_encryption:

   319         case core_connect_iap_wep_but_ap_has_no_privacy:

   320         case core_connect_iap_wpa_but_ap_has_no_privacy:

   321         case core_connect_eapol_auth_start_timeout:

   322         case core_connect_wep_open_authentication_unsupported:

   323         case core_connect_wep_shared_authentication_unsupported:

   324             return KErrWlanNetworkNotFound;

   325         case core_connect_iap_wep_but_ap_has_wpa_ie:

   326             return KErrWlanWpaAuthRequired;

   327         case core_connect_wpa_ap_has_no_valid_ciphers:

   328         case core_connect_wpa_ie_required_but_ap_has_none:

   329             {

   330             if ( security_mode == core_security_mode_wpa2only )

   331                 {

   332                 return KErrWlanWpa2OnlyModeNotSupported;

   333                 }

   334 

   335             return KErrWlanNetworkNotFound;

   336             }

   337         case core_connect_wep_open_echo_test_failed:

   338             return KErrWlanIllegalEncryptionKeys;

   339         case core_connect_wep_shared_authentication_failed:

   340             return KErrWlanSharedKeyAuthFailed;

   341         case core_connect_wpa_psk_required_but_ap_has_no_support:

   342             return KErrWlanEapModeRequired;

   343         case core_connect_wpa_eap_required_but_ap_has_no_support:

   344             return KErrWlanPskModeRequired;

   345         case core_connect_wpa_eap_failure:

   346             return KErrWlanWpaAuthFailed;

   347         case core_connect_wpa_psk_failure:

   348             return KErrWlanIllegalWpaPskKey;

   349         case core_connect_802_1x_failure:

   350         case core_connect_802_1x_authentication_algorithm_not_supported:

   351             return KErrWlan802dot1xAuthFailed;

   352         case core_connect_wpa_authentication_canceled_by_user:

   353         case core_connect_802_1x_authentication_canceled_by_user:

   354             return KErrCancel;

   355         case core_connect_eap_gtc_failure:

   356             return KErrWlanEapGtcFailed;

   357         case core_connect_eap_tls_failure:

   358             return KErrWlanEapTlsFailed;

   359         case core_connect_eap_tls_server_certificate_expired:

   360         case core_connect_eap_ttls_server_certificate_expired:

   361         case core_connect_eap_peap_server_certificate_expired:

   362             return KErrWlanServerCertificateExpired;

   363         case core_connect_eap_tls_server_certificate_unknown:

   364         case core_connect_eap_ttls_server_certificate_unknown:

   365         case core_connect_eap_peap_server_certificate_unknown:

   366             return KErrWlanCerficateVerifyFailed;

   367         case core_connect_eap_tls_user_certificate_expired:

   368         case core_connect_eap_ttls_user_certificate_expired:

   369         case core_connect_eap_peap_user_certificate_expired:

   370             return KErrWlanUserCertificateExpired;

   371         case core_connect_eap_tls_user_certificate_unknown:

   372         case core_connect_eap_ttls_user_certificate_unknown:

   373         case core_connect_eap_peap_user_certificate_unknown:

   374             return KErrWlanNoUserCertificate;

   375         case core_connect_eap_tls_illegal_cipher_suite:

   376         case core_connect_eap_ttls_illegal_cipher_suite:

   377         case core_connect_eap_peap_illegal_cipher_suite:

   378             return KErrWlanNoCipherSuite;

   379         case core_connect_eap_tls_user_rejected:

   380         case core_connect_eap_ttls_user_rejected:

   381         case core_connect_eap_peap_user_rejected:

   382             return KErrWlanUserRejected;

   383         case core_connect_eap_leap_failure:

   384             return KErrWlanLeapFailed;

   385         case core_connect_eap_sim_failure:

   386             return KErrWlanEapSimFailed;

   387         case core_connect_eap_sim_identity_query_failed:

   388         case core_connect_eap_aka_identity_query_failed:

   389             return KErrWlanSimNotInstalled;

   390         case core_connect_eap_sim_user_has_not_subscribed_to_the_requested_service:

   391         case core_connect_eap_aka_user_has_not_subscribed_to_the_requested_service:

   392             return KErrWlanNotSubscribed;

   393         case core_connect_eap_sim_users_calls_are_barred:

   394         case core_connect_eap_aka_users_calls_are_barred:

   395             return KErrWlanAccessBarred;

   396         case core_connect_eap_ttls_failure:

   397             return KErrWlanEapTtlsFailed;

   398         case core_connect_eap_aka_failure:

   399             return KErrWlanEapAkaFailed;

   400         case core_connect_eap_peap_failure:

   401             return KErrWlanEapPeapFailed;

   402         case core_connect_eap_mschapv2_failure:

   403             return KErrWlanEapMsChapv2;

   404         case core_connect_eap_mschapv2_restricted_logon_hours:

   405             return KErrWlanRestrictedLogonHours;

   406         case core_connect_eap_mschapv2_account_disabled:

   407             return KErrWlanAccountDisabled;

   408         case core_connect_eap_mschapv2_no_dialin_permission:

   409             return KErrWlanNoDialinPermissions;

   410         case core_connect_eap_mschapv2_password_expired:

   411             return KErrWlanPasswordExpired;

   412         case core_connect_eap_fast_tunnel_compromise_error:

   413             return KErrWlanEapFastTunnelCompromiseError;

   414         case core_connect_eap_fast_unexpected_tlv_exhanged:

   415             return KErrWlanEapFastUnexpextedTlvExhanged;

   416         case core_connect_eap_fast_no_pac_nor_certs_to_authenticate_with_provision_disabled:

   417             return KErrWlanEapFastNoPacNorCertsToAuthenticateWithProvDisabled;

   418         case core_connect_eap_fast_no_matching_pac_for_aid:

   419             return KErrWlanEapFastNoMatchingPacForAid;

   420         case core_connect_eap_fast_authentication_failed:

   421             return KErrWlanEapFastAuthFailed;

   422         case core_connect_eap_fast_pac_store_corrupted:

   423             return KErrWlanEapFastPacStoreCorrupted;

   424         case core_connect_wapi_ie_required_but_ap_has_none:

   425         case core_connect_wapi_certificate_required_but_ap_has_no_support:

   426         case core_connect_wapi_psk_required_but_ap_has_no_support:

   427         case core_connect_wapi_ap_has_no_valid_ciphers:

   428             return KErrWlanNetworkNotFound;

   429         case core_connect_wapi_psk_failure:

   430             return KErrWlanInternalError;

   431         case core_connect_wapi_certificate_failure:

   432             return KErrWlanInternalError;

   433         default:

   434             return KErrUnknown;

   435         }

   436     }

   437 

   438 // ---------------------------------------------------------

   439 // TWlanConversionUtil::ConvertRegion()

   440 // ---------------------------------------------------------

   441 //

   442 core_wlan_region_e TWlanConversionUtil::ConvertRegion(

   443     const TWlanRegion& aAmRegion )

   444     {

   445     switch( aAmRegion )

   446         {

   447         case EETSI:

   448             return core_wlan_region_etsi;

   449         default:

   450             return core_wlan_region_fcc;

   451         }

   452     }

   453 

   454 // ---------------------------------------------------------

   455 // TWlanConversionUtil::ConvertRegion()

   456 // ---------------------------------------------------------

   457 //

   458 TWlanRegion TWlanConversionUtil::ConvertRegion(

   459     const core_wlan_region_e& aCoreRegion )

   460     {

   461     switch( aCoreRegion )

   462         {

   463         case core_wlan_region_etsi:

   464             return EETSI;

   465         default:

   466             return EFCC;

   467         }

   468     }

   469 

   470 // ---------------------------------------------------------

   471 // TWlanConversionUtil::ConvertMacAddress()

   472 // ---------------------------------------------------------

   473 //

   474 void TWlanConversionUtil::ConvertMacAddress(

   475     TMacAddress& aAmMacAddress,

   476     const core_mac_address_s& aCoreMacAddress )

   477     {

   478     // Function assumes both mac address types have the same length

   479     Mem::Copy( 

   480         aAmMacAddress.iMacAddress, 

   481         aCoreMacAddress.addr, 

   482         MAC_ADDR_LEN );

   483     }

   484 

   485 // ---------------------------------------------------------

   486 // TWlanConversionUtil::ConvertMacAddress()

   487 // ---------------------------------------------------------

   488 //

   489 void TWlanConversionUtil::ConvertMacAddress(

   490     core_mac_address_s& aCoreAddress,

   491     const TMacAddress& aAmMacAddress )

   492     {

   493     // Function assumes both mac address types have the same length

   494     Mem::Copy( 

   495         aCoreAddress.addr, 

   496         aAmMacAddress.iMacAddress, 

   497         MAC_ADDR_LEN );

   498     }

   499 

   500 // ---------------------------------------------------------

   501 // TWlanConversionUtil::ConvertMacAddress()

   502 // ---------------------------------------------------------

   503 //

   504 void TWlanConversionUtil::ConvertMacAddress(

   505     core_mac_address_s& aCoreAddress,

   506     const TMacAddr& aAmMacAddress )

   507     {

   508     // Function assumes both mac address types have the same length

   509     Mem::Copy( 

   510         aCoreAddress.addr, 

   511         aAmMacAddress.iMacAddress, 

   512         MAC_ADDR_LEN );

   513     }

   514 

   515 // ---------------------------------------------------------

   516 // TWlanConversionUtil::ConvertMacAddress()

   517 // ---------------------------------------------------------

   518 //

   519 void TWlanConversionUtil::ConvertMacAddress(

   520     TMacAddress& aCoreAddress,

   521     const TMacAddr& aAmMacAddress )

   522     {

   523     // Function assumes both mac address types have the same length

   524     Mem::Copy( 

   525         aCoreAddress.iMacAddress, 

   526         aAmMacAddress.iMacAddress, 

   527         MAC_ADDR_LEN );

   528     }

   529 

   530 // ---------------------------------------------------------

   531 // TWlanConversionUtil::ConvertPowerMode()

   532 // ---------------------------------------------------------

   533 //

   534 TPowerMode TWlanConversionUtil::ConvertPowerMode(

   535     const core_power_mode_e& aCorePowerMode )

   536     {

   537     switch( aCorePowerMode )

   538         {

   539         case core_power_mode_cam:

   540             return EPowerModeCam;

   541         default:

   542             return EPowerModePs;

   543         }

   544     }

   545 

   546 // ---------------------------------------------------------

   547 // TWlanConversionUtil::ConvertWakeUpInterval()

   548 // ---------------------------------------------------------

   549 //

   550 void TWlanConversionUtil::ConvertWakeUpInterval(

   551     TWlanWakeUpInterval& aAmWakeUpMode,

   552     TUint8& aAmWakeUpInterval,

   553     const core_power_save_wakeup_mode_e& aCoreWakeUpMode,

   554     const u8_t& aCoreWakeUpInterval )

   555     {

   556     switch( aCoreWakeUpMode )

   557         {

   558         case core_power_save_wakeup_mode_dtim:

   559             {

   560             if( aCoreWakeUpInterval == 1 )

   561                 {

   562                 aAmWakeUpMode = EWakeUpIntervalAllDtims;

   563                 aAmWakeUpInterval = 0;

   564                 }

   565             else

   566                 {

   567                 aAmWakeUpMode = EWakeUpIntervalEveryNthDtim;

   568                 aAmWakeUpInterval = aCoreWakeUpInterval;

   569                 }

   570             break;

   571             }       

   572         default:

   573             {

   574             if( aCoreWakeUpInterval == 1 )

   575                 {

   576                 aAmWakeUpMode = EWakeUpIntervalAllBeacons;

   577                 aAmWakeUpInterval = 0;

   578                 }

   579             else

   580                 {

   581                 aAmWakeUpMode = EWakeUpIntervalEveryNthBeacon;

   582                 aAmWakeUpInterval = aCoreWakeUpInterval;

   583                 }

   584             break;

   585             }

   586         }

   587     }

   588 

   589 // ---------------------------------------------------------

   590 // TWlanConversionUtil::ConvertIndication()

   591 // ---------------------------------------------------------

   592 //

   593 core_am_indication_e TWlanConversionUtil::ConvertIndication(

   594     const TIndication& aAmIndication )

   595     {

   596     switch( aAmIndication )

   597         {

   598         case EMediaDisconnect:        

   599             return core_am_indication_wlan_media_disconnect;

   600         case EOsPowerStandby:

   601             return core_am_indication_os_power_standby;

   602         case EHWFailed:

   603             return core_am_indication_wlan_hw_failed;

   604         case EConsecutiveBeaconsLost:

   605             return core_am_indication_wlan_beacon_lost;

   606         case EConsecutiveTxFailures:

   607             return core_am_indication_wlan_tx_fail;

   608         case EConsecutivePwrModeSetFailures:

   609             return core_am_indication_wlan_power_mode_failure;

   610         case EBSSRegained:

   611             return core_am_indication_wlan_bss_regained;

   612         case EWepDecryptFailure:

   613             return core_am_indication_wlan_wep_decrypt_failure;

   614         case EPairwiseKeyMicFailure:

   615             return core_am_indication_wlan_pairwise_key_mic_failure;

   616         case EGroupKeyMicFailure:

   617             return core_am_indication_wlan_group_key_mic_failure;

   618         case ERcpiTrigger:

   619             return core_am_indication_wlan_rcpi_trigger;

   620         case EScanCompleted:

   621             return core_am_indication_wlan_scan_complete;

   622         case ESignalLossPrediction:

   623             return core_am_indication_wlan_signal_loss_prediction;

   624         case EApTestOpportunity:

   625             return core_am_indication_wlan_power_save_test_trigger;

   626         case EVoiceCallOn:

   627             return core_am_indication_voice_call_on;

   628         case EVoiceCallOff:

   629             return core_am_indication_voice_call_off;

   630         case EPsModeError:

   631             return core_am_indication_wlan_ap_ps_mode_error;

   632         default:

   633             return core_am_indication_wlan_hw_failed;

   634         }

   635     }

   636 

   637 // ---------------------------------------------------------

   638 // TWlanConversionUtil::ConvertDeviceSettings()

   639 // ---------------------------------------------------------

   640 //

   641 void TWlanConversionUtil::ConvertDeviceSettings(

   642     core_device_settings_s& aCoreSettings,

   643     const CWlanDeviceSettings::SWlanDeviceSettings& aAmSettings )

   644     {

   645     aCoreSettings.beacon = static_cast<u32_t>( aAmSettings.beacon );

   646     aCoreSettings.long_retry = static_cast<u32_t>( aAmSettings.longRetry );

   647     aCoreSettings.short_retry = static_cast<u32_t>( aAmSettings.shortRetry );

   648     aCoreSettings.rts = static_cast<u32_t>( aAmSettings.rts );

   649     aCoreSettings.tx_power_level = TWlanConversionUtil::ConvertMilliwattsToDecibel( aAmSettings.txPowerLevel );    

   650 	aCoreSettings.scan_rate = static_cast<u32_t>( aAmSettings.scanRate ); // TRate -> u32_t

   651 	aCoreSettings.rcpi_trigger = static_cast<u32_t>( aAmSettings.rcpiTrigger );

   652 	aCoreSettings.active_scan_min_ch_time = static_cast<u32_t>( aAmSettings.minActiveChannelTime );

   653 	aCoreSettings.active_scan_max_ch_time = static_cast<u32_t>( aAmSettings.maxActiveChannelTime );

   654 	aCoreSettings.passive_scan_min_ch_time = static_cast<u32_t>( aAmSettings.minPassiveChannelTime );

   655 	aCoreSettings.passive_scan_max_ch_time = static_cast<u32_t>( aAmSettings.maxPassiveChannelTime );

   656     aCoreSettings.max_tx_msdu_life_time = static_cast<u32_t>( aAmSettings.maxTxMSDULifeTime );

   657     aCoreSettings.unload_driver_timer = static_cast<u32_t>( aAmSettings.unloadDriverTimer );

   658     aCoreSettings.roam_timer = static_cast<u32_t>( aAmSettings.roamTimer );

   659     aCoreSettings.rcpi_difference = static_cast<u32_t>( aAmSettings.rcpiDifference );

   660     aCoreSettings.max_tries_to_find_nw = static_cast<u32_t>( aAmSettings.maxTriesToFindNw );

   661     aCoreSettings.delay_between_find_nw = static_cast<u32_t>( aAmSettings.delayBetweenFindNw );

   662     aCoreSettings.power_save_enabled = static_cast<u32_t>( aAmSettings.powerMode );

   663     aCoreSettings.allow_radio_measurements = static_cast<bool_t>( aAmSettings.allowRadioMeasurements );    

   664     aCoreSettings.max_ap_association_failure_count = static_cast<u32_t>( aAmSettings.maxApFailureCount );

   665     aCoreSettings.max_ap_authentication_failure_count = static_cast<u32_t>( aAmSettings.maxApAuthFailureCount );

   666     aCoreSettings.long_beacon_find_count = static_cast<u32_t>( aAmSettings.longBeaconFindCount );

   667     aCoreSettings.qos_null_frame_interval = static_cast<u32_t>( aAmSettings.qosNullFrameInterval );

   668     aCoreSettings.qos_null_frame_exit_timeout = static_cast<u32_t>( aAmSettings.qosNullFrameTimeout );

   669     aCoreSettings.qos_null_frame_entry_timeout = static_cast<u32_t>( aAmSettings.qosNullFrameEntryTimeout );

   670     aCoreSettings.qos_null_frame_entry_tx_count = static_cast<u32_t>( aAmSettings.qosNullFrameEntryTxCount );

   671     aCoreSettings.keep_alive_interval = static_cast<u32_t>( aAmSettings.keepAliveInterval );

   672     aCoreSettings.scan_stop_rcpi_threshold = static_cast<u32_t>( aAmSettings.scanStopRcpiThreshold );

   673     aCoreSettings.iap_availability_rcpi_threshold = static_cast<u32_t>( aAmSettings.minRcpiForIapAvailability );

   674     aCoreSettings.max_ap_deauthentication_count = static_cast<u32_t>( aAmSettings.maxApDeauthenticationCount );

   675     aCoreSettings.ap_deauthentication_timeout = static_cast<u32_t>( aAmSettings.apDeauthenticationTimeout );    

   676     aCoreSettings.sp_rcpi_target = static_cast<u32_t>( aAmSettings.spRcpiTarget );

   677     aCoreSettings.sp_time_target = static_cast<u32_t>( aAmSettings.spTimeTarget );

   678     aCoreSettings.sp_min_indication_interval = static_cast<u32_t>( aAmSettings.spMinIndicationInterval );

   679     aCoreSettings.scan_list_expiration_time = static_cast<u32_t>( aAmSettings.scanListExpirationTime );

   680     aCoreSettings.rcpi_roam_min_interval = static_cast<u32_t>( aAmSettings.rcpiRoamMinInterval );

   681     aCoreSettings.rcpi_roam_max_interval = static_cast<u32_t>( aAmSettings.rcpiRoamMaxInterval );

   682     aCoreSettings.rcpi_roam_attempts_per_interval = static_cast<u32_t>( aAmSettings.rcpiRoamAttemptsPerInterval );

   683     aCoreSettings.rcpi_roam_next_interval_factor = static_cast<u32_t>( aAmSettings.rcpiRoamNextIntervalFactor );

   684     aCoreSettings.rcpi_roam_next_interval_addition = static_cast<u32_t>( aAmSettings.rcpiRoamNextIntervalAddition );    

   685     aCoreSettings.bss_lost_roam_min_interval = static_cast<u32_t>( aAmSettings.bssLostRoamMinInterval );

   686     aCoreSettings.bss_lost_roam_max_interval = static_cast<u32_t>( aAmSettings.bssLostRoamMaxInterval );

   687     aCoreSettings.bss_lost_roam_attempts_per_interval = static_cast<u32_t>( aAmSettings.bssLostRoamAttemptsPerInterval );

   688     aCoreSettings.bss_lost_roam_next_interval_factor = static_cast<u32_t>( aAmSettings.bssLostRoamNextIntervalFactor );

   689     aCoreSettings.bss_lost_roam_next_interval_addition = static_cast<u32_t>( aAmSettings.bssLostRoamNextIntervalAddition );

   690     aCoreSettings.bss_lost_roam_max_tries_to_find_nw = static_cast<u32_t>( aAmSettings.bssLostRoamMaxTriesToFindNw );        

   691     aCoreSettings.max_dtim_skip_interval = static_cast<u32_t>( aAmSettings.maxDtimSkipInterval );

   692     aCoreSettings.ps_active_to_light_timeout = static_cast<u32_t>( aAmSettings.psActiveToLightTimeout );

   693     aCoreSettings.ps_active_to_light_threshold = static_cast<u32_t>( aAmSettings.psActiveToLightThreshold );

   694     aCoreSettings.ps_light_to_active_timeout = static_cast<u32_t>( aAmSettings.psLightToActiveTimeout );

   695     aCoreSettings.ps_light_to_active_threshold = static_cast<u32_t>( aAmSettings.psLightToActiveThreshold );

   696     aCoreSettings.ps_light_to_deep_timeout = static_cast<u32_t>( aAmSettings.psLightToDeepTimeout );

   697     aCoreSettings.ps_light_to_deep_threshold = static_cast<u32_t>( aAmSettings.psLightToDeepThreshold );

   698     aCoreSettings.ps_uapsd_rx_frame_length = static_cast<u32_t>( aAmSettings.psUapsdRxThreshold );

   699     aCoreSettings.rrm_min_measurement_interval = static_cast<u32_t>( aAmSettings.rrmMinMeasurementInterval );

   700     }

   701 

   702 // ---------------------------------------------------------

   703 // TWlanConversionUtil::ConvertIapSettings()

   704 // ---------------------------------------------------------

   705 //

   706 void TWlanConversionUtil::ConvertIapSettings(

   707     core_iap_data_s& aCoreSettings,

   708     const SWLANSettings& aAmSettings,

   709     const TBool aDhcpInUse,

   710     const TWLMOverrideSettings& aOverrideSettings )

   711     {

   712     Mem::FillZ( &aCoreSettings, sizeof( aCoreSettings ) );

   713 

   714     aCoreSettings.id = aAmSettings.ServiceID; // LanService table row-id

   715 

   716     // Handle

   717     // Connection mode

   718     if ( aAmSettings.ConnectionMode == Adhoc ||

   719          aOverrideSettings.settingsMask & EOverrideIbssMask )

   720         {

   721         aCoreSettings.op_mode = core_operating_mode_ibss;

   722         }

   723     else

   724         {

   725         aCoreSettings.op_mode = core_operating_mode_infrastructure;

   726         }

   727     

   728     // Handle

   729     // SSID

   730     if( aOverrideSettings.settingsMask & EOverrideSsidMask )

   731         {

   732         Mem::Copy( 

   733             aCoreSettings.ssid.ssid,

   734             aOverrideSettings.ssid.ssid, 

   735             aOverrideSettings.ssid.ssidLength );

   736         aCoreSettings.ssid.length = aOverrideSettings.ssid.ssidLength;

   737         }

   738     else

   739         {

   740         TBuf8<MAX_SSID_LEN> buf8;

   741         buf8.Copy( aAmSettings.SSID );

   742         Mem::Copy( 

   743             aCoreSettings.ssid.ssid,

   744             buf8.Ptr(),

   745             aAmSettings.SSID.Length() );

   746         aCoreSettings.ssid.length = aAmSettings.SSID.Length();        

   747         }

   748 

   749     // Handle

   750     // ScanSSID / is_hidden

   751     if( aAmSettings.ScanSSID )

   752         {

   753         aCoreSettings.is_hidden = true_t;

   754         }

   755     else

   756         {

   757         aCoreSettings.is_hidden = false_t;

   758         }

   759     

   760     // Handle

   761     // Security mode

   762     switch( aAmSettings.SecurityMode )

   763         {

   764         case AllowUnsecure:

   765             aCoreSettings.security_mode = core_security_mode_allow_unsecure;

   766             break;

   767         case Wep:

   768             aCoreSettings.security_mode = core_security_mode_wep;

   769             break;

   770         case Wlan8021x:

   771             aCoreSettings.security_mode = core_security_mode_802dot1x;

   772             break;

   773         case Wpa:

   774             aCoreSettings.security_mode = core_security_mode_wpa;

   775             break;            

   776         case Wpa2Only:

   777             aCoreSettings.security_mode = core_security_mode_wpa2only;

   778             break;

   779         case Wapi:

   780             aCoreSettings.security_mode = core_security_mode_wapi;

   781             break;            

   782         default:

   783             aCoreSettings.security_mode = core_security_mode_allow_unsecure;

   784         }

   785 

   786     // Handle

   787     // WEP Keys

   788     if( aOverrideSettings.settingsMask & EOverrideWepMask )

   789         {

   790         aCoreSettings.wep_key1.key_index = aOverrideSettings.wep.KeyIndex;

   791         aCoreSettings.wep_key1.key_length = aOverrideSettings.wep.KeyLength;

   792         Mem::Copy(

   793             aCoreSettings.wep_key1.key_data, 

   794             aOverrideSettings.wep.KeyMaterial, 

   795             MAX_WEP_KEY_LENGTH );

   796         aCoreSettings.default_wep_key = aOverrideSettings.wep.KeyIndex;

   797         aCoreSettings.security_mode = core_security_mode_wep;        

   798 

   799         aCoreSettings.wep_key2.key_length = 0;

   800         aCoreSettings.wep_key3.key_length = 0;

   801         aCoreSettings.wep_key4.key_length = 0;

   802         }

   803     else

   804         {

   805         aCoreSettings.wep_key1.key_index = aAmSettings.WepKey1.KeyIndex;

   806         aCoreSettings.wep_key1.key_length = aAmSettings.WepKey1.KeyLength;

   807         Mem::Copy( 

   808             aCoreSettings.wep_key1.key_data, 

   809             aAmSettings.WepKey1.KeyMaterial, 

   810             MAX_WEP_KEY_LENGTH );

   811 

   812         aCoreSettings.wep_key2.key_index = aAmSettings.WepKey2.KeyIndex;

   813         aCoreSettings.wep_key2.key_length = aAmSettings.WepKey2.KeyLength;

   814         Mem::Copy( 

   815             aCoreSettings.wep_key2.key_data, 

   816             aAmSettings.WepKey2.KeyMaterial, 

   817             MAX_WEP_KEY_LENGTH );

   818 

   819         aCoreSettings.wep_key3.key_index = aAmSettings.WepKey3.KeyIndex;

   820         aCoreSettings.wep_key3.key_length = aAmSettings.WepKey3.KeyLength;

   821         Mem::Copy( 

   822             aCoreSettings.wep_key3.key_data, 

   823             aAmSettings.WepKey3.KeyMaterial, 

   824             MAX_WEP_KEY_LENGTH );

   825 

   826         aCoreSettings.wep_key4.key_index = aAmSettings.WepKey4.KeyIndex;

   827         aCoreSettings.wep_key4.key_length = aAmSettings.WepKey4.KeyLength;

   828         Mem::Copy( 

   829             aCoreSettings.wep_key4.key_data, 

   830             aAmSettings.WepKey4.KeyMaterial, 

   831             MAX_WEP_KEY_LENGTH );

   832 

   833         aCoreSettings.default_wep_key = aAmSettings.WepIndex;        

   834         }

   835 

   836     // Handle

   837     // Authentication mode

   838     switch( aAmSettings.AuthenticationMode )

   839         {

   840         case EWepAuthModeShared:

   841             aCoreSettings.authentication_mode = core_authentication_mode_shared;

   842             break;

   843         case EWepAuthModeOpen:

   844             /** Falls through on purpose. */

   845         default:

   846             aCoreSettings.authentication_mode = core_authentication_mode_open;

   847             break;

   848         }

   849 

   850     // Handle

   851     // Preshared key

   852     aCoreSettings.wpa_preshared_key_in_use = aAmSettings.EnableWpaPsk;

   853     if ( aAmSettings.EnableWpaPsk )

   854         {

   855         Mem::Copy(

   856             aCoreSettings.wpa_preshared_key.key_data,

   857             aAmSettings.WPAPreSharedKey.Ptr(),

   858             aAmSettings.WPAKeyLength );

   859         aCoreSettings.wpa_preshared_key.key_length = aAmSettings.WPAKeyLength;

   860         }

   861 

   862     // Handle

   863     // EOverrideWpaPskMask

   864     if ( aOverrideSettings.settingsMask & EOverrideWpaPskMask )

   865         {

   866         Mem::Copy(

   867             aCoreSettings.wpa_preshared_key.key_data,

   868             aOverrideSettings.wpaPsk.KeyMaterial,

   869             aOverrideSettings.wpaPsk.KeyLength );

   870         aCoreSettings.wpa_preshared_key.key_length = aOverrideSettings.wpaPsk.KeyLength;

   871         aCoreSettings.security_mode = core_security_mode_wpa;

   872         aCoreSettings.wpa_preshared_key_in_use = true_t;

   873         aCoreSettings.is_wpa_overriden = true_t;

   874         }

   875 

   876     // Handle

   877     // EOverrideWpaMask

   878     if ( aOverrideSettings.settingsMask & EOverrideWpaMask )

   879         {

   880         aCoreSettings.wpa_preshared_key.key_length = 0;

   881         aCoreSettings.security_mode = core_security_mode_wpa;

   882         aCoreSettings.wpa_preshared_key_in_use = false_t;

   883         aCoreSettings.is_wpa_overriden = true_t;

   884         }

   885 

   886     // Handle

   887     // ChannelId (Adhoc feature)

   888     aCoreSettings.used_adhoc_channel = aAmSettings.ChannelID;

   889 

   890     // Handle DHCP vs static IP

   891     aCoreSettings.is_dynamic_ip_addr = aDhcpInUse;    

   892 

   893     // Roaming is always allowed.

   894     aCoreSettings.is_roaming_allowed = true_t;

   895     }

   896 

   897 // ---------------------------------------------------------

   898 // TWlanConversionUtil::ConvertIapSettings()

   899 // ---------------------------------------------------------

   900 //

   901 void TWlanConversionUtil::ConvertIapSettings(

   902     core_iap_data_s& aCoreSettings,

   903     const TWlanLimitedIapData& aAmSettings )

   904     {

   905     Mem::FillZ( &aCoreSettings, sizeof( aCoreSettings ) );

   906 

   907     aCoreSettings.id = aAmSettings.iapId;

   908 

   909     // Handle

   910     // Connection mode

   911     if ( aAmSettings.networkType == Adhoc )

   912         {

   913         aCoreSettings.op_mode = core_operating_mode_ibss;

   914         }

   915     else

   916         {

   917         aCoreSettings.op_mode = core_operating_mode_infrastructure;

   918         }

   919     

   920     // Handle

   921     // SSID

   922     ConvertSSID( aCoreSettings.ssid, aAmSettings.ssid );

   923 

   924     // Handle

   925     // ScanSSID / is_hidden

   926     if( aAmSettings.isHidden )

   927         {

   928         aCoreSettings.is_hidden = true_t;

   929         }

   930     else

   931         {

   932         aCoreSettings.is_hidden = false_t;

   933         }

   934     

   935     // Handle

   936     // Security mode

   937     switch( aAmSettings.securityMode )

   938         {

   939         case AllowUnsecure:

   940             aCoreSettings.security_mode = core_security_mode_allow_unsecure;

   941             break;

   942         case Wep:

   943             aCoreSettings.security_mode = core_security_mode_wep;

   944             break;

   945         case Wlan8021x:

   946             aCoreSettings.security_mode = core_security_mode_802dot1x;

   947             break;

   948         case Wpa:

   949             aCoreSettings.security_mode = core_security_mode_wpa;

   950             break;            

   951         case Wpa2Only:

   952             aCoreSettings.security_mode = core_security_mode_wpa2only;

   953             break;

   954         case Wapi:

   955             aCoreSettings.security_mode = core_security_mode_wapi;

   956             break;

   957         default:

   958             aCoreSettings.security_mode = core_security_mode_allow_unsecure;

   959         }

   960 

   961     // Handle

   962     // Preshared key

   963     aCoreSettings.wpa_preshared_key_in_use = aAmSettings.isPskEnabled;

   964     }

   965 

   966 // ---------------------------------------------------------

   967 // TWlanConversionUtil::ConvertErrorCode()

   968 // ---------------------------------------------------------

   969 //

   970 TInt TWlanConversionUtil::ConvertErrorCode( const core_error_e aError )

   971     {

   972     switch ( aError )

   973         {

   974         case core_error_ok:

   975             return KErrNone;

   976         case core_error_not_found:

   977             return KErrNotFound;

   978         case core_error_no_memory:

   979             return KErrNoMemory;

   980         case core_error_illegal_argument:

   981             return KErrArgument;

   982         case core_error_not_supported:

   983             return KErrNotSupported;

   984         case core_error_in_use:

   985             return KErrInUse;

   986         case core_error_timeout:

   987             return KErrTimedOut;

   988         case core_error_connection_already_active:

   989             return KErrWlanConnAlreadyActive;

   990         case core_error_wlan_disabled:

   991             return KErrNotReady;

   992         case core_error_cancel:

   993             return KErrCancel;

   994         case core_error_already_exists:

   995             return KErrAlreadyExists;

   996         case core_error_illegal_rate:

   997         case core_error_failed:

   998         case core_error_drivers_not_loaded:

   999         case core_error_in_power_save:

  1000         case core_error_challenge_failure:

  1001         case core_error_not_connected:

  1002         case core_error_general:

  1003         default:

  1004             return KErrGeneral;

  1005         }

  1006     }

  1007 

  1008 // ---------------------------------------------------------

  1009 // TWlanConversionUtil::ConvertErrorCode()

  1010 // ---------------------------------------------------------

  1011 //

  1012 core_error_e TWlanConversionUtil::ConvertErrorCode( const TInt aError )

  1013     {

  1014     switch ( aError )

  1015         {

  1016         case KErrNone:

  1017             return core_error_ok;

  1018         case KErrNotFound:

  1019             return core_error_not_found;

  1020         case KErrNoMemory:

  1021             return core_error_no_memory;

  1022         case KErrNotSupported:

  1023             return core_error_not_supported;

  1024         case KErrArgument:

  1025             return core_error_illegal_argument;

  1026         case KErrInUse:

  1027             return core_error_in_use;

  1028         case KErrTimedOut:

  1029             return core_error_timeout;

  1030         case KErrCancel:

  1031             return core_error_cancel;

  1032         case KErrAlreadyExists:

  1033             return core_error_already_exists;

  1034         default:

  1035             return core_error_general;    

  1036         }

  1037     }

  1038 

  1039 // ---------------------------------------------------------

  1040 // TWlanConversionUtil::ConvertMilliwattsToDecibel()

  1041 // ---------------------------------------------------------

  1042 //

  1043 u32_t TWlanConversionUtil::ConvertMilliwattsToDecibel(

  1044     const TUint32 aValue )

  1045     {

  1046     TReal realResult( 0 );

  1047     TInt32 intResult( 0 );

  1048     TUint32 retValue( 0 );

  1049 

  1050     DEBUG1( "TWlanConversionUtil::ConvertMilliwattsToDecibel() - aValue = %u",

  1051         aValue );

  1052     

  1053     if ( ( Math::Log( realResult, aValue ) == KErrNone ) &&

  1054          ( Math::Int( intResult, realResult * 10 ) == KErrNone ) )

  1055         {

  1056         if ( intResult )

  1057             {

  1058             retValue = intResult;

  1059             }        

  1060         }

  1061     

  1062     DEBUG1( "TWlanConversionUtil::ConvertMilliwattsToDecibel() - retValue = %u",

  1063         retValue );

  1064     return static_cast<u32_t>( retValue );

  1065     }

  1066 

  1067 // ---------------------------------------------------------

  1068 // TWlanConversionUtil::ConvertDecibelToMilliWatts()

  1069 // ---------------------------------------------------------

  1070 //

  1071 TUint32 TWlanConversionUtil::ConvertDecibelToMilliWatts(

  1072     const u32_t aValue )

  1073     {

  1074     TReal realResult( 0 );

  1075     TReal realRound( 0 );

  1076     const TReal realValue( 10 );

  1077     const TReal realPower( static_cast<TUint32>( aValue ) );

  1078     TInt32 intResult( 0 );

  1079     TInt32 intDecimalPlaces( 0 );

  1080     TUint32 retValue( 1 );

  1081 

  1082     DEBUG1( "TWlanConversionUtil::ConvertDecibelToMilliWatts() - aValue = %u",

  1083         aValue );

  1084 

  1085     if ( ( Math::Pow( realResult, realValue, realPower / 10 ) == KErrNone ) &&

  1086          ( Math::Round( realRound, realResult, intDecimalPlaces ) == KErrNone ) &&

  1087          ( Math::Int( intResult, realRound ) == KErrNone ) )

  1088         {

  1089         if ( intResult )

  1090             {

  1091             retValue = intResult;

  1092             }

  1093         }

  1094 

  1095     DEBUG1( "TWlanConversionUtil::ConvertDecibelToMilliWatts() - retValue = %u",

  1096         retValue );

  1097     return retValue;

  1098     }

  1099 

  1100 // ---------------------------------------------------------

  1101 // TWlanConversionUtil::ConvertRcpClass()

  1102 // ---------------------------------------------------------

  1103 //

  1104 TWlanRCPLevel TWlanConversionUtil::ConvertRcpClass(

  1105     const core_rcp_class_e aValue )

  1106     {

  1107     switch( aValue )

  1108         {

  1109         case core_rcp_weak:

  1110             return EWlanRcpWeak;

  1111         default:

  1112             return EWlanRcpNormal;

  1113         }

  1114     }

  1115 

  1116 // ---------------------------------------------------------

  1117 // TWlanConversionUtil::ConvertScanChannels()

  1118 // ---------------------------------------------------------

  1119 //

  1120 void TWlanConversionUtil::ConvertScanChannels(

  1121     SChannels& aAmChannels,

  1122     const core_scan_channels_s& aCoreChannels )

  1123     {

  1124     aAmChannels.iBand = aCoreChannels.band;

  1125     Mem::Copy(

  1126         &aAmChannels.iChannels2dot4GHz[0],

  1127         &aCoreChannels.channels2dot4ghz[0],

  1128         sizeof( aCoreChannels.channels2dot4ghz ) );

  1129     Mem::Copy(

  1130         &aAmChannels.iChannels4dot9GHz[0],

  1131         &aCoreChannels.channels4dot9ghz[0],

  1132         sizeof( aCoreChannels.channels4dot9ghz ) );

  1133     Mem::Copy(

  1134         &aAmChannels.iChannels5GHz[0],