le_mrc_interface.h

    1 
    2 
    3 /*
    4  * ====================== WARNING ======================
    5  *
    6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    7  * DO NOT MODIFY IN ANY WAY.
    8  *
    9  * ====================== WARNING ======================
   10  */
   11 
   12 /**
   13  * @page c_mrc Modem Radio Control
   14  *
   15  * @ref le_mrc_interface.h "API Reference"
   16  *
   17  * <HR>
   18  *
   19  * The Modem Radio Control (MRC) APIs is used to control cellular network environments.
   20  *
   21  * It's important for many M2M apps to know details about cellular network environments (like
   22  * network registration and signal quality).
   23  * It allows you to limit some M2M services based on the reliability of the network environment, and
   24  * provides information to control power consumption (power on or shutdown the radio module).
   25  *
   26  * @section le_mrc_binding IPC interfaces binding
   27  *
   28  * All the functions of this API are provided by the @b modemService service.
   29  *
   30  * Here's a code sample binding to modem services:
   31  * @verbatim
   32    bindings:
   33    {
   34       clientExe.clientComponent.le_mrc -> modemService.le_mrc
   35    }
   36    @endverbatim
   37  *
   38  * @section le_mrc_power Radio Power Management
   39  * le_mrc_SetRadioPower() API allows the application to power up or shutdown the radio module.
   40  *
   41  * le_mrc_GetRadioPower() API displays radio module power state.
   42  *
   43  * A sample code can be seen in the following page:
   44  * - @subpage c_mrcRadioPower
   45  *
   46  * @section le_mrc_configuration Radio Configuration preferences
   47  *
   48  * The following functions let you configure and retrieve the radio configuration preferences:
   49  * le_mrc_SetAutomaticRegisterMode(), le_mrc_SetManualRegisterMode() and le_mrc_GetRegisterMode()
   50  * let you set/get the selected Scan mode.
   51  *
   52  * le_mrc_SetBandPreferences(), le_mrc_GetBandPreferences() let you set/get the 2G/3G band
   53  * preferences by using a bit mask built with @c le_mrc_BandBitMask_t
   54  *
   55  * The 2G/3G band preferences can be:
   56  * - Band-Class-0-A-System
   57  * - Band-Class-0-B-System
   58  * - Band-Class-1-All-Blocks
   59  * - Band-Class-2-Placeholder
   60  * - Band-Class-3-A-System
   61  * - Band-Class-4-All-Blocks
   62  * - Band-Class-5-All-Blocks
   63  * - Band-Class-6
   64  * - Band-Class-7
   65  * - Band-Class-8
   66  * - Band-Class-9
   67  * - Band-Class-10
   68  * - Band-Class-11
   69  * - Band-Class-12
   70  * - Band-Class-13
   71  * - Band-Class-14
   72  * - Band-Class-15
   73  * - Band-Class-16
   74  * - Band-Class-17
   75  * - Band-Class-18
   76  * - Band-Class-19
   77  * - GSM-DCS-1800
   78  * - E-GSM-900 (for Extended GSM 900 band)
   79  * - Primary-GSM-900
   80  * - GSM-450
   81  * - GSM-480
   82  * - GSM-750
   83  * - GSM-850
   84  * - GSMR-900 (for GSM Railways GSM 900 band)
   85  * - GSM-PCS-1900
   86  * - WCDMA-EU-J-CH-IMT-2100 (for WCDMA Europe, Japan, and China IMT 2100 band)
   87  * - WCDMA-US-PCS-1900 (for WCDMA U.S. PCS 1900 band)
   88  * - WCDMA-EU-CH-DCS-1800 (for WCDMA Europe and China DCS 1800 band)
   89  * - WCDMA-US-1700 (for WCDMA U.S. 1700 band)
   90  * - WCDMA-US-850 (for WCDMA U.S. 850 band)
   91  * - WCDMA-J-800 (for WCDMA Japan 800 band)
   92  * - WCDMA-EU-2600 (for WCDMA Europe 2600 band)
   93  * - WCDMA-EU-J-900 (for WCDMA Europe and Japan 900 band)
   94  * - WCDMA-J-1700 (for WCDMA Japan 1700 band)
   95  *
   96  * le_mrc_SetLteBandPreferences(), le_mrc_GetLteBandPreferences() let you set/get the LTE band
   97  * preferences by using a bit mask built with @c le_mrc_LteBandBitMask_t.
   98  *
   99  * The LTE band preferences can be 0 to 43 except 15, 16, 22, 23, and 26 to 32.
  100  *
  101  * le_mrc_SetTdScdmaBandPreferences(), le_mrc_GetTdScdmaBandPreferences() let you set/get the
  102  * TD-SCDMA band preferences by using a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
  103  *
  104  * The TD-SCDMA band preferences can be 'A' to 'F'
  105  *
  106  * @warning Ensure to check the supported preferences for your specific platform.
  107  *
  108  * le_mrc_AddPreferredOperator() , le_mrc_RemovePreferredOperator() to add/remove a preferred
  109  * operator by specifying the MCC/MNC and the Radio Access Technology.
  110  *
  111  * le_mrc_GetPreferredOperatorsList(), le_mrc_GetFirstPreferredOperator(),
  112  * le_mrc_GetNextPreferredOperator(), le_mrc_DeletePreferredOperatorsList(),
  113  * le_mrc_GetPreferredOperatorDetails() let you retrieve a list of the selected preferred
  114  * operators and get their details.
  115  *
  116  * A sample code can be seen in the following page:
  117  * - @subpage c_mrcRadioConfigurationPreferences
  118  *
  119  * @section le_mrc_AddNetRegRejectHandler Report Network Registration Reject Indication
  120  *
  121  * The application can register a handler function to report network reject with reject cause,
  122  * reject service domain, MNC/MCC code and the Radio Access Technology using
  123  * le_mrc_AddNetRegRejectHandler() API (le_mrc_AddNetworkRejectHandler() will be deprecated).
  124  *
  125  * le_mrc_RemoveNetRegRejectHandler() API uninstalls the handler function.
  126  *
  127  * @deprecated le_mrc_NetworkRejectHandler() will be removed in near future.
  128  * It will be replaced by le_mrc_AddNetRegRejectHandler().
  129  *
  130  * le_mrc_NetworkRejectHandler Report Network Reject Indication
  131  *
  132  * The application can register a handler function to report network reject with MNC/MCC code and
  133  * the Radio Access Technology using le_mrc_AddNetworkRejectHandler() API.
  134  *
  135  * le_mrc_RemoveNetworkRejectHandler() API uninstalls the handler function.
  136  *
  137  * @section le_mrc_capabilities Radio Capabilities
  138  *
  139  * le_mrc_GetBandCapabilities() let you get the 2G/3G band capabilities by retrieving a bit mask
  140  * built with @c le_mrc_BandBitMask_t
  141  *
  142  * le_mrc_GetLteBandCapabilities() let you get the LTE band capabilities by retrieving a bit mask
  143  * built with @c le_mrc_LteBandBitMask_t
  144  *
  145  * le_mrc_GetTdScdmaBandCapabilities() let you get the TD-SCDMA band capabilities by retrieving
  146  * a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
  147  *
  148  * A sample code can be seen in the following page:
  149  * - @subpage c_mrcBandCapabilities
  150  *
  151  * @section le_mrc_rat Radio Access Technology (RAT)
  152  * le_mrc_GetRadioAccessTechInUse() API retrieves the current active Radio Access Technology (RAT).
  153  * @note  The API returns the RAT only if the device is registered on the network.
  154  *
  155  * The application can register a handler function to retrieve the Radio Access Technology each time
  156  * the RAT changes.
  157  *
  158  * le_mrc_AddRatChangeHandler() API installs a RAT change handler.
  159  *
  160  * le_mrc_RemoveRatChangeHandler() API uninstalls the handler function.
  161  *
  162  * le_mrc_SetRatPreferences(), le_mrc_GetRatPreferences() let you set/get the Radio Access
  163  * Technology preferences by using a bit mask built with @c le_mrc_RatBitMask_t.
  164  *
  165  * The Radio Access Technology preferences can be:
  166  * - CDMA (CDMA2000-1X + CDMA2000-HRPD)
  167  * - GSM
  168  * - UMTS (UMTS)
  169  * - TDSCDMA (TD-SCDMA)
  170  * - LTE
  171  *
  172  * @note LE_MRC_BITMASK_RAT_ALL value can be used to select the RAT in automatic mode.
  173  *
  174  * A sample code can be seen in the following page:
  175  * - @subpage c_mrcRAT
  176  *
  177  * @section le_mrc_registration Network Registration
  178  * le_mrc_GetNetRegState() API retrieves the radio module network registration status.
  179  *
  180  * The application can register a handler function to retrieve the registration status each time the
  181  * registration state changes.
  182  *
  183  * le_mrc_AddNetRegStateEventHandler() API installs a registration state handler.
  184  *
  185  * le_mrc_RemoveNetRegStateEventHandler() API uninstalls the handler function.
  186  * @note If only one handler is registered, the le_mrc_RemoveNetRegStateHandler() API
  187  *       resets the registration mode to its original value before any handler functions were added.
  188  *
  189  * le_mrc_SetManualRegisterMode() API registers on a cellular network.
  190  *
  191  * Call le_mrc_SetManualRegisterModeAsync() function to set the manual registration mode
  192  *  asynchronously. The function is not blocking. The response will be returned with the
  193  *  @c le_mrc_ManualSelectionHandlerFunc_t handler function.
  194  *
  195  * When the network registration fails, the platform specific network registration error code can
  196  * be known by using le_mrc_GetPlatformSpecificRegistrationErrorCode() API.
  197  * Please refer to @ref platformConstraintsSpecificErrorCodes for platform specific
  198  * registration error code description.
  199  *
  200  * A sample code can be seen in the following page:
  201  * - @subpage c_mrcNetworkRegistration
  202  *
  203  * @section le_mrc_service Packet services state
  204  *
  205  * le_mrc_GetPacketSwitchedState() API retrieves the current Packet Switched state
  206  * @ref le_mrc_NetRegState_t.
  207  *
  208  * The Packet Switched services state can be:
  209  * - NONE
  210  * - HOME
  211  * - ROAMING
  212  *
  213  * The application can register a handler function to retrieve the Packet
  214  * Switched state each time the service state changes.
  215  *
  216  * le_mrc_AddPacketSwitchedChangeHandler() API installs a Packet Switched state handler.
  217  *
  218  * le_mrc_RemovePacketSwitchedChangeHandler() API uninstalls the handler function.
  219  *
  220  * A sample code can be seen in the following page:
  221  * - @subpage c_mrcGetService
  222  *
  223  * @section le_mrc_signal Signal Quality
  224  *
  225  * le_mrc_GetSignalQual() retrieves the received signal strength details.
  226  *
  227  * You must call le_mrc_MeasureSignalMetrics() to measure the signal metrics of the serving cell
  228  * (aka the 'serving' cell). It returns a reference of le_mrc_MetricsRef_t type.
  229  *
  230  * When the signal metrics are no longer needed, you must call le_mrc_DeleteSignalMetrics() to free
  231  * all allocated ressources associated with the Metrics object.
  232  *
  233  * le_mrc_GetRatOfSignalMetrics() returns the Radio Access Technology of the signal measures.
  234  *
  235  * le_mrc_GetGsmSignalMetrics() the signal strength in dBm and the bit error rate measured on GSM
  236  * network.
  237  *
  238  * le_mrc_GetUmtsSignalMetrics() returns the signal metrics measured on UMTS or TD-SCDMA networks.
  239  *
  240  * le_mrc_GetLteSignalMetrics() returns the signal metrics measured on LTE network.
  241  *
  242  * le_mrc_GetCdmaSignalMetrics() returns the signal metrics measured on CDMA network.
  243  *
  244  * The application can register a handler function to get notifications when the signal strength
  245  * changes of a certain threshold value.
  246  *
  247  * le_mrc_AddSignalStrengthChangeHandler() API installs a signal strength change handler.
  248  * The RAT, the lower-range and the upper-range thresholds must be passed as input parameters. These
  249  * parameters are updated each time the function is called, the previous thresholds are replaced by
  250  * the new ones if the function is called with the same RAT. The event is notified when we cross the
  251  * range limits in both direction.
  252  *
  253  * @warning A fatal error will be thrown if the RAT is not valid and the
  254  *  le_mrc_AddSignalStrengthChangeHandler function won't return.
  255  *
  256  * le_mrc_RemoveSignalStrengthChangeHandler() API uninstalls the handler function.
  257  *
  258  * le_mrc_SetSignalStrengthIndThresholds() API changes or sets new thresholds.
  259  *
  260  * le_mrc_SetSignalStrengthIndDelta() API sets a signal strength indication delta value for a
  261  * specific RAT. The event is notified when the delta range is crossed in both direction.
  262  *
  263  * A sample code can be seen in the following page:
  264  * - @subpage c_mrcQuality
  265  *
  266  * @section le_mrc_location Serving cell's location information
  267  *
  268  * le_mrc_GetServingCellId() retrieves the the serving Cell Identifier.
  269  *
  270  * le_mrc_GetServingCellLocAreaCode() retrieves the Location Area Code of the serving cell.
  271  *
  272  * le_mrc_GetServingCellLteTracAreaCode() retrieves the the Tracking Area Code of the serving cell
  273  * (LTE only).
  274  *
  275  * A sample code can be seen in the following page:
  276  * - @subpage c_mrcLocationinformation
  277  *
  278  * @section le_mrc_network_information Current Network Information
  279  * le_mrc_GetCurrentNetworkName() retrieves the Current Network Name.
  280  * le_mrc_GetCurrentNetworkMccMnc() retrieves the Current Network PLMN information.
  281  *
  282  * A sample code can be seen in the following page:
  283  * - @subpage c_mrcGetCurrentNetwork
  284  *
  285  * @section le_mrc_networkScan Network Scan
  286  *
  287  * Call le_mrc_PerformCellularNetworkScan() to fill a list of all network in sight.
  288  * You can go through all Scan Information by calling le_mrc_GetFirstCellularNetworkScan() and
  289  * le_mrc_GetNextCellularNetworkScan().
  290  *
  291  * Call le_mrc_PerformCellularNetworkScanAsync() to start a network scan asynchronously. The
  292  * function is not blocking. The scan list reference will be returned with the handler function
  293  * response (@c le_mrc_CellularNetworkScanHandlerFunc_t).
  294  *
  295  * For each Scan Information, you can call:
  296  *
  297  *  - le_mrc_GetCellularNetworkMccMnc() to have the operator code.
  298  *  - le_mrc_GetCellularNetworkName() to get the operator name.
  299  *  - le_mrc_GetCellularNetworkRat() to get the radio access technology.
  300  *  - le_mrc_IsCellularNetworkInUse() to check if this is currently in use by the network.
  301  *  - le_mrc_IsCellularNetworkAvailable() to check if this is available.
  302  *  - le_mrc_IsCellularNetworkHome() to check if this is in home status.
  303  *  - le_mrc_IsCellularNetworkForbidden() to check if this is forbidden by the network.
  304  *
  305  * le_mrc_DeleteCellularNetworkScan() should be called when you do not need the list anymore.
  306  *
  307  * A sample code can be seen in the following page:
  308  * - @subpage c_mrcNetworkScan
  309  *
  310  * @section le_mrc_PcinetworkScan PCI Network Scan
  311  *
  312  * Call le_mrc_PerformPciNetworkScan() to fill a list of all neighboring cells.
  313  * The Pci scan is used to get the according MCC/MNC for each neightboring cells ID. Not that a cell
  314  * may contain more than one MCC/MNC when sevral plmn sharing the same cell.
  315  *
  316  * You can go through all Scan Information by calling le_mrc_GetFirstPciScanInfo() and
  317  * le_mrc_GetNextPciScanInfo(). Note that each cell info contains a list of mcc/mnc, you can go
  318  * through all mcc/mnc Information for each cell by calling le_mrc_GetFirstPlmnInfo()
  319  * and le_mrc_GetNextPlmnInfo(), this two APIs return a reference to PlmnInformation, then use
  320  * le_mrc_GetPciScanMccMnc() by giving this reference as parameter to get the Mcc/Mnc of the Plmn.
  321  *
  322  * Call le_mrc_PerformPciNetworkScanAsync()to start a pci scan asynchronously. The
  323  * function is not blocking. The scan list reference will be returned with the handler function
  324  * response (@c le_mrc_PciNetworkScanHandlerFunc_t).
  325  *
  326  *
  327  * For Pci Network Scan Information, you can call:
  328  *
  329  *  - le_mrc_GetPciScanCellId() to get the physical id of each cell.
  330  *  - le_mrc_GetPciScanGlobalCellId() to get the global id of each cell.
  331  *  - le_mrc_GetPciScanMccMnc() to get the Mcc/Mnc of each plmn on each cell.
  332  *  - le_mrc_DeletePciNetworkScan() should be called when you do not need the list anymore.
  333  *
  334  * A sample code can be seen in the following page:
  335  * - @subpage c_mrcPciScan
  336  *
  337  * @section le_mrc_ngbr Neighboring Cells Information
  338  *
  339  * @warning The following functions do not apply to CDMA network.
  340  *
  341  * You must call le_mrc_GetNeighborCellsInfo() to retrieve the neighboring cells
  342  * information. It returns a reference of le_mrc_NeighborCellsRef_t type.
  343  *
  344  * When the neighboring cells information is no longer needed, you must call
  345  * le_mrc_DeleteNeighborCellsInfo() to free all allocated resources associated with the
  346  * object.
  347  *
  348  * Then, you can use the following function to get the information:
  349  * - le_mrc_GetFirstNeighborCellInfo() and le_mrc_GetFirstNeighborCellInfo() allow to go among
  350  *   the single cell information retrieved with le_mrc_GetNeighborCellsInfo(). These two functions
  351  *   return a reference of le_mrc_CellInfoRef_t type.
  352  * - le_mrc_GetNeighborCellId() gets the identifier of the cell specified with the
  353  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT32_MAX value is
  354  *   returned if the value is not available.
  355  * - le_mrc_GetNeighborCellLocAreaCode() gets the location area code of the cell specified with the
  356  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT16_MAX value is
  357  *   returned if the value is not available.
  358  * - le_mrc_GetNeighborCellRxLevel() gets the signal strength (in dBm) of the cell specified with
  359  *   the le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
  360  * - le_mrc_GetNeighborCellRat() gets the Radio Access Technology of the cell specified with
  361  *   the le_mrc_CellInfoRef_t parameter.
  362  * - le_mrc_GetNeighborCellUmtsEcIo() gets the Ec/Io (the received energy per chip divided by the
  363  *   power density in the band measured in dBm on the primary CPICH channel of serving cell) of the
  364  *   cell specified with the le_mrc_CellInfoRef_t parameter.
  365  * - le_mrc_GetNeighborCellLteIntraFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  366  *   specified with the le_mrc_CellInfoRef_t parameter.
  367  * - le_mrc_GetNeighborCellLteInterFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  368  *   specified with the le_mrc_CellInfoRef_t parameter.
  369  *
  370  * A sample code can be seen in the following page:
  371  * - @subpage c_mrcNeighborCells
  372  *
  373  * @section le_mrc_jamming Jamming detection
  374  *
  375  * The jamming detection algorithm is based on power measurements and cell synchronization actions
  376  * performed during a GSM network scan procedure.
  377  * During this procedure some intermediate results are reported, that allows user to take some
  378  * preventive actions if necessary.
  379  * This result is reported as a jammed state probability. See @ref le_mrc_JammingStatus_t
  380  * enumeration for probability description.
  381  * Each time the jamming status changes during the scan procedure, it is reported to the user.
  382  * See @ref le_mrc_JammingReport_t enumeration for details.
  383  *
  384  * The jamming status is reported:
  385  * - In an unsolicited way, each time the protocol stack initiates a scan for PLMN selection or
  386  * reselection.
  387  * - On user demand, when a user PLMN scan is performed.
  388  *
  389  * Call le_mrc_StartJammingDetection() to launch jamming monitoring.
  390  * By registering a handler by calling le_mrc_AddJammingDetectionEventHandler(), the notification
  391  * on jamming detection can be sent to the registered application.
  392  *
  393  * For each jamming detection monitoring, the following APIs can be called:
  394  * - le_mrc_StartJammingDetection() to start the jamming monitoring.
  395  * - le_mrc_StopJammingDetection() to stop the jamming monitoring.
  396  * - le_mrc_AddJammingDetectionEventHandler() to register an event handler.
  397  * - le_mrc_RemoveJammingDetectionEventHandler() to remove an event handler.
  398  *
  399  * @section le_mrc_sar SAR backoff
  400  * SAR (Specific Absorption Rate) is a measure of RF energy absorption by the human body.
  401  * Users can dynamically select a pre-configured SAR backoff state so they can adjust the SAR
  402  * depending on their needs.  To manage SAR backoff, these API should be used:
  403  * - le_mrc_SetSarBackoffState() to set a new SAR backoff state.
  404  * - le_mrc_GetSarBackoffState() to get the current SAR backoff state.
  405  * This feature may be unsupported by some targets. Also, the number of supported states may vary
  406  * depending on the target. Please refer to @ref platformConstraintsMdc for further details.
  407  *
  408  * <HR>
  409  *
  410  * Copyright (C) Sierra Wireless Inc.
  411  */
  412 /**
  413  * @page c_mrcRadioPower Sample code for Radio Power Management
  414  *
  415  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Radio Power
  416  */
  417 /**
  418  * @page c_mrcRadioConfigurationPreferences Sample code for Radio Configuration Preferences
  419  *
  420  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Preferences
  421  *
  422  */
  423 /**
  424  * @page c_mrcRAT Sample code for Radio Access Technology
  425  *
  426  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT in Use
  427  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT Preferences
  428  *
  429  */
  430 /**
  431  * @page c_mrcNetworkRegistration Sample code for Network Registration
  432  *
  433  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Register
  434  *
  435  */
  436 /**
  437  * @page c_mrcQuality Sample code for Signal Quality
  438  *
  439  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Signal Quality
  440  *
  441  */
  442 /**
  443  * @page c_mrcLocationinformation Sample code for Location information
  444  *
  445  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Loc information
  446  *
  447  */
  448 /**
  449  * @page c_mrcBandCapabilities Sample code for Band Capabilities
  450  *
  451  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Capabilities
  452  *
  453  */
  454 /**
  455  * @page c_mrcGetCurrentNetwork Sample code for Get Current Network Information
  456  *
  457  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Get Network
  458  *
  459  */
  460 /**
  461  * @page c_mrcNetworkScan Sample code for Network Scan
  462  *
  463  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Network Scan
  464  *
  465  */
  466 /**
  467  * @page c_mrcPciScan Sample code for LTE PCI Scan
  468  *
  469  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" PCI Scan
  470  *
  471  */
  472 /**
  473  * @page c_mrcNeighborCells Sample code for Neighboring Cells Information
  474  *
  475  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Neighbor Cells
  476  *
  477  */
  478 /**
  479  * @page c_mrcGetService Sample code for Get the Current Packet Switched state
  480  *
  481  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Service State
  482  *
  483  */
  484 /**
  485  * @file le_mrc_interface.h
  486  *
  487  * Legato @ref c_mrc include file.
  488  *
  489  * Copyright (C) Sierra Wireless Inc.
  490  */
  491 
  492 #ifndef LE_MRC_INTERFACE_H_INCLUDE_GUARD
  493 #define LE_MRC_INTERFACE_H_INCLUDE_GUARD
  494 
  495 
  496 #include "legato.h"
  497 
  498 
  499 //--------------------------------------------------------------------------------------------------
  500 /**
  501  * Type for handler called when a server disconnects.
  502  */
  503 //--------------------------------------------------------------------------------------------------
  504 typedef void (*le_mrc_DisconnectHandler_t)(void *);
  505 
  506 //--------------------------------------------------------------------------------------------------
  507 /**
  508  *
  509  * Connect the current client thread to the service providing this API. Block until the service is
  510  * available.
  511  *
  512  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  513  * called before any other functions in this API.  Normally, ConnectService is automatically called
  514  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  515  *
  516  * This function is created automatically.
  517  */
  518 //--------------------------------------------------------------------------------------------------
  519 void le_mrc_ConnectService
  520 (
  521     void
  522 );
  523 
  524 //--------------------------------------------------------------------------------------------------
  525 /**
  526  *
  527  * Try to connect the current client thread to the service providing this API. Return with an error
  528  * if the service is not available.
  529  *
  530  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  531  * called before any other functions in this API.  Normally, ConnectService is automatically called
  532  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  533  *
  534  * This function is created automatically.
  535  *
  536  * @return
  537  *  - LE_OK if the client connected successfully to the service.
  538  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  539  *    bound.
  540  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  541  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  542  */
  543 //--------------------------------------------------------------------------------------------------
  544 le_result_t le_mrc_TryConnectService
  545 (
  546     void
  547 );
  548 
  549 //--------------------------------------------------------------------------------------------------
  550 /**
  551  * Set handler called when server disconnection is detected.
  552  *
  553  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  554  * to continue without exiting, it should call longjmp() from inside the handler.
  555  */
  556 //--------------------------------------------------------------------------------------------------
  557 void le_mrc_SetServerDisconnectHandler
  558 (
  559     le_mrc_DisconnectHandler_t disconnectHandler,
  560     void *contextPtr
  561 );
  562 
  563 //--------------------------------------------------------------------------------------------------
  564 /**
  565  *
  566  * Disconnect the current client thread from the service providing this API.
  567  *
  568  * Normally, this function doesn't need to be called. After this function is called, there's no
  569  * longer a connection to the service, and the functions in this API can't be used. For details, see
  570  * @ref apiFilesC_client.
  571  *
  572  * This function is created automatically.
  573  */
  574 //--------------------------------------------------------------------------------------------------
  575 void le_mrc_DisconnectService
  576 (
  577     void
  578 );
  579 
  580 
  581 //--------------------------------------------------------------------------------------------------
  582 /**
  583  * Mobile Country Code length
  584  */
  585 //--------------------------------------------------------------------------------------------------
  586 #define LE_MRC_MCC_LEN 3
  587 
  588 //--------------------------------------------------------------------------------------------------
  589 /**
  590  * Mobile Country Code length
  591  * One extra byte is added for the null character.
  592  */
  593 //--------------------------------------------------------------------------------------------------
  594 #define LE_MRC_MCC_BYTES 4
  595 
  596 //--------------------------------------------------------------------------------------------------
  597 /**
  598  * Mobile Network Code length
  599  */
  600 //--------------------------------------------------------------------------------------------------
  601 #define LE_MRC_MNC_LEN 3
  602 
  603 //--------------------------------------------------------------------------------------------------
  604 /**
  605  * Mobile Network Code length
  606  * One extra byte is added for the null character.
  607  */
  608 //--------------------------------------------------------------------------------------------------
  609 #define LE_MRC_MNC_BYTES 4
  610 
  611 //--------------------------------------------------------------------------------------------------
  612 /**
  613  * Cellular Network length.
  614  *
  615  */
  616 //--------------------------------------------------------------------------------------------------
  617 #define LE_MRC_NETWORK_NAME_MAX_LEN 100
  618 
  619 //--------------------------------------------------------------------------------------------------
  620 /**
  621  * 2G/3G Band Bit Mask (64 bits)
  622  */
  623 //--------------------------------------------------------------------------------------------------
  624 typedef enum
  625 {
  626     LE_MRC_BITMASK_BAND_CLASS_0_A_SYSTEM = 0x1,
  627     LE_MRC_BITMASK_BAND_CLASS_0_B_SYSTEM = 0x2,
  628     LE_MRC_BITMASK_BAND_CLASS_1_ALL_BLOCKS = 0x4,
  629     LE_MRC_BITMASK_BAND_CLASS_2_PLACEHOLDER = 0x8,
  630     LE_MRC_BITMASK_BAND_CLASS_3_A_SYSTEM = 0x10,
  631     LE_MRC_BITMASK_BAND_CLASS_4_ALL_BLOCKS = 0x20,
  632     LE_MRC_BITMASK_BAND_CLASS_5_ALL_BLOCKS = 0x40,
  633     LE_MRC_BITMASK_BAND_CLASS_6 = 0x80,
  634     LE_MRC_BITMASK_BAND_CLASS_7 = 0x100,
  635     LE_MRC_BITMASK_BAND_CLASS_8 = 0x200,
  636     LE_MRC_BITMASK_BAND_CLASS_9 = 0x400,
  637     LE_MRC_BITMASK_BAND_CLASS_10 = 0x800,
  638     LE_MRC_BITMASK_BAND_CLASS_11 = 0x1000,
  639     LE_MRC_BITMASK_BAND_CLASS_12 = 0x2000,
  640     LE_MRC_BITMASK_BAND_CLASS_14 = 0x4000,
  641     LE_MRC_BITMASK_BAND_CLASS_15 = 0x8000,
  642     LE_MRC_BITMASK_BAND_CLASS_16 = 0x10000,
  643     LE_MRC_BITMASK_BAND_CLASS_17 = 0x20000,
  644     LE_MRC_BITMASK_BAND_CLASS_18 = 0x40000,
  645     LE_MRC_BITMASK_BAND_CLASS_19 = 0x80000,
  646     LE_MRC_BITMASK_BAND_GSM_DCS_1800 = 0x100000,
  647     LE_MRC_BITMASK_BAND_EGSM_900 = 0x200000,
  648     LE_MRC_BITMASK_BAND_PRI_GSM_900 = 0x400000,
  649     LE_MRC_BITMASK_BAND_GSM_450 = 0x800000,
  650     LE_MRC_BITMASK_BAND_GSM_480 = 0x1000000,
  651     LE_MRC_BITMASK_BAND_GSM_750 = 0x2000000,
  652     LE_MRC_BITMASK_BAND_GSM_850 = 0x4000000,
  653     LE_MRC_BITMASK_BAND_GSMR_900 = 0x8000000,
  654     LE_MRC_BITMASK_BAND_GSM_PCS_1900 = 0x10000000,
  655     LE_MRC_BITMASK_BAND_WCDMA_EU_J_CH_IMT_2100 = 0x20000000,
  656     LE_MRC_BITMASK_BAND_WCDMA_US_PCS_1900 = 0x40000000,
  657     LE_MRC_BITMASK_BAND_WCDMA_EU_CH_DCS_1800 = 0x80000000,
  658     LE_MRC_BITMASK_BAND_WCDMA_US_1700 = 0x100000000,
  659     LE_MRC_BITMASK_BAND_WCDMA_US_850 = 0x200000000,
  660     LE_MRC_BITMASK_BAND_WCDMA_J_800 = 0x400000000,
  661     LE_MRC_BITMASK_BAND_WCDMA_EU_2600 = 0x800000000,
  662     LE_MRC_BITMASK_BAND_WCDMA_EU_J_900 = 0x1000000000,
  663     LE_MRC_BITMASK_BAND_WCDMA_J_1700 = 0x2000000000
  664 }
  665 le_mrc_BandBitMask_t;
  666 
  667 
  668 //--------------------------------------------------------------------------------------------------
  669 /**
  670  * LTE Band Bit Mask (64 bits)
  671  *
  672  */
  673 //--------------------------------------------------------------------------------------------------
  674 typedef enum
  675 {
  676     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_1 = 0x1,
  677     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_2 = 0x2,
  678     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_3 = 0x4,
  679     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_4 = 0x8,
  680     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_5 = 0x10,
  681     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_6 = 0x20,
  682     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_7 = 0x40,
  683     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_8 = 0x80,
  684     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_9 = 0x100,
  685     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_10 = 0x200,
  686     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_11 = 0x400,
  687     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_12 = 0x800,
  688     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_13 = 0x1000,
  689     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_14 = 0x2000,
  690     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_17 = 0x4000,
  691     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_18 = 0x8000,
  692     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_19 = 0x10000,
  693     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_20 = 0x20000,
  694     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_21 = 0x40000,
  695     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_24 = 0x80000,
  696     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_25 = 0x100000,
  697     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_26 = 0x200000,
  698     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_28 = 0x400000,
  699     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_33 = 0x800000,
  700     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_34 = 0x1000000,
  701     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_35 = 0x2000000,
  702     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_36 = 0x4000000,
  703     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_37 = 0x8000000,
  704     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_38 = 0x10000000,
  705     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_39 = 0x20000000,
  706     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_40 = 0x40000000,
  707     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_41 = 0x80000000,
  708     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_42 = 0x100000000,
  709     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_43 = 0x200000000
  710 }
  711 le_mrc_LteBandBitMask_t;
  712 
  713 
  714 //--------------------------------------------------------------------------------------------------
  715 /**
  716  * TDSCDMA Band Bit Mask
  717  *
  718  */
  719 //--------------------------------------------------------------------------------------------------
  720 typedef enum
  721 {
  722     LE_MRC_BITMASK_TDSCDMA_BAND_A = 0x1,
  723     LE_MRC_BITMASK_TDSCDMA_BAND_B = 0x2,
  724     LE_MRC_BITMASK_TDSCDMA_BAND_C = 0x4,
  725     LE_MRC_BITMASK_TDSCDMA_BAND_D = 0x8,
  726     LE_MRC_BITMASK_TDSCDMA_BAND_E = 0x10,
  727     LE_MRC_BITMASK_TDSCDMA_BAND_F = 0x20
  728 }
  729 le_mrc_TdScdmaBandBitMask_t;
  730 
  731 
  732 //--------------------------------------------------------------------------------------------------
  733 /**
  734  * Reference type for referring to MRC Scan Information objects.
  735  */
  736 //--------------------------------------------------------------------------------------------------
  737 typedef struct le_mrc_ScanInformation* le_mrc_ScanInformationRef_t;
  738 
  739 
  740 //--------------------------------------------------------------------------------------------------
  741 /**
  742  * Reference type for Scan Information Listing.
  743  */
  744 //--------------------------------------------------------------------------------------------------
  745 typedef struct le_mrc_ScanInformationList* le_mrc_ScanInformationListRef_t;
  746 
  747 
  748 //--------------------------------------------------------------------------------------------------
  749 /**
  750  * Reference type for PCI Scan Information Listing.
  751  */
  752 //--------------------------------------------------------------------------------------------------
  753 typedef struct le_mrc_PciScanInformationList* le_mrc_PciScanInformationListRef_t;
  754 
  755 
  756 //--------------------------------------------------------------------------------------------------
  757 /**
  758  * Reference type for PCI Scan Information .
  759  */
  760 //--------------------------------------------------------------------------------------------------
  761 typedef struct le_mrc_PciScanInformation* le_mrc_PciScanInformationRef_t;
  762 
  763 
  764 //--------------------------------------------------------------------------------------------------
  765 /**
  766  * Reference type for PLMN Information .
  767  */
  768 //--------------------------------------------------------------------------------------------------
  769 typedef struct le_mrc_PlmnInformation* le_mrc_PlmnInformationRef_t;
  770 
  771 
  772 //--------------------------------------------------------------------------------------------------
  773 /**
  774  * Reference type for referring to the Preferred Operator objects.
  775  */
  776 //--------------------------------------------------------------------------------------------------
  777 typedef struct le_mrc_PreferredOperator* le_mrc_PreferredOperatorRef_t;
  778 
  779 
  780 //--------------------------------------------------------------------------------------------------
  781 /**
  782  * Reference type for Preferred Operator Listing.
  783  */
  784 //--------------------------------------------------------------------------------------------------
  785 typedef struct le_mrc_PreferredOperatorList* le_mrc_PreferredOperatorListRef_t;
  786 
  787 
  788 //--------------------------------------------------------------------------------------------------
  789 /**
  790  *  Reference type for one Cell Information.
  791  */
  792 //--------------------------------------------------------------------------------------------------
  793 typedef struct le_mrc_CellInfo* le_mrc_CellInfoRef_t;
  794 
  795 
  796 //--------------------------------------------------------------------------------------------------
  797 /**
  798  *  Reference type for all Neighboring Cells Information.
  799  */
  800 //--------------------------------------------------------------------------------------------------
  801 typedef struct le_mrc_NeighborCells* le_mrc_NeighborCellsRef_t;
  802 
  803 
  804 //--------------------------------------------------------------------------------------------------
  805 /**
  806  *  Reference type for the signal metrics.
  807  */
  808 //--------------------------------------------------------------------------------------------------
  809 typedef struct le_mrc_Metrics* le_mrc_MetricsRef_t;
  810 
  811 
  812 //--------------------------------------------------------------------------------------------------
  813 /**
  814  * Network Registration states.
  815  */
  816 //--------------------------------------------------------------------------------------------------
  817 typedef enum
  818 {
  819     LE_MRC_REG_NONE = 0,
  820         ///< Not registered and not currently searching for new operator.
  821     LE_MRC_REG_HOME = 1,
  822         ///< Registered, home network.
  823     LE_MRC_REG_SEARCHING = 2,
  824         ///< Not registered but currently searching for a new operator.
  825     LE_MRC_REG_DENIED = 3,
  826         ///< Registration was denied, usually because of invalid access credentials.
  827     LE_MRC_REG_ROAMING = 4,
  828         ///< Registered to a roaming network.
  829     LE_MRC_REG_UNKNOWN = 5
  830         ///< Unknown state.
  831 }
  832 le_mrc_NetRegState_t;
  833 
  834 
  835 //--------------------------------------------------------------------------------------------------
  836 /**
  837  * Radio Access Technology enum
  838  */
  839 //--------------------------------------------------------------------------------------------------
  840 typedef enum
  841 {
  842     LE_MRC_RAT_UNKNOWN = 0,
  843         ///< Unknown
  844     LE_MRC_RAT_GSM = 1,
  845         ///< GSM network
  846     LE_MRC_RAT_UMTS = 2,
  847         ///< UMTS networks
  848     LE_MRC_RAT_TDSCDMA = 3,
  849         ///< TD-SCDMA networks
  850     LE_MRC_RAT_LTE = 4,
  851         ///< LTE network
  852     LE_MRC_RAT_CDMA = 5
  853         ///< CDMA network
  854 }
  855 le_mrc_Rat_t;
  856 
  857 
  858 //--------------------------------------------------------------------------------------------------
  859 /**
  860  * Jamming detection report type enum
  861  *
  862  * @note If the reported status is the final status (end of the procedure), this shall be indicated
  863  * within the status report.
  864  * @note Other reports, called intermediate reports, gives only intermediate results issuing from
  865  * the algorithm
  866  */
  867 //--------------------------------------------------------------------------------------------------
  868 typedef enum
  869 {
  870     LE_MRC_JAMMING_REPORT_FINAL = 0,
  871         ///< Final jamming status report
  872     LE_MRC_JAMMING_REPORT_INTERMEDIATE = 1
  873         ///< Intermediate jamming status report
  874 }
  875 le_mrc_JammingReport_t;
  876 
  877 
  878 //--------------------------------------------------------------------------------------------------
  879 /**
  880  * Jamming detection status type enum
  881  *
  882  * @note The final status can be only NULL or JAMMED.
  883  */
  884 //--------------------------------------------------------------------------------------------------
  885 typedef enum
  886 {
  887     LE_MRC_JAMMING_STATUS_UNKNOWN = 0,
  888         ///< Status is unknown
  889     LE_MRC_JAMMING_STATUS_NULL = 1,
  890         ///< No jamming suspicion; radio environment is considered normal
  891     LE_MRC_JAMMING_STATUS_LOW = 2,
  892         ///< Low probability that the device is jammed, but some radio
  893         ///< environment parameters are considered abnormal
  894     LE_MRC_JAMMING_STATUS_MEDIUM = 3,
  895         ///< Medium probability that the device is jammed; a lot of
  896         ///< interferences in the radio spectrum
  897     LE_MRC_JAMMING_STATUS_HIGH = 4,
  898         ///< High probability that the device is jammed; radio environment is
  899         ///< considered jammed, but there is still a possibility that the module
  900         ///< succeeds in synchronizing a cell
  901     LE_MRC_JAMMING_STATUS_JAMMED = 5
  902         ///< Module is jammed; cell synchronization impossible while sufficient
  903         ///< power level is detected on a large number of frequencies
  904 }
  905 le_mrc_JammingStatus_t;
  906 
  907 
  908 //--------------------------------------------------------------------------------------------------
  909 /**
  910  * Radio Bitmask Access Technology Bit Mask
  911  */
  912 //--------------------------------------------------------------------------------------------------
  913 typedef enum
  914 {
  915     LE_MRC_BITMASK_RAT_GSM = 0x1,        ///< GSM RAT Bit Mask
  916     LE_MRC_BITMASK_RAT_UMTS = 0x2,        ///< UMTS RAT Bit Mask
  917     LE_MRC_BITMASK_RAT_TDSCDMA = 0x4,        ///< TD-SCDMA RAT Bit Mask
  918     LE_MRC_BITMASK_RAT_LTE = 0x8,        ///< LTE RAT Bit Mask
  919     LE_MRC_BITMASK_RAT_CDMA = 0x10,        ///< CDMA RAT Bit Mask
  920     LE_MRC_BITMASK_RAT_ALL = 0x20,        ///< To Set all RAT preference Bit Mask
  921     LE_MRC_BITMASK_RAT_MAX = 0x40
  922 }
  923 le_mrc_RatBitMask_t;
  924 
  925 
  926 //--------------------------------------------------------------------------------------------------
  927 /**
  928  * Network Registration reject cause type enum.
  929  */
  930 //--------------------------------------------------------------------------------------------------
  931 typedef enum
  932 {
  933     LE_MRC_IMSI_UNKNOWN = 0,
  934         ///< IMSI unknown in HLR.
  935     LE_MRC_ILLEGAL_MS = 1,
  936         ///< Illegal MS.
  937     LE_MRC_IMEI_NOT_ACCEPTED = 2,
  938         ///< IMEI not accepted.
  939     LE_MRC_ILLEGAL_ME = 3,
  940         ///< Illegal ME.
  941     LE_MRC_GPRS_NOT_ALLOWED = 4,
  942         ///< GPRS services not allowed.
  943     LE_MRC_GPRS_NON_GPRS_NOT_ALLOWED = 5,
  944         ///< GPRS services and non-GPRS services not allowed.
  945     LE_MRC_MS_IDENTITY_UNKNOWN = 6,
  946         ///< Network cannot derive the MS’s identity.
  947     LE_MRC_NETWORK_IMPLICIT_DETACH = 7,
  948         ///< Implicitly detached.
  949     LE_MRC_PLMN_NOT_ALLOWED = 8,
  950         ///< PLMN not allowed.
  951     LE_MRC_LOCATION_NOT_ALLOWED = 9,
  952         ///< Location Area not allowed.
  953     LE_MRC_ROAMING_NOT_ALLOWED = 10,
  954         ///< Roaming not allowed in this location area.
  955     LE_MRC_GPRS_NOT_ALLOWED_PLMN = 11,
  956         ///< GPRS services not allowed in this PLMN.
  957     LE_MRC_NO_SUITABLE_CELL = 12,
  958         ///< No Suitable Cells In Location Area.
  959     LE_MRC_MSC_NOT_REACHABLE = 13,
  960         ///< MSC temporarily not reachable.
  961     LE_MRC_NETWORK_FAILURE = 14,
  962         ///< Network failure.
  963     LE_MRC_MAC_FAILURE = 15,
  964         ///< MAC failure.
  965     LE_MRC_SYNCH_FAILURE = 16,
  966         ///< Synch failure.
  967     LE_MRC_CONGESTION = 17,
  968         ///< Congestion.
  969     LE_MRC_GSM_AUTH_FAILURE = 18,
  970         ///< GSM authentication unacceptable.
  971     LE_MRC_CSG_NOT_AUTHORIZED = 19,
  972         ///< Not authorized for this CSG.
  973     LE_MRC_SMS_VIA_GPRS = 20,
  974         ///< SMS provided via GPRS in this routing area.
  975     LE_MRC_No_PDP_ACTIVATED = 21,
  976         ///< No PDP context activated.
  977     LE_MRC_RETRY_NEW_CELL = 22,
  978         ///< Retry upon entry into a new cell.
  979     LE_MRC_SEMANTICAL_INCORRECT = 23,
  980         ///< Semantically incorrect message.
  981     LE_MRC_INVALID_INFORMATION = 24,
  982         ///< Invalid mandatory information.
  983     LE_MRC_MESSAGE_TYPE_WRONG = 25,
  984         ///< Message type non-existent or not implemented.
  985     LE_MRC_MESSAGE_TYPE_NOT_COMPATIBLE = 26,
  986         ///< Message type not compatible with the protocol state.
  987     LE_MRC_WRONG_IE = 27,
  988         ///< Information element non-existent or not implemented.
  989     LE_MRC_IE_ERROR = 28,
  990         ///< Conditional IE error.
  991     LE_MRC_MESSAGE_NOT_COMPATIBLE = 29,
  992         ///< Message not compatible with the protocol state.
  993     LE_MRC_PROTOCOL_ERROR = 30
  994         ///< Protocol error, unspecified.
  995 }
  996 le_mrc_NetRejCause_t;
  997 
  998 
  999 //--------------------------------------------------------------------------------------------------
 1000 /**
 1001  * Network Registration service domain type enum.
 1002  */
 1003 //--------------------------------------------------------------------------------------------------
 1004 typedef enum
 1005 {
 1006     LE_MRC_NO_SERVICE = 0,
 1007         ///< Scan is ongoing, the module cannot see any networks.
 1008     LE_MRC_CS = 1,
 1009         ///< Circuit-switched only.
 1010     LE_MRC_PS = 2,
 1011         ///< Packet-switched only.
 1012     LE_MRC_CS_PS = 3,
 1013         ///< Circuit-switched and packet-switched.
 1014     LE_MRC_LIMITED_SERVICE = 4
 1015         ///< No network register after scan.
 1016 }
 1017 le_mrc_NetRegDomain_t;
 1018 
 1019 
 1020 //--------------------------------------------------------------------------------------------------
 1021 /**
 1022  * Network registration reject indication structure.
 1023  */
 1024 //--------------------------------------------------------------------------------------------------
 1025 typedef struct
 1026 {
 1027     le_mrc_Rat_t rat;
 1028     char mcc[4];
 1029     char mnc[4];
 1030     le_mrc_NetRejCause_t cause;
 1031     le_mrc_NetRegDomain_t rejDomain;
 1032 }
 1033 le_mrc_NetRegRejectInd_t;
 1034 
 1035 
 1036 //--------------------------------------------------------------------------------------------------
 1037 /**
 1038  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegStateEvent'
 1039  */
 1040 //--------------------------------------------------------------------------------------------------
 1041 typedef struct le_mrc_NetRegStateEventHandler* le_mrc_NetRegStateEventHandlerRef_t;
 1042 
 1043 
 1044 //--------------------------------------------------------------------------------------------------
 1045 /**
 1046  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RatChange'
 1047  */
 1048 //--------------------------------------------------------------------------------------------------
 1049 typedef struct le_mrc_RatChangeHandler* le_mrc_RatChangeHandlerRef_t;
 1050 
 1051 
 1052 //--------------------------------------------------------------------------------------------------
 1053 /**
 1054  * Reference type used by Add/Remove functions for EVENT 'le_mrc_PacketSwitchedChange'
 1055  */
 1056 //--------------------------------------------------------------------------------------------------
 1057 typedef struct le_mrc_PacketSwitchedChangeHandler* le_mrc_PacketSwitchedChangeHandlerRef_t;
 1058 
 1059 
 1060 //--------------------------------------------------------------------------------------------------
 1061 /**
 1062  * Reference type used by Add/Remove functions for EVENT 'le_mrc_SignalStrengthChange'
 1063  */
 1064 //--------------------------------------------------------------------------------------------------
 1065 typedef struct le_mrc_SignalStrengthChangeHandler* le_mrc_SignalStrengthChangeHandlerRef_t;
 1066 
 1067 
 1068 //--------------------------------------------------------------------------------------------------
 1069 /**
 1070  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetworkReject'
 1071  */
 1072 //--------------------------------------------------------------------------------------------------
 1073 typedef struct le_mrc_NetworkRejectHandler* le_mrc_NetworkRejectHandlerRef_t;
 1074 
 1075 
 1076 //--------------------------------------------------------------------------------------------------
 1077 /**
 1078  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegReject'
 1079  */
 1080 //--------------------------------------------------------------------------------------------------
 1081 typedef struct le_mrc_NetRegRejectHandler* le_mrc_NetRegRejectHandlerRef_t;
 1082 
 1083 
 1084 //--------------------------------------------------------------------------------------------------
 1085 /**
 1086  * Reference type used by Add/Remove functions for EVENT 'le_mrc_JammingDetectionEvent'
 1087  */
 1088 //--------------------------------------------------------------------------------------------------
 1089 typedef struct le_mrc_JammingDetectionEventHandler* le_mrc_JammingDetectionEventHandlerRef_t;
 1090 
 1091 
 1092 //--------------------------------------------------------------------------------------------------
 1093 /**
 1094  * Handler for Network registration state changes.
 1095  */
 1096 //--------------------------------------------------------------------------------------------------
 1097 typedef void (*le_mrc_NetRegStateHandlerFunc_t)
 1098 (
 1099     le_mrc_NetRegState_t state,
 1100         ///< Parameter ready to receive the Network Registration state.
 1101     void* contextPtr
 1102         ///<
 1103 );
 1104 
 1105 //--------------------------------------------------------------------------------------------------
 1106 /**
 1107  * Handler for Radio Access Technology changes.
 1108  *
 1109  */
 1110 //--------------------------------------------------------------------------------------------------
 1111 typedef void (*le_mrc_RatChangeHandlerFunc_t)
 1112 (
 1113     le_mrc_Rat_t rat,
 1114         ///< Parameter ready to receive the Radio Access Technology.
 1115     void* contextPtr
 1116         ///<
 1117 );
 1118 
 1119 //--------------------------------------------------------------------------------------------------
 1120 /**
 1121  * Handler for Packet Switched service state changes.
 1122  *
 1123  */
 1124 //--------------------------------------------------------------------------------------------------
 1125 typedef void (*le_mrc_PacketSwitchedChangeHandlerFunc_t)
 1126 (
 1127     le_mrc_NetRegState_t state,
 1128         ///< Parameter ready to receive the Packet Switched service state.
 1129     void* contextPtr
 1130         ///<
 1131 );
 1132 
 1133 //--------------------------------------------------------------------------------------------------
 1134 /**
 1135  * Handler for Signal Strength value changes.
 1136  *
 1137  */
 1138 //--------------------------------------------------------------------------------------------------
 1139 typedef void (*le_mrc_SignalStrengthChangeHandlerFunc_t)
 1140 (
 1141     int32_t ss,
 1142         ///< Signal strength in dBm
 1143     void* contextPtr
 1144         ///<
 1145 );
 1146 
 1147 //--------------------------------------------------------------------------------------------------
 1148 /**
 1149  * Handler for cellular asynchronous network scan Sending result.
 1150  *  Returns the reference to the List object. Null pointer if the scan failed.
 1151  *
 1152  */
 1153 //--------------------------------------------------------------------------------------------------
 1154 typedef void (*le_mrc_CellularNetworkScanHandlerFunc_t)
 1155 (
 1156     le_mrc_ScanInformationListRef_t listRef,
 1157         ///< Reference to the List object. Null pointer if the
 1158         ///< scan failed.
 1159     void* contextPtr
 1160         ///<
 1161 );
 1162 
 1163 //--------------------------------------------------------------------------------------------------
 1164 /**
 1165  * Handler for PCI asynchronous network scan Sending result.
 1166  *  Returns the reference to the List object. Null pointer if the scan failed.
 1167  *
 1168  */
 1169 //--------------------------------------------------------------------------------------------------
 1170 typedef void (*le_mrc_PciNetworkScanHandlerFunc_t)
 1171 (
 1172     le_mrc_PciScanInformationListRef_t listRef,
 1173         ///< Reference to the List object. Null pointer if the
 1174         ///< scan failed.
 1175     void* contextPtr
 1176         ///<
 1177 );
 1178 
 1179 //--------------------------------------------------------------------------------------------------
 1180 /**
 1181  * Handler for asynchronous manual selection response
 1182  *
 1183  */
 1184 //--------------------------------------------------------------------------------------------------
 1185 typedef void (*le_mrc_ManualSelectionHandlerFunc_t)
 1186 (
 1187     le_result_t result,
 1188         ///< Manual selection response
 1189     void* contextPtr
 1190         ///<
 1191 );
 1192 
 1193 //--------------------------------------------------------------------------------------------------
 1194 /**
 1195  * Handler to report network reject indication.
 1196  *
 1197  * @deprecated le_mrc_NetworkRejectHandler() will be removed in near future.
 1198  * It will be replaced by le_mrc_AddNetRegRejectHandler().
 1199  *
 1200  */
 1201 //--------------------------------------------------------------------------------------------------
 1202 typedef void (*le_mrc_NetworkRejectHandlerFunc_t)
 1203 (
 1204     const char* LE_NONNULL mcc,
 1205         ///< Mobile Country Code
 1206     const char* LE_NONNULL mnc,
 1207         ///< Mobile Network Code
 1208     le_mrc_Rat_t rat,
 1209         ///< Radio Access Technology.
 1210     void* contextPtr
 1211         ///<
 1212 );
 1213 
 1214 //--------------------------------------------------------------------------------------------------
 1215 /**
 1216  * Handler to report network registration reject indication.
 1217  * NetworkRejectHandler is deprecated.
 1218  */
 1219 //--------------------------------------------------------------------------------------------------
 1220 typedef void (*le_mrc_NetRegRejectHandlerFunc_t)
 1221 (
 1222     const le_mrc_NetRegRejectInd_t * LE_NONNULL networkRejectIndPtr,
 1223         ///< NetRegRejectInd Reference.
 1224     void* contextPtr
 1225         ///<
 1226 );
 1227 
 1228 //--------------------------------------------------------------------------------------------------
 1229 /**
 1230  * Handler for jamming detection event.
 1231  */
 1232 //--------------------------------------------------------------------------------------------------
 1233 typedef void (*le_mrc_JammingDetectionHandlerFunc_t)
 1234 (
 1235     le_mrc_JammingReport_t report,
 1236         ///< Report type.
 1237     le_mrc_JammingStatus_t status,
 1238         ///< Jamming detection status.
 1239     void* contextPtr
 1240         ///<
 1241 );
 1242 
 1243 //--------------------------------------------------------------------------------------------------
 1244 /**
 1245  * Add handler function for EVENT 'le_mrc_NetRegStateEvent'
 1246  *
 1247  * This event provides information on network registration state changes.
 1248  *
 1249  * @note <b>multi-app safe</b>
 1250  */
 1251 //--------------------------------------------------------------------------------------------------
 1252 le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler
 1253 (
 1254     le_mrc_NetRegStateHandlerFunc_t handlerPtr,
 1255         ///< [IN]
 1256     void* contextPtr
 1257         ///< [IN]
 1258 );
 1259 
 1260 //--------------------------------------------------------------------------------------------------
 1261 /**
 1262  * Remove handler function for EVENT 'le_mrc_NetRegStateEvent'
 1263  */
 1264 //--------------------------------------------------------------------------------------------------
 1265 void le_mrc_RemoveNetRegStateEventHandler
 1266 (
 1267     le_mrc_NetRegStateEventHandlerRef_t handlerRef
 1268         ///< [IN]
 1269 );
 1270 
 1271 //--------------------------------------------------------------------------------------------------
 1272 /**
 1273  * Add handler function for EVENT 'le_mrc_RatChange'
 1274  *
 1275  * This event provides information on Radio Access Technology changes.
 1276  *
 1277  * @note <b>multi-app safe</b>
 1278  */
 1279 //--------------------------------------------------------------------------------------------------
 1280 le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler
 1281 (
 1282     le_mrc_RatChangeHandlerFunc_t handlerPtr,
 1283         ///< [IN]
 1284     void* contextPtr
 1285         ///< [IN]
 1286 );
 1287 
 1288 //--------------------------------------------------------------------------------------------------
 1289 /**
 1290  * Remove handler function for EVENT 'le_mrc_RatChange'
 1291  */
 1292 //--------------------------------------------------------------------------------------------------
 1293 void le_mrc_RemoveRatChangeHandler
 1294 (
 1295     le_mrc_RatChangeHandlerRef_t handlerRef
 1296         ///< [IN]
 1297 );
 1298 
 1299 //--------------------------------------------------------------------------------------------------
 1300 /**
 1301  * Add handler function for EVENT 'le_mrc_PacketSwitchedChange'
 1302  *
 1303  * This event provides information on Packet Switched service changes.
 1304  *
 1305  * @note <b>multi-app safe</b>
 1306  */
 1307 //--------------------------------------------------------------------------------------------------
 1308 le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler
 1309 (
 1310     le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr,
 1311         ///< [IN]
 1312     void* contextPtr
 1313         ///< [IN]
 1314 );
 1315 
 1316 //--------------------------------------------------------------------------------------------------
 1317 /**
 1318  * Remove handler function for EVENT 'le_mrc_PacketSwitchedChange'
 1319  */
 1320 //--------------------------------------------------------------------------------------------------
 1321 void le_mrc_RemovePacketSwitchedChangeHandler
 1322 (
 1323     le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef
 1324         ///< [IN]
 1325 );
 1326 
 1327 //--------------------------------------------------------------------------------------------------
 1328 /**
 1329  * Add handler function for EVENT 'le_mrc_SignalStrengthChange'
 1330  *
 1331  * This event provides information on Signal Strength value changes.
 1332  *
 1333  * @note <b>NOT multi-app safe</b>
 1334  */
 1335 //--------------------------------------------------------------------------------------------------
 1336 le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler
 1337 (
 1338     le_mrc_Rat_t rat,
 1339         ///< [IN] Radio Access Technology
 1340     int32_t lowerRangeThreshold,
 1341         ///< [IN] Lower-range Signal strength threshold in dBm
 1342     int32_t upperRangeThreshold,
 1343         ///< [IN] Upper-range Signal strength threshold in dBm
 1344     le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr,
 1345         ///< [IN]
 1346     void* contextPtr
 1347         ///< [IN]
 1348 );
 1349 
 1350 //--------------------------------------------------------------------------------------------------
 1351 /**
 1352  * Remove handler function for EVENT 'le_mrc_SignalStrengthChange'
 1353  */
 1354 //--------------------------------------------------------------------------------------------------
 1355 void le_mrc_RemoveSignalStrengthChangeHandler
 1356 (
 1357     le_mrc_SignalStrengthChangeHandlerRef_t handlerRef
 1358         ///< [IN]
 1359 );
 1360 
 1361 //--------------------------------------------------------------------------------------------------
 1362 /**
 1363  * This function sets signal strength indication thresholds for a specific RAT.
 1364  *
 1365  * @return
 1366  *  - LE_OK             Function succeeded.
 1367  *  - LE_BAD_PARAMETER  Bad parameters
 1368  *  - LE_FAULT          Function failed.
 1369  *
 1370  * @note <b>NOT multi-app safe</b>
 1371  */
 1372 //--------------------------------------------------------------------------------------------------
 1373 le_result_t le_mrc_SetSignalStrengthIndThresholds
 1374 (
 1375     le_mrc_Rat_t rat,
 1376         ///< [IN] Radio Access Technology
 1377     int32_t lowerRangeThreshold,
 1378         ///< [IN] Lower-range Signal strength threshold in dBm
 1379     int32_t upperRangeThreshold
 1380         ///< [IN] Upper-range Signal strength threshold in dBm
 1381 );
 1382 
 1383 //--------------------------------------------------------------------------------------------------
 1384 /**
 1385  * This function sets a signal strength indication delta for a specific RAT.
 1386  *
 1387  * @return
 1388  *  - LE_OK             Function succeeded.
 1389  *  - LE_BAD_PARAMETER  Bad parameters.
 1390  *  - LE_FAULT          Function failed.
 1391  *
 1392  * @note The signal delta is set in units of 0.1 dBm. For example, to set a delta of 10.6 dBm, the
 1393  *       delta value must be set to 106.
 1394  *
 1395  * @warning The signal delta resolution is platform dependent. Please refer to
 1396  *          @ref platformConstraintsMdc section for full details.
 1397  */
 1398 //--------------------------------------------------------------------------------------------------
 1399 le_result_t le_mrc_SetSignalStrengthIndDelta
 1400 (
 1401     le_mrc_Rat_t rat,
 1402         ///< [IN] Radio Access Technology
 1403     uint16_t delta
 1404         ///< [IN] Signal delta in units of 0.1 dBm
 1405 );
 1406 
 1407 //--------------------------------------------------------------------------------------------------
 1408 /**
 1409  * Enable the automatic Selection Register mode.
 1410  *
 1411  * @return
 1412  *  - LE_FAULT  Function failed.
 1413  *  - LE_OK     Function succeeded.
 1414  *
 1415  * @note <b>NOT multi-app safe</b>
 1416  */
 1417 //--------------------------------------------------------------------------------------------------
 1418 le_result_t le_mrc_SetAutomaticRegisterMode
 1419 (
 1420     void
 1421 );
 1422 
 1423 //--------------------------------------------------------------------------------------------------
 1424 /**
 1425  * Set the manual Selection Register mode with the MCC/MNC parameters.
 1426  *
 1427  * @return
 1428  *  - LE_FAULT  Function failed.
 1429  *  - LE_OK     Function succeeded.
 1430  *
 1431  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1432  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1433  *       won't return.
 1434  *
 1435  * @note <b>NOT multi-app safe</b>
 1436  */
 1437 //--------------------------------------------------------------------------------------------------
 1438 le_result_t le_mrc_SetManualRegisterMode
 1439 (
 1440     const char* LE_NONNULL mcc,
 1441         ///< [IN] Mobile Country Code
 1442     const char* LE_NONNULL mnc
 1443         ///< [IN] Mobile Network Code
 1444 );
 1445 
 1446 //--------------------------------------------------------------------------------------------------
 1447 /**
 1448  * Set the manual selection register mode asynchronously. This function is not blocking,
 1449  *  the response will be returned with a handler function.
 1450  *
 1451  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1452  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1453  *       won't return.
 1454  *
 1455  *@note <b>NOT multi-app safe</b>
 1456  *
 1457  */
 1458 //--------------------------------------------------------------------------------------------------
 1459 void le_mrc_SetManualRegisterModeAsync
 1460 (
 1461     const char* LE_NONNULL mcc,
 1462         ///< [IN] Mobile Country Code
 1463     const char* LE_NONNULL mnc,
 1464         ///< [IN] Mobile Network Code
 1465     le_mrc_ManualSelectionHandlerFunc_t handlerPtr,
 1466         ///< [IN] handler for sending result
 1467     void* contextPtr
 1468         ///< [IN]
 1469 );
 1470 
 1471 //--------------------------------------------------------------------------------------------------
 1472 /**
 1473  * Get the selected Selection Register mode.
 1474  *
 1475  * @return
 1476  *  - LE_FAULT  Function failed.
 1477  *  - LE_OK     Function succeeded.
 1478  *
 1479  * @note <b>multi-app safe</b>
 1480  */
 1481 //--------------------------------------------------------------------------------------------------
 1482 le_result_t le_mrc_GetRegisterMode
 1483 (
 1484     bool* isManualPtrPtr,
 1485         ///< [OUT] true if the scan mode is manual, false if the scan mode is automatic.
 1486     char* mccPtr,
 1487         ///< [OUT] Mobile Country Code
 1488     size_t mccPtrSize,
 1489         ///< [IN]
 1490     char* mncPtr,
 1491         ///< [OUT] Mobile Network Code
 1492     size_t mncPtrSize
 1493         ///< [IN]
 1494 );
 1495 
 1496 //--------------------------------------------------------------------------------------------------
 1497 /**
 1498  * Get the Packet Switched state.
 1499  *
 1500  * @return
 1501  *  - LE_FAULT  Function failed.
 1502  *  - LE_OK     Function succeeded.
 1503  *
 1504  * @note <b>multi-app safe</b>
 1505  */
 1506 //--------------------------------------------------------------------------------------------------
 1507 le_result_t le_mrc_GetPacketSwitchedState
 1508 (
 1509     le_mrc_NetRegState_t* statePtr
 1510         ///< [OUT] The current Packet switched state.
 1511 );
 1512 
 1513 //--------------------------------------------------------------------------------------------------
 1514 /**
 1515  * Get the platform specific network registration error code.
 1516  *
 1517  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific
 1518  * registration error code description.
 1519  *
 1520  * @return the platform specific registration error code
 1521  *
 1522  */
 1523 //--------------------------------------------------------------------------------------------------
 1524 int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode
 1525 (
 1526     void
 1527 );
 1528 
 1529 //--------------------------------------------------------------------------------------------------
 1530 /**
 1531  * Set the Radio Access Technology preferences by using a bit mask.
 1532  *
 1533  * @return
 1534  *  - LE_FAULT           Function failed.
 1535  *  - LE_OK              Function succeeded.
 1536  *  - LE_UNSUPPORTED     Not supported by platform.
 1537  *
 1538  * @note <b>NOT multi-app safe</b>
 1539  */
 1540 //--------------------------------------------------------------------------------------------------
 1541 le_result_t le_mrc_SetRatPreferences
 1542 (
 1543     le_mrc_RatBitMask_t ratMask
 1544         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1545 );
 1546 
 1547 //--------------------------------------------------------------------------------------------------
 1548 /**
 1549  * Get the Radio Access Technology preferences
 1550  *
 1551  * @return
 1552  * - LE_FAULT  Function failed.
 1553  * - LE_OK     Function succeeded.
 1554  *
 1555  * @note <b>multi-app safe</b>
 1556  */
 1557 //--------------------------------------------------------------------------------------------------
 1558 le_result_t le_mrc_GetRatPreferences
 1559 (
 1560     le_mrc_RatBitMask_t* ratMaskPtrPtr
 1561         ///< [OUT] Bit mask for the Radio Access Technology preferences.
 1562 );
 1563 
 1564 //--------------------------------------------------------------------------------------------------
 1565 /**
 1566  * Set the 2G/3G Band preferences by using a bit mask.
 1567  *
 1568  * @return
 1569  *  - LE_FAULT  Function failed.
 1570  *  - LE_OK     Function succeeded.
 1571  *
 1572  * @note <b>NOT multi-app safe</b>
 1573  */
 1574 //--------------------------------------------------------------------------------------------------
 1575 le_result_t le_mrc_SetBandPreferences
 1576 (
 1577     le_mrc_BandBitMask_t bandMask
 1578         ///< [IN] Bit mask for 2G/3G Band preferences.
 1579 );
 1580 
 1581 //--------------------------------------------------------------------------------------------------
 1582 /**
 1583  * Get the Bit mask for 2G/3G Band preferences.
 1584  *
 1585  * @return
 1586  *  - LE_FAULT  Function failed.
 1587  *  - LE_OK     Function succeeded.
 1588  *
 1589  * @note <b>multi-app safe</b>
 1590  */
 1591 //--------------------------------------------------------------------------------------------------
 1592 le_result_t le_mrc_GetBandPreferences
 1593 (
 1594     le_mrc_BandBitMask_t* bandMaskPtrPtr
 1595         ///< [OUT] Bit mask for 2G/3G Band preferences.
 1596 );
 1597 
 1598 //--------------------------------------------------------------------------------------------------
 1599 /**
 1600  * Set the LTE Band preferences by using a bit mask.
 1601  *
 1602  * @return
 1603  *  - LE_FAULT        Function failed.
 1604  *  - LE_OK           Function succeeded.
 1605  *  - LE_UNSUPPORTED  The platform doesn't support setting LTE Band preferences.
 1606  *
 1607  * @note <b>NOT multi-app safe</b>
 1608  */
 1609 //--------------------------------------------------------------------------------------------------
 1610 le_result_t le_mrc_SetLteBandPreferences
 1611 (
 1612     le_mrc_LteBandBitMask_t bandMask
 1613         ///< [IN] Bit mask for LTE Band preferences.
 1614 );
 1615 
 1616 //--------------------------------------------------------------------------------------------------
 1617 /**
 1618  * Get the Bit mask for LTE Band preferences.
 1619  *
 1620  * @return
 1621  *  - LE_FAULT  Function failed.
 1622  *  - LE_OK     Function succeeded.
 1623  *
 1624  * @note <b>multi-app safe</b>
 1625  */
 1626 //--------------------------------------------------------------------------------------------------
 1627 le_result_t le_mrc_GetLteBandPreferences
 1628 (
 1629     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 1630         ///< [OUT] Bit mask for LTE Band preferences.
 1631 );
 1632 
 1633 //--------------------------------------------------------------------------------------------------
 1634 /**
 1635  * Set the TD-SCDMA Band preferences by using a bit mask.
 1636  *
 1637  * @return
 1638  *  - LE_OK           Function succeeded.
 1639  *  - LE_FAULT        Function failed.
 1640  *  - LE_UNSUPPORTED  The platform doesn't support setting TD-SCDMA Band preferences.
 1641  *
 1642  * @note <b>NOT multi-app safe</b>
 1643  */
 1644 //--------------------------------------------------------------------------------------------------
 1645 le_result_t le_mrc_SetTdScdmaBandPreferences
 1646 (
 1647     le_mrc_TdScdmaBandBitMask_t bandMask
 1648         ///< [IN] Bit mask for TD-SCDMA Band preferences.
 1649 );
 1650 
 1651 //--------------------------------------------------------------------------------------------------
 1652 /**
 1653  * Get the Bit mask for TD-SCDMA Band preferences.
 1654  *
 1655  * @return
 1656  *  - LE_OK           Function succeeded.
 1657  *  - LE_FAULT        Function failed.
 1658  *  - LE_UNSUPPORTED  The platform doesn't support getting TD-SCDMA Band preferences.
 1659  *
 1660  * @note <b>multi-app safe</b>
 1661  */
 1662 //--------------------------------------------------------------------------------------------------
 1663 le_result_t le_mrc_GetTdScdmaBandPreferences
 1664 (
 1665     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 1666         ///< [OUT] Bit mask for TD-SCDMA Band preferences.
 1667 );
 1668 
 1669 //--------------------------------------------------------------------------------------------------
 1670 /**
 1671  * Add a preferred operator by specifying the MCC/MNC and the Radio Access Technology.
 1672  *
 1673  * @return
 1674  *  - LE_UNSUPPORTED   List of User Preferred operators not available.
 1675  *  - LE_FAULT         Function failed.
 1676  *  - LE_BAD_PARAMETER RAT mask is invalid.
 1677  *  - LE_OK            Function succeeded.
 1678  *
 1679  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1680  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1681  *       won't return.
 1682  *
 1683  * @note <b>NOT multi-app safe</b>
 1684  */
 1685 //--------------------------------------------------------------------------------------------------
 1686 le_result_t le_mrc_AddPreferredOperator
 1687 (
 1688     const char* LE_NONNULL mcc,
 1689         ///< [IN] Mobile Country Code
 1690     const char* LE_NONNULL mnc,
 1691         ///< [IN] Mobile Network Code
 1692     le_mrc_RatBitMask_t ratMask
 1693         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1694 );
 1695 
 1696 //--------------------------------------------------------------------------------------------------
 1697 /**
 1698  * Remove a preferred operator by specifying the MCC/MNC.
 1699  *
 1700  * @return
 1701  *  - LE_UNSUPPORTED    List of User Preferred operators not available.
 1702  *  - LE_NOT_FOUND      Operator not found in the User Preferred operators list.
 1703  *  - LE_FAULT          Function failed.
 1704  *  - LE_OK             Function succeeded.
 1705  *
 1706  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1707  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1708  *       won't return.
 1709  *
 1710  * @note <b>NOT multi-app safe</b>
 1711  */
 1712 //--------------------------------------------------------------------------------------------------
 1713 le_result_t le_mrc_RemovePreferredOperator
 1714 (
 1715     const char* LE_NONNULL mcc,
 1716         ///< [IN] Mobile Country Code
 1717     const char* LE_NONNULL mnc
 1718         ///< [IN] Mobile Network Code
 1719 );
 1720 
 1721 //--------------------------------------------------------------------------------------------------
 1722 /**
 1723  * This function must be called to retrieve a list of the preferred operators.
 1724  *
 1725  * @return
 1726  * - Reference to the List object.
 1727  * - Null pointer if there is no preferences list.
 1728  *
 1729  * @note <b>multi-app safe</b>
 1730  */
 1731 //--------------------------------------------------------------------------------------------------
 1732 le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList
 1733 (
 1734     void
 1735 );
 1736 
 1737 //--------------------------------------------------------------------------------------------------
 1738 /**
 1739  * This function must be called to get the first Operator object reference in the list of the
 1740  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1741  *
 1742  * @return
 1743  *  - NULL                          No operator information found.
 1744  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1745  *
 1746  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1747  *       function won't return.
 1748  *
 1749  * @note <b>multi-app safe</b>
 1750  */
 1751 //--------------------------------------------------------------------------------------------------
 1752 le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator
 1753 (
 1754     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1755         ///< [IN] The list of the preferred operators.
 1756 );
 1757 
 1758 //--------------------------------------------------------------------------------------------------
 1759 /**
 1760  * This function must be called to get the next Operator object reference in the list of the
 1761  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1762  *
 1763  * @return
 1764  *  - NULL                          No operator information found.
 1765  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1766  *
 1767  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1768  *       function won't return.
 1769  *
 1770  * @note <b>multi-app safe</b>
 1771  */
 1772 //--------------------------------------------------------------------------------------------------
 1773 le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator
 1774 (
 1775     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1776         ///< [IN] The list of the preferred operators.
 1777 );
 1778 
 1779 //--------------------------------------------------------------------------------------------------
 1780 /**
 1781  * This function must be called to delete the list of the preferred operators retrieved with
 1782  * le_mrc_GetPreferredOperators().
 1783  *
 1784  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1785  *       reference for validity.
 1786  *
 1787  * @note <b>multi-app safe</b>
 1788  */
 1789 //--------------------------------------------------------------------------------------------------
 1790 void le_mrc_DeletePreferredOperatorsList
 1791 (
 1792     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1793         ///< [IN] The list of the preferred operators.
 1794 );
 1795 
 1796 //--------------------------------------------------------------------------------------------------
 1797 /**
 1798  * This function must be called to get the Operator information details.
 1799  *
 1800  * @return
 1801  *      - LE_OK on success
 1802  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1803  *      - LE_FAULT for all other errors
 1804  *
 1805  * @note <b>multi-app safe</b>
 1806  */
 1807 //--------------------------------------------------------------------------------------------------
 1808 le_result_t le_mrc_GetPreferredOperatorDetails
 1809 (
 1810     le_mrc_PreferredOperatorRef_t preferredOperatorRef,
 1811         ///< [IN] Operator object reference.
 1812     char* mccPtr,
 1813         ///< [OUT] Mobile Country Code.
 1814     size_t mccPtrSize,
 1815         ///< [IN]
 1816     char* mncPtr,
 1817         ///< [OUT] Mobile Network Code.
 1818     size_t mncPtrSize,
 1819         ///< [IN]
 1820     le_mrc_RatBitMask_t* ratMaskPtr
 1821         ///< [OUT] Bit mask for the RAT preferences.
 1822 );
 1823 
 1824 //--------------------------------------------------------------------------------------------------
 1825 /**
 1826  * Get the network registration state.
 1827  *
 1828  * @return LE_FAULT         The function failed to get the Network registration state.
 1829  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1830  * @return LE_OK            The function succeeded.
 1831  *
 1832  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1833  *       function won't return.
 1834  *
 1835  * @note <b>multi-app safe</b>
 1836  */
 1837 //--------------------------------------------------------------------------------------------------
 1838 le_result_t le_mrc_GetNetRegState
 1839 (
 1840     le_mrc_NetRegState_t* statePtr
 1841         ///< [OUT] Network Registration state.
 1842 );
 1843 
 1844 //--------------------------------------------------------------------------------------------------
 1845 /**
 1846  * Get the signal quality.
 1847  *
 1848  * @return LE_FAULT         The function failed to get the Signal Quality information.
 1849  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1850  * @return LE_OK            The function succeeded.
 1851  *
 1852  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1853  *       function won't return.
 1854  *
 1855  * @note <b>multi-app safe</b>
 1856  */
 1857 //--------------------------------------------------------------------------------------------------
 1858 le_result_t le_mrc_GetSignalQual
 1859 (
 1860     uint32_t* qualityPtr
 1861         ///< [OUT] [OUT] Received signal strength quality (0 = no signal strength,
 1862         ///<        5 = very good signal strength).
 1863 );
 1864 
 1865 //--------------------------------------------------------------------------------------------------
 1866 /**
 1867  * Set the power of the Radio Module.
 1868  *
 1869  * @return LE_BAD_PARAMETER Bad power mode specified.
 1870  * @return LE_FAULT         Function failed.
 1871  * @return LE_OK            Function succeed.
 1872  *
 1873  * @note <b>NOT multi-app safe</b>
 1874  */
 1875 //--------------------------------------------------------------------------------------------------
 1876 le_result_t le_mrc_SetRadioPower
 1877 (
 1878     le_onoff_t power
 1879         ///< [IN] The power state.
 1880 );
 1881 
 1882 //--------------------------------------------------------------------------------------------------
 1883 /**
 1884  * Must be called to get the Radio Module power state.
 1885  *
 1886  * @return LE_FAULT         The function failed to get the Radio Module power state.
 1887  * @return LE_BAD_PARAMETER if powerPtr is NULL.
 1888  * @return LE_OK            The function succeed.
 1889  *
 1890  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1891  *       function won't return.
 1892  *
 1893  * @note <b>multi-app safe</b>
 1894  */
 1895 //--------------------------------------------------------------------------------------------------
 1896 le_result_t le_mrc_GetRadioPower
 1897 (
 1898     le_onoff_t* powerPtr
 1899         ///< [OUT] Power state.
 1900 );
 1901 
 1902 //--------------------------------------------------------------------------------------------------
 1903 /**
 1904  * This function must be called to perform a cellular network scan.
 1905  *
 1906  * @return Reference to the List object. Null pointer if the scan failed.
 1907  *
 1908  * @note <b>multi-app safe</b>
 1909  */
 1910 //--------------------------------------------------------------------------------------------------
 1911 le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan
 1912 (
 1913     le_mrc_RatBitMask_t ratMask
 1914         ///< [IN] Radio Access Technology mask
 1915 );
 1916 
 1917 //--------------------------------------------------------------------------------------------------
 1918 /**
 1919  * This function must be called to perform a PCI network scan.
 1920  *
 1921  * @return Reference to the List object. Null pointer if the scan failed.
 1922  *
 1923  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
 1924  *          details.
 1925  *
 1926  * @note <b>multi-app safe</b>
 1927  */
 1928 //--------------------------------------------------------------------------------------------------
 1929 le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan
 1930 (
 1931     le_mrc_RatBitMask_t ratMask
 1932         ///< [IN] Radio Access Technology mask
 1933 );
 1934 
 1935 //--------------------------------------------------------------------------------------------------
 1936 /**
 1937  * This function must be called to perform a cellular network scan asynchronously. This function
 1938  * is not blocking, the response will be returned with a handler function.
 1939  *
 1940  *@note <b>multi-app safe</b>
 1941  *
 1942  */
 1943 //--------------------------------------------------------------------------------------------------
 1944 void le_mrc_PerformCellularNetworkScanAsync
 1945 (
 1946     le_mrc_RatBitMask_t ratMask,
 1947         ///< [IN] Radio Access Technology mask
 1948     le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr,
 1949         ///< [IN] handler for sending result.
 1950     void* contextPtr
 1951         ///< [IN]
 1952 );
 1953 
 1954 //--------------------------------------------------------------------------------------------------
 1955 /**
 1956  * This function must be called to perform a PCI network scan asynchronously. This function
 1957  * is not blocking, the response will be returned with a handler function.
 1958  *
 1959  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
 1960  *          details.
 1961  *
 1962  *@note <b>multi-app safe</b>
 1963  *
 1964  */
 1965 //--------------------------------------------------------------------------------------------------
 1966 void le_mrc_PerformPciNetworkScanAsync
 1967 (
 1968     le_mrc_RatBitMask_t ratMask,
 1969         ///< [IN] Radio Access Technology mask
 1970     le_mrc_PciNetworkScanHandlerFunc_t handlerPtr,
 1971         ///< [IN] handler for sending result.
 1972     void* contextPtr
 1973         ///< [IN]
 1974 );
 1975 
 1976 //--------------------------------------------------------------------------------------------------
 1977 /**
 1978  * This function must be called to get the first Scan Information object reference in the list of
 1979  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
 1980  *
 1981  * @return NULL                         No scan information found.
 1982  * @return le_mrc_ScanInformationRef_t  The Scan Information object reference.
 1983  *
 1984  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1985  *       function won't return.
 1986  *
 1987  * @note <b>multi-app safe</b>
 1988  */
 1989 //--------------------------------------------------------------------------------------------------
 1990 le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan
 1991 (
 1992     le_mrc_ScanInformationListRef_t scanInformationListRef
 1993         ///< [IN] The list of scan information.
 1994 );
 1995 
 1996 //--------------------------------------------------------------------------------------------------
 1997 /**
 1998  * This function must be called to get the next Scan Information object reference in the list of
 1999  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
 2000  *
 2001  * @return NULL                         No scan information found.
 2002  * @return le_mrc_ScanInformationRef_t  The Scan Information object reference.
 2003  *
 2004  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2005  *       function won't return.
 2006  *
 2007  * @note <b>multi-app safe</b>
 2008  */
 2009 //--------------------------------------------------------------------------------------------------
 2010 le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan
 2011 (
 2012     le_mrc_ScanInformationListRef_t scanInformationListRef
 2013         ///< [IN] The list of scan information.
 2014 );
 2015 
 2016 //--------------------------------------------------------------------------------------------------
 2017 /**
 2018  * This function must be called to get the first Pci Scan Information object reference in the list of
 2019  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
 2020  *
 2021  * @return NULL                         No scan information found.
 2022  * @return The Scan Information object reference.
 2023  *
 2024  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2025  *       function won't return.
 2026  *
 2027  * @note <b>multi-app safe</b>
 2028  */
 2029 //--------------------------------------------------------------------------------------------------
 2030 le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo
 2031 (
 2032     le_mrc_PciScanInformationListRef_t scanInformationListRef
 2033         ///< [IN] The list of scan information.
 2034 );
 2035 
 2036 //--------------------------------------------------------------------------------------------------
 2037 /**
 2038  * This function must be called to get the next Scan Information object reference in the list of
 2039  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
 2040  *
 2041  * @return NULL                         No scan information found.
 2042  * @return The Scan Information object reference.
 2043  *
 2044  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2045  *       function won't return.
 2046  *
 2047  * @note <b>multi-app safe</b>
 2048  */
 2049 //--------------------------------------------------------------------------------------------------
 2050 le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo
 2051 (
 2052     le_mrc_PciScanInformationListRef_t scanInformationListRef
 2053         ///< [IN] The list of scan information.
 2054 );
 2055 
 2056 //--------------------------------------------------------------------------------------------------
 2057 /**
 2058  * This function must be called to get the first Plmn Information object reference in the list of
 2059  * Plmn on each cell.
 2060  *
 2061  * @return NULL                         No scan information found.
 2062  * @return le_mrc_PlmnInformationRef_t  The Plmn Information object reference.
 2063  *
 2064  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2065  *       function won't return.
 2066  *
 2067  */
 2068 //--------------------------------------------------------------------------------------------------
 2069 le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo
 2070 (
 2071     le_mrc_PciScanInformationRef_t pciScanInformationRef
 2072         ///< [IN] [IN] The reference to the cell information.
 2073 );
 2074 
 2075 //--------------------------------------------------------------------------------------------------
 2076 /**
 2077  * This function must be called to get the next Plmn Information object reference in the list of
 2078  * Plmn on each cell.
 2079  *
 2080  * @return NULL                         No scan information found.
 2081  * @return le_mrc_PlmnInformationRef_t  The Plmn Information object reference.
 2082  *
 2083  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2084  *       function won't return.
 2085  *
 2086  */
 2087 //--------------------------------------------------------------------------------------------------
 2088 le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo
 2089 (
 2090     le_mrc_PciScanInformationRef_t plmnRef
 2091         ///< [IN] [IN] The reference to the cell information.
 2092 );
 2093 
 2094 //--------------------------------------------------------------------------------------------------
 2095 /**
 2096  * This function must be called to get the physical cell id referenced by PciScanInformation which
 2097  * is returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
 2098  *
 2099  * @return The Physical Cell Identifier.
 2100  *
 2101  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2102  *       function won't return.
 2103  */
 2104 //--------------------------------------------------------------------------------------------------
 2105 uint16_t le_mrc_GetPciScanCellId
 2106 (
 2107     le_mrc_PciScanInformationRef_t pciScanInformationRef
 2108         ///< [IN] [IN] The reference to the cell information.
 2109 );
 2110 
 2111 //--------------------------------------------------------------------------------------------------
 2112 /**
 2113  * This function must be called to get the global cell id referenced by PciScanInformation which is
 2114  * returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
 2115  *
 2116  * @return The Global Cell Identifier.
 2117  *
 2118  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2119  *       function won't return.
 2120  */
 2121 //--------------------------------------------------------------------------------------------------
 2122 uint32_t le_mrc_GetPciScanGlobalCellId
 2123 (
 2124     le_mrc_PciScanInformationRef_t pciScanInformationRef
 2125         ///< [IN] [IN] The reference to the cell information.
 2126 );
 2127 
 2128 //--------------------------------------------------------------------------------------------------
 2129 /**
 2130  * This function must be called to get the Mcc/Mnc of each PLMN referenced in the list of
 2131  * Plmn Information retrieved with le_mrc_GetFirstPlmnInfo() and le_mrc_GetNextPlmnInfo().
 2132  *
 2133  * @return
 2134  *      - LE_OK on success
 2135  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 2136  *      - LE_FAULT for all other errors
 2137  *
 2138  *
 2139  */
 2140 //--------------------------------------------------------------------------------------------------
 2141 le_result_t le_mrc_GetPciScanMccMnc
 2142 (
 2143     le_mrc_PlmnInformationRef_t plmnRef,
 2144         ///< [IN] [IN] The reference to the cell information.
 2145     char* mccPtr,
 2146         ///< [OUT] Mobile Country Code
 2147     size_t mccPtrSize,
 2148         ///< [IN]
 2149     char* mncPtr,
 2150         ///< [OUT] Mobile Network Code
 2151     size_t mncPtrSize
 2152         ///< [IN]
 2153 );
 2154 
 2155 //--------------------------------------------------------------------------------------------------
 2156 /**
 2157  * This function must be called to delete the list of the Scan Information retrieved with
 2158  * le_mrc_PerformCellularNetworkScan().
 2159  *
 2160  * @note
 2161  *      On failure, the process exits, so you don't have to worry about checking the returned
 2162  *      reference for validity.
 2163  *
 2164  * @note <b>multi-app safe</b>
 2165  */
 2166 //--------------------------------------------------------------------------------------------------
 2167 void le_mrc_DeleteCellularNetworkScan
 2168 (
 2169     le_mrc_ScanInformationListRef_t scanInformationListRef
 2170         ///< [IN] The list of scan information.
 2171 );
 2172 
 2173 //--------------------------------------------------------------------------------------------------
 2174 /**
 2175  * This function must be called to delete the list of the Pci Scan Information retrieved with
 2176  * le_mrc_PerformPciNetworkScan().
 2177  *
 2178  * @note
 2179  *      On failure, the process exits, so you don't have to worry about checking the returned
 2180  *      reference for validity.
 2181  *
 2182  */
 2183 //--------------------------------------------------------------------------------------------------
 2184 void le_mrc_DeletePciNetworkScan
 2185 (
 2186     le_mrc_PciScanInformationListRef_t scanInformationListRef
 2187         ///< [IN] The list of scan information.
 2188 );
 2189 
 2190 //--------------------------------------------------------------------------------------------------
 2191 /**
 2192  * This function must be called to get the Cellular Network Code [mcc:mnc]
 2193  *
 2194  * @return
 2195  *      - LE_OK on success
 2196  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 2197  *      - LE_FAULT for all other errors
 2198  *
 2199  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2200  *       reference for validity.
 2201  *
 2202  * @note <b>multi-app safe</b>
 2203  */
 2204 //--------------------------------------------------------------------------------------------------
 2205 le_result_t le_mrc_GetCellularNetworkMccMnc
 2206 (
 2207     le_mrc_ScanInformationRef_t scanInformationRef,
 2208         ///< [IN] Scan information reference
 2209     char* mccPtr,
 2210         ///< [OUT] Mobile Country Code
 2211     size_t mccPtrSize,
 2212         ///< [IN]
 2213     char* mncPtr,
 2214         ///< [OUT] Mobile Network Code
 2215     size_t mncPtrSize
 2216         ///< [IN]
 2217 );
 2218 
 2219 //--------------------------------------------------------------------------------------------------
 2220 /**
 2221  * This function must be called to get the Cellular Network Name.
 2222  *
 2223  * @return
 2224  *      - LE_OK on success
 2225  *      - LE_OVERFLOW if the operator name would not fit in buffer
 2226  *      - LE_FAULT for all other errors
 2227  *
 2228  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2229  *       reference for validity.
 2230  *
 2231  * @note <b>multi-app safe</b>
 2232  */
 2233 //--------------------------------------------------------------------------------------------------
 2234 le_result_t le_mrc_GetCellularNetworkName
 2235 (
 2236     le_mrc_ScanInformationRef_t scanInformationRef,
 2237         ///< [IN] Scan information reference
 2238     char* namePtr,
 2239         ///< [OUT] Name of operator
 2240     size_t namePtrSize
 2241         ///< [IN]
 2242 );
 2243 
 2244 //--------------------------------------------------------------------------------------------------
 2245 /**
 2246  * This function must be called to get the radio access technology of a scanInformationRef.
 2247  *
 2248  * @return the radio access technology
 2249  *
 2250  * @note On failure, the process exits.
 2251  *
 2252  * @note <b>multi-app safe</b>
 2253  */
 2254 //--------------------------------------------------------------------------------------------------
 2255 le_mrc_Rat_t le_mrc_GetCellularNetworkRat
 2256 (
 2257     le_mrc_ScanInformationRef_t scanInformationRef
 2258         ///< [IN] Scan information reference
 2259 );
 2260 
 2261 //--------------------------------------------------------------------------------------------------
 2262 /**
 2263  * This function must be called to check if a cellular network is currently in use.
 2264  *
 2265  * @return true     The network is in use
 2266  * @return false    The network isn't in use
 2267  *
 2268  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2269  *       reference for validity.
 2270  *
 2271  * @note <b>multi-app safe</b>
 2272  */
 2273 //--------------------------------------------------------------------------------------------------
 2274 bool le_mrc_IsCellularNetworkInUse
 2275 (
 2276     le_mrc_ScanInformationRef_t scanInformationRef
 2277         ///< [IN] Scan information reference
 2278 );
 2279 
 2280 //--------------------------------------------------------------------------------------------------
 2281 /**
 2282  * This function must be called to check if a cellular network is available.
 2283  *
 2284  * @return true     The network is available
 2285  * @return false    The network isn't available
 2286  *
 2287  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2288  *       reference for validity.
 2289  *
 2290  * @note <b>multi-app safe</b>
 2291  */
 2292 //--------------------------------------------------------------------------------------------------
 2293 bool le_mrc_IsCellularNetworkAvailable
 2294 (
 2295     le_mrc_ScanInformationRef_t scanInformationRef
 2296         ///< [IN] Scan information reference
 2297 );
 2298 
 2299 //--------------------------------------------------------------------------------------------------
 2300 /**
 2301  * This function must be called to check if a cellular network is currently in home mode.
 2302  *
 2303  * @return true     The network is home
 2304  * @return false    The network is roaming
 2305  *
 2306  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2307  *       reference for validity.
 2308  *
 2309  * @note <b>multi-app safe</b>
 2310  */
 2311 //--------------------------------------------------------------------------------------------------
 2312 bool le_mrc_IsCellularNetworkHome
 2313 (
 2314     le_mrc_ScanInformationRef_t scanInformationRef
 2315         ///< [IN] Scan information reference
 2316 );
 2317 
 2318 //--------------------------------------------------------------------------------------------------
 2319 /**
 2320  * This function must be called to check if a cellular network is forbidden by the operator.
 2321  *
 2322  * @return true     The network is forbidden
 2323  * @return false    The network is allowed
 2324  *
 2325  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2326  *       reference for validity.
 2327  *
 2328  * @note <b>multi-app safe</b>
 2329  */
 2330 //--------------------------------------------------------------------------------------------------
 2331 bool le_mrc_IsCellularNetworkForbidden
 2332 (
 2333     le_mrc_ScanInformationRef_t scanInformationRef
 2334         ///< [IN] Scan information reference
 2335 );
 2336 
 2337 //--------------------------------------------------------------------------------------------------
 2338 /**
 2339  * This function must be called to get the current network name information.
 2340  *
 2341  * @return
 2342  *      - LE_OK             on success
 2343  *      - LE_BAD_PARAMETER  if nameStr is NULL
 2344  *      - LE_OVERFLOW       if the Home Network Name can't fit in nameStr
 2345  *      - LE_FAULT          on any other failure
 2346  *
 2347  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2348  *       function won't return.
 2349  *
 2350  * @note <b>multi-app safe</b>
 2351  */
 2352 //--------------------------------------------------------------------------------------------------
 2353 le_result_t le_mrc_GetCurrentNetworkName
 2354 (
 2355     char* nameStr,
 2356         ///< [OUT] the home network Name
 2357     size_t nameStrSize
 2358         ///< [IN]
 2359 );
 2360 
 2361 //--------------------------------------------------------------------------------------------------
 2362 /**
 2363  * This function must be called to get the current network PLMN information.
 2364  *
 2365  * @return
 2366  *      - LE_OK       on success
 2367  *      - LE_FAULT    on any other failure
 2368  *
 2369  * @note <b>multi-app safe</b>
 2370  */
 2371 //--------------------------------------------------------------------------------------------------
 2372 le_result_t le_mrc_GetCurrentNetworkMccMnc
 2373 (
 2374     char* mccStr,
 2375         ///< [OUT] the mobile country code
 2376     size_t mccStrSize,
 2377         ///< [IN]
 2378     char* mncStr,
 2379         ///< [OUT] the mobile network code
 2380     size_t mncStrSize
 2381         ///< [IN]
 2382 );
 2383 
 2384 //--------------------------------------------------------------------------------------------------
 2385 /**
 2386  * This function must be called to get the current Radio Access Technology in use.
 2387  *
 2388  * @return LE_OK            Function succeeded.
 2389  * @return LE_BAD_PARAMETER Invalid parameter.
 2390  * @return LE_FAULT         Function failed to get the Radio Access Technology.
 2391  *
 2392  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2393  *       function won't return.
 2394  *
 2395  * @note The API returns the RAT only if the device is registered on the network.
 2396  *       le_mrc_GetNetRegState() function can be called first to obtain the network registration
 2397  *       state.
 2398  *
 2399  * @note <b>multi-app safe</b>
 2400  */
 2401 //--------------------------------------------------------------------------------------------------
 2402 le_result_t le_mrc_GetRadioAccessTechInUse
 2403 (
 2404     le_mrc_Rat_t* ratPtr
 2405         ///< [OUT] The Radio Access Technology.
 2406 );
 2407 
 2408 //--------------------------------------------------------------------------------------------------
 2409 /**
 2410  * This function must be called to retrieve the Neighboring Cells information. It creates and
 2411  * returns a reference to the Neighboring Cells information.
 2412  *
 2413  * @return A reference to the Neighboring Cells information.
 2414  * @return NULL if no Cells Information are available.
 2415  *
 2416  * @note <b>multi-app safe</b>
 2417  */
 2418 //--------------------------------------------------------------------------------------------------
 2419 le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo
 2420 (
 2421     void
 2422 );
 2423 
 2424 //--------------------------------------------------------------------------------------------------
 2425 /**
 2426  * This function must be called to delete the Neighboring Cells information.
 2427  *
 2428  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2429  *       reference for validity.
 2430  *
 2431  * @note <b>multi-app safe</b>
 2432  */
 2433 //--------------------------------------------------------------------------------------------------
 2434 void le_mrc_DeleteNeighborCellsInfo
 2435 (
 2436     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2437         ///< [IN] Neighboring Cells reference.
 2438 );
 2439 
 2440 //--------------------------------------------------------------------------------------------------
 2441 /**
 2442  * This function must be called to get the first Cell Information reference in the list of
 2443  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 2444  *
 2445  * @return NULL                   No Cell information object found.
 2446  * @return le_mrc_CellInfoRef_t   The Cell information object reference.
 2447  *
 2448  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2449  *       function won't return.
 2450  *
 2451  * @note <b>multi-app safe</b>
 2452  */
 2453 //--------------------------------------------------------------------------------------------------
 2454 le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo
 2455 (
 2456     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2457         ///< [IN] Neighboring Cells reference.
 2458 );
 2459 
 2460 //--------------------------------------------------------------------------------------------------
 2461 /**
 2462  * This function must be called to get the next Cell Information reference in the list of
 2463  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 2464  *
 2465  * @return NULL                   No Cell information object found.
 2466  * @return le_mrc_CellInfoRef_t   Cell information object reference.
 2467  *
 2468  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2469  *       function won't return.
 2470  *
 2471  * @note <b>multi-app safe</b>
 2472  */
 2473 //--------------------------------------------------------------------------------------------------
 2474 le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo
 2475 (
 2476     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2477         ///< [IN] Neighboring Cells reference.
 2478 );
 2479 
 2480 //--------------------------------------------------------------------------------------------------
 2481 /**
 2482  * This function must be called to get the Physical Cell Identifier.
 2483  *
 2484  * @return The Physical Cell Identifier. UINT32_MAX value is returned if the Cell Identifier is not
 2485  * available.
 2486  *
 2487  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2488  *       function won't return.
 2489  *
 2490  * @note <b>multi-app safe</b>
 2491  */
 2492 //--------------------------------------------------------------------------------------------------
 2493 uint32_t le_mrc_GetNeighborCellId
 2494 (
 2495     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2496         ///< [IN] Cell information reference.
 2497 );
 2498 
 2499 //--------------------------------------------------------------------------------------------------
 2500 /**
 2501  * This function must be called to get the Location Area Code of a cell.
 2502  *
 2503  * @return The Location Area Code of a cell. UINT16_MAX value is returned if the value is not
 2504  * available.
 2505  *
 2506  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2507  *       function won't return.
 2508  *
 2509  * @note <b>multi-app safe</b>
 2510  */
 2511 //--------------------------------------------------------------------------------------------------
 2512 uint32_t le_mrc_GetNeighborCellLocAreaCode
 2513 (
 2514     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2515         ///< [IN] Cell information reference.
 2516 );
 2517 
 2518 //--------------------------------------------------------------------------------------------------
 2519 /**
 2520  * This function must be called to get the signal strength of a cell.
 2521  *
 2522  * @return The signal strength of a cell in dBm.
 2523  *
 2524  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2525  *       function won't return.
 2526  *
 2527  * @note <b>multi-app safe</b>
 2528  */
 2529 //--------------------------------------------------------------------------------------------------
 2530 int32_t le_mrc_GetNeighborCellRxLevel
 2531 (
 2532     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2533         ///< [IN] Cell information reference.
 2534 );
 2535 
 2536 //--------------------------------------------------------------------------------------------------
 2537 /**
 2538  * This function must be called to get the Radio Access Technology of a cell.
 2539  *
 2540  * @return The Radio Access Technology of a cell.
 2541  *
 2542  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2543  *       function won't return.
 2544  *
 2545  * @note <b>multi-app safe</b>
 2546  */
 2547 //--------------------------------------------------------------------------------------------------
 2548 le_mrc_Rat_t le_mrc_GetNeighborCellRat
 2549 (
 2550     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2551         ///< [IN] Cell information reference.
 2552 );
 2553 
 2554 //--------------------------------------------------------------------------------------------------
 2555 /**
 2556  * This function must be called to get the Ec/Io; the received energy per chip divided by the power
 2557  * density in the band measured in dBm on the primary CPICH channel of serving cell (negative value)
 2558  *
 2559  * @return
 2560  *  - The Ec/Io of a cell given in dB with 1 decimal place. (only applicable for UMTS network).
 2561  *  - INT32_MAX when the value isn't available.
 2562  *
 2563  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2564  *       function won't return.
 2565  *
 2566  * @note <b>multi-app safe</b>
 2567  */
 2568 //--------------------------------------------------------------------------------------------------
 2569 int32_t le_mrc_GetNeighborCellUmtsEcIo
 2570 (
 2571     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2572         ///< [IN] Cell information reference.
 2573 );
 2574 
 2575 //--------------------------------------------------------------------------------------------------
 2576 /**
 2577  * This function must be called to get the RSRP and RSRQ of the Intrafrequency of a LTE cell.
 2578  *
 2579  * @return
 2580  *      - LE_OK on success
 2581  *      - LE_FAULT on failure
 2582  *
 2583  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2584  *       function won't return.
 2585  *
 2586  * @note <b>multi-app safe</b>
 2587  */
 2588 //--------------------------------------------------------------------------------------------------
 2589 le_result_t le_mrc_GetNeighborCellLteIntraFreq
 2590 (
 2591     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2592         ///< [IN] Cell information reference.
 2593     int32_t* rsrqPtr,
 2594         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2595         ///< place
 2596     int32_t* rsrpPtr
 2597         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2598         ///< place
 2599 );
 2600 
 2601 //--------------------------------------------------------------------------------------------------
 2602 /**
 2603  * This function must be called to get the RSRP and RSRQ of the Interfrequency of a LTE cell.
 2604  *
 2605  * @return
 2606  *      - LE_OK on success
 2607  *      - LE_FAULT on failure
 2608  *
 2609  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2610  *       function won't return.
 2611  *
 2612  * @note <b>multi-app safe</b>
 2613  */
 2614 //--------------------------------------------------------------------------------------------------
 2615 le_result_t le_mrc_GetNeighborCellLteInterFreq
 2616 (
 2617     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2618         ///< [IN] Cell information reference.
 2619     int32_t* rsrqPtr,
 2620         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2621         ///< place
 2622     int32_t* rsrpPtr
 2623         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2624         ///< place
 2625 );
 2626 
 2627 //--------------------------------------------------------------------------------------------------
 2628 /**
 2629  * This function must be called to measure the signal metrics. It creates and returns a reference
 2630  * to the signal metrics.
 2631  *
 2632  * @return A reference to the signal metrics.
 2633  * @return NULL if no signal metrics are available.
 2634  *
 2635  * @note <b>multi-app safe</b>
 2636  */
 2637 //--------------------------------------------------------------------------------------------------
 2638 le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics
 2639 (
 2640     void
 2641 );
 2642 
 2643 //--------------------------------------------------------------------------------------------------
 2644 /**
 2645  * This function must be called to delete the the signal metrics.
 2646  *
 2647  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2648  *       reference for validity.
 2649  *
 2650  * @note <b>multi-app safe</b>
 2651  */
 2652 //--------------------------------------------------------------------------------------------------
 2653 void le_mrc_DeleteSignalMetrics
 2654 (
 2655     le_mrc_MetricsRef_t MetricsRef
 2656         ///< [IN] Signal metrics reference.
 2657 );
 2658 
 2659 //--------------------------------------------------------------------------------------------------
 2660 /**
 2661  * This function returns the Radio Access Technology of the signal metrics.
 2662  *
 2663  * @return The Radio Access Technology of the signal measure.
 2664  *
 2665  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2666  *       function won't return.
 2667  *
 2668  * @note <b>multi-app safe</b>
 2669  */
 2670 //--------------------------------------------------------------------------------------------------
 2671 le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics
 2672 (
 2673     le_mrc_MetricsRef_t MetricsRef
 2674         ///< [IN] Signal metrics reference.
 2675 );
 2676 
 2677 //--------------------------------------------------------------------------------------------------
 2678 /**
 2679  * This function returns the signal strength in dBm and the bit error rate measured on GSM network.
 2680  *
 2681  * @return
 2682  *      - LE_OK on success
 2683  *      - LE_FAULT on failure
 2684  *
 2685  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2686  *       function won't return.
 2687  *
 2688  * @note <b>multi-app safe</b>
 2689  */
 2690 //--------------------------------------------------------------------------------------------------
 2691 le_result_t le_mrc_GetGsmSignalMetrics
 2692 (
 2693     le_mrc_MetricsRef_t MetricsRef,
 2694         ///< [IN] Signal metrics reference.
 2695     int32_t* rssiPtr,
 2696         ///< [OUT] Signal strength in dBm
 2697     uint32_t* berPtr
 2698         ///< [OUT] Bit error rate.
 2699 );
 2700 
 2701 //--------------------------------------------------------------------------------------------------
 2702 /**
 2703  * This function returns the signal metrics measured on UMTS or TD-SCDMA networks.
 2704  *
 2705  * @return
 2706  *      - LE_OK on success
 2707  *      - LE_FAULT on failure
 2708  *
 2709  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2710  *       function won't return.
 2711  *
 2712  * @note <b>multi-app safe</b>
 2713  */
 2714 //--------------------------------------------------------------------------------------------------
 2715 le_result_t le_mrc_GetUmtsSignalMetrics
 2716 (
 2717     le_mrc_MetricsRef_t MetricsRef,
 2718         ///< [IN] Signal metrics reference.
 2719     int32_t* ssPtr,
 2720         ///< [OUT] Signal strength in dBm
 2721     uint32_t* blerPtr,
 2722         ///< [OUT] Block error rate
 2723     int32_t* ecioPtr,
 2724         ///< [OUT] Ec/Io value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2725         ///< value)
 2726     int32_t* rscpPtr,
 2727         ///< [OUT] Measured RSCP in dBm (negative value, value INT32_MAX means
 2728         ///< that RSCP is not available)
 2729     int32_t* sinrPtr
 2730         ///< [OUT] Measured SINR in dB (only applicable for TD-SCDMA network, value
 2731         ///< INT32_MAX means that the SINR is not available)
 2732 );
 2733 
 2734 //--------------------------------------------------------------------------------------------------
 2735 /**
 2736  * This function returns the signal metrics measured on LTE network.
 2737  *
 2738  * @return
 2739  *      - LE_OK on success
 2740  *      - LE_FAULT on failure
 2741  *      - sinrPtr and ioPtr return INT32_MAX when the value isn't available.
 2742  *
 2743  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2744  *       function won't return.
 2745  *
 2746  * @note <b>multi-app safe</b>
 2747  */
 2748 //--------------------------------------------------------------------------------------------------
 2749 le_result_t le_mrc_GetLteSignalMetrics
 2750 (
 2751     le_mrc_MetricsRef_t MetricsRef,
 2752         ///< [IN] Signal metrics reference.
 2753     int32_t* ssPtr,
 2754         ///< [OUT] Signal strength in dBm
 2755     uint32_t* blerPtr,
 2756         ///< [OUT] Block error rate
 2757     int32_t* rsrqPtr,
 2758         ///< [OUT] RSRQ value in dB as measured by L1 with 1 decimal place
 2759     int32_t* rsrpPtr,
 2760         ///< [OUT] Current RSRP in dBm as measured by L1 with 1 decimal place
 2761     int32_t* snrPtr
 2762         ///< [OUT] SNR level in dB with 1 decimal place (15 = 1.5 dB)
 2763 );
 2764 
 2765 //--------------------------------------------------------------------------------------------------
 2766 /**
 2767  * This function returns the signal metrics measured on CDMA network.
 2768  *
 2769  * @return
 2770  *      - LE_OK on success
 2771  *      - LE_FAULT on failure
 2772  *      - rscpPtr and sinrPtr return INT32_MAX when the value isn't available.
 2773  *
 2774  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2775  *       function won't return.
 2776  *
 2777  * @note <b>multi-app safe</b>
 2778  */
 2779 //--------------------------------------------------------------------------------------------------
 2780 le_result_t le_mrc_GetCdmaSignalMetrics
 2781 (
 2782     le_mrc_MetricsRef_t MetricsRef,
 2783         ///< [IN] Signal metrics reference.
 2784     int32_t* ssPtr,
 2785         ///< [OUT] Signal strength in dBm
 2786     uint32_t* erPtr,
 2787         ///< [OUT] Frame/Packet error rate
 2788     int32_t* ecioPtr,
 2789         ///< [OUT] ECIO value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2790         ///< value)
 2791     int32_t* sinrPtr,
 2792         ///< [OUT] SINR level in dB with 1 decimal place, (only applicable for
 2793         ///< 1xEV-DO, value INT32_MAX means that the value is not available)
 2794     int32_t* ioPtr
 2795         ///< [OUT] Received IO in dBm (only applicable for 1xEV-DO, value INT32_MAX
 2796         ///< means that the value is not available)
 2797 );
 2798 
 2799 //--------------------------------------------------------------------------------------------------
 2800 /**
 2801  * This function must be called to get the serving Cell Identifier.
 2802  *
 2803  * @return The Cell Identifier. UINT32_MAX value is returned if the value is not available.
 2804  *
 2805  * @note When the module is in UMTS network, the API returns the serving UTRAN Cell Identity (UC-Id)
 2806  * which is used to identify the cell uniquely.
 2807  * It is composed of the Controlling Radio Network Controller Identifier (CRNC-Id, 12 bits) and the
 2808  * Cell Identifier (C-Id, 16 bits). (3GPP 25.401, section 6.1.5)
 2809  * The Cell Identifier is coded in the lower 2 bytes of the 4 bytes UC-Id and the CRNC-Id is coded
 2810  * in the upper 2 bytes.
 2811  * Example: the API returns 7807609 -> 0x772279 (CRNC-Id = 0x77 , cell ID = 0x2279)
 2812  *
 2813  * @note <b>multi-app safe</b>
 2814  */
 2815 //--------------------------------------------------------------------------------------------------
 2816 uint32_t le_mrc_GetServingCellId
 2817 (
 2818     void
 2819 );
 2820 
 2821 //--------------------------------------------------------------------------------------------------
 2822 /**
 2823  * This function must be called to get the Location Area Code of the serving cell.
 2824  *
 2825  * @return The Location Area Code. UINT32_MAX value is returned if the value is not available.
 2826  *
 2827  * @note <b>multi-app safe</b>
 2828  */
 2829 //--------------------------------------------------------------------------------------------------
 2830 uint32_t le_mrc_GetServingCellLocAreaCode
 2831 (
 2832     void
 2833 );
 2834 
 2835 //--------------------------------------------------------------------------------------------------
 2836 /**
 2837  * This function must be called to get the Tracking Area Code of the serving cell (LTE only).
 2838  *
 2839  * @return The Tracking Area Code. UINT16_MAX value is returned if the value is not available.
 2840  *
 2841  * @note <b>multi-app safe</b>
 2842  */
 2843 //--------------------------------------------------------------------------------------------------
 2844 uint16_t le_mrc_GetServingCellLteTracAreaCode
 2845 (
 2846     void
 2847 );
 2848 
 2849 //--------------------------------------------------------------------------------------------------
 2850 /**
 2851  * Get the Bit mask for 2G/3G Band capabilities.
 2852  *
 2853  * @return
 2854  *  - LE_OK              on success
 2855  *  - LE_FAULT           on failure
 2856  *  - LE_UNSUPPORTED     Unable to get the 2G/3G Band capabilities on this platform
 2857  *
 2858  * @note <b>multi-app safe</b>
 2859  */
 2860 //--------------------------------------------------------------------------------------------------
 2861 le_result_t le_mrc_GetBandCapabilities
 2862 (
 2863     le_mrc_BandBitMask_t* bandMaskPtrPtr
 2864         ///< [OUT] Bit mask for 2G/3G Band capabilities.
 2865 );
 2866 
 2867 //--------------------------------------------------------------------------------------------------
 2868 /**
 2869  * Get the Bit mask for LTE Band capabilities.
 2870  *
 2871  * @return
 2872  *  - LE_OK              on success
 2873  *  - LE_FAULT           on failure
 2874  *  - LE_UNSUPPORTED     Unable to get the LTE Band capabilities on this platform
 2875  *
 2876  * @note <b>multi-app safe</b>
 2877  */
 2878 //--------------------------------------------------------------------------------------------------
 2879 le_result_t le_mrc_GetLteBandCapabilities
 2880 (
 2881     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 2882         ///< [OUT] Bit mask for LTE Band capabilities.
 2883 );
 2884 
 2885 //--------------------------------------------------------------------------------------------------
 2886 /**
 2887  * Get the Bit mask for TD-SCDMA Band capabilities.
 2888  *
 2889  * @return
 2890  *  - LE_OK              on success
 2891  *  - LE_FAULT           on failure
 2892  *  - LE_UNSUPPORTED     Unable to get the TD-SCDMA Band Capabilities on this platform
 2893  *
 2894  * @note <b>multi-app safe</b>
 2895  */
 2896 //--------------------------------------------------------------------------------------------------
 2897 le_result_t le_mrc_GetTdScdmaBandCapabilities
 2898 (
 2899     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 2900         ///< [OUT] Bit mask for TD-SCDMA Band capabilities.
 2901 );
 2902 
 2903 //--------------------------------------------------------------------------------------------------
 2904 /**
 2905  * Add handler function for EVENT 'le_mrc_NetworkReject'
 2906  *
 2907  * Event to report network reject indication.
 2908  *
 2909  */
 2910 //--------------------------------------------------------------------------------------------------
 2911 le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler
 2912 (
 2913     le_mrc_NetworkRejectHandlerFunc_t handlerPtr,
 2914         ///< [IN]
 2915     void* contextPtr
 2916         ///< [IN]
 2917 );
 2918 
 2919 //--------------------------------------------------------------------------------------------------
 2920 /**
 2921  * Remove handler function for EVENT 'le_mrc_NetworkReject'
 2922  */
 2923 //--------------------------------------------------------------------------------------------------
 2924 void le_mrc_RemoveNetworkRejectHandler
 2925 (
 2926     le_mrc_NetworkRejectHandlerRef_t handlerRef
 2927         ///< [IN]
 2928 );
 2929 
 2930 //--------------------------------------------------------------------------------------------------
 2931 /**
 2932  * Add handler function for EVENT 'le_mrc_NetRegReject'
 2933  *
 2934  * Event to report network registration reject indication.
 2935  * NetworkReject will be deprecated.
 2936  */
 2937 //--------------------------------------------------------------------------------------------------
 2938 le_mrc_NetRegRejectHandlerRef_t le_mrc_AddNetRegRejectHandler
 2939 (
 2940     le_mrc_NetRegRejectHandlerFunc_t handlerPtr,
 2941         ///< [IN]
 2942     void* contextPtr
 2943         ///< [IN]
 2944 );
 2945 
 2946 //--------------------------------------------------------------------------------------------------
 2947 /**
 2948  * Remove handler function for EVENT 'le_mrc_NetRegReject'
 2949  */
 2950 //--------------------------------------------------------------------------------------------------
 2951 void le_mrc_RemoveNetRegRejectHandler
 2952 (
 2953     le_mrc_NetRegRejectHandlerRef_t handlerRef
 2954         ///< [IN]
 2955 );
 2956 
 2957 //--------------------------------------------------------------------------------------------------
 2958 /**
 2959  * Add handler function for EVENT 'le_mrc_JammingDetectionEvent'
 2960  *
 2961  * This event provides information on jamming detection.
 2962  */
 2963 //--------------------------------------------------------------------------------------------------
 2964 le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler
 2965 (
 2966     le_mrc_JammingDetectionHandlerFunc_t handlerPtr,
 2967         ///< [IN]
 2968     void* contextPtr
 2969         ///< [IN]
 2970 );
 2971 
 2972 //--------------------------------------------------------------------------------------------------
 2973 /**
 2974  * Remove handler function for EVENT 'le_mrc_JammingDetectionEvent'
 2975  */
 2976 //--------------------------------------------------------------------------------------------------
 2977 void le_mrc_RemoveJammingDetectionEventHandler
 2978 (
 2979     le_mrc_JammingDetectionEventHandlerRef_t handlerRef
 2980         ///< [IN]
 2981 );
 2982 
 2983 //--------------------------------------------------------------------------------------------------
 2984 /**
 2985  * Start the jamming detection monitoring.
 2986  *
 2987  * @warning The jamming detection feature might be limited by the platform.
 2988  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 2989  *
 2990  * @return
 2991  *  - LE_OK             The function succeeded.
 2992  *  - LE_FAULT          The function failed.
 2993  *  - LE_DUPLICATE      The feature is already activated and an activation is requested.
 2994  *  - LE_UNSUPPORTED    The feature is not supported.
 2995  */
 2996 //--------------------------------------------------------------------------------------------------
 2997 le_result_t le_mrc_StartJammingDetection
 2998 (
 2999     void
 3000 );
 3001 
 3002 //--------------------------------------------------------------------------------------------------
 3003 /**
 3004  * Stop the jamming detection monitoring.
 3005  *
 3006  * @return
 3007  *  - LE_OK             The function succeeded.
 3008  *  - LE_FAULT          The function failed or the application did not start the jamming detection.
 3009  *  - LE_UNSUPPORTED    The feature is not supported.
 3010  */
 3011 //--------------------------------------------------------------------------------------------------
 3012 le_result_t le_mrc_StopJammingDetection
 3013 (
 3014     void
 3015 );
 3016 
 3017 //--------------------------------------------------------------------------------------------------
 3018 /**
 3019  * Set the SAR backoff state
 3020  *
 3021  * @warning The SAR backoff feature might be unsupported by some platforms.
 3022  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 3023  *
 3024  * @return
 3025  *  - LE_OK             The function succeeded.
 3026  *  - LE_FAULT          The function failed.
 3027  *  - LE_UNSUPPORTED    The feature is not supported.
 3028  *  - LE_OUT_OF_RANGE   The provided index is out of range.
 3029  */
 3030 //--------------------------------------------------------------------------------------------------
 3031 le_result_t le_mrc_SetSarBackoffState
 3032 (
 3033     uint8_t state
 3034         ///< [IN] New state to enable. By default, SAR is disabled (state = 0).
 3035         ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
 3036 );
 3037 
 3038 //--------------------------------------------------------------------------------------------------
 3039 /**
 3040  * Get the SAR backoff state
 3041  *
 3042  * @warning The SAR backoff feature might be unsupported by some platforms.
 3043  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 3044  *
 3045  * @return
 3046  *  - LE_OK             The function succeeded.
 3047  *  - LE_FAULT          The function failed.
 3048  *  - LE_UNSUPPORTED    The feature is not supported.
 3049  */
 3050 //--------------------------------------------------------------------------------------------------
 3051 le_result_t le_mrc_GetSarBackoffState
 3052 (
 3053     uint8_t* statePtr
 3054         ///< [OUT] Current state. By default, SAR is disabled (state = 0).
 3055         ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
 3056 );
 3057 
 3058 #endif // LE_MRC_INTERFACE_H_INCLUDE_GUARD
