1 /**
2   ******************************************************************************
3   * @file    stm32h7rsxx_hal_dcmipp.c
4   * @author  MCD Application Team
5   * @brief   DCMIPP HAL module driver
6   *          This file provides firmware functions to manage the following
7   *          functionalities of the DCMIPP (Digital Camera Interface Pixel Pipeline)  peripheral:
8   *           + Initialization and de-initialization functions
9   *           + IO operation functions
10   *           + Peripheral Control functions
11   *           + Peripheral State and Error functions
12   *
13   ******************************************************************************
14   * @attention
15   *
16   * Copyright (c) 2022 STMicroelectronics.
17   * All rights reserved.
18   *
19   * This software is licensed under terms that can be found in the LICENSE file
20   * in the root directory of this software component.
21   * If no LICENSE file comes with this software, it is provided AS-IS.
22   *
23   ******************************************************************************
24   @verbatim
25   ==============================================================================
26                         ##### How to use this driver #####
27   ==============================================================================
28   [..]
29      The sequence below describes how to use this driver to capture image
30      from a camera module connected to the DCMIPP Interface.
31      This sequence does not take into account the configuration of the
32      camera module, which should be made before to configure and enable
33      the DCMIPP to capture images.
34 
35      (#) Program the required configuration through the following parameters:
36          the Format, the VSPolarity,the HSPolarity, the PCKPolarity, the ExtendedDataMode
37          the SynchroMode, the SynchroCodes of the frame delimite, the SwapBits and the SwapCycles
38          using HAL_DCMIPP_Init() and HAL_DCMIPP_SetParallelConfig
39      (#) Program the required configuration through the following parameters:
40          the FrameRate using HAL_DCMIPP_PIPE_Config function.
41 
42   *** Interrupt mode IO operation ***
43   ===================================
44      (#) Configure Pipe parameter, destination (one or two) and Capture Mode (Snapshot or Continuous) and enable
45          the capture request using the following functions:
46          HAL_DCMIPP_PIPE_Start() or HAL_DCMIPP_PIPE_DoubleBufferStart().
47 
48      (#) Use HAL_DCMIPP_IRQHandler() called under DCMIPP_IRQHandler() interrupt subroutine.
49      (#) At the end of frame capture request HAL_DCMIPP_IRQHandler() function is executed and user can
50          add his own function by customization of function pointer PipeFrameEventCallback (member
51          of DCMIPP handle structure).
52      (#) In case of common error, the HAL_DCMIPP_IRQHandler() function calls the callback
53          ErrorCallback otherwise in case of Pipe error
54          the HAL_DCMIPP_IRQHandler() function calls the callbackPipeErrorCallback.
55 
56     (#) The Pipe capture can be suspended and resumed using the following functions
57         HAL_DCMIPP_PIPE_Suspend() and HAL_DCMIPP_PIPE_Resume().
58 
59     (#) For Snapshot Mode the capture can be re-enabled using the HAL_DCMIPP_PIPE_EnableCapture();
60 
61     (#) Optionally, Program the required configuration through the following parameters:
62         Client, MemoryPageSize, Traffic, MaxOutstandingTransactions, DPREGStart, DPREGEnd
63         and WLRURatio using HAL_DCMIPP_SetIPPlugConfig().
64 
65     (#) Optionally, configure and Enable the CROP feature to select a rectangular
66         window from the received image using HAL_DCMIPP_PIPE_SetCropConfig()
67         and HAL_DCMIPP_PIPE_EnableCrop() functions.
68 
69     (#) Optionally, configure and Enable the line and bytes decimation features
70         using the following functions HAL_DCMIPP_PIPE_SetLinesDecimationConfig and
71         HAL_DCMIPP_PIPE_SetBytesDecimationConfig.
72 
73     (#) Optionally, configure and enable the line event using the function HAL_DCMIPP_PIPE_EnableLineEvent().
74 
75     (#) Optionally, configure and enable the Limit event using the function HAL_DCMIPP_PIPE_EnableLimitEvent().
76 
77     (#) If needed, reconfigure and change the input pixel format value, the frame rate
78         value, the capture Mode , the destination memory address , the syncunmask values,
79         Multiline value and Limit value using respectively
80         the following functions: HAL_DCMIPP_PIPE_SetInputPixelFormat(), HAL_DCMIPP_PIPE_SetFrameRate(),
81         HAL_DCMIPP_PIPE_SetCaptureMode(), HAL_DCMIPP_PIPE_SetMemoryAddress(), HAL_DCMIPP_SetSyncUnmask(),
82         HAL_DCMIPP_PIPE_EnableLineEvent() and HAL_DCMIPP_PIPE_EnableLimitEvent().
83 
84     (#) To read the transferred data counter , use the HAL_DCMIPP_PIPE_GetDataCounter()
85 
86     (#) To read and reset the Frame counter of the pipe, use the following functions:
87         HAL_DCMIPP_PIPE_ReadFrameCounter() and HAL_DCMIPP_PIPE_ResetFrameCounter().
88 
89     (#) The Pipe capture can be Stopped using HAL_DCMIPP_PIPE_Stop() function.
90 
91 
92     (#) To control the DCMIPP state, use the following function: HAL_DCMIPP_GetState().
93 
94     (#) To control the DCMIPP Pipe state, use the following function: HAL_DCMIPP_PIPE_GetState().
95 
96     (#) To read the DCMIPP error code, use the following function: HAL_DCMIPP_GetError().
97 
98   *** DCMIPP HAL driver macros list ***
99   =============================================
100   [..]
101      Below the list of most used macros in DCMIPP HAL driver :
102 
103      (+) __HAL_DCMIPP_GET_FLAG: Get the DCMIPP pending flags.
104      (+) __HAL_DCMIPP_CLEAR_FLAG: Clear the DCMIPP pending flags.
105      (+) __HAL_DCMIPP_ENABLE_IT: Enable the specified DCMIPP interrupts.
106      (+) __HAL_DCMIPP_DISABLE_IT: Disable the specified DCMIPP interrupts.
107      (+) __HAL_DCMIPP_GET_IT_SOURCE: Check whether the specified DCMIPP interrupt is enabled or not.
108 
109   *** Callback registration ***
110   ===================================
111   [..]
112      (#) The compilation define  USE_HAL_DCMIPP_REGISTER_CALLBACKS when set to 1
113           allows the user to configure dynamically the driver callbacks.
114           Use function @ref HAL_DCMIPP_RegisterCallback() to register a user callback.
115           Use function @ref HAL_DCMIPP_PIPE_RegisterCallback() to register a user pipe callback.
116 
117      (#) Function @ref HAL_DCMIPP_RegisterCallback() allows to register following callbacks:
118          (+) ErrorCallback          : callback for Error
119          (+) MspInitCallback        : DCMIPP MspInit.
120          (+) MspDeInitCallback      : DCMIPP MspDeInit.
121           This function takes as parameters the HAL peripheral handle, the Callback ID
122           and a pointer to the user callback function.
123      (#) Function @ref HAL_DCMIPP_PIPE_RegisterCallback() allows to register following callbacks:
124          (+) PipeFrameEventCallback : callback for Pipe Frame Event.
125          (+) PipeVsyncEventCallback : callback for Pipe Vsync Event.
126          (+) PipeLineEventCallback  : callback for Pipe Line Event.
127          (+) PipeLimitEventCallback : callback for Pipe Limit Event.
128          (+) PipeErrorCallback      : callback for Pipe Error
129           This function takes as parameters the HAL peripheral handle, the Callback ID
130           and a pointer to the user callback function.
131 
132      (#) Use function @ref HAL_DCMIPP_UnRegisterCallback() to reset a callback to the default
133          weak (surcharged) function.
134          @ref HAL_DCMIPP_UnRegisterCallback() takes as parameters the HAL peripheral handle,
135          and the Callback ID.
136          This function allows to reset following callbacks:
137          (+) ErrorCallback          : callback for Error
138          (+) MspInitCallback        : DCMIPP MspInit.
139          (+) MspDeInitCallback      : DCMIPP MspDeInit.
140      (#) Use function @ref HAL_DCMIPP_PIPE_UnRegisterCallback() to reset a pipe callback to the default
141          weak (surcharged) function.
142          @ref HAL_DCMIPP_PIPE_UnRegisterCallback() takes as parameters the HAL peripheral handle,
143          and the Callback ID.
144          This function allows to reset following callbacks:
145          (+) PipeFrameEventCallback : callback for Pipe Frame Event.
146          (+) PipeVsyncEventCallback : callback for Pipe Vsync Event.
147          (+) PipeLineEventCallback  : callback for Pipe Line Event.
148          (+) PipeLimitEventCallback : callback for Pipe Limit Event.
149          (+) PipeErrorCallback      : callback for Pipe Error
150 
151      (#) By default, after the @ref HAL_DCMIPP_Init and if the state is HAL_DCMIPP_STATE_RESET
152          all callbacks are reset to the corresponding legacy weak (surcharged) functions:
153          examples @ref PipeFrameEventCallback(), @ref PipeVsyncEventCallback()
154          Exception done for MspInit and MspDeInit callbacks that are respectively
155          reset to the legacy weak (surcharged) functions in the @ref HAL_DCMIPP_Init
156          and @ref HAL_DCMIPP_DeInit only when these callbacks are null (not registered beforehand)
157          If not, MspInit or MspDeInit are not null, the @ref HAL_DCMIPP_Init and @ref HAL_DCMIPP_DeInit
158          keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
159 
160          Callbacks can be registered/unregistered in READY state only.
161          Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
162          in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
163          during the Init/DeInit.
164          In that case first register the MspInit/MspDeInit user callbacks
165          using @ref HAL_DCMIPP_RegisterCallback before calling @ref HAL_DCMIPP_DeInit
166          or @ref HAL_DCMIPP_Init function.
167 
168          When The compilation define USE_HAL_DCMIPP_REGISTER_CALLBACKS is set to 0 or
169          not defined, the callback registering feature is not available
170          and weak (surcharged) callbacks are used.
171 
172      [..]
173       (@) You can refer to the DCMIPP HAL driver header file for more useful macros
174   @endverbatim
175   ******************************************************************************
176   */
177 
178 /* Includes ------------------------------------------------------------------*/
179 #include "stm32h7rsxx_hal.h"
180 
181 #ifdef HAL_DCMIPP_MODULE_ENABLED
182 #if defined (DCMIPP)
183 
184 /** @addtogroup STM32H7RSxx_HAL_Driver
185   * @{
186   */
187 /** @defgroup DCMIPP DCMIPP
188   * @brief DCMIPP HAL module driver
189   * @{
190   */
191 
192 /* Private typedef -----------------------------------------------------------*/
193 /* Private define ------------------------------------------------------------*/
194 /** @defgroup DCMIPP_Private_Constants DCMIPP Private Constants
195   * @{
196   */
197 #define DCMIPP_TIMEOUT 1000U  /*!<  1s  */
198 /**
199   * @}
200   */
201 /* Private macro -------------------------------------------------------------*/
202 /* Private variables ---------------------------------------------------------*/
203 /* Private function prototypes -----------------------------------------------*/
204 /** @defgroup DCMIPP_Private_Functions DCMIPP Private Functions
205   * @{
206   */
207 static void Pipe_Config(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, const DCMIPP_PipeConfTypeDef *pPipeConfig);
208 static void DCMIPP_SetConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t DstAddress, uint32_t CaptureMode);
209 static void DCMIPP_SetDBMConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t DstAddress0,
210                                 uint32_t DstAddress1, uint32_t CaptureMode);
211 static void DCMIPP_EnableCapture(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe);
212 static HAL_StatusTypeDef DCMIPP_Stop(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe);
213 /**
214   * @}
215   */
216 /* Private functions ---------------------------------------------------------*/
217 /** @defgroup DCMIPP_Private_Functions DCMIPP Private Functions
218   * @{
219   */
220 /**
221   * @brief  Configure the selected Pipe
222   * @param  hdcmipp     Pointer to DCMIPP handle
223   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
224   * @param  pPipeConfig pointer to the DCMIPP_PipeConfTypeDef structure that contains
225   *                     the configuration information for the pipe.
226   * @retval None
227   */
Pipe_Config(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,const DCMIPP_PipeConfTypeDef * pPipeConfig)228 static void Pipe_Config(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, const DCMIPP_PipeConfTypeDef *pPipeConfig)
229 {
230   if (Pipe == DCMIPP_PIPE0)
231   {
232     /* Configure Pipe0 */
233     /* Configure Frame Rate */
234     MODIFY_REG(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_FRATE, pPipeConfig->FrameRate);
235   }
236 }
237 /**
238   * @brief  Configure the destination address and capture mode for the selected pipe
239   * @param  hdcmipp     Pointer to DCMIPP handle
240   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
241   * @param  DstAddress  Specifies the destination memory address for the captured data.
242   * @param  CaptureMode Specifies the capture mode to be set for the pipe.
243   * @retval None
244   */
DCMIPP_SetConfig(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t DstAddress,uint32_t CaptureMode)245 static void DCMIPP_SetConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t DstAddress, uint32_t CaptureMode)
246 {
247   if (Pipe == DCMIPP_PIPE0)
248   {
249     /* Update the DCMIPP pipe State */
250     hdcmipp->PipeState[Pipe] = HAL_DCMIPP_PIPE_STATE_BUSY;
251 
252     /* Set the capture mode */
253     hdcmipp->Instance->P0FCTCR |= CaptureMode;
254 
255     /* Set the destination address */
256     WRITE_REG(hdcmipp->Instance->P0PPM0AR1, DstAddress);
257 
258     /* Enable all required interrupts lines for the PIPE0 */
259     __HAL_DCMIPP_ENABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_FRAME | DCMIPP_IT_PIPE0_VSYNC | DCMIPP_IT_PIPE0_OVR |
260                            DCMIPP_IT_AXI_TRANSFER_ERROR);
261   }
262 }
263 /**
264   * @brief  Configure the destination addresses and capture mode for the selected pipe for Double Buffering Mode
265   * @param  hdcmipp     Pointer to DCMIPP handle
266   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
267   * @param  DstAddress0 Specifies the first destination memory address for the captured data.
268   * @param  DstAddress1 Specifies the second destination memory address for the captured data.
269   * @param  CaptureMode Specifies the capture mode to be set for the pipe.
270   * @retval None
271   */
DCMIPP_SetDBMConfig(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t DstAddress0,uint32_t DstAddress1,uint32_t CaptureMode)272 static void DCMIPP_SetDBMConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t DstAddress0,
273                                 uint32_t DstAddress1, uint32_t CaptureMode)
274 {
275   if (Pipe == DCMIPP_PIPE0)
276   {
277     /* Update the DCMIPP pipe State */
278     hdcmipp->PipeState[Pipe] = HAL_DCMIPP_PIPE_STATE_BUSY;
279 
280     /* Set the capture mode */
281     hdcmipp->Instance->P0FCTCR |= CaptureMode;
282 
283     /* Set the destination address */
284     WRITE_REG(hdcmipp->Instance->P0PPM0AR1, DstAddress0);
285 
286     /* Set the second destination address */
287     WRITE_REG(hdcmipp->Instance->P0PPM0AR2, DstAddress1);
288 
289     /* Enable Double buffering Mode */
290     SET_BIT(hdcmipp->Instance->P0PPCR, DCMIPP_P0PPCR_DBM);
291 
292     /* Enable all required interrupts lines for the Pipe0 */
293     __HAL_DCMIPP_ENABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_FRAME | DCMIPP_IT_PIPE0_VSYNC | DCMIPP_IT_PIPE0_OVR);
294   }
295 }
296 /**
297   * @brief  Enable the capture for the specified DCMIPP pipe.
298   * @param  hdcmipp     Pointer to DCMIPP handle
299   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
300   * @retval None
301   */
DCMIPP_EnableCapture(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)302 static void DCMIPP_EnableCapture(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
303 {
304   if (Pipe == DCMIPP_PIPE0)
305   {
306     /* Activate the Pipe */
307     SET_BIT(hdcmipp->Instance->P0FSCR, DCMIPP_P0FSCR_PIPEN);
308 
309     /* Start the capture */
310     SET_BIT(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_CPTREQ);
311   }
312 }
313 /**
314   * @brief  Stop the capture for the specified DCMIPP pipe.
315   * @param  hdcmipp     Pointer to DCMIPP handle
316   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
317   * @retval HAL status
318   */
DCMIPP_Stop(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)319 static HAL_StatusTypeDef DCMIPP_Stop(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
320 {
321   uint32_t tickstart;
322 
323   if (Pipe == DCMIPP_PIPE0)
324   {
325     /* Stop the capture */
326     CLEAR_BIT(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_CPTREQ);
327 
328     /* Poll CPTACT status till No capture currently active */
329     tickstart = HAL_GetTick();
330     do
331     {
332       if ((HAL_GetTick() - tickstart) > DCMIPP_TIMEOUT)
333       {
334         return HAL_ERROR;
335       }
336     } while ((hdcmipp->Instance->CMSR1 & DCMIPP_CMSR1_P0CPTACT) != 0U);
337 
338     /* Disable DBM when enabled */
339     if ((hdcmipp->Instance->P0PPCR & DCMIPP_P0PPCR_DBM) == DCMIPP_P0PPCR_DBM)
340     {
341       CLEAR_BIT(hdcmipp->Instance->P0PPCR, DCMIPP_P0PPCR_DBM);
342     }
343 
344     /* Disable the pipe */
345     CLEAR_BIT(hdcmipp->Instance->P0FSCR, DCMIPP_P0FSCR_PIPEN);
346 
347     /* Disable all interrupts for this pipe */
348     __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_FRAME | DCMIPP_IT_PIPE0_VSYNC | DCMIPP_IT_PIPE0_LINE | \
349                             DCMIPP_IT_PIPE0_LIMIT | DCMIPP_IT_PIPE0_OVR);
350 
351   }
352 
353   return HAL_OK;
354 }
355 /**
356   * @}
357   */
358 
359 /* Exported functions --------------------------------------------------------*/
360 
361 /** @defgroup DCMIPP_Exported_Functions DCMIPP Exported Functions
362   * @{
363   */
364 
365 /** @addtogroup DCMIPP_Initialization_De-Initialization_Functions DCMIPP Initialization De-Initialization Functions
366   *  @brief     Initialization and De-Initialization Functions
367   * @{
368   */
369 
370 /**
371   * @brief  Initialize the selected HAL DCMIPP handle and associate a DCMIPP peripheral instance.
372   * @param  hdcmipp  Pointer to DCMIPP handle
373   * @retval HAL status
374   */
HAL_DCMIPP_Init(DCMIPP_HandleTypeDef * hdcmipp)375 HAL_StatusTypeDef HAL_DCMIPP_Init(DCMIPP_HandleTypeDef *hdcmipp)
376 {
377   uint32_t pipe_index;
378 
379   /* Check pointer validity */
380   if (hdcmipp == NULL)
381   {
382     return HAL_ERROR;
383   }
384 
385   /* Check function parameters */
386   assert_param(IS_DCMIPP_ALL_INSTANCE(hdcmipp->Instance));
387 
388   if (hdcmipp->State == HAL_DCMIPP_STATE_RESET)
389   {
390     /* Init the DCMIPP Callback settings */
391 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
392     /* Reset callback pointers to the weak predefined callbacks */
393     hdcmipp->PIPE_FrameEventCallback = HAL_DCMIPP_PIPE_FrameEventCallback;
394     hdcmipp->PIPE_VsyncEventCallback = HAL_DCMIPP_PIPE_VsyncEventCallback;
395     hdcmipp->PIPE_LineEventCallback  = HAL_DCMIPP_PIPE_LineEventCallback;
396     hdcmipp->PIPE_LimitEventCallback = HAL_DCMIPP_PIPE_LimitEventCallback;
397     hdcmipp->PIPE_ErrorCallback      = HAL_DCMIPP_PIPE_ErrorCallback;
398     hdcmipp->ErrorCallback           = HAL_DCMIPP_ErrorCallback;
399     if (hdcmipp->MspInitCallback == NULL)
400     {
401       /* Legacy weak MspInit Callback        */
402       hdcmipp->MspInitCallback = HAL_DCMIPP_MspInit;
403     }
404     /* Initialize the low level hardware (MSP) */
405     hdcmipp->MspInitCallback(hdcmipp);
406 #else
407     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
408     HAL_DCMIPP_MspInit(hdcmipp);
409 #endif /* (USE_HAL_DCMIPP_REGISTER_CALLBACKS) */
410   }
411 
412   /* Change the DCMIPP state */
413   hdcmipp->State = HAL_DCMIPP_STATE_BUSY;
414 
415   /* Reset DCMIPP Pipe state */
416   for (pipe_index = 0U; pipe_index < DCMIPP_NUM_OF_PIPES; pipe_index++)
417   {
418     hdcmipp->PipeState[pipe_index] = HAL_DCMIPP_PIPE_STATE_RESET;
419   }
420 
421   /* Update error code */
422   hdcmipp->ErrorCode = HAL_DCMIPP_ERROR_NONE;
423 
424   /* Update the DCMIPP state*/
425   hdcmipp->State = HAL_DCMIPP_STATE_INIT;
426 
427   return HAL_OK;
428 }
429 
430 /**
431   * @brief  De-initializes the DCMIPP peripheral registers to their default reset values.
432   * @param  hdcmipp  Pointer to DCMIPP handle
433   * @retval HAL status
434   */
HAL_DCMIPP_DeInit(DCMIPP_HandleTypeDef * hdcmipp)435 HAL_StatusTypeDef HAL_DCMIPP_DeInit(DCMIPP_HandleTypeDef *hdcmipp)
436 {
437   uint32_t pipe_index;
438 
439   /* Check pointer validity */
440   if (hdcmipp == NULL)
441   {
442     return HAL_ERROR;
443   }
444 
445   /* Disable the Parallel Interface */
446   hdcmipp->Instance->PRCR &= ~DCMIPP_PRCR_ENABLE;
447 
448   /* Reset flow selection configuration register for the Pipe0 */
449   hdcmipp->Instance->P0FSCR = 0;
450 
451 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
452   if (hdcmipp->MspDeInitCallback == NULL)
453   {
454     hdcmipp->MspDeInitCallback = HAL_DCMIPP_MspDeInit;
455   }
456 
457   /* DeInit the low level hardware */
458   hdcmipp->MspDeInitCallback(hdcmipp);
459 #else
460   /* DeInit the low level hardware */
461   HAL_DCMIPP_MspDeInit(hdcmipp);
462 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
463 
464   /* Update error code */
465   hdcmipp->ErrorCode = HAL_DCMIPP_ERROR_NONE;
466 
467   /* Initialize the DCMIPP state*/
468   hdcmipp->State = HAL_DCMIPP_STATE_RESET;
469 
470   /* Reset DCMIPP Pipe state */
471   for (pipe_index = 0U; pipe_index < DCMIPP_NUM_OF_PIPES; pipe_index++)
472   {
473     hdcmipp->PipeState[pipe_index] = HAL_DCMIPP_PIPE_STATE_RESET;
474   }
475 
476   return HAL_OK;
477 }
478 
479 /**
480   * @brief  Initializes the DCMIPP MSP.
481   * @param  hdcmipp  Pointer to DCMIPP handle
482   * @retval None
483   */
HAL_DCMIPP_MspInit(DCMIPP_HandleTypeDef * hdcmipp)484 __weak void HAL_DCMIPP_MspInit(DCMIPP_HandleTypeDef *hdcmipp)
485 {
486   /* Prevent unused argument(s) compilation warning */
487   UNUSED(hdcmipp);
488 
489   /* NOTE : This function Should not be modified, when the callback is needed,
490             the HAL_DCMIPP_MspInit could be implemented in the user file
491    */
492 }
493 
494 /**
495   * @brief  De-Initializes the DCMIPP MSP.
496   * @param  hdcmipp  Pointer to DCMIPP handle
497   * @retval None
498   */
HAL_DCMIPP_MspDeInit(DCMIPP_HandleTypeDef * hdcmipp)499 __weak void HAL_DCMIPP_MspDeInit(DCMIPP_HandleTypeDef *hdcmipp)
500 {
501   /* Prevent unused argument(s) compilation warning */
502   UNUSED(hdcmipp);
503 
504   /* NOTE : This function Should not be modified, when the callback is needed,
505             the HAL_DCMIPP_MspDeInit could be implemented in the user file
506    */
507 }
508 /**
509   * @}
510   */
511 
512 /** @defgroup DCMIPP_Configuration_Functions DCMIPP Configuration Functions
513   * @brief    Configuration Functions
514   * @{
515   */
516 /**
517   * @brief  Configure the DCMIPP Parallel Interface according to the user parameters.
518   * @param  hdcmipp         Pointer to DCMIPP handle
519   * @param  pParallelConfig pointer to DCMIPP_ParallelConfTypeDef that contains
520   *                         the parallel Interface configuration information for DCMIPP.
521   * @retval HAL status
522   */
HAL_DCMIPP_PARALLEL_SetConfig(DCMIPP_HandleTypeDef * hdcmipp,const DCMIPP_ParallelConfTypeDef * pParallelConfig)523 HAL_StatusTypeDef HAL_DCMIPP_PARALLEL_SetConfig(DCMIPP_HandleTypeDef *hdcmipp,
524                                                 const DCMIPP_ParallelConfTypeDef *pParallelConfig)
525 {
526   uint32_t prcr_reg;
527   uint32_t prescr_reg;
528 
529   /* Check parameters */
530   if ((hdcmipp == NULL) || (pParallelConfig == NULL))
531   {
532     return HAL_ERROR;
533   }
534 
535   /* Check function parameters */
536   assert_param(IS_DCMIPP_FORMAT(pParallelConfig->Format));
537   assert_param(IS_DCMIPP_VSPOLARITY(pParallelConfig->VSPolarity));
538   assert_param(IS_DCMIPP_HSPOLARITY(pParallelConfig->HSPolarity));
539   assert_param(IS_DCMIPP_PCKPOLARITY(pParallelConfig->PCKPolarity));
540   assert_param(IS_DCMIPP_EXTENDED_DATA_MODE(pParallelConfig->ExtendedDataMode));
541   assert_param(IS_DCMIPP_SYNC_MODE(pParallelConfig->SynchroMode));
542   assert_param(IS_DCMIPP_SWAP_BITS(pParallelConfig->SwapBits));
543   assert_param(IS_DCMIPP_SWAP_CYCLES(pParallelConfig->SwapCycles));
544 
545   /* Check DCMIPP state */
546   if (hdcmipp->State != HAL_DCMIPP_STATE_INIT)
547   {
548     return HAL_ERROR;
549   }
550   else
551   {
552     /* Configures the Format, VS, HS, PCK polarity, ExtendedDataMode, SynchronisationMode, Swap Cycles and bits */
553     prcr_reg  = ((pParallelConfig->Format)           | \
554                  (pParallelConfig->VSPolarity)       | \
555                  (pParallelConfig->HSPolarity)       | \
556                  (pParallelConfig->PCKPolarity)      | \
557                  (pParallelConfig->ExtendedDataMode) | \
558                  (pParallelConfig->SynchroMode)      | \
559                  (pParallelConfig->SwapCycles)       | \
560                  (pParallelConfig->SwapBits));
561 
562     WRITE_REG(hdcmipp->Instance->PRCR, prcr_reg);
563 
564     if (pParallelConfig->SynchroMode == DCMIPP_SYNCHRO_EMBEDDED)
565     {
566       /* Set Embedded Sync codes */
567       prescr_reg = (((uint32_t)pParallelConfig->SynchroCodes.FrameEndCode << DCMIPP_PRESCR_FEC_Pos)   | \
568                     ((uint32_t)pParallelConfig->SynchroCodes.LineEndCode << DCMIPP_PRESCR_LEC_Pos)    | \
569                     ((uint32_t)pParallelConfig->SynchroCodes.FrameStartCode << DCMIPP_PRESCR_FSC_Pos) | \
570                     ((uint32_t)pParallelConfig->SynchroCodes.LineStartCode << DCMIPP_PRESCR_LSC_Pos));
571 
572       WRITE_REG(hdcmipp->Instance->PRESCR, prescr_reg);
573 
574       /* Set Embedded Sync Unmask codes : All codes are unmasked */
575       WRITE_REG(hdcmipp->Instance->PRESUR, 0xFFFFFFFFU);
576     }
577 
578     /* Enable the Synchronization error interrupt on parallel interface */
579     __HAL_DCMIPP_ENABLE_IT(hdcmipp, DCMIPP_IT_PARALLEL_SYNC_ERROR);
580 
581     /* Enable Parallel interface */
582     SET_BIT(hdcmipp->Instance->PRCR, DCMIPP_PRCR_ENABLE);
583 
584   }
585 
586   /* Update the DCMIPP state */
587   hdcmipp->State = HAL_DCMIPP_STATE_READY;
588 
589   return HAL_OK;
590 }
591 
592 
593 /**
594   * @brief  Configure the pipe according to the user parameters.
595   * @param  hdcmipp     Pointer to DCMIPP handle
596   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
597   * @param  pPipeConfig pointer to pipe configuration structure
598   * @retval HAL status
599   */
HAL_DCMIPP_PIPE_SetConfig(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,const DCMIPP_PipeConfTypeDef * pPipeConfig)600 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
601                                             const DCMIPP_PipeConfTypeDef *pPipeConfig)
602 {
603   HAL_DCMIPP_PipeStateTypeDef pipe_state;
604 
605   /* Check the DCMIPP peripheral handle parameter and pPipeConfig parameter */
606   if ((hdcmipp == NULL) || (pPipeConfig == NULL))
607   {
608     return HAL_ERROR;
609   }
610 
611   /* Check the parameters */
612   assert_param(IS_DCMIPP_ALL_INSTANCE(hdcmipp->Instance));
613   assert_param(IS_DCMIPP_PIPE(Pipe));
614   assert_param(IS_DCMIPP_FRAME_RATE(pPipeConfig->FrameRate));
615   /* Get Pipe State */
616   pipe_state = hdcmipp->PipeState[Pipe];
617 
618   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
619   {
620     if ((pipe_state == HAL_DCMIPP_PIPE_STATE_RESET) || (pipe_state == HAL_DCMIPP_PIPE_STATE_ERROR))
621     {
622       /* Update the DCMIPP PIPE state */
623       hdcmipp->PipeState[Pipe] = HAL_DCMIPP_PIPE_STATE_BUSY;
624 
625       /* Initialize the DCMIPP Pipe registers */
626       Pipe_Config(hdcmipp, Pipe, pPipeConfig);
627 
628       /* Update the DCMIPP pipe state */
629       hdcmipp->PipeState[Pipe] = HAL_DCMIPP_PIPE_STATE_READY;
630     }
631     else
632     {
633       return HAL_ERROR;
634     }
635   }
636   else
637   {
638     return HAL_ERROR;
639   }
640 
641   return HAL_OK;
642 }
643 
644 /**
645   * @brief  Configure the DCMIPP AXI master memory IP-Plug.
646   * @param  hdcmipp       Pointer to DCMIPP handle
647   * @param  pIPPlugConfig pointer to IPPLUG configuration structure
648   * @retval HAL status
649   */
HAL_DCMIPP_SetIPPlugConfig(DCMIPP_HandleTypeDef * hdcmipp,const DCMIPP_IPPlugConfTypeDef * pIPPlugConfig)650 HAL_StatusTypeDef HAL_DCMIPP_SetIPPlugConfig(DCMIPP_HandleTypeDef *hdcmipp,
651                                              const DCMIPP_IPPlugConfTypeDef *pIPPlugConfig)
652 {
653   uint32_t tickstart;
654 
655   /* Check handle validity */
656   if ((hdcmipp == NULL) || (pIPPlugConfig == NULL))
657   {
658     return HAL_ERROR;
659   }
660 
661   /* Check the parameters */
662   assert_param(IS_DCMIPP_CLIENT(pIPPlugConfig->Client));
663   assert_param(IS_DCMIPP_DPREG_END(pIPPlugConfig->DPREGEnd));
664   assert_param(IS_DCMIPP_DPREG_START(pIPPlugConfig->DPREGStart));
665   assert_param(IS_DCMIPP_MAX_OUTSTANDING_TRANSACTIONS(pIPPlugConfig->MaxOutstandingTransactions));
666   assert_param(IS_DCMIPP_MEMORY_PAGE_SIZE(pIPPlugConfig->MemoryPageSize));
667   assert_param(IS_DCMIPP_TRAFFIC(pIPPlugConfig->Traffic));
668   assert_param(IS_DCMIPP_WLRU_RATIO(pIPPlugConfig->WLRURatio));
669 
670 
671   if (hdcmipp->State != HAL_DCMIPP_STATE_RESET)
672   {
673     /* Request to lock the IP-Plug, to allow reconfiguration */
674     SET_BIT(hdcmipp->Instance->IPGR2, DCMIPP_IPGR2_PSTART);
675 
676     tickstart = HAL_GetTick();
677     do
678     {
679       if ((HAL_GetTick() - tickstart) > DCMIPP_TIMEOUT)
680       {
681         return HAL_ERROR;
682       }
683     } while ((hdcmipp->Instance->IPGR3 & DCMIPP_IPGR3_IDLE) != DCMIPP_IPGR3_IDLE);
684   }
685   else
686   {
687     return HAL_ERROR;
688   }
689 
690   /* IP-Plug is currently locked and can be reconfigured */
691 
692   /* Set Memory page size */
693   hdcmipp->Instance->IPGR1 = (pIPPlugConfig->MemoryPageSize);
694 
695   /* IP-PLUG Client1 configuration */
696   switch (pIPPlugConfig->Client)
697   {
698     case DCMIPP_CLIENT1:
699     {
700       /* Set Traffic : Burst size and Maximum Outstanding transactions */
701       hdcmipp->Instance->IPC1R1 = (pIPPlugConfig->Traffic |
702                                    (pIPPlugConfig->MaxOutstandingTransactions << DCMIPP_IPC1R1_OTR_Pos));
703 
704       /* Set End word and Start Word of the FIFO of the Clientx */
705       hdcmipp->Instance->IPC1R2 = (pIPPlugConfig->WLRURatio << DCMIPP_IPC1R2_WLRU_Pos);
706 
707       /* Set End word and Start Word of the FIFO of the Clientx */
708       hdcmipp->Instance->IPC1R3 = ((pIPPlugConfig->DPREGStart << DCMIPP_IPC1R3_DPREGSTART_Pos) |
709                                    (pIPPlugConfig->DPREGEnd << DCMIPP_IPC1R3_DPREGEND_Pos));
710       break;
711     }
712     default:
713       break;
714   }
715 
716   /* No lock requested, IP-Plug runs on demand by background HW */
717   CLEAR_BIT(hdcmipp->Instance->IPGR2, DCMIPP_IPGR2_PSTART);
718 
719   /* Enable DCMIPP_IT_AXI_TRANSFER_ERR */
720   __HAL_DCMIPP_ENABLE_IT(hdcmipp, DCMIPP_IT_AXI_TRANSFER_ERROR);
721 
722   return HAL_OK;
723 }
724 
725 /**
726   * @}
727   */
728 
729 /** @addtogroup DCMIPP_IO_operation_Functions DCMIPP IO operation Functions
730   *  @brief     IO operation functions
731   * @{
732   */
733 /**
734   * @brief  Start the DCMIPP capture on the specified pipe
735   * @param  hdcmipp     Pointer to DCMIPP handle
736   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
737   * @param  DstAddress  the destination address
738   * @param  CaptureMode DCMIPP capture mode for the pipe can be a value from @ref DCMIPP_Capture_Mode.
739   * @retval HAL status
740   */
HAL_DCMIPP_PIPE_Start(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t DstAddress,uint32_t CaptureMode)741 HAL_StatusTypeDef HAL_DCMIPP_PIPE_Start(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t DstAddress,
742                                         uint32_t CaptureMode)
743 {
744   assert_param(IS_DCMIPP_PIPE(Pipe));
745   assert_param(IS_DCMIPP_CAPTURE_MODE(CaptureMode));
746 
747   /* Check pointer validity */
748   if ((hdcmipp == NULL) || ((DstAddress & 0xFU) != 0U))
749   {
750     return HAL_ERROR;
751   }
752 
753   /* Check DCMIPP pipe state */
754   if (hdcmipp->PipeState[Pipe]  != HAL_DCMIPP_PIPE_STATE_READY)
755   {
756     return HAL_ERROR;
757   }
758 
759   /* Set Capture Mode and Destination address for the selected pipe */
760   DCMIPP_SetConfig(hdcmipp, Pipe, DstAddress, CaptureMode);
761 
762   /* Enable Capture for the selected Pipe */
763   DCMIPP_EnableCapture(hdcmipp, Pipe);
764 
765   return HAL_OK;
766 }
767 
768 /**
769   * @brief  Start the DCMIPP capture on the specified pipe with double buffering Mode
770   * @param  hdcmipp     Pointer to DCMIPP handle
771   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
772   * @param  DstAddress0 the first destination address
773   * @param  DstAddress1 the second destination address
774   * @param  CaptureMode DCMIPP capture mode for the pipe can be a value from @ref DCMIPP_Capture_Mode.
775   * @retval HAL status
776   */
HAL_DCMIPP_PIPE_DoubleBufferStart(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t DstAddress0,uint32_t DstAddress1,uint32_t CaptureMode)777 HAL_StatusTypeDef HAL_DCMIPP_PIPE_DoubleBufferStart(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t DstAddress0,
778                                                     uint32_t DstAddress1, uint32_t CaptureMode)
779 {
780   assert_param(IS_DCMIPP_PIPE(Pipe));
781   assert_param(IS_DCMIPP_CAPTURE_MODE(CaptureMode));
782 
783   /* Check pointer validity */
784   if ((hdcmipp == NULL) || ((DstAddress0 & 0xFU) != 0U) || ((DstAddress1 & 0xFU) != 0U))
785   {
786     return HAL_ERROR;
787   }
788 
789   /* Check DCMIPP pipe state */
790   if (hdcmipp->PipeState[Pipe]  != HAL_DCMIPP_PIPE_STATE_READY)
791   {
792     return HAL_ERROR;
793   }
794 
795   /* Set Capture Mode and Destination addresses for the selected pipe */
796   DCMIPP_SetDBMConfig(hdcmipp, Pipe, DstAddress0, DstAddress1, CaptureMode);
797 
798   /* Enable Capture for the selected Pipe */
799   DCMIPP_EnableCapture(hdcmipp, Pipe);
800 
801   return HAL_OK;
802 }
803 
804 /**
805   * @brief  Stop DCMIPP capture on the specified pipe
806   * @param  hdcmipp  Pointer to DCMIPP handle
807   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
808   * @retval HAL status
809   */
HAL_DCMIPP_PIPE_Stop(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)810 HAL_StatusTypeDef HAL_DCMIPP_PIPE_Stop(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
811 {
812   HAL_DCMIPP_PipeStateTypeDef pipe_state;
813 
814   assert_param(IS_DCMIPP_PIPE(Pipe));
815 
816   /* Check pointer validity */
817   if (hdcmipp == NULL)
818   {
819     return HAL_ERROR;
820   }
821 
822   /* Get Pipe State */
823   pipe_state = hdcmipp->PipeState[Pipe];
824 
825   /* Check DCMIPP Pipe state */
826   if (pipe_state != HAL_DCMIPP_PIPE_STATE_RESET)
827   {
828     if (DCMIPP_Stop(hdcmipp, Pipe) != HAL_OK)
829     {
830       return HAL_ERROR;
831     }
832 
833     /* Update the DCMIPP pipe State */
834     hdcmipp->PipeState[Pipe] = HAL_DCMIPP_PIPE_STATE_READY;
835   }
836   else
837   {
838     return HAL_ERROR;
839   }
840 
841   return HAL_OK;
842 }
843 
844 /**
845   * @brief  Suspend DCMIPP capture on the specified pipe
846   * @param  hdcmipp  Pointer to DCMIPP handle
847   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
848   * @retval HAL status
849   */
HAL_DCMIPP_PIPE_Suspend(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)850 HAL_StatusTypeDef HAL_DCMIPP_PIPE_Suspend(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
851 {
852   HAL_DCMIPP_PipeStateTypeDef pipe_state;
853   uint32_t tickstart;
854 
855   assert_param(IS_DCMIPP_PIPE(Pipe));
856 
857   if (hdcmipp == NULL)
858   {
859     /* Return Function Status */
860     return HAL_ERROR;
861   }
862 
863   pipe_state = hdcmipp->PipeState[Pipe];
864 
865   if (Pipe == DCMIPP_PIPE0)
866   {
867     /* Check Pipe0 State */
868     if (pipe_state == HAL_DCMIPP_PIPE_STATE_BUSY)
869     {
870       /* Disable Capture Request */
871       CLEAR_BIT(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_CPTREQ);
872 
873       /* Change Pipe State */
874       hdcmipp->PipeState[0] = HAL_DCMIPP_PIPE_STATE_SUSPEND;
875 
876       /* Poll CPTACT status till No capture currently active */
877       tickstart = HAL_GetTick();
878       do
879       {
880         if ((HAL_GetTick() - tickstart) > DCMIPP_TIMEOUT)
881         {
882           /* Change Pipe State */
883           hdcmipp->PipeState[Pipe] = HAL_DCMIPP_PIPE_STATE_ERROR;
884 
885           return HAL_ERROR;
886         }
887       } while ((hdcmipp->Instance->CMSR1 & DCMIPP_CMSR1_P0CPTACT) != 0U);
888     }
889     else
890     {
891       /* Return Function Status */
892       return HAL_ERROR;
893     }
894   }
895   else
896   {
897     return HAL_ERROR;
898   }
899 
900   /* Return Function Status */
901   return HAL_OK;
902 }
903 
904 /**
905   * @brief  Resume DCMIPP capture on the specified pipe
906   * @param  hdcmipp  Pointer to DCMIPP handle
907   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
908   * @retval HAL status
909   */
HAL_DCMIPP_PIPE_Resume(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)910 HAL_StatusTypeDef HAL_DCMIPP_PIPE_Resume(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
911 {
912   HAL_DCMIPP_PipeStateTypeDef pipe_state ;
913 
914   assert_param(IS_DCMIPP_PIPE(Pipe));
915 
916   if (hdcmipp == NULL)
917   {
918     return HAL_ERROR;
919   }
920 
921   pipe_state = hdcmipp->PipeState[Pipe];
922 
923   if (Pipe == DCMIPP_PIPE0)
924   {
925     /* Check Pipe0 State */
926     if (pipe_state == HAL_DCMIPP_PIPE_STATE_SUSPEND)
927     {
928       /* Enable Capture Request */
929       SET_BIT(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_CPTREQ);
930 
931       /* Change Pipe State */
932       hdcmipp->PipeState[0] = HAL_DCMIPP_PIPE_STATE_BUSY;
933     }
934     else
935     {
936       return HAL_ERROR;
937     }
938   }
939   else
940   {
941     return HAL_ERROR;
942   }
943 
944   return HAL_OK;
945 }
946 
947 /**
948   * @}
949   */
950 
951 /** @addtogroup DCMIPP_IRQ_and_Callbacks_Functions DCMIPP IRQ and Callbacks Functions
952   * @brief      IRQ and Callbacks functions
953   * @{
954   */
955 
956 /** @addtogroup DCMIPP_IRQHandler_Function IRQHandler Function
957   * @{
958   */
959 /**
960   * @brief  Handles DCMIPP interrupt request.
961   * @param  hdcmipp  Pointer to DCMIPP handle
962   * @retval None
963   */
HAL_DCMIPP_IRQHandler(DCMIPP_HandleTypeDef * hdcmipp)964 void HAL_DCMIPP_IRQHandler(DCMIPP_HandleTypeDef *hdcmipp)
965 {
966   uint32_t cmsr2flags = READ_REG(hdcmipp->Instance->CMSR2);
967   uint32_t cmierflags = READ_REG(hdcmipp->Instance->CMIER);
968 
969   /* ========================= PIPE0 INTERRUPTS ==================== */
970   /* Limit error on the PIPE0 ********************************************/
971   if ((cmsr2flags & DCMIPP_FLAG_PIPE0_LIMIT) != 0U)
972   {
973     if ((cmierflags & DCMIPP_IT_PIPE0_LIMIT) != 0U)
974     {
975       /* Disable Limit error Interrupt for pipe0 */
976       __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_LIMIT);
977 
978       /* Update error code */
979       hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_PIPE0_LIMIT;
980 
981       /* Clear the Limit error flag */
982       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_PIPE0_LIMIT);
983 
984       /* LIMIT Callback */
985 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
986       hdcmipp->PIPE_LimitEventCallback(hdcmipp, DCMIPP_PIPE0);
987 #else
988       HAL_DCMIPP_PIPE_LimitEventCallback(hdcmipp, DCMIPP_PIPE0);
989 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
990     }
991   }
992 
993   /* VSYNC interrupt management **********************************************/
994   if ((cmsr2flags & DCMIPP_FLAG_PIPE0_VSYNC) != 0U)
995   {
996     if ((cmierflags & DCMIPP_IT_PIPE0_VSYNC) != 0U)
997     {
998       /* Clear the VSYNC flag for pipe0 */
999       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_PIPE0_VSYNC);
1000 
1001       /* VSYNC Callback */
1002 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1003       hdcmipp->PIPE_VsyncEventCallback(hdcmipp, DCMIPP_PIPE0);
1004 #else
1005       HAL_DCMIPP_PIPE_VsyncEventCallback(hdcmipp, DCMIPP_PIPE0);
1006 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1007     }
1008   }
1009 
1010   /* FRAME interrupt management ****************************/
1011   if ((cmsr2flags & DCMIPP_FLAG_PIPE0_FRAME) != 0U)
1012   {
1013     if ((cmierflags & DCMIPP_IT_PIPE0_FRAME) != 0U)
1014     {
1015       /* When snapshot mode, disable Vsync, Error and Overrun interrupts */
1016       if ((hdcmipp->Instance->P0FCTCR & DCMIPP_P0FCTCR_CPTMODE) == DCMIPP_MODE_SNAPSHOT)
1017       {
1018         __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_FRAME | DCMIPP_IT_PIPE0_VSYNC | DCMIPP_IT_PIPE0_OVR);
1019 
1020         /* Update Pipe State */
1021         hdcmipp->PipeState[0] = HAL_DCMIPP_PIPE_STATE_READY;
1022       }
1023 
1024       /* Clear the End of Frame flag */
1025       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_PIPE0_FRAME);
1026 
1027       /* Frame Callback */
1028 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1029       hdcmipp->PIPE_FrameEventCallback(hdcmipp, DCMIPP_PIPE0);
1030 #else
1031       HAL_DCMIPP_PIPE_FrameEventCallback(hdcmipp, DCMIPP_PIPE0);
1032 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1033     }
1034   }
1035 
1036   /* LINE interrupt management **********************************************/
1037   if ((cmsr2flags & DCMIPP_FLAG_PIPE0_LINE) != 0U)
1038   {
1039     if ((cmierflags & DCMIPP_IT_PIPE0_LINE) != 0U)
1040     {
1041       /* Clear the LINE flag */
1042       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_PIPE0_LINE);
1043 
1044       /* LINE Callback */
1045 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1046       hdcmipp->PIPE_LineEventCallback(hdcmipp, DCMIPP_PIPE0);
1047 #else
1048       HAL_DCMIPP_PIPE_LineEventCallback(hdcmipp, DCMIPP_PIPE0);
1049 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1050     }
1051   }
1052 
1053   /* Overrun error interrupt for Pipe0 ***************************************/
1054   if ((cmsr2flags & DCMIPP_FLAG_PIPE0_OVR) != 0U)
1055   {
1056     if ((cmierflags & DCMIPP_IT_PIPE0_OVR) != 0U)
1057     {
1058       /* Disable Overrun Error Interrupt for pipe0 */
1059       __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_OVR);
1060 
1061       /* Update error code */
1062       hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_PIPE0_OVR;
1063 
1064       /* Clear the overrun error flag */
1065       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_PIPE0_OVR);
1066 
1067       /* Change DCMIPP Pipe state */
1068       hdcmipp->PipeState[0] = HAL_DCMIPP_PIPE_STATE_ERROR;
1069 
1070       /* Error Callback */
1071 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1072       hdcmipp->PIPE_ErrorCallback(hdcmipp, DCMIPP_PIPE0);
1073 #else
1074       HAL_DCMIPP_PIPE_ErrorCallback(hdcmipp, DCMIPP_PIPE0);
1075 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1076     }
1077   }
1078 
1079 
1080   /* Synchronization Error Interrupt on the parallel interface  **************/
1081   if ((cmsr2flags & DCMIPP_FLAG_PARALLEL_SYNC_ERROR) != 0U)
1082   {
1083     if ((cmierflags & DCMIPP_IT_PARALLEL_SYNC_ERROR) != 0U)
1084     {
1085       /* Disable Synchronization error interrupt on parallel interface */
1086       __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PARALLEL_SYNC_ERROR);
1087 
1088       /* Update error code */
1089       hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_PARALLEL_SYNC;
1090 
1091       /* Clear the synchronization error flag */
1092       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_PARALLEL_SYNC_ERROR);
1093 
1094       /* Change DCMIPP state */
1095       hdcmipp->State = HAL_DCMIPP_STATE_ERROR;
1096 
1097       /* Error Callback */
1098 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1099       hdcmipp->ErrorCallback(hdcmipp);
1100 #else
1101       HAL_DCMIPP_ErrorCallback(hdcmipp);
1102 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1103     }
1104   }
1105 
1106   /* IPPLUG AXI transfer Error Interrupt     *********************************/
1107   if ((cmsr2flags & DCMIPP_FLAG_AXI_TRANSFER_ERROR) != 0U)
1108   {
1109     if ((cmierflags & DCMIPP_IT_AXI_TRANSFER_ERROR) != 0U)
1110     {
1111       /* Disable IPPLUG AXI transfer Error Interrupt */
1112       __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_AXI_TRANSFER_ERROR);
1113 
1114       /* Update error code */
1115       hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_AXI_TRANSFER;
1116 
1117       /* Clear the AXI transfer error flag */
1118       __HAL_DCMIPP_CLEAR_FLAG(hdcmipp, DCMIPP_FLAG_AXI_TRANSFER_ERROR);
1119 
1120       /* Change DCMIPP state */
1121       hdcmipp->State = HAL_DCMIPP_STATE_ERROR;
1122 
1123       /* Error Callback */
1124 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1125       hdcmipp->ErrorCallback(hdcmipp);
1126 #else
1127       HAL_DCMIPP_ErrorCallback(hdcmipp);
1128 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1129     }
1130   }
1131 }
1132 /**
1133   * @}
1134   */
1135 
1136 /** @addtogroup DCMIPP_Callback_Functions Callback Functions
1137   * @{
1138   */
1139 /**
1140   * @brief  Frame Event callback on the pipe
1141   * @param  hdcmipp  Pointer to DCMIPP handle
1142   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1143   * @retval None
1144   */
HAL_DCMIPP_PIPE_FrameEventCallback(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1145 __weak void HAL_DCMIPP_PIPE_FrameEventCallback(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1146 {
1147   /* NOTE : This function Should not be modified, when the callback is needed,
1148             the HAL_DCMIPP_FrameEventDumpPipeCallback could be implemented in the user file
1149    */
1150   /* Prevent unused argument(s) compilation warning */
1151   UNUSED(Pipe);
1152   UNUSED(hdcmipp);
1153 }
1154 
1155 /**
1156   * @brief  Vsync Event callback on pipe
1157   * @param  hdcmipp  Pointer to DCMIPP handle
1158   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1159   * @retval None
1160   */
HAL_DCMIPP_PIPE_VsyncEventCallback(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1161 __weak void HAL_DCMIPP_PIPE_VsyncEventCallback(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1162 {
1163   /* NOTE : This function Should not be modified, when the callback is needed,
1164             the HAL_DCMIPP_VsyncEventDumpPipeCallback could be implemented in the user file
1165    */
1166   /* Prevent unused argument(s) compilation warning */
1167   UNUSED(Pipe);
1168   UNUSED(hdcmipp);
1169 }
1170 
1171 
1172 /**
1173   * @brief  Line Event callback on the pipe
1174   * @param  hdcmipp  Pointer to DCMIPP handle
1175   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1176   * @retval None
1177   */
HAL_DCMIPP_PIPE_LineEventCallback(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1178 __weak void HAL_DCMIPP_PIPE_LineEventCallback(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1179 {
1180   /* NOTE : This function Should not be modified, when the callback is needed,
1181             the HAL_DCMIPP_LineEventMainPipeCallback could be implemented in the user file
1182    */
1183   /* Prevent unused argument(s) compilation warning */
1184   UNUSED(Pipe);
1185   UNUSED(hdcmipp);
1186 }
1187 
1188 /**
1189   * @brief  Limit callback on the Pipe
1190   * @param  hdcmipp  Pointer to DCMIPP handle
1191   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1192   * @retval None
1193   */
HAL_DCMIPP_PIPE_LimitEventCallback(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1194 __weak void HAL_DCMIPP_PIPE_LimitEventCallback(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1195 {
1196   /* NOTE : This function Should not be modified, when the callback is needed,
1197             the HAL_DCMIPP_LimitEventDumpPipeCallback could be implemented in the user file
1198    */
1199   /* Prevent unused argument(s) compilation warning */
1200   UNUSED(Pipe);
1201   UNUSED(hdcmipp);
1202 }
1203 
1204 /**
1205   * @brief  Error callback on the pipe
1206   * @param  hdcmipp  Pointer to DCMIPP handle
1207   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1208   * @retval None
1209   */
HAL_DCMIPP_PIPE_ErrorCallback(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1210 __weak void HAL_DCMIPP_PIPE_ErrorCallback(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1211 {
1212   /* NOTE : This function Should not be modified, when the callback is needed,
1213             the HAL_DCMIPP_SyncErrorEventCallback could be implemented in the user file
1214    */
1215   /* Prevent unused argument(s) compilation warning */
1216   UNUSED(Pipe);
1217   UNUSED(hdcmipp);
1218 }
1219 
1220 
1221 /**
1222   * @brief  Error callback on DCMIPP
1223   * @param  hdcmipp  Pointer to DCMIPP handle
1224   * @retval None
1225   */
HAL_DCMIPP_ErrorCallback(DCMIPP_HandleTypeDef * hdcmipp)1226 __weak void HAL_DCMIPP_ErrorCallback(DCMIPP_HandleTypeDef *hdcmipp)
1227 {
1228   /* NOTE : This function Should not be modified, when the callback is needed,
1229             the HAL_DCMIPP_ErrorCallback could be implemented in the user file
1230    */
1231   /* Prevent unused argument(s) compilation warning */
1232   UNUSED(hdcmipp);
1233 }
1234 /**
1235   * @}
1236   */
1237 
1238 /** @addtogroup DCMIPP_RegisterCallback_Functions Register Callback Functions
1239   * @{
1240   */
1241 #if (USE_HAL_DCMIPP_REGISTER_CALLBACKS == 1)
1242 /**
1243   * @brief  Register a User DCMIPP Callback
1244   *         To be used instead of the weak (surcharged) predefined callback
1245   * @param  hdcmipp    Pointer to DCMIPP handle
1246   * @param  CallbackID ID of the callback to be registered
1247   *         This parameter can be one of the following values:
1248   *          @arg @ref  HAL_DCMIPP_ERROR_CB_ID DCMIPP Error callback ID
1249   *          @arg @ref  HAL_DCMIPP_MSPINIT_CB_ID DCMIPP MspInit callback ID
1250   *          @arg @ref  HAL_DCMIPP_MSPDEINIT_CB_ID DCMIPP MspDeInit callback ID
1251   * @param pCallback pointer to the Callback function
1252   * @retval status
1253   */
HAL_DCMIPP_RegisterCallback(DCMIPP_HandleTypeDef * hdcmipp,HAL_DCMIPP_CallbackIDTypeDef CallbackID,pDCMIPP_CallbackTypeDef pCallback)1254 HAL_StatusTypeDef HAL_DCMIPP_RegisterCallback(DCMIPP_HandleTypeDef *hdcmipp, HAL_DCMIPP_CallbackIDTypeDef CallbackID,
1255                                               pDCMIPP_CallbackTypeDef pCallback)
1256 {
1257 
1258   HAL_StatusTypeDef status = HAL_OK;
1259 
1260   if (pCallback == NULL)
1261   {
1262     /* Update the error code */
1263     hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1264     return HAL_ERROR;
1265   }
1266 
1267   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
1268   {
1269     switch (CallbackID)
1270     {
1271       case HAL_DCMIPP_MSPINIT_CB_ID :
1272         hdcmipp->MspInitCallback = pCallback;
1273         break;
1274 
1275       case HAL_DCMIPP_MSPDEINIT_CB_ID :
1276         hdcmipp->MspDeInitCallback = pCallback;
1277         break;
1278 
1279       case HAL_DCMIPP_ERROR_CB_ID :
1280         hdcmipp->ErrorCallback = pCallback;
1281         break;
1282 
1283       default :
1284         /* Update the error code */
1285         hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1286         /* update return status */
1287         status =  HAL_ERROR;
1288         break;
1289     }
1290   }
1291   else if (hdcmipp->State == HAL_DCMIPP_STATE_RESET)
1292   {
1293     switch (CallbackID)
1294     {
1295       case HAL_DCMIPP_MSPINIT_CB_ID :
1296         hdcmipp->MspInitCallback = pCallback;
1297         break;
1298 
1299       case HAL_DCMIPP_MSPDEINIT_CB_ID :
1300         hdcmipp->MspDeInitCallback = pCallback;
1301         break;
1302 
1303       default :
1304         /* Update the error code */
1305         hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1306         /* update return status */
1307         status =  HAL_ERROR;
1308         break;
1309     }
1310   }
1311   else
1312   {
1313     /* Update the error code */
1314     hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1315     /* update return status */
1316     status =  HAL_ERROR;
1317   }
1318 
1319   return status;
1320 }
1321 
1322 /**
1323   * @brief  Unregister a User DCMIPP Callback
1324   *         DCMIPP Callback is redirected to the weak (surcharged) predefined callback
1325   * @param  hdcmipp    Pointer to DCMIPP handle
1326   * @param  CallbackID ID of the callback to be unregistered
1327   *         This parameter can be one of the following values:
1328   *          @arg @ref  HAL_DCMIPP_ERROR_CB_ID DCMIPP Error callback ID
1329   *          @arg @ref  HAL_DCMIPP_MSPINIT_CB_ID DCMIPP MspInit callback ID
1330   *          @arg @ref  HAL_DCMIPP_MSPDEINIT_CB_ID DCMIPP MspDeInit callback ID
1331   * @retval status
1332   */
HAL_DCMIPP_UnRegisterCallback(DCMIPP_HandleTypeDef * hdcmipp,HAL_DCMIPP_CallbackIDTypeDef CallbackID)1333 HAL_StatusTypeDef HAL_DCMIPP_UnRegisterCallback(DCMIPP_HandleTypeDef *hdcmipp, HAL_DCMIPP_CallbackIDTypeDef CallbackID)
1334 {
1335   HAL_StatusTypeDef status = HAL_OK;
1336 
1337   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
1338   {
1339     switch (CallbackID)
1340     {
1341       case HAL_DCMIPP_MSPINIT_CB_ID :
1342         hdcmipp->MspInitCallback = HAL_DCMIPP_MspInit; /* Legacy weak (surcharged) Msp Init */
1343         break;
1344 
1345       case HAL_DCMIPP_MSPDEINIT_CB_ID :
1346         hdcmipp->MspDeInitCallback = HAL_DCMIPP_MspDeInit; /* Legacy weak (surcharged) Msp DeInit */
1347         break;
1348 
1349       default :
1350         /* Update the error code */
1351         hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1352         /* update return status */
1353         status =  HAL_ERROR;
1354         break;
1355     }
1356   }
1357   else if (hdcmipp->State == HAL_DCMIPP_STATE_RESET)
1358   {
1359     switch (CallbackID)
1360     {
1361       case HAL_DCMIPP_MSPINIT_CB_ID :
1362         hdcmipp->MspInitCallback = HAL_DCMIPP_MspInit;   /* Legacy weak (surcharged) Msp Init */
1363         break;
1364 
1365       case HAL_DCMIPP_MSPDEINIT_CB_ID :
1366         hdcmipp->MspDeInitCallback = HAL_DCMIPP_MspDeInit;  /* Legacy weak (surcharged) Msp DeInit */
1367         break;
1368 
1369       default :
1370         /* Update the error code */
1371         hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1372         /* update return status */
1373         status =  HAL_ERROR;
1374         break;
1375     }
1376   }
1377   else
1378   {
1379     /* Update the error code */
1380     hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1381     /* update return status */
1382     status =  HAL_ERROR;
1383   }
1384 
1385   return status;
1386 }
1387 
1388 /**
1389   * @brief  Register a User DCMIPP Pipe Callback
1390   *         To be used instead of the weak (surcharged) predefined callback
1391   * @param  hdcmipp  Pointer to DCMIPP handle
1392   * @param  CallbackID ID of the callback to be registered
1393   *         This parameter can be one of the following values:
1394   *          @arg @ref  HAL_DCMIPP_PIPE_FRAME_EVENT_CB_ID DCMIPP Pipe Frame event callback ID
1395   *          @arg @ref  HAL_DCMIPP_PIPE_VSYNC_EVENT_CB_ID DCMIPP Pipe Vsync event callback ID
1396   *          @arg @ref  HAL_DCMIPP_PIPE_LINE_EVENT_CB_ID DCMIPP Pipe Line event callback ID
1397   *          @arg @ref  HAL_DCMIPP_PIPE_LIMIT_EVENT_CB_ID DCMIPP Pipe Limit event callback ID
1398   *          @arg @ref  HAL_DCMIPP_PIPE_ERROR_CB_ID DCMIPP Pipe Error callback ID
1399   * @param pCallback pointer to the Pipe Callback function
1400   * @retval status
1401   */
HAL_DCMIPP_PIPE_RegisterCallback(DCMIPP_HandleTypeDef * hdcmipp,HAL_DCMIPP_PIPE_CallbackIDTypeDef CallbackID,pDCMIPP_PIPE_CallbackTypeDef pCallback)1402 HAL_StatusTypeDef HAL_DCMIPP_PIPE_RegisterCallback(DCMIPP_HandleTypeDef *hdcmipp,
1403                                                    HAL_DCMIPP_PIPE_CallbackIDTypeDef CallbackID,
1404                                                    pDCMIPP_PIPE_CallbackTypeDef pCallback)
1405 {
1406   HAL_StatusTypeDef status = HAL_OK;
1407 
1408   if (pCallback == NULL)
1409   {
1410     /* Update the error code */
1411     hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1412     return HAL_ERROR;
1413   }
1414 
1415   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
1416   {
1417     switch (CallbackID)
1418     {
1419       case HAL_DCMIPP_PIPE_FRAME_EVENT_CB_ID :
1420         hdcmipp->PIPE_FrameEventCallback = pCallback;
1421         break;
1422 
1423       case HAL_DCMIPP_PIPE_VSYNC_EVENT_CB_ID :
1424         hdcmipp->PIPE_VsyncEventCallback = pCallback;
1425         break;
1426 
1427       case HAL_DCMIPP_PIPE_LINE_EVENT_CB_ID :
1428         hdcmipp->PIPE_LineEventCallback = pCallback;
1429         break;
1430 
1431       case HAL_DCMIPP_PIPE_LIMIT_EVENT_CB_ID :
1432         hdcmipp->PIPE_LimitEventCallback = pCallback;
1433         break;
1434 
1435       case HAL_DCMIPP_PIPE_ERROR_CB_ID :
1436         hdcmipp->PIPE_ErrorCallback = pCallback;
1437         break;
1438 
1439       default :
1440         /* Update the error code */
1441         hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1442         /* update return status */
1443         status =  HAL_ERROR;
1444         break;
1445     }
1446   }
1447   else
1448   {
1449     /* Update the error code */
1450     hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1451     /* update return status */
1452     status =  HAL_ERROR;
1453   }
1454 
1455   return status;
1456 }
1457 
1458 /**
1459   * @brief  UnRegister a User DCMIPP Pipe Callback
1460   *         DCMIPP Callback is redirected to the weak (surcharged) predefined callback
1461   * @param  hdcmipp   Pointer to DCMIPP handle
1462   * @param  CallbackID ID of the callback to be unregistered
1463   *         This parameter can be one of the following values:
1464   *          @arg @ref  HAL_DCMIPP_PIPE_FRAME_EVENT_CB_ID DCMIPP Pipe Frame event callback ID
1465   *          @arg @ref  HAL_DCMIPP_PIPE_VSYNC_EVENT_CB_ID DCMIPP Pipe Vsync event callback ID
1466   *          @arg @ref  HAL_DCMIPP_PIPE_LINE_EVENT_CB_ID DCMIPP Pipe Line event callback ID
1467   *          @arg @ref  HAL_DCMIPP_PIPE_LIMIT_EVENT_CB_ID DCMIPP Pipe Limit event callback ID
1468   *          @arg @ref  HAL_DCMIPP_PIPE_ERROR_CB_ID DCMIPP Pipe Error callback ID
1469   * @retval status
1470   */
HAL_DCMIPP_PIPE_UnRegisterCallback(DCMIPP_HandleTypeDef * hdcmipp,HAL_DCMIPP_PIPE_CallbackIDTypeDef CallbackID)1471 HAL_StatusTypeDef HAL_DCMIPP_PIPE_UnRegisterCallback(DCMIPP_HandleTypeDef *hdcmipp,
1472                                                      HAL_DCMIPP_PIPE_CallbackIDTypeDef CallbackID)
1473 {
1474   HAL_StatusTypeDef status = HAL_OK;
1475 
1476   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
1477   {
1478     switch (CallbackID)
1479     {
1480       case HAL_DCMIPP_PIPE_FRAME_EVENT_CB_ID :
1481         hdcmipp->PIPE_FrameEventCallback = HAL_DCMIPP_PIPE_FrameEventCallback;
1482         break;
1483 
1484       case HAL_DCMIPP_PIPE_VSYNC_EVENT_CB_ID :
1485         hdcmipp->PIPE_VsyncEventCallback = HAL_DCMIPP_PIPE_VsyncEventCallback;
1486         break;
1487 
1488       case HAL_DCMIPP_PIPE_LINE_EVENT_CB_ID :
1489         hdcmipp->PIPE_LineEventCallback = HAL_DCMIPP_PIPE_LineEventCallback;
1490         break;
1491 
1492       case HAL_DCMIPP_PIPE_LIMIT_EVENT_CB_ID :
1493         hdcmipp->PIPE_LimitEventCallback = HAL_DCMIPP_PIPE_LimitEventCallback;
1494         break;
1495 
1496       case HAL_DCMIPP_PIPE_ERROR_CB_ID :
1497         hdcmipp->PIPE_ErrorCallback = HAL_DCMIPP_PIPE_ErrorCallback;
1498         break;
1499 
1500       default :
1501         /* Update the error code */
1502         hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1503         /* update return status */
1504         status =  HAL_ERROR;
1505         break;
1506     }
1507   }
1508   else
1509   {
1510     /* Update the error code */
1511     hdcmipp->ErrorCode |= HAL_DCMIPP_ERROR_INVALID_CALLBACK;
1512     /* update return status */
1513     status =  HAL_ERROR;
1514   }
1515 
1516   return status;
1517 }
1518 #endif /* USE_HAL_DCMIPP_REGISTER_CALLBACKS */
1519 /**
1520   * @}
1521   */
1522 /**
1523   * @}
1524   */
1525 /** @defgroup DCMIPP_Crop_Functions DCMIPP Crop Functions
1526   * @{
1527   */
1528 /**
1529   * @brief  Configures cropping for the specified DCMIPP pipe according to the user parameters
1530   * @param  hdcmipp     Pointer to DCMIPP handle
1531   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1532   * @param  pCropConfig pointer to DCMIPP_CropConfTypeDef structure that contains
1533   *                     the configuration information for Crop.
1534   * @retval HAL status
1535   */
HAL_DCMIPP_PIPE_SetCropConfig(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,const DCMIPP_CropConfTypeDef * pCropConfig)1536 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetCropConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
1537                                                 const DCMIPP_CropConfTypeDef *pCropConfig)
1538 {
1539   uint32_t tmp;
1540 
1541   /* Check handle validity */
1542   if ((hdcmipp == NULL) || (pCropConfig == NULL))
1543   {
1544     return HAL_ERROR;
1545   }
1546 
1547   assert_param(IS_DCMIPP_PIPE(Pipe));
1548   assert_param(IS_DCMIPP_PIPE_CROP_AREA(pCropConfig->PipeArea));
1549   assert_param(IS_DCMIPP_PIPE_CROP_HSTART(pCropConfig->HStart));
1550   assert_param(IS_DCMIPP_PIPE_CROP_HSIZE(pCropConfig->HSize));
1551   assert_param(IS_DCMIPP_PIPE_CROP_VSIZE(pCropConfig->VSize));
1552   assert_param(IS_DCMIPP_PIPE_CROP_VSTART(pCropConfig->VStart));
1553 
1554   /* Check the DCMIPP State */
1555   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
1556   {
1557 
1558     if (Pipe == DCMIPP_PIPE0)
1559     {
1560       tmp = READ_REG(hdcmipp->Instance->PRCR);
1561 
1562       /* Verify for parallel mode with jpeg format , no Line Crop enable  */
1563       if (((tmp & DCMIPP_PRCR_ENABLE) == DCMIPP_PRCR_ENABLE) && ((tmp & DCMIPP_PRCR_FORMAT) == DCMIPP_FORMAT_BYTE))
1564       {
1565         return HAL_ERROR;
1566       }
1567       else
1568       {
1569         /* Set Cropping horizontal and vertical start for Pipe0 */
1570         MODIFY_REG(hdcmipp->Instance->P0SCSTR, DCMIPP_P0SCSTR_HSTART | DCMIPP_P0SCSTR_VSTART,
1571                    (pCropConfig->HStart << DCMIPP_P0SCSTR_HSTART_Pos) |
1572                    (pCropConfig->VStart << DCMIPP_P0SCSTR_VSTART_Pos));
1573 
1574         /* Set Cropping horizontal and vertical width for Pipe0 */
1575         /* Set crop Area (Inner or outer) for Pipe0 */
1576         MODIFY_REG(hdcmipp->Instance->P0SCSZR, DCMIPP_P0SCSZR_HSIZE | DCMIPP_P0SCSZR_VSIZE | DCMIPP_P0SCSZR_POSNEG,
1577                    (pCropConfig->HSize << DCMIPP_P0SCSZR_HSIZE_Pos) | (pCropConfig->VSize << DCMIPP_P0SCSZR_VSIZE_Pos) |
1578                    (pCropConfig->PipeArea));
1579       }
1580     }
1581     else
1582     {
1583       return HAL_ERROR;
1584     }
1585   }
1586   else
1587   {
1588     return HAL_ERROR;
1589   }
1590 
1591   return HAL_OK;
1592 }
1593 
1594 /**
1595   * @brief  Enables the cropping for the specified DCMIPP pipe.
1596   * @param  hdcmipp  Pointer to DCMIPP handle
1597   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1598   * @note   Cropping cannot be enabled in parallel mode with JPEG Format
1599   * @retval HAL status
1600   */
HAL_DCMIPP_PIPE_EnableCrop(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1601 HAL_StatusTypeDef HAL_DCMIPP_PIPE_EnableCrop(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1602 {
1603   uint32_t tmp;
1604 
1605   assert_param(IS_DCMIPP_PIPE(Pipe));
1606 
1607   /* Check handle validity */
1608   if (hdcmipp == NULL)
1609   {
1610     return HAL_ERROR;
1611   }
1612 
1613   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
1614   {
1615     if (Pipe == DCMIPP_PIPE0)
1616     {
1617       /* This bit must be kept cleared if the input format is JPEG */
1618       /* Verify for parallel mode with jpeg format , no Line Crop enable  */
1619 
1620       tmp = READ_REG(hdcmipp->Instance->PRCR);
1621 
1622       if (((tmp & DCMIPP_PRCR_ENABLE) == DCMIPP_PRCR_ENABLE) && ((tmp & DCMIPP_PRCR_FORMAT) == DCMIPP_FORMAT_BYTE))
1623       {
1624         return HAL_ERROR;
1625       }
1626       else
1627       {
1628         SET_BIT(hdcmipp->Instance->P0SCSZR, DCMIPP_P0SCSZR_ENABLE);
1629       }
1630     }
1631     else
1632     {
1633       return HAL_ERROR;
1634     }
1635   }
1636   else
1637   {
1638     return HAL_ERROR;
1639   }
1640 
1641   return HAL_OK;
1642 }
1643 
1644 /**
1645   * @brief  Disable the cropping for the specified DCMIPP pipe.
1646   * @param  hdcmipp  Pointer to DCMIPP handle
1647   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1648   * @retval HAL status
1649   */
HAL_DCMIPP_PIPE_DisableCrop(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1650 HAL_StatusTypeDef HAL_DCMIPP_PIPE_DisableCrop(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1651 {
1652   assert_param(IS_DCMIPP_PIPE(Pipe));
1653 
1654   /* Check handle validity */
1655   if (hdcmipp == NULL)
1656   {
1657     return HAL_ERROR;
1658   }
1659 
1660   if (Pipe == DCMIPP_PIPE0)
1661   {
1662     CLEAR_BIT(hdcmipp->Instance->P0SCSZR, DCMIPP_P0SCSZR_ENABLE);
1663   }
1664   else
1665   {
1666     return HAL_ERROR;
1667   }
1668 
1669   return HAL_OK;
1670 }
1671 /**
1672   * @}
1673   */
1674 
1675 /** @defgroup DCMIPP_Decimation_Functions DCMIPP Decimation Functions
1676   * @{
1677   */
1678 /**
1679   * @brief  Configure the Bytes decimation for the selected Pipe.
1680   * @param  hdcmipp     Pointer to DCMIPP handle
1681   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1682   * @param  SelectStart can a be value from @ref DCMIPP_Byte_Start_Mode
1683   * @param  SelectMode  can be a value from @ref DCMIPP_Byte_Select_Mode
1684   * @retval HAL status
1685   */
HAL_DCMIPP_PIPE_SetBytesDecimationConfig(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t SelectStart,uint32_t SelectMode)1686 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetBytesDecimationConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
1687                                                            uint32_t SelectStart, uint32_t SelectMode)
1688 {
1689   uint32_t tmp;
1690 
1691   assert_param(IS_DCMIPP_PIPE(Pipe));
1692   assert_param(IS_DCMIPP_BYTE_SELECT_START(SelectStart));
1693   assert_param(IS_DCMIPP_BYTE_SELECT_MODE(SelectMode));
1694 
1695   /* Check handle validity */
1696   if (hdcmipp == NULL)
1697   {
1698     return HAL_ERROR;
1699   }
1700 
1701   if (Pipe == DCMIPP_PIPE0)
1702   {
1703     /* OEBS : This bit works in conjunction with BSM field (BSM != 00) */
1704     /* Modes 10 and 11 work only with EDM [2:0] = 000 into the DCMIPP_PRCR */
1705     tmp = (hdcmipp->Instance->PRCR & DCMIPP_PRCR_EDM);
1706 
1707     if (((SelectStart  == DCMIPP_OEBS_EVEN) && (SelectMode > DCMIPP_BSM_ALL)) || \
1708         ((SelectMode > DCMIPP_BSM_DATA_OUT_2) && (tmp != DCMIPP_INTERFACE_8BITS)))
1709     {
1710       return HAL_ERROR;
1711     }
1712     else
1713     {
1714       /* Set Bytes select Start and Bytes select Mode */
1715       MODIFY_REG(hdcmipp->Instance->P0PPCR, DCMIPP_P0PPCR_BSM | DCMIPP_P0PPCR_OEBS, (SelectStart | SelectMode));
1716     }
1717   }
1718   else
1719   {
1720     return HAL_ERROR;
1721   }
1722 
1723   return HAL_OK;
1724 }
1725 
1726 /**
1727   * @brief  Configure the Lines decimation for the selected Pipe.
1728   * @param  hdcmipp     Pointer to DCMIPP handle
1729   * @param  Pipe        Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1730   * @param  SelectStart can a be value from @ref DCMIPP_Line_Start_Mode
1731   * @param  SelectMode  can be a value from @ref DCMIPP_Line_Select_Mode
1732   * @retval HAL status
1733   */
HAL_DCMIPP_PIPE_SetLinesDecimationConfig(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t SelectStart,uint32_t SelectMode)1734 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetLinesDecimationConfig(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
1735                                                            uint32_t SelectStart, uint32_t SelectMode)
1736 {
1737   assert_param(IS_DCMIPP_PIPE(Pipe));
1738   assert_param(IS_DCMIPP_LINE_SELECT_MODE(SelectMode));
1739   assert_param(IS_DCMIPP_LINE_SELECT_START(SelectStart));
1740 
1741   /* Check handle validity */
1742   if (hdcmipp == NULL)
1743   {
1744     return HAL_ERROR;
1745   }
1746 
1747   if (Pipe == DCMIPP_PIPE0)
1748   {
1749     /* This bit works in conjunction with LSM field (LSM = 1) */
1750     if ((SelectStart == DCMIPP_OELS_EVEN) && (SelectMode == DCMIPP_LSM_ALTERNATE_2))
1751     {
1752       return HAL_ERROR;
1753     }
1754     else
1755     {
1756       /* Set Lines select Start and Bytes select Mode */
1757       MODIFY_REG(hdcmipp->Instance->P0PPCR, DCMIPP_P0PPCR_LSM | DCMIPP_P0PPCR_OELS, (SelectStart | SelectMode));
1758     }
1759   }
1760   else
1761   {
1762     return HAL_ERROR;
1763   }
1764   return HAL_OK;
1765 }
1766 /**
1767   * @}
1768   */
1769 
1770 /** @defgroup DCMIPP_LimitEvent_Functions DCMIPP Limit Event Functions
1771   * @{
1772   */
1773 /**
1774   * @brief  Define the Data dump limit for the selected Pipe.
1775   * @param  hdcmipp  Pointer to DCMIPP handle
1776   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1777   * @param  Limit    Data dump Limit.
1778   * @retval HAL status
1779   */
HAL_DCMIPP_PIPE_EnableLimitEvent(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t Limit)1780 HAL_StatusTypeDef HAL_DCMIPP_PIPE_EnableLimitEvent(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t Limit)
1781 {
1782   assert_param(IS_DCMIPP_PIPE(Pipe));
1783   assert_param(IS_DCMIPP_DATA_LIMIT(Limit));
1784 
1785   /* Check Parameters */
1786   if (hdcmipp == NULL)
1787   {
1788     return HAL_ERROR;
1789   }
1790 
1791   if (Pipe == DCMIPP_PIPE0)
1792   {
1793     /* Set and enable data limit on Pipe 0 */
1794     WRITE_REG(hdcmipp->Instance->P0DCLMTR, (Limit << DCMIPP_P0DCLMTR_LIMIT_Pos) | DCMIPP_P0DCLMTR_ENABLE);
1795 
1796     /* Enable Limit Interrupt for pipe0 */
1797     __HAL_DCMIPP_ENABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_LIMIT);
1798   }
1799   else
1800   {
1801     return HAL_ERROR;
1802   }
1803 
1804   return HAL_OK;
1805 }
1806 
1807 /**
1808   * @brief  Disable the the Limit interrupt.
1809   * @param  hdcmipp  Pointer to DCMIPP handle
1810   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1811   * @retval HAL status
1812   */
HAL_DCMIPP_PIPE_DisableLimitEvent(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1813 HAL_StatusTypeDef HAL_DCMIPP_PIPE_DisableLimitEvent(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1814 {
1815   assert_param(IS_DCMIPP_PIPE(Pipe));
1816 
1817   /* Check Parameters */
1818   if (hdcmipp == NULL)
1819   {
1820     return HAL_ERROR;
1821   }
1822 
1823   if (Pipe == DCMIPP_PIPE0)
1824   {
1825     /* Disable data limit on Pipe 0 */
1826     CLEAR_BIT(hdcmipp->Instance->P0DCLMTR, DCMIPP_P0DCLMTR_ENABLE);
1827 
1828     /* Disable Limit Interrupt for pipe0 */
1829     __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_LIMIT);
1830   }
1831   else
1832   {
1833     return HAL_ERROR;
1834   }
1835 
1836   return HAL_OK;
1837 }
1838 
1839 /**
1840   * @}
1841   */
1842 /** @defgroup DCMIPP_PeripheralControl_Functions DCMIPP Peripheral Control Functions
1843   * @{
1844   */
1845 /**
1846   * @brief  Reconfigure the Frame Rate for the selected pipe
1847   * @param  hdcmipp    Pointer to DCMIPP handle
1848   * @param  Pipe       Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1849   * @param  FrameRate  the new Frame Rate, can be a value from @ref DCMIPP_Frame_Rates
1850   * @retval HAL status
1851   */
HAL_DCMIPP_PIPE_SetFrameRate(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t FrameRate)1852 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetFrameRate(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t FrameRate)
1853 {
1854   /* Check Parameters */
1855   if (hdcmipp == NULL)
1856   {
1857     return HAL_ERROR;
1858   }
1859 
1860   /* Check parameters */
1861   assert_param(IS_DCMIPP_PIPE(Pipe));
1862   assert_param(IS_DCMIPP_FRAME_RATE(FrameRate));
1863 
1864   /* Set Frame Rate for the Pipe */
1865   if (Pipe == DCMIPP_PIPE0)
1866   {
1867     MODIFY_REG(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_FRATE, FrameRate);
1868   }
1869   else
1870   {
1871     return HAL_ERROR;
1872   }
1873 
1874   return HAL_OK;
1875 }
1876 /**
1877   * @brief  Reconfigure Capture Mode for the selected pipe
1878   * @param  hdcmipp      Pointer to DCMIPP handle
1879   * @param  Pipe         Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1880   * @param  CaptureMode  the new Capture Mode, can be a value from @ref DCMIPP_Capture_Mode
1881   * @retval HAL status
1882   */
HAL_DCMIPP_PIPE_SetCaptureMode(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t CaptureMode)1883 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetCaptureMode(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t CaptureMode)
1884 {
1885   /* Check Parameters */
1886   if (hdcmipp == NULL)
1887   {
1888     return HAL_ERROR;
1889   }
1890 
1891   assert_param(IS_DCMIPP_PIPE(Pipe));
1892   assert_param(IS_DCMIPP_CAPTURE_MODE(CaptureMode));
1893 
1894 
1895   /* Set Capture Mode */
1896   if (Pipe == DCMIPP_PIPE0)
1897   {
1898     MODIFY_REG(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_CPTMODE, CaptureMode);
1899   }
1900   else
1901   {
1902     return HAL_ERROR;
1903   }
1904 
1905   return HAL_OK;
1906 }
1907 /**
1908   * @brief  Re-Enable Capture for the selected pipe
1909   * @param  hdcmipp   Pointer to DCMIPP handle
1910   * @param  Pipe      Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1911   * @retval HAL status
1912   */
HAL_DCMIPP_PIPE_EnableCapture(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)1913 HAL_StatusTypeDef HAL_DCMIPP_PIPE_EnableCapture(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
1914 {
1915   /* Check Parameters */
1916   if (hdcmipp == NULL)
1917   {
1918     return HAL_ERROR;
1919   }
1920 
1921   /* Request Capture for the chosen Pipe */
1922 
1923   if (Pipe == DCMIPP_PIPE0)
1924   {
1925     SET_BIT(hdcmipp->Instance->P0FCTCR, DCMIPP_P0FCTCR_CPTREQ);
1926   }
1927   else
1928   {
1929     return HAL_ERROR;
1930   }
1931 
1932   return HAL_OK;
1933 }
1934 /**
1935   * @brief  Reconfigure the destination memory address for the selected pipe
1936   * @param  hdcmipp    Pointer to DCMIPP handle
1937   * @param  Pipe       Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1938   * @param  Memory     the destination address to be changed can be value from @ref DCMIPP_Memory.
1939   * @param  DstAddress the new destination address
1940   * @retval HAL status
1941   */
HAL_DCMIPP_PIPE_SetMemoryAddress(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t Memory,uint32_t DstAddress)1942 HAL_StatusTypeDef HAL_DCMIPP_PIPE_SetMemoryAddress(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t Memory,
1943                                                    uint32_t DstAddress)
1944 {
1945   /* Check Parameters */
1946   if (hdcmipp == NULL)
1947   {
1948     return HAL_ERROR;
1949   }
1950 
1951   assert_param(IS_DCMIPP_PIPE(Pipe));
1952   assert_param(IS_DCMIPP_MEMORY_ADDRESS(Memory));
1953 
1954   /* Request Capture for the chosen Pipe */
1955 
1956   if (Pipe == DCMIPP_PIPE0)
1957   {
1958     if (Memory == DCMIPP_MEMORY_ADDRESS_0)
1959     {
1960       /* Set Memory0 destination addresses for pipe0 */
1961       WRITE_REG(hdcmipp->Instance->P0PPM0AR1, DstAddress);
1962     }
1963     else
1964     {
1965       if ((hdcmipp->Instance->P0PPCR & DCMIPP_P0PPCR_DBM) == DCMIPP_P0PPCR_DBM)
1966       {
1967         /* Set Memory1 destination addresses for pipe0 */
1968         WRITE_REG(hdcmipp->Instance->P0PPM0AR2, DstAddress);
1969       }
1970       else
1971       {
1972         return HAL_ERROR;
1973       }
1974     }
1975   }
1976   else
1977   {
1978     return HAL_ERROR;
1979   }
1980 
1981   return HAL_OK;
1982 
1983 }
1984 /**
1985   * @brief  Reconfigure the input pixel format for the selected pipe
1986   * @param  hdcmipp           Pointer to DCMIPP handle
1987   * @param  Pipe              Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
1988   * @param  InputPixelFormat  new pixel format, can be a value from @ref DCMIPP_Format
1989   * @retval HAL status
1990   */
HAL_DCMIPP_PIPE_PARALLEL_SetInputPixelFormat(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t InputPixelFormat)1991 HAL_StatusTypeDef HAL_DCMIPP_PIPE_PARALLEL_SetInputPixelFormat(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
1992                                                                uint32_t InputPixelFormat)
1993 {
1994   assert_param(IS_DCMIPP_PIPE(Pipe));
1995   assert_param(IS_DCMIPP_FORMAT(InputPixelFormat));
1996 
1997   if (hdcmipp == NULL)
1998   {
1999     return HAL_ERROR;
2000   }
2001 
2002   if (Pipe == DCMIPP_PIPE0)
2003   {
2004     /* Set Frame Rate */
2005     MODIFY_REG(hdcmipp->Instance->PRCR, DCMIPP_PRCR_FORMAT, InputPixelFormat);
2006   }
2007   else
2008   {
2009     return HAL_ERROR;
2010   }
2011 
2012   return HAL_OK;
2013 }
2014 /**
2015   * @brief  Set embedded synchronization delimiters unmasks.
2016   * @param  hdcmipp    Pointer to DCMIPP handle
2017   * @param  SyncUnmask Pointer to a DCMIPP_EmbeddedSyncUnmaskTypeDef structure that contains
2018   *                    the embedded synchronization delimiters unmasks.
2019   * @retval HAL status
2020   */
HAL_DCMIPP_PARALLEL_SetSyncUnmask(DCMIPP_HandleTypeDef * hdcmipp,const DCMIPP_EmbeddedSyncUnmaskTypeDef * SyncUnmask)2021 HAL_StatusTypeDef HAL_DCMIPP_PARALLEL_SetSyncUnmask(DCMIPP_HandleTypeDef *hdcmipp,
2022                                                     const DCMIPP_EmbeddedSyncUnmaskTypeDef *SyncUnmask)
2023 {
2024   uint32_t presur_reg;
2025   uint32_t prcr_reg;
2026 
2027   /* Check pointer validity */
2028   if ((hdcmipp == NULL) || (SyncUnmask == NULL))
2029   {
2030     return HAL_ERROR;
2031   }
2032 
2033   /* Check the DCMIPP State */
2034   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
2035   {
2036     prcr_reg = hdcmipp->Instance->PRCR;
2037     /* Check that Embedded synchronisation mode is configured */
2038     if ((prcr_reg & DCMIPP_PRCR_ESS) == DCMIPP_SYNCHRO_EMBEDDED)
2039     {
2040       /* Configure DCMIPP embedded synchronization unmask register */
2041       presur_reg = (((uint32_t)SyncUnmask->FrameStartUnmask << DCMIPP_PRESUR_FSU_Pos) | \
2042                     ((uint32_t)SyncUnmask->LineStartUnmask << DCMIPP_PRESUR_LSU_Pos)  | \
2043                     ((uint32_t)SyncUnmask->LineEndUnmask << DCMIPP_PRESUR_LEU_Pos)    | \
2044                     ((uint32_t)SyncUnmask->FrameEndUnmask << DCMIPP_PRESUR_FEU_Pos));
2045 
2046       WRITE_REG(hdcmipp->Instance->PRESUR, presur_reg);
2047     }
2048     else
2049     {
2050       return HAL_ERROR;
2051     }
2052   }
2053   else
2054   {
2055     return HAL_ERROR;
2056   }
2057 
2058   return HAL_OK;
2059 }
2060 /**
2061   * @}
2062   */
2063 /** @defgroup DCMIPP_Line_Event_Functions DCMIPP Line Event Functions
2064   * @{
2065   */
2066 /**
2067   * @brief  Configures the position of the line interrupt.
2068   * @param  hdcmipp  Pointer to DCMIPP handle
2069   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
2070   * @param  Line     Line Interrupt Position.
2071   * @retval HAL status
2072   */
HAL_DCMIPP_PIPE_EnableLineEvent(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t Line)2073 HAL_StatusTypeDef HAL_DCMIPP_PIPE_EnableLineEvent(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe, uint32_t Line)
2074 {
2075   assert_param(IS_DCMIPP_PIPE(Pipe));
2076   assert_param(IS_DCMIPP_PIPE_MULTILINE(Line));
2077 
2078   if (Pipe == DCMIPP_PIPE0)
2079   {
2080     /* Set MultiLine configuration */
2081     MODIFY_REG(hdcmipp->Instance->P0PPCR, DCMIPP_P0PPCR_LINEMULT, Line);
2082 
2083     /* Enable Multiline Interrupt */
2084     __HAL_DCMIPP_ENABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_LINE);
2085   }
2086   else
2087   {
2088     return HAL_ERROR;
2089   }
2090 
2091   return HAL_OK;
2092 }
2093 /**
2094   * @brief  Disable the the line event interrupt.
2095   * @param  hdcmipp  Pointer to DCMIPP handle
2096   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
2097   * @retval HAL status
2098   */
HAL_DCMIPP_PIPE_DisableLineEvent(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)2099 HAL_StatusTypeDef HAL_DCMIPP_PIPE_DisableLineEvent(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
2100 {
2101   assert_param(IS_DCMIPP_PIPE(Pipe));
2102 
2103   /* Disable Multiline Interrupt */
2104   if (Pipe == DCMIPP_PIPE0)
2105   {
2106     __HAL_DCMIPP_DISABLE_IT(hdcmipp, DCMIPP_IT_PIPE0_LINE);
2107   }
2108   else
2109   {
2110     return HAL_ERROR;
2111   }
2112 
2113   return HAL_OK;
2114 }
2115 /**
2116   * @}
2117   */
2118 /** @defgroup DCMIPP_Frame_Counter_Functions DCMIPP Frame Counter Functions
2119   * @{
2120   */
2121 /**
2122   * @brief  Reset the DCMIPP Pipe frame counter
2123   * @param  hdcmipp  Pointer to DCMIPP handle
2124   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
2125   * @retval HAL status
2126   */
HAL_DCMIPP_PIPE_ResetFrameCounter(DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)2127 HAL_StatusTypeDef HAL_DCMIPP_PIPE_ResetFrameCounter(DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
2128 {
2129 
2130   /* Check pointer validity */
2131   if (hdcmipp == NULL)
2132   {
2133     return HAL_ERROR;
2134   }
2135 
2136   /* Prevent unused argument(s) compilation warning */
2137   UNUSED(Pipe);
2138   /* Check parameters */
2139   assert_param(IS_DCMIPP_PIPE(Pipe));
2140 
2141   /* Check the DCMIPP State */
2142   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
2143   {
2144     /* Clear Frame counter */
2145     SET_BIT(hdcmipp->Instance->CMCR, DCMIPP_CMCR_CFC);
2146   }
2147   else
2148   {
2149     return HAL_ERROR;
2150   }
2151 
2152   return HAL_OK;
2153 }
2154 /**
2155   * @brief  Read the DCMIPP frame counter
2156   * @param  hdcmipp  Pointer to DCMIPP handle
2157   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
2158   * @param  pCounter pointer to store the value of the frame counter
2159   * @retval HAL status
2160   */
HAL_DCMIPP_PIPE_ReadFrameCounter(const DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t * pCounter)2161 HAL_StatusTypeDef HAL_DCMIPP_PIPE_ReadFrameCounter(const DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
2162                                                    uint32_t *pCounter)
2163 {
2164 
2165   /* Check parameters */
2166   assert_param(IS_DCMIPP_PIPE(Pipe));
2167 
2168   /* Prevent unused argument(s) compilation warning */
2169   UNUSED(Pipe);
2170   /* Check pointer validity */
2171   if ((hdcmipp == NULL) || (pCounter == NULL))
2172   {
2173     return HAL_ERROR;
2174   }
2175 
2176   /* Check the DCMIPP State */
2177   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
2178   {
2179     /* Read frame counter */
2180     *pCounter = READ_REG(hdcmipp->Instance->CMFRCR);
2181   }
2182   else
2183   {
2184     return HAL_ERROR;
2185   }
2186 
2187   return HAL_OK;
2188 }
2189 /**
2190   * @}
2191   */
2192 
2193 /** @defgroup DCMIPP_Data_Counter_Functions DCMIPP Data Counter Functions
2194   * @{
2195   */
2196 /**
2197   * @brief  Read Number of data dumped during the frame.
2198   * @param  hdcmipp  Pointer to DCMIPP handle
2199   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
2200   * @param  pCounter pointer to amount of word transferred
2201   * @note   Data Counter is available only on DCMIPP_PIPE0. The counter saturates at 0x3FFFFFF.
2202   * @note   Granularity is 32-bit for all the formats except for the
2203   *         byte stream formats (e.g. JPEG) having byte granularity
2204   * @retval Status
2205   */
HAL_DCMIPP_PIPE_GetDataCounter(const DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe,uint32_t * pCounter)2206 HAL_StatusTypeDef HAL_DCMIPP_PIPE_GetDataCounter(const DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe,
2207                                                  uint32_t *pCounter)
2208 {
2209   /* Check parameters */
2210   assert_param(IS_DCMIPP_PIPE(Pipe));
2211 
2212   /* Prevent unused argument(s) compilation warning */
2213   UNUSED(Pipe);
2214   /* Check pointer validity */
2215   if ((hdcmipp == NULL) || (pCounter == NULL))
2216   {
2217     return HAL_ERROR;
2218   }
2219 
2220   /* Check the DCMIPP State */
2221   if (hdcmipp->State == HAL_DCMIPP_STATE_READY)
2222   {
2223     /* Read  Pipe0 dump counter register */
2224     *pCounter = READ_REG(hdcmipp->Instance->P0DCCNTR);
2225   }
2226   else
2227   {
2228     return HAL_ERROR;
2229   }
2230 
2231   return HAL_OK;
2232 }
2233 /**
2234   * @}
2235   */
2236 
2237 /** @defgroup DCMIPP_State_and_Error_Functions DCMIPP State and Error Functions
2238   * @{
2239   */
2240 
2241 /**
2242   * @brief  Return the DCMIPP state
2243   * @param  hdcmipp  Pointer to DCMIPP handle
2244   * @retval HAL state
2245   */
HAL_DCMIPP_GetState(const DCMIPP_HandleTypeDef * hdcmipp)2246 HAL_DCMIPP_StateTypeDef HAL_DCMIPP_GetState(const DCMIPP_HandleTypeDef *hdcmipp)
2247 {
2248   return hdcmipp->State;
2249 }
2250 /**
2251   * @brief  Return the DCMIPP error code
2252   * @param  hdcmipp  Pointer to DCMIPP handle
2253   * @retval DCMIPP Error Code
2254   */
HAL_DCMIPP_GetError(const DCMIPP_HandleTypeDef * hdcmipp)2255 uint32_t HAL_DCMIPP_GetError(const DCMIPP_HandleTypeDef *hdcmipp)
2256 {
2257   return hdcmipp->ErrorCode;
2258 }
2259 /**
2260   * @brief  Return the DCMIPP state
2261   * @param  hdcmipp  Pointer to DCMIPP handle
2262   * @param  Pipe     Specifies the DCMIPP pipe, can be a value from @ref DCMIPP_Pipes
2263   * @retval HAL state
2264   */
HAL_DCMIPP_PIPE_GetState(const DCMIPP_HandleTypeDef * hdcmipp,uint32_t Pipe)2265 HAL_DCMIPP_PipeStateTypeDef HAL_DCMIPP_PIPE_GetState(const DCMIPP_HandleTypeDef *hdcmipp, uint32_t Pipe)
2266 {
2267   /* Check Parameters */
2268   assert_param(IS_DCMIPP_PIPE(Pipe));
2269 
2270   return hdcmipp->PipeState[Pipe];
2271 }
2272 
2273 /**
2274   * @}
2275   */
2276 
2277 /**
2278   * @}
2279   */
2280 
2281 /**
2282   * @}
2283   */
2284 
2285 /**
2286   * @}
2287   */
2288 #endif /* DCMIPP */
2289 #endif /* HAL_DCMIPP_MODULE_ENABLED */
2290