1 /*

     2 * Copyright (c) 2002-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: 32 %

    20 */

    21 

    22 #ifndef WLANCONVERSIONUTIL_H

    23 #define WLANCONVERSIONUTIL_H

    24 

    25 #include <wdbifwlansettings.h>  // Used in SIAPSettings.

    26 #include <wdbiflansettings.h>   // Used in SLanSettings.

    27 #include <wlancontrolinterface.h>

    28 #include <wlantrafficstreamparameters.h>

    29 #include "FrameXferBlock.h"

    30 #include "wlmclientserver.h"

    31 #include "core_types.h"

    32 #include "core_type_list.h"

    33 #include "wlandevicesettings.h"

    34 #include "umac_types.h"

    35 #include "wlanpowersaveinterface.h"

    36 #include "wlanhwinit.h"

    37 

    38 /**

    39 * Utility class for making type conversion between Symbian and "Wlan Core" types

    40 * @lib wlmserversrv.lib

    41 * @since Series 60 3.0

    42 */

    43 class TWlanConversionUtil

    44     {

    45     public:  // New functions

    46 

    47         /**

    48         * ConvertSSID

    49         * @since Series 60 3.0

    50         * @param aCoreSSID (OUT)

    51         * @param aSSID (IN)

    52         */    

    53         static void ConvertSSID(

    54             core_ssid_s& aCoreSSID,

    55             const TSSID& aSSID );

    56 

    57         /**

    58         * ConvertSSID

    59         * @since Series 60 3.0

    60         * @param aCoreSSID (OUT)

    61         * @param aSSID (IN)

    62         */    

    63         static void ConvertSSID(

    64             core_ssid_s& aCoreSSID,

    65             const TDesC& aSSID );

    66 

    67         /**

    68         * ConvertSSID

    69         * @since Series 60 3.0

    70         * @param aCoreSSID (OUT)

    71         * @param aSSID (IN)

    72         */    

    73         static void ConvertSSID(

    74             core_ssid_s& aCoreSSID,

    75             const TDesC8& aSSID );

    76 

    77         /**

    78         * ConvertSSID

    79         * @since Series 60 3.0

    80         * @param aCoreSSID

    81         * @

    82         */    

    83         static void ConvertSSID(

    84             TSSID& aAmSSID,

    85             const core_ssid_s& aCoreSSID );

    86 

    87         /**

    88         * ConvertScanRate

    89         * @since Series 60 3.0

    90         * @param aCoreScanRate

    91         * @return TRate

    92         */    

    93         static TRate ConvertScanRate( int_t aCoreScanRate );

    94 

    95         /**

    96         * ConvertSecurityMode

    97         * @since Series 60 3.0

    98         * @param aCoreMode

    99         * @return TWlanSecurity

   100         */    

   101         static TWlanSecurity ConvertSecurityMode(

   102             const core_connection_security_mode_e& aCoreMode );

   103 

   104         /**

   105         * ConvertEncryptionMode

   106         * @since Series 60 3.0

   107         * @param aCoreEncryptionMode

   108         * @return TWEPStatus

   109         */    

   110         static TEncryptionStatus ConvertEncryptionMode(

   111             const core_encryption_mode_e& aCoreEncryptionMode );

   112 

   113         /**

   114         * ConvertConnectionState

   115         * @since Series 60 3.0

   116         * @param aCoreState

   117         * @return TWlanConnectionState 

   118         */   

   119         static TWlanConnectionState ConvertConnectionState(

   120             const core_connection_state_e& aCoreState );

   121 

   122         /**

   123         * ConvertScanMode

   124         * @since Series 60 3.0

   125         * @param aAmScanMode

   126         * @return core_scan_mode_e 

   127         */   

   128         static core_scan_mode_e ConvertScanMode(

   129             const TScanMode& aAmScanMode );

   130 

   131         /**

   132         * ConvertScanMode

   133         * @since Series 60 3.0

   134         * @param aCoreScanMode

   135         * @return TScanMode 

   136         */   

   137         static TScanMode ConvertScanMode(

   138             const core_scan_mode_e& aCoreScanMode );

   139 

   140         /**

   141         * ConvertConvertCipherKeyType

   142         * @since Series 60 3.0

   143         * @param aCoreCipherKeyType

   144         * @return TWlanCipherSuite

   145         */   

   146         static TWlanCipherSuite ConvertCipherKeyType(

   147             const core_cipher_key_type_e& aCoreCipherKeyType );

   148 

   149         /**

   150         * ConvertNotificationType

   151         * @since Series 60 3.0

   152         * @param aCoreNotificationType

   153         * @return TWlmNotify 

   154         */   

   155         static TWlmNotify ConvertNotificationType(

   156             const core_notification_e& aCoreNotificationType );

   157 

   158         /**

   159         * ConvertConnectStatus

   160         * @since Series 60 3.0

   161         * @param aCoreConnectStatus The core connect status being converted.

   162         * @param security_mode Security mode of the IAP.

   163         * @return error code either Symbian generic or WLAN specific 

   164         */   

   165         static TInt ConvertConnectStatus(

   166             const core_connect_status_e& aCoreConnectStatus,

   167             core_security_mode_e security_mode );

   168         

   169         /**

   170         * ConvertRegion

   171         * @since Series 60 3.0

   172         * @param aAmRegion

   173         * @return core_wlan_region_e 

   174         */   

   175         static core_wlan_region_e ConvertRegion( const TWlanRegion& aAmRegion );

   176 

   177         /**

   178          * ConvertRegion

   179          * @since Series 60 5.0

   180          * @param aCoreRegion

   181          * @return TWlanRegion 

   182          */   

   183          static TWlanRegion ConvertRegion( const core_wlan_region_e& aCoreRegion );

   184         

   185         /**

   186         * ConvertMacAddress

   187         * Function assumes both mac address types have the same length

   188         * @since Series 60 3.0

   189         * @param aAmMacAddress (OUT)

   190         * @param aCoreMacAddress (IN)

   191         */   

   192         static void ConvertMacAddress(

   193             TMacAddress& aAmMacAddress,

   194             const core_mac_address_s& aCoreMacAddress );

   195 

   196         /**

   197         * ConvertMacAddress

   198         * Function assumes both mac address types have the same length

   199         * @since Series 60 3.0

   200         * @param aCoreMacAddress (OUT)

   201         * @param aAmMacAddress (IN)

   202         */   

   203         static void ConvertMacAddress(

   204             core_mac_address_s& aCoreMacAddress,

   205             const TMacAddress& aAmMacAddress );

   206 

   207         /**

   208         * ConvertMacAddress

   209         * Function assumes both mac address types have the same length

   210         * @since Series 60 3.0

   211         * @param aCoreMacAddress (OUT)

   212         * @param aAmMacAddress (IN)

   213         */   

   214         static void ConvertMacAddress(

   215             core_mac_address_s& aCoreMacAddress,

   216             const TMacAddr& aAmMacAddress );

   217 

   218         /**

   219         * ConvertMacAddress

   220         * Function assumes both mac address types have the same length

   221         * @since Series 60 3.0

   222         * @param aCoreMacAddress (OUT)

   223         * @param aAmMacAddress (IN)

   224         */   

   225         static void ConvertMacAddress(

   226             TMacAddress& aCoreMacAddress,

   227             const TMacAddr& aAmMacAddress );

   228 

   229         /**

   230         * ConvertPowerMode

   231         * @since Series 60 3.0

   232         * @param aCorePowerMode (IN)

   233         * @return TPowerMode

   234         */        

   235         static TPowerMode TWlanConversionUtil::ConvertPowerMode(

   236             const core_power_mode_e& aCorePowerMode );

   237 

   238         /**

   239         * ConvertWakeUpInterval

   240         * @since Series 60 3.0

   241         * @param aAmWakeUpMode (OUT)

   242         * @param aAmWakeUpInterval (OUT)

   243         * @param aCoreWakeUpMode (OUT)

   244         * @param aCoreWakeUpInterval (IN)

   245         */        

   246         static void TWlanConversionUtil::ConvertWakeUpInterval(

   247             TWlanWakeUpInterval& aAmWakeUpMode,

   248             TUint8& aAmWakeUpInterval,

   249             const core_power_save_wakeup_mode_e& aCoreWakeUpMode,

   250             const u8_t& aCoreWakeUpInterval );

   251 

   252         /**

   253         * ConvertIndication

   254         * @since Series 60 3.0

   255         * @param aAmIndication

   256         * @return core_am_indication_e 

   257         */   

   258         static core_am_indication_e ConvertIndication(

   259             const TIndication& aAmIndication );

   260 

   261         /**

   262         * ConvertDeviceSettings

   263         * @since Series 60 3.0

   264         * @param aCoreSettings (OUT)

   265         * @param aAmSettings (IN)

   266         */    

   267         static void ConvertDeviceSettings(

   268             core_device_settings_s& aCoreSettings,

   269             const CWlanDeviceSettings::SWlanDeviceSettings& aAmSettings );

   270             

   271         /**

   272         * ConvertIapSettings

   273         * @since Series 60 3.0

   274         * @param aCoreSettings (OUT)

   275         * @param aAmSettings (IN)

   276         * @param aDhcpInUse (IN)

   277         * @param aOverrideSettings (IN)

   278         */    

   279         static void ConvertIapSettings(

   280             core_iap_data_s& aCoreSettings,

   281             const SWLANSettings& aAmSettings,

   282             const TBool aDhcpInUse,

   283             const TWLMOverrideSettings& aOverrideSettings );

   284 

   285         /**

   286         * ConvertIapSettings

   287         * @since Series 60 3.2

   288         * @param aCoreSettings (OUT)

   289         * @param aAmSettings (IN)

   290         */    

   291         static void ConvertIapSettings(

   292             core_iap_data_s& aCoreSettings,

   293             const TWlanLimitedIapData& aAmSettings );

   294 

   295         /**

   296         * ConvertErrorCode

   297         * @since Series 60 3.0

   298         * @param aError

   299         * @return Corresponding Adaptation module error code.

   300         */    

   301         static TInt ConvertErrorCode( const core_error_e aError );

   302 

   303         /**

   304         * ConvertErrorCode

   305         * @since Series 60 3.0

   306         * @param aError

   307         * @return Corresponding Core error code.

   308         */    

   309         static core_error_e ConvertErrorCode( const TInt aError );

   310     

   311         /**

   312         * Convert mW to dBm.

   313         * @since Series 60 3.0

   314         * @param aValue mW value to convert.

   315         * @return Corresponding value in dBm.

   316         * @note If the method is unable to perform conversion,

   317         * it will return 0dBm as the conversion result.

   318         */

   319         static u32_t ConvertMilliwattsToDecibel( const TUint32 aValue );

   320 

   321         /**

   322         * Convert dBm to mW.

   323         * @since Series 60 3.0

   324         * @param aValue dBm value to convert.

   325         * @return Corresponding value in mW.

   326         * @note If the method is unable to perform conversion,

   327         * it will return 1mW as the conversion result.

   328         */

   329         static TUint32 ConvertDecibelToMilliWatts( const u32_t aValue );

   330 

   331         /**

   332         * Convert RSS class

   333         * @since Series 60 3.0

   334         * @param aCoreRssClass.

   335         * @return Corresponding Adaptation module value.

   336         */

   337         static TWlanRCPLevel ConvertRcpClass( const core_rcp_class_e aValue );

   338 

   339         /**

   340         * Convert scan channels

   341         * @since Series 60 3.0

   342         * @param aAmChannels (OUT)

   343         * @param aCoreChannels (IN)

   344         */

   345         static void ConvertScanChannels(

   346             SChannels& aAmChannels,

   347             const core_scan_channels_s& aCoreChannels );

   348             

   349         /**

   350         * Convert scan channels

   351         * @since Series 60 3.0

   352         * @param aCoreChannels (OUT)

   353         * @param aAmChannels (IN)

   354         */

   355         static void ConvertScanChannels(            

   356             core_scan_channels_s& aCoreChannels,

   357             RArray<TUint>& aAmChannels );

   358             

   359         /**

   360         * Convert frame type

   361         * @since Series 60 3.1

   362         * @param core frame type

   363         * @return adaptation frame type

   364         */

   365         static TDataBuffer::TFrameType ConvertFrameType(

   366             core_frame_type_e aFrameType );

   367 

   368         /**

   369         * Convert frame type

   370         * @since Series 60 3.1

   371         * @param adaptation frame type

   372         * @return core frame type

   373         */

   374         static core_frame_type_e ConvertFrameType(

   375             TDataBuffer::TFrameType aFrameType );

   376 

   377         /**

   378          * Convert packet statistics.

   379          * 

   380          * @since Series 60 3.2

   381          * @param aAmStatistics (OUT)

   382          * @param aCoreStatistics (IN)         

   383          */

   384         static void ConvertPacketStatistics(

   385             TWlanPacketStatistics& aAmStatistics,

   386             const core_packet_statistics_s& aCoreStatistics );

   387 

   388         /**

   389          * Convert U-APSD settings.

   390          * 

   391          * @since Series 60 3.2

   392          * @param aCoreSettings (OUT)

   393          * @param aAmSettings (IN)         

   394          */

   395         static void ConvertUapsdSettings(

   396             core_uapsd_settings_s& aCoreSettings,

   397             const TWlanUapsdSettings& aAmSettings );

   398 

   399         /**

   400          * Convert U-APSD settings.

   401          * 

   402          * @since Series 60 3.2

   403          * @param aAmSettings (OUT)

   404          * @param aCoreSettings (IN)         

   405          */

   406         static void ConvertUapsdSettings(

   407             TWlanUapsdSettings& aAmSettings,

   408             const core_uapsd_settings_s& aCoreSettings );

   409 

   410         /**

   411          * Convert TX rate policies.

   412          * 

   413          * @since Series 60 3.2

   414          * @param aAmPolicies (OUT)

   415          * @param aAmMcsPolicies (OUT)

   416          * @param aAmAutoRatePolicies (OUT)

   417          * @param aCorePolicies (IN)         

   418          */

   419         static void ConvertTxRatePolicies(

   420             TTxRatePolicy& aAmPolicies,

   421             THtMcsPolicy& aAmMcsPolicies,

   422             TTxAutoRatePolicy& aAmAutoRatePolicies,

   423             const core_tx_rate_policies_s& aCorePolicies );

   424 

   425         /**

   426          * Convert TX rate policy mappings.

   427          * 

   428          * @since Series 60 3.2

   429          * @param aAmMappings (OUT)

   430          * @param aCoreMappings (IN)         

   431          */

   432         static void ConvertTxRatePolicyMappings(

   433             TQueue2RateClass& aAmMappings,

   434             const core_tx_rate_policy_mappings_s& aCoreMappings );

   435 

   436         /**

   437          * Convert TX rate policy initial rates.

   438          * 

   439          * @since Series 60 3.2

   440          * @param aInitialRates (OUT)

   441          * @param aCorePolicies (IN)         

   442          */

   443         static void ConvertTxRatePolicyInitialRates(

   444             TInitialMaxTxRate4RateClass& aInitialRates,

   445             const core_tx_rate_policies_s& aCorePolicies );

   446 

   447         /**

   448          * Convert power save settings.

   449          * 

   450          * @since Series 60 3.2

   451          * @param aCoreSettings (OUT)

   452          * @param aAmSettings (IN)         

   453          */

   454         static void ConvertPowerSaveSettings(

   455             core_power_save_settings_s& aCoreSettings,

   456             const TWlanPowerSaveSettings& aAmSettings );

   457 

   458         /**

   459          * Convert power save settings.

   460          * 

   461          * @since Series 60 3.2

   462          * @param aAmSettings (OUT)

   463          * @param aCoreSettings (IN)         

   464          */

   465         static void ConvertPowerSaveSettings(

   466             TWlanPowerSaveSettings& aAmSettings,

   467             const core_power_save_settings_s& aCoreSettings );

   468 

   469         /**

   470          * Convert U-APSD maximum service period length

   471          * @since Series 60 3.2

   472          * @param aServicePeriodLength (IN)

   473          * @return Corresponding Adaptation module maximum service period length

   474          */

   475         static TMaxServicePeriodLength ConvertUapsdMaxServicePeriod(

   476             core_max_service_period_length_e aServicePeriodLength );

   477             

   478         /**

   479          * Convert traffic stream status.

   480          * @since Series 60 3.2

   481          * @param aStatus (IN)

   482          * @return Corresponding Adaptation module traffic stream status.

   483          */

   484         static TWlanTrafficStreamStatus ConvertTrafficStreamStatus(

   485             core_traffic_stream_status_e aStatus );        

   486 

   487         /**

   488          * Convert access point information.

   489          * @since Series 60 3.2

   490          * @param aAmInfo (OUT)

   491          * @param aCoreInfo (IN)

   492          */

   493         static void ConvertApInformation(

   494             TWlanAccessPointInfo& aAmInfo,

   495             const core_ap_information_s& aCoreInfo );

   496 

   497         /**

   498          * Convert roam metrics of the current connection.

   499          * @since Series 60 3.2

   500          * @param aAmRoamMetrics (OUT)

   501          * @param aCoreRoamMetrics (IN)

   502          */

   503         static void ConvertRoamMetrics(

   504             TWlanRoamMetrics& aAmRoamMetrics,

   505             const core_roam_metrics_s& aCoreRoamMetrics );

   506 

   507         /**

   508          * Convert list of BSSIDs on the rogue list.

   509          * @since Series 60 3.2

   510          * @param aAmRogueList (OUT)

   511          * @param aCoreRogueList (IN)

   512          */ 

   513         static void ConvertRogueList(

   514             TWlmRogueList& aAmRogueList,

   515             core_type_list_c<core_mac_address_s>& aCoreRogueList );

   516 

   517         /**

   518          * Convert tx queue id.

   519          * @since Series 60 3.2

   520          * @param queue_id (IN)

   521          * @return Corresponding Adaptation module tx queue id.

   522          */

   523         static TQueueId ConvertTxQueueId(

   524             core_access_class_e queue_id );

   525 

   526         /**

   527          * Convert a Protected Setup credential attribute.

   528          * @since S60 3.2

   529          * @param aAmAttribute (OUT)

   530          * @param aCoreAttribute (IN)

   531          */

   532         static void ConvertProtectedSetupCredentialAttribute(

   533             TWlanProtectedSetupCredentialAttribute& aAmAttribute,

   534             const core_iap_data_s& aCoreAttribute );

   535 

   536         /**

   537          * Convert a Protected Setup status code to a WLAN error code.

   538          * @since Series 60 3.2

   539          * @param aCoreStatus The core Protected Setup status being converted.

   540          * @return WLAN specific error code.

   541          */

   542         static TInt ConvertProtectedSetupStatus(

   543             core_protected_setup_status_e aCoreStatus );

   544 

   545         /**

   546          * Convert SNAP header.

   547          * @since Series 60 3.2

   548          * @param aAmHeader (OUT)

   549          * @param aCoreHeader (IN)

   550          */

   551         static void ConvertSnapHeader(

   552             TSnapHeader& aAmHeader,

   553             const core_snap_header_s& aCoreHeader );        

   554 

   555         /**

   556          * Convert power save mode.

   557          * 

   558          * @since Series 60 5.0.1

   559          * @param aCoreMode (OUT)

   560          * @param aAmMode (IN)         

   561          */

   562         static void ConvertPowerSaveMode(

   563             core_power_save_mode_s& aCoreMode,

   564             TWlanPowerSaveMode aAmMode );        

   565       

   566         /**

   567          * Convert feature flags.

   568          *

   569          * @since S60 v5.1

   570          * @param aFeatures

   571          * @return Corresponding core features.

   572          */

   573         static u32_t ConvertFeatureFlags(

   574             TUint aFeatures );

   575 

   576         /**

   577          * Convert access class.

   578          * 

   579          * @param aAccessClass (IN)

   580          * @return Corresponding Adaptation module access class.

   581          */

   582         static TWlmAccessClass ConvertAccessClass(

   583             core_access_class_e aAccessClass );

   584 

   585         /**

   586          * Convert traffic mode.

   587          * 

   588          * @param aAccessClass (IN)

   589          * @return Corresponding Adaptation module traffic mode.

   590          */

   591         static TWlmAcTrafficMode ConvertTrafficMode(

   592             core_access_class_traffic_mode_e aMode );

   593 

   594         /**

   595          * Convert traffic status.

   596          * 

   597          * @param aAccessClass (IN)

   598          * @return Corresponding Adaptation module traffic status

   599          */

   600         static TWlmAcTrafficStatus ConvertTrafficStatus(

   601             core_access_class_traffic_status_e aStatus );

   602 

   603         /**

   604          * Convert traffic stream parameters.

   605          * 

   606          * @param aCoreTid (OUT)

   607          * @param aCoreUserPriority (OUT)

   608          * @param coreParams (OUT)

   609          * @param aAmParams (IN)         

   610          */

   611         static void ConvertTrafficStreamParameters(

   612             u8_t& aCoreTid,

   613             u8_t& aCoreUserPriority,

   614             core_traffic_stream_params_s& aCoreParams,

   615             const TWlanTrafficStreamParameters& aAmParams );

   616 

   617         /**

   618          * Convert TX rate enumeration to corresponding rate as bits per second.

   619          *

   620          * @since aRate (IN)

   621          * @return Corresponding rate as bits per second.

   622          */

   623         static u32_t ConvertTxRate(

   624             TWlanRate aRate );

   625 

   626     };

   627 

   628 #endif // WLANCONVERSIONUTIL_H