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 
171 /* Sub block ID: 0x01C2, ICD API: AWR_MONITOR_ANALOG_ENABLES_CONF_SB */
172 /* DesignId : MMWL_DesignId_075 */
173 /* Requirements : AUTORADAR_REQ-769, AUTORADAR_REQ-602, AUTORADAR_REQ-215 */
174 rlReturnVal_t rlRfAnaMonConfig(rlUInt8_t deviceMap, rlMonAnaEnables_t* data)
175 {
176  rlReturnVal_t retVal;
177 
178  /* check if deviceIndex is out of defined value */
179  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
180  {
181  /* set return error code */
182  retVal = RL_RET_CODE_INVALID_INPUT;
183  }
184  else
185  {
186  /* Package the command with given data and send it to device */
187  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
188  RL_RF_ANA_MON_EN_SB, (rlUInt8_t*)data,
189  (rlUInt16_t)sizeof(rlMonAnaEnables_t));
190  }
191  return retVal;
192 }
193 
215 /* Sub block ID: 0x01C3, ICD API: AWR_MONITOR_TEMPERATURE_CONF_SB */
216 /* DesignId : MMWL_DesignId_076 */
217 /* Requirements : AUTORADAR_REQ-857 */
218 rlReturnVal_t rlRfTempMonConfig(rlUInt8_t deviceMap, rlTempMonConf_t* data)
219 {
220  rlReturnVal_t retVal;
221 
222  /* check if deviceIndex is out of defined value */
223  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
224  {
225  /* set return error code */
226  retVal = RL_RET_CODE_INVALID_INPUT;
227  }
228  else
229  {
230  /* Package the command with given data and send it to device */
231  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
232  RL_RF_TEMP_MON_CONF_SB, (rlUInt8_t*)data,
233  (rlUInt16_t)sizeof(rlTempMonConf_t));
234  }
235  return retVal;
236 }
237 
257 /* Sub block ID: 0x01C4, ICD API: AWR_MONITOR_RX_GAIN_PHASE_CONF_SB */
258 /* DesignId : MMWL_DesignId_077 */
259 /* Requirements : AUTORADAR_REQ-858, AUTORADAR_REQ-1041 */
260 rlReturnVal_t rlRfRxGainPhMonConfig(rlUInt8_t deviceMap, rlRxGainPhaseMonConf_t* data)
261 {
262  rlReturnVal_t retVal;
263 
264  /* check if deviceIndex is out of defined value */
265  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
266  (RL_NULL_PTR == data))
267  {
268  /* set return error code */
269  retVal = RL_RET_CODE_INVALID_INPUT;
270  }
271  else
272  {
273  /* Package the command with given data and send it to device */
274  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
275  RL_RF_RX_GAIN_PHASE_MON_CONF_SB, (rlUInt8_t*)data,
276  (rlUInt16_t)sizeof(rlRxGainPhaseMonConf_t));
277  }
278  return retVal;
279 }
280 
302 /* Sub block ID: 0x01C5, ICD API: AWR_MONITOR_RX_NOISE_FIGURE_CONF_SB */
303 /* DesignId : MMWL_DesignId_078 */
304 /* Requirements : AUTORADAR_REQ-859*/
305 rlReturnVal_t rlRfRxNoiseMonConfig(rlUInt8_t deviceMap, rlRxNoiseMonConf_t* data)
306 {
307  rlReturnVal_t retVal;
308 
309  /* check if deviceIndex is out of defined value */
310  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
311  (RL_NULL_PTR == data))
312  {
313  /* set return error code */
314  retVal = RL_RET_CODE_INVALID_INPUT;
315  }
316  else
317  {
318  /* Package the command with given data and send it to device */
319  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
320  RL_RF_RX_NOISE_MON_CONF_SB, (rlUInt8_t*)data,
321  (rlUInt16_t)sizeof(rlRxNoiseMonConf_t));
322  }
323  return retVal;
324 }
325 
339 /* Sub block ID: 0x01C6, ICD API: AWR_MONITOR_RX_IFSTAGE_CONF_SB */
340 /* DesignId : MMWL_DesignId_079 */
341 /* Requirements : AUTORADAR_REQ-860 */
342 rlReturnVal_t rlRfRxIfStageMonConfig(rlUInt8_t deviceMap, rlRxIfStageMonConf_t* data)
343 {
344  rlReturnVal_t retVal;
345 
346  /* check if deviceIndex is out of defined value */
347  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
348  {
349  /* set return error code */
350  retVal = RL_RET_CODE_INVALID_INPUT;
351  }
352  else
353  {
354  /* Package the command with given data and send it to device */
355  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
356  RL_RF_RX_IFSTAGE_MON_CONF_SB, (rlUInt8_t*)data,
357  (rlUInt16_t)sizeof(rlRxIfStageMonConf_t));
358  }
359  return retVal;
360 }
361 
379 /* Sub block ID: 0x01C7, ICD API: AWR_MONITOR_TX0_POWER_CONF_SB */
380 /* Sub block ID: 0x01C8, ICD API: AWR_MONITOR_TX1_POWER_CONF_SB */
381 /* Sub block ID: 0x01C9, ICD API: AWR_MONITOR_TX2_POWER_CONF_SB */
382 /* DesignId : MMWL_DesignId_080 */
383 /* Requirements : AUTORADAR_REQ-861 */
384 rlReturnVal_t rlRfTxPowrMonConfig(rlUInt8_t deviceMap, rlAllTxPowMonConf_t *data)
385 {
386  rlReturnVal_t retVal;
387  /* Initialize Command and Response Sub Blocks */
388  rlDriverMsg_t inMsg;
389  rlDriverMsg_t outMsg = {0};
390  rlUInt16_t numSbc = 0U;
391 
392  /* Initialize Command and Response Sub Blocks */
393  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = {0};
394 
395  RL_LOGV_ARG0("rlRfTxPowrMonConfig starts...\n");
396 
397  /* Construct command packet */
398  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
399 
400  /* check if deviceIndex is out of defined value */
401  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
402  (RL_NULL_PTR == data))
403  {
404  retVal = RL_RET_CODE_INVALID_INPUT;
405  RL_LOGE_ARG0("rlRfTxPowrMonConfig, Invalid input \n");
406  }
407  else
408  {
409  /* check for NULL pointer */
410  if ((RL_NULL_PTR != data->tx0PowrMonCfg))
411  {
412  /* Fill in-message Payload */
413  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
414  RL_RF_TX0_POW_MON_CONF_SB,
415  &inPayloadSb[numSbc],
416  (rlUInt8_t* )data->tx0PowrMonCfg,
417  (rlUInt16_t)sizeof(rlTxPowMonConf_t));
418  numSbc++;
419  }
420  /* check for NULL pointer */
421  if ((RL_NULL_PTR != data->tx1PowrMonCfg))
422  {
423  /* Fill in-message Payload */
424  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
425  RL_RF_TX1_POW_MON_CONF_SB,
426  &inPayloadSb[numSbc],
427  (rlUInt8_t* )data->tx1PowrMonCfg,
428  (rlUInt16_t)sizeof(rlTxPowMonConf_t));
429  numSbc++;
430  }
431  /* check for NULL pointer */
432  if ((RL_NULL_PTR != data->tx2PowrMonCfg))
433  {
434  /* Fill in-message Payload */
435  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
436  RL_RF_TX2_POW_MON_CONF_SB,
437  &inPayloadSb[numSbc],
438  (rlUInt8_t* )data->tx2PowrMonCfg,
439  (rlUInt16_t)sizeof(rlTxPowMonConf_t));
440  numSbc++;
441  }
442 
443  if (numSbc > 0U)
444  {
445  /* setting num of sub-block to inMsg */
446  inMsg.opcode.nsbc = numSbc;
447 
448  /* Send Command to mmWave Radar Device */
449  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
450  }
451  else
452  {
453  retVal = RL_RET_CODE_INVALID_INPUT;
454  RL_LOGE_ARG0("sub block is NULL\n");
455  }
456  }
457 
458  return retVal;
459 }
460 
474 /* Sub block ID: 0x01CA, ICD API: AWR_MONITOR_TX0_BALLBREAK_CONF_SB */
475 /* Sub block ID: 0x01CB, ICD API: AWR_MONITOR_TX1_BALLBREAK_CONF_SB */
476 /* Sub block ID: 0x01CC, ICD API: AWR_MONITOR_TX2_BALLBREAK_CONF_SB */
477 /* DesignId : MMWL_DesignId_081 */
478 /* Requirements : AUTORADAR_REQ-862 */
479 rlReturnVal_t rlRfTxBallbreakMonConfig(rlUInt8_t deviceMap, rlAllTxBallBreakMonCfg_t* data)
480 {
481  rlReturnVal_t retVal;
482  /* Initialize Command and Response Sub Blocks */
483  rlDriverMsg_t inMsg;
484  rlDriverMsg_t outMsg = {0};
485  rlUInt16_t numSbc = 0U;
486 
487  /* Initialize Command and Response Sub Blocks */
488  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = {0};
489 
490  RL_LOGV_ARG0("rlRfTxBallBreakMonConfig starts...\n");
491 
492  /* Construct command packet */
493  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
494 
495  /* check if deviceIndex is out of defined value */
496  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
497  (RL_NULL_PTR == data) )
498  {
499  retVal = RL_RET_CODE_INVALID_INPUT;
500  RL_LOGE_ARG0("rlRfTxBallBreakMonConfig, Invalid input \n");
501  }
502  else
503  {
504  /* check for NULL pointer */
505  if ((RL_NULL_PTR != data->tx0BallBrkMonCfg))
506  {
507  /* Fill in-message Payload */
508  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
509  RL_RF_TX0_BALLBREAK_MON_CONF_SB,
510  &inPayloadSb[numSbc],
511  (rlUInt8_t* )data->tx0BallBrkMonCfg,
512  (rlUInt16_t)sizeof(rlTxBallbreakMonConf_t));
513  numSbc++;
514  }
515  /* check for NULL pointer */
516  if ((RL_NULL_PTR != data->tx1BallBrkMonCfg))
517  {
518  /* Fill in-message Payload */
519  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
520  RL_RF_TX1_BALLBREAK_MON_CONF_SB,
521  &inPayloadSb[numSbc],
522  (rlUInt8_t* )data->tx1BallBrkMonCfg,
523  (rlUInt16_t)sizeof(rlTxBallbreakMonConf_t));
524  numSbc++;
525  }
526  /* check for NULL pointer */
527  if ((RL_NULL_PTR != data->tx2BallBrkMonCfg))
528  {
529  /* Fill in-message Payload */
530  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
531  RL_RF_TX2_BALLBREAK_MON_CONF_SB,
532  &inPayloadSb[numSbc],
533  (rlUInt8_t* )data->tx2BallBrkMonCfg,
534  (rlUInt16_t)sizeof(rlTxBallbreakMonConf_t));
535  numSbc++;
536  }
537 
538  if (numSbc > 0U)
539  {
540  /* setting num of sub-block to inMsg */
541  inMsg.opcode.nsbc = numSbc;
542 
543  /* Send Command to mmWave Radar Device */
544  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
545  }
546  else
547  {
548  retVal = RL_RET_CODE_INVALID_INPUT;
549  RL_LOGE_ARG0("sub block is NULL\n");
550  }
551  }
552 
553  return retVal;
554 
555 }
556 
579 /* Sub block ID: 0x01CD, ICD API: AWR_MONITOR_TX_GAIN_PHASE_MISMATCH_CONF_SB */
580 /* DesignId : MMWL_DesignId_082 */
581 /* Requirements : AUTORADAR_REQ-863 */
582 rlReturnVal_t rlRfTxGainPhaseMismatchMonConfig(rlUInt8_t deviceMap,
584 {
585  rlReturnVal_t retVal;
586 
587  /* check if deviceIndex is out of defined value */
588  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
589  {
590  /* set return error code */
591  retVal = RL_RET_CODE_INVALID_INPUT;
592  }
593  else
594  {
595  /* Package the command with given data and send it to device */
596  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
597  RL_RF_TX_GAIN_PHASE_MISMATCH_MON_CONF_SB,
598  (rlUInt8_t*)data,
599  (rlUInt16_t)sizeof(rlTxGainPhaseMismatchMonConf_t));
600  }
601  return retVal;
602 }
603 
641 /* Sub block ID: 0x01D1, ICD API: AWR_MONITOR_SYNTHESIZER_FREQUENCY_CONF_SB */
642 /* DesignId : MMWL_DesignId_084 */
643 /* Requirements : AUTORADAR_REQ-865, AUTORADAR_REQ-1052 */
644 rlReturnVal_t rlRfSynthFreqMonConfig(rlUInt8_t deviceMap, rlSynthFreqMonConf_t* data)
645 {
646  rlReturnVal_t retVal;
647 
648  /* check if deviceIndex is out of defined value */
649  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
650  {
651  /* set return error code */
652  retVal = RL_RET_CODE_INVALID_INPUT;
653  }
654  else
655  {
656  /* Package the command with given data and send it to device */
657  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
658  RL_RF_SYNTH_FREQ_MON_CONF_SB, (rlUInt8_t*)data,
659  (rlUInt16_t)sizeof(rlSynthFreqMonConf_t));
660  }
661  return retVal;
662 }
663 
678 /* Sub block ID: 0x01D2, ICD API: AWR_MONITORING_EXTERNAL_ANALOG_SIGNALS_CONF_SB */
679 /* DesignId : MMWL_DesignId_085 */
680 /* Requirements : AUTORADAR_REQ-866 */
681 rlReturnVal_t rlRfExtAnaSignalsMonConfig(rlUInt8_t deviceMap,
683 {
684  rlReturnVal_t retVal;
685 
686  /* check if deviceIndex is out of defined value */
687  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
688  (RL_NULL_PTR == data))
689  {
690  /* set return error code */
691  retVal = RL_RET_CODE_INVALID_INPUT;
692  }
693  else
694  {
695  /* Package the command with given data and send it to device */
696  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
697  RL_RF_EXT_ANA_SIGNALS_MON_CONF_SB, (rlUInt8_t*)data,
698  (rlUInt16_t)sizeof(rlExtAnaSignalsMonConf_t));
699  }
700  return retVal;
701 }
702 
718 /* Sub block ID: 0x01D3, ICD API: AWR_MONITOR_TX0_INTERNAL_ANALOG_SIGNALS_CONF_SB */
719 /* Sub block ID: 0x01D4, ICD API: AWR_MONITOR_TX1_INTERNAL_ANALOG_SIGNALS_CONF_SB */
720 /* Sub block ID: 0x01D5, ICD API: AWR_MONITOR_TX2_INTERNAL_ANALOG_SIGNALS_CONF_SB */
721 /* DesignId : MMWL_DesignId_086 */
722 /* Requirements : AUTORADAR_REQ-867, AUTORADAR_REQ-1062 */
723 rlReturnVal_t rlRfTxIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
725 {
726  rlReturnVal_t retVal;
727  /* Initialize Command and Response Sub Blocks */
728  rlDriverMsg_t inMsg;
729  rlDriverMsg_t outMsg = {0};
730  rlUInt16_t numSbc = 0U;
731 
732  /* Initialize Command and Response Sub Blocks */
733  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = {0};
734 
735  RL_LOGV_ARG0("rlRfTxIntAnaSignalsMonConfig starts...\n");
736 
737  /* Construct command packet */
738  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
739 
740  /* check if deviceIndex is out of defined value */
741  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
742  (RL_NULL_PTR == data) )
743  {
744  retVal = RL_RET_CODE_INVALID_INPUT;
745  RL_LOGE_ARG0("rlRfTxIntAnaSignalsMonConfig, Invalid input \n");
746  }
747  else
748  {
749  /* check for NULL pointer */
750  if ((RL_NULL_PTR != data->tx0IntAnaSgnlMonCfg))
751  {
752  /* Fill in-message Payload */
753  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
754  RL_RF_TX0_INT_ANA_SIGNALS_MON_CONF_SB,
755  &inPayloadSb[numSbc],
756  (rlUInt8_t* )data->tx0IntAnaSgnlMonCfg,
757  (rlUInt16_t)sizeof(rlTxIntAnaSignalsMonConf_t));
758  numSbc++;
759  }
760  /* check for NULL pointer */
761  if ((RL_NULL_PTR != data->tx1IntAnaSgnlMonCfg))
762  {
763  /* Fill in-message Payload */
764  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
765  RL_RF_TX1_INT_ANA_SIGNALS_MON_CONF_SB,
766  &inPayloadSb[numSbc],
767  (rlUInt8_t* )data->tx1IntAnaSgnlMonCfg,
768  (rlUInt16_t)sizeof(rlTxIntAnaSignalsMonConf_t));
769  numSbc++;
770  }
771  /* check for NULL pointer */
772  if ((RL_NULL_PTR != data->tx2IntAnaSgnlMonCfg))
773  {
774  /* Fill in-message Payload */
775  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
776  RL_RF_TX2_INT_ANA_SIGNALS_MON_CONF_SB,
777  &inPayloadSb[numSbc],
778  (rlUInt8_t* )data->tx2IntAnaSgnlMonCfg,
779  (rlUInt16_t)sizeof(rlTxIntAnaSignalsMonConf_t));
780  numSbc++;
781  }
782 
783  if (numSbc > 0U)
784  {
785  /* setting num of sub-block to inMsg */
786  inMsg.opcode.nsbc = numSbc;
787 
788  /* Send Command to mmWave Radar Device */
789  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
790  }
791  else
792  {
793  retVal = RL_RET_CODE_INVALID_INPUT;
794  RL_LOGE_ARG0("sub block is NULL\n");
795  }
796  }
797 
798  return retVal;
799 }
800 
815 /* Sub block ID: 0x01D6, ICD API: AWR_MONITOR_RX_INTERNAL_ANALOG_SIGNALS_CONF_SB */
816 /* DesignId : MMWL_DesignId_087 */
817 /* Requirements : AUTORADAR_REQ-868 */
818 rlReturnVal_t rlRfRxIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
819  rlRxIntAnaSignalsMonConf_t* data)
820 {
821  rlReturnVal_t retVal;
822 
823  /* check if deviceIndex is out of defined value */
824  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
825  (RL_NULL_PTR == data))
826  {
827  /* set return error code */
828  retVal = RL_RET_CODE_INVALID_INPUT;
829  }
830  else
831  {
832  /* Package the command with given data and send it to device */
833  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
834  RL_RF_RX_INT_ANA_SIGNALS_MON_CONF_SB, (rlUInt8_t*)data,
835  (rlUInt16_t)sizeof(rlRxIntAnaSignalsMonConf_t));
836  }
837  return retVal;
838 }
839 
858 /* Sub block ID: 0x01D7, ICD API: AWR_MONITOR_PMCLKLO_INTERNAL_ANALOG_SIGNALS_CONF_SB */
859 /* DesignId : MMWL_DesignId_088 */
860 /* Requirements : AUTORADAR_REQ-869 */
861 rlReturnVal_t rlRfPmClkLoIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
863 {
864  rlReturnVal_t retVal;
865 
866  /* check if deviceIndex is out of defined value */
867  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
868  (RL_NULL_PTR == data))
869  {
870  /* set return error code */
871  retVal = RL_RET_CODE_INVALID_INPUT;
872  }
873  else
874  {
875  /* Package the command with given data and send it to device */
876  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
877  RL_RF_PMCLKLO_INT_ANA_SIGNALS_MON_CONF_SB,
878  (rlUInt8_t*)data,
879  (rlUInt16_t)sizeof(rlPmClkLoIntAnaSignalsMonConf_t));
880  }
881  return retVal;
882 }
883 
898 /* Sub block ID: 0x01D8, ICD API: AWR_MONITOR_GPADC_INTERNAL_ANALOG_SIGNALS_CONF_SB */
899 /* DesignId : MMWL_DesignId_089 */
900 /* Requirements : AUTORADAR_REQ-870 */
901 rlReturnVal_t rlRfGpadcIntAnaSignalsMonConfig(rlUInt8_t deviceMap,
903 {
904  rlReturnVal_t retVal;
905 
906  /* check if deviceIndex is out of defined value */
907  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
908  (RL_NULL_PTR == data))
909  {
910  /* set return error code */
911  retVal = RL_RET_CODE_INVALID_INPUT;
912  }
913  else
914  {
915  /* Package the command with given data and send it to device */
916  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
917  RL_RF_GPADC_INT_ANA_SIGNALS_MON_CONF_SB,
918  (rlUInt8_t*)data,
919  (rlUInt16_t)sizeof(rlGpadcIntAnaSignalsMonConf_t));
920  }
921  return retVal;
922 }
923 
938 /* Sub block ID: 0x01D9, ICD API: AWR_MONITOR_PLL_CONTROL_VOLTAGE_SIGNALS_CONF_SB */
939 /* DesignId : MMWL_DesignId_090 */
940 /* Requirements : AUTORADAR_REQ-871 */
941 rlReturnVal_t rlRfPllContrlVoltMonConfig(rlUInt8_t deviceMap,
943 {
944  rlReturnVal_t retVal;
945 
946  /* check if deviceIndex is out of defined value */
947  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
948  (RL_NULL_PTR == data))
949  {
950  /* set return error code */
951  retVal = RL_RET_CODE_INVALID_INPUT;
952  }
953  else
954  {
955  /* Package the command with given data and send it to device */
956  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
957  RL_RF_PLL_CONTROL_VOLT_MON_CONF_SB,
958  (rlUInt8_t*)data,
959  (rlUInt16_t)sizeof(rlPllContrVoltMonConf_t));
960  }
961  return retVal;
962 }
963 
977 /* Sub block ID: 0x01DA, ICD API: AWR_MONITOR_DUAL_CLOCK_COMP_CONF_SB */
978 /* DesignId : MMWL_DesignId_091 */
979 /* Requirements : AUTORADAR_REQ-872 */
980 rlReturnVal_t rlRfDualClkCompMonConfig(rlUInt8_t deviceMap,
982 {
983  rlReturnVal_t retVal;
984 
985  /* check if deviceIndex is out of defined value */
986  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
987  (RL_NULL_PTR == data))
988  {
989  /* set return error code */
990  retVal = RL_RET_CODE_INVALID_INPUT;
991  }
992  else
993  {
994  /* Package the command with given data and send it to device */
995  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
996  RL_RF_DUAL_CLOCK_COMP_MON_CONF_SB,
997  (rlUInt8_t*)data,
998  (rlUInt16_t)sizeof(rlDualClkCompMonConf_t));
999  }
1000  return retVal;
1001 }
1002 
1026 /* Sub block ID: 0x01DB, ICD API: AWR_MONITOR_RX_SATURATION_DETECTOR_CONF_SB */
1027 /* DesignId : MMWL_DesignId_092 */
1028 /* Requirements : AUTORADAR_REQ-873 */
1029 rlReturnVal_t rlRfRxIfSatMonConfig(rlUInt8_t deviceMap,
1030  rlRxSatMonConf_t* data)
1031 {
1032  rlReturnVal_t retVal;
1033 
1034  /* check if deviceIndex is out of defined value */
1035  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1036  (RL_NULL_PTR == data))
1037  {
1038  /* set return error code */
1039  retVal = RL_RET_CODE_INVALID_INPUT;
1040  }
1041  else
1042  {
1043  /* Package the command with given data and send it to device */
1044  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1045  RL_RF_RX_SATURATION_MON_CONF_SB,
1046  (rlUInt8_t*)data,
1047  (rlUInt16_t)sizeof(rlRxSatMonConf_t));
1048  }
1049  return retVal;
1050 }
1051 
1076 /* Sub block ID: 0x01DC, ICD API: AWR_MONITOR_SIG_IMG_MONITOR_CONF_SB */
1077 /* DesignId : MMWL_DesignId_093 */
1078 /* Requirements : AUTORADAR_REQ-874 */
1079 rlReturnVal_t rlRfRxSigImgMonConfig(rlUInt8_t deviceMap,
1080  rlSigImgMonConf_t* data)
1081 {
1082  rlReturnVal_t retVal;
1083 
1084  /* check if deviceIndex is out of defined value */
1085  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1086  (RL_NULL_PTR == data))
1087  {
1088  /* set return error code */
1089  retVal = RL_RET_CODE_INVALID_INPUT;
1090  }
1091  else
1092  {
1093  /* Package the command with given data and send it to device */
1094  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1095  RL_RF_RX_SIGIMG_MON_CONF_SB,
1096  (rlUInt8_t*)data,
1097  (rlUInt16_t)sizeof(rlSigImgMonConf_t));
1098  }
1099  return retVal;
1100 }
1101 
1116 /* Sub block ID: 0x01DD, ICD API: AWR_MONITOR_RX_MIXER_IN_POWER_CONF_SB */
1117 /* DesignId : MMWL_DesignId_094 */
1118 /* Requirements : AUTORADAR_REQ-875 */
1119 rlReturnVal_t rlRfRxMixerInPwrConfig(rlUInt8_t deviceMap,
1120  rlRxMixInPwrMonConf_t* data)
1121 {
1122  rlReturnVal_t retVal;
1123 
1124  /* check if deviceIndex is out of defined value */
1125  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1126  (RL_NULL_PTR == data))
1127  {
1128  /* set return error code */
1129  retVal = RL_RET_CODE_INVALID_INPUT;
1130  }
1131  else
1132  {
1133  /* Package the command with given data and send it to device */
1134  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1135  RL_RF_RX_MIXER_IN_POWR_CONF_SB,
1136  (rlUInt8_t*)data,
1137  (rlUInt16_t)sizeof(rlRxMixInPwrMonConf_t));
1138  }
1139  return retVal;
1140 }
1141 
1162 /* Sub block ID: 0x01DF, ICD API: AWR_ANALOG_FAULT_INJECTION_CONF_SB */
1163 /* DesignId : MMWL_DesignId_095 */
1164 /* Requirements : AUTORADAR_REQ-876 */
1165 rlReturnVal_t rlRfAnaFaultInjConfig(rlUInt8_t deviceMap,
1166  rlAnaFaultInj_t* data)
1167 {
1168  rlReturnVal_t retVal;
1169 
1170  /* check if deviceIndex is out of defined value */
1171  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) ||\
1172  (RL_NULL_PTR == data))
1173  {
1174  /* set return error code */
1175  retVal = RL_RET_CODE_INVALID_INPUT;
1176  }
1177  else
1178  {
1179  /* Package the command with given data and send it to device */
1180  retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_MONITORING_CONF_SET_MSG,
1181  RL_RF_FAULT_INJECTION_CONF_SB,
1182  (rlUInt8_t*)data,
1183  (rlUInt16_t)sizeof(rlAnaFaultInj_t));
1184  }
1185  return retVal;
1186 }
1187 
1216 /* Sub block ID: 0x01CE, ICD API: AWR_MONITOR_TX0_PHASE_SHIFTER_CONF_SB */
1217 /* Sub block ID: 0x01CF, ICD API: AWR_MONITOR_TX1_PHASE_SHIFTER_CONF_SB */
1218 /* Sub block ID: 0x01D0, ICD API: AWR_MONITOR_TX2_PHASE_SHIFTER_CONF_SB */
1219 /* DesignId : MMWL_DesignId_083 */
1220 /* Requirements : AUTORADAR_REQ-1066, AUTORADAR_REQ-864 */
1221 rlReturnVal_t rlRfTxPhShiftMonConfig(rlUInt8_t deviceMap, rlAllTxPhShiftMonConf_t* data)
1222 {
1223  rlReturnVal_t retVal;
1224  /* Initialize Command and Response Sub Blocks */
1225  rlDriverMsg_t inMsg;
1226  rlDriverMsg_t outMsg = { 0 };
1227  rlUInt16_t numSbc = 0U;
1228 
1229  /* Initialize Command and Response Sub Blocks */
1230  rlPayloadSb_t inPayloadSb[RL_MAX_SB_IN_MSG] = { 0 };
1231 
1232  RL_LOGV_ARG0("rlRfTxPhShiftMonConfig starts...\n");
1233 
1234  /* Construct command packet */
1235  rlDriverConstructInMsg(RL_RF_MONITORING_CONF_SET_MSG, &inMsg, &inPayloadSb[0U]);
1236 
1237  /* check if deviceIndex is out of defined value */
1238  if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
1239  (RL_NULL_PTR == data))
1240  {
1241  retVal = RL_RET_CODE_INVALID_INPUT;
1242  RL_LOGE_ARG0("rlRfTxPhShiftMonConfig, Invalid input \n");
1243  }
1244  else
1245  {
1246  /* check for NULL pointer */
1247  if ((RL_NULL_PTR != data->tx0PhShiftMonCfg))
1248  {
1249  /* Fill in-message Payload */
1250  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
1251  RL_RF_TX0_PH_SHIFT_MON_CONF_SB,
1252  &inPayloadSb[numSbc],
1253  (rlUInt8_t*)data->tx0PhShiftMonCfg,
1254  (rlUInt16_t)sizeof(rlTxPhShiftMonConf_t));
1255  numSbc++;
1256  }
1257  /* check for NULL pointer */
1258  if ((RL_NULL_PTR != data->tx1PhShiftMonCfg))
1259  {
1260  /* Fill in-message Payload */
1261  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
1262  RL_RF_TX1_PH_SHIFT_MON_CONF_SB,
1263  &inPayloadSb[numSbc],
1264  (rlUInt8_t*)data->tx1PhShiftMonCfg,
1265  (rlUInt16_t)sizeof(rlTxPhShiftMonConf_t));
1266  numSbc++;
1267  }
1268  /* check for NULL pointer */
1269  if ((RL_NULL_PTR != data->tx2PhShiftMonCfg))
1270  {
1271  /* Fill in-message Payload */
1272  rlDriverFillPayload(RL_RF_MONITORING_CONF_SET_MSG,
1273  RL_RF_TX2_PH_SHIFT_MON_CONF_SB,
1274  &inPayloadSb[numSbc],
1275  (rlUInt8_t*)data->tx2PhShiftMonCfg,
1276  (rlUInt16_t)sizeof(rlTxPhShiftMonConf_t));
1277  numSbc++;
1278  }
1279 
1280  if (numSbc > 0U)
1281  {
1282  /* setting num of sub-block to inMsg */
1283  inMsg.opcode.nsbc = numSbc;
1284 
1285  /* Send Command to mmWave Radar Device */
1286  retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
1287  }
1288  else
1289  {
1290  retVal = RL_RET_CODE_INVALID_INPUT;
1291  RL_LOGE_ARG0("sub block is NULL\n");
1292  }
1293  }
1294 
1295  return retVal;
1296 }
1297 
1298 /*
1299  * END OF rl_monitoring.c FILE
1300  */
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 2021, Texas Instruments Incorporated