le_mrc_interface.h

Go to the documentation of this file.
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 Tracking Area Code of the serving cell
273  * (LTE only).
274  *
275  * le_mrc_GetServingCellEarfcn() retrieves the serving cell E-UTRA Absolute Radio Frequency
276  * Channel Number (EARFCN, defined in 3GPP TS 36.101). The EARFCN is in the range from 0 to 262143.
277  *
278  * le_mrc_GetServingCellTimingAdvance() retrieves the serving cell timing advance index value.
279  * UINT32_MAX value is returned if the value is not available. The index value returned is defined
280  * by 3GPP 36.213. The index value is in the range from 0 to 1280.
281  *
282  * le_mrc_GetPhysicalServingLteCellId() retrieves the physical serving cell Id in LTE. The physical
283  * cell Id is in the range from 0 to 503.
284  *
285  * le_mrc_GetServingCellGsmBsic() retrieves the Base Station Identity Code (BSIC) for the serving
286  * cell on GSM network.
287  *
288  * le_mrc_GetServingCellScramblingCode() retrieves the primary scrambling code for the serving cell
289  * on UMTS network.
290  *
291  * The BSIC is a local colour code (CC) that allows a Mobile Station (MS) to distinguish between
292  * different neighbouring base stations. BSIC is a 6-bit length code structured the following way:
293  * NCC (PLMN colour code) 3 bits + BCC (BS colour code) 3 bits. More information is available
294  * under the 3GPP reference 23.003 (Base Station Identify Code (BSIC) )
295  *
296  * A sample code can be seen in the following page:
297  * - @subpage c_mrcLocationinformation
298  *
299  * @section le_mrc_network_information Current Network Information
300  * le_mrc_GetCurrentNetworkName() retrieves the Current Network Name.
301  * le_mrc_GetCurrentNetworkMccMnc() retrieves the Current Network PLMN information.
302  *
303  * A sample code can be seen in the following page:
304  * - @subpage c_mrcGetCurrentNetwork
305  *
306  * @section le_mrc_networkScan Network Scan
307  *
308  * Call le_mrc_PerformCellularNetworkScan() to fill a list of all network in sight.
309  * You can go through all Scan Information by calling le_mrc_GetFirstCellularNetworkScan() and
310  * le_mrc_GetNextCellularNetworkScan().
311  *
312  * Call le_mrc_PerformCellularNetworkScanAsync() to start a network scan asynchronously. The
313  * function is not blocking. The scan list reference will be returned with the handler function
314  * response (@c le_mrc_CellularNetworkScanHandlerFunc_t).
315  *
316  * For each Scan Information, you can call:
317  *
318  * - le_mrc_GetCellularNetworkMccMnc() to have the operator code.
319  * - le_mrc_GetCellularNetworkName() to get the operator name.
320  * - le_mrc_GetCellularNetworkRat() to get the radio access technology.
321  * - le_mrc_IsCellularNetworkInUse() to check if this is currently in use by the network.
322  * - le_mrc_IsCellularNetworkAvailable() to check if this is available.
323  * - le_mrc_IsCellularNetworkHome() to check if this is in home status.
324  * - le_mrc_IsCellularNetworkForbidden() to check if this is forbidden by the network.
325  *
326  * le_mrc_DeleteCellularNetworkScan() should be called when you do not need the list anymore.
327  *
328  * A sample code can be seen in the following page:
329  * - @subpage c_mrcNetworkScan
330  *
331  * @section le_mrc_PcinetworkScan PCI Network Scan
332  *
333  * Call le_mrc_PerformPciNetworkScan() to fill a list of all neighboring cells.
334  * The Pci scan is used to get the according MCC/MNC for each neightboring cells ID. Not that a cell
335  * may contain more than one MCC/MNC when sevral plmn sharing the same cell.
336  *
337  * You can go through all Scan Information by calling le_mrc_GetFirstPciScanInfo() and
338  * le_mrc_GetNextPciScanInfo(). Note that each cell info contains a list of mcc/mnc, you can go
339  * through all mcc/mnc Information for each cell by calling le_mrc_GetFirstPlmnInfo()
340  * and le_mrc_GetNextPlmnInfo(), this two APIs return a reference to PlmnInformation, then use
341  * le_mrc_GetPciScanMccMnc() by giving this reference as parameter to get the Mcc/Mnc of the Plmn.
342  *
343  * Call le_mrc_PerformPciNetworkScanAsync()to start a pci scan asynchronously. The
344  * function is not blocking. The scan list reference will be returned with the handler function
345  * response (@c le_mrc_PciNetworkScanHandlerFunc_t).
346  *
347  *
348  * For Pci Network Scan Information, you can call:
349  *
350  * - le_mrc_GetPciScanCellId() to get the physical id of each cell.
351  * - le_mrc_GetPciScanGlobalCellId() to get the global id of each cell.
352  * - le_mrc_GetPciScanMccMnc() to get the Mcc/Mnc of each plmn on each cell.
353  * - le_mrc_DeletePciNetworkScan() should be called when you do not need the list anymore.
354  *
355  * A sample code can be seen in the following page:
356  * - @subpage c_mrcPciScan
357  *
358  * @section le_mrc_ngbr Neighboring Cells Information
359  *
360  * @warning The following functions do not apply to CDMA network.
361  *
362  * You must call le_mrc_GetNeighborCellsInfo() to retrieve the neighboring cells
363  * information. It returns a reference of le_mrc_NeighborCellsRef_t type.
364  *
365  * When the neighboring cells information is no longer needed, you must call
366  * le_mrc_DeleteNeighborCellsInfo() to free all allocated resources associated with the
367  * object.
368  *
369  * Then, you can use the following function to get the information:
370  * - le_mrc_GetFirstNeighborCellInfo() and le_mrc_GetFirstNeighborCellInfo() allow to go among
371  * the single cell information retrieved with le_mrc_GetNeighborCellsInfo(). These two functions
372  * return a reference of le_mrc_CellInfoRef_t type.
373  * - le_mrc_GetNeighborCellId() gets the identifier of the cell specified with the
374  * le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT32_MAX value is
375  * returned if the value is not available.
376  * - le_mrc_GetNeighborCellLocAreaCode() gets the location area code of the cell specified with the
377  * le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT16_MAX value is
378  * returned if the value is not available.
379  * - le_mrc_GetNeighborCellRxLevel() gets the signal strength (in dBm) of the cell specified with
380  * the le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
381  * - le_mrc_GetNeighborCellRat() gets the Radio Access Technology of the cell specified with
382  * the le_mrc_CellInfoRef_t parameter.
383  * - le_mrc_GetNeighborCellUmtsEcIo() gets the Ec/Io (the received energy per chip divided by the
384  * power density in the band measured in dBm on the primary CPICH channel of serving cell) of the
385  * cell specified with the le_mrc_CellInfoRef_t parameter.
386  * - le_mrc_GetNeighborCellLteIntraFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
387  * specified with the le_mrc_CellInfoRef_t parameter.
388  * - le_mrc_GetNeighborCellLteInterFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
389  * specified with the le_mrc_CellInfoRef_t parameter.
390  * - le_mrc_GetNeighborCellEarfcn() gets the neighbor Cell Frequency Channel Number (EARFCN).
391  * The EARFCN is in the range from 0 to 262143.
392  * - le_mrc_GetPhysicalNeighborLteCellId() gets the physical neighbor cell Id in LTE. The physical
393  * cell Id is in the range from 0 to 503.
394  * - le_mrc_GetNeighborCellGsmBsic() retrieves the Base Station Identity Code (BSIC) for the cell
395  * specified with the le_mrc_CellInfoRef_t parameter.
396  * - le_mrc_GetNeighborCellScramblingCode() retrieves the primary scrambling code for the cell
397  * specified with the le_mrc_CellInfoRef_t parameter.
398  *
399  * A sample code can be seen in the following page:
400  * - @subpage c_mrcNeighborCells
401  *
402  * @section le_mrc_jamming Jamming detection
403  *
404  * The jamming detection algorithm is based on power measurements and cell synchronization actions
405  * performed during a GSM network scan procedure.
406  * During this procedure some intermediate results are reported, that allows user to take some
407  * preventive actions if necessary.
408  * This result is reported as a jammed state probability. See @ref le_mrc_JammingStatus_t
409  * enumeration for probability description.
410  * Each time the jamming status changes during the scan procedure, it is reported to the user.
411  * See @ref le_mrc_JammingReport_t enumeration for details.
412  *
413  * The jamming status is reported:
414  * - In an unsolicited way, each time the protocol stack initiates a scan for PLMN selection or
415  * reselection.
416  * - On user demand, when a user PLMN scan is performed.
417  *
418  * Call le_mrc_StartJammingDetection() to launch jamming monitoring.
419  * By registering a handler by calling le_mrc_AddJammingDetectionEventHandler(), the notification
420  * on jamming detection can be sent to the registered application.
421  *
422  * For each jamming detection monitoring, the following APIs can be called:
423  * - le_mrc_StartJammingDetection() to start the jamming monitoring.
424  * - le_mrc_StopJammingDetection() to stop the jamming monitoring.
425  * - le_mrc_AddJammingDetectionEventHandler() to register an event handler.
426  * - le_mrc_RemoveJammingDetectionEventHandler() to remove an event handler.
427  *
428  * @section le_mrc_sar SAR backoff
429  * SAR (Specific Absorption Rate) is a measure of RF energy absorption by the human body.
430  * Users can dynamically select a pre-configured SAR backoff state so they can adjust the SAR
431  * depending on their needs. To manage SAR backoff, these API should be used:
432  * - le_mrc_SetSarBackoffState() to set a new SAR backoff state.
433  * - le_mrc_GetSarBackoffState() to get the current SAR backoff state.
434  * This feature may be unsupported by some targets. Also, the number of supported states may vary
435  * depending on the target. Please refer to @ref platformConstraintsMdc for further details.
436  *
437  * <HR>
438  *
439  * Copyright (C) Sierra Wireless Inc.
440  */
441 /**
442  * @page c_mrcRadioPower Sample code for Radio Power Management
443  *
444  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Radio Power
445  */
446 /**
447  * @page c_mrcRadioConfigurationPreferences Sample code for Radio Configuration Preferences
448  *
449  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Preferences
450  *
451  */
452 /**
453  * @page c_mrcRAT Sample code for Radio Access Technology
454  *
455  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT in Use
456  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT Preferences
457  *
458  */
459 /**
460  * @page c_mrcNetworkRegistration Sample code for Network Registration
461  *
462  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Register
463  *
464  */
465 /**
466  * @page c_mrcQuality Sample code for Signal Quality
467  *
468  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Signal Quality
469  *
470  */
471 /**
472  * @page c_mrcLocationinformation Sample code for Location information
473  *
474  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Loc information
475  *
476  */
477 /**
478  * @page c_mrcBandCapabilities Sample code for Band Capabilities
479  *
480  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Capabilities
481  *
482  */
483 /**
484  * @page c_mrcGetCurrentNetwork Sample code for Get Current Network Information
485  *
486  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Get Network
487  *
488  */
489 /**
490  * @page c_mrcNetworkScan Sample code for Network Scan
491  *
492  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Network Scan
493  *
494  */
495 /**
496  * @page c_mrcPciScan Sample code for LTE PCI Scan
497  *
498  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" PCI Scan
499  *
500  */
501 /**
502  * @page c_mrcNeighborCells Sample code for Neighboring Cells Information
503  *
504  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Neighbor Cells
505  *
506  */
507 /**
508  * @page c_mrcGetService Sample code for Get the Current Packet Switched state
509  *
510  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Service State
511  *
512  */
513 /**
514  * @file le_mrc_interface.h
515  *
516  * Legato @ref c_mrc include file.
517  *
518  * Copyright (C) Sierra Wireless Inc.
519  */
520 
521 #ifndef LE_MRC_INTERFACE_H_INCLUDE_GUARD
522 #define LE_MRC_INTERFACE_H_INCLUDE_GUARD
523 
524 
525 #include "legato.h"
526 
527 // Internal includes for this interface
528 #include "le_mrc_common.h"
529 /** @addtogroup le_mrc le_mrc API Reference
530  * @{
531  * @file le_mrc_common.h
532  * @file le_mrc_interface.h **/
533 //--------------------------------------------------------------------------------------------------
534 /**
535  * Type for handler called when a server disconnects.
536  */
537 //--------------------------------------------------------------------------------------------------
538 typedef void (*le_mrc_DisconnectHandler_t)(void *);
539 
540 //--------------------------------------------------------------------------------------------------
541 /**
542  *
543  * Connect the current client thread to the service providing this API. Block until the service is
544  * available.
545  *
546  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
547  * called before any other functions in this API. Normally, ConnectService is automatically called
548  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
549  *
550  * This function is created automatically.
551  */
552 //--------------------------------------------------------------------------------------------------
554 (
555  void
556 );
557 
558 //--------------------------------------------------------------------------------------------------
559 /**
560  *
561  * Try to connect the current client thread to the service providing this API. Return with an error
562  * if the service is not available.
563  *
564  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
565  * called before any other functions in this API. Normally, ConnectService is automatically called
566  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
567  *
568  * This function is created automatically.
569  *
570  * @return
571  * - LE_OK if the client connected successfully to the service.
572  * - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
573  * bound.
574  * - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
575  * - LE_COMM_ERROR if the Service Directory cannot be reached.
576  */
577 //--------------------------------------------------------------------------------------------------
579 (
580  void
581 );
582 
583 //--------------------------------------------------------------------------------------------------
584 /**
585  * Set handler called when server disconnection is detected.
586  *
587  * When a server connection is lost, call this handler then exit with LE_FATAL. If a program wants
588  * to continue without exiting, it should call longjmp() from inside the handler.
589  */
590 //--------------------------------------------------------------------------------------------------
592 (
593  le_mrc_DisconnectHandler_t disconnectHandler,
594  void *contextPtr
595 );
596 
597 //--------------------------------------------------------------------------------------------------
598 /**
599  *
600  * Disconnect the current client thread from the service providing this API.
601  *
602  * Normally, this function doesn't need to be called. After this function is called, there's no
603  * longer a connection to the service, and the functions in this API can't be used. For details, see
604  * @ref apiFilesC_client.
605  *
606  * This function is created automatically.
607  */
608 //--------------------------------------------------------------------------------------------------
610 (
611  void
612 );
613 
614 
615 //--------------------------------------------------------------------------------------------------
616 /**
617  * 2G/3G Band Bit Mask (64 bits)
618  */
619 //--------------------------------------------------------------------------------------------------
620 
621 
622 //--------------------------------------------------------------------------------------------------
623 /**
624  * LTE Band Bit Mask (64 bits)
625  *
626  */
627 //--------------------------------------------------------------------------------------------------
628 
629 
630 //--------------------------------------------------------------------------------------------------
631 /**
632  * TDSCDMA Band Bit Mask
633  *
634  */
635 //--------------------------------------------------------------------------------------------------
636 
637 
638 //--------------------------------------------------------------------------------------------------
639 /**
640  * Reference type for referring to MRC Scan Information objects.
641  */
642 //--------------------------------------------------------------------------------------------------
643 
644 
645 //--------------------------------------------------------------------------------------------------
646 /**
647  * Reference type for Scan Information Listing.
648  */
649 //--------------------------------------------------------------------------------------------------
650 
651 
652 //--------------------------------------------------------------------------------------------------
653 /**
654  * Reference type for PCI Scan Information Listing.
655  */
656 //--------------------------------------------------------------------------------------------------
657 
658 
659 //--------------------------------------------------------------------------------------------------
660 /**
661  * Reference type for PCI Scan Information .
662  */
663 //--------------------------------------------------------------------------------------------------
664 
665 
666 //--------------------------------------------------------------------------------------------------
667 /**
668  * Reference type for PLMN Information .
669  */
670 //--------------------------------------------------------------------------------------------------
671 
672 
673 //--------------------------------------------------------------------------------------------------
674 /**
675  * Reference type for referring to the Preferred Operator objects.
676  */
677 //--------------------------------------------------------------------------------------------------
678 
679 
680 //--------------------------------------------------------------------------------------------------
681 /**
682  * Reference type for Preferred Operator Listing.
683  */
684 //--------------------------------------------------------------------------------------------------
685 
686 
687 //--------------------------------------------------------------------------------------------------
688 /**
689  * Reference type for one Cell Information.
690  */
691 //--------------------------------------------------------------------------------------------------
692 
693 
694 //--------------------------------------------------------------------------------------------------
695 /**
696  * Reference type for all Neighboring Cells Information.
697  */
698 //--------------------------------------------------------------------------------------------------
699 
700 
701 //--------------------------------------------------------------------------------------------------
702 /**
703  * Reference type for the signal metrics.
704  */
705 //--------------------------------------------------------------------------------------------------
706 
707 
708 //--------------------------------------------------------------------------------------------------
709 /**
710  * Network Registration states.
711  */
712 //--------------------------------------------------------------------------------------------------
713 
714 
715 //--------------------------------------------------------------------------------------------------
716 /**
717  * Radio Access Technology enum
718  */
719 //--------------------------------------------------------------------------------------------------
720 
721 
722 //--------------------------------------------------------------------------------------------------
723 /**
724  * Jamming detection report type enum
725  *
726  * @note If the reported status is the final status (end of the procedure), this shall be indicated
727  * within the status report.
728  * @note Other reports, called intermediate reports, gives only intermediate results issuing from
729  * the algorithm
730  */
731 //--------------------------------------------------------------------------------------------------
732 
733 
734 //--------------------------------------------------------------------------------------------------
735 /**
736  * Jamming detection status type enum
737  *
738  * @note The final status can be only NULL or JAMMED.
739  */
740 //--------------------------------------------------------------------------------------------------
741 
742 
743 //--------------------------------------------------------------------------------------------------
744 /**
745  * Radio Bitmask Access Technology Bit Mask
746  */
747 //--------------------------------------------------------------------------------------------------
748 
749 
750 //--------------------------------------------------------------------------------------------------
751 /**
752  * Network Registration reject cause type enum.
753  */
754 //--------------------------------------------------------------------------------------------------
755 
756 
757 //--------------------------------------------------------------------------------------------------
758 /**
759  * Network Registration service domain type enum.
760  */
761 //--------------------------------------------------------------------------------------------------
762 
763 
764 //--------------------------------------------------------------------------------------------------
765 /**
766  * Network registration reject indication structure.
767  */
768 //--------------------------------------------------------------------------------------------------
769 
770 
771 //--------------------------------------------------------------------------------------------------
772 /**
773  * Handler for Network registration state changes.
774  */
775 //--------------------------------------------------------------------------------------------------
776 
777 
778 //--------------------------------------------------------------------------------------------------
779 /**
780  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegStateEvent'
781  */
782 //--------------------------------------------------------------------------------------------------
783 
784 
785 //--------------------------------------------------------------------------------------------------
786 /**
787  * Handler for Radio Access Technology changes.
788  *
789  */
790 //--------------------------------------------------------------------------------------------------
791 
792 
793 //--------------------------------------------------------------------------------------------------
794 /**
795  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RatChange'
796  */
797 //--------------------------------------------------------------------------------------------------
798 
799 
800 //--------------------------------------------------------------------------------------------------
801 /**
802  * Handler for Rank indicate Technology changes.
803  *
804  */
805 //--------------------------------------------------------------------------------------------------
806 
807 
808 //--------------------------------------------------------------------------------------------------
809 /**
810  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RankChange'
811  */
812 //--------------------------------------------------------------------------------------------------
813 
814 
815 //--------------------------------------------------------------------------------------------------
816 /**
817  * Handler for Packet Switched service state changes.
818  *
819  */
820 //--------------------------------------------------------------------------------------------------
821 
822 
823 //--------------------------------------------------------------------------------------------------
824 /**
825  * Reference type used by Add/Remove functions for EVENT 'le_mrc_PacketSwitchedChange'
826  */
827 //--------------------------------------------------------------------------------------------------
828 
829 
830 //--------------------------------------------------------------------------------------------------
831 /**
832  * Handler for Signal Strength value changes.
833  *
834  */
835 //--------------------------------------------------------------------------------------------------
836 
837 
838 //--------------------------------------------------------------------------------------------------
839 /**
840  * Reference type used by Add/Remove functions for EVENT 'le_mrc_SignalStrengthChange'
841  */
842 //--------------------------------------------------------------------------------------------------
843 
844 
845 //--------------------------------------------------------------------------------------------------
846 /**
847  * Handler for cellular asynchronous network scan Sending result.
848  * Returns the reference to the List object. Null pointer if the scan failed.
849  *
850  */
851 //--------------------------------------------------------------------------------------------------
852 
853 
854 //--------------------------------------------------------------------------------------------------
855 /**
856  * Handler for PCI asynchronous network scan Sending result.
857  * Returns the reference to the List object. Null pointer if the scan failed.
858  *
859  */
860 //--------------------------------------------------------------------------------------------------
861 
862 
863 //--------------------------------------------------------------------------------------------------
864 /**
865  * Handler for asynchronous manual selection response
866  *
867  */
868 //--------------------------------------------------------------------------------------------------
869 
870 
871 //--------------------------------------------------------------------------------------------------
872 /**
873  * Handler to report network reject indication.
874  *
875  * @deprecated le_mrc_NetworkRejectHandler() will be removed in near future.
876  * It will be replaced by le_mrc_AddNetRegRejectHandler().
877  *
878  */
879 //--------------------------------------------------------------------------------------------------
880 
881 
882 //--------------------------------------------------------------------------------------------------
883 /**
884  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetworkReject'
885  */
886 //--------------------------------------------------------------------------------------------------
887 
888 
889 //--------------------------------------------------------------------------------------------------
890 /**
891  * Handler to report network registration reject indication.
892  * NetworkRejectHandler is deprecated.
893  */
894 //--------------------------------------------------------------------------------------------------
895 
896 
897 //--------------------------------------------------------------------------------------------------
898 /**
899  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegReject'
900  */
901 //--------------------------------------------------------------------------------------------------
902 
903 
904 //--------------------------------------------------------------------------------------------------
905 /**
906  * Handler for jamming detection event.
907  */
908 //--------------------------------------------------------------------------------------------------
909 
910 
911 //--------------------------------------------------------------------------------------------------
912 /**
913  * Reference type used by Add/Remove functions for EVENT 'le_mrc_JammingDetectionEvent'
914  */
915 //--------------------------------------------------------------------------------------------------
916 
917 
918 //--------------------------------------------------------------------------------------------------
919 /**
920  * Add handler function for EVENT 'le_mrc_NetRegStateEvent'
921  *
922  * This event provides information on network registration state changes.
923  *
924  * @note <b>multi-app safe</b>
925  */
926 //--------------------------------------------------------------------------------------------------
928 (
930  ///< [IN]
931  void* contextPtr
932  ///< [IN]
933 );
934 
935 //--------------------------------------------------------------------------------------------------
936 /**
937  * Remove handler function for EVENT 'le_mrc_NetRegStateEvent'
938  */
939 //--------------------------------------------------------------------------------------------------
941 (
943  ///< [IN]
944 );
945 
946 //--------------------------------------------------------------------------------------------------
947 /**
948  * Add handler function for EVENT 'le_mrc_RatChange'
949  *
950  * This event provides information on Radio Access Technology changes.
951  *
952  * @note <b>multi-app safe</b>
953  */
954 //--------------------------------------------------------------------------------------------------
956 (
958  ///< [IN]
959  void* contextPtr
960  ///< [IN]
961 );
962 
963 //--------------------------------------------------------------------------------------------------
964 /**
965  * Remove handler function for EVENT 'le_mrc_RatChange'
966  */
967 //--------------------------------------------------------------------------------------------------
969 (
971  ///< [IN]
972 );
973 
974 //--------------------------------------------------------------------------------------------------
975 /**
976  * Add handler function for EVENT 'le_mrc_RankChange'
977  *
978  * This event provides information on Rank indicate changes.
979  *
980  * @note <b>multi-app safe</b>
981  */
982 //--------------------------------------------------------------------------------------------------
984 (
986  ///< [IN]
987  void* contextPtr
988  ///< [IN]
989 );
990 
991 //--------------------------------------------------------------------------------------------------
992 /**
993  * Remove handler function for EVENT 'le_mrc_RankChange'
994  */
995 //--------------------------------------------------------------------------------------------------
997 (
999  ///< [IN]
1000 );
1001 
1002 //--------------------------------------------------------------------------------------------------
1003 /**
1004  * Add handler function for EVENT 'le_mrc_PacketSwitchedChange'
1005  *
1006  * This event provides information on Packet Switched service changes.
1007  *
1008  * @note <b>multi-app safe</b>
1009  */
1010 //--------------------------------------------------------------------------------------------------
1012 (
1014  ///< [IN]
1015  void* contextPtr
1016  ///< [IN]
1017 );
1018 
1019 //--------------------------------------------------------------------------------------------------
1020 /**
1021  * Remove handler function for EVENT 'le_mrc_PacketSwitchedChange'
1022  */
1023 //--------------------------------------------------------------------------------------------------
1025 (
1027  ///< [IN]
1028 );
1029 
1030 //--------------------------------------------------------------------------------------------------
1031 /**
1032  * Add handler function for EVENT 'le_mrc_SignalStrengthChange'
1033  *
1034  * This event provides information on Signal Strength value changes.
1035  *
1036  * @note <b>NOT multi-app safe</b>
1037  */
1038 //--------------------------------------------------------------------------------------------------
1040 (
1041  le_mrc_Rat_t rat,
1042  ///< [IN] Radio Access Technology
1043  int32_t lowerRangeThreshold,
1044  ///< [IN] Lower-range Signal strength threshold in dBm
1045  int32_t upperRangeThreshold,
1046  ///< [IN] Upper-range Signal strength threshold in dBm
1048  ///< [IN]
1049  void* contextPtr
1050  ///< [IN]
1051 );
1052 
1053 //--------------------------------------------------------------------------------------------------
1054 /**
1055  * Remove handler function for EVENT 'le_mrc_SignalStrengthChange'
1056  */
1057 //--------------------------------------------------------------------------------------------------
1059 (
1061  ///< [IN]
1062 );
1063 
1064 //--------------------------------------------------------------------------------------------------
1065 /**
1066  * This function sets signal strength indication thresholds for a specific RAT.
1067  *
1068  * @return
1069  * - LE_OK Function succeeded.
1070  * - LE_BAD_PARAMETER Bad parameters
1071  * - LE_FAULT Function failed.
1072  *
1073  * @note <b>NOT multi-app safe</b>
1074  */
1075 //--------------------------------------------------------------------------------------------------
1077 (
1078  le_mrc_Rat_t rat,
1079  ///< [IN] Radio Access Technology
1080  int32_t lowerRangeThreshold,
1081  ///< [IN] Lower-range Signal strength threshold in dBm
1082  int32_t upperRangeThreshold
1083  ///< [IN] Upper-range Signal strength threshold in dBm
1084 );
1085 
1086 //--------------------------------------------------------------------------------------------------
1087 /**
1088  * This function sets a signal strength indication delta for a specific RAT.
1089  *
1090  * @return
1091  * - LE_OK Function succeeded.
1092  * - LE_BAD_PARAMETER Bad parameters.
1093  * - LE_FAULT Function failed.
1094  *
1095  * @note The signal delta is set in units of 0.1 dBm. For example, to set a delta of 10.6 dBm, the
1096  * delta value must be set to 106.
1097  *
1098  * @warning The signal delta resolution is platform dependent. Please refer to
1099  * @ref platformConstraintsMdc section for full details.
1100  */
1101 //--------------------------------------------------------------------------------------------------
1103 (
1104  le_mrc_Rat_t rat,
1105  ///< [IN] Radio Access Technology
1106  uint16_t delta
1107  ///< [IN] Signal delta in units of 0.1 dBm
1108 );
1109 
1110 //--------------------------------------------------------------------------------------------------
1111 /**
1112  * Enable the automatic Selection Register mode.
1113  *
1114  * @return
1115  * - LE_FAULT Function failed.
1116  * - LE_OK Function succeeded.
1117  *
1118  * @note <b>NOT multi-app safe</b>
1119  */
1120 //--------------------------------------------------------------------------------------------------
1122 (
1123  void
1124 );
1125 
1126 //--------------------------------------------------------------------------------------------------
1127 /**
1128  * Set the manual Selection Register mode with the MCC/MNC parameters.
1129  *
1130  * @return
1131  * - LE_FAULT Function failed.
1132  * - LE_OK Function succeeded.
1133  *
1134  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1135  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1136  * won't return.
1137  *
1138  * @note <b>NOT multi-app safe</b>
1139  */
1140 //--------------------------------------------------------------------------------------------------
1142 (
1143  const char* LE_NONNULL mcc,
1144  ///< [IN] Mobile Country Code
1145  const char* LE_NONNULL mnc
1146  ///< [IN] Mobile Network Code
1147 );
1148 
1149 //--------------------------------------------------------------------------------------------------
1150 /**
1151  * Set the manual selection register mode asynchronously. This function is not blocking,
1152  * the response will be returned with a handler function.
1153  *
1154  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1155  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1156  * won't return.
1157  *
1158  *@note <b>NOT multi-app safe</b>
1159  *
1160  */
1161 //--------------------------------------------------------------------------------------------------
1163 (
1164  const char* LE_NONNULL mcc,
1165  ///< [IN] Mobile Country Code
1166  const char* LE_NONNULL mnc,
1167  ///< [IN] Mobile Network Code
1169  ///< [IN] handler for sending result
1170  void* contextPtr
1171  ///< [IN]
1172 );
1173 
1174 //--------------------------------------------------------------------------------------------------
1175 /**
1176  * Get the selected Selection Register mode.
1177  *
1178  * @return
1179  * - LE_FAULT Function failed.
1180  * - LE_OK Function succeeded.
1181  *
1182  * @note <b>multi-app safe</b>
1183  */
1184 //--------------------------------------------------------------------------------------------------
1186 (
1187  bool* isManualPtrPtr,
1188  ///< [OUT] true if the scan mode is manual, false if the scan mode is automatic.
1189  char* mccPtr,
1190  ///< [OUT] Mobile Country Code
1191  size_t mccPtrSize,
1192  ///< [IN]
1193  char* mncPtr,
1194  ///< [OUT] Mobile Network Code
1195  size_t mncPtrSize
1196  ///< [IN]
1197 );
1198 
1199 //--------------------------------------------------------------------------------------------------
1200 /**
1201  * Get the Packet Switched state.
1202  *
1203  * @return
1204  * - LE_FAULT Function failed.
1205  * - LE_OK Function succeeded.
1206  *
1207  * @note <b>multi-app safe</b>
1208  */
1209 //--------------------------------------------------------------------------------------------------
1211 (
1212  le_mrc_NetRegState_t* statePtr
1213  ///< [OUT] The current Packet switched state.
1214 );
1215 
1216 //--------------------------------------------------------------------------------------------------
1217 /**
1218  * Get the platform specific network registration error code.
1219  *
1220  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific
1221  * registration error code description.
1222  *
1223  * @return the platform specific registration error code
1224  *
1225  */
1226 //--------------------------------------------------------------------------------------------------
1228 (
1229  void
1230 );
1231 
1232 //--------------------------------------------------------------------------------------------------
1233 /**
1234  * Set the Radio Access Technology preferences by using a bit mask.
1235  *
1236  * @return
1237  * - LE_FAULT Function failed.
1238  * - LE_OK Function succeeded.
1239  * - LE_UNSUPPORTED Not supported by platform.
1240  *
1241  * @note <b>NOT multi-app safe</b>
1242  */
1243 //--------------------------------------------------------------------------------------------------
1245 (
1246  le_mrc_RatBitMask_t ratMask
1247  ///< [IN] Bit mask for the Radio Access Technology preferences.
1248 );
1249 
1250 //--------------------------------------------------------------------------------------------------
1251 /**
1252  * Get the Radio Access Technology preferences
1253  *
1254  * @return
1255  * - LE_FAULT Function failed.
1256  * - LE_OK Function succeeded.
1257  *
1258  * @note <b>multi-app safe</b>
1259  */
1260 //--------------------------------------------------------------------------------------------------
1262 (
1263  le_mrc_RatBitMask_t* ratMaskPtrPtr
1264  ///< [OUT] Bit mask for the Radio Access Technology preferences.
1265 );
1266 
1267 //--------------------------------------------------------------------------------------------------
1268 /**
1269  * Set the 2G/3G Band preferences by using a bit mask.
1270  *
1271  * @return
1272  * - LE_FAULT Function failed.
1273  * - LE_OK Function succeeded.
1274  *
1275  * @note <b>NOT multi-app safe</b>
1276  */
1277 //--------------------------------------------------------------------------------------------------
1279 (
1280  le_mrc_BandBitMask_t bandMask
1281  ///< [IN] Bit mask for 2G/3G Band preferences.
1282 );
1283 
1284 //--------------------------------------------------------------------------------------------------
1285 /**
1286  * Get the Bit mask for 2G/3G Band preferences.
1287  *
1288  * @return
1289  * - LE_FAULT Function failed.
1290  * - LE_OK Function succeeded.
1291  *
1292  * @note <b>multi-app safe</b>
1293  */
1294 //--------------------------------------------------------------------------------------------------
1296 (
1297  le_mrc_BandBitMask_t* bandMaskPtrPtr
1298  ///< [OUT] Bit mask for 2G/3G Band preferences.
1299 );
1300 
1301 //--------------------------------------------------------------------------------------------------
1302 /**
1303  * Set the LTE Band preferences by using a bit mask.
1304  *
1305  * @return
1306  * - LE_FAULT Function failed.
1307  * - LE_OK Function succeeded.
1308  * - LE_UNSUPPORTED The platform doesn't support setting LTE Band preferences.
1309  *
1310  * @note <b>NOT multi-app safe</b>
1311  */
1312 //--------------------------------------------------------------------------------------------------
1314 (
1315  le_mrc_LteBandBitMask_t bandMask
1316  ///< [IN] Bit mask for LTE Band preferences.
1317 );
1318 
1319 //--------------------------------------------------------------------------------------------------
1320 /**
1321  * Get the Bit mask for LTE Band preferences.
1322  *
1323  * @return
1324  * - LE_FAULT Function failed.
1325  * - LE_OK Function succeeded.
1326  *
1327  * @note <b>multi-app safe</b>
1328  */
1329 //--------------------------------------------------------------------------------------------------
1331 (
1332  le_mrc_LteBandBitMask_t* bandMaskPtrPtr
1333  ///< [OUT] Bit mask for LTE Band preferences.
1334 );
1335 
1336 //--------------------------------------------------------------------------------------------------
1337 /**
1338  * Set the TD-SCDMA Band preferences by using a bit mask.
1339  *
1340  * @return
1341  * - LE_OK Function succeeded.
1342  * - LE_FAULT Function failed.
1343  * - LE_UNSUPPORTED The platform doesn't support setting TD-SCDMA Band preferences.
1344  *
1345  * @note <b>NOT multi-app safe</b>
1346  */
1347 //--------------------------------------------------------------------------------------------------
1349 (
1350  le_mrc_TdScdmaBandBitMask_t bandMask
1351  ///< [IN] Bit mask for TD-SCDMA Band preferences.
1352 );
1353 
1354 //--------------------------------------------------------------------------------------------------
1355 /**
1356  * Get the Bit mask for TD-SCDMA Band preferences.
1357  *
1358  * @return
1359  * - LE_OK Function succeeded.
1360  * - LE_FAULT Function failed.
1361  * - LE_UNSUPPORTED The platform doesn't support getting TD-SCDMA Band preferences.
1362  *
1363  * @note <b>multi-app safe</b>
1364  */
1365 //--------------------------------------------------------------------------------------------------
1367 (
1368  le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
1369  ///< [OUT] Bit mask for TD-SCDMA Band preferences.
1370 );
1371 
1372 //--------------------------------------------------------------------------------------------------
1373 /**
1374  * Add a preferred operator by specifying the MCC/MNC and the Radio Access Technology.
1375  *
1376  * @return
1377  * - LE_UNSUPPORTED List of User Preferred operators not available.
1378  * - LE_FAULT Function failed.
1379  * - LE_BAD_PARAMETER RAT mask is invalid.
1380  * - LE_OK Function succeeded.
1381  *
1382  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1383  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1384  * won't return.
1385  *
1386  * @note <b>NOT multi-app safe</b>
1387  */
1388 //--------------------------------------------------------------------------------------------------
1390 (
1391  const char* LE_NONNULL mcc,
1392  ///< [IN] Mobile Country Code
1393  const char* LE_NONNULL mnc,
1394  ///< [IN] Mobile Network Code
1395  le_mrc_RatBitMask_t ratMask
1396  ///< [IN] Bit mask for the Radio Access Technology preferences.
1397 );
1398 
1399 //--------------------------------------------------------------------------------------------------
1400 /**
1401  * Remove a preferred operator by specifying the MCC/MNC.
1402  *
1403  * @return
1404  * - LE_UNSUPPORTED List of User Preferred operators not available.
1405  * - LE_NOT_FOUND Operator not found in the User Preferred operators list.
1406  * - LE_FAULT Function failed.
1407  * - LE_OK Function succeeded.
1408  *
1409  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1410  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1411  * won't return.
1412  *
1413  * @note <b>NOT multi-app safe</b>
1414  */
1415 //--------------------------------------------------------------------------------------------------
1417 (
1418  const char* LE_NONNULL mcc,
1419  ///< [IN] Mobile Country Code
1420  const char* LE_NONNULL mnc
1421  ///< [IN] Mobile Network Code
1422 );
1423 
1424 //--------------------------------------------------------------------------------------------------
1425 /**
1426  * This function must be called to retrieve a list of the preferred operators.
1427  *
1428  * @return
1429  * - Reference to the List object.
1430  * - Null pointer if there is no preferences list.
1431  *
1432  * @note <b>multi-app safe</b>
1433  */
1434 //--------------------------------------------------------------------------------------------------
1436 (
1437  void
1438 );
1439 
1440 //--------------------------------------------------------------------------------------------------
1441 /**
1442  * This function must be called to get the first Operator object reference in the list of the
1443  * preferred operators retrieved with le_mrc_GetPreferredOperators().
1444  *
1445  * @return
1446  * - NULL No operator information found.
1447  * - le_mrc_PreferredOperatorRef The Operator object reference.
1448  *
1449  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
1450  * function won't return.
1451  *
1452  * @note <b>multi-app safe</b>
1453  */
1454 //--------------------------------------------------------------------------------------------------
1456 (
1457  le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
1458  ///< [IN] The list of the preferred operators.
1459 );
1460 
1461 //--------------------------------------------------------------------------------------------------
1462 /**
1463  * This function must be called to get the next Operator object reference in the list of the
1464  * preferred operators retrieved with le_mrc_GetPreferredOperators().
1465  *
1466  * @return
1467  * - NULL No operator information found.
1468  * - le_mrc_PreferredOperatorRef The Operator object reference.
1469  *
1470  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
1471  * function won't return.
1472  *
1473  * @note <b>multi-app safe</b>
1474  */
1475 //--------------------------------------------------------------------------------------------------
1477 (
1478  le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
1479  ///< [IN] The list of the preferred operators.
1480 );
1481 
1482 //--------------------------------------------------------------------------------------------------
1483 /**
1484  * This function must be called to delete the list of the preferred operators retrieved with
1485  * le_mrc_GetPreferredOperators().
1486  *
1487  * @note On failure, the process exits, so you don't have to worry about checking the returned
1488  * reference for validity.
1489  *
1490  * @note <b>multi-app safe</b>
1491  */
1492 //--------------------------------------------------------------------------------------------------
1494 (
1495  le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
1496  ///< [IN] The list of the preferred operators.
1497 );
1498 
1499 //--------------------------------------------------------------------------------------------------
1500 /**
1501  * This function must be called to get the Operator information details.
1502  *
1503  * @return
1504  * - LE_OK on success
1505  * - LE_OVERFLOW if the MCC or MNC would not fit in buffer
1506  * - LE_FAULT for all other errors
1507  *
1508  * @note <b>multi-app safe</b>
1509  */
1510 //--------------------------------------------------------------------------------------------------
1512 (
1513  le_mrc_PreferredOperatorRef_t preferredOperatorRef,
1514  ///< [IN] Operator object reference.
1515  char* mccPtr,
1516  ///< [OUT] Mobile Country Code.
1517  size_t mccPtrSize,
1518  ///< [IN]
1519  char* mncPtr,
1520  ///< [OUT] Mobile Network Code.
1521  size_t mncPtrSize,
1522  ///< [IN]
1523  le_mrc_RatBitMask_t* ratMaskPtr
1524  ///< [OUT] Bit mask for the RAT preferences.
1525 );
1526 
1527 //--------------------------------------------------------------------------------------------------
1528 /**
1529  * Get the network registration state.
1530  *
1531  * @return LE_FAULT The function failed to get the Network registration state.
1532  * @return LE_BAD_PARAMETER A bad parameter was passed.
1533  * @return LE_OK The function succeeded.
1534  *
1535  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1536  * function won't return.
1537  *
1538  * @note <b>multi-app safe</b>
1539  */
1540 //--------------------------------------------------------------------------------------------------
1542 (
1543  le_mrc_NetRegState_t* statePtr
1544  ///< [OUT] Network Registration state.
1545 );
1546 
1547 //--------------------------------------------------------------------------------------------------
1548 /**
1549  * Get the signal quality.
1550  *
1551  * @return LE_FAULT The function failed to get the Signal Quality information.
1552  * @return LE_BAD_PARAMETER A bad parameter was passed.
1553  * @return LE_OK The function succeeded.
1554  *
1555  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1556  * function won't return.
1557  *
1558  * @note <b>multi-app safe</b>
1559  */
1560 //--------------------------------------------------------------------------------------------------
1562 (
1563  uint32_t* qualityPtr
1564  ///< [OUT] [OUT] Received signal strength quality (0 = no signal strength,
1565  ///< 5 = very good signal strength).
1566 );
1567 
1568 //--------------------------------------------------------------------------------------------------
1569 /**
1570  * Set the power of the Radio Module.
1571  *
1572  * @return LE_BAD_PARAMETER Bad power mode specified.
1573  * @return LE_FAULT Function failed.
1574  * @return LE_OK Function succeed.
1575  *
1576  * @note <b>NOT multi-app safe</b>
1577  */
1578 //--------------------------------------------------------------------------------------------------
1580 (
1581  le_onoff_t power
1582  ///< [IN] The power state.
1583 );
1584 
1585 //--------------------------------------------------------------------------------------------------
1586 /**
1587  * Must be called to get the Radio Module power state.
1588  *
1589  * @return LE_FAULT The function failed to get the Radio Module power state.
1590  * @return LE_BAD_PARAMETER if powerPtr is NULL.
1591  * @return LE_OK The function succeed.
1592  *
1593  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1594  * function won't return.
1595  *
1596  * @note <b>multi-app safe</b>
1597  */
1598 //--------------------------------------------------------------------------------------------------
1600 (
1601  le_onoff_t* powerPtr
1602  ///< [OUT] Power state.
1603 );
1604 
1605 //--------------------------------------------------------------------------------------------------
1606 /**
1607  * This function must be called to perform a cellular network scan.
1608  *
1609  * @return Reference to the List object. Null pointer if the scan failed.
1610  *
1611  * @note <b>multi-app safe</b>
1612  */
1613 //--------------------------------------------------------------------------------------------------
1615 (
1616  le_mrc_RatBitMask_t ratMask
1617  ///< [IN] Radio Access Technology mask
1618 );
1619 
1620 //--------------------------------------------------------------------------------------------------
1621 /**
1622  * This function must be called to perform a PCI network scan.
1623  *
1624  * @return Reference to the List object. Null pointer if the scan failed.
1625  *
1626  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
1627  * details.
1628  *
1629  * @note On devices with the watchdog service enabled, the timeout is 4 mins. On those without, the
1630  * timeout is 5 mins.
1631  *
1632  * @note <b>multi-app safe</b>
1633  */
1634 //--------------------------------------------------------------------------------------------------
1636 (
1637  le_mrc_RatBitMask_t ratMask
1638  ///< [IN] Radio Access Technology mask
1639 );
1640 
1641 //--------------------------------------------------------------------------------------------------
1642 /**
1643  * This function must be called to perform a cellular network scan asynchronously. This function
1644  * is not blocking, the response will be returned with a handler function.
1645  *
1646  *@note <b>multi-app safe</b>
1647  *
1648  */
1649 //--------------------------------------------------------------------------------------------------
1651 (
1652  le_mrc_RatBitMask_t ratMask,
1653  ///< [IN] Radio Access Technology mask
1655  ///< [IN] handler for sending result.
1656  void* contextPtr
1657  ///< [IN]
1658 );
1659 
1660 //--------------------------------------------------------------------------------------------------
1661 /**
1662  * This function must be called to perform a PCI network scan asynchronously. This function
1663  * is not blocking, the response will be returned with a handler function.
1664  *
1665  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
1666  * details.
1667  *
1668  *@note <b>multi-app safe</b>
1669  *
1670  */
1671 //--------------------------------------------------------------------------------------------------
1673 (
1674  le_mrc_RatBitMask_t ratMask,
1675  ///< [IN] Radio Access Technology mask
1677  ///< [IN] handler for sending result.
1678  void* contextPtr
1679  ///< [IN]
1680 );
1681 
1682 //--------------------------------------------------------------------------------------------------
1683 /**
1684  * This function must be called to get the first Scan Information object reference in the list of
1685  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
1686  *
1687  * @return NULL No scan information found.
1688  * @return le_mrc_ScanInformationRef_t The Scan Information object reference.
1689  *
1690  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1691  * function won't return.
1692  *
1693  * @note <b>multi-app safe</b>
1694  */
1695 //--------------------------------------------------------------------------------------------------
1697 (
1698  le_mrc_ScanInformationListRef_t scanInformationListRef
1699  ///< [IN] The list of scan information.
1700 );
1701 
1702 //--------------------------------------------------------------------------------------------------
1703 /**
1704  * This function must be called to get the next Scan Information object reference in the list of
1705  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
1706  *
1707  * @return NULL No scan information found.
1708  * @return le_mrc_ScanInformationRef_t The Scan Information object reference.
1709  *
1710  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1711  * function won't return.
1712  *
1713  * @note <b>multi-app safe</b>
1714  */
1715 //--------------------------------------------------------------------------------------------------
1717 (
1718  le_mrc_ScanInformationListRef_t scanInformationListRef
1719  ///< [IN] The list of scan information.
1720 );
1721 
1722 //--------------------------------------------------------------------------------------------------
1723 /**
1724  * This function must be called to get the first Pci Scan Information object reference in the list of
1725  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
1726  *
1727  * @return NULL No scan information found.
1728  * @return The Scan Information object reference.
1729  *
1730  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1731  * function won't return.
1732  *
1733  * @note <b>multi-app safe</b>
1734  */
1735 //--------------------------------------------------------------------------------------------------
1737 (
1738  le_mrc_PciScanInformationListRef_t scanInformationListRef
1739  ///< [IN] The list of scan information.
1740 );
1741 
1742 //--------------------------------------------------------------------------------------------------
1743 /**
1744  * This function must be called to get the next Scan Information object reference in the list of
1745  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
1746  *
1747  * @return NULL No scan information found.
1748  * @return The Scan Information object reference.
1749  *
1750  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1751  * function won't return.
1752  *
1753  * @note <b>multi-app safe</b>
1754  */
1755 //--------------------------------------------------------------------------------------------------
1757 (
1758  le_mrc_PciScanInformationListRef_t scanInformationListRef
1759  ///< [IN] The list of scan information.
1760 );
1761 
1762 //--------------------------------------------------------------------------------------------------
1763 /**
1764  * This function must be called to get the first Plmn Information object reference in the list of
1765  * Plmn on each cell.
1766  *
1767  * @return NULL No scan information found.
1768  * @return le_mrc_PlmnInformationRef_t The Plmn Information object reference.
1769  *
1770  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1771  * function won't return.
1772  *
1773  */
1774 //--------------------------------------------------------------------------------------------------
1776 (
1777  le_mrc_PciScanInformationRef_t pciScanInformationRef
1778  ///< [IN] [IN] The reference to the cell information.
1779 );
1780 
1781 //--------------------------------------------------------------------------------------------------
1782 /**
1783  * This function must be called to get the next Plmn Information object reference in the list of
1784  * Plmn on each cell.
1785  *
1786  * @return NULL No scan information found.
1787  * @return le_mrc_PlmnInformationRef_t The Plmn Information object reference.
1788  *
1789  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1790  * function won't return.
1791  *
1792  */
1793 //--------------------------------------------------------------------------------------------------
1795 (
1797  ///< [IN] [IN] The reference to the cell information.
1798 );
1799 
1800 //--------------------------------------------------------------------------------------------------
1801 /**
1802  * This function must be called to get the physical cell id referenced by PciScanInformation which
1803  * is returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
1804  *
1805  * @return The Physical Cell Identifier.
1806  *
1807  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1808  * function won't return.
1809  */
1810 //--------------------------------------------------------------------------------------------------
1811 uint16_t le_mrc_GetPciScanCellId
1812 (
1813  le_mrc_PciScanInformationRef_t pciScanInformationRef
1814  ///< [IN] [IN] The reference to the cell information.
1815 );
1816 
1817 //--------------------------------------------------------------------------------------------------
1818 /**
1819  * This function must be called to get the global cell id referenced by PciScanInformation which is
1820  * returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
1821  *
1822  * @return The Global Cell Identifier.
1823  *
1824  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1825  * function won't return.
1826  */
1827 //--------------------------------------------------------------------------------------------------
1829 (
1830  le_mrc_PciScanInformationRef_t pciScanInformationRef
1831  ///< [IN] [IN] The reference to the cell information.
1832 );
1833 
1834 //--------------------------------------------------------------------------------------------------
1835 /**
1836  * This function must be called to get the Mcc/Mnc of each PLMN referenced in the list of
1837  * Plmn Information retrieved with le_mrc_GetFirstPlmnInfo() and le_mrc_GetNextPlmnInfo().
1838  *
1839  * @return
1840  * - LE_OK on success
1841  * - LE_OVERFLOW if the MCC or MNC would not fit in buffer
1842  * - LE_FAULT for all other errors
1843  *
1844  *
1845  */
1846 //--------------------------------------------------------------------------------------------------
1848 (
1850  ///< [IN] [IN] The reference to the cell information.
1851  char* mccPtr,
1852  ///< [OUT] Mobile Country Code
1853  size_t mccPtrSize,
1854  ///< [IN]
1855  char* mncPtr,
1856  ///< [OUT] Mobile Network Code
1857  size_t mncPtrSize
1858  ///< [IN]
1859 );
1860 
1861 //--------------------------------------------------------------------------------------------------
1862 /**
1863  * This function must be called to delete the list of the Scan Information retrieved with
1864  * le_mrc_PerformCellularNetworkScan().
1865  *
1866  * @note
1867  * On failure, the process exits, so you don't have to worry about checking the returned
1868  * reference for validity.
1869  *
1870  * @note <b>multi-app safe</b>
1871  */
1872 //--------------------------------------------------------------------------------------------------
1874 (
1875  le_mrc_ScanInformationListRef_t scanInformationListRef
1876  ///< [IN] The list of scan information.
1877 );
1878 
1879 //--------------------------------------------------------------------------------------------------
1880 /**
1881  * This function must be called to delete the list of the Pci Scan Information retrieved with
1882  * le_mrc_PerformPciNetworkScan() or le_mrc_PerformPciNetworkScanAsync().
1883  *
1884  * @note
1885  * On failure, the process exits, so you don't have to worry about checking the returned
1886  * reference for validity.
1887  *
1888  */
1889 //--------------------------------------------------------------------------------------------------
1891 (
1892  le_mrc_PciScanInformationListRef_t scanInformationListRef
1893  ///< [IN] The list of scan information.
1894 );
1895 
1896 //--------------------------------------------------------------------------------------------------
1897 /**
1898  * This function must be called to get the Cellular Network Code [mcc:mnc]
1899  *
1900  * @return
1901  * - LE_OK on success
1902  * - LE_OVERFLOW if the MCC or MNC would not fit in buffer
1903  * - LE_FAULT for all other errors
1904  *
1905  * @note On failure, the process exits, so you don't have to worry about checking the returned
1906  * reference for validity.
1907  *
1908  * @note <b>multi-app safe</b>
1909  */
1910 //--------------------------------------------------------------------------------------------------
1912 (
1913  le_mrc_ScanInformationRef_t scanInformationRef,
1914  ///< [IN] Scan information reference
1915  char* mccPtr,
1916  ///< [OUT] Mobile Country Code
1917  size_t mccPtrSize,
1918  ///< [IN]
1919  char* mncPtr,
1920  ///< [OUT] Mobile Network Code
1921  size_t mncPtrSize
1922  ///< [IN]
1923 );
1924 
1925 //--------------------------------------------------------------------------------------------------
1926 /**
1927  * This function must be called to get the Cellular Network Name.
1928  *
1929  * @return
1930  * - LE_OK on success
1931  * - LE_OVERFLOW if the operator name would not fit in buffer
1932  * - LE_FAULT for all other errors
1933  *
1934  * @note On failure, the process exits, so you don't have to worry about checking the returned
1935  * reference for validity.
1936  *
1937  * @note <b>multi-app safe</b>
1938  */
1939 //--------------------------------------------------------------------------------------------------
1941 (
1942  le_mrc_ScanInformationRef_t scanInformationRef,
1943  ///< [IN] Scan information reference
1944  char* namePtr,
1945  ///< [OUT] Name of operator
1946  size_t namePtrSize
1947  ///< [IN]
1948 );
1949 
1950 //--------------------------------------------------------------------------------------------------
1951 /**
1952  * This function must be called to get the radio access technology of a scanInformationRef.
1953  *
1954  * @return the radio access technology
1955  *
1956  * @note On failure, the process exits.
1957  *
1958  * @note <b>multi-app safe</b>
1959  */
1960 //--------------------------------------------------------------------------------------------------
1962 (
1963  le_mrc_ScanInformationRef_t scanInformationRef
1964  ///< [IN] Scan information reference
1965 );
1966 
1967 //--------------------------------------------------------------------------------------------------
1968 /**
1969  * This function must be called to check if a cellular network is currently in use.
1970  *
1971  * @return true The network is in use
1972  * @return false The network isn't in use
1973  *
1974  * @note On failure, the process exits, so you don't have to worry about checking the returned
1975  * reference for validity.
1976  *
1977  * @note <b>multi-app safe</b>
1978  */
1979 //--------------------------------------------------------------------------------------------------
1981 (
1982  le_mrc_ScanInformationRef_t scanInformationRef
1983  ///< [IN] Scan information reference
1984 );
1985 
1986 //--------------------------------------------------------------------------------------------------
1987 /**
1988  * This function must be called to check if a cellular network is available.
1989  *
1990  * @return true The network is available
1991  * @return false The network isn't available
1992  *
1993  * @note On failure, the process exits, so you don't have to worry about checking the returned
1994  * reference for validity.
1995  *
1996  * @note <b>multi-app safe</b>
1997  */
1998 //--------------------------------------------------------------------------------------------------
2000 (
2001  le_mrc_ScanInformationRef_t scanInformationRef
2002  ///< [IN] Scan information reference
2003 );
2004 
2005 //--------------------------------------------------------------------------------------------------
2006 /**
2007  * This function must be called to check if a cellular network is currently in home mode.
2008  *
2009  * @return true The network is home
2010  * @return false The network is roaming
2011  *
2012  * @note On failure, the process exits, so you don't have to worry about checking the returned
2013  * reference for validity.
2014  *
2015  * @note <b>multi-app safe</b>
2016  */
2017 //--------------------------------------------------------------------------------------------------
2019 (
2020  le_mrc_ScanInformationRef_t scanInformationRef
2021  ///< [IN] Scan information reference
2022 );
2023 
2024 //--------------------------------------------------------------------------------------------------
2025 /**
2026  * This function must be called to check if a cellular network is forbidden by the operator.
2027  *
2028  * @return true The network is forbidden
2029  * @return false The network is allowed
2030  *
2031  * @note On failure, the process exits, so you don't have to worry about checking the returned
2032  * reference for validity.
2033  *
2034  * @note <b>multi-app safe</b>
2035  */
2036 //--------------------------------------------------------------------------------------------------
2038 (
2039  le_mrc_ScanInformationRef_t scanInformationRef
2040  ///< [IN] Scan information reference
2041 );
2042 
2043 //--------------------------------------------------------------------------------------------------
2044 /**
2045  * This function must be called to get the current network name information.
2046  *
2047  * @return
2048  * - LE_OK on success
2049  * - LE_BAD_PARAMETER if nameStr is NULL
2050  * - LE_OVERFLOW if the Home Network Name can't fit in nameStr
2051  * - LE_FAULT on any other failure
2052  *
2053  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2054  * function won't return.
2055  *
2056  * @note <b>multi-app safe</b>
2057  */
2058 //--------------------------------------------------------------------------------------------------
2060 (
2061  char* nameStr,
2062  ///< [OUT] the home network Name
2063  size_t nameStrSize
2064  ///< [IN]
2065 );
2066 
2067 //--------------------------------------------------------------------------------------------------
2068 /**
2069  * This function must be called to get the current network PLMN information.
2070  *
2071  * @return
2072  * - LE_OK on success
2073  * - LE_FAULT on any other failure
2074  *
2075  * @note <b>multi-app safe</b>
2076  */
2077 //--------------------------------------------------------------------------------------------------
2079 (
2080  char* mccStr,
2081  ///< [OUT] the mobile country code
2082  size_t mccStrSize,
2083  ///< [IN]
2084  char* mncStr,
2085  ///< [OUT] the mobile network code
2086  size_t mncStrSize
2087  ///< [IN]
2088 );
2089 
2090 //--------------------------------------------------------------------------------------------------
2091 /**
2092  * This function must be called to get the current Radio Access Technology in use.
2093  *
2094  * @return LE_OK Function succeeded.
2095  * @return LE_BAD_PARAMETER Invalid parameter.
2096  * @return LE_FAULT Function failed to get the Radio Access Technology.
2097  *
2098  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2099  * function won't return.
2100  *
2101  * @note The API returns the RAT only if the device is registered on the network.
2102  * le_mrc_GetNetRegState() function can be called first to obtain the network registration
2103  * state.
2104  *
2105  * @note <b>multi-app safe</b>
2106  */
2107 //--------------------------------------------------------------------------------------------------
2109 (
2110  le_mrc_Rat_t* ratPtr
2111  ///< [OUT] The Radio Access Technology.
2112 );
2113 
2114 //--------------------------------------------------------------------------------------------------
2115 /**
2116  * This function must be called to get the current Radio Band in use.
2117  *
2118  * @return LE_OK Function succeeded.
2119  * @return LE_BAD_PARAMETER Invalid parameter.
2120  * @return LE_FAULT Function failed to get the Radio Band.
2121  *
2122  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2123  * function won't return.
2124  *
2125  * @note <b>multi-app safe</b>
2126  */
2127 //--------------------------------------------------------------------------------------------------
2129 (
2130  uint32_t* bandPtr
2131  ///< [OUT] The Radio Band.
2132 );
2133 
2134 //--------------------------------------------------------------------------------------------------
2135 /**
2136  * This function must be called to retrieve the Neighboring Cells information. It creates and
2137  * returns a reference to the Neighboring Cells information.
2138  *
2139  * @return A reference to the Neighboring Cells information.
2140  * @return NULL if no Cells Information are available.
2141  *
2142  * @note <b>multi-app safe</b>
2143  */
2144 //--------------------------------------------------------------------------------------------------
2146 (
2147  void
2148 );
2149 
2150 //--------------------------------------------------------------------------------------------------
2151 /**
2152  * This function must be called to delete the Neighboring Cells information.
2153  *
2154  * @note On failure, the process exits, so you don't have to worry about checking the returned
2155  * reference for validity.
2156  *
2157  * @note <b>multi-app safe</b>
2158  */
2159 //--------------------------------------------------------------------------------------------------
2161 (
2162  le_mrc_NeighborCellsRef_t ngbrCellsRef
2163  ///< [IN] Neighboring Cells reference.
2164 );
2165 
2166 //--------------------------------------------------------------------------------------------------
2167 /**
2168  * This function must be called to get the first Cell Information reference in the list of
2169  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
2170  *
2171  * @return NULL No Cell information object found.
2172  * @return le_mrc_CellInfoRef_t The Cell information object reference.
2173  *
2174  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2175  * function won't return.
2176  *
2177  * @note <b>multi-app safe</b>
2178  */
2179 //--------------------------------------------------------------------------------------------------
2181 (
2182  le_mrc_NeighborCellsRef_t ngbrCellsRef
2183  ///< [IN] Neighboring Cells reference.
2184 );
2185 
2186 //--------------------------------------------------------------------------------------------------
2187 /**
2188  * This function must be called to get the next Cell Information reference in the list of
2189  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
2190  *
2191  * @return NULL No Cell information object found.
2192  * @return le_mrc_CellInfoRef_t Cell information object reference.
2193  *
2194  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2195  * function won't return.
2196  *
2197  * @note <b>multi-app safe</b>
2198  */
2199 //--------------------------------------------------------------------------------------------------
2201 (
2202  le_mrc_NeighborCellsRef_t ngbrCellsRef
2203  ///< [IN] Neighboring Cells reference.
2204 );
2205 
2206 //--------------------------------------------------------------------------------------------------
2207 /**
2208  * This function must be called to get the Physical Cell Identifier.
2209  *
2210  * @return The Physical Cell Identifier. UINT32_MAX value is returned if the Cell Identifier is not
2211  * available.
2212  *
2213  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2214  * function won't return.
2215  *
2216  * @note <b>multi-app safe</b>
2217  */
2218 //--------------------------------------------------------------------------------------------------
2219 uint32_t le_mrc_GetNeighborCellId
2220 (
2221  le_mrc_CellInfoRef_t ngbrCellInfoRef
2222  ///< [IN] Cell information reference.
2223 );
2224 
2225 //--------------------------------------------------------------------------------------------------
2226 /**
2227  * This function must be called to get the Location Area Code of a cell.
2228  *
2229  * @return The Location Area Code of a cell. UINT16_MAX value is returned if the value is not
2230  * available.
2231  *
2232  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2233  * function won't return.
2234  *
2235  * @note <b>multi-app safe</b>
2236  */
2237 //--------------------------------------------------------------------------------------------------
2239 (
2240  le_mrc_CellInfoRef_t ngbrCellInfoRef
2241  ///< [IN] Cell information reference.
2242 );
2243 
2244 //--------------------------------------------------------------------------------------------------
2245 /**
2246  * This function must be called to get the signal strength of a cell.
2247  *
2248  * @return The signal strength of a cell in dBm.
2249  *
2250  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2251  * function won't return.
2252  *
2253  * @note <b>multi-app safe</b>
2254  */
2255 //--------------------------------------------------------------------------------------------------
2257 (
2258  le_mrc_CellInfoRef_t ngbrCellInfoRef
2259  ///< [IN] Cell information reference.
2260 );
2261 
2262 //--------------------------------------------------------------------------------------------------
2263 /**
2264  * This function must be called to get the Radio Access Technology of a cell.
2265  *
2266  * @return The Radio Access Technology of a cell.
2267  *
2268  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2269  * function won't return.
2270  *
2271  * @note <b>multi-app safe</b>
2272  */
2273 //--------------------------------------------------------------------------------------------------
2275 (
2276  le_mrc_CellInfoRef_t ngbrCellInfoRef
2277  ///< [IN] Cell information reference.
2278 );
2279 
2280 //--------------------------------------------------------------------------------------------------
2281 /**
2282  * This function must be called to get the Ec/Io; the received energy per chip divided by the power
2283  * density in the band measured in dBm on the primary CPICH channel of serving cell (negative value)
2284  *
2285  * @return
2286  * - The Ec/Io of a cell given in dB with 1 decimal place. (only applicable for UMTS network).
2287  * - INT32_MAX when the value isn't available.
2288  *
2289  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2290  * function won't return.
2291  *
2292  * @note <b>multi-app safe</b>
2293  */
2294 //--------------------------------------------------------------------------------------------------
2296 (
2297  le_mrc_CellInfoRef_t ngbrCellInfoRef
2298  ///< [IN] Cell information reference.
2299 );
2300 
2301 //--------------------------------------------------------------------------------------------------
2302 /**
2303  * This function must be called to get the RSRP and RSRQ of the Intrafrequency of a LTE cell.
2304  *
2305  * @return
2306  * - LE_OK on success
2307  * - LE_FAULT on failure
2308  *
2309  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2310  * function won't return.
2311  *
2312  * @note <b>multi-app safe</b>
2313  */
2314 //--------------------------------------------------------------------------------------------------
2316 (
2317  le_mrc_CellInfoRef_t ngbrCellInfoRef,
2318  ///< [IN] Cell information reference.
2319  int32_t* rsrqPtr,
2320  ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
2321  ///< place
2322  int32_t* rsrpPtr
2323  ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
2324  ///< place
2325 );
2326 
2327 //--------------------------------------------------------------------------------------------------
2328 /**
2329  * This function must be called to get the RSRP and RSRQ of the Interfrequency of a LTE cell.
2330  *
2331  * @return
2332  * - LE_OK on success
2333  * - LE_FAULT on failure
2334  *
2335  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2336  * function won't return.
2337  *
2338  * @note <b>multi-app safe</b>
2339  */
2340 //--------------------------------------------------------------------------------------------------
2342 (
2343  le_mrc_CellInfoRef_t ngbrCellInfoRef,
2344  ///< [IN] Cell information reference.
2345  int32_t* rsrqPtr,
2346  ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
2347  ///< place
2348  int32_t* rsrpPtr
2349  ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
2350  ///< place
2351 );
2352 
2353 //--------------------------------------------------------------------------------------------------
2354 /**
2355  * This function must be called to get the neighbor cell primary scrambling code.
2356  *
2357  * @return The neighbor cell primary scrambling code. UINT16_MAX value is returned if the value is
2358  * not available.
2359  *
2360  * @note <b>multi-app safe</b>
2361  */
2362 //--------------------------------------------------------------------------------------------------
2364 (
2365  le_mrc_CellInfoRef_t ngbrCellInfoRef
2366  ///< [IN] Cell information reference
2367 );
2368 
2369 //--------------------------------------------------------------------------------------------------
2370 /**
2371  * This function must be called to measure the signal metrics. It creates and returns a reference
2372  * to the signal metrics.
2373  *
2374  * @return A reference to the signal metrics.
2375  * @return NULL if no signal metrics are available.
2376  *
2377  * @note <b>multi-app safe</b>
2378  */
2379 //--------------------------------------------------------------------------------------------------
2381 (
2382  void
2383 );
2384 
2385 //--------------------------------------------------------------------------------------------------
2386 /**
2387  * This function must be called to delete the the signal metrics.
2388  *
2389  * @note On failure, the process exits, so you don't have to worry about checking the returned
2390  * reference for validity.
2391  *
2392  * @note <b>multi-app safe</b>
2393  */
2394 //--------------------------------------------------------------------------------------------------
2396 (
2397  le_mrc_MetricsRef_t MetricsRef
2398  ///< [IN] Signal metrics reference.
2399 );
2400 
2401 //--------------------------------------------------------------------------------------------------
2402 /**
2403  * This function returns the Radio Access Technology of the signal metrics.
2404  *
2405  * @return The Radio Access Technology of the signal measure.
2406  *
2407  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2408  * function won't return.
2409  *
2410  * @note <b>multi-app safe</b>
2411  */
2412 //--------------------------------------------------------------------------------------------------
2414 (
2415  le_mrc_MetricsRef_t MetricsRef
2416  ///< [IN] Signal metrics reference.
2417 );
2418 
2419 //--------------------------------------------------------------------------------------------------
2420 /**
2421  * This function returns the signal strength in dBm and the bit error rate measured on GSM network.
2422  *
2423  * @return
2424  * - LE_OK on success
2425  * - LE_FAULT on failure
2426  *
2427  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2428  * function won't return.
2429  *
2430  * @note <b>multi-app safe</b>
2431  */
2432 //--------------------------------------------------------------------------------------------------
2434 (
2435  le_mrc_MetricsRef_t MetricsRef,
2436  ///< [IN] Signal metrics reference.
2437  int32_t* rssiPtr,
2438  ///< [OUT] Signal strength in dBm
2439  uint32_t* berPtr
2440  ///< [OUT] Bit error rate.
2441 );
2442 
2443 //--------------------------------------------------------------------------------------------------
2444 /**
2445  * This function returns the signal metrics measured on UMTS or TD-SCDMA networks.
2446  *
2447  * @return
2448  * - LE_OK on success
2449  * - LE_FAULT on failure
2450  *
2451  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2452  * function won't return.
2453  *
2454  * @note <b>multi-app safe</b>
2455  */
2456 //--------------------------------------------------------------------------------------------------
2458 (
2459  le_mrc_MetricsRef_t MetricsRef,
2460  ///< [IN] Signal metrics reference.
2461  int32_t* ssPtr,
2462  ///< [OUT] Signal strength in dBm
2463  uint32_t* blerPtr,
2464  ///< [OUT] Block error rate
2465  int32_t* ecioPtr,
2466  ///< [OUT] Ec/Io value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
2467  ///< value)
2468  int32_t* rscpPtr,
2469  ///< [OUT] Measured RSCP in dBm (negative value, value INT32_MAX means
2470  ///< that RSCP is not available)
2471  int32_t* sinrPtr
2472  ///< [OUT] Measured SINR in dB (only applicable for TD-SCDMA network, value
2473  ///< INT32_MAX means that the SINR is not available)
2474 );
2475 
2476 //--------------------------------------------------------------------------------------------------
2477 /**
2478  * This function returns the signal metrics measured on LTE network.
2479  *
2480  * @return
2481  * - LE_OK on success
2482  * - LE_FAULT on failure
2483  * - sinrPtr and ioPtr return INT32_MAX when the value isn't available.
2484  *
2485  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2486  * function won't return.
2487  *
2488  * @note <b>multi-app safe</b>
2489  */
2490 //--------------------------------------------------------------------------------------------------
2492 (
2493  le_mrc_MetricsRef_t MetricsRef,
2494  ///< [IN] Signal metrics reference.
2495  int32_t* ssPtr,
2496  ///< [OUT] Signal strength in dBm
2497  uint32_t* blerPtr,
2498  ///< [OUT] Block error rate
2499  int32_t* rsrqPtr,
2500  ///< [OUT] RSRQ value in dB as measured by L1 with 1 decimal place
2501  int32_t* rsrpPtr,
2502  ///< [OUT] Current RSRP in dBm as measured by L1 with 1 decimal place
2503  int32_t* snrPtr
2504  ///< [OUT] SNR level in dB with 1 decimal place (15 = 1.5 dB)
2505 );
2506 
2507 //--------------------------------------------------------------------------------------------------
2508 /**
2509  * This function returns the signal metrics measured on CDMA network.
2510  *
2511  * @return
2512  * - LE_OK on success
2513  * - LE_FAULT on failure
2514  * - rscpPtr and sinrPtr return INT32_MAX when the value isn't available.
2515  *
2516  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2517  * function won't return.
2518  *
2519  * @note <b>multi-app safe</b>
2520  */
2521 //--------------------------------------------------------------------------------------------------
2523 (
2524  le_mrc_MetricsRef_t MetricsRef,
2525  ///< [IN] Signal metrics reference.
2526  int32_t* ssPtr,
2527  ///< [OUT] Signal strength in dBm
2528  uint32_t* erPtr,
2529  ///< [OUT] Frame/Packet error rate
2530  int32_t* ecioPtr,
2531  ///< [OUT] ECIO value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
2532  ///< value)
2533  int32_t* sinrPtr,
2534  ///< [OUT] SINR level in dB with 1 decimal place, (only applicable for
2535  ///< 1xEV-DO, value INT32_MAX means that the value is not available)
2536  int32_t* ioPtr
2537  ///< [OUT] Received IO in dBm (only applicable for 1xEV-DO, value INT32_MAX
2538  ///< means that the value is not available)
2539 );
2540 
2541 //--------------------------------------------------------------------------------------------------
2542 /**
2543  * This function must be called to get the serving Cell Identifier.
2544  *
2545  * @return The Cell Identifier. UINT32_MAX value is returned if the value is not available.
2546  *
2547  * @note When the module is in UMTS network, the API returns the serving UTRAN Cell Identity (UC-Id)
2548  * which is used to identify the cell uniquely.
2549  * It is composed of the Controlling Radio Network Controller Identifier (CRNC-Id, 12 bits) and the
2550  * Cell Identifier (C-Id, 16 bits). (3GPP 25.401, section 6.1.5)
2551  * The Cell Identifier is coded in the lower 2 bytes of the 4 bytes UC-Id and the CRNC-Id is coded
2552  * in the upper 2 bytes.
2553  * Example: the API returns 7807609 -> 0x772279 (CRNC-Id = 0x77 , cell ID = 0x2279)
2554  *
2555  * @note <b>multi-app safe</b>
2556  */
2557 //--------------------------------------------------------------------------------------------------
2558 uint32_t le_mrc_GetServingCellId
2559 (
2560  void
2561 );
2562 
2563 //--------------------------------------------------------------------------------------------------
2564 /**
2565  * This function must be called to get the Location Area Code of the serving cell.
2566  *
2567  * @return The Location Area Code. UINT32_MAX value is returned if the value is not available.
2568  *
2569  * @note <b>multi-app safe</b>
2570  */
2571 //--------------------------------------------------------------------------------------------------
2573 (
2574  void
2575 );
2576 
2577 //--------------------------------------------------------------------------------------------------
2578 /**
2579  * This function must be called to get the Tracking Area Code of the serving cell (LTE only).
2580  *
2581  * @return The Tracking Area Code. UINT16_MAX value is returned if the value is not available.
2582  *
2583  * @note <b>multi-app safe</b>
2584  */
2585 //--------------------------------------------------------------------------------------------------
2587 (
2588  void
2589 );
2590 
2591 //--------------------------------------------------------------------------------------------------
2592 /**
2593  * This function must be called to get the serving cell primary scrambling code.
2594  *
2595  * @return The serving cell primary scrambling code. UINT16_MAX value is returned if the value is
2596  * not available.
2597  *
2598  * @note <b>multi-app safe</b>
2599  */
2600 //--------------------------------------------------------------------------------------------------
2602 (
2603  void
2604 );
2605 
2606 //--------------------------------------------------------------------------------------------------
2607 /**
2608  * Get the Bit mask for 2G/3G Band capabilities.
2609  *
2610  * @return
2611  * - LE_OK on success
2612  * - LE_FAULT on failure
2613  * - LE_UNSUPPORTED Unable to get the 2G/3G Band capabilities on this platform
2614  *
2615  * @note <b>multi-app safe</b>
2616  */
2617 //--------------------------------------------------------------------------------------------------
2619 (
2620  le_mrc_BandBitMask_t* bandMaskPtrPtr
2621  ///< [OUT] Bit mask for 2G/3G Band capabilities.
2622 );
2623 
2624 //--------------------------------------------------------------------------------------------------
2625 /**
2626  * Get the Bit mask for LTE Band capabilities.
2627  *
2628  * @return
2629  * - LE_OK on success
2630  * - LE_FAULT on failure
2631  * - LE_UNSUPPORTED Unable to get the LTE Band capabilities on this platform
2632  *
2633  * @note <b>multi-app safe</b>
2634  */
2635 //--------------------------------------------------------------------------------------------------
2637 (
2638  le_mrc_LteBandBitMask_t* bandMaskPtrPtr
2639  ///< [OUT] Bit mask for LTE Band capabilities.
2640 );
2641 
2642 //--------------------------------------------------------------------------------------------------
2643 /**
2644  * Get the Bit mask for TD-SCDMA Band capabilities.
2645  *
2646  * @return
2647  * - LE_OK on success
2648  * - LE_FAULT on failure
2649  * - LE_UNSUPPORTED Unable to get the TD-SCDMA Band Capabilities on this platform
2650  *
2651  * @note <b>multi-app safe</b>
2652  */
2653 //--------------------------------------------------------------------------------------------------
2655 (
2656  le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
2657  ///< [OUT] Bit mask for TD-SCDMA Band capabilities.
2658 );
2659 
2660 //--------------------------------------------------------------------------------------------------
2661 /**
2662  * Add handler function for EVENT 'le_mrc_NetworkReject'
2663  *
2664  * Event to report network reject indication.
2665  *
2666  */
2667 //--------------------------------------------------------------------------------------------------
2669 (
2671  ///< [IN]
2672  void* contextPtr
2673  ///< [IN]
2674 );
2675 
2676 //--------------------------------------------------------------------------------------------------
2677 /**
2678  * Remove handler function for EVENT 'le_mrc_NetworkReject'
2679  */
2680 //--------------------------------------------------------------------------------------------------
2682 (
2684  ///< [IN]
2685 );
2686 
2687 //--------------------------------------------------------------------------------------------------
2688 /**
2689  * Add handler function for EVENT 'le_mrc_NetRegReject'
2690  *
2691  * Event to report network registration reject indication.
2692  * NetworkReject will be deprecated.
2693  */
2694 //--------------------------------------------------------------------------------------------------
2696 (
2698  ///< [IN]
2699  void* contextPtr
2700  ///< [IN]
2701 );
2702 
2703 //--------------------------------------------------------------------------------------------------
2704 /**
2705  * Remove handler function for EVENT 'le_mrc_NetRegReject'
2706  */
2707 //--------------------------------------------------------------------------------------------------
2709 (
2711  ///< [IN]
2712 );
2713 
2714 //--------------------------------------------------------------------------------------------------
2715 /**
2716  * Add handler function for EVENT 'le_mrc_JammingDetectionEvent'
2717  *
2718  * This event provides information on jamming detection.
2719  */
2720 //--------------------------------------------------------------------------------------------------
2722 (
2724  ///< [IN]
2725  void* contextPtr
2726  ///< [IN]
2727 );
2728 
2729 //--------------------------------------------------------------------------------------------------
2730 /**
2731  * Remove handler function for EVENT 'le_mrc_JammingDetectionEvent'
2732  */
2733 //--------------------------------------------------------------------------------------------------
2735 (
2737  ///< [IN]
2738 );
2739 
2740 //--------------------------------------------------------------------------------------------------
2741 /**
2742  * Start the jamming detection monitoring.
2743  *
2744  * @warning The jamming detection feature might be limited by the platform.
2745  * Please refer to the platform documentation @ref platformConstraintsMdc.
2746  *
2747  * @return
2748  * - LE_OK The function succeeded.
2749  * - LE_FAULT The function failed.
2750  * - LE_DUPLICATE The feature is already activated and an activation is requested.
2751  * - LE_UNSUPPORTED The feature is not supported.
2752  */
2753 //--------------------------------------------------------------------------------------------------
2755 (
2756  void
2757 );
2758 
2759 //--------------------------------------------------------------------------------------------------
2760 /**
2761  * Stop the jamming detection monitoring.
2762  *
2763  * @return
2764  * - LE_OK The function succeeded.
2765  * - LE_FAULT The function failed or the application did not start the jamming detection.
2766  * - LE_UNSUPPORTED The feature is not supported.
2767  */
2768 //--------------------------------------------------------------------------------------------------
2770 (
2771  void
2772 );
2773 
2774 //--------------------------------------------------------------------------------------------------
2775 /**
2776  * Set the SAR backoff state
2777  *
2778  * @warning The SAR backoff feature might be unsupported by some platforms.
2779  * Please refer to the platform documentation @ref platformConstraintsMdc.
2780  *
2781  * @return
2782  * - LE_OK The function succeeded.
2783  * - LE_FAULT The function failed.
2784  * - LE_UNSUPPORTED The feature is not supported.
2785  * - LE_OUT_OF_RANGE The provided index is out of range.
2786  */
2787 //--------------------------------------------------------------------------------------------------
2789 (
2790  uint8_t state
2791  ///< [IN] New state to enable. By default, SAR is disabled (state = 0).
2792  ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
2793 );
2794 
2795 //--------------------------------------------------------------------------------------------------
2796 /**
2797  * Get the SAR backoff state
2798  *
2799  * @warning The SAR backoff feature might be unsupported by some platforms.
2800  * Please refer to the platform documentation @ref platformConstraintsMdc.
2801  *
2802  * @return
2803  * - LE_OK The function succeeded.
2804  * - LE_FAULT The function failed.
2805  * - LE_UNSUPPORTED The feature is not supported.
2806  */
2807 //--------------------------------------------------------------------------------------------------
2809 (
2810  uint8_t* statePtr
2811  ///< [OUT] Current state. By default, SAR is disabled (state = 0).
2812  ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
2813 );
2814 
2815 //--------------------------------------------------------------------------------------------------
2816 /**
2817  * Get the serving cell radio frequency channel number. The EARFCN is in the range from 0 to 262143.
2818  *
2819  * @return The serving cell frequency channel number. UINT32_MAX value is returned if the value is
2820  * not available.
2821  */
2822 //--------------------------------------------------------------------------------------------------
2824 (
2825  void
2826 );
2827 
2828 //--------------------------------------------------------------------------------------------------
2829 /**
2830  * Get the neighbor cell radio frequency channel number. The EARFCN is in the range from 0
2831  * to 262143.
2832  *
2833  * @return The neighbor cell frequency channel number. UINT32_MAX value is returned if the value is
2834  * not available.
2835  */
2836 //--------------------------------------------------------------------------------------------------
2838 (
2839  le_mrc_CellInfoRef_t ngbrCellInfoRef
2840  ///< [IN] The cell information reference
2841 );
2842 
2843 //--------------------------------------------------------------------------------------------------
2844 /**
2845  * Get the serving cell timing advance index value. Timing advance index value is in the range
2846  * from 0 to 1280.
2847  *
2848  * @return The serving cell timing advance index value. UINT32_MAX value is returned if the value
2849  * is not available.
2850  */
2851 //--------------------------------------------------------------------------------------------------
2853 (
2854  void
2855 );
2856 
2857 //--------------------------------------------------------------------------------------------------
2858 /**
2859  * Get the physical serving cell Id. The physical cell Id is in the range from 0 to 503.
2860  *
2861  * @return The physical serving cell Id. UINT16_MAX value is returned if the value is
2862  * not available.
2863  */
2864 //--------------------------------------------------------------------------------------------------
2866 (
2867  void
2868 );
2869 
2870 //--------------------------------------------------------------------------------------------------
2871 /**
2872  * Get the neighbor physical cell Id. The physical cell Id is in the range from 0 to 503.
2873  *
2874  * @return The physical serving cell Id. UINT16_MAX value is returned if the value is
2875  * not available.
2876  */
2877 //--------------------------------------------------------------------------------------------------
2879 (
2880  le_mrc_CellInfoRef_t ngbrCellInfoRef
2881  ///< [IN] The cell information reference
2882 );
2883 
2884 //--------------------------------------------------------------------------------------------------
2885 /**
2886  * Get the Base Station Identity Code (BSIC) for the serving cell on GSM network.
2887  *
2888  * @return LE_OK The function succeeded.
2889  * @return LE_BAD_PARAMETER Bad parameter passed to the function
2890  * @return LE_FAULT The function failed.
2891  * @return LE_UNAVAILABLE The BSIC is not available. The BSIC value is set to UINT8_MAX.
2892  */
2893 //--------------------------------------------------------------------------------------------------
2895 (
2896  uint8_t* BSICPtr
2897  ///< [OUT] The BSIC value
2898 );
2899 
2900 //--------------------------------------------------------------------------------------------------
2901 /**
2902  * Get the Base Station Identity Code (BSIC) for a neighbour cell on GSM network.
2903  *
2904  * @return LE_OK The function succeeded.
2905  * @return LE_BAD_PARAMETER Bad parameter passed to the function
2906  * @return LE_FAULT The function failed.
2907  * @return LE_UNAVAILABLE The BSIC is not available. The BSIC value is set to UINT8_MAX.
2908  */
2909 //--------------------------------------------------------------------------------------------------
2911 (
2912  le_mrc_CellInfoRef_t ngbrCellInfoRef,
2913  ///< [IN] The cell information reference.
2914  uint8_t* bsicPtr
2915  ///< [OUT] The BSIC value
2916 );
2917 
2918 //--------------------------------------------------------------------------------------------------
2919 /**
2920  * Get the LTE Data modulation and coding scheme for the physical multicast channel.
2921  *
2922  * @return LE_OK The function succeeded.
2923  * @return LE_FAULT The function failed.
2924  * @return LE_UNAVAILABLE The mcs is not available. The mcs value is set to UINT8_MAX.
2925  *
2926  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2927  * function won't return.
2928  */
2929 //--------------------------------------------------------------------------------------------------
2931 (
2932  uint8_t* mcsPtr
2933  ///< [OUT] The mcs value
2934 );
2935 
2936 //--------------------------------------------------------------------------------------------------
2937 /**
2938  * Get the TX power
2939  *
2940  * @return LE_OK The function succeeded.
2941  * @return LE_FAULT The function failed.
2942  * @return LE_UNAVAILABLE The TX power is not available. The TX power value is set to INT32_MAX.
2943  *
2944  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2945  * function won't return.
2946  */
2947 //--------------------------------------------------------------------------------------------------
2949 (
2950  int32_t* tx_pwrPtr
2951  ///< [OUT] The TX power value
2952 );
2953 
2954 //--------------------------------------------------------------------------------------------------
2955 /**
2956  * This command gets LTE CQI
2957  *
2958  * @return
2959  * - LE_OK The function succeeded.
2960  * - LE_FAULT The function failed.
2961  * - LE_UNSUPPORTED The feature is not supported.
2962  *
2963  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2964  * function won't return.
2965  */
2966 //--------------------------------------------------------------------------------------------------
2968 (
2969  uint32_t* cqiPtr
2970  ///< [OUT] The CQI value
2971 );
2972 
2973 //--------------------------------------------------------------------------------------------------
2974 /**
2975  * Enable or disable monitoring on Rank change indicate . By default, monitoring is disabled.
2976  *
2977  * @return
2978  * - LE_OK The function succeeded.
2979  * - LE_FAULT The function failed.
2980  * - LE_UNSUPPORTED The feature is not supported.
2981  */
2982 //--------------------------------------------------------------------------------------------------
2984 (
2985  bool enable
2986  ///< [IN] If monitoring should be enabled
2987 );
2988 
2989 /** @} **/
2990 
2991 #endif // LE_MRC_INTERFACE_H_INCLUDE_GUARD
le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
void le_mrc_RemoveNetworkRejectHandler(le_mrc_NetworkRejectHandlerRef_t handlerRef)
int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode(void)
void(* le_mrc_NetRegStateHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_common.h:545
le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo(le_mrc_PciScanInformationRef_t plmnRef)
le_result_t le_mrc_GetBandPreferences(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_result_t le_mrc_SetRadioPower(le_onoff_t power)
le_result_t le_mrc_SetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t bandMask)
uint16_t le_mrc_GetPhysicalServingLteCellId(void)
void(* le_mrc_RankChangeHandlerFunc_t)(int32_t rank, void *contextPtr)
Definition: le_mrc_common.h:573
le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler(le_mrc_NetRegStateHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t
Definition: le_basics.h:46
le_result_t le_mrc_SetManualRegisterMode(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
uint32_t le_mrc_GetServingCellLocAreaCode(void)
struct le_mrc_Metrics * le_mrc_MetricsRef_t
Definition: le_mrc_common.h:249
int32_t le_mrc_GetNeighborCellRxLevel(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_Rat_t le_mrc_GetCellularNetworkRat(le_mrc_ScanInformationRef_t scanInformationRef)
void le_mrc_ConnectService(void)
struct le_mrc_PciScanInformation * le_mrc_PciScanInformationRef_t
Definition: le_mrc_common.h:201
le_result_t le_mrc_GetLteCqi(uint32_t *cqiPtr)
struct le_mrc_PlmnInformation * le_mrc_PlmnInformationRef_t
Definition: le_mrc_common.h:209
le_result_t le_mrc_GetTxPowerInfo(int32_t *tx_pwrPtr)
void le_mrc_RemoveSignalStrengthChangeHandler(le_mrc_SignalStrengthChangeHandlerRef_t handlerRef)
void(* le_mrc_DisconnectHandler_t)(void *)
Definition: le_mrc_interface.h:538
le_result_t le_mrc_GetNeighborCellGsmBsic(le_mrc_CellInfoRef_t ngbrCellInfoRef, uint8_t *bsicPtr)
le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList(void)
le_result_t le_mrc_TryConnectService(void)
le_result_t le_mrc_SetSignalStrengthIndDelta(le_mrc_Rat_t rat, uint16_t delta)
le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_result_t le_mrc_SetAutomaticRegisterMode(void)
struct le_mrc_PreferredOperatorList * le_mrc_PreferredOperatorListRef_t
Definition: le_mrc_common.h:225
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_result_t le_mrc_GetSignalQual(uint32_t *qualityPtr)
void(* le_mrc_JammingDetectionHandlerFunc_t)(le_mrc_JammingReport_t report, le_mrc_JammingStatus_t status, void *contextPtr)
Definition: le_mrc_common.h:695
void le_mrc_RemoveRatChangeHandler(le_mrc_RatChangeHandlerRef_t handlerRef)
le_mrc_NetRegState_t
Definition: le_mrc_common.h:257
void le_mrc_DeleteCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
struct le_mrc_NeighborCells * le_mrc_NeighborCellsRef_t
Definition: le_mrc_common.h:241
le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler(le_mrc_RatChangeHandlerFunc_t handlerPtr, void *contextPtr)
void(* le_mrc_ManualSelectionHandlerFunc_t)(le_result_t result, void *contextPtr)
Definition: le_mrc_common.h:647
le_result_t le_mrc_GetGsmSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *rssiPtr, uint32_t *berPtr)
le_result_t le_mrc_SetSarBackoffState(uint8_t state)
le_result_t le_mrc_GetRadioBandInUse(uint32_t *bandPtr)
le_result_t le_mrc_GetNetRegState(le_mrc_NetRegState_t *statePtr)
le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan(le_mrc_RatBitMask_t ratMask)
le_result_t le_mrc_GetPciScanMccMnc(le_mrc_PlmnInformationRef_t plmnRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
struct le_mrc_JammingDetectionEventHandler * le_mrc_JammingDetectionEventHandlerRef_t
Definition: le_mrc_common.h:536
bool le_mrc_IsCellularNetworkForbidden(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_RankChangeHandlerRef_t le_mrc_AddRankChangeHandler(le_mrc_RankChangeHandlerFunc_t handlerPtr, void *contextPtr)
void le_mrc_PerformPciNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_PciNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
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)
void le_mrc_DisconnectService(void)
le_result_t le_mrc_GetCellularNetworkName(le_mrc_ScanInformationRef_t scanInformationRef, char *namePtr, size_t namePtrSize)
void le_mrc_DeleteSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_result_t le_mrc_GetRadioAccessTechInUse(le_mrc_Rat_t *ratPtr)
le_result_t le_mrc_StartJammingDetection(void)
struct le_mrc_ScanInformationList * le_mrc_ScanInformationListRef_t
Definition: le_mrc_common.h:185
le_result_t le_mrc_GetLteBandPreferences(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
uint32_t le_mrc_GetServingCellId(void)
void(* le_mrc_PacketSwitchedChangeHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_common.h:587
uint16_t le_mrc_GetNeighborCellScramblingCode(le_mrc_CellInfoRef_t ngbrCellInfoRef)
uint32_t le_mrc_GetPciScanGlobalCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
bool le_mrc_IsCellularNetworkAvailable(le_mrc_ScanInformationRef_t scanInformationRef)
le_result_t le_mrc_GetPacketSwitchedState(le_mrc_NetRegState_t *statePtr)
void(* le_mrc_CellularNetworkScanHandlerFunc_t)(le_mrc_ScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_common.h:616
le_result_t le_mrc_GetNeighborCellLteInterFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
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_result_t le_mrc_GetCellularNetworkMccMnc(le_mrc_ScanInformationRef_t scanInformationRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
uint32_t le_mrc_GetServingCellTimingAdvance(void)
struct le_mrc_NetRegStateEventHandler * le_mrc_NetRegStateEventHandlerRef_t
Definition: le_mrc_common.h:480
void(* le_mrc_NetRegRejectHandlerFunc_t)(const le_mrc_NetRegRejectInd_t *LE_NONNULL networkRejectIndPtr, void *contextPtr)
Definition: le_mrc_common.h:682
void le_mrc_RemoveNetRegRejectHandler(le_mrc_NetRegRejectHandlerRef_t handlerRef)
uint32_t le_mrc_GetNeighborCellId(le_mrc_CellInfoRef_t ngbrCellInfoRef)
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_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
struct le_mrc_PciScanInformationList * le_mrc_PciScanInformationListRef_t
Definition: le_mrc_common.h:193
le_result_t le_mrc_GetLteBandCapabilities(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
void le_mrc_PerformCellularNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
struct le_mrc_NetworkRejectHandler * le_mrc_NetworkRejectHandlerRef_t
Definition: le_mrc_common.h:520
le_result_t le_mrc_GetSarBackoffState(uint8_t *statePtr)
le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr, void *contextPtr)
uint32_t le_mrc_GetServingCellEarfcn(void)
le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo(void)
le_result_t le_mrc_SetRatPreferences(le_mrc_RatBitMask_t ratMask)
#define LE_FULL_API
Definition: le_apiFeatures.h:40
struct le_mrc_RankChangeHandler * le_mrc_RankChangeHandlerRef_t
Definition: le_mrc_common.h:496
uint16_t le_mrc_GetServingCellScramblingCode(void)
LE_FULL_API void le_mrc_SetServerDisconnectHandler(le_mrc_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_result_t le_mrc_GetRadioPower(le_onoff_t *powerPtr)
le_result_t le_mrc_SetRankChangeMonitoring(bool enable)
le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler(le_mrc_JammingDetectionHandlerFunc_t handlerPtr, void *contextPtr)
void(* le_mrc_PciNetworkScanHandlerFunc_t)(le_mrc_PciScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_common.h:632
le_result_t le_mrc_SetBandPreferences(le_mrc_BandBitMask_t bandMask)
le_result_t le_mrc_StopJammingDetection(void)
le_result_t le_mrc_GetLteEmbmsInfo(uint8_t *mcsPtr)
le_result_t le_mrc_GetRatPreferences(le_mrc_RatBitMask_t *ratMaskPtrPtr)
le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics(void)
uint16_t le_mrc_GetServingCellLteTracAreaCode(void)
void le_mrc_DeleteNeighborCellsInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_result_t le_mrc_GetNeighborCellLteIntraFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
bool le_mrc_IsCellularNetworkHome(le_mrc_ScanInformationRef_t scanInformationRef)
le_result_t le_mrc_GetBandCapabilities(le_mrc_BandBitMask_t *bandMaskPtrPtr)
struct le_mrc_CellInfo * le_mrc_CellInfoRef_t
Definition: le_mrc_common.h:233
void le_mrc_RemoveNetRegStateEventHandler(le_mrc_NetRegStateEventHandlerRef_t handlerRef)
le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler(le_mrc_NetworkRejectHandlerFunc_t handlerPtr, void *contextPtr)
struct le_mrc_RatChangeHandler * le_mrc_RatChangeHandlerRef_t
Definition: le_mrc_common.h:488
void(* le_mrc_RatChangeHandlerFunc_t)(le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_common.h:559
le_result_t le_mrc_RemovePreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
le_mrc_NetRegRejectHandlerRef_t le_mrc_AddNetRegRejectHandler(le_mrc_NetRegRejectHandlerFunc_t handlerPtr, void *contextPtr)
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_common.h:664
struct le_mrc_PreferredOperator * le_mrc_PreferredOperatorRef_t
Definition: le_mrc_common.h:217
void le_mrc_DeletePciNetworkScan(le_mrc_PciScanInformationListRef_t scanInformationListRef)
uint16_t le_mrc_GetPhysicalNeighborLteCellId(le_mrc_CellInfoRef_t ngbrCellInfoRef)
bool le_mrc_IsCellularNetworkInUse(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_Rat_t
Definition: le_mrc_common.h:280
void le_mrc_DeletePreferredOperatorsList(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_Rat_t le_mrc_GetNeighborCellRat(le_mrc_CellInfoRef_t ngbrCellInfoRef)
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)
struct le_mrc_NetRegRejectHandler * le_mrc_NetRegRejectHandlerRef_t
Definition: le_mrc_common.h:528
void le_mrc_RemoveJammingDetectionEventHandler(le_mrc_JammingDetectionEventHandlerRef_t handlerRef)
void(* le_mrc_SignalStrengthChangeHandlerFunc_t)(int32_t ss, void *contextPtr)
Definition: le_mrc_common.h:601
uint16_t le_mrc_GetPciScanCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
le_result_t le_mrc_GetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_result_t le_mrc_GetCurrentNetworkMccMnc(char *mccStr, size_t mccStrSize, char *mncStr, size_t mncStrSize)
le_result_t le_mrc_GetRegisterMode(bool *isManualPtrPtr, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
int32_t le_mrc_GetNeighborCellUmtsEcIo(le_mrc_CellInfoRef_t ngbrCellInfoRef)
void le_mrc_RemovePacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef)
void le_mrc_SetManualRegisterModeAsync(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_ManualSelectionHandlerFunc_t handlerPtr, void *contextPtr)
void le_mrc_RemoveRankChangeHandler(le_mrc_RankChangeHandlerRef_t handlerRef)
le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo(le_mrc_PciScanInformationRef_t pciScanInformationRef)
le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
struct le_mrc_ScanInformation * le_mrc_ScanInformationRef_t
Definition: le_mrc_common.h:177
le_result_t le_mrc_SetLteBandPreferences(le_mrc_LteBandBitMask_t bandMask)
le_result_t le_mrc_AddPreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_RatBitMask_t ratMask)
le_result_t le_mrc_GetCurrentNetworkName(char *nameStr, size_t nameStrSize)
struct le_mrc_PacketSwitchedChangeHandler * le_mrc_PacketSwitchedChangeHandlerRef_t
Definition: le_mrc_common.h:504
le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan(le_mrc_RatBitMask_t ratMask)
le_result_t le_mrc_GetServingCellGsmBsic(uint8_t *BSICPtr)
uint32_t le_mrc_GetNeighborCellEarfcn(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_result_t le_mrc_SetSignalStrengthIndThresholds(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold)
uint32_t le_mrc_GetNeighborCellLocAreaCode(le_mrc_CellInfoRef_t ngbrCellInfoRef)
struct le_mrc_SignalStrengthChangeHandler * le_mrc_SignalStrengthChangeHandlerRef_t
Definition: le_mrc_common.h:512
le_onoff_t
Definition: le_basics.h:85
le_result_t le_mrc_GetTdScdmaBandCapabilities(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)