le_mrc_GetLteBandCapabilities
le_result_t le_mrc_GetLteBandCapabilities(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_mrc_GetNeighborCellId
uint32_t le_mrc_GetNeighborCellId(le_mrc_CellInfoRef_t ngbrCellInfoRef)
LE_MRC_IMEI_NOT_ACCEPTED
IMEI not accepted. 
Definition: le_mrc_interface.h:937
le_mrc_GetPreferredOperatorDetails
le_result_t le_mrc_GetPreferredOperatorDetails(le_mrc_PreferredOperatorRef_t preferredOperatorRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize, le_mrc_RatBitMask_t *ratMaskPtr)
LE_MRC_RAT_TDSCDMA
TD-SCDMA networks. 
Definition: le_mrc_interface.h:848
LE_MRC_BITMASK_RAT_LTE
LTE RAT Bit Mask. 
Definition: le_mrc_interface.h:918
le_mrc_PciScanInformationListRef_t
struct le_mrc_PciScanInformationList * le_mrc_PciScanInformationListRef_t
Definition: le_mrc_interface.h:753
LE_MRC_SEMANTICAL_INCORRECT
Semantically incorrect message. 
Definition: le_mrc_interface.h:979
le_mrc_GetGsmSignalMetrics
le_result_t le_mrc_GetGsmSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *rssiPtr, uint32_t *berPtr)
LE_MRC_BITMASK_RAT_CDMA
CDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:919
le_mrc_GetSignalQual
le_result_t le_mrc_GetSignalQual(uint32_t *qualityPtr)
LE_MRC_PLMN_NOT_ALLOWED
PLMN not allowed. 
Definition: le_mrc_interface.h:949
le_mrc_GetServingCellLteTracAreaCode
uint16_t le_mrc_GetServingCellLteTracAreaCode(void)
le_mrc_DeleteNeighborCellsInfo
void le_mrc_DeleteNeighborCellsInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_GetNextNeighborCellInfo
le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_RemovePacketSwitchedChangeHandler
void le_mrc_RemovePacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef)
le_mrc_GetNetRegState
le_result_t le_mrc_GetNetRegState(le_mrc_NetRegState_t *statePtr)
le_mrc_AddRatChangeHandler
le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler(le_mrc_RatChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_SetAutomaticRegisterMode
le_result_t le_mrc_SetAutomaticRegisterMode(void)
le_mrc_PreferredOperatorListRef_t
struct le_mrc_PreferredOperatorList * le_mrc_PreferredOperatorListRef_t
Definition: le_mrc_interface.h:785
le_mrc_SetSignalStrengthIndThresholds
le_result_t le_mrc_SetSignalStrengthIndThresholds(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold)
le_mrc_PreferredOperatorRef_t
struct le_mrc_PreferredOperator * le_mrc_PreferredOperatorRef_t
Definition: le_mrc_interface.h:777
LE_MRC_WRONG_IE
Information element non-existent or not implemented. 
Definition: le_mrc_interface.h:987
le_mrc_RemovePreferredOperator
le_result_t le_mrc_RemovePreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
le_mrc_AddSignalStrengthChangeHandler
le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold, le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr, void *contextPtr)
LE_MRC_LOCATION_NOT_ALLOWED
Location Area not allowed. 
Definition: le_mrc_interface.h:951
le_mrc_GetRadioPower
le_result_t le_mrc_GetRadioPower(le_onoff_t *powerPtr)
le_mrc_GetServingCellId
uint32_t le_mrc_GetServingCellId(void)
le_mrc_AddNetRegStateEventHandler
le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler(le_mrc_NetRegStateHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_DisconnectHandler_t
void(* le_mrc_DisconnectHandler_t)(void *)
Definition: le_mrc_interface.h:504
LE_MRC_RETRY_NEW_CELL
Retry upon entry into a new cell. 
Definition: le_mrc_interface.h:977
le_result_t
le_result_t
Definition: le_basics.h:35
LE_MRC_ILLEGAL_MS
Illegal MS. 
Definition: le_mrc_interface.h:935
le_mrc_SetRadioPower
le_result_t le_mrc_SetRadioPower(le_onoff_t power)
le_mrc_GetFirstPlmnInfo
le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo(le_mrc_PciScanInformationRef_t pciScanInformationRef)
LE_MRC_NO_SUITABLE_CELL
No Suitable Cells In Location Area. 
Definition: le_mrc_interface.h:957
le_mrc_GetCurrentNetworkMccMnc
le_result_t le_mrc_GetCurrentNetworkMccMnc(char *mccStr, size_t mccStrSize, char *mncStr, size_t mncStrSize)
le_mrc_NetRegDomain_t
le_mrc_NetRegDomain_t
Definition: le_mrc_interface.h:1004
le_mrc_NeighborCellsRef_t
struct le_mrc_NeighborCells * le_mrc_NeighborCellsRef_t
Definition: le_mrc_interface.h:801
le_mrc_SetTdScdmaBandPreferences
le_result_t le_mrc_SetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t bandMask)
le_mrc_MetricsRef_t
struct le_mrc_Metrics * le_mrc_MetricsRef_t
Definition: le_mrc_interface.h:809
le_mrc_GetPacketSwitchedState
le_result_t le_mrc_GetPacketSwitchedState(le_mrc_NetRegState_t *statePtr)
LE_MRC_MSC_NOT_REACHABLE
MSC temporarily not reachable. 
Definition: le_mrc_interface.h:959
LE_MRC_RAT_UMTS
UMTS networks. 
Definition: le_mrc_interface.h:846
LE_MRC_BITMASK_RAT_TDSCDMA
TD-SCDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:917
le_mrc_GetRatOfSignalMetrics
le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_NetRegStateEventHandlerRef_t
struct le_mrc_NetRegStateEventHandler * le_mrc_NetRegStateEventHandlerRef_t
Definition: le_mrc_interface.h:1041
LE_MRC_GPRS_NOT_ALLOWED_PLMN
GPRS services not allowed in this PLMN. 
Definition: le_mrc_interface.h:955
le_mrc_GetTdScdmaBandPreferences
le_result_t le_mrc_GetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_mrc_DeleteSignalMetrics
void le_mrc_DeleteSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_RatChangeHandlerRef_t
struct le_mrc_RatChangeHandler * le_mrc_RatChangeHandlerRef_t
Definition: le_mrc_interface.h:1049
le_mrc_GetFirstNeighborCellInfo
le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
LE_MRC_REG_ROAMING
Registered to a roaming network. 
Definition: le_mrc_interface.h:827
le_mrc_GetCdmaSignalMetrics
le_result_t le_mrc_GetCdmaSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *erPtr, int32_t *ecioPtr, int32_t *sinrPtr, int32_t *ioPtr)
LE_MRC_CS
Circuit-switched only. 
Definition: le_mrc_interface.h:1008
le_mrc_SetManualRegisterMode
le_result_t le_mrc_SetManualRegisterMode(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
le_mrc_GetNeighborCellLteIntraFreq
le_result_t le_mrc_GetNeighborCellLteIntraFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
le_mrc_GetNextPlmnInfo
le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo(le_mrc_PciScanInformationRef_t plmnRef)
LE_MRC_JAMMING_STATUS_NULL
No jamming suspicion; radio environment is considered normal. 
Definition: le_mrc_interface.h:889
le_mrc_ScanInformationListRef_t
struct le_mrc_ScanInformationList * le_mrc_ScanInformationListRef_t
Definition: le_mrc_interface.h:745
le_mrc_TryConnectService
le_result_t le_mrc_TryConnectService(void)
le_mrc_AddNetRegRejectHandler
le_mrc_NetRegRejectHandlerRef_t le_mrc_AddNetRegRejectHandler(le_mrc_NetRegRejectHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_PciNetworkScanHandlerFunc_t
void(* le_mrc_PciNetworkScanHandlerFunc_t)(le_mrc_PciScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_interface.h:1171
LE_MRC_IMSI_UNKNOWN
IMSI unknown in HLR. 
Definition: le_mrc_interface.h:933
le_mrc_SetSignalStrengthIndDelta
le_result_t le_mrc_SetSignalStrengthIndDelta(le_mrc_Rat_t rat, uint16_t delta)
le_mrc_NetRegRejectHandlerFunc_t
void(* le_mrc_NetRegRejectHandlerFunc_t)(const le_mrc_NetRegRejectInd_t *LE_NONNULL networkRejectIndPtr, void *contextPtr)
Definition: le_mrc_interface.h:1221
LE_MRC_RAT_LTE
LTE network. 
Definition: le_mrc_interface.h:850
LE_MRC_GSM_AUTH_FAILURE
GSM authentication unacceptable. 
Definition: le_mrc_interface.h:969
LE_MRC_LIMITED_SERVICE
No network register after scan. 
Definition: le_mrc_interface.h:1014
le_mrc_GetRatPreferences
le_result_t le_mrc_GetRatPreferences(le_mrc_RatBitMask_t *ratMaskPtrPtr)
le_mrc_NetRegRejectInd_t
Definition: le_mrc_interface.h:1025
le_mrc_CellInfoRef_t
struct le_mrc_CellInfo * le_mrc_CellInfoRef_t
Definition: le_mrc_interface.h:793
le_mrc_PerformCellularNetworkScan
le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan(le_mrc_RatBitMask_t ratMask)
le_mrc_SetBandPreferences
le_result_t le_mrc_SetBandPreferences(le_mrc_BandBitMask_t bandMask)
le_mrc_SetRatPreferences
le_result_t le_mrc_SetRatPreferences(le_mrc_RatBitMask_t ratMask)
LE_MRC_INVALID_INFORMATION
Invalid mandatory information. 
Definition: le_mrc_interface.h:981
LE_MRC_CONGESTION
Congestion. 
Definition: le_mrc_interface.h:967
le_mrc_DeleteCellularNetworkScan
void le_mrc_DeleteCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
le_mrc_GetNeighborCellRxLevel
int32_t le_mrc_GetNeighborCellRxLevel(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_AddPacketSwitchedChangeHandler
le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr, void *contextPtr)
le_mrc_GetNeighborCellLteInterFreq
le_result_t le_mrc_GetNeighborCellLteInterFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
le_mrc_RemoveSignalStrengthChangeHandler
void le_mrc_RemoveSignalStrengthChangeHandler(le_mrc_SignalStrengthChangeHandlerRef_t handlerRef)
le_mrc_SetSarBackoffState
le_result_t le_mrc_SetSarBackoffState(uint8_t state)
le_mrc_SignalStrengthChangeHandlerRef_t
struct le_mrc_SignalStrengthChangeHandler * le_mrc_SignalStrengthChangeHandlerRef_t
Definition: le_mrc_interface.h:1065
le_mrc_GetNeighborCellsInfo
le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo(void)
le_mrc_GetPciScanMccMnc
le_result_t le_mrc_GetPciScanMccMnc(le_mrc_PlmnInformationRef_t plmnRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
le_mrc_GetCellularNetworkRat
le_mrc_Rat_t le_mrc_GetCellularNetworkRat(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_GetPciScanGlobalCellId
uint32_t le_mrc_GetPciScanGlobalCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
le_mrc_RemoveRatChangeHandler
void le_mrc_RemoveRatChangeHandler(le_mrc_RatChangeHandlerRef_t handlerRef)
LE_MRC_MESSAGE_NOT_COMPATIBLE
Message not compatible with the protocol state. 
Definition: le_mrc_interface.h:991
le_mrc_NetworkRejectHandlerRef_t
struct le_mrc_NetworkRejectHandler * le_mrc_NetworkRejectHandlerRef_t
Definition: le_mrc_interface.h:1073
le_mrc_RemoveNetRegRejectHandler
void le_mrc_RemoveNetRegRejectHandler(le_mrc_NetRegRejectHandlerRef_t handlerRef)
le_mrc_PlmnInformationRef_t
struct le_mrc_PlmnInformation * le_mrc_PlmnInformationRef_t
Definition: le_mrc_interface.h:769
LE_MRC_REG_HOME
Registered, home network. 
Definition: le_mrc_interface.h:821
LE_MRC_JAMMING_STATUS_HIGH
Definition: le_mrc_interface.h:897
LE_MRC_No_PDP_ACTIVATED
No PDP context activated. 
Definition: le_mrc_interface.h:975
le_mrc_GetSarBackoffState
le_result_t le_mrc_GetSarBackoffState(uint8_t *statePtr)
LE_MRC_PS
Packet-switched only. 
Definition: le_mrc_interface.h:1010
le_mrc_GetServingCellLocAreaCode
uint32_t le_mrc_GetServingCellLocAreaCode(void)
le_mrc_GetFirstPreferredOperator
le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_GetFirstPciScanInfo
le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
le_mrc_PerformCellularNetworkScanAsync
void le_mrc_PerformCellularNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetLteSignalMetrics
le_result_t le_mrc_GetLteSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *rsrqPtr, int32_t *rsrpPtr, int32_t *snrPtr)
le_mrc_NetRegRejectHandlerRef_t
struct le_mrc_NetRegRejectHandler * le_mrc_NetRegRejectHandlerRef_t
Definition: le_mrc_interface.h:1081
LE_MRC_RAT_GSM
GSM network. 
Definition: le_mrc_interface.h:844
LE_MRC_GPRS_NON_GPRS_NOT_ALLOWED
GPRS services and non-GPRS services not allowed. 
Definition: le_mrc_interface.h:943
le_mrc_RemoveNetworkRejectHandler
void le_mrc_RemoveNetworkRejectHandler(le_mrc_NetworkRejectHandlerRef_t handlerRef)
le_mrc_RatChangeHandlerFunc_t
void(* le_mrc_RatChangeHandlerFunc_t)(le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:1112
le_mrc_GetNextPciScanInfo
le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
LE_MRC_BITMASK_RAT_ALL
To Set all RAT preference Bit Mask. 
Definition: le_mrc_interface.h:920
le_mrc_RatBitMask_t
le_mrc_RatBitMask_t
Definition: le_mrc_interface.h:913
le_mrc_GetPlatformSpecificRegistrationErrorCode
int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode(void)
LE_MRC_JAMMING_REPORT_FINAL
Final jamming status report. 
Definition: le_mrc_interface.h:870
le_mrc_GetNextPreferredOperator
le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
LE_MRC_RAT_CDMA
CDMA network. 
Definition: le_mrc_interface.h:852
le_mrc_SetManualRegisterModeAsync
void le_mrc_SetManualRegisterModeAsync(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_ManualSelectionHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_Rat_t
le_mrc_Rat_t
Definition: le_mrc_interface.h:840
le_mrc_GetTdScdmaBandCapabilities
le_result_t le_mrc_GetTdScdmaBandCapabilities(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_mrc_NetworkRejectHandlerFunc_t
void(* le_mrc_NetworkRejectHandlerFunc_t)(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:1203
le_mrc_GetRegisterMode
le_result_t le_mrc_GetRegisterMode(bool *isManualPtrPtr, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
LE_MRC_JAMMING_STATUS_LOW
Definition: le_mrc_interface.h:891
le_mrc_JammingReport_t
le_mrc_JammingReport_t
Definition: le_mrc_interface.h:868
LE_MRC_RAT_UNKNOWN
Unknown. 
Definition: le_mrc_interface.h:842
LE_MRC_ILLEGAL_ME
Illegal ME. 
Definition: le_mrc_interface.h:939
LE_MRC_MS_IDENTITY_UNKNOWN
Network cannot derive the MS’s identity. 
Definition: le_mrc_interface.h:945
le_mrc_SetLteBandPreferences
le_result_t le_mrc_SetLteBandPreferences(le_mrc_LteBandBitMask_t bandMask)
le_mrc_IsCellularNetworkForbidden
bool le_mrc_IsCellularNetworkForbidden(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_ScanInformationRef_t
struct le_mrc_ScanInformation * le_mrc_ScanInformationRef_t
Definition: le_mrc_interface.h:737
LE_MRC_CS_PS
Circuit-switched and packet-switched. 
Definition: le_mrc_interface.h:1012
le_mrc_GetNeighborCellUmtsEcIo
int32_t le_mrc_GetNeighborCellUmtsEcIo(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_GetCellularNetworkMccMnc
le_result_t le_mrc_GetCellularNetworkMccMnc(le_mrc_ScanInformationRef_t scanInformationRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
LE_MRC_PROTOCOL_ERROR
Protocol error, unspecified. 
Definition: le_mrc_interface.h:993
le_mrc_GetNextCellularNetworkScan
le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
le_mrc_JammingDetectionHandlerFunc_t
void(* le_mrc_JammingDetectionHandlerFunc_t)(le_mrc_JammingReport_t report, le_mrc_JammingStatus_t status, void *contextPtr)
Definition: le_mrc_interface.h:1234
LE_MRC_NO_SERVICE
Scan is ongoing, the module cannot see any networks. 
Definition: le_mrc_interface.h:1006
LE_MRC_JAMMING_STATUS_MEDIUM
Definition: le_mrc_interface.h:894
LE_MRC_MESSAGE_TYPE_WRONG
Message type non-existent or not implemented. 
Definition: le_mrc_interface.h:983
le_mrc_SetServerDisconnectHandler
void le_mrc_SetServerDisconnectHandler(le_mrc_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_mrc_GetCurrentNetworkName
le_result_t le_mrc_GetCurrentNetworkName(char *nameStr, size_t nameStrSize)
LE_MRC_JAMMING_REPORT_INTERMEDIATE
Intermediate jamming status report. 
Definition: le_mrc_interface.h:872
le_mrc_GetRadioAccessTechInUse
le_result_t le_mrc_GetRadioAccessTechInUse(le_mrc_Rat_t *ratPtr)
LE_MRC_GPRS_NOT_ALLOWED
GPRS services not allowed. 
Definition: le_mrc_interface.h:941
le_mrc_GetPreferredOperatorsList
le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList(void)
le_mrc_GetLteBandPreferences
le_result_t le_mrc_GetLteBandPreferences(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_mrc_AddPreferredOperator
le_result_t le_mrc_AddPreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_RatBitMask_t ratMask)
le_mrc_GetBandCapabilities
le_result_t le_mrc_GetBandCapabilities(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_mrc_IsCellularNetworkHome
bool le_mrc_IsCellularNetworkHome(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_PerformPciNetworkScan
le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan(le_mrc_RatBitMask_t ratMask)
le_mrc_GetCellularNetworkName
le_result_t le_mrc_GetCellularNetworkName(le_mrc_ScanInformationRef_t scanInformationRef, char *namePtr, size_t namePtrSize)
le_mrc_JammingStatus_t
le_mrc_JammingStatus_t
Definition: le_mrc_interface.h:885
le_mrc_ConnectService
void le_mrc_ConnectService(void)
le_mrc_DeletePreferredOperatorsList
void le_mrc_DeletePreferredOperatorsList(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_AddJammingDetectionEventHandler
le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler(le_mrc_JammingDetectionHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_StartJammingDetection
le_result_t le_mrc_StartJammingDetection(void)
legato.h
le_mrc_NetRegStateHandlerFunc_t
void(* le_mrc_NetRegStateHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:1098
LE_MRC_REG_SEARCHING
Not registered but currently searching for a new operator. 
Definition: le_mrc_interface.h:823
le_mrc_StopJammingDetection
le_result_t le_mrc_StopJammingDetection(void)
le_mrc_BandBitMask_t
le_mrc_BandBitMask_t
Definition: le_mrc_interface.h:624
LE_MRC_SYNCH_FAILURE
Synch failure. 
Definition: le_mrc_interface.h:965
le_mrc_GetUmtsSignalMetrics
le_result_t le_mrc_GetUmtsSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *ecioPtr, int32_t *rscpPtr, int32_t *sinrPtr)
le_mrc_DisconnectService
void le_mrc_DisconnectService(void)
le_mrc_IsCellularNetworkInUse
bool le_mrc_IsCellularNetworkInUse(le_mrc_ScanInformationRef_t scanInformationRef)
LE_MRC_SMS_VIA_GPRS
SMS provided via GPRS in this routing area. 
Definition: le_mrc_interface.h:973
le_mrc_PerformPciNetworkScanAsync
void le_mrc_PerformPciNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_PciNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_ManualSelectionHandlerFunc_t
void(* le_mrc_ManualSelectionHandlerFunc_t)(le_result_t result, void *contextPtr)
Definition: le_mrc_interface.h:1186
LE_MRC_NETWORK_FAILURE
Network failure. 
Definition: le_mrc_interface.h:961
le_mrc_NetRegState_t
le_mrc_NetRegState_t
Definition: le_mrc_interface.h:817
le_mrc_GetNeighborCellLocAreaCode
uint32_t le_mrc_GetNeighborCellLocAreaCode(le_mrc_CellInfoRef_t ngbrCellInfoRef)
LE_MRC_IE_ERROR
Conditional IE error. 
Definition: le_mrc_interface.h:989
le_mrc_MeasureSignalMetrics
le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics(void)
le_mrc_LteBandBitMask_t
le_mrc_LteBandBitMask_t
Definition: le_mrc_interface.h:674
LE_MRC_REG_UNKNOWN
Unknown state. 
Definition: le_mrc_interface.h:829
le_mrc_IsCellularNetworkAvailable
bool le_mrc_IsCellularNetworkAvailable(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_JammingDetectionEventHandlerRef_t
struct le_mrc_JammingDetectionEventHandler * le_mrc_JammingDetectionEventHandlerRef_t
Definition: le_mrc_interface.h:1089
LE_MRC_REG_DENIED
Registration was denied, usually because of invalid access credentials. 
Definition: le_mrc_interface.h:825
LE_MRC_BITMASK_RAT_UMTS
UMTS RAT Bit Mask. 
Definition: le_mrc_interface.h:916
le_mrc_DeletePciNetworkScan
void le_mrc_DeletePciNetworkScan(le_mrc_PciScanInformationListRef_t scanInformationListRef)
le_mrc_GetPciScanCellId
uint16_t le_mrc_GetPciScanCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
le_mrc_SignalStrengthChangeHandlerFunc_t
void(* le_mrc_SignalStrengthChangeHandlerFunc_t)(int32_t ss, void *contextPtr)
Definition: le_mrc_interface.h:1140
le_mrc_TdScdmaBandBitMask_t
le_mrc_TdScdmaBandBitMask_t
Definition: le_mrc_interface.h:720
LE_MRC_REG_NONE
Not registered and not currently searching for new operator. 
Definition: le_mrc_interface.h:819
le_mrc_RemoveJammingDetectionEventHandler
void le_mrc_RemoveJammingDetectionEventHandler(le_mrc_JammingDetectionEventHandlerRef_t handlerRef)
LE_MRC_NETWORK_IMPLICIT_DETACH
Implicitly detached. 
Definition: le_mrc_interface.h:947
le_mrc_NetRejCause_t
le_mrc_NetRejCause_t
Definition: le_mrc_interface.h:931
LE_MRC_CSG_NOT_AUTHORIZED
Not authorized for this CSG. 
Definition: le_mrc_interface.h:971
LE_MRC_BITMASK_RAT_GSM
GSM RAT Bit Mask. 
Definition: le_mrc_interface.h:915
le_mrc_AddNetworkRejectHandler
le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler(le_mrc_NetworkRejectHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetBandPreferences
le_result_t le_mrc_GetBandPreferences(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_mrc_PacketSwitchedChangeHandlerRef_t
struct le_mrc_PacketSwitchedChangeHandler * le_mrc_PacketSwitchedChangeHandlerRef_t
Definition: le_mrc_interface.h:1057
le_mrc_CellularNetworkScanHandlerFunc_t
void(* le_mrc_CellularNetworkScanHandlerFunc_t)(le_mrc_ScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_interface.h:1155
le_mrc_PacketSwitchedChangeHandlerFunc_t
void(* le_mrc_PacketSwitchedChangeHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:1126
le_mrc_RemoveNetRegStateEventHandler
void le_mrc_RemoveNetRegStateEventHandler(le_mrc_NetRegStateEventHandlerRef_t handlerRef)
LE_MRC_ROAMING_NOT_ALLOWED
Roaming not allowed in this location area. 
Definition: le_mrc_interface.h:953
le_mrc_GetFirstCellularNetworkScan
le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
LE_MRC_JAMMING_STATUS_UNKNOWN
Status is unknown. 
Definition: le_mrc_interface.h:887
le_mrc_PciScanInformationRef_t
struct le_mrc_PciScanInformation * le_mrc_PciScanInformationRef_t
Definition: le_mrc_interface.h:761
le_mrc_GetNeighborCellRat
le_mrc_Rat_t le_mrc_GetNeighborCellRat(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_onoff_t
le_onoff_t
Definition: le_basics.h:70
LE_MRC_JAMMING_STATUS_JAMMED
Definition: le_mrc_interface.h:901
LE_MRC_MESSAGE_TYPE_NOT_COMPATIBLE
Message type not compatible with the protocol state. 
Definition: le_mrc_interface.h:985
LE_MRC_MAC_FAILURE
MAC failure. 
Definition: le_mrc_interface.h:963