feat(Other, PeriphDrivers): Add ADC support for Zephyr stream (#1404)

Signed-off-by: Dimitrije Lilic <dimitrije.lilic@orioninc.com>

Author: dimitrije-lilic

Libraries/PeriphDrivers/Include/MAX32690/adc.h

@@ -336,6 +336,20 @@ int MXC_ADC_StartConversion(void);
  */
 int MXC_ADC_StartConversionAsync(mxc_adc_complete_cb_t callback);
 
+/**
+ * @brief   Perform a stream conversion on a specific channel
+ * @note    The channel must be configured separately
+ *          The ADC interrupt must be enabled and MXC_ADC_Handler() called in the ISR
+ *          places data in the error parameter of the callback function
+ *          Has different flags but behaves same as MXC_ADC_StartConversionAsync.
+ *          Enables interrupts for FIFO level only and starts ADC in continuous mode.
+ *
+ * @param   callback the function to call when the conversion is complete
+ *
+ * @return  Success/Fail, see \ref MXC_Error_Codes for a list of return codes.
+ */
+int MXC_ADC_StartConversionAsyncStream(mxc_adc_complete_cb_t callback);
+
 /**
  * @brief   Perform a conversion on a specific channel using a DMA transfer.
  *          DMA channel must be acquired using \ref MXC_DMA_AcquireChannel and should
@@ -361,6 +375,15 @@ int MXC_ADC_StartConversionDMA(mxc_adc_conversion_req_t *req, int *data,
 
 int MXC_ADC_Handler(void);
 
+/**
+ * @brief   Free the continous conversion resources.
+ * @note    Free the callback without need to change current
+ *          Revb Handler to keep backward compatibility.
+ *
+ * @param   None
+ */
+void MXC_ADC_Free(void);
+
 /**
  * @brief   Selects the analog input divider.
  *

Libraries/PeriphDrivers/Source/ADC/adc_me18.c

@@ -176,6 +176,11 @@ int MXC_ADC_StartConversionAsync(mxc_adc_complete_cb_t callback)
     return MXC_ADC_RevB_StartConversionAsync((mxc_adc_revb_regs_t *)MXC_ADC, callback);
 }
 
+int MXC_ADC_StartConversionAsyncStream(mxc_adc_complete_cb_t callback)
+{
+    return MXC_ADC_RevB_StartConversionAsyncStream((mxc_adc_revb_regs_t *)MXC_ADC, callback);
+}
+
 int MXC_ADC_StartConversionDMA(mxc_adc_conversion_req_t *req, int *data, void (*callback)(int, int))
 {
     return MXC_ADC_RevB_StartConversionDMA((mxc_adc_revb_regs_t *)MXC_ADC, req, data, callback);
@@ -186,6 +191,11 @@ int MXC_ADC_Handler(void)
     return MXC_ADC_RevB_Handler((mxc_adc_revb_regs_t *)MXC_ADC);
 }
 
+void MXC_ADC_Free(void)
+{
+    MXC_ADC_RevB_Free((mxc_adc_revb_regs_t *)MXC_ADC);
+}
+
 int MXC_ADC_GetData(int *outdata)
 {
     return MXC_ADC_RevB_GetData((mxc_adc_revb_regs_t *)MXC_ADC, outdata);

Libraries/PeriphDrivers/Source/ADC/adc_revb.c

@@ -208,6 +208,26 @@ int MXC_ADC_RevB_StartConversionAsync(mxc_adc_revb_regs_t *adc, mxc_adc_complete
     return E_NO_ERROR;
 }
 
+int MXC_ADC_RevB_StartConversionAsyncStream(mxc_adc_revb_regs_t *adc,
+                                            mxc_adc_complete_cb_t callback)
+{
+    if (callback == NULL) {
+        return E_BAD_PARAM;
+    }
+
+    adc->fifodmactrl |= MXC_F_ADC_REVB_FIFODMACTRL_FLUSH; //Flush data FIFO
+
+    MXC_ADC_RevB_ClearFlags(adc, ADC_IF_MASK);
+
+    while (MXC_GetLock((uint32_t *)&async_callback, (uint32_t)callback) != E_NO_ERROR) {}
+
+    MXC_ADC_RevB_EnableInt(adc, MXC_F_ADC_REVB_INTEN_FIFO_LVL);
+
+    adc->ctrl1 |= MXC_F_ADC_REVB_CTRL1_START | MXC_F_ADC_REVB_CTRL1_CNV_MODE;
+
+    return E_NO_ERROR;
+}
+
 int MXC_ADC_RevB_StartConversionDMA(mxc_adc_revb_regs_t *adc, mxc_adc_conversion_req_t *req,
                                     int *data, void (*callback)(int, int))
 {
@@ -304,6 +324,17 @@ int MXC_ADC_RevB_Handler(mxc_adc_revb_regs_t *adc)
     return E_NO_ERROR;
 }
 
+void MXC_ADC_RevB_Free(mxc_adc_revb_regs_t *adc)
+{
+    if ((adc->ctrl1 & MXC_F_ADC_REVB_CTRL1_CNV_MODE)) {
+        MXC_ADC_RevB_DisableInt(adc,
+                                (MXC_F_ADC_REVB_INTFL_SEQ_DONE | MXC_F_ADC_REVB_INTFL_CONV_DONE |
+                                 MXC_F_ADC_REVB_INTEN_FIFO_LVL));
+
+        MXC_FreeLock((uint32_t *)&async_callback);
+    }
+}
+
 int MXC_ADC_RevB_GetData(mxc_adc_revb_regs_t *adc, int *outdata)
 {
     uint32_t loop_counter, length;

Libraries/PeriphDrivers/Source/ADC/adc_revb.h

@@ -59,6 +59,9 @@ int MXC_ADC_RevB_StartConversion(mxc_adc_revb_regs_t *adcq);
 
 int MXC_ADC_RevB_StartConversionAsync(mxc_adc_revb_regs_t *adc, mxc_adc_complete_cb_t callback);
 
+int MXC_ADC_RevB_StartConversionAsyncStream(mxc_adc_revb_regs_t *adc,
+                                            mxc_adc_complete_cb_t callback);
+
 int MXC_ADC_RevB_StartConversionDMA(mxc_adc_revb_regs_t *adc, mxc_adc_conversion_req_t *req,
                                     int *data, void (*callback)(int, int));
 
@@ -74,6 +77,8 @@ void MXC_ADC_RevB_TS_SelectDisable(mxc_adc_revb_regs_t *adc);
 
 int MXC_ADC_RevB_GetData(mxc_adc_revb_regs_t *adc, int *outdata);
 
+void MXC_ADC_RevB_Free(mxc_adc_revb_regs_t *adc);
+
 uint16_t MXC_ADC_RevB_FIFO_Level(mxc_adc_revb_regs_t *adc);
 
 int MXC_ADC_RevB_FIFO_Threshold_Config(mxc_adc_revb_regs_t *adc, uint32_t fifo_threshold);

Libraries/zephyr/MAX/Include/wrap_max32_adc.h

@@ -284,6 +284,14 @@ static inline int Wrap_MXC_ADC_StartConversionAsync(uint32_t *sample_channels,
     return MXC_ADC_StartConversionAsync(callback);
 }
 
+static inline int Wrap_MXC_ADC_StartConversionAsyncStream(uint32_t *sample_channels,
+                                                          mxc_adc_complete_cb_t callback)
+{
+    MXC_ADC_FIFO_Threshold_Config(MAX_ADC_FIFO_LEN >> 1);
+    Wrap_MXC_ADC_ChannelSelect(sample_channels);
+    return MXC_ADC_StartConversionAsyncStream(callback);
+}
+
 static inline void Wrap_MXC_ADC_GetData(uint16_t **outdata)
 {
     mxc_adc_regs_t *adc = MXC_ADC;