tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_dcmi.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f4xx_hal_dcmi.c
   4   * @author  MCD Application Team
   5   * @version V1.1.0
   6   * @date    19-June-2014
   7   * @brief   DCMI HAL module driver
   8   *          This file provides firmware functions to manage the following
   9   *          functionalities of the Digital Camera Interface (DCMI) peripheral:
  10   *           + Initialization and de-initialization functions
  11   *           + IO operation functions
  12   *           + Peripheral Control functions
  13   *           + Peripheral State and Error functions
  14   *
  15   @verbatim
  16   ==============================================================================
  17                         ##### How to use this driver #####
  18   ==============================================================================
  19   [..]
  20       The sequence below describes how to use this driver to capture image
  21       from a camera module connected to the DCMI Interface.
  22       This sequence does not take into account the configuration of the
  23       camera module, which should be made before to configure and enable
  24       the DCMI to capture images.
  25
  26     (#) Program the required configuration through following parameters:
  27         horizontal and vertical polarity, pixel clock polarity, Capture Rate,
  28         Synchronization Mode, code of the frame delimiter and data width
  29         using HAL_DCMI_Init() function.
  30
  31     (#) Configure the DMA2_Stream1 channel1 to transfer Data from DCMI DR
  32         register to the destination memory buffer.
  33
  34     (#) Program the required configuration through following parameters:
  35         DCMI mode, destination memory Buffer address and the data length
  36         and enable capture using HAL_DCMI_Start_DMA() function.
  37
  38     (#) Optionally, configure and Enable the CROP feature to select a rectangular
  39         window from the received image using HAL_DCMI_ConfigCrop()
  40         and HAL_DCMI_EnableCROP() functions
  41
  42     (#) The capture can be stopped using HAL_DCMI_Stop() function.
  43
  44     (#) To control DCMI state you can use the function HAL_DCMI_GetState().
  45
  46      *** DCMI HAL driver macros list ***
  47      =============================================
  48      [..]
  49        Below the list of most used macros in DCMI HAL driver.
  50
  51       (+) __HAL_DCMI_ENABLE: Enable the DCMI peripheral.
  52       (+) __HAL_DCMI_DISABLE: Disable the DCMI peripheral.
  53       (+) __HAL_DCMI_GET_FLAG: Get the DCMI pending flags.
  54       (+) __HAL_DCMI_CLEAR_FLAG: Clear the DCMI pending flags.
  55       (+) __HAL_DCMI_ENABLE_IT: Enable the specified DCMI interrupts.
  56       (+) __HAL_DCMI_DISABLE_IT: Disable the specified DCMI interrupts.
  57       (+) __HAL_DCMI_GET_IT_SOURCE: Check whether the specified DCMI interrupt has occurred or not.
  58
  59      [..]
  60        (@) You can refer to the DCMI HAL driver header file for more useful macros
  61
  62   @endverbatim
  63   ******************************************************************************
  64   * @attention
  65   *
  66   * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
  67   *
  68   * Redistribution and use in source and binary forms, with or without modification,
  69   * are permitted provided that the following conditions are met:
  70   *   1. Redistributions of source code must retain the above copyright notice,
  71   *      this list of conditions and the following disclaimer.
  72   *   2. Redistributions in binary form must reproduce the above copyright notice,
  73   *      this list of conditions and the following disclaimer in the documentation
  74   *      and/or other materials provided with the distribution.
  75   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  76   *      may be used to endorse or promote products derived from this software
  77   *      without specific prior written permission.
  78   *
  79   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  80   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  81   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  82   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  83   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  84   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  85   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  86   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  87   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  88   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  89   *
  90   ******************************************************************************
  91   */
  92
  93 /* Includes ------------------------------------------------------------------*/
  94 #include "stm32f4xx_hal.h"
  95
  96 /** @addtogroup STM32F4xx_HAL_Driver
  97   * @{
  98   */
  99 /** @defgroup DCMI
 100   * @brief DCMI HAL module driver
 101   * @{
 102   */
 103
 104 #ifdef HAL_DCMI_MODULE_ENABLED
 105
 106 #if defined(STM32F407xx) || defined(STM32F417xx) || defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx)
 107 /* Private typedef -----------------------------------------------------------*/
 108 /* Private define ------------------------------------------------------------*/
 109 #define HAL_TIMEOUT_DCMI_STOP    ((uint32_t)1000)  /* 1s  */
 110 /* Private macro -------------------------------------------------------------*/
 111 /* Private variables ---------------------------------------------------------*/
 112 /* Private function prototypes -----------------------------------------------*/
 113 static void       DCMI_DMAConvCplt(DMA_HandleTypeDef *hdma);
 114 static void       DCMI_DMAError(DMA_HandleTypeDef *hdma);
 115
 116 /* Private functions ---------------------------------------------------------*/
 117
 118 /** @defgroup DCMI_Private_Functions
 119   * @{
 120   */
 121
 122 /** @defgroup DCMI_Group1 Initialization and Configuration functions
 123  *  @brief   Initialization and Configuration functions
 124  *
 125 @verbatim
 126  ===============================================================================
 127                 ##### Initialization and Configuration functions #####
 128  ===============================================================================
 129     [..]  This section provides functions allowing to:
 130       (+) Initialize and configure the DCMI
 131       (+) De-initialize the DCMI
 132
 133 @endverbatim
 134   * @{
 135   */
 136
 137 /**
 138   * @brief  Initializes the DCMI according to the specified
 139   *         parameters in the DCMI_InitTypeDef and create the associated handle.
 140   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 141   *                the configuration information for DCMI.
 142   * @retval HAL status
 143   */
 144 HAL_StatusTypeDef HAL_DCMI_Init(DCMI_HandleTypeDef *hdcmi)
 145 {
 146   /* Check the DCMI peripheral state */
 147   if(hdcmi == HAL_NULL)
 148   {
 149      return HAL_ERROR;
 150   }
 151
 152   /* Check function parameters */
 153   assert_param(IS_DCMI_ALL_INSTANCE(hdcmi->Instance));
 154   assert_param(IS_DCMI_PCKPOLARITY(hdcmi->Init.PCKPolarity));
 155   assert_param(IS_DCMI_VSPOLARITY(hdcmi->Init.VSPolarity));
 156   assert_param(IS_DCMI_HSPOLARITY(hdcmi->Init.HSPolarity));
 157   assert_param(IS_DCMI_SYNCHRO(hdcmi->Init.SynchroMode));
 158   assert_param(IS_DCMI_CAPTURE_RATE(hdcmi->Init.CaptureRate));
 159   assert_param(IS_DCMI_EXTENDED_DATA(hdcmi->Init.ExtendedDataMode));
 160   assert_param(IS_DCMI_MODE_JPEG(hdcmi->Init.JPEGMode));
 161
 162   if(hdcmi->State == HAL_DCMI_STATE_RESET)
 163   {
 164     /* Init the low level hardware */
 165     HAL_DCMI_MspInit(hdcmi);
 166   }
 167
 168   /* Change the DCMI state */
 169   hdcmi->State = HAL_DCMI_STATE_BUSY;
 170
 171   /* Configures the HS, VS, DE and PC polarity */
 172   hdcmi->Instance->CR &= ~(DCMI_CR_PCKPOL | DCMI_CR_HSPOL  | DCMI_CR_VSPOL  | DCMI_CR_EDM_0 |
 173                            DCMI_CR_EDM_1  | DCMI_CR_FCRC_0 | DCMI_CR_FCRC_1 | DCMI_CR_JPEG  |
 174                            DCMI_CR_ESS);
 175   hdcmi->Instance->CR |=  (uint32_t)(hdcmi->Init.SynchroMode | hdcmi->Init.CaptureRate | \
 176                                      hdcmi->Init.VSPolarity  | hdcmi->Init.HSPolarity  | \
 177                                      hdcmi->Init.PCKPolarity | hdcmi->Init.ExtendedDataMode | \
 178                                      hdcmi->Init.JPEGMode);
 179
 180   if(hdcmi->Init.SynchroMode == DCMI_SYNCHRO_EMBEDDED)
 181   {
 182     DCMI->ESCR = (((uint32_t)hdcmi->Init.SyncroCode.FrameStartCode)    |
 183                   ((uint32_t)hdcmi->Init.SyncroCode.LineStartCode << 8)|
 184                   ((uint32_t)hdcmi->Init.SyncroCode.LineEndCode << 16) |
 185                   ((uint32_t)hdcmi->Init.SyncroCode.FrameEndCode << 24));
 186   }
 187
 188   /* Enable the Line interrupt */
 189   __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_LINE);
 190
 191   /* Enable the VSYNC interrupt */
 192   __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_VSYNC);
 193
 194   /* Enable the Frame capture complete interrupt */
 195   __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_FRAME);
 196
 197   /* Enable the Synchronization error interrupt */
 198   __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_ERR);
 199
 200   /* Enable the Overflow interrupt */
 201   __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_OVF);
 202
 203   /* Enable DCMI by setting DCMIEN bit */
 204   __HAL_DCMI_ENABLE(hdcmi);
 205
 206   /* Update error code */
 207   hdcmi->ErrorCode = HAL_DCMI_ERROR_NONE;
 208
 209   /* Initialize the DCMI state*/
 210   hdcmi->State  = HAL_DCMI_STATE_READY;
 211
 212   return HAL_OK;
 213 }
 214
 215 /**
 216   * @brief  Deinitializes the DCMI peripheral registers to their default reset
 217   *         values.
 218   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 219   *                the configuration information for DCMI.
 220   * @retval HAL status
 221   */
 222
 223 HAL_StatusTypeDef HAL_DCMI_DeInit(DCMI_HandleTypeDef *hdcmi)
 224 {
 225   /* DeInit the low level hardware */
 226   HAL_DCMI_MspDeInit(hdcmi);
 227
 228   /* Update error code */
 229   hdcmi->ErrorCode = HAL_DCMI_ERROR_NONE;
 230
 231   /* Initialize the DCMI state*/
 232   hdcmi->State = HAL_DCMI_STATE_RESET;
 233
 234   /* Release Lock */
 235   __HAL_UNLOCK(hdcmi);
 236
 237   return HAL_OK;
 238 }
 239
 240 /**
 241   * @brief  Initializes the DCMI MSP.
 242   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 243   *                the configuration information for DCMI.
 244   * @retval None
 245   */
 246 __weak void HAL_DCMI_MspInit(DCMI_HandleTypeDef* hdcmi)
 247 {
 248   /* NOTE : This function Should not be modified, when the callback is needed,
 249             the HAL_DCMI_MspInit could be implemented in the user file
 250    */
 251 }
 252
 253 /**
 254   * @brief  DeInitializes the DCMI MSP.
 255   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 256   *                the configuration information for DCMI.
 257   * @retval None
 258   */
 259 __weak void HAL_DCMI_MspDeInit(DCMI_HandleTypeDef* hdcmi)
 260 {
 261   /* NOTE : This function Should not be modified, when the callback is needed,
 262             the HAL_DCMI_MspDeInit could be implemented in the user file
 263    */
 264 }
 265
 266 /**
 267   * @}
 268   */
 269 /** @defgroup DCMI_Group2 IO operation functions
 270  *  @brief   IO operation functions
 271  *
 272 @verbatim
 273  ===============================================================================
 274                       #####  IO operation functions  #####
 275  ===============================================================================
 276     [..]  This section provides functions allowing to:
 277       (+) Configure destination address and data length and
 278           Enables DCMI DMA request and enables DCMI capture
 279       (+) Stop the DCMI capture.
 280       (+) Handles DCMI interrupt request.
 281
 282 @endverbatim
 283   * @{
 284   */
 285
 286 /**
 287   * @brief  Enables DCMI DMA request and enables DCMI capture
 288   * @param  hdcmi:     pointer to a DCMI_HandleTypeDef structure that contains
 289   *                    the configuration information for DCMI.
 290   * @param  DCMI_Mode: DCMI capture mode snapshot or continuous grab.
 291   * @param  pData:     The destination memory Buffer address (LCD Frame buffer).
 292   * @param  Length:    The length of capture to be transferred.
 293   * @retval HAL status
 294   */
 295 HAL_StatusTypeDef HAL_DCMI_Start_DMA(DCMI_HandleTypeDef* hdcmi, uint32_t DCMI_Mode, uint32_t pData, uint32_t Length)
 296 {
 297   /* Initialise the second memory address */
 298   uint32_t SecondMemAddress = 0;
 299
 300   /* Check function parameters */
 301   assert_param(IS_DCMI_CAPTURE_MODE(DCMI_Mode));
 302
 303   /* Process Locked */
 304   __HAL_LOCK(hdcmi);
 305
 306   /* Lock the DCMI peripheral state */
 307   hdcmi->State = HAL_DCMI_STATE_BUSY;
 308
 309   /* Check the parameters */
 310   assert_param(IS_DCMI_CAPTURE_MODE(DCMI_Mode));
 311
 312   /* Configure the DCMI Mode */
 313   hdcmi->Instance->CR &= ~(DCMI_CR_CM);
 314   hdcmi->Instance->CR |=  (uint32_t)(DCMI_Mode);
 315
 316   /* Set the DMA memory0 conversion complete callback */
 317   hdcmi->DMA_Handle->XferCpltCallback = DCMI_DMAConvCplt;
 318
 319   /* Set the DMA error callback */
 320   hdcmi->DMA_Handle->XferErrorCallback = DCMI_DMAError;
 321
 322   if(Length <= 0xFFFF)
 323   {
 324     /* Enable the DMA Stream */
 325     HAL_DMA_Start_IT(hdcmi->DMA_Handle, (uint32_t)&hdcmi->Instance->DR, (uint32_t)pData, Length);
 326   }
 327   else /* DCMI_DOUBLE_BUFFER Mode */
 328   {
 329     /* Set the DMA memory1 conversion complete callback */
 330     hdcmi->DMA_Handle->XferM1CpltCallback = DCMI_DMAConvCplt;
 331
 332     /* Initialise transfer parameters */
 333     hdcmi->XferCount = 1;
 334     hdcmi->XferSize = Length;
 335     hdcmi->pBuffPtr = pData;
 336
 337     /* Get the number of buffer */
 338     while(hdcmi->XferSize > 0xFFFF)
 339     {
 340       hdcmi->XferSize = (hdcmi->XferSize/2);
 341       hdcmi->XferCount = hdcmi->XferCount*2;
 342     }
 343
 344     /* Update DCMI counter  and transfer number*/
 345     hdcmi->XferCount = (hdcmi->XferCount - 2);
 346     hdcmi->XferTransferNumber = hdcmi->XferCount;
 347
 348     /* Update second memory address */
 349     SecondMemAddress = (uint32_t)(pData + (4*hdcmi->XferSize));
 350
 351     /* Start DMA multi buffer transfer */
 352     HAL_DMAEx_MultiBufferStart_IT(hdcmi->DMA_Handle, (uint32_t)&hdcmi->Instance->DR, (uint32_t)pData, SecondMemAddress, hdcmi->XferSize);
 353   }
 354
 355   /* Enable Capture */
 356   DCMI->CR |= DCMI_CR_CAPTURE;
 357
 358   /* Return function status */
 359   return HAL_OK;
 360 }
 361
 362 /**
 363   * @brief  Disable DCMI DMA request and Disable DCMI capture
 364   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 365   *                the configuration information for DCMI.
 366   * @retval HAL status
 367   */
 368 HAL_StatusTypeDef HAL_DCMI_Stop(DCMI_HandleTypeDef* hdcmi)
 369 {
 370   uint32_t tickstart = 0;
 371
 372   /* Lock the DCMI peripheral state */
 373   hdcmi->State = HAL_DCMI_STATE_BUSY;
 374
 375   __HAL_DCMI_DISABLE(hdcmi);
 376
 377   /* Disable Capture */
 378   DCMI->CR &= ~(DCMI_CR_CAPTURE);
 379
 380   /* Get tick */
 381   tickstart = HAL_GetTick();
 382
 383   /* Check if the DCMI capture effectively disabled */
 384   while((hdcmi->Instance->CR & DCMI_CR_CAPTURE) != 0)
 385   {
 386     if((HAL_GetTick() - tickstart ) > HAL_TIMEOUT_DCMI_STOP)
 387     {
 388       /* Process Unlocked */
 389       __HAL_UNLOCK(hdcmi);
 390
 391       /* Update error code */
 392       hdcmi->ErrorCode |= HAL_DCMI_ERROR_TIMEOUT;
 393
 394       /* Change DCMI state */
 395       hdcmi->State = HAL_DCMI_STATE_TIMEOUT;
 396
 397       return HAL_TIMEOUT;
 398     }
 399   }
 400
 401   /* Disable the DMA */
 402   HAL_DMA_Abort(hdcmi->DMA_Handle);
 403
 404   /* Update error code */
 405   hdcmi->ErrorCode |= HAL_DCMI_ERROR_NONE;
 406
 407   /* Change DCMI state */
 408   hdcmi->State = HAL_DCMI_STATE_READY;
 409
 410   /* Process Unlocked */
 411   __HAL_UNLOCK(hdcmi);
 412
 413   /* Return function status */
 414   return HAL_OK;
 415 }
 416
 417 /**
 418   * @brief  Handles DCMI interrupt request.
 419   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 420   *                the configuration information for the DCMI.
 421   * @retval None
 422   */
 423 void HAL_DCMI_IRQHandler(DCMI_HandleTypeDef *hdcmi)
 424 {
 425   /* Synchronization error interrupt management *******************************/
 426   if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_ERRRI) != RESET)
 427   {
 428     if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_ERR) != RESET)
 429     {
 430       /* Disable the Synchronization error interrupt */
 431       __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_ERR);
 432
 433       /* Clear the Synchronization error flag */
 434       __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_ERRRI);
 435
 436       /* Update error code */
 437       hdcmi->ErrorCode |= HAL_DCMI_ERROR_SYNC;
 438
 439       /* Change DCMI state */
 440       hdcmi->State = HAL_DCMI_STATE_ERROR;
 441
 442       /* Process Unlocked */
 443       __HAL_UNLOCK(hdcmi);
 444
 445       /* Abort the DMA Transfer */
 446       HAL_DMA_Abort(hdcmi->DMA_Handle);
 447
 448       /* Synchronization error Callback */
 449       HAL_DCMI_ErrorCallback(hdcmi);
 450     }
 451   }
 452   /* Overflow interrupt management ********************************************/
 453   if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_OVFRI) != RESET)
 454   {
 455     if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_OVF) != RESET)
 456     {
 457       /* Disable the Overflow interrupt */
 458       __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_OVF);
 459
 460       /* Clear the Overflow flag */
 461       __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_OVFRI);
 462
 463       /* Update error code */
 464       hdcmi->ErrorCode |= HAL_DCMI_ERROR_OVF;
 465
 466       /* Change DCMI state */
 467       hdcmi->State = HAL_DCMI_STATE_ERROR;
 468
 469       /* Process Unlocked */
 470       __HAL_UNLOCK(hdcmi);
 471
 472       /* Abort the DMA Transfer */
 473       HAL_DMA_Abort(hdcmi->DMA_Handle);
 474
 475       /* Overflow Callback */
 476       HAL_DCMI_ErrorCallback(hdcmi);
 477     }
 478   }
 479   /* Line Interrupt management ************************************************/
 480   if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_LINERI) != RESET)
 481   {
 482     if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_LINE) != RESET)
 483     {
 484       /* Clear the Line interrupt flag */
 485       __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_LINERI);
 486
 487       /* Process Unlocked */
 488       __HAL_UNLOCK(hdcmi);
 489
 490       /* Line interrupt Callback */
 491       HAL_DCMI_LineEventCallback(hdcmi);
 492     }
 493   }
 494   /* VSYNC interrupt management ***********************************************/
 495   if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_VSYNCRI) != RESET)
 496   {
 497     if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_VSYNC) != RESET)
 498     {
 499       /* Disable the VSYNC interrupt */
 500       __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_VSYNC);
 501
 502       /* Clear the VSYNC flag */
 503       __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_VSYNCRI);
 504
 505       /* Process Unlocked */
 506       __HAL_UNLOCK(hdcmi);
 507
 508       /* VSYNC Callback */
 509       HAL_DCMI_VsyncEventCallback(hdcmi);
 510     }
 511   }
 512   /* End of Frame interrupt management ****************************************/
 513   if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_FRAMERI) != RESET)
 514   {
 515     if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_FRAME) != RESET)
 516     {
 517       /* Disable the End of Frame interrupt */
 518       __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_FRAME);
 519
 520       /* Clear the End of Frame flag */
 521       __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_FRAMERI);
 522
 523       /* Process Unlocked */
 524       __HAL_UNLOCK(hdcmi);
 525
 526       /* End of Frame Callback */
 527       HAL_DCMI_FrameEventCallback(hdcmi);
 528     }
 529   }
 530 }
 531
 532 /**
 533   * @brief  Error DCMI callback.
 534   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 535   *                the configuration information for DCMI.
 536   * @retval None
 537   */
 538 __weak void HAL_DCMI_ErrorCallback(DCMI_HandleTypeDef *hdcmi)
 539 {
 540   /* NOTE : This function Should not be modified, when the callback is needed,
 541             the HAL_DCMI_ErrorCallback could be implemented in the user file
 542    */
 543 }
 544
 545 /**
 546   * @brief  Line Event callback.
 547   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 548   *                the configuration information for DCMI.
 549   * @retval None
 550   */
 551 __weak void HAL_DCMI_LineEventCallback(DCMI_HandleTypeDef *hdcmi)
 552 {
 553   /* NOTE : This function Should not be modified, when the callback is needed,
 554             the HAL_DCMI_LineEventCallback could be implemented in the user file
 555    */
 556 }
 557
 558 /**
 559   * @brief  VSYNC Event callback.
 560   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 561   *                the configuration information for DCMI.
 562   * @retval None
 563   */
 564 __weak void HAL_DCMI_VsyncEventCallback(DCMI_HandleTypeDef *hdcmi)
 565 {
 566   /* NOTE : This function Should not be modified, when the callback is needed,
 567             the HAL_DCMI_VsyncEventCallback could be implemented in the user file
 568    */
 569 }
 570
 571 /**
 572   * @brief  Frame Event callback.
 573   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 574   *                the configuration information for DCMI.
 575   * @retval None
 576   */
 577 __weak void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
 578 {
 579   /* NOTE : This function Should not be modified, when the callback is needed,
 580             the HAL_DCMI_FrameEventCallback could be implemented in the user file
 581    */
 582 }
 583
 584 /**
 585   * @}
 586   */
 587
 588 /** @defgroup DCMI_Group3 Peripheral Control functions
 589  *  @brief    Peripheral Control functions
 590  *
 591 @verbatim
 592  ===============================================================================
 593                     ##### Peripheral Control functions #####
 594  ===============================================================================
 595 [..]  This section provides functions allowing to:
 596       (+) Configure the CROP feature.
 597       (+) Enable/Disable the CROP feature.
 598
 599 @endverbatim
 600   * @{
 601   */
 602
 603 /**
 604   * @brief  Configure the DCMI CROP coordinate.
 605   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 606   *                the configuration information for DCMI.
 607   * @param  YSize: DCMI Line number
 608   * @param  XSize: DCMI Pixel per line
 609   * @param  X0:    DCMI window X offset
 610   * @param  Y0:    DCMI window Y offset
 611   * @retval HAL status
 612   */
 613 HAL_StatusTypeDef HAL_DCMI_ConfigCROP(DCMI_HandleTypeDef *hdcmi, uint32_t X0, uint32_t Y0, uint32_t XSize, uint32_t YSize)
 614 {
 615   /* Process Locked */
 616   __HAL_LOCK(hdcmi);
 617
 618   /* Lock the DCMI peripheral state */
 619   hdcmi->State = HAL_DCMI_STATE_BUSY;
 620
 621   /* Check the parameters */
 622   assert_param(IS_DCMI_WINDOW_COORDINATE(X0));
 623   assert_param(IS_DCMI_WINDOW_COORDINATE(Y0));
 624   assert_param(IS_DCMI_WINDOW_COORDINATE(XSize));
 625   assert_param(IS_DCMI_WINDOW_HEIGHT(YSize));
 626
 627   /* Configure CROP */
 628   DCMI->CWSIZER = (XSize | (YSize << 16));
 629   DCMI->CWSTRTR = (X0 | (Y0 << 16));
 630
 631   /* Initialize the DCMI state*/
 632   hdcmi->State  = HAL_DCMI_STATE_READY;
 633
 634   /* Process Unlocked */
 635   __HAL_UNLOCK(hdcmi);
 636
 637   return HAL_OK;
 638 }
 639
 640 /**
 641   * @brief  Disable the Crop feature.
 642   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 643   *                the configuration information for DCMI.
 644   * @retval HAL status
 645   */
 646 HAL_StatusTypeDef HAL_DCMI_DisableCROP(DCMI_HandleTypeDef *hdcmi)
 647 {
 648   /* Process Locked */
 649   __HAL_LOCK(hdcmi);
 650
 651   /* Lock the DCMI peripheral state */
 652   hdcmi->State = HAL_DCMI_STATE_BUSY;
 653
 654   /* Disable DCMI Crop feature */
 655   DCMI->CR &= ~(uint32_t)DCMI_CR_CROP;
 656
 657   /* Change the DCMI state*/
 658   hdcmi->State = HAL_DCMI_STATE_READY;
 659
 660   /* Process Unlocked */
 661   __HAL_UNLOCK(hdcmi);
 662
 663   return HAL_OK;
 664 }
 665
 666 /**
 667   * @brief  Enable the Crop feature.
 668   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 669   *                the configuration information for DCMI.
 670   * @retval HAL status
 671   */
 672 HAL_StatusTypeDef HAL_DCMI_EnableCROP(DCMI_HandleTypeDef *hdcmi)
 673 {
 674   /* Process Locked */
 675   __HAL_LOCK(hdcmi);
 676
 677   /* Lock the DCMI peripheral state */
 678   hdcmi->State = HAL_DCMI_STATE_BUSY;
 679
 680   /* Enable DCMI Crop feature */
 681   DCMI->CR |= (uint32_t)DCMI_CR_CROP;
 682
 683   /* Change the DCMI state*/
 684   hdcmi->State = HAL_DCMI_STATE_READY;
 685
 686   /* Process Unlocked */
 687   __HAL_UNLOCK(hdcmi);
 688
 689   return HAL_OK;
 690 }
 691
 692 /**
 693   * @}
 694   */
 695
 696 /** @defgroup DCMI_Group4 Peripheral State functions
 697  *  @brief    Peripheral State functions
 698  *
 699 @verbatim
 700  ===============================================================================
 701                ##### Peripheral State and Errors functions #####
 702  ===============================================================================
 703     [..]
 704     This subsection provides functions allowing to
 705       (+) Check the DCMI state.
 706       (+) Get the specific DCMI error flag.
 707
 708 @endverbatim
 709   * @{
 710   */
 711
 712 /**
 713   * @brief  Return the DCMI state
 714   * @param  hdcmi: pointer to a DCMI_HandleTypeDef structure that contains
 715   *                the configuration information for DCMI.
 716   * @retval HAL state
 717   */
 718 HAL_DCMI_StateTypeDef HAL_DCMI_GetState(DCMI_HandleTypeDef *hdcmi)
 719 {
 720   return hdcmi->State;
 721 }
 722
 723 /**
 724 * @brief  Return the DCMI error code
 725 * @param  hdcmi : pointer to a DCMI_HandleTypeDef structure that contains
 726   *               the configuration information for DCMI.
 727 * @retval DCMI Error Code
 728 */
 729 uint32_t HAL_DCMI_GetError(DCMI_HandleTypeDef *hdcmi)
 730 {
 731   return hdcmi->ErrorCode;
 732 }
 733
 734 /**
 735   * @}
 736   */
 737
 738   /**
 739   * @brief  DMA conversion complete callback.
 740   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
 741   *                the configuration information for the specified DMA module.
 742   * @retval None
 743   */
 744 static void DCMI_DMAConvCplt(DMA_HandleTypeDef *hdma)
 745 {
 746   uint32_t tmp = 0;
 747
 748   DCMI_HandleTypeDef* hdcmi = ( DCMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
 749   hdcmi->State= HAL_DCMI_STATE_READY;
 750
 751   if(hdcmi->XferCount != 0)
 752   {
 753     /* Update memory 0 address location */
 754     tmp = ((hdcmi->DMA_Handle->Instance->CR) & DMA_SxCR_CT);
 755     if(((hdcmi->XferCount % 2) == 0) && (tmp != 0))
 756     {
 757       tmp = hdcmi->DMA_Handle->Instance->M0AR;
 758       HAL_DMAEx_ChangeMemory(hdcmi->DMA_Handle, (tmp + (8*hdcmi->XferSize)), MEMORY0);
 759       hdcmi->XferCount--;
 760     }
 761     /* Update memory 1 address location */
 762     else if((hdcmi->DMA_Handle->Instance->CR & DMA_SxCR_CT) == 0)
 763     {
 764       tmp = hdcmi->DMA_Handle->Instance->M1AR;
 765       HAL_DMAEx_ChangeMemory(hdcmi->DMA_Handle, (tmp + (8*hdcmi->XferSize)), MEMORY1);
 766       hdcmi->XferCount--;
 767     }
 768   }
 769   /* Update memory 0 address location */
 770   else if((hdcmi->DMA_Handle->Instance->CR & DMA_SxCR_CT) != 0)
 771   {
 772     hdcmi->DMA_Handle->Instance->M0AR = hdcmi->pBuffPtr;
 773   }
 774   /* Update memory 1 address location */
 775   else if((hdcmi->DMA_Handle->Instance->CR & DMA_SxCR_CT) == 0)
 776   {
 777     tmp = hdcmi->pBuffPtr;
 778     hdcmi->DMA_Handle->Instance->M1AR = (tmp + (4*hdcmi->XferSize));
 779     hdcmi->XferCount = hdcmi->XferTransferNumber;
 780   }
 781
 782   if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_FRAMERI) != RESET)
 783   {
 784     /* Process Unlocked */
 785     __HAL_UNLOCK(hdcmi);
 786
 787     /* FRAME Callback */
 788     HAL_DCMI_FrameEventCallback(hdcmi);
 789   }
 790 }
 791
 792 /**
 793   * @brief  DMA error callback
 794   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
 795   *                the configuration information for the specified DMA module.
 796   * @retval None
 797   */
 798 static void DCMI_DMAError(DMA_HandleTypeDef *hdma)
 799 {
 800     DCMI_HandleTypeDef* hdcmi = ( DCMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
 801     hdcmi->State= HAL_DCMI_STATE_READY;
 802     HAL_DCMI_ErrorCallback(hdcmi);
 803 }
 804
 805 /**
 806   * @}
 807   */
 808 #endif /* STM32F405xx || STM32F415xx || STM32F407xx || STM32F417xx || STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx */
 809 #endif /* HAL_DCMI_MODULE_ENABLED */
 810 /**
 811   * @}
 812   */
 813
 814 /**
 815   * @}
 816   */
 817
 818 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/