rl_monitoring.c
1 /****************************************************************************************
2  * FileName : rl_monitoring.c
3  *
4  * Description : This file defines the functions required to configure monitoring reports from
5  * mmWave Device.
6  *
7  ****************************************************************************************
8  * (C) Copyright 2014, Texas Instruments Incorporated. - TI web address www.ti.com
9  *---------------------------------------------------------------------------------------
10  *
11  * Redistribution and use in source and binary forms, with or without modification,
12  * are permitted provided that the following conditions are met:
13  *
14  * Redistributions of source code must retain the above copyright notice,
15  * this list of conditions and the following disclaimer.
16  *
17  * Redistributions in binary form must reproduce the above copyright notice,
18  * this list of conditions and the following disclaimer in the documentation
19  * and/or other materials provided with the distribution.
20  *
21  * Neither the name of Texas Instruments Incorporated nor the names of its
22  * contributors may be used to endorse or promote products derived from this
23  * software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, data, OR PROFITS; OR BUSINESS
32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  */
37 
38 /*
39 ****************************************************************************************
40 * Revision History :
41 *---------------------------------------------------------------------------------------
42 * Version Date Author Defect No Description
43 *---------------------------------------------------------------------------------------
44 * 0.1.0 12May2015 Kaushal Kukkar - Initial Version
45 *
46 * 0.8.6 24Jul2017 Jitendra Gupta MMWL-30 RF/Analog Monitoring APIs
47 * Kaushal Kukkar MMWL-23 Big Endian Support
48 * Kaushal Kukkar MMWL-13 Fault Injection API
49 *
50 * 1.2.2.4 20Feb2019 Pavan Penikalapati MMWL162 Fixed comment for rlRfTxPowrMonConfig
51 ****************************************************************************************
52 */
53 
54 /******************************************************************************
55  * INCLUDE FILES
56  ******************************************************************************
57  */
58 #include <stdlib.h>
59 #include <string.h>
60 #include <ti/control/mmwavelink/mmwavelink.h>
61 #include <ti/control/mmwavelink/include/rl_driver.h>
62 #include <ti/control/mmwavelink/include/rl_monitoring.h>
63 #include <ti/control/mmwavelink/include/rl_trace.h>
64 
65 
66 /******************************************************************************
67  * GLOBAL VARIABLES/DATA-TYPES DEFINITIONS
68  ******************************************************************************
69  */
70 
71 /******************************************************************************
72  * FUNCTION DEFINITIONS
73  ******************************************************************************
74  */
75 
76 
90 /* Sub block ID: 0x01C0, ICD API: AWR_MONITOR_RF_DIG_LATENTFAULT_CONF_SB */
91 /* DesignId : MMWL_DesignId_073 */
92 /* Requirements : AUTORADAR_REQ-768 */
93 rlReturnVal_t rlRfDigMonEnableConfig(rlUInt8_t deviceMap, rlMonDigEnables_t* data)
94 {
95  rlReturnVal_t retVal;
96 
97  /* check if deviceIndex is out of defined value */
98  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
99  {
100  /* set return error code */
101  retVal = RL_RET_CODE_INVALID_INPUT;
102  }
103  else
104  {
105  /* Package the command with given data and send it to device */
106  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
107  RL_RF_DIG_MON_EN_SB, (rlUInt8_t*)data,
108  (rlUInt16_t)sizeof(rlMonDigEnables_t));
109  }
110  return retVal;
111 }
112 
124 /* Sub block ID: 0x01C1, ICD API: AWR_MONITOR_RF_DIG_PERIODIC_CONF_SB */
125 /* DesignId : MMWL_DesignId_074 */
126 /* Requirements : AUTORADAR_REQ-768 */
127 rlReturnVal_t rlRfDigMonPeriodicConfig(rlUInt8_t deviceMap, rlDigMonPeriodicConf_t* data)
128 {
129  rlReturnVal_t retVal;
130 
131  /* check if deviceIndex is out of defined value */
132  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
133  {
134  /* set return error code */
135  retVal = RL_RET_CODE_INVALID_INPUT;
136  }
137  else
138  {
139  /* Package the command with given data and send it to device */
140  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
141  RL_RF_DIG_MON_PERIODIC_CONF_SB, (rlUInt8_t*)data,
142  (rlUInt16_t)sizeof(rlDigMonPeriodicConf_t));
143  }
144  return retVal;
145 }
146 
170 /* Sub block ID: 0x01C2, ICD API: AWR_MONITOR_ANALOG_ENABLES_CONF_SB */
171 /* DesignId : MMWL_DesignId_075 */
172 /* Requirements : AUTORADAR_REQ-769, AUTORADAR_REQ-602, AUTORADAR_REQ-215 */
173 rlReturnVal_t rlRfAnaMonConfig(rlUInt8_t deviceMap, rlMonAnaEnables_t* data)
174 {
175  rlReturnVal_t retVal;
176 
177  /* check if deviceIndex is out of defined value */
178  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
179  {
180  /* set return error code */
181  retVal = RL_RET_CODE_INVALID_INPUT;
182  }
183  else
184  {
185  /* Package the command with given data and send it to device */
186  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
187  RL_RF_ANA_MON_EN_SB, (rlUInt8_t*)data,
188  (rlUInt16_t)sizeof(rlMonAnaEnables_t));
189  }
190  return retVal;
191 }
192 
214 /* Sub block ID: 0x01C3, ICD API: AWR_MONITOR_TEMPERATURE_CONF_SB */
215 /* DesignId : MMWL_DesignId_076 */
216 /* Requirements : AUTORADAR_REQ-857 */
217 rlReturnVal_t rlRfTempMonConfig(rlUInt8_t deviceMap, rlTempMonConf_t* data)
218 {
219  rlReturnVal_t retVal;
220 
221  /* check if deviceIndex is out of defined value */
222  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
223  {
224  /* set return error code */
225  retVal = RL_RET_CODE_INVALID_INPUT;
226  }
227  else
228  {
229  /* Package the command with given data and send it to device */
230  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
231  RL_RF_TEMP_MON_CONF_SB, (rlUInt8_t*)data,
232  (rlUInt16_t)sizeof(rlTempMonConf_t));
233  }
234  return retVal;
235 }
236 
256 /* Sub block ID: 0x01C4, ICD API: AWR_MONITOR_RX_GAIN_PHASE_CONF_SB */
257 /* DesignId : MMWL_DesignId_077 */
258 /* Requirements : AUTORADAR_REQ-858, AUTORADAR_REQ-1041 */
259 rlReturnVal_t rlRfRxGainPhMonConfig(rlUInt8_t deviceMap, rlRxGainPhaseMonConf_t* data)
260 {
261  rlReturnVal_t retVal;
262 
263  /* check if deviceIndex is out of defined value */
264  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
265  (RL_NULL_PTR == data))
266  {
267  /* set return error code */
268  retVal = RL_RET_CODE_INVALID_INPUT;
269  }
270  else
271  {
272  /* Package the command with given data and send it to device */
273  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
274  RL_RF_RX_GAIN_PHASE_MON_CONF_SB, (rlUInt8_t*)data,
275  (rlUInt16_t)sizeof(rlRxGainPhaseMonConf_t));
276  }
277  return retVal;
278 }
279 
301 /* Sub block ID: 0x01C5, ICD API: AWR_MONITOR_RX_NOISE_FIGURE_CONF_SB */
302 /* DesignId : MMWL_DesignId_078 */
303 /* Requirements : AUTORADAR_REQ-859*/
304 rlReturnVal_t rlRfRxNoiseMonConfig(rlUInt8_t deviceMap, rlRxNoiseMonConf_t* data)
305 {
306  rlReturnVal_t retVal;
307 
308  /* check if deviceIndex is out of defined value */
309  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
310  (RL_NULL_PTR == data))
311  {
312  /* set return error code */
313  retVal = RL_RET_CODE_INVALID_INPUT;
314  }
315  else
316  {
317  /* Package the command with given data and send it to device */
318  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
319  RL_RF_RX_NOISE_MON_CONF_SB, (rlUInt8_t*)data,
320  (rlUInt16_t)sizeof(rlRxNoiseMonConf_t));
321  }
322  return retVal;
323 }
324 
338 /* Sub block ID: 0x01C6, ICD API: AWR_MONITOR_RX_IFSTAGE_CONF_SB */
339 /* DesignId : MMWL_DesignId_079 */
340 /* Requirements : AUTORADAR_REQ-860 */
341 rlReturnVal_t rlRfRxIfStageMonConfig(rlUInt8_t deviceMap, rlRxIfStageMonConf_t* data)
342 {
343  rlReturnVal_t retVal;
344 
345  /* check if deviceIndex is out of defined value */
346  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
347  {
348  /* set return error code */
349  retVal = RL_RET_CODE_INVALID_INPUT;
350  }
351  else
352  {
353  /* Package the command with given data and send it to device */
354  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
355  RL_RF_RX_IFSTAGE_MON_CONF_SB, (rlUInt8_t*)data,
356  (rlUInt16_t)sizeof(rlRxIfStageMonConf_t));
357  }
358  return retVal;
359 }
360 
378 /* Sub block ID: 0x01C7, ICD API: AWR_MONITOR_TX0_POWER_CONF_SB */
379 /* Sub block ID: 0x01C8, ICD API: AWR_MONITOR_TX1_POWER_CONF_SB */
380 /* Sub block ID: 0x01C9, ICD API: AWR_MONITOR_TX2_POWER_CONF_SB */
381 /* DesignId : MMWL_DesignId_080 */
382 /* Requirements : AUTORADAR_REQ-861 */
383 rlReturnVal_t rlRfTxPowrMonConfig(rlUInt8_t deviceMap, rlAllTxPowMonConf_t *data)
384 {
385  rlReturnVal_t retVal;
386  /* Initialize Command and Response Sub Blocks */
387  rlDriverMsg_t inMsg;
388  rlDriverMsg_t outMsg = {0};
389  rlUInt16_t numSbc = 0U;
390 
391  /* Initialize Command and Response Sub Blocks */
392  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = {0};
393 
394  RL_LOGV_ARG0("rlRfTxPowrMonConfig starts...\n");
395 
396  /* Construct command packet */
397  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
398 
399  /* check if deviceIndex is out of defined value */
400  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
401  (RL_NULL_PTR == data))
402  {
403  retVal = RL_RET_CODE_INVALID_INPUT;
404  RL_LOGE_ARG0("rlRfTxPowrMonConfig, Invalid input \n");
405  }
406  else
407  {
408  /* check for NULL pointer */
409  if ((RL_NULL_PTR != data->tx0PowrMonCfg))
410  {
411  /* Fill in-message Payload */
412  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
413  RL_RF_TX0_POW_MON_CONF_SB,
414  &inPayloadSb[numSbc],
415  (rlUInt8_t* )data->tx0PowrMonCfg,
416  (rlUInt16_t)sizeof(rlTxPowMonConf_t));
417  numSbc++;
418  }
419  /* check for NULL pointer */
420  if ((RL_NULL_PTR != data->tx1PowrMonCfg))
421  {
422  /* Fill in-message Payload */
423  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
424  RL_RF_TX1_POW_MON_CONF_SB,
425  &inPayloadSb[numSbc],
426  (rlUInt8_t* )data->tx1PowrMonCfg,
427  (rlUInt16_t)sizeof(rlTxPowMonConf_t));
428  numSbc++;
429  }
430  /* check for NULL pointer */
431  if ((RL_NULL_PTR != data->tx2PowrMonCfg))
432  {
433  /* Fill in-message Payload */
434  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
435  RL_RF_TX2_POW_MON_CONF_SB,
436  &inPayloadSb[numSbc],
437  (rlUInt8_t* )data->tx2PowrMonCfg,
438  (rlUInt16_t)sizeof(rlTxPowMonConf_t));
439  numSbc++;
440  }
441 
442  if (numSbc > 0U)
443  {
444  /* setting num of sub-block to inMsg */
445  inMsg.opcode.nsbc = numSbc;
446 
447  /* Send Command to mmWave Radar Device */
448  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
449  }
450  else
451  {
452  retVal = RL_RET_CODE_INVALID_INPUT;
453  RL_LOGE_ARG0("sub block is NULL\n");
454  }
455  }
456 
457  return retVal;
458 }
459 
473 /* Sub block ID: 0x01CA, ICD API: AWR_MONITOR_TX0_BALLBREAK_CONF_SB */
474 /* Sub block ID: 0x01CB, ICD API: AWR_MONITOR_TX1_BALLBREAK_CONF_SB */
475 /* Sub block ID: 0x01CC, ICD API: AWR_MONITOR_TX2_BALLBREAK_CONF_SB */
476 /* DesignId : MMWL_DesignId_081 */
477 /* Requirements : AUTORADAR_REQ-862 */
478 rlReturnVal_t rlRfTxBallbreakMonConfig(rlUInt8_t deviceMap, rlAllTxBallBreakMonCfg_t* data)
479 {
480  rlReturnVal_t retVal;
481  /* Initialize Command and Response Sub Blocks */
482  rlDriverMsg_t inMsg;
483  rlDriverMsg_t outMsg = {0};
484  rlUInt16_t numSbc = 0U;
485 
486  /* Initialize Command and Response Sub Blocks */
487  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = {0};
488 
489  RL_LOGV_ARG0("rlRfTxBallBreakMonConfig starts...\n");
490 
491  /* Construct command packet */
492  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
493 
494  /* check if deviceIndex is out of defined value */
495  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
496  (RL_NULL_PTR == data) )
497  {
498  retVal = RL_RET_CODE_INVALID_INPUT;
499  RL_LOGE_ARG0("rlRfTxBallBreakMonConfig, Invalid input \n");
500  }
501  else
502  {
503  /* check for NULL pointer */
504  if ((RL_NULL_PTR != data->tx0BallBrkMonCfg))
505  {
506  /* Fill in-message Payload */
507  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
508  RL_RF_TX0_BALLBREAK_MON_CONF_SB,
509  &inPayloadSb[numSbc],
510  (rlUInt8_t* )data->tx0BallBrkMonCfg,
511  (rlUInt16_t)sizeof(rlTxBallbreakMonConf_t));
512  numSbc++;
513  }
514  /* check for NULL pointer */
515  if ((RL_NULL_PTR != data->tx1BallBrkMonCfg))
516  {
517  /* Fill in-message Payload */
518  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
519  RL_RF_TX1_BALLBREAK_MON_CONF_SB,
520  &inPayloadSb[numSbc],
521  (rlUInt8_t* )data->tx1BallBrkMonCfg,
522  (rlUInt16_t)sizeof(rlTxBallbreakMonConf_t));
523  numSbc++;
524  }
525  /* check for NULL pointer */
526  if ((RL_NULL_PTR != data->tx2BallBrkMonCfg))
527  {
528  /* Fill in-message Payload */
529  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
530  RL_RF_TX2_BALLBREAK_MON_CONF_SB,
531  &inPayloadSb[numSbc],
532  (rlUInt8_t* )data->tx2BallBrkMonCfg,
533  (rlUInt16_t)sizeof(rlTxBallbreakMonConf_t));
534  numSbc++;
535  }
536 
537  if (numSbc > 0U)
538  {
539  /* setting num of sub-block to inMsg */
540  inMsg.opcode.nsbc = numSbc;
541 
542  /* Send Command to mmWave Radar Device */
543  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
544  }
545  else
546  {
547  retVal = RL_RET_CODE_INVALID_INPUT;
548  RL_LOGE_ARG0("sub block is NULL\n");
549  }
550  }
551 
552  return retVal;
553 
554 }
555 
578 /* Sub block ID: 0x01CD, ICD API: AWR_MONITOR_TX_GAIN_PHASE_MISMATCH_CONF_SB */
579 /* DesignId : MMWL_DesignId_082 */
580 /* Requirements : AUTORADAR_REQ-863 */
581 rlReturnVal_t rlRfTxGainPhaseMismatchMonConfig(rlUInt8_t deviceMap,
583 {
584  rlReturnVal_t retVal;
585 
586  /* check if deviceIndex is out of defined value */
587  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
588  {
589  /* set return error code */
590  retVal = RL_RET_CODE_INVALID_INPUT;
591  }
592  else
593  {
594  /* Package the command with given data and send it to device */
595  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
596  RL_RF_TX_GAIN_PHASE_MISMATCH_MON_CONF_SB,
597  (rlUInt8_t*)data,
598  (rlUInt16_t)sizeof(rlTxGainPhaseMismatchMonConf_t));
599  }
600  return retVal;
601 }
602 
640 /* Sub block ID: 0x01D1, ICD API: AWR_MONITOR_SYNTHESIZER_FREQUENCY_CONF_SB */
641 /* DesignId : MMWL_DesignId_084 */
642 /* Requirements : AUTORADAR_REQ-865, AUTORADAR_REQ-1052 */
643 rlReturnVal_t rlRfSynthFreqMonConfig(rlUInt8_t deviceMap, rlSynthFreqMonConf_t* data)
644 {
645  rlReturnVal_t retVal;
646 
647  /* check if deviceIndex is out of defined value */
648  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
649  {
650  /* set return error code */
651  retVal = RL_RET_CODE_INVALID_INPUT;
652  }
653  else
654  {
655  /* Package the command with given data and send it to device */
656  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
657  RL_RF_SYNTH_FREQ_MON_CONF_SB, (rlUInt8_t*)data,
658  (rlUInt16_t)sizeof(rlSynthFreqMonConf_t));
659  }
660  return retVal;
661 }
662 
677 /* Sub block ID: 0x01D2, ICD API: AWR_MONITORING_EXTERNAL_ANALOG_SIGNALS_CONF_SB */
678 /* DesignId : MMWL_DesignId_085 */
679 /* Requirements : AUTORADAR_REQ-866 */
680 rlReturnVal_t rlRfExtAnaSignalsMonConfig(rlUInt8_t deviceMap,
682 {
683  rlReturnVal_t retVal;
684 
685  /* check if deviceIndex is out of defined value */
686  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
687  (RL_NULL_PTR == data))
688  {
689  /* set return error code */
690  retVal = RL_RET_CODE_INVALID_INPUT;
691  }
692  else
693  {
694  /* Package the command with given data and send it to device */
695  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
696  RL_RF_EXT_ANA_SIGNALS_MON_CONF_SB, (rlUInt8_t*)data,
697  (rlUInt16_t)sizeof(rlExtAnaSignalsMonConf_t));
698  }
699  return retVal;
700 }
701 
717 /* Sub block ID: 0x01D3, ICD API: AWR_MONITOR_TX0_INTERNAL_ANALOG_SIGNALS_CONF_SB */
718 /* Sub block ID: 0x01D4, ICD API: AWR_MONITOR_TX1_INTERNAL_ANALOG_SIGNALS_CONF_SB */
719 /* Sub block ID: 0x01D5, ICD API: AWR_MONITOR_TX2_INTERNAL_ANALOG_SIGNALS_CONF_SB */
720 /* DesignId : MMWL_DesignId_086 */
721 /* Requirements : AUTORADAR_REQ-867, AUTORADAR_REQ-1062 */
722 rlReturnVal_t rlRfTxIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
724 {
725  rlReturnVal_t retVal;
726  /* Initialize Command and Response Sub Blocks */
727  rlDriverMsg_t inMsg;
728  rlDriverMsg_t outMsg = {0};
729  rlUInt16_t numSbc = 0U;
730 
731  /* Initialize Command and Response Sub Blocks */
732  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = {0};
733 
734  RL_LOGV_ARG0("rlRfTxIntAnaSignalsMonConfig starts...\n");
735 
736  /* Construct command packet */
737  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
738 
739  /* check if deviceIndex is out of defined value */
740  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
741  (RL_NULL_PTR == data) )
742  {
743  retVal = RL_RET_CODE_INVALID_INPUT;
744  RL_LOGE_ARG0("rlRfTxIntAnaSignalsMonConfig, Invalid input \n");
745  }
746  else
747  {
748  /* check for NULL pointer */
749  if ((RL_NULL_PTR != data->tx0IntAnaSgnlMonCfg))
750  {
751  /* Fill in-message Payload */
752  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
753  RL_RF_TX0_INT_ANA_SIGNALS_MON_CONF_SB,
754  &inPayloadSb[numSbc],
755  (rlUInt8_t* )data->tx0IntAnaSgnlMonCfg,
756  (rlUInt16_t)sizeof(rlTxIntAnaSignalsMonConf_t));
757  numSbc++;
758  }
759  /* check for NULL pointer */
760  if ((RL_NULL_PTR != data->tx1IntAnaSgnlMonCfg))
761  {
762  /* Fill in-message Payload */
763  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
764  RL_RF_TX1_INT_ANA_SIGNALS_MON_CONF_SB,
765  &inPayloadSb[numSbc],
766  (rlUInt8_t* )data->tx1IntAnaSgnlMonCfg,
767  (rlUInt16_t)sizeof(rlTxIntAnaSignalsMonConf_t));
768  numSbc++;
769  }
770  /* check for NULL pointer */
771  if ((RL_NULL_PTR != data->tx2IntAnaSgnlMonCfg))
772  {
773  /* Fill in-message Payload */
774  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
775  RL_RF_TX2_INT_ANA_SIGNALS_MON_CONF_SB,
776  &inPayloadSb[numSbc],
777  (rlUInt8_t* )data->tx2IntAnaSgnlMonCfg,
778  (rlUInt16_t)sizeof(rlTxIntAnaSignalsMonConf_t));
779  numSbc++;
780  }
781 
782  if (numSbc > 0U)
783  {
784  /* setting num of sub-block to inMsg */
785  inMsg.opcode.nsbc = numSbc;
786 
787  /* Send Command to mmWave Radar Device */
788  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
789  }
790  else
791  {
792  retVal = RL_RET_CODE_INVALID_INPUT;
793  RL_LOGE_ARG0("sub block is NULL\n");
794  }
795  }
796 
797  return retVal;
798 }
799 
814 /* Sub block ID: 0x01D6, ICD API: AWR_MONITOR_RX_INTERNAL_ANALOG_SIGNALS_CONF_SB */
815 /* DesignId : MMWL_DesignId_087 */
816 /* Requirements : AUTORADAR_REQ-868 */
817 rlReturnVal_t rlRfRxIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
818  rlRxIntAnaSignalsMonConf_t* data)
819 {
820  rlReturnVal_t retVal;
821 
822  /* check if deviceIndex is out of defined value */
823  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
824  (RL_NULL_PTR == data))
825  {
826  /* set return error code */
827  retVal = RL_RET_CODE_INVALID_INPUT;
828  }
829  else
830  {
831  /* Package the command with given data and send it to device */
832  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
833  RL_RF_RX_INT_ANA_SIGNALS_MON_CONF_SB, (rlUInt8_t*)data,
834  (rlUInt16_t)sizeof(rlRxIntAnaSignalsMonConf_t));
835  }
836  return retVal;
837 }
838 
857 /* Sub block ID: 0x01D7, ICD API: AWR_MONITOR_PMCLKLO_INTERNAL_ANALOG_SIGNALS_CONF_SB */
858 /* DesignId : MMWL_DesignId_088 */
859 /* Requirements : AUTORADAR_REQ-869 */
860 rlReturnVal_t rlRfPmClkLoIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
862 {
863  rlReturnVal_t retVal;
864 
865  /* check if deviceIndex is out of defined value */
866  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
867  (RL_NULL_PTR == data))
868  {
869  /* set return error code */
870  retVal = RL_RET_CODE_INVALID_INPUT;
871  }
872  else
873  {
874  /* Package the command with given data and send it to device */
875  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
876  RL_RF_PMCLKLO_INT_ANA_SIGNALS_MON_CONF_SB,
877  (rlUInt8_t*)data,
878  (rlUInt16_t)sizeof(rlPmClkLoIntAnaSignalsMonConf_t));
879  }
880  return retVal;
881 }
882 
897 /* Sub block ID: 0x01D8, ICD API: AWR_MONITOR_GPADC_INTERNAL_ANALOG_SIGNALS_CONF_SB */
898 /* DesignId : MMWL_DesignId_089 */
899 /* Requirements : AUTORADAR_REQ-870 */
900 rlReturnVal_t rlRfGpadcIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
902 {
903  rlReturnVal_t retVal;
904 
905  /* check if deviceIndex is out of defined value */
906  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
907  (RL_NULL_PTR == data))
908  {
909  /* set return error code */
910  retVal = RL_RET_CODE_INVALID_INPUT;
911  }
912  else
913  {
914  /* Package the command with given data and send it to device */
915  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
916  RL_RF_GPADC_INT_ANA_SIGNALS_MON_CONF_SB,
917  (rlUInt8_t*)data,
918  (rlUInt16_t)sizeof(rlGpadcIntAnaSignalsMonConf_t));
919  }
920  return retVal;
921 }
922 
937 /* Sub block ID: 0x01D9, ICD API: AWR_MONITOR_PLL_CONTROL_VOLTAGE_SIGNALS_CONF_SB */
938 /* DesignId : MMWL_DesignId_090 */
939 /* Requirements : AUTORADAR_REQ-871 */
940 rlReturnVal_t rlRfPllContrlVoltMonConfig(rlUInt8_t deviceMap,
942 {
943  rlReturnVal_t retVal;
944 
945  /* check if deviceIndex is out of defined value */
946  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
947  (RL_NULL_PTR == data))
948  {
949  /* set return error code */
950  retVal = RL_RET_CODE_INVALID_INPUT;
951  }
952  else
953  {
954  /* Package the command with given data and send it to device */
955  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
956  RL_RF_PLL_CONTROL_VOLT_MON_CONF_SB,
957  (rlUInt8_t*)data,
958  (rlUInt16_t)sizeof(rlPllContrVoltMonConf_t));
959  }
960  return retVal;
961 }
962 
976 /* Sub block ID: 0x01DA, ICD API: AWR_MONITOR_DUAL_CLOCK_COMP_CONF_SB */
977 /* DesignId : MMWL_DesignId_091 */
978 /* Requirements : AUTORADAR_REQ-872 */
979 rlReturnVal_t rlRfDualClkCompMonConfig(rlUInt8_t deviceMap,
981 {
982  rlReturnVal_t retVal;
983 
984  /* check if deviceIndex is out of defined value */
985  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
986  (RL_NULL_PTR == data))
987  {
988  /* set return error code */
989  retVal = RL_RET_CODE_INVALID_INPUT;
990  }
991  else
992  {
993  /* Package the command with given data and send it to device */
994  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
995  RL_RF_DUAL_CLOCK_COMP_MON_CONF_SB,
996  (rlUInt8_t*)data,
997  (rlUInt16_t)sizeof(rlDualClkCompMonConf_t));
998  }
999  return retVal;
1000 }
1001 
1025 /* Sub block ID: 0x01DB, ICD API: AWR_MONITOR_RX_SATURATION_DETECTOR_CONF_SB */
1026 /* DesignId : MMWL_DesignId_092 */
1027 /* Requirements : AUTORADAR_REQ-873 */
1028 rlReturnVal_t rlRfRxIfSatMonConfig(rlUInt8_t deviceMap,
1029  rlRxSatMonConf_t* data)
1030 {
1031  rlReturnVal_t retVal;
1032 
1033  /* check if deviceIndex is out of defined value */
1034  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1035  (RL_NULL_PTR == data))
1036  {
1037  /* set return error code */
1038  retVal = RL_RET_CODE_INVALID_INPUT;
1039  }
1040  else
1041  {
1042  /* Package the command with given data and send it to device */
1043  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1044  RL_RF_RX_SATURATION_MON_CONF_SB,
1045  (rlUInt8_t*)data,
1046  (rlUInt16_t)sizeof(rlRxSatMonConf_t));
1047  }
1048  return retVal;
1049 }
1050 
1075 /* Sub block ID: 0x01DC, ICD API: AWR_MONITOR_SIG_IMG_MONITOR_CONF_SB */
1076 /* DesignId : MMWL_DesignId_093 */
1077 /* Requirements : AUTORADAR_REQ-874 */
1078 rlReturnVal_t rlRfRxSigImgMonConfig(rlUInt8_t deviceMap,
1079  rlSigImgMonConf_t* data)
1080 {
1081  rlReturnVal_t retVal;
1082 
1083  /* check if deviceIndex is out of defined value */
1084  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1085  (RL_NULL_PTR == data))
1086  {
1087  /* set return error code */
1088  retVal = RL_RET_CODE_INVALID_INPUT;
1089  }
1090  else
1091  {
1092  /* Package the command with given data and send it to device */
1093  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1094  RL_RF_RX_SIGIMG_MON_CONF_SB,
1095  (rlUInt8_t*)data,
1096  (rlUInt16_t)sizeof(rlSigImgMonConf_t));
1097  }
1098  return retVal;
1099 }
1100 
1115 /* Sub block ID: 0x01DD, ICD API: AWR_MONITOR_RX_MIXER_IN_POWER_CONF_SB */
1116 /* DesignId : MMWL_DesignId_094 */
1117 /* Requirements : AUTORADAR_REQ-875 */
1118 rlReturnVal_t rlRfRxMixerInPwrConfig(rlUInt8_t deviceMap,
1119  rlRxMixInPwrMonConf_t* data)
1120 {
1121  rlReturnVal_t retVal;
1122 
1123  /* check if deviceIndex is out of defined value */
1124  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1125  (RL_NULL_PTR == data))
1126  {
1127  /* set return error code */
1128  retVal = RL_RET_CODE_INVALID_INPUT;
1129  }
1130  else
1131  {
1132  /* Package the command with given data and send it to device */
1133  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1134  RL_RF_RX_MIXER_IN_POWR_CONF_SB,
1135  (rlUInt8_t*)data,
1136  (rlUInt16_t)sizeof(rlRxMixInPwrMonConf_t));
1137  }
1138  return retVal;
1139 }
1140 
1161 /* Sub block ID: 0x01DF, ICD API: AWR_ANALOG_FAULT_INJECTION_CONF_SB */
1162 /* DesignId : MMWL_DesignId_095 */
1163 /* Requirements : AUTORADAR_REQ-876 */
1164 rlReturnVal_t rlRfAnaFaultInjConfig(rlUInt8_t deviceMap,
1165  rlAnaFaultInj_t* data)
1166 {
1167  rlReturnVal_t retVal;
1168 
1169  /* check if deviceIndex is out of defined value */
1170  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1171  (RL_NULL_PTR == data))
1172  {
1173  /* set return error code */
1174  retVal = RL_RET_CODE_INVALID_INPUT;
1175  }
1176  else
1177  {
1178  /* Package the command with given data and send it to device */
1179  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1180  RL_RF_FAULT_INJECTION_CONF_SB,
1181  (rlUInt8_t*)data,
1182  (rlUInt16_t)sizeof(rlAnaFaultInj_t));
1183  }
1184  return retVal;
1185 }
1186 
1215 /* Sub block ID: 0x01CE, ICD API: AWR_MONITOR_TX0_PHASE_SHIFTER_CONF_SB */
1216 /* Sub block ID: 0x01CF, ICD API: AWR_MONITOR_TX1_PHASE_SHIFTER_CONF_SB */
1217 /* Sub block ID: 0x01D0, ICD API: AWR_MONITOR_TX2_PHASE_SHIFTER_CONF_SB */
1218 /* DesignId : MMWL_DesignId_083 */
1219 /* Requirements : AUTORADAR_REQ-1066, AUTORADAR_REQ-864 */
1220 rlReturnVal_t rlRfTxPhShiftMonConfig(rlUInt8_t deviceMap, rlAllTxPhShiftMonConf_t* data)
1221 {
1222  rlReturnVal_t retVal;
1223  /* Initialize Command and Response Sub Blocks */
1224  rlDriverMsg_t inMsg;
1225  rlDriverMsg_t outMsg = { 0 };
1226  rlUInt16_t numSbc = 0U;
1227 
1228  /* Initialize Command and Response Sub Blocks */
1229  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = { 0 };
1230 
1231  RL_LOGV_ARG0("rlRfTxPhShiftMonConfig starts...\n");
1232 
1233  /* Construct command packet */
1234  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
1235 
1236  /* check if deviceIndex is out of defined value */
1237  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
1238  (RL_NULL_PTR == data))
1239  {
1240  retVal = RL_RET_CODE_INVALID_INPUT;
1241  RL_LOGE_ARG0("rlRfTxPhShiftMonConfig, Invalid input \n");
1242  }
1243  else
1244  {
1245  /* check for NULL pointer */
1246  if ((RL_NULL_PTR != data->tx0PhShiftMonCfg))
1247  {
1248  /* Fill in-message Payload */
1249  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
1250  RL_RF_TX0_PH_SHIFT_MON_CONF_SB,
1251  &inPayloadSb[numSbc],
1252  (rlUInt8_t*)data->tx0PhShiftMonCfg,
1253  (rlUInt16_t)sizeof(rlTxPhShiftMonConf_t));
1254  numSbc++;
1255  }
1256  /* check for NULL pointer */
1257  if ((RL_NULL_PTR != data->tx1PhShiftMonCfg))
1258  {
1259  /* Fill in-message Payload */
1260  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
1261  RL_RF_TX1_PH_SHIFT_MON_CONF_SB,
1262  &inPayloadSb[numSbc],
1263  (rlUInt8_t*)data->tx1PhShiftMonCfg,
1264  (rlUInt16_t)sizeof(rlTxPhShiftMonConf_t));
1265  numSbc++;
1266  }
1267  /* check for NULL pointer */
1268  if ((RL_NULL_PTR != data->tx2PhShiftMonCfg))
1269  {
1270  /* Fill in-message Payload */
1271  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
1272  RL_RF_TX2_PH_SHIFT_MON_CONF_SB,
1273  &inPayloadSb[numSbc],
1274  (rlUInt8_t*)data->tx2PhShiftMonCfg,
1275  (rlUInt16_t)sizeof(rlTxPhShiftMonConf_t));
1276  numSbc++;
1277  }
1278 
1279  if (numSbc > 0U)
1280  {
1281  /* setting num of sub-block to inMsg */
1282  inMsg.opcode.nsbc = numSbc;
1283 
1284  /* Send Command to mmWave Radar Device */
1285  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
1286  }
1287  else
1288  {
1289  retVal = RL_RET_CODE_INVALID_INPUT;
1290  RL_LOGE_ARG0("sub block is NULL\n");
1291  }
1292  }
1293 
1294  return retVal;
1295 }
1296 
1297 /*
1298  * END OF rl_monitoring.c FILE
1299  */
TX power monitoring configuration.
Internal signals for DCC based clock monitoring configuration.
Signal and image band energy monitoring configuration.
External analog signals monitoring configuration.
RX saturation monitoring configuration.
rlReturnVal_t rlRfTxBallbreakMonConfig(rlUInt8_t deviceMap, rlAllTxBallBreakMonCfg_t *data)
Sets information related to TX ball break detection.
rlReturnVal_t rlRfAnaMonConfig(rlUInt8_t deviceMap, rlMonAnaEnables_t *data)
This function contains the consolidated configuration of all analog monitoring. The enabled monitorin...
rlTxPhShiftMonConf_t * tx2PhShiftMonCfg
Tx-2 Phase shifter monitoring config.
Digital monitoring latent fault reporting configuration.
rlReturnVal_t rlRfRxGainPhMonConfig(rlUInt8_t deviceMap, rlRxGainPhaseMonConf_t *data)
This API is to set RX gain and phase monitoring config to device.
rlReturnVal_t rlRfRxSigImgMonConfig(rlUInt8_t deviceMap, rlSigImgMonConf_t *data)
Sets information related to signal and image band energy.
rlTxBallbreakMonConf_t * tx0BallBrkMonCfg
Tx ballbreak monitoring config for Tx0.
Internal signals for PLL control voltage monitoring configuration.
void rlDriverConstructInMsg(rlUInt16_t msgId, rlDriverMsg_t *inMsg, rlPayloadSb_t *payloadPtr)
: Construct command packet (inMsg) based on given message-ID and payload
Definition: rl_driver.c:3033
rlReturnVal_t rlRfRxIfStageMonConfig(rlUInt8_t deviceMap, rlRxIfStageMonConf_t *data)
Sets information related to RX IF filter attenuation monitoring.
rlReturnVal_t rlRfTxPhShiftMonConfig(rlUInt8_t deviceMap, rlAllTxPhShiftMonConf_t *data)
Sets information related to TX Phase shifter monitoring.
rlTxBallbreakMonConf_t * tx1BallBrkMonCfg
Tx ballbreak monitoring config for Tx1.
rlUInt16_t nsbc
Number of Sub Blocks in Payload.
Definition: rl_driver.h:349
rlReturnVal_t rlRfSynthFreqMonConfig(rlUInt8_t deviceMap, rlSynthFreqMonConf_t *data)
Sets information related to synthesizer frequency.
rlReturnVal_t rlRfDigMonEnableConfig(rlUInt8_t deviceMap, rlMonDigEnables_t *data)
Sets the consolidated configuration of all digital monitoring.
Definition: rl_monitoring.c:93
rlReturnVal_t rlRfAnaFaultInjConfig(rlUInt8_t deviceMap, rlAnaFaultInj_t *data)
Sets information related to RF fault injection.
TX Phase shifter monitoring configuration.
TX power monitoring configuration.
RX noise monitoring configuration.
RX IF stage monitoring configuration.
rlTxIntAnaSignalsMonConf_t * tx2IntAnaSgnlMonCfg
Internal signals in the Tx-2 path monitoring config.
TX ballbreak monitoring configuration.
rlReturnVal_t rlRfPllContrlVoltMonConfig(rlUInt8_t deviceMap, rlPllContrVoltMonConf_t *data)
Sets information related to APLL and Synthesizer's control voltage signals monitoring.
Internal signals in the TX path monitoring configuration.
rlReturnVal_t rlRfRxIfSatMonConfig(rlUInt8_t deviceMap, rlRxSatMonConf_t *data)
Sets information related to RX saturation detector monitoring.
rlTxPowMonConf_t * tx1PowrMonCfg
Power Monitoring Configuration for Tx1.
rlReturnVal_t rlRfTempMonConfig(rlUInt8_t deviceMap, rlTempMonConf_t *data)
This API configure the on chip temperature monitors and report the soft results from the monitor....
TX gain and phase mismatch monitoring configuration.
rlTxPhShiftMonConf_t * tx1PhShiftMonCfg
Tx-1 Phase shifter monitoring config.
RHCP Payload Structure.
Definition: rl_driver.h:161
rlReturnVal_t rlDriverCmdInvoke(rlUInt8_t deviceMap, rlDriverMsg_t inMsg, rlDriverMsg_t *outMsg)
Invokes a command to mmwave radar Device. Implements mmwave radar Host Communication Protocol(RHCP)
Definition: rl_driver.c:2739
rlReturnVal_t rlRfGpadcIntAnaSignalsMonConfig(rlUInt8_t deviceMap, rlGpadcIntAnaSignalsMonConf_t *data)
Sets information related to GPADC Internal Analog Signals monitoring.
rlReturnVal_t rlRfDigMonPeriodicConfig(rlUInt8_t deviceMap, rlDigMonPeriodicConf_t *data)
Sets the consolidated configuration.
mmwave radar Driver Payload
Definition: rl_driver.h:355
TX ballbreak monitoring configuration.
rlReturnVal_t rlRfExtAnaSignalsMonConfig(rlUInt8_t deviceMap, rlExtAnaSignalsMonConf_t *data)
Sets information related to external DC signals monitoring.
Synthesizer frequency monitoring configuration.
Digital monitoring configuration.
Definition: rl_monitoring.h:72
rlTxIntAnaSignalsMonConf_t * tx1IntAnaSgnlMonCfg
Internal signals in the Tx-1 path monitoring config.
rlReturnVal_t rlRfPmClkLoIntAnaSignalsMonConfig(rlUInt8_t deviceMap, rlPmClkLoIntAnaSignalsMonConf_t *data)
Sets information related to Power Management, Clock generation and LO distribution.
Internal signals for GPADC monitoring configuration.
void rlDriverFillPayload(rlUInt16_t msgId, rlUInt16_t sbcID, rlPayloadSb_t *payloadPtr, rlUInt8_t *data, rlUInt16_t inLen)
: Fill payload based on given message-ID, sub-block ID and data.
Definition: rl_driver.c:3099
TX Phase shifter monitoring configuration.
rlTxIntAnaSignalsMonConf_t * tx0IntAnaSgnlMonCfg
Internal signals in the Tx-0 path monitoring config.
RX mixer input power monitoring configuration.
rlReturnVal_t rlRfTxIntAnaSignalsMonConfig(rlUInt8_t deviceMap, rlAllTxIntAnaSignalsMonConf_t *data)
Sets information related to TX Internal Analog Signals monitoring.
rlReturnVal_t rlRfRxNoiseMonConfig(rlUInt8_t deviceMap, rlRxNoiseMonConf_t *data)
Sets information related to RX noise monitoring.
rlTxBallbreakMonConf_t * tx2BallBrkMonCfg
Tx ballbreak monitoring config for Tx2.
Analog monitoring configuration.
rlTxPowMonConf_t * tx2PowrMonCfg
Power Monitoring Configuration for Tx2.
rlReturnVal_t rlRfRxIntAnaSignalsMonConfig(rlUInt8_t deviceMap, rlRxIntAnaSignalsMonConf_t *data)
Sets information related to RX Internal Analog Signals monitoring.
Temperature sensor monitoring configuration.
Internal signals in the TX path monitoring configuration.
Internal signals for PM, CLK and LO monitoring configuration.
rlReturnVal_t rlRfDualClkCompMonConfig(rlUInt8_t deviceMap, rlDualClkCompMonConf_t *data)
Sets information related to the DCC based clock frequency monitoring.
rlTxPowMonConf_t * tx0PowrMonCfg
Power Monitoring Configuration for Tx0.
rlTxPhShiftMonConf_t * tx0PhShiftMonCfg
Tx-0 Phase shifter monitoring config.
rlReturnVal_t rlRfTxGainPhaseMismatchMonConfig(rlUInt8_t deviceMap, rlTxGainPhaseMismatchMonConf_t *data)
Sets information related to TX gain and phase mismatch monitoring.
RX gain and phase monitoring configuration.
rlReturnVal_t rlRfTxPowrMonConfig(rlUInt8_t deviceMap, rlAllTxPowMonConf_t *data)
Sets information related to TX power monitoring.
rlReturnVal_t rlDriverExecuteSetApi(rlUInt8_t deviceMap, rlUInt16_t msgId, rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
: Construct set message and invoke command.
Definition: rl_driver.c:3188
rlReturnVal_t rlDriverIsDeviceMapValid(rlUInt8_t deviceMap)
Checks if given deviecMap is valid wrt to global DeviceMap set to mmWaveLink.
Definition: rl_driver.c:2394

Copyright 2020, Texas Instruments Incorporated