638146de1616af5ee9938f8f9911e2cd3237786b
[processor-sdk/pdk.git] / packages / ti / drv / adcbuf / adcbuf.h
1 /*
2  *  Copyright (c) Texas Instruments Incorporated 2021
3  *
4  *  Redistribution and use in source and binary forms, with or without
5  *  modification, are permitted provided that the following conditions
6  *  are met:
7  *
8  *    Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  *    Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the
14  *    distribution.
15  *
16  *    Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /** ===========================================================
34  *  @file       drv/adcbuf/adcbuf.h
35  *
36  *  @brief      ADCBuf driver interface
37  *
38  */
40  /** \defgroup DRV_ADCBUF_MODULE ADCBuf Driver
41  *
42  *  The ADCBUF in the AWR29xx SoCs can be programmed at a high-level using
43  *  the ADCBUF driver software that allows hook-up with an operating system.
44  *  The ADCBUF driver exposes programming of most features provided by the IP.
45  * 
46  * 
47  *  The ADCBuf header file should be included in an application as follows:
48  *  @code
49  *  #include <ti/drv/adcbuf/adcbuf.h>
50  *  @endcode
51  *
52  *  # Operation #
53  *  The ADCBuf driver samples an analog waveform at a specified frequency. 
54  *  The resulting samples are transferred to a buffer provided by
55  *  the application. The driver can either take n samples once, or continuously
56  *  sample by double-buffering and providing a callback to process each finished
57  *  buffer.
58  *
59  *  The APIs in this driver serve as an interface to a typical TI-RTOS
60  *  application. The specific peripheral implementations are responsible to
61  *  create all the SYS/BIOS specific primitives to allow for thread-safe
62  *  operation.
63  *
64  *  The platform specific ADCBUF file present in the ti/drv/adcbuf/soc/
65  *  directory. This file is built as a part of the ADCBUF Library for the specific
66  *  platform.
67  * 
68  *  The documentation for all APIs can be referred by clicking at above file or
69  *  by going to @ref ADCBUF_DRIVER_EXTERNAL_FUNCTION. Example usage of the EDMA
70  *  driver can be seen by referring to the EDMA unit test code located at
71  *  @verbatim ti/drv/adcbuf/test/example/main_mss.c @endverbatim
72  *
73  *  ## Opening the driver #
74  *
75  *  @code
76  *      ADCBuf_Handle adcBufHandle;
77  *      ADCBuf_Params adcBufParams;
78  *
79  *      ADCBuf_Params_init(&adcBufParams);
80  *      adcBufHandle = ADCBuf_open(Board_ADCBuf0, &adcBufParams);
81  *  @endcode
82  *
83  *
84  *  # Implementation #
85  *
86  *  This module serves as the main interface for applications. Its
87  *  purpose is to redirect the module's APIs to specific peripheral
88  *  implementations which are specified using a pointer to an ADCBuf_FxnTable.
89  *
90  *  The ADCBuf driver interface module is joined (at link time) to a
91  *  NULL-terminated array of ADCBuf_Config data structures named *ADCBuf_config*.
92  *  *ADCBuf_config* is implemented in the application with each entry being an
93  *  instance of an ADCBuf peripheral. Each entry in *ADCBuf_config* contains a:
94  *  - (ADCBuf_FxnTable *) to a set of functions that implement an ADCBuf peripheral
95  *  - (void *) data object that is associated with the ADCBuf_FxnTable
96  *  - (void *) hardware attributes that are associated to the ADCBuf_FxnTable
97  * 
98  *  \section memory_footprint Memory Footprint
99  *
100  *  The memory footprint of the driver depends on how many APIs are referred to
101  *  by an application (all are not necessary for basic operation). The unit test
102  *  code's generated memory map file may be used to get an estimate of
103  *  the memory foot-print when most APIs are used.
104  *
105  *
106  *  ============================================================================
107  */
109 /**
110  *  \file       drv/adcbuf/adcbuf.h
111  *
112  *  \brief      ADCBUF driver interface
113  *
114  */
115 #ifndef ADCBUF_DRV_H
116 #define ADCBUF_DRV_H
118 /* ========================================================================== */
119 /*                             Include Files                                  */
120 /* ========================================================================== */
121 #include <stdint.h>
122 #include <stdbool.h>
123 #include <stddef.h>
124 #include "ti/drv/adcbuf/soc/adcbuf_soc.h"
126 #ifdef __cplusplus
127 extern "C" {
128 #endif
130 /* ========================================================================== */
131 /*                           Macros & Typedefs                                */
132 /* ========================================================================== */
133 /** \brief ADCBUF driver error base */
134 #define MMWAVE_ERRNO_ADCBUF_BASE             (-2400)
136 /******************************************************************************/
137 /************************ Error code defines **********************************/
138 /******************************************************************************/
139 /** \defgroup ADCBUF_ERROR_CODES Error Codes
140 \ingroup DRV_ADCBUF_MODULE
141  *
142  @{ */
144 /*!
145 * \brief  Success status code returned by:
146 * ADCBuf_control()
148 * Functions return ADCBuf_STATUS_SUCCESS if the call was executed
149 * successfully.
150 */
151 #define ADCBUF_STATUS_SUCCESS           (0U)
153 /*!
154 * \brief   Generic error status code returned by ADCBuf_control().
156 * ADCBuf_control() returns ADCBuf_STATUS_ERROR if the control code was not executed
157 * successfully.
160 */
161 #define ADCBUF_STATUS_ERROR             (MMWAVE_ERRNO_ADCBUF_BASE - 1)
163 /*!
164 * \brief   An error status code returned by ADCBuf_control() for undefined
165 * command codes.
167 * ADCBuf_control() returns ADCBuf_STATUS_UNDEFINEDCMD if the control code is not
168 * recognized by the driver implementation.
171 */
172 #define ADCBUF_STATUS_UNDEFINEDCMD      (MMWAVE_ERRNO_ADCBUF_BASE - 2)
174 /*!
175 * \brief   An error status code returned by ADCBuf_control() for feature not implemented.
177 * ADCBuf_control() returns ADCBuf_STATUS_NOT_IMPLEMENTED if the control command
178 * was not supported.
181 */
182 #define ADCBUF_STATUS_NOT_IMPLEMENTED   (MMWAVE_ERRNO_ADCBUF_BASE - 3)
184 /*!
185 * \brief   An error status code returned by ADCBuf_control() for invalid input parameters.
187 * ADCBuf_control() returns ADCBuf_STATUS_INVALID_PARAMS if the control code gets
188 * invalid parameters.
191 */
192 #define ADCBUF_STATUS_INVALID_PARAMS  (MMWAVE_ERRNO_ADCBUF_BASE - 4)
194 /*!
195 * \brief   An error status code returned by ADCBuf_control() for invalid
196 * command codes.
198 * ADCBuf_control() returns ADCBuf_STATUS_INVALID_CMD if the control code is not
199 * recognized by the driver implementation.
202 */
203 #define ADCBUF_STATUS_INVALID_CMD      (MMWAVE_ERRNO_ADCBUF_BASE - 5)
205 /** @}*/ /* end defgroup ADCBUF_ERROR_CODES */
208 /*!
209  *  @brief      A handle that is returned from an ADCBuf_open() call.
210  */
211 typedef struct ADCBuf_Config_t              *ADCBuf_Handle;
214 /** @addtogroup ADCBUF_DRIVER_EXTERNAL_DATA_STRUCTURE      ADCBUF Driver External Data Structures
215 \ingroup DRV_ADCBUF_MODULE
216  @{ */
218 /**
219 * @brief
220 *  ADCBUF Source selection
222 * @details
223 *  The structure is used to define ADCBUF driver commands.
225 */
226 typedef enum ADCBufSource_e
228     /**
229      * @brief  Select DFE as source.
230      */
231     ADCBUF_SOURCE_DFE        = 0,
233     /**
234      * @brief  Select HIL as source.
235      */
236     ADCBUF_SOURCE_HIL
237 }ADCBufSource;
239 /**
240 * @brief
241 *  ADC Buffer data format Parameters
243 * @details
244 *  The structure is used to define ADC Buffer data format.
246 */
247 typedef struct ADCBuf_dataFormat_t
249     /* ADC out Format
250          0 - Complex Data mode
251          1 - Real data mode
252       */
253     uint8_t     adcOutFormat;
255     /* Sample interleave - IQswap
256          0 - I is stored in LSB, Q is stored in MSB
257          1 - Q is stored in LSB, I is stored in MSB
258       */
259     uint8_t     sampleInterleave;
261     /* channel interleave
262          0 - interleaved
263          1 - non-interleaved
264       */
265     uint8_t     channelInterleave;
266 }ADCBuf_dataFormat;
268 /**
269 * @brief
270 *  ADC Buffer RX channel configuration Parameters
272 * @details
273 *  The structure is used to define ADC Buffer RX Channel configuration.
276 */
277 typedef struct ADCBuf_RxChanConf_t
279     /* RX channel id - 0~3 */
280     uint8_t   channel;
282     /* Address offset for the channel in Ping/Pong buffer
283       Used only in non-interleaved mode, it must be 16 bytes aligned.
284      */
285     uint16_t  offset;
286 }ADCBuf_RxChanConf;
288 /**
289 * @brief
290 *  ADC Buffer test pattern configuration Parameters
292 * @details
293 *  The structure is used to define ADC Buffer test pattern configuration.
295 */
296 typedef struct ADCBuf_rxTestPatternConf_t
298     /* I sample offset */
299     uint16_t rxIOffset;
301     /* I sample incremental value */
302     uint16_t rxIInc;
304     /* Q sample offset */
305     uint16_t rxQOffset;
307     /* Q sample incremental value */
308     uint16_t rxQInc;
309 }ADCBuf_rxTestPatternConf;
311 /**
312 * @brief
313 *  ADC Buffer test pattern configuration Parameters
315 * @details
316 *  The structure is used to define ADC Buffer test pattern configuration.
318 */
319 typedef struct ADCBuf_TestPatternConf_t
321     /* Test pattern configuration for 4 channels */
322     ADCBuf_rxTestPatternConf rxConfig[NUM_RX_CHANNEL];
324     /* Periodicity of the pattern */
325     uint16_t               period;
327     /* Sample count to store in ADC buffer */
328     uint16_t               numSamples;
329 }ADCBuf_TestPatternConf;
331 /**
332 * @brief
333 *  Chirp Quality(CQ) configuration Parameters
335 * @details
336 *  The structure is used to define Chirp Quality configuration.
339 */
340 typedef struct ADCBuf_CQConf_t
342     /*! 0x0 or 0x1:Raw16, 0x2:Raw12, 0x3:Raw14 */
343     uint8_t   cqDataWidth;
345     /*! Set in case of 3 channel mode  */
346     uint8_t   cq96BitPackEn;
348     /*! CQ0 Address offset : 16bytes aligned address for Storing CQ0 */
349     uint16_t  cq0AddrOffset;
351     /*! CQ1 Address offset : 16 bytes aligned address for Storing CQ1 */
352     uint16_t  cq1AddrOffset;
354     /*! CQ2 Address offset : 16 bytes aligned address for Storing CQ2 */
355     uint16_t  cq2AddrOffset;
356 }ADCBuf_CQConf;
358 /*!
359 *  @brief ADC Parameters
361 *  ADC Parameters are used to with the ADCBuf_open() call. Default values for
362 *  these parameters are set using ADCBuf_Params_init().
364 */
365 typedef struct ADCBuf_Params_t
368     /**
369      * @brief   ADC buffer source, DFE or HIL 
370      */
371     ADCBufSource        source;
373     /**
374      * @brief   Continuous mode selection 
375      */
376     uint8_t             continousMode;
378     /**
379      * @brief   AWR2944: Ping buffer Chirp Threshold
380                 for non-continous operation 
381      */
382     uint8_t             chirpThresholdPing;
384     /**
385      * @brief   xwr16xx/xwr18xx/xwr68xx: Pong buffer Chirp Threshold 
386                 for non-continous operation 
387      */
388     uint8_t             chirpThresholdPong;
390     /**
391      * @brief   Custom configuration, Pointer to a device specific 
392                 extension of the ADCBuf_Params 
393      */
394     void                *custom;
395 } ADCBuf_Params;
397 /**
398 * @brief
399 *  ADCBUF Command
401 * @details
402 *  The structure is used to define ADCBUF driver commands.
404 */
405 typedef enum ADCBufMMWave_CMD_e
407     /**
408      * @brief   set ADCBUF source, it can be DFE or VIN.
409      *          The size of the argument size for this command is 4 bytes
410      */
411     ADCBufMMWave_CMD_SET_SRC    = 0,
413     /**
414      * @brief   Set number of Chirps to be stored in each Ping and Pong buffer.
415      *          It should be programmed one less the actual number needed .
416      *          The size of the argument size for this command is 4 bytes
417      */
418     ADCBufMMWave_CMD_SET_CHIRP_THRESHHOLD,
420     /**
421      * @brief   Set number of Chirps to be stored in each Ping buffer.
422      *          It should be programmed one less the actual number needed .
423      *          The size of the argument size for this command is 4 bytes
424      */
425     ADCBufMMWave_CMD_SET_PING_CHIRP_THRESHHOLD,
427     /**
428      * @brief   Set number of Chirps to be stored in each  Pong buffer.
429      *          It should be programmed one less the actual number needed .
430      *          The size of the argument size for this command is 4 bytes
431      */
432     ADCBufMMWave_CMD_SET_PONG_CHIRP_THRESHHOLD,
434     /**
435      * @brief   Enables/Disables Continuous mode for ADCBUF.
436      *             1 to enable continuous mode.
437      *          The size of the argument size for this command is 4 bytes
438      */
439     ADCBufMMWave_CMD_SET_CONTINUOUS_MODE,
441     /**
442      * @brief   Starts Continuous mode for ADCBUF.
443      *          Number of Samples to store in Ping/Pong buffer needs to be provided.
444      *          The size of the argument size for this command is 4 bytes
445      */
446     ADCBufMMWave_CMD_START_CONTINUOUS_MODE,
448     /**
449      * @brief   Stops Continuous mode for ADCBUF.
450      *          The size of the argument size for this command is 0 bytes
451      */
452     ADCBufMMWave_CMD_STOP_CONTINUOUS_MODE,
454     /**
455      * @brief   Configures ADCBUF data format.
456      *          The size of the argument size for this command is size of \ref ADCBuf_dataFormat
457      */
458     ADCBufMMWave_CMD_CONF_DATA_FORMAT,
460     /**
461      * @brief   Enable RX channels and configures the address offset in ADCBUF for the channel.
462      *          The size of the argument size for this command is size of \ref ADCBuf_RxChanConf
463      */
464     ADCBufMMWave_CMD_CHANNEL_ENABLE,
466     /**
467      * @brief   Disable RX channels specified with RX channel bitmask
468      *          The size of the argument size for this command is 4 bytes
469      */
470     ADCBufMMWave_CMD_CHANNEL_DISABLE,
472     /**
473      * @brief   Test pattern configuration.
474      *          The size of the argument size for this command is size of \ref ADCBuf_TestPatternConf
475      */
476     ADCBufMMWave_CMD_CONF_TEST_PATTERN,
478     /**
479      * @brief   Starts Test pattern generation. Reboot is required when switching from Test pattern mode
480      *          to normal operation mode.
481      *          The size of the argument size for this command is 0 bytes
482      */
483     ADCBufMMWave_CMD_START_TEST_PATTERN,
485     /**
486      * @brief   Stops Test pattern generation.
487      *          The size of the argument size for this command is 0 bytes
488      */
489     ADCBufMMWave_CMD_STOP_TEST_PATTERN,
491     /**
492      * @brief   Chirp Quality configuration.
493      *          The size of the argument size for this command is size of \ref ADCBuf_CQConf
494      */
495     ADCBufMMWave_CMD_CONF_CQ,
497     /**
498      * @brief  Last command.
499      */
500     ADCBufMMWave_CMD_LAST
501 }ADCBufMMWave_CMD;
503 /*!
504 *  @brief      A function pointer to a driver specific implementation of
505 *              ADCBuf_close().
506 */
507 typedef void (*ADCBuf_CloseFxn)                     (ADCBuf_Handle handle);
510 /*!
511 *  @brief      A function pointer to a driver specific implementation of
512 *              ADCBuf_open().
513 */
514 typedef ADCBuf_Handle (*ADCBuf_OpenFxn)             (ADCBuf_Handle handle,
515                                                      const ADCBuf_Params *params);
517 /*!
518 *  @brief      A function pointer to a driver specific implementation of
519 *              ADCBuf_control().
520 */
521 typedef int_fast16_t (*ADCBuf_ControlFxn)           (ADCBuf_Handle handle,
522                                                      uint_fast8_t cmd,
523                                                      void *arg);
524 /*!
525 *  @brief      A function pointer to a driver specific implementation of
526 *              ADCBuf_init().
527 */
528 typedef void (*ADCBuf_InitFxn)                      (ADCBuf_Handle handle);
530 /*!
531 *  @brief      A function pointer to a driver specific implementation of
532 *              ADCBuf_getChanBufAddr().
533 */
534 typedef uint32_t (*ADCBuf_GetChanBufAddrFxn)         (ADCBuf_Handle handle,
535                                                      uint8_t channel,
536                                                      int32_t *errCode);
538 /*!
539 *  @brief      The definition of an ADCBuf function table that contains the
540 *              required set of functions to control a specific ADC driver
541 *              implementation.
542 */
543 typedef struct ADCBuf_FxnTable_t
545     /*! Function to close the specified peripheral */
546     ADCBuf_CloseFxn            closeFxn;
547     /*! Function to driver implementation specific control function */
548     ADCBuf_ControlFxn          controlFxn;
549     /*! Function to initialize the given data object */
550     ADCBuf_InitFxn             initFxn;
551     /*! Function to open the specified peripheral */
552     ADCBuf_OpenFxn             openFxn;
553     /*! Function to get ADC buffer address for a given channel */
554     ADCBuf_GetChanBufAddrFxn   getChanBufAddr;
555 } ADCBuf_FxnTable;
557 /*!
558 *  @brief ADCBuf Global configuration
560 *  The ADCBuf_Config structure contains a set of pointers used to characterise
561 *  the ADC driver implementation.
563 *  This structure needs to be defined before calling ADCBuf_init() and it must
564 *  not be changed thereafter.
566 */
567 typedef struct ADCBuf_Config_t
569     /*! Pointer to a table of driver-specific implementations of ADC APIs */
570     const ADCBuf_FxnTable   *fxnTablePtr;
572     /*! Pointer to a driver specific data object */
573     void                    *object;
575     /*! Pointer to a driver specific hardware attributes structure */
576     void const              *hwAttrs;
577 } ADCBuf_Config;
580 /**
581 * @brief
582 *  ADCBUF CQ monitoring type
584 * @details
585 *  The structure is used to define CQ monitoring types.
587 */
588 typedef enum ADCBufMMWave_CQType_e
590     /**
591      * @brief   CQ type for CQ0.
592      */
593     ADCBufMMWave_CQType_CQ0,
595     /**
596      * @brief   CQ type for CQ1.
597      */
598     ADCBufMMWave_CQType_CQ1,
600     /**
601      * @brief   CQ type for CQ2.
602      */
603     ADCBufMMWave_CQType_CQ2,
605     /**
606      * @brief   Maximum number of CQ which can be supported.
607      */
608     ADCBufMMWave_CQType_MAX_CQ
609 }ADCBufMMWave_CQType;
611 /** @}*/ /* end defgroup ADCBUF_DRIVER_EXTERNAL_DATA_STRUCTURE */
613 /* ========================================================================== */
614 /*                          Function Declarations                             */
615 /* ========================================================================== */
617 /**
618 \defgroup ADCBUF_DRIVER_EXTERNAL_FUNCTION       ADCBUF Driver External Functions
619 \ingroup DRV_ADCBUF_MODULE
620 \brief
621 *   The section has a list of all the exported API which the applications need to
622 *   invoke in order to use the driver
623  @{ */
625 /**
626 *  @b Description
627 *  @n
628 *      Function to close an ADC peripheral specified by the ADC handle
630 *  @param[in]  handle
631 *      Handle to the ADCBUF instance obtained through call to @ref ADCBuf_open.
632 */
633 extern void ADCBuf_close(ADCBuf_Handle handle);
636 /**
637 *  @b Description
638 *  @n
639 *      Function performs implementation specific features on a given
640 *      ADCBuf_Handle.
642 *  @param[in]  handle
643 *      Handle to the ADCBUF instance obtained through call to @ref ADCBuf_open.
644 *  @param[in] cmd
645 *      A command value defined by the driver specific implementation @ref ADCBufMMWave_CMD. \n
646 *  @param[in] arg
647 *      A pointer to an optional R/W (read/write) argument that is accompanied with cmd. 
648 *      arg should be 4 bytes aligned.
649 *  @retval
650 *      Success     - @ref ADCBUF_STATUS_SUCCESS
651 *  @retval
652 *      Error       - one of @ref ADCBUF_ERROR_CODES
653 */
654 extern int_fast16_t ADCBuf_control(ADCBuf_Handle handle, uint_fast8_t cmd, void * arg);
657 /**
658 *  @b Description
659 *  @n
660 *      This function gets the physical address of ADCBuf for a given receive channel.
662 *  @param[in]  handle
663 *      Handle to the ADCBUF instance obtained through call to @ref ADCBuf_open.
664 *  @param[in] channel
665 *      Receive channel number.
666 *  @param[in] errCode
667 *      Pointer to an error code populated by the driver.
668 *  @retval
669 *      Success     - An ADCBuf physical address for the given channel.
670 *  @retval
671 *      Error       - 0 on an error.
672 */
673 extern uint32_t ADCBuf_getChanBufAddr(ADCBuf_Handle handle, uint8_t channel, int32_t *errCode);
676 /**
677 *  @b Description
678 *  @n
679 *      This function gets the physical address of chirp info(CQ) buffer for a given CQ type.
681 *  @param[in]  handle
682 *      Handle to the ADCBUF instance obtained through call to @ref ADCBuf_open.
683 *  @param[in] cqType
684 *      Type of CQ that request the address.
685 *  @param[in] errCode
686 *      Pointer to an error code populated by the driver.
687 *  @retval
688 *      Success     - An CQ buffer physical address for the given cqType
689 *  @retval
690 *      Error       - 0 on an error.
691 */
692 extern uint32_t ADCBUF_MMWave_getCQBufAddr
694     ADCBuf_Handle handle,
695     ADCBufMMWave_CQType cqType,
696     int32_t *errCode
697 );
699 /**
700 *  @b Description
701 *  @n
702 *      This function initializes the ADC module. This function must be called
703 *      before any other functions are called.
705 */
706 extern void ADCBuf_init(void);
708 /**
709 *  @b Description
710 *  @n
711 *      This function sets all fields of a specified ADCBuf_Params structure to their
712 *      default values.
714 *  @param[in]  params      A pointer to ADCBuf_Params structure for initialization
716 *  Default values are:
717 *                      source             = ADCBUF_SOURCE_DFE,
718 *                      continousMode      = 0;
719 *                      chirpThresholdPing = 1,
720 *                      chirpThresholdPong = 1,
721 *                      custom             = NULL
723 */
724 extern void ADCBuf_Params_init(ADCBuf_Params *params);
726 /**
727 *  @b Description
728 *  @n
729  *      This function opens a given ADCBuf peripheral.
730  *
731  *  @param[in]  index   Logical peripheral number for the ADCBuf indexed into
732  *                      the ADCBuf_config table
733  *
734  *  @param[in]  params  Pointer to an parameter block, if NULL it will use
735  *                      default values.
736  *
737  *  @return An ADCBuf_Handle on success or a NULL on an error or if it has been
738  *          opened already. If NULL is returned further ADC API calls will
739  *          result in undefined behaviour.
740  *
741  */
742 extern ADCBuf_Handle ADCBuf_open(uint_fast8_t index, ADCBuf_Params *params);
744 /** @}*/ /* end defgroup ADCBUF_DRIVER_EXTERNAL_FUNCTION */
746 #ifdef __cplusplus
748 #endif
749 #endif /* ADCBUF_DRV_H */