mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F7/device/stm32f7xx_hal_dsi.c@165:e614a9f1c9e2, 2017-05-26 (annotated)

Committer:
AnnaBridge
Date:
Fri May 26 12:39:01 2017 +0100
Revision:
165:e614a9f1c9e2
Parent:
161:2cc1468da177
Child:
168:9672193075cf
This updates the lib to the mbed lib v 143

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f7xx_hal_dsi.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 161:2cc1468da177 5 * @version V1.2.0
<> 161:2cc1468da177 6 * @date 30-December-2016
<> 144:ef7eb2e8f9f7 7 * @brief DSI HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities of the DSI peripheral:
<> 144:ef7eb2e8f9f7 10 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 11 * + IO operation functions
<> 144:ef7eb2e8f9f7 12 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 14 ******************************************************************************
<> 144:ef7eb2e8f9f7 15 * @attention
<> 144:ef7eb2e8f9f7 16 *
<> 144:ef7eb2e8f9f7 17 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 18 *
<> 144:ef7eb2e8f9f7 19 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 20 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 21 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 22 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 23 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 24 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 25 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 26 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 27 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 28 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 29 *
<> 144:ef7eb2e8f9f7 30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 33 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 34 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 36 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 37 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 38 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 40 *
<> 144:ef7eb2e8f9f7 41 ******************************************************************************
<> 144:ef7eb2e8f9f7 42 */
<> 144:ef7eb2e8f9f7 43
<> 144:ef7eb2e8f9f7 44 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 45 #include "stm32f7xx_hal.h"
<> 144:ef7eb2e8f9f7 46
<> 144:ef7eb2e8f9f7 47 /** @addtogroup STM32F7xx_HAL_Driver
<> 144:ef7eb2e8f9f7 48 * @{
<> 144:ef7eb2e8f9f7 49 */
<> 144:ef7eb2e8f9f7 50 /** @addtogroup DSI
<> 144:ef7eb2e8f9f7 51 * @{
<> 144:ef7eb2e8f9f7 52 */
<> 144:ef7eb2e8f9f7 53
<> 144:ef7eb2e8f9f7 54 #ifdef HAL_DSI_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 55
<> 144:ef7eb2e8f9f7 56 #if defined (STM32F769xx) || defined (STM32F779xx)
<> 144:ef7eb2e8f9f7 57
<> 144:ef7eb2e8f9f7 58 /* Private types -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 59 /* Private defines -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 60 /** @addtogroup DSI_Private_Constants
<> 144:ef7eb2e8f9f7 61 * @{
<> 144:ef7eb2e8f9f7 62 */
<> 144:ef7eb2e8f9f7 63 #define DSI_TIMEOUT_VALUE ((uint32_t)1000) /* 1s */
<> 144:ef7eb2e8f9f7 64
<> 144:ef7eb2e8f9f7 65 #define DSI_ERROR_ACK_MASK (DSI_ISR0_AE0 | DSI_ISR0_AE1 | DSI_ISR0_AE2 | DSI_ISR0_AE3 | \
<> 144:ef7eb2e8f9f7 66 DSI_ISR0_AE4 | DSI_ISR0_AE5 | DSI_ISR0_AE6 | DSI_ISR0_AE7 | \
<> 144:ef7eb2e8f9f7 67 DSI_ISR0_AE8 | DSI_ISR0_AE9 | DSI_ISR0_AE10 | DSI_ISR0_AE11 | \
<> 144:ef7eb2e8f9f7 68 DSI_ISR0_AE12 | DSI_ISR0_AE13 | DSI_ISR0_AE14 | DSI_ISR0_AE15)
<> 144:ef7eb2e8f9f7 69 #define DSI_ERROR_PHY_MASK (DSI_ISR0_PE0 | DSI_ISR0_PE1 | DSI_ISR0_PE2 | DSI_ISR0_PE3 | DSI_ISR0_PE4)
<> 144:ef7eb2e8f9f7 70 #define DSI_ERROR_TX_MASK DSI_ISR1_TOHSTX
<> 144:ef7eb2e8f9f7 71 #define DSI_ERROR_RX_MASK DSI_ISR1_TOLPRX
<> 144:ef7eb2e8f9f7 72 #define DSI_ERROR_ECC_MASK (DSI_ISR1_ECCSE | DSI_ISR1_ECCME)
<> 144:ef7eb2e8f9f7 73 #define DSI_ERROR_CRC_MASK DSI_ISR1_CRCE
<> 144:ef7eb2e8f9f7 74 #define DSI_ERROR_PSE_MASK DSI_ISR1_PSE
<> 144:ef7eb2e8f9f7 75 #define DSI_ERROR_EOT_MASK DSI_ISR1_EOTPE
<> 144:ef7eb2e8f9f7 76 #define DSI_ERROR_OVF_MASK DSI_ISR1_LPWRE
<> 144:ef7eb2e8f9f7 77 #define DSI_ERROR_GEN_MASK (DSI_ISR1_GCWRE | DSI_ISR1_GPWRE | DSI_ISR1_GPTXE | DSI_ISR1_GPRDE | DSI_ISR1_GPRXE)
<> 144:ef7eb2e8f9f7 78 /**
<> 144:ef7eb2e8f9f7 79 * @}
<> 144:ef7eb2e8f9f7 80 */
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 83 /* Private constants ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 84 /* Private macros ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 85 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 86 static void DSI_ConfigPacketHeader(DSI_TypeDef *DSIx, uint32_t ChannelID, uint32_t DataType, uint32_t Data0, uint32_t Data1);
<> 144:ef7eb2e8f9f7 87
<> 144:ef7eb2e8f9f7 88 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 89 /**
<> 144:ef7eb2e8f9f7 90 * @brief Generic DSI packet header configuration
<> 144:ef7eb2e8f9f7 91 * @param DSIx: Pointer to DSI register base
<> 144:ef7eb2e8f9f7 92 * @param ChannelID: Virtual channel ID of the header packet
<> 144:ef7eb2e8f9f7 93 * @param DataType: Packet data type of the header packet
<> 144:ef7eb2e8f9f7 94 * This parameter can be any value of :
<> 144:ef7eb2e8f9f7 95 * @ref DSI_SHORT_WRITE_PKT_Data_Type
<> 144:ef7eb2e8f9f7 96 * or @ref DSI_LONG_WRITE_PKT_Data_Type
<> 144:ef7eb2e8f9f7 97 * or @ref DSI_SHORT_READ_PKT_Data_Type
<> 144:ef7eb2e8f9f7 98 * or DSI_MAX_RETURN_PKT_SIZE
<> 144:ef7eb2e8f9f7 99 * @param Data0: Word count LSB
<> 144:ef7eb2e8f9f7 100 * @param Data1: Word count MSB
<> 144:ef7eb2e8f9f7 101 * @retval None
<> 144:ef7eb2e8f9f7 102 */
<> 144:ef7eb2e8f9f7 103 static void DSI_ConfigPacketHeader(DSI_TypeDef *DSIx,
<> 144:ef7eb2e8f9f7 104 uint32_t ChannelID,
<> 144:ef7eb2e8f9f7 105 uint32_t DataType,
<> 144:ef7eb2e8f9f7 106 uint32_t Data0,
<> 144:ef7eb2e8f9f7 107 uint32_t Data1)
<> 144:ef7eb2e8f9f7 108 {
<> 144:ef7eb2e8f9f7 109 /* Update the DSI packet header with new information */
<> 144:ef7eb2e8f9f7 110 DSIx->GHCR = (DataType | (ChannelID<<6) | (Data0<<8) | (Data1<<16));
<> 144:ef7eb2e8f9f7 111 }
<> 144:ef7eb2e8f9f7 112
<> 144:ef7eb2e8f9f7 113 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 114 /** @addtogroup DSI_Exported_Functions
<> 144:ef7eb2e8f9f7 115 * @{
<> 144:ef7eb2e8f9f7 116 */
<> 144:ef7eb2e8f9f7 117
<> 144:ef7eb2e8f9f7 118 /** @defgroup DSI_Group1 Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 119 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 120 *
<> 144:ef7eb2e8f9f7 121 @verbatim
<> 144:ef7eb2e8f9f7 122 ===============================================================================
<> 144:ef7eb2e8f9f7 123 ##### Initialization and Configuration functions #####
<> 144:ef7eb2e8f9f7 124 ===============================================================================
<> 144:ef7eb2e8f9f7 125 [..] This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 126 (+) Initialize and configure the DSI
<> 144:ef7eb2e8f9f7 127 (+) De-initialize the DSI
<> 144:ef7eb2e8f9f7 128
<> 144:ef7eb2e8f9f7 129 @endverbatim
<> 144:ef7eb2e8f9f7 130 * @{
<> 144:ef7eb2e8f9f7 131 */
<> 144:ef7eb2e8f9f7 132
<> 144:ef7eb2e8f9f7 133 /**
<> 144:ef7eb2e8f9f7 134 * @brief Initializes the DSI according to the specified
<> 144:ef7eb2e8f9f7 135 * parameters in the DSI_InitTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 136 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 137 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 138 * @param PLLInit: pointer to a DSI_PLLInitTypeDef structure that contains
<> 144:ef7eb2e8f9f7 139 * the PLL Clock structure definition for the DSI.
<> 144:ef7eb2e8f9f7 140 * @retval HAL status
<> 144:ef7eb2e8f9f7 141 */
<> 144:ef7eb2e8f9f7 142 HAL_StatusTypeDef HAL_DSI_Init(DSI_HandleTypeDef *hdsi, DSI_PLLInitTypeDef *PLLInit)
<> 144:ef7eb2e8f9f7 143 {
<> 144:ef7eb2e8f9f7 144 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 145 uint32_t unitIntervalx4 = 0;
<> 144:ef7eb2e8f9f7 146 uint32_t tempIDF = 0;
<> 144:ef7eb2e8f9f7 147
<> 144:ef7eb2e8f9f7 148 /* Check the DSI handle allocation */
<> 144:ef7eb2e8f9f7 149 if(hdsi == NULL)
<> 144:ef7eb2e8f9f7 150 {
<> 144:ef7eb2e8f9f7 151 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 152 }
<> 144:ef7eb2e8f9f7 153
<> 144:ef7eb2e8f9f7 154 /* Check function parameters */
<> 144:ef7eb2e8f9f7 155 assert_param(IS_DSI_PLL_NDIV(PLLInit->PLLNDIV));
<> 144:ef7eb2e8f9f7 156 assert_param(IS_DSI_PLL_IDF(PLLInit->PLLIDF));
<> 144:ef7eb2e8f9f7 157 assert_param(IS_DSI_PLL_ODF(PLLInit->PLLODF));
<> 144:ef7eb2e8f9f7 158 assert_param(IS_DSI_AUTO_CLKLANE_CONTROL(hdsi->Init.AutomaticClockLaneControl));
<> 144:ef7eb2e8f9f7 159 assert_param(IS_DSI_NUMBER_OF_LANES(hdsi->Init.NumberOfLanes));
<> 144:ef7eb2e8f9f7 160
<> 144:ef7eb2e8f9f7 161 if(hdsi->State == HAL_DSI_STATE_RESET)
<> 144:ef7eb2e8f9f7 162 {
<> 144:ef7eb2e8f9f7 163 /* Initialize the low level hardware */
<> 144:ef7eb2e8f9f7 164 HAL_DSI_MspInit(hdsi);
<> 144:ef7eb2e8f9f7 165 }
<> 144:ef7eb2e8f9f7 166
<> 144:ef7eb2e8f9f7 167 /* Change DSI peripheral state */
<> 144:ef7eb2e8f9f7 168 hdsi->State = HAL_DSI_STATE_BUSY;
<> 144:ef7eb2e8f9f7 169
<> 144:ef7eb2e8f9f7 170 /**************** Turn on the regulator and enable the DSI PLL ****************/
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /* Enable the regulator */
<> 144:ef7eb2e8f9f7 173 __HAL_DSI_REG_ENABLE(hdsi);
<> 144:ef7eb2e8f9f7 174
<> 144:ef7eb2e8f9f7 175 /* Get tick */
<> 144:ef7eb2e8f9f7 176 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 177
<> 144:ef7eb2e8f9f7 178 /* Wait until the regulator is ready */
<> 144:ef7eb2e8f9f7 179 while(__HAL_DSI_GET_FLAG(hdsi, DSI_FLAG_RRS) == RESET)
<> 144:ef7eb2e8f9f7 180 {
<> 144:ef7eb2e8f9f7 181 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 182 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 183 {
<> 144:ef7eb2e8f9f7 184 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 185 }
<> 144:ef7eb2e8f9f7 186 }
<> 144:ef7eb2e8f9f7 187
<> 144:ef7eb2e8f9f7 188 /* Set the PLL division factors */
<> 144:ef7eb2e8f9f7 189 hdsi->Instance->WRPCR &= ~(DSI_WRPCR_PLL_NDIV | DSI_WRPCR_PLL_IDF | DSI_WRPCR_PLL_ODF);
<> 144:ef7eb2e8f9f7 190 hdsi->Instance->WRPCR |= (((PLLInit->PLLNDIV)<<2) | ((PLLInit->PLLIDF)<<11) | ((PLLInit->PLLODF)<<16));
<> 144:ef7eb2e8f9f7 191
<> 144:ef7eb2e8f9f7 192 /* Enable the DSI PLL */
<> 144:ef7eb2e8f9f7 193 __HAL_DSI_PLL_ENABLE(hdsi);
<> 144:ef7eb2e8f9f7 194
<> 144:ef7eb2e8f9f7 195 /* Get tick */
<> 144:ef7eb2e8f9f7 196 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 197
<> 144:ef7eb2e8f9f7 198 /* Wait for the lock of the PLL */
<> 144:ef7eb2e8f9f7 199 while(__HAL_DSI_GET_FLAG(hdsi, DSI_FLAG_PLLLS) == RESET)
<> 144:ef7eb2e8f9f7 200 {
<> 144:ef7eb2e8f9f7 201 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 202 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 203 {
<> 144:ef7eb2e8f9f7 204 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 205 }
<> 144:ef7eb2e8f9f7 206 }
<> 144:ef7eb2e8f9f7 207
<> 144:ef7eb2e8f9f7 208 /*************************** Set the PHY parameters ***************************/
<> 144:ef7eb2e8f9f7 209
<> 144:ef7eb2e8f9f7 210 /* D-PHY clock and digital enable*/
<> 144:ef7eb2e8f9f7 211 hdsi->Instance->PCTLR |= (DSI_PCTLR_CKE | DSI_PCTLR_DEN);
<> 144:ef7eb2e8f9f7 212
<> 144:ef7eb2e8f9f7 213 /* Clock lane configuration */
<> 144:ef7eb2e8f9f7 214 hdsi->Instance->CLCR &= ~(DSI_CLCR_DPCC | DSI_CLCR_ACR);
<> 144:ef7eb2e8f9f7 215 hdsi->Instance->CLCR |= (DSI_CLCR_DPCC | hdsi->Init.AutomaticClockLaneControl);
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 /* Configure the number of active data lanes */
<> 144:ef7eb2e8f9f7 218 hdsi->Instance->PCONFR &= ~DSI_PCONFR_NL;
<> 144:ef7eb2e8f9f7 219 hdsi->Instance->PCONFR |= hdsi->Init.NumberOfLanes;
<> 144:ef7eb2e8f9f7 220
<> 144:ef7eb2e8f9f7 221 /************************ Set the DSI clock parameters ************************/
<> 144:ef7eb2e8f9f7 222
<> 144:ef7eb2e8f9f7 223 /* Set the TX escape clock division factor */
<> 144:ef7eb2e8f9f7 224 hdsi->Instance->CCR &= ~DSI_CCR_TXECKDIV;
<> 157:ff67d9f36b67 225 hdsi->Instance->CCR |= hdsi->Init.TXEscapeCkdiv;
<> 144:ef7eb2e8f9f7 226
<> 144:ef7eb2e8f9f7 227 /* Calculate the bit period in high-speed mode in unit of 0.25 ns (UIX4) */
<> 144:ef7eb2e8f9f7 228 /* The equation is : UIX4 = IntegerPart( (1000/F_PHY_Mhz) * 4 ) */
<> 144:ef7eb2e8f9f7 229 /* Where : F_PHY_Mhz = (NDIV * HSE_Mhz) / (IDF * ODF) */
<> 144:ef7eb2e8f9f7 230 tempIDF = (PLLInit->PLLIDF > 0) ? PLLInit->PLLIDF : 1;
<> 144:ef7eb2e8f9f7 231 unitIntervalx4 = (4000000 * tempIDF * (1 << PLLInit->PLLODF)) / ((HSE_VALUE/1000) * PLLInit->PLLNDIV);
<> 144:ef7eb2e8f9f7 232
<> 144:ef7eb2e8f9f7 233 /* Set the bit period in high-speed mode */
<> 144:ef7eb2e8f9f7 234 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_UIX4;
<> 144:ef7eb2e8f9f7 235 hdsi->Instance->WPCR[0] |= unitIntervalx4;
<> 144:ef7eb2e8f9f7 236
<> 144:ef7eb2e8f9f7 237 /****************************** Error management *****************************/
<> 144:ef7eb2e8f9f7 238
<> 144:ef7eb2e8f9f7 239 /* Disable all error interrupts and reset the Error Mask */
<> 144:ef7eb2e8f9f7 240 hdsi->Instance->IER[0] = 0;
<> 144:ef7eb2e8f9f7 241 hdsi->Instance->IER[1] = 0;
<> 144:ef7eb2e8f9f7 242 hdsi->ErrorMsk = 0;
<> 144:ef7eb2e8f9f7 243
<> 144:ef7eb2e8f9f7 244 /* Initialise the error code */
<> 144:ef7eb2e8f9f7 245 hdsi->ErrorCode = HAL_DSI_ERROR_NONE;
<> 144:ef7eb2e8f9f7 246
<> 144:ef7eb2e8f9f7 247 /* Initialize the DSI state*/
<> 144:ef7eb2e8f9f7 248 hdsi->State = HAL_DSI_STATE_READY;
<> 144:ef7eb2e8f9f7 249
<> 144:ef7eb2e8f9f7 250 return HAL_OK;
<> 144:ef7eb2e8f9f7 251 }
<> 144:ef7eb2e8f9f7 252
<> 144:ef7eb2e8f9f7 253 /**
<> 144:ef7eb2e8f9f7 254 * @brief De-initializes the DSI peripheral registers to their default reset
<> 144:ef7eb2e8f9f7 255 * values.
<> 144:ef7eb2e8f9f7 256 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 257 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 258 * @retval HAL status
<> 144:ef7eb2e8f9f7 259 */
<> 144:ef7eb2e8f9f7 260 HAL_StatusTypeDef HAL_DSI_DeInit(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 261 {
<> 144:ef7eb2e8f9f7 262 /* Check the DSI handle allocation */
<> 144:ef7eb2e8f9f7 263 if(hdsi == NULL)
<> 144:ef7eb2e8f9f7 264 {
<> 144:ef7eb2e8f9f7 265 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 266 }
<> 144:ef7eb2e8f9f7 267
<> 144:ef7eb2e8f9f7 268 /* Change DSI peripheral state */
<> 144:ef7eb2e8f9f7 269 hdsi->State = HAL_DSI_STATE_BUSY;
<> 144:ef7eb2e8f9f7 270
<> 144:ef7eb2e8f9f7 271 /* Disable the DSI wrapper */
<> 144:ef7eb2e8f9f7 272 __HAL_DSI_WRAPPER_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 273
<> 144:ef7eb2e8f9f7 274 /* Disable the DSI host */
<> 144:ef7eb2e8f9f7 275 __HAL_DSI_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 276
<> 144:ef7eb2e8f9f7 277 /* D-PHY clock and digital disable */
<> 144:ef7eb2e8f9f7 278 hdsi->Instance->PCTLR &= ~(DSI_PCTLR_CKE | DSI_PCTLR_DEN);
<> 144:ef7eb2e8f9f7 279
<> 144:ef7eb2e8f9f7 280 /* Turn off the DSI PLL */
<> 144:ef7eb2e8f9f7 281 __HAL_DSI_PLL_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 282
<> 144:ef7eb2e8f9f7 283 /* Disable the regulator */
<> 144:ef7eb2e8f9f7 284 __HAL_DSI_REG_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 285
<> 144:ef7eb2e8f9f7 286 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 287 HAL_DSI_MspDeInit(hdsi);
<> 144:ef7eb2e8f9f7 288
<> 144:ef7eb2e8f9f7 289 /* Initialise the error code */
<> 144:ef7eb2e8f9f7 290 hdsi->ErrorCode = HAL_DSI_ERROR_NONE;
<> 144:ef7eb2e8f9f7 291
<> 144:ef7eb2e8f9f7 292 /* Initialize the DSI state*/
<> 144:ef7eb2e8f9f7 293 hdsi->State = HAL_DSI_STATE_RESET;
<> 144:ef7eb2e8f9f7 294
<> 144:ef7eb2e8f9f7 295 /* Release Lock */
<> 144:ef7eb2e8f9f7 296 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 297
<> 144:ef7eb2e8f9f7 298 return HAL_OK;
<> 144:ef7eb2e8f9f7 299 }
<> 144:ef7eb2e8f9f7 300
<> 144:ef7eb2e8f9f7 301 /**
<> 144:ef7eb2e8f9f7 302 * @brief Return the DSI error code
<> 144:ef7eb2e8f9f7 303 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 304 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 305 * @retval DSI Error Code
<> 144:ef7eb2e8f9f7 306 */
<> 144:ef7eb2e8f9f7 307 uint32_t HAL_DSI_GetError(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 308 {
<> 144:ef7eb2e8f9f7 309 /* Get the error code */
<> 144:ef7eb2e8f9f7 310 return hdsi->ErrorCode;
<> 144:ef7eb2e8f9f7 311 }
<> 144:ef7eb2e8f9f7 312
<> 144:ef7eb2e8f9f7 313 /**
<> 144:ef7eb2e8f9f7 314 * @brief Enable the error monitor flags
<> 144:ef7eb2e8f9f7 315 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 316 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 317 * @param ActiveErrors: indicates which error interrupts will be enabled.
<> 144:ef7eb2e8f9f7 318 * This parameter can be any combination of @ref DSI_Error_Data_Type.
<> 144:ef7eb2e8f9f7 319 * @retval HAL status
<> 144:ef7eb2e8f9f7 320 */
<> 144:ef7eb2e8f9f7 321 HAL_StatusTypeDef HAL_DSI_ConfigErrorMonitor(DSI_HandleTypeDef *hdsi, uint32_t ActiveErrors)
<> 144:ef7eb2e8f9f7 322 {
<> 144:ef7eb2e8f9f7 323 /* Process locked */
<> 144:ef7eb2e8f9f7 324 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 325
<> 144:ef7eb2e8f9f7 326 hdsi->Instance->IER[0] = 0;
<> 144:ef7eb2e8f9f7 327 hdsi->Instance->IER[1] = 0;
<> 144:ef7eb2e8f9f7 328
<> 144:ef7eb2e8f9f7 329 /* Store active errors to the handle */
<> 144:ef7eb2e8f9f7 330 hdsi->ErrorMsk = ActiveErrors;
<> 144:ef7eb2e8f9f7 331
<> 144:ef7eb2e8f9f7 332 if((ActiveErrors & HAL_DSI_ERROR_ACK) != RESET)
<> 144:ef7eb2e8f9f7 333 {
<> 144:ef7eb2e8f9f7 334 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 335 hdsi->Instance->IER[0] |= DSI_ERROR_ACK_MASK;
<> 144:ef7eb2e8f9f7 336 }
<> 144:ef7eb2e8f9f7 337
<> 144:ef7eb2e8f9f7 338 if((ActiveErrors & HAL_DSI_ERROR_PHY ) != RESET)
<> 144:ef7eb2e8f9f7 339 {
<> 144:ef7eb2e8f9f7 340 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 341 hdsi->Instance->IER[0] |= DSI_ERROR_PHY_MASK;
<> 144:ef7eb2e8f9f7 342 }
<> 144:ef7eb2e8f9f7 343
<> 144:ef7eb2e8f9f7 344 if((ActiveErrors & HAL_DSI_ERROR_TX) != RESET)
<> 144:ef7eb2e8f9f7 345 {
<> 144:ef7eb2e8f9f7 346 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 347 hdsi->Instance->IER[1] |= DSI_ERROR_TX_MASK;
<> 144:ef7eb2e8f9f7 348 }
<> 144:ef7eb2e8f9f7 349
<> 144:ef7eb2e8f9f7 350 if((ActiveErrors & HAL_DSI_ERROR_RX) != RESET)
<> 144:ef7eb2e8f9f7 351 {
<> 144:ef7eb2e8f9f7 352 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 353 hdsi->Instance->IER[1] |= DSI_ERROR_RX_MASK;
<> 144:ef7eb2e8f9f7 354 }
<> 144:ef7eb2e8f9f7 355
<> 144:ef7eb2e8f9f7 356 if((ActiveErrors & HAL_DSI_ERROR_ECC) != RESET)
<> 144:ef7eb2e8f9f7 357 {
<> 144:ef7eb2e8f9f7 358 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 359 hdsi->Instance->IER[1] |= DSI_ERROR_ECC_MASK;
<> 144:ef7eb2e8f9f7 360 }
<> 144:ef7eb2e8f9f7 361
<> 144:ef7eb2e8f9f7 362 if((ActiveErrors & HAL_DSI_ERROR_CRC) != RESET)
<> 144:ef7eb2e8f9f7 363 {
<> 144:ef7eb2e8f9f7 364 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 365 hdsi->Instance->IER[1] |= DSI_ERROR_CRC_MASK;
<> 144:ef7eb2e8f9f7 366 }
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 if((ActiveErrors & HAL_DSI_ERROR_PSE) != RESET)
<> 144:ef7eb2e8f9f7 369 {
<> 144:ef7eb2e8f9f7 370 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 371 hdsi->Instance->IER[1] |= DSI_ERROR_PSE_MASK;
<> 144:ef7eb2e8f9f7 372 }
<> 144:ef7eb2e8f9f7 373
<> 144:ef7eb2e8f9f7 374 if((ActiveErrors & HAL_DSI_ERROR_EOT) != RESET)
<> 144:ef7eb2e8f9f7 375 {
<> 144:ef7eb2e8f9f7 376 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 377 hdsi->Instance->IER[1] |= DSI_ERROR_EOT_MASK;
<> 144:ef7eb2e8f9f7 378 }
<> 144:ef7eb2e8f9f7 379
<> 144:ef7eb2e8f9f7 380 if((ActiveErrors & HAL_DSI_ERROR_OVF) != RESET)
<> 144:ef7eb2e8f9f7 381 {
<> 144:ef7eb2e8f9f7 382 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 383 hdsi->Instance->IER[1] |= DSI_ERROR_OVF_MASK;
<> 144:ef7eb2e8f9f7 384 }
<> 144:ef7eb2e8f9f7 385
<> 144:ef7eb2e8f9f7 386 if((ActiveErrors & HAL_DSI_ERROR_GEN) != RESET)
<> 144:ef7eb2e8f9f7 387 {
<> 144:ef7eb2e8f9f7 388 /* Enable the interrupt generation on selected errors */
<> 144:ef7eb2e8f9f7 389 hdsi->Instance->IER[1] |= DSI_ERROR_GEN_MASK;
<> 144:ef7eb2e8f9f7 390 }
<> 144:ef7eb2e8f9f7 391
<> 144:ef7eb2e8f9f7 392 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 393 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 394
<> 144:ef7eb2e8f9f7 395 return HAL_OK;
<> 144:ef7eb2e8f9f7 396 }
<> 144:ef7eb2e8f9f7 397
<> 144:ef7eb2e8f9f7 398 /**
<> 144:ef7eb2e8f9f7 399 * @brief Initializes the DSI MSP.
<> 144:ef7eb2e8f9f7 400 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 401 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 402 * @retval None
<> 144:ef7eb2e8f9f7 403 */
<> 144:ef7eb2e8f9f7 404 __weak void HAL_DSI_MspInit(DSI_HandleTypeDef* hdsi)
<> 144:ef7eb2e8f9f7 405 {
<> 144:ef7eb2e8f9f7 406 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 407 UNUSED(hdsi);
<> 144:ef7eb2e8f9f7 408
<> 144:ef7eb2e8f9f7 409 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 410 the HAL_DSI_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 411 */
<> 144:ef7eb2e8f9f7 412 }
<> 144:ef7eb2e8f9f7 413
<> 144:ef7eb2e8f9f7 414 /**
<> 144:ef7eb2e8f9f7 415 * @brief De-initializes the DSI MSP.
<> 144:ef7eb2e8f9f7 416 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 417 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 418 * @retval None
<> 144:ef7eb2e8f9f7 419 */
<> 144:ef7eb2e8f9f7 420 __weak void HAL_DSI_MspDeInit(DSI_HandleTypeDef* hdsi)
<> 144:ef7eb2e8f9f7 421 {
<> 144:ef7eb2e8f9f7 422 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 423 UNUSED(hdsi);
<> 144:ef7eb2e8f9f7 424
<> 144:ef7eb2e8f9f7 425 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 426 the HAL_DSI_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 427 */
<> 144:ef7eb2e8f9f7 428 }
<> 144:ef7eb2e8f9f7 429
<> 144:ef7eb2e8f9f7 430 /**
<> 144:ef7eb2e8f9f7 431 * @}
<> 144:ef7eb2e8f9f7 432 */
<> 144:ef7eb2e8f9f7 433
<> 144:ef7eb2e8f9f7 434 /** @defgroup DSI_Group2 IO operation functions
<> 144:ef7eb2e8f9f7 435 * @brief IO operation functions
<> 144:ef7eb2e8f9f7 436 *
<> 144:ef7eb2e8f9f7 437 @verbatim
<> 144:ef7eb2e8f9f7 438 ===============================================================================
<> 144:ef7eb2e8f9f7 439 ##### IO operation functions #####
<> 144:ef7eb2e8f9f7 440 ===============================================================================
<> 144:ef7eb2e8f9f7 441 [..] This section provides function allowing to:
<> 144:ef7eb2e8f9f7 442 (+) Handle DSI interrupt request
<> 144:ef7eb2e8f9f7 443
<> 144:ef7eb2e8f9f7 444 @endverbatim
<> 144:ef7eb2e8f9f7 445 * @{
<> 144:ef7eb2e8f9f7 446 */
<> 144:ef7eb2e8f9f7 447 /**
<> 144:ef7eb2e8f9f7 448 * @brief Handles DSI interrupt request.
<> 144:ef7eb2e8f9f7 449 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 450 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 451 * @retval HAL status
<> 144:ef7eb2e8f9f7 452 */
<> 144:ef7eb2e8f9f7 453 void HAL_DSI_IRQHandler(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 454 {
<> 144:ef7eb2e8f9f7 455 uint32_t ErrorStatus0, ErrorStatus1;
<> 144:ef7eb2e8f9f7 456
<> 144:ef7eb2e8f9f7 457 /* Tearing Effect Interrupt management ***************************************/
<> 144:ef7eb2e8f9f7 458 if(__HAL_DSI_GET_FLAG(hdsi, DSI_FLAG_TE) != RESET)
<> 144:ef7eb2e8f9f7 459 {
<> 144:ef7eb2e8f9f7 460 if(__HAL_DSI_GET_IT_SOURCE(hdsi, DSI_IT_TE) != RESET)
<> 144:ef7eb2e8f9f7 461 {
<> 144:ef7eb2e8f9f7 462 /* Clear the Tearing Effect Interrupt Flag */
<> 144:ef7eb2e8f9f7 463 __HAL_DSI_CLEAR_FLAG(hdsi, DSI_FLAG_TE);
<> 144:ef7eb2e8f9f7 464
<> 144:ef7eb2e8f9f7 465 /* Tearing Effect Callback */
<> 144:ef7eb2e8f9f7 466 HAL_DSI_TearingEffectCallback(hdsi);
<> 144:ef7eb2e8f9f7 467 }
<> 144:ef7eb2e8f9f7 468 }
<> 144:ef7eb2e8f9f7 469
<> 144:ef7eb2e8f9f7 470 /* End of Refresh Interrupt management ***************************************/
<> 144:ef7eb2e8f9f7 471 if(__HAL_DSI_GET_FLAG(hdsi, DSI_FLAG_ER) != RESET)
<> 144:ef7eb2e8f9f7 472 {
<> 144:ef7eb2e8f9f7 473 if(__HAL_DSI_GET_IT_SOURCE(hdsi, DSI_IT_ER) != RESET)
<> 144:ef7eb2e8f9f7 474 {
<> 144:ef7eb2e8f9f7 475 /* Clear the End of Refresh Interrupt Flag */
<> 144:ef7eb2e8f9f7 476 __HAL_DSI_CLEAR_FLAG(hdsi, DSI_FLAG_ER);
<> 144:ef7eb2e8f9f7 477
<> 144:ef7eb2e8f9f7 478 /* End of Refresh Callback */
<> 144:ef7eb2e8f9f7 479 HAL_DSI_EndOfRefreshCallback(hdsi);
<> 144:ef7eb2e8f9f7 480 }
<> 144:ef7eb2e8f9f7 481 }
<> 144:ef7eb2e8f9f7 482
<> 144:ef7eb2e8f9f7 483 /* Error Interrupts management ***********************************************/
<> 144:ef7eb2e8f9f7 484 if(hdsi->ErrorMsk != 0)
<> 144:ef7eb2e8f9f7 485 {
<> 144:ef7eb2e8f9f7 486 ErrorStatus0 = hdsi->Instance->ISR[0];
<> 144:ef7eb2e8f9f7 487 ErrorStatus0 &= hdsi->Instance->IER[0];
<> 144:ef7eb2e8f9f7 488 ErrorStatus1 = hdsi->Instance->ISR[1];
<> 144:ef7eb2e8f9f7 489 ErrorStatus1 &= hdsi->Instance->IER[1];
<> 144:ef7eb2e8f9f7 490
<> 144:ef7eb2e8f9f7 491 if((ErrorStatus0 & DSI_ERROR_ACK_MASK) != RESET)
<> 144:ef7eb2e8f9f7 492 {
<> 144:ef7eb2e8f9f7 493 hdsi->ErrorCode |= HAL_DSI_ERROR_ACK;
<> 144:ef7eb2e8f9f7 494 }
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 if((ErrorStatus0 & DSI_ERROR_PHY_MASK) != RESET)
<> 144:ef7eb2e8f9f7 497 {
<> 144:ef7eb2e8f9f7 498 hdsi->ErrorCode |= HAL_DSI_ERROR_PHY;
<> 144:ef7eb2e8f9f7 499 }
<> 144:ef7eb2e8f9f7 500
<> 144:ef7eb2e8f9f7 501 if((ErrorStatus1 & DSI_ERROR_TX_MASK) != RESET)
<> 144:ef7eb2e8f9f7 502 {
<> 144:ef7eb2e8f9f7 503 hdsi->ErrorCode |= HAL_DSI_ERROR_TX;
<> 144:ef7eb2e8f9f7 504 }
<> 144:ef7eb2e8f9f7 505
<> 144:ef7eb2e8f9f7 506 if((ErrorStatus1 & DSI_ERROR_RX_MASK) != RESET)
<> 144:ef7eb2e8f9f7 507 {
<> 144:ef7eb2e8f9f7 508 hdsi->ErrorCode |= HAL_DSI_ERROR_RX;
<> 144:ef7eb2e8f9f7 509 }
<> 144:ef7eb2e8f9f7 510
<> 144:ef7eb2e8f9f7 511 if((ErrorStatus1 & DSI_ERROR_ECC_MASK) != RESET)
<> 144:ef7eb2e8f9f7 512 {
<> 144:ef7eb2e8f9f7 513 hdsi->ErrorCode |= HAL_DSI_ERROR_ECC;
<> 144:ef7eb2e8f9f7 514 }
<> 144:ef7eb2e8f9f7 515
<> 144:ef7eb2e8f9f7 516 if((ErrorStatus1 & DSI_ERROR_CRC_MASK) != RESET)
<> 144:ef7eb2e8f9f7 517 {
<> 144:ef7eb2e8f9f7 518 hdsi->ErrorCode |= HAL_DSI_ERROR_CRC;
<> 144:ef7eb2e8f9f7 519 }
<> 144:ef7eb2e8f9f7 520
<> 144:ef7eb2e8f9f7 521 if((ErrorStatus1 & DSI_ERROR_PSE_MASK) != RESET)
<> 144:ef7eb2e8f9f7 522 {
<> 144:ef7eb2e8f9f7 523 hdsi->ErrorCode |= HAL_DSI_ERROR_PSE;
<> 144:ef7eb2e8f9f7 524 }
<> 144:ef7eb2e8f9f7 525
<> 144:ef7eb2e8f9f7 526 if((ErrorStatus1 & DSI_ERROR_EOT_MASK) != RESET)
<> 144:ef7eb2e8f9f7 527 {
<> 144:ef7eb2e8f9f7 528 hdsi->ErrorCode |= HAL_DSI_ERROR_EOT;
<> 144:ef7eb2e8f9f7 529 }
<> 144:ef7eb2e8f9f7 530
<> 144:ef7eb2e8f9f7 531 if((ErrorStatus1 & DSI_ERROR_OVF_MASK) != RESET)
<> 144:ef7eb2e8f9f7 532 {
<> 144:ef7eb2e8f9f7 533 hdsi->ErrorCode |= HAL_DSI_ERROR_OVF;
<> 144:ef7eb2e8f9f7 534 }
<> 144:ef7eb2e8f9f7 535
<> 144:ef7eb2e8f9f7 536 if((ErrorStatus1 & DSI_ERROR_GEN_MASK) != RESET)
<> 144:ef7eb2e8f9f7 537 {
<> 144:ef7eb2e8f9f7 538 hdsi->ErrorCode |= HAL_DSI_ERROR_GEN;
<> 144:ef7eb2e8f9f7 539 }
<> 144:ef7eb2e8f9f7 540
<> 144:ef7eb2e8f9f7 541 /* Check only selected errors */
<> 144:ef7eb2e8f9f7 542 if(hdsi->ErrorCode != HAL_DSI_ERROR_NONE)
<> 144:ef7eb2e8f9f7 543 {
<> 144:ef7eb2e8f9f7 544 /* DSI error interrupt user callback */
<> 144:ef7eb2e8f9f7 545 HAL_DSI_ErrorCallback(hdsi);
<> 144:ef7eb2e8f9f7 546 }
<> 144:ef7eb2e8f9f7 547 }
<> 144:ef7eb2e8f9f7 548 }
<> 144:ef7eb2e8f9f7 549
<> 144:ef7eb2e8f9f7 550 /**
<> 144:ef7eb2e8f9f7 551 * @brief Tearing Effect DSI callback.
<> 144:ef7eb2e8f9f7 552 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 553 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 554 * @retval None
<> 144:ef7eb2e8f9f7 555 */
<> 144:ef7eb2e8f9f7 556 __weak void HAL_DSI_TearingEffectCallback(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 557 {
<> 144:ef7eb2e8f9f7 558 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 559 UNUSED(hdsi);
<> 144:ef7eb2e8f9f7 560
<> 144:ef7eb2e8f9f7 561 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 562 the HAL_DSI_TearingEffectCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 563 */
<> 144:ef7eb2e8f9f7 564 }
<> 144:ef7eb2e8f9f7 565
<> 144:ef7eb2e8f9f7 566 /**
<> 144:ef7eb2e8f9f7 567 * @brief End of Refresh DSI callback.
<> 144:ef7eb2e8f9f7 568 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 569 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 570 * @retval None
<> 144:ef7eb2e8f9f7 571 */
<> 144:ef7eb2e8f9f7 572 __weak void HAL_DSI_EndOfRefreshCallback(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 573 {
<> 144:ef7eb2e8f9f7 574 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 575 UNUSED(hdsi);
<> 144:ef7eb2e8f9f7 576
<> 144:ef7eb2e8f9f7 577 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 578 the HAL_DSI_EndOfRefreshCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 579 */
<> 144:ef7eb2e8f9f7 580 }
<> 144:ef7eb2e8f9f7 581
<> 144:ef7eb2e8f9f7 582 /**
<> 144:ef7eb2e8f9f7 583 * @brief Operation Error DSI callback.
<> 144:ef7eb2e8f9f7 584 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 585 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 586 * @retval None
<> 144:ef7eb2e8f9f7 587 */
<> 144:ef7eb2e8f9f7 588 __weak void HAL_DSI_ErrorCallback(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 589 {
<> 144:ef7eb2e8f9f7 590 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 591 UNUSED(hdsi);
<> 144:ef7eb2e8f9f7 592
<> 144:ef7eb2e8f9f7 593 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 594 the HAL_DSI_ErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 595 */
<> 144:ef7eb2e8f9f7 596 }
<> 144:ef7eb2e8f9f7 597
<> 144:ef7eb2e8f9f7 598 /**
<> 144:ef7eb2e8f9f7 599 * @}
<> 144:ef7eb2e8f9f7 600 */
<> 144:ef7eb2e8f9f7 601
<> 144:ef7eb2e8f9f7 602 /** @defgroup DSI_Group3 Peripheral Control functions
<> 144:ef7eb2e8f9f7 603 * @brief Peripheral Control functions
<> 144:ef7eb2e8f9f7 604 *
<> 144:ef7eb2e8f9f7 605 @verbatim
<> 144:ef7eb2e8f9f7 606 ===============================================================================
<> 144:ef7eb2e8f9f7 607 ##### Peripheral Control functions #####
<> 161:2cc1468da177 608 ===============================================================================
<> 144:ef7eb2e8f9f7 609
<> 144:ef7eb2e8f9f7 610 @endverbatim
<> 144:ef7eb2e8f9f7 611 * @{
<> 144:ef7eb2e8f9f7 612 */
<> 144:ef7eb2e8f9f7 613
<> 144:ef7eb2e8f9f7 614 /**
<> 144:ef7eb2e8f9f7 615 * @brief Configure the Generic interface read-back Virtual Channel ID.
<> 144:ef7eb2e8f9f7 616 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 617 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 618 * @param VirtualChannelID: Virtual channel ID
<> 144:ef7eb2e8f9f7 619 * @retval HAL status
<> 144:ef7eb2e8f9f7 620 */
<> 144:ef7eb2e8f9f7 621 HAL_StatusTypeDef HAL_DSI_SetGenericVCID(DSI_HandleTypeDef *hdsi, uint32_t VirtualChannelID)
<> 144:ef7eb2e8f9f7 622 {
<> 144:ef7eb2e8f9f7 623 /* Process locked */
<> 144:ef7eb2e8f9f7 624 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 625
<> 144:ef7eb2e8f9f7 626 /* Update the GVCID register */
<> 144:ef7eb2e8f9f7 627 hdsi->Instance->GVCIDR &= ~DSI_GVCIDR_VCID;
<> 144:ef7eb2e8f9f7 628 hdsi->Instance->GVCIDR |= VirtualChannelID;
<> 144:ef7eb2e8f9f7 629
<> 144:ef7eb2e8f9f7 630 /* Process unlocked */
<> 144:ef7eb2e8f9f7 631 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 632
<> 144:ef7eb2e8f9f7 633 return HAL_OK;
<> 144:ef7eb2e8f9f7 634 }
<> 144:ef7eb2e8f9f7 635
<> 144:ef7eb2e8f9f7 636 /**
<> 144:ef7eb2e8f9f7 637 * @brief Select video mode and configure the corresponding parameters
<> 144:ef7eb2e8f9f7 638 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 639 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 640 * @param VidCfg: pointer to a DSI_VidCfgTypeDef structure that contains
<> 144:ef7eb2e8f9f7 641 * the DSI video mode configuration parameters
<> 144:ef7eb2e8f9f7 642 * @retval HAL status
<> 144:ef7eb2e8f9f7 643 */
<> 144:ef7eb2e8f9f7 644 HAL_StatusTypeDef HAL_DSI_ConfigVideoMode(DSI_HandleTypeDef *hdsi, DSI_VidCfgTypeDef *VidCfg)
<> 144:ef7eb2e8f9f7 645 {
<> 144:ef7eb2e8f9f7 646 /* Process locked */
<> 144:ef7eb2e8f9f7 647 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 648
<> 144:ef7eb2e8f9f7 649 /* Check the parameters */
<> 144:ef7eb2e8f9f7 650 assert_param(IS_DSI_COLOR_CODING(VidCfg->ColorCoding));
<> 144:ef7eb2e8f9f7 651 assert_param(IS_DSI_VIDEO_MODE_TYPE(VidCfg->Mode));
<> 144:ef7eb2e8f9f7 652 assert_param(IS_DSI_LP_COMMAND(VidCfg->LPCommandEnable));
<> 144:ef7eb2e8f9f7 653 assert_param(IS_DSI_LP_HFP(VidCfg->LPHorizontalFrontPorchEnable));
<> 144:ef7eb2e8f9f7 654 assert_param(IS_DSI_LP_HBP(VidCfg->LPHorizontalBackPorchEnable));
<> 144:ef7eb2e8f9f7 655 assert_param(IS_DSI_LP_VACTIVE(VidCfg->LPVerticalActiveEnable));
<> 144:ef7eb2e8f9f7 656 assert_param(IS_DSI_LP_VFP(VidCfg->LPVerticalFrontPorchEnable));
<> 144:ef7eb2e8f9f7 657 assert_param(IS_DSI_LP_VBP(VidCfg->LPVerticalBackPorchEnable));
<> 144:ef7eb2e8f9f7 658 assert_param(IS_DSI_LP_VSYNC(VidCfg->LPVerticalSyncActiveEnable));
<> 144:ef7eb2e8f9f7 659 assert_param(IS_DSI_FBTAA(VidCfg->FrameBTAAcknowledgeEnable));
<> 144:ef7eb2e8f9f7 660 assert_param(IS_DSI_DE_POLARITY(VidCfg->DEPolarity));
<> 144:ef7eb2e8f9f7 661 assert_param(IS_DSI_VSYNC_POLARITY(VidCfg->VSPolarity));
<> 144:ef7eb2e8f9f7 662 assert_param(IS_DSI_HSYNC_POLARITY(VidCfg->HSPolarity));
<> 144:ef7eb2e8f9f7 663 /* Check the LooselyPacked variant only in 18-bit mode */
<> 144:ef7eb2e8f9f7 664 if(VidCfg->ColorCoding == DSI_RGB666)
<> 144:ef7eb2e8f9f7 665 {
<> 144:ef7eb2e8f9f7 666 assert_param(IS_DSI_LOOSELY_PACKED(VidCfg->LooselyPacked));
<> 144:ef7eb2e8f9f7 667 }
<> 144:ef7eb2e8f9f7 668
<> 144:ef7eb2e8f9f7 669 /* Select video mode by resetting CMDM and DSIM bits */
<> 144:ef7eb2e8f9f7 670 hdsi->Instance->MCR &= ~DSI_MCR_CMDM;
<> 144:ef7eb2e8f9f7 671 hdsi->Instance->WCFGR &= ~DSI_WCFGR_DSIM;
<> 144:ef7eb2e8f9f7 672
<> 144:ef7eb2e8f9f7 673 /* Configure the video mode transmission type */
<> 144:ef7eb2e8f9f7 674 hdsi->Instance->VMCR &= ~DSI_VMCR_VMT;
<> 144:ef7eb2e8f9f7 675 hdsi->Instance->VMCR |= VidCfg->Mode;
<> 144:ef7eb2e8f9f7 676
<> 144:ef7eb2e8f9f7 677 /* Configure the video packet size */
<> 144:ef7eb2e8f9f7 678 hdsi->Instance->VPCR &= ~DSI_VPCR_VPSIZE;
<> 144:ef7eb2e8f9f7 679 hdsi->Instance->VPCR |= VidCfg->PacketSize;
<> 144:ef7eb2e8f9f7 680
<> 144:ef7eb2e8f9f7 681 /* Set the chunks number to be transmitted through the DSI link */
<> 144:ef7eb2e8f9f7 682 hdsi->Instance->VCCR &= ~DSI_VCCR_NUMC;
<> 144:ef7eb2e8f9f7 683 hdsi->Instance->VCCR |= VidCfg->NumberOfChunks;
<> 144:ef7eb2e8f9f7 684
<> 144:ef7eb2e8f9f7 685 /* Set the size of the null packet */
<> 144:ef7eb2e8f9f7 686 hdsi->Instance->VNPCR &= ~DSI_VNPCR_NPSIZE;
<> 144:ef7eb2e8f9f7 687 hdsi->Instance->VNPCR |= VidCfg->NullPacketSize;
<> 144:ef7eb2e8f9f7 688
<> 144:ef7eb2e8f9f7 689 /* Select the virtual channel for the LTDC interface traffic */
<> 144:ef7eb2e8f9f7 690 hdsi->Instance->LVCIDR &= ~DSI_LVCIDR_VCID;
<> 144:ef7eb2e8f9f7 691 hdsi->Instance->LVCIDR |= VidCfg->VirtualChannelID;
<> 144:ef7eb2e8f9f7 692
<> 144:ef7eb2e8f9f7 693 /* Configure the polarity of control signals */
<> 144:ef7eb2e8f9f7 694 hdsi->Instance->LPCR &= ~(DSI_LPCR_DEP | DSI_LPCR_VSP | DSI_LPCR_HSP);
<> 144:ef7eb2e8f9f7 695 hdsi->Instance->LPCR |= (VidCfg->DEPolarity | VidCfg->VSPolarity | VidCfg->HSPolarity);
<> 144:ef7eb2e8f9f7 696
<> 144:ef7eb2e8f9f7 697 /* Select the color coding for the host */
<> 144:ef7eb2e8f9f7 698 hdsi->Instance->LCOLCR &= ~DSI_LCOLCR_COLC;
<> 144:ef7eb2e8f9f7 699 hdsi->Instance->LCOLCR |= VidCfg->ColorCoding;
<> 144:ef7eb2e8f9f7 700
<> 144:ef7eb2e8f9f7 701 /* Select the color coding for the wrapper */
<> 144:ef7eb2e8f9f7 702 hdsi->Instance->WCFGR &= ~DSI_WCFGR_COLMUX;
<> 144:ef7eb2e8f9f7 703 hdsi->Instance->WCFGR |= ((VidCfg->ColorCoding)<<1);
<> 144:ef7eb2e8f9f7 704
<> 144:ef7eb2e8f9f7 705 /* Enable/disable the loosely packed variant to 18-bit configuration */
<> 144:ef7eb2e8f9f7 706 if(VidCfg->ColorCoding == DSI_RGB666)
<> 144:ef7eb2e8f9f7 707 {
<> 144:ef7eb2e8f9f7 708 hdsi->Instance->LCOLCR &= ~DSI_LCOLCR_LPE;
<> 144:ef7eb2e8f9f7 709 hdsi->Instance->LCOLCR |= VidCfg->LooselyPacked;
<> 144:ef7eb2e8f9f7 710 }
<> 144:ef7eb2e8f9f7 711
<> 144:ef7eb2e8f9f7 712 /* Set the Horizontal Synchronization Active (HSA) in lane byte clock cycles */
<> 144:ef7eb2e8f9f7 713 hdsi->Instance->VHSACR &= ~DSI_VHSACR_HSA;
<> 144:ef7eb2e8f9f7 714 hdsi->Instance->VHSACR |= VidCfg->HorizontalSyncActive;
<> 144:ef7eb2e8f9f7 715
<> 144:ef7eb2e8f9f7 716 /* Set the Horizontal Back Porch (HBP) in lane byte clock cycles */
<> 144:ef7eb2e8f9f7 717 hdsi->Instance->VHBPCR &= ~DSI_VHBPCR_HBP;
<> 144:ef7eb2e8f9f7 718 hdsi->Instance->VHBPCR |= VidCfg->HorizontalBackPorch;
<> 144:ef7eb2e8f9f7 719
<> 144:ef7eb2e8f9f7 720 /* Set the total line time (HLINE=HSA+HBP+HACT+HFP) in lane byte clock cycles */
<> 144:ef7eb2e8f9f7 721 hdsi->Instance->VLCR &= ~DSI_VLCR_HLINE;
<> 144:ef7eb2e8f9f7 722 hdsi->Instance->VLCR |= VidCfg->HorizontalLine;
<> 144:ef7eb2e8f9f7 723
<> 144:ef7eb2e8f9f7 724 /* Set the Vertical Synchronization Active (VSA) */
<> 144:ef7eb2e8f9f7 725 hdsi->Instance->VVSACR &= ~DSI_VVSACR_VSA;
<> 144:ef7eb2e8f9f7 726 hdsi->Instance->VVSACR |= VidCfg->VerticalSyncActive;
<> 144:ef7eb2e8f9f7 727
<> 144:ef7eb2e8f9f7 728 /* Set the Vertical Back Porch (VBP)*/
<> 144:ef7eb2e8f9f7 729 hdsi->Instance->VVBPCR &= ~DSI_VVBPCR_VBP;
<> 144:ef7eb2e8f9f7 730 hdsi->Instance->VVBPCR |= VidCfg->VerticalBackPorch;
<> 144:ef7eb2e8f9f7 731
<> 144:ef7eb2e8f9f7 732 /* Set the Vertical Front Porch (VFP)*/
<> 144:ef7eb2e8f9f7 733 hdsi->Instance->VVFPCR &= ~DSI_VVFPCR_VFP;
<> 144:ef7eb2e8f9f7 734 hdsi->Instance->VVFPCR |= VidCfg->VerticalFrontPorch;
<> 144:ef7eb2e8f9f7 735
<> 144:ef7eb2e8f9f7 736 /* Set the Vertical Active period*/
<> 144:ef7eb2e8f9f7 737 hdsi->Instance->VVACR &= ~DSI_VVACR_VA;
<> 144:ef7eb2e8f9f7 738 hdsi->Instance->VVACR |= VidCfg->VerticalActive;
<> 144:ef7eb2e8f9f7 739
<> 144:ef7eb2e8f9f7 740 /* Configure the command transmission mode */
<> 144:ef7eb2e8f9f7 741 hdsi->Instance->VMCR &= ~DSI_VMCR_LPCE;
<> 144:ef7eb2e8f9f7 742 hdsi->Instance->VMCR |= VidCfg->LPCommandEnable;
<> 144:ef7eb2e8f9f7 743
<> 144:ef7eb2e8f9f7 744 /* Low power largest packet size */
<> 144:ef7eb2e8f9f7 745 hdsi->Instance->LPMCR &= ~DSI_LPMCR_LPSIZE;
<> 144:ef7eb2e8f9f7 746 hdsi->Instance->LPMCR |= ((VidCfg->LPLargestPacketSize)<<16);
<> 144:ef7eb2e8f9f7 747
<> 144:ef7eb2e8f9f7 748 /* Low power VACT largest packet size */
<> 144:ef7eb2e8f9f7 749 hdsi->Instance->LPMCR &= ~DSI_LPMCR_VLPSIZE;
<> 144:ef7eb2e8f9f7 750 hdsi->Instance->LPMCR |= VidCfg->LPVACTLargestPacketSize;
<> 144:ef7eb2e8f9f7 751
<> 144:ef7eb2e8f9f7 752 /* Enable LP transition in HFP period */
<> 144:ef7eb2e8f9f7 753 hdsi->Instance->VMCR &= ~DSI_VMCR_LPHFPE;
<> 144:ef7eb2e8f9f7 754 hdsi->Instance->VMCR |= VidCfg->LPHorizontalFrontPorchEnable;
<> 144:ef7eb2e8f9f7 755
<> 144:ef7eb2e8f9f7 756 /* Enable LP transition in HBP period */
<> 144:ef7eb2e8f9f7 757 hdsi->Instance->VMCR &= ~DSI_VMCR_LPHBPE;
<> 144:ef7eb2e8f9f7 758 hdsi->Instance->VMCR |= VidCfg->LPHorizontalBackPorchEnable;
<> 144:ef7eb2e8f9f7 759
<> 144:ef7eb2e8f9f7 760 /* Enable LP transition in VACT period */
<> 144:ef7eb2e8f9f7 761 hdsi->Instance->VMCR &= ~DSI_VMCR_LPVAE;
<> 144:ef7eb2e8f9f7 762 hdsi->Instance->VMCR |= VidCfg->LPVerticalActiveEnable;
<> 144:ef7eb2e8f9f7 763
<> 144:ef7eb2e8f9f7 764 /* Enable LP transition in VFP period */
<> 144:ef7eb2e8f9f7 765 hdsi->Instance->VMCR &= ~DSI_VMCR_LPVFPE;
<> 144:ef7eb2e8f9f7 766 hdsi->Instance->VMCR |= VidCfg->LPVerticalFrontPorchEnable;
<> 144:ef7eb2e8f9f7 767
<> 144:ef7eb2e8f9f7 768 /* Enable LP transition in VBP period */
<> 144:ef7eb2e8f9f7 769 hdsi->Instance->VMCR &= ~DSI_VMCR_LPVBPE;
<> 144:ef7eb2e8f9f7 770 hdsi->Instance->VMCR |= VidCfg->LPVerticalBackPorchEnable;
<> 144:ef7eb2e8f9f7 771
<> 144:ef7eb2e8f9f7 772 /* Enable LP transition in vertical sync period */
<> 144:ef7eb2e8f9f7 773 hdsi->Instance->VMCR &= ~DSI_VMCR_LPVSAE;
<> 144:ef7eb2e8f9f7 774 hdsi->Instance->VMCR |= VidCfg->LPVerticalSyncActiveEnable;
<> 144:ef7eb2e8f9f7 775
<> 144:ef7eb2e8f9f7 776 /* Enable the request for an acknowledge response at the end of a frame */
<> 144:ef7eb2e8f9f7 777 hdsi->Instance->VMCR &= ~DSI_VMCR_FBTAAE;
<> 144:ef7eb2e8f9f7 778 hdsi->Instance->VMCR |= VidCfg->FrameBTAAcknowledgeEnable;
<> 144:ef7eb2e8f9f7 779
<> 144:ef7eb2e8f9f7 780 /* Process unlocked */
<> 144:ef7eb2e8f9f7 781 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 782
<> 144:ef7eb2e8f9f7 783 return HAL_OK;
<> 144:ef7eb2e8f9f7 784 }
<> 144:ef7eb2e8f9f7 785
<> 144:ef7eb2e8f9f7 786 /**
<> 144:ef7eb2e8f9f7 787 * @brief Select adapted command mode and configure the corresponding parameters
<> 144:ef7eb2e8f9f7 788 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 789 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 790 * @param CmdCfg: pointer to a DSI_CmdCfgTypeDef structure that contains
<> 144:ef7eb2e8f9f7 791 * the DSI command mode configuration parameters
<> 144:ef7eb2e8f9f7 792 * @retval HAL status
<> 144:ef7eb2e8f9f7 793 */
<> 144:ef7eb2e8f9f7 794 HAL_StatusTypeDef HAL_DSI_ConfigAdaptedCommandMode(DSI_HandleTypeDef *hdsi, DSI_CmdCfgTypeDef *CmdCfg)
<> 144:ef7eb2e8f9f7 795 {
<> 144:ef7eb2e8f9f7 796 /* Process locked */
<> 144:ef7eb2e8f9f7 797 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 798
<> 144:ef7eb2e8f9f7 799 /* Check the parameters */
<> 144:ef7eb2e8f9f7 800 assert_param(IS_DSI_COLOR_CODING(CmdCfg->ColorCoding));
<> 144:ef7eb2e8f9f7 801 assert_param(IS_DSI_TE_SOURCE(CmdCfg->TearingEffectSource));
<> 144:ef7eb2e8f9f7 802 assert_param(IS_DSI_TE_POLARITY(CmdCfg->TearingEffectPolarity));
<> 144:ef7eb2e8f9f7 803 assert_param(IS_DSI_AUTOMATIC_REFRESH(CmdCfg->AutomaticRefresh));
<> 144:ef7eb2e8f9f7 804 assert_param(IS_DSI_VS_POLARITY(CmdCfg->VSyncPol));
<> 144:ef7eb2e8f9f7 805 assert_param(IS_DSI_TE_ACK_REQUEST(CmdCfg->TEAcknowledgeRequest));
<> 144:ef7eb2e8f9f7 806 assert_param(IS_DSI_DE_POLARITY(CmdCfg->DEPolarity));
<> 144:ef7eb2e8f9f7 807 assert_param(IS_DSI_VSYNC_POLARITY(CmdCfg->VSPolarity));
<> 144:ef7eb2e8f9f7 808 assert_param(IS_DSI_HSYNC_POLARITY(CmdCfg->HSPolarity));
<> 144:ef7eb2e8f9f7 809
<> 144:ef7eb2e8f9f7 810 /* Select command mode by setting CMDM and DSIM bits */
<> 144:ef7eb2e8f9f7 811 hdsi->Instance->MCR |= DSI_MCR_CMDM;
<> 144:ef7eb2e8f9f7 812 hdsi->Instance->WCFGR &= ~DSI_WCFGR_DSIM;
<> 144:ef7eb2e8f9f7 813 hdsi->Instance->WCFGR |= DSI_WCFGR_DSIM;
<> 144:ef7eb2e8f9f7 814
<> 144:ef7eb2e8f9f7 815 /* Select the virtual channel for the LTDC interface traffic */
<> 144:ef7eb2e8f9f7 816 hdsi->Instance->LVCIDR &= ~DSI_LVCIDR_VCID;
<> 144:ef7eb2e8f9f7 817 hdsi->Instance->LVCIDR |= CmdCfg->VirtualChannelID;
<> 144:ef7eb2e8f9f7 818
<> 144:ef7eb2e8f9f7 819 /* Configure the polarity of control signals */
<> 144:ef7eb2e8f9f7 820 hdsi->Instance->LPCR &= ~(DSI_LPCR_DEP | DSI_LPCR_VSP | DSI_LPCR_HSP);
<> 144:ef7eb2e8f9f7 821 hdsi->Instance->LPCR |= (CmdCfg->DEPolarity | CmdCfg->VSPolarity | CmdCfg->HSPolarity);
<> 144:ef7eb2e8f9f7 822
<> 144:ef7eb2e8f9f7 823 /* Select the color coding for the host */
<> 144:ef7eb2e8f9f7 824 hdsi->Instance->LCOLCR &= ~DSI_LCOLCR_COLC;
<> 144:ef7eb2e8f9f7 825 hdsi->Instance->LCOLCR |= CmdCfg->ColorCoding;
<> 144:ef7eb2e8f9f7 826
<> 144:ef7eb2e8f9f7 827 /* Select the color coding for the wrapper */
<> 144:ef7eb2e8f9f7 828 hdsi->Instance->WCFGR &= ~DSI_WCFGR_COLMUX;
<> 144:ef7eb2e8f9f7 829 hdsi->Instance->WCFGR |= ((CmdCfg->ColorCoding)<<1);
<> 144:ef7eb2e8f9f7 830
<> 144:ef7eb2e8f9f7 831 /* Configure the maximum allowed size for write memory command */
<> 144:ef7eb2e8f9f7 832 hdsi->Instance->LCCR &= ~DSI_LCCR_CMDSIZE;
<> 144:ef7eb2e8f9f7 833 hdsi->Instance->LCCR |= CmdCfg->CommandSize;
<> 144:ef7eb2e8f9f7 834
<> 144:ef7eb2e8f9f7 835 /* Configure the tearing effect source and polarity and select the refresh mode */
<> 144:ef7eb2e8f9f7 836 hdsi->Instance->WCFGR &= ~(DSI_WCFGR_TESRC | DSI_WCFGR_TEPOL | DSI_WCFGR_AR | DSI_WCFGR_VSPOL);
<> 144:ef7eb2e8f9f7 837 hdsi->Instance->WCFGR |= (CmdCfg->TearingEffectSource | CmdCfg->TearingEffectPolarity | CmdCfg->AutomaticRefresh | CmdCfg->VSyncPol);
<> 144:ef7eb2e8f9f7 838
<> 144:ef7eb2e8f9f7 839 /* Configure the tearing effect acknowledge request */
<> 144:ef7eb2e8f9f7 840 hdsi->Instance->CMCR &= ~DSI_CMCR_TEARE;
<> 144:ef7eb2e8f9f7 841 hdsi->Instance->CMCR |= CmdCfg->TEAcknowledgeRequest;
<> 144:ef7eb2e8f9f7 842
<> 144:ef7eb2e8f9f7 843 /* Enable the Tearing Effect interrupt */
<> 144:ef7eb2e8f9f7 844 __HAL_DSI_ENABLE_IT(hdsi, DSI_IT_TE);
<> 144:ef7eb2e8f9f7 845
<> 144:ef7eb2e8f9f7 846 /* Enable the End of Refresh interrupt */
<> 144:ef7eb2e8f9f7 847 __HAL_DSI_ENABLE_IT(hdsi, DSI_IT_ER);
<> 144:ef7eb2e8f9f7 848
<> 144:ef7eb2e8f9f7 849 /* Process unlocked */
<> 144:ef7eb2e8f9f7 850 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 851
<> 144:ef7eb2e8f9f7 852 return HAL_OK;
<> 144:ef7eb2e8f9f7 853 }
<> 144:ef7eb2e8f9f7 854
<> 144:ef7eb2e8f9f7 855 /**
<> 144:ef7eb2e8f9f7 856 * @brief Configure command transmission mode: High-speed or Low-power
<> 144:ef7eb2e8f9f7 857 * and enable/disable acknowledge request after packet transmission
<> 144:ef7eb2e8f9f7 858 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 859 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 860 * @param LPCmd: pointer to a DSI_LPCmdTypeDef structure that contains
<> 144:ef7eb2e8f9f7 861 * the DSI command transmission mode configuration parameters
<> 144:ef7eb2e8f9f7 862 * @retval HAL status
<> 144:ef7eb2e8f9f7 863 */
<> 144:ef7eb2e8f9f7 864 HAL_StatusTypeDef HAL_DSI_ConfigCommand(DSI_HandleTypeDef *hdsi, DSI_LPCmdTypeDef *LPCmd)
<> 144:ef7eb2e8f9f7 865 {
<> 144:ef7eb2e8f9f7 866 /* Process locked */
<> 144:ef7eb2e8f9f7 867 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 868
<> 144:ef7eb2e8f9f7 869 assert_param(IS_DSI_LP_GSW0P(LPCmd->LPGenShortWriteNoP));
<> 144:ef7eb2e8f9f7 870 assert_param(IS_DSI_LP_GSW1P(LPCmd->LPGenShortWriteOneP));
<> 144:ef7eb2e8f9f7 871 assert_param(IS_DSI_LP_GSW2P(LPCmd->LPGenShortWriteTwoP));
<> 144:ef7eb2e8f9f7 872 assert_param(IS_DSI_LP_GSR0P(LPCmd->LPGenShortReadNoP));
<> 144:ef7eb2e8f9f7 873 assert_param(IS_DSI_LP_GSR1P(LPCmd->LPGenShortReadOneP));
<> 144:ef7eb2e8f9f7 874 assert_param(IS_DSI_LP_GSR2P(LPCmd->LPGenShortReadTwoP));
<> 144:ef7eb2e8f9f7 875 assert_param(IS_DSI_LP_GLW(LPCmd->LPGenLongWrite));
<> 144:ef7eb2e8f9f7 876 assert_param(IS_DSI_LP_DSW0P(LPCmd->LPDcsShortWriteNoP));
<> 144:ef7eb2e8f9f7 877 assert_param(IS_DSI_LP_DSW1P(LPCmd->LPDcsShortWriteOneP));
<> 144:ef7eb2e8f9f7 878 assert_param(IS_DSI_LP_DSR0P(LPCmd->LPDcsShortReadNoP));
<> 144:ef7eb2e8f9f7 879 assert_param(IS_DSI_LP_DLW(LPCmd->LPDcsLongWrite));
<> 144:ef7eb2e8f9f7 880 assert_param(IS_DSI_LP_MRDP(LPCmd->LPMaxReadPacket));
<> 144:ef7eb2e8f9f7 881 assert_param(IS_DSI_ACK_REQUEST(LPCmd->AcknowledgeRequest));
<> 144:ef7eb2e8f9f7 882
<> 144:ef7eb2e8f9f7 883 /* Select High-speed or Low-power for command transmission */
<> 144:ef7eb2e8f9f7 884 hdsi->Instance->CMCR &= ~(DSI_CMCR_GSW0TX |\
<> 144:ef7eb2e8f9f7 885 DSI_CMCR_GSW1TX |\
<> 144:ef7eb2e8f9f7 886 DSI_CMCR_GSW2TX |\
<> 144:ef7eb2e8f9f7 887 DSI_CMCR_GSR0TX |\
<> 144:ef7eb2e8f9f7 888 DSI_CMCR_GSR1TX |\
<> 144:ef7eb2e8f9f7 889 DSI_CMCR_GSR2TX |\
<> 144:ef7eb2e8f9f7 890 DSI_CMCR_GLWTX |\
<> 144:ef7eb2e8f9f7 891 DSI_CMCR_DSW0TX |\
<> 144:ef7eb2e8f9f7 892 DSI_CMCR_DSW1TX |\
<> 144:ef7eb2e8f9f7 893 DSI_CMCR_DSR0TX |\
<> 144:ef7eb2e8f9f7 894 DSI_CMCR_DLWTX |\
<> 144:ef7eb2e8f9f7 895 DSI_CMCR_MRDPS);
<> 144:ef7eb2e8f9f7 896 hdsi->Instance->CMCR |= (LPCmd->LPGenShortWriteNoP |\
<> 144:ef7eb2e8f9f7 897 LPCmd->LPGenShortWriteOneP |\
<> 144:ef7eb2e8f9f7 898 LPCmd->LPGenShortWriteTwoP |\
<> 144:ef7eb2e8f9f7 899 LPCmd->LPGenShortReadNoP |\
<> 144:ef7eb2e8f9f7 900 LPCmd->LPGenShortReadOneP |\
<> 144:ef7eb2e8f9f7 901 LPCmd->LPGenShortReadTwoP |\
<> 144:ef7eb2e8f9f7 902 LPCmd->LPGenLongWrite |\
<> 144:ef7eb2e8f9f7 903 LPCmd->LPDcsShortWriteNoP |\
<> 144:ef7eb2e8f9f7 904 LPCmd->LPDcsShortWriteOneP |\
<> 144:ef7eb2e8f9f7 905 LPCmd->LPDcsShortReadNoP |\
<> 144:ef7eb2e8f9f7 906 LPCmd->LPDcsLongWrite |\
<> 144:ef7eb2e8f9f7 907 LPCmd->LPMaxReadPacket);
<> 144:ef7eb2e8f9f7 908
<> 144:ef7eb2e8f9f7 909 /* Configure the acknowledge request after each packet transmission */
<> 144:ef7eb2e8f9f7 910 hdsi->Instance->CMCR &= ~DSI_CMCR_ARE;
<> 144:ef7eb2e8f9f7 911 hdsi->Instance->CMCR |= LPCmd->AcknowledgeRequest;
<> 144:ef7eb2e8f9f7 912
<> 144:ef7eb2e8f9f7 913 /* Process unlocked */
<> 144:ef7eb2e8f9f7 914 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 915
<> 144:ef7eb2e8f9f7 916 return HAL_OK;
<> 144:ef7eb2e8f9f7 917 }
<> 144:ef7eb2e8f9f7 918
<> 144:ef7eb2e8f9f7 919 /**
<> 144:ef7eb2e8f9f7 920 * @brief Configure the flow control parameters
<> 144:ef7eb2e8f9f7 921 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 922 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 923 * @param FlowControl: flow control feature(s) to be enabled.
<> 144:ef7eb2e8f9f7 924 * This parameter can be any combination of @ref DSI_FlowControl.
<> 144:ef7eb2e8f9f7 925 * @retval HAL status
<> 144:ef7eb2e8f9f7 926 */
<> 144:ef7eb2e8f9f7 927 HAL_StatusTypeDef HAL_DSI_ConfigFlowControl(DSI_HandleTypeDef *hdsi, uint32_t FlowControl)
<> 144:ef7eb2e8f9f7 928 {
<> 144:ef7eb2e8f9f7 929 /* Process locked */
<> 144:ef7eb2e8f9f7 930 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 931
<> 144:ef7eb2e8f9f7 932 /* Check the parameters */
<> 144:ef7eb2e8f9f7 933 assert_param(IS_DSI_FLOW_CONTROL(FlowControl));
<> 144:ef7eb2e8f9f7 934
<> 144:ef7eb2e8f9f7 935 /* Set the DSI Host Protocol Configuration Register */
<> 144:ef7eb2e8f9f7 936 hdsi->Instance->PCR &= ~DSI_FLOW_CONTROL_ALL;
<> 144:ef7eb2e8f9f7 937 hdsi->Instance->PCR |= FlowControl;
<> 144:ef7eb2e8f9f7 938
<> 144:ef7eb2e8f9f7 939 /* Process unlocked */
<> 144:ef7eb2e8f9f7 940 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 941
<> 144:ef7eb2e8f9f7 942 return HAL_OK;
<> 144:ef7eb2e8f9f7 943 }
<> 144:ef7eb2e8f9f7 944
<> 144:ef7eb2e8f9f7 945 /**
<> 144:ef7eb2e8f9f7 946 * @brief Configure the DSI PHY timer parameters
<> 144:ef7eb2e8f9f7 947 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 948 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 949 * @param PhyTimers: DSI_PHY_TimerTypeDef structure that contains
<> 144:ef7eb2e8f9f7 950 * the DSI PHY timing parameters
<> 144:ef7eb2e8f9f7 951 * @retval HAL status
<> 144:ef7eb2e8f9f7 952 */
<> 144:ef7eb2e8f9f7 953 HAL_StatusTypeDef HAL_DSI_ConfigPhyTimer(DSI_HandleTypeDef *hdsi, DSI_PHY_TimerTypeDef *PhyTimers)
<> 144:ef7eb2e8f9f7 954 {
<> 144:ef7eb2e8f9f7 955 uint32_t maxTime;
<> 144:ef7eb2e8f9f7 956 /* Process locked */
<> 144:ef7eb2e8f9f7 957 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 958
<> 144:ef7eb2e8f9f7 959 maxTime = (PhyTimers->ClockLaneLP2HSTime > PhyTimers->ClockLaneHS2LPTime)? PhyTimers->ClockLaneLP2HSTime: PhyTimers->ClockLaneHS2LPTime;
<> 144:ef7eb2e8f9f7 960
<> 144:ef7eb2e8f9f7 961 /* Clock lane timer configuration */
<> 144:ef7eb2e8f9f7 962
<> 144:ef7eb2e8f9f7 963 /* In Automatic Clock Lane control mode, the DSI Host can turn off the clock lane between two
<> 144:ef7eb2e8f9f7 964 High-Speed transmission.
<> 144:ef7eb2e8f9f7 965 To do so, the DSI Host calculates the time required for the clock lane to change from HighSpeed
<> 144:ef7eb2e8f9f7 966 to Low-Power and from Low-Power to High-Speed.
<> 144:ef7eb2e8f9f7 967 This timings are configured by the HS2LP_TIME and LP2HS_TIME in the DSI Host Clock Lane Timer Configuration Register (DSI_CLTCR).
<> 144:ef7eb2e8f9f7 968 But the DSI Host is not calculating LP2HS_TIME + HS2LP_TIME but 2 x HS2LP_TIME.
<> 144:ef7eb2e8f9f7 969
<> 144:ef7eb2e8f9f7 970 Workaround : Configure HS2LP_TIME and LP2HS_TIME with the same value being the max of HS2LP_TIME or LP2HS_TIME.
<> 144:ef7eb2e8f9f7 971 */
<> 144:ef7eb2e8f9f7 972 hdsi->Instance->CLTCR &= ~(DSI_CLTCR_LP2HS_TIME | DSI_CLTCR_HS2LP_TIME);
<> 144:ef7eb2e8f9f7 973 hdsi->Instance->CLTCR |= (maxTime | ((maxTime)<<16));
<> 144:ef7eb2e8f9f7 974
<> 144:ef7eb2e8f9f7 975 /* Data lane timer configuration */
<> 144:ef7eb2e8f9f7 976 hdsi->Instance->DLTCR &= ~(DSI_DLTCR_MRD_TIME | DSI_DLTCR_LP2HS_TIME | DSI_DLTCR_HS2LP_TIME);
<> 144:ef7eb2e8f9f7 977 hdsi->Instance->DLTCR |= (PhyTimers->DataLaneMaxReadTime | ((PhyTimers->DataLaneLP2HSTime)<<16) | ((PhyTimers->DataLaneHS2LPTime)<<24));
<> 144:ef7eb2e8f9f7 978
<> 144:ef7eb2e8f9f7 979 /* Configure the wait period to request HS transmission after a stop state */
<> 144:ef7eb2e8f9f7 980 hdsi->Instance->PCONFR &= ~DSI_PCONFR_SW_TIME;
<> 144:ef7eb2e8f9f7 981 hdsi->Instance->PCONFR |= ((PhyTimers->StopWaitTime)<<8);
<> 144:ef7eb2e8f9f7 982
<> 144:ef7eb2e8f9f7 983 /* Process unlocked */
<> 144:ef7eb2e8f9f7 984 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 985
<> 144:ef7eb2e8f9f7 986 return HAL_OK;
<> 144:ef7eb2e8f9f7 987 }
<> 144:ef7eb2e8f9f7 988
<> 144:ef7eb2e8f9f7 989 /**
<> 144:ef7eb2e8f9f7 990 * @brief Configure the DSI HOST timeout parameters
<> 144:ef7eb2e8f9f7 991 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 992 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 993 * @param HostTimeouts: DSI_HOST_TimeoutTypeDef structure that contains
<> 144:ef7eb2e8f9f7 994 * the DSI host timeout parameters
<> 144:ef7eb2e8f9f7 995 * @retval HAL status
<> 144:ef7eb2e8f9f7 996 */
<> 144:ef7eb2e8f9f7 997 HAL_StatusTypeDef HAL_DSI_ConfigHostTimeouts(DSI_HandleTypeDef *hdsi, DSI_HOST_TimeoutTypeDef *HostTimeouts)
<> 144:ef7eb2e8f9f7 998 {
<> 144:ef7eb2e8f9f7 999 /* Process locked */
<> 144:ef7eb2e8f9f7 1000 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1001
<> 144:ef7eb2e8f9f7 1002 /* Set the timeout clock division factor */
<> 144:ef7eb2e8f9f7 1003 hdsi->Instance->CCR &= ~DSI_CCR_TOCKDIV;
<> 157:ff67d9f36b67 1004 hdsi->Instance->CCR |= ((HostTimeouts->TimeoutCkdiv)<<8);
<> 144:ef7eb2e8f9f7 1005
<> 144:ef7eb2e8f9f7 1006 /* High-speed transmission timeout */
<> 144:ef7eb2e8f9f7 1007 hdsi->Instance->TCCR[0] &= ~DSI_TCCR0_HSTX_TOCNT;
<> 144:ef7eb2e8f9f7 1008 hdsi->Instance->TCCR[0] |= ((HostTimeouts->HighSpeedTransmissionTimeout)<<16);
<> 144:ef7eb2e8f9f7 1009
<> 144:ef7eb2e8f9f7 1010 /* Low-power reception timeout */
<> 144:ef7eb2e8f9f7 1011 hdsi->Instance->TCCR[0] &= ~DSI_TCCR0_LPRX_TOCNT;
<> 144:ef7eb2e8f9f7 1012 hdsi->Instance->TCCR[0] |= HostTimeouts->LowPowerReceptionTimeout;
<> 144:ef7eb2e8f9f7 1013
<> 144:ef7eb2e8f9f7 1014 /* High-speed read timeout */
<> 144:ef7eb2e8f9f7 1015 hdsi->Instance->TCCR[1] &= ~DSI_TCCR1_HSRD_TOCNT;
<> 144:ef7eb2e8f9f7 1016 hdsi->Instance->TCCR[1] |= HostTimeouts->HighSpeedReadTimeout;
<> 144:ef7eb2e8f9f7 1017
<> 144:ef7eb2e8f9f7 1018 /* Low-power read timeout */
<> 144:ef7eb2e8f9f7 1019 hdsi->Instance->TCCR[2] &= ~DSI_TCCR2_LPRD_TOCNT;
<> 144:ef7eb2e8f9f7 1020 hdsi->Instance->TCCR[2] |= HostTimeouts->LowPowerReadTimeout;
<> 144:ef7eb2e8f9f7 1021
<> 144:ef7eb2e8f9f7 1022 /* High-speed write timeout */
<> 144:ef7eb2e8f9f7 1023 hdsi->Instance->TCCR[3] &= ~DSI_TCCR3_HSWR_TOCNT;
<> 144:ef7eb2e8f9f7 1024 hdsi->Instance->TCCR[3] |= HostTimeouts->HighSpeedWriteTimeout;
<> 144:ef7eb2e8f9f7 1025
<> 144:ef7eb2e8f9f7 1026 /* High-speed write presp mode */
<> 144:ef7eb2e8f9f7 1027 hdsi->Instance->TCCR[3] &= ~DSI_TCCR3_PM;
<> 144:ef7eb2e8f9f7 1028 hdsi->Instance->TCCR[3] |= HostTimeouts->HighSpeedWritePrespMode;
<> 144:ef7eb2e8f9f7 1029
<> 144:ef7eb2e8f9f7 1030 /* Low-speed write timeout */
<> 144:ef7eb2e8f9f7 1031 hdsi->Instance->TCCR[4] &= ~DSI_TCCR4_LPWR_TOCNT;
<> 144:ef7eb2e8f9f7 1032 hdsi->Instance->TCCR[4] |= HostTimeouts->LowPowerWriteTimeout;
<> 144:ef7eb2e8f9f7 1033
<> 144:ef7eb2e8f9f7 1034 /* BTA timeout */
<> 144:ef7eb2e8f9f7 1035 hdsi->Instance->TCCR[5] &= ~DSI_TCCR5_BTA_TOCNT;
<> 144:ef7eb2e8f9f7 1036 hdsi->Instance->TCCR[5] |= HostTimeouts->BTATimeout;
<> 144:ef7eb2e8f9f7 1037
<> 144:ef7eb2e8f9f7 1038 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1039 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1040
<> 144:ef7eb2e8f9f7 1041 return HAL_OK;
<> 144:ef7eb2e8f9f7 1042 }
<> 144:ef7eb2e8f9f7 1043
<> 144:ef7eb2e8f9f7 1044 /**
<> 144:ef7eb2e8f9f7 1045 * @brief Start the DSI module
<> 144:ef7eb2e8f9f7 1046 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1047 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1048 * @retval HAL status
<> 144:ef7eb2e8f9f7 1049 */
<> 144:ef7eb2e8f9f7 1050 HAL_StatusTypeDef HAL_DSI_Start(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1051 {
<> 144:ef7eb2e8f9f7 1052 /* Process locked */
<> 144:ef7eb2e8f9f7 1053 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1054
<> 144:ef7eb2e8f9f7 1055 /* Enable the DSI host */
<> 144:ef7eb2e8f9f7 1056 __HAL_DSI_ENABLE(hdsi);
<> 144:ef7eb2e8f9f7 1057
<> 144:ef7eb2e8f9f7 1058 /* Enable the DSI wrapper */
<> 144:ef7eb2e8f9f7 1059 __HAL_DSI_WRAPPER_ENABLE(hdsi);
<> 144:ef7eb2e8f9f7 1060
<> 144:ef7eb2e8f9f7 1061 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1062 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1063
<> 144:ef7eb2e8f9f7 1064 return HAL_OK;
<> 144:ef7eb2e8f9f7 1065 }
<> 144:ef7eb2e8f9f7 1066
<> 144:ef7eb2e8f9f7 1067 /**
<> 144:ef7eb2e8f9f7 1068 * @brief Stop the DSI module
<> 144:ef7eb2e8f9f7 1069 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1070 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1071 * @retval HAL status
<> 144:ef7eb2e8f9f7 1072 */
<> 144:ef7eb2e8f9f7 1073 HAL_StatusTypeDef HAL_DSI_Stop(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1074 {
<> 144:ef7eb2e8f9f7 1075 /* Process locked */
<> 144:ef7eb2e8f9f7 1076 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1077
<> 144:ef7eb2e8f9f7 1078 /* Disable the DSI host */
<> 144:ef7eb2e8f9f7 1079 __HAL_DSI_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 1080
<> 144:ef7eb2e8f9f7 1081 /* Disable the DSI wrapper */
<> 144:ef7eb2e8f9f7 1082 __HAL_DSI_WRAPPER_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 1083
<> 144:ef7eb2e8f9f7 1084 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1085 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1086
<> 144:ef7eb2e8f9f7 1087 return HAL_OK;
<> 144:ef7eb2e8f9f7 1088 }
<> 144:ef7eb2e8f9f7 1089
<> 144:ef7eb2e8f9f7 1090 /**
<> 144:ef7eb2e8f9f7 1091 * @brief Refresh the display in command mode
<> 144:ef7eb2e8f9f7 1092 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1093 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1094 * @retval HAL status
<> 144:ef7eb2e8f9f7 1095 */
<> 144:ef7eb2e8f9f7 1096 HAL_StatusTypeDef HAL_DSI_Refresh(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1097 {
<> 144:ef7eb2e8f9f7 1098 /* Process locked */
<> 144:ef7eb2e8f9f7 1099 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1100
<> 144:ef7eb2e8f9f7 1101 /* Update the display */
<> 144:ef7eb2e8f9f7 1102 hdsi->Instance->WCR |= DSI_WCR_LTDCEN;
<> 144:ef7eb2e8f9f7 1103
<> 144:ef7eb2e8f9f7 1104 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1105 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1106
<> 144:ef7eb2e8f9f7 1107 return HAL_OK;
<> 144:ef7eb2e8f9f7 1108 }
<> 144:ef7eb2e8f9f7 1109
<> 144:ef7eb2e8f9f7 1110 /**
<> 144:ef7eb2e8f9f7 1111 * @brief Controls the display color mode in Video mode
<> 144:ef7eb2e8f9f7 1112 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1113 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1114 * @param ColorMode: Color mode (full or 8-colors).
<> 144:ef7eb2e8f9f7 1115 * This parameter can be any value of @ref DSI_Color_Mode
<> 144:ef7eb2e8f9f7 1116 * @retval HAL status
<> 144:ef7eb2e8f9f7 1117 */
<> 144:ef7eb2e8f9f7 1118 HAL_StatusTypeDef HAL_DSI_ColorMode(DSI_HandleTypeDef *hdsi, uint32_t ColorMode)
<> 144:ef7eb2e8f9f7 1119 {
<> 144:ef7eb2e8f9f7 1120 /* Process locked */
<> 144:ef7eb2e8f9f7 1121 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1122
<> 144:ef7eb2e8f9f7 1123 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1124 assert_param(IS_DSI_COLOR_MODE(ColorMode));
<> 144:ef7eb2e8f9f7 1125
<> 144:ef7eb2e8f9f7 1126 /* Update the display color mode */
<> 144:ef7eb2e8f9f7 1127 hdsi->Instance->WCR &= ~DSI_WCR_COLM;
<> 144:ef7eb2e8f9f7 1128 hdsi->Instance->WCR |= ColorMode;
<> 144:ef7eb2e8f9f7 1129
<> 144:ef7eb2e8f9f7 1130 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1131 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1132
<> 144:ef7eb2e8f9f7 1133 return HAL_OK;
<> 144:ef7eb2e8f9f7 1134 }
<> 144:ef7eb2e8f9f7 1135
<> 144:ef7eb2e8f9f7 1136 /**
<> 144:ef7eb2e8f9f7 1137 * @brief Control the display shutdown in Video mode
<> 144:ef7eb2e8f9f7 1138 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1139 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1140 * @param Shutdown: Shut-down (Display-ON or Display-OFF).
<> 144:ef7eb2e8f9f7 1141 * This parameter can be any value of @ref DSI_ShutDown
<> 144:ef7eb2e8f9f7 1142 * @retval HAL status
<> 144:ef7eb2e8f9f7 1143 */
<> 144:ef7eb2e8f9f7 1144 HAL_StatusTypeDef HAL_DSI_Shutdown(DSI_HandleTypeDef *hdsi, uint32_t Shutdown)
<> 144:ef7eb2e8f9f7 1145 {
<> 144:ef7eb2e8f9f7 1146 /* Process locked */
<> 144:ef7eb2e8f9f7 1147 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1148
<> 144:ef7eb2e8f9f7 1149 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1150 assert_param(IS_DSI_SHUT_DOWN(Shutdown));
<> 144:ef7eb2e8f9f7 1151
<> 144:ef7eb2e8f9f7 1152 /* Update the display Shutdown */
<> 144:ef7eb2e8f9f7 1153 hdsi->Instance->WCR &= ~DSI_WCR_SHTDN;
<> 144:ef7eb2e8f9f7 1154 hdsi->Instance->WCR |= Shutdown;
<> 144:ef7eb2e8f9f7 1155
<> 144:ef7eb2e8f9f7 1156 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1157 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1158
<> 144:ef7eb2e8f9f7 1159 return HAL_OK;
<> 144:ef7eb2e8f9f7 1160 }
<> 144:ef7eb2e8f9f7 1161
<> 144:ef7eb2e8f9f7 1162 /**
<> 144:ef7eb2e8f9f7 1163 * @brief DCS or Generic short write command
<> 144:ef7eb2e8f9f7 1164 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1165 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1166 * @param ChannelID: Virtual channel ID.
<> 144:ef7eb2e8f9f7 1167 * @param Mode: DSI short packet data type.
<> 144:ef7eb2e8f9f7 1168 * This parameter can be any value of @ref DSI_SHORT_WRITE_PKT_Data_Type.
<> 144:ef7eb2e8f9f7 1169 * @param Param1: DSC command or first generic parameter.
<> 144:ef7eb2e8f9f7 1170 * This parameter can be any value of @ref DSI_DCS_Command or a
<> 144:ef7eb2e8f9f7 1171 * generic command code.
<> 144:ef7eb2e8f9f7 1172 * @param Param2: DSC parameter or second generic parameter.
<> 144:ef7eb2e8f9f7 1173 * @retval HAL status
<> 144:ef7eb2e8f9f7 1174 */
<> 144:ef7eb2e8f9f7 1175 HAL_StatusTypeDef HAL_DSI_ShortWrite(DSI_HandleTypeDef *hdsi,
<> 144:ef7eb2e8f9f7 1176 uint32_t ChannelID,
<> 144:ef7eb2e8f9f7 1177 uint32_t Mode,
<> 144:ef7eb2e8f9f7 1178 uint32_t Param1,
<> 144:ef7eb2e8f9f7 1179 uint32_t Param2)
<> 144:ef7eb2e8f9f7 1180 {
<> 144:ef7eb2e8f9f7 1181 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1182
<> 144:ef7eb2e8f9f7 1183 /* Process locked */
<> 144:ef7eb2e8f9f7 1184 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1185
<> 144:ef7eb2e8f9f7 1186 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1187 assert_param(IS_DSI_SHORT_WRITE_PACKET_TYPE(Mode));
<> 144:ef7eb2e8f9f7 1188
<> 144:ef7eb2e8f9f7 1189 /* Get tick */
<> 144:ef7eb2e8f9f7 1190 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1191
<> 144:ef7eb2e8f9f7 1192 /* Wait for Command FIFO Empty */
<> 144:ef7eb2e8f9f7 1193 while((hdsi->Instance->GPSR & DSI_GPSR_CMDFE) == 0)
<> 144:ef7eb2e8f9f7 1194 {
<> 144:ef7eb2e8f9f7 1195 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1196 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1197 {
<> 144:ef7eb2e8f9f7 1198 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1199 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1200
<> 144:ef7eb2e8f9f7 1201 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1202 }
<> 144:ef7eb2e8f9f7 1203 }
<> 144:ef7eb2e8f9f7 1204
<> 144:ef7eb2e8f9f7 1205 /* Configure the packet to send a short DCS command with 0 or 1 parameter */
<> 144:ef7eb2e8f9f7 1206 DSI_ConfigPacketHeader(hdsi->Instance,
<> 144:ef7eb2e8f9f7 1207 ChannelID,
<> 144:ef7eb2e8f9f7 1208 Mode,
<> 144:ef7eb2e8f9f7 1209 Param1,
<> 144:ef7eb2e8f9f7 1210 Param2);
<> 144:ef7eb2e8f9f7 1211
<> 144:ef7eb2e8f9f7 1212 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1213 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1214
<> 144:ef7eb2e8f9f7 1215 return HAL_OK;
<> 144:ef7eb2e8f9f7 1216 }
<> 144:ef7eb2e8f9f7 1217
<> 144:ef7eb2e8f9f7 1218 /**
<> 144:ef7eb2e8f9f7 1219 * @brief DCS or Generic long write command
<> 144:ef7eb2e8f9f7 1220 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1221 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1222 * @param ChannelID: Virtual channel ID.
<> 144:ef7eb2e8f9f7 1223 * @param Mode: DSI long packet data type.
<> 144:ef7eb2e8f9f7 1224 * This parameter can be any value of @ref DSI_LONG_WRITE_PKT_Data_Type.
<> 144:ef7eb2e8f9f7 1225 * @param NbParams: Number of parameters.
<> 144:ef7eb2e8f9f7 1226 * @param Param1: DSC command or first generic parameter.
<> 144:ef7eb2e8f9f7 1227 * This parameter can be any value of @ref DSI_DCS_Command or a
<> 144:ef7eb2e8f9f7 1228 * generic command code
<> 144:ef7eb2e8f9f7 1229 * @param ParametersTable: Pointer to parameter values table.
<> 144:ef7eb2e8f9f7 1230 * @retval HAL status
<> 144:ef7eb2e8f9f7 1231 */
<> 144:ef7eb2e8f9f7 1232 HAL_StatusTypeDef HAL_DSI_LongWrite(DSI_HandleTypeDef *hdsi,
<> 144:ef7eb2e8f9f7 1233 uint32_t ChannelID,
<> 144:ef7eb2e8f9f7 1234 uint32_t Mode,
<> 144:ef7eb2e8f9f7 1235 uint32_t NbParams,
<> 144:ef7eb2e8f9f7 1236 uint32_t Param1,
<> 144:ef7eb2e8f9f7 1237 uint8_t* ParametersTable)
<> 144:ef7eb2e8f9f7 1238 {
<> 144:ef7eb2e8f9f7 1239 uint32_t uicounter = 0;
<> 144:ef7eb2e8f9f7 1240 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1241
<> 144:ef7eb2e8f9f7 1242 /* Process locked */
<> 144:ef7eb2e8f9f7 1243 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1244
<> 144:ef7eb2e8f9f7 1245 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1246 assert_param(IS_DSI_LONG_WRITE_PACKET_TYPE(Mode));
<> 144:ef7eb2e8f9f7 1247
<> 144:ef7eb2e8f9f7 1248 /* Get tick */
<> 144:ef7eb2e8f9f7 1249 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1250
<> 144:ef7eb2e8f9f7 1251 /* Wait for Command FIFO Empty */
<> 144:ef7eb2e8f9f7 1252 while((hdsi->Instance->GPSR & DSI_GPSR_CMDFE) == RESET)
<> 144:ef7eb2e8f9f7 1253 {
<> 144:ef7eb2e8f9f7 1254 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1255 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1256 {
<> 144:ef7eb2e8f9f7 1257 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1258 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1259
<> 144:ef7eb2e8f9f7 1260 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1261 }
<> 144:ef7eb2e8f9f7 1262 }
<> 144:ef7eb2e8f9f7 1263
<> 144:ef7eb2e8f9f7 1264 /* Set the DCS code hexadecimal on payload byte 1, and the other parameters on the write FIFO command*/
<> 144:ef7eb2e8f9f7 1265 while(uicounter < NbParams)
<> 144:ef7eb2e8f9f7 1266 {
<> 144:ef7eb2e8f9f7 1267 if(uicounter == 0x00)
<> 144:ef7eb2e8f9f7 1268 {
<> 144:ef7eb2e8f9f7 1269 hdsi->Instance->GPDR=(Param1 | \
<> 144:ef7eb2e8f9f7 1270 ((uint32_t)(*(ParametersTable + uicounter)) << 8) | \
<> 144:ef7eb2e8f9f7 1271 ((uint32_t)(*(ParametersTable + uicounter+1))<<16) | \
<> 144:ef7eb2e8f9f7 1272 ((uint32_t)(*(ParametersTable + uicounter+2))<<24));
<> 144:ef7eb2e8f9f7 1273 uicounter += 3;
<> 144:ef7eb2e8f9f7 1274 }
<> 144:ef7eb2e8f9f7 1275 else
<> 144:ef7eb2e8f9f7 1276 {
<> 144:ef7eb2e8f9f7 1277 hdsi->Instance->GPDR=((uint32_t)(*(ParametersTable + uicounter)) | \
<> 144:ef7eb2e8f9f7 1278 ((uint32_t)(*(ParametersTable + uicounter+1)) << 8) | \
<> 144:ef7eb2e8f9f7 1279 ((uint32_t)(*(ParametersTable + uicounter+2)) << 16) | \
<> 144:ef7eb2e8f9f7 1280 ((uint32_t)(*(ParametersTable + uicounter+3)) << 24));
<> 144:ef7eb2e8f9f7 1281 uicounter+=4;
<> 144:ef7eb2e8f9f7 1282 }
<> 144:ef7eb2e8f9f7 1283 }
<> 144:ef7eb2e8f9f7 1284
<> 144:ef7eb2e8f9f7 1285 /* Configure the packet to send a long DCS command */
<> 144:ef7eb2e8f9f7 1286 DSI_ConfigPacketHeader(hdsi->Instance,
<> 144:ef7eb2e8f9f7 1287 ChannelID,
<> 144:ef7eb2e8f9f7 1288 Mode,
<> 144:ef7eb2e8f9f7 1289 ((NbParams+1)&0x00FF),
<> 144:ef7eb2e8f9f7 1290 (((NbParams+1)&0xFF00)>>8));
<> 144:ef7eb2e8f9f7 1291
<> 144:ef7eb2e8f9f7 1292 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1293 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1294
<> 144:ef7eb2e8f9f7 1295 return HAL_OK;
<> 144:ef7eb2e8f9f7 1296 }
<> 144:ef7eb2e8f9f7 1297
<> 144:ef7eb2e8f9f7 1298 /**
<> 144:ef7eb2e8f9f7 1299 * @brief Read command (DCS or generic)
<> 144:ef7eb2e8f9f7 1300 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1301 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1302 * @param ChannelNbr: Virtual channel ID
<> 144:ef7eb2e8f9f7 1303 * @param Array: pointer to a buffer to store the payload of a read back operation.
<> 144:ef7eb2e8f9f7 1304 * @param Size: Data size to be read (in byte).
<> 144:ef7eb2e8f9f7 1305 * @param Mode: DSI read packet data type.
<> 144:ef7eb2e8f9f7 1306 * This parameter can be any value of @ref DSI_SHORT_READ_PKT_Data_Type.
<> 144:ef7eb2e8f9f7 1307 * @param DCSCmd: DCS get/read command.
<> 144:ef7eb2e8f9f7 1308 * @param ParametersTable: Pointer to parameter values table.
<> 144:ef7eb2e8f9f7 1309 * @retval HAL status
<> 144:ef7eb2e8f9f7 1310 */
<> 144:ef7eb2e8f9f7 1311 HAL_StatusTypeDef HAL_DSI_Read(DSI_HandleTypeDef *hdsi,
<> 144:ef7eb2e8f9f7 1312 uint32_t ChannelNbr,
<> 144:ef7eb2e8f9f7 1313 uint8_t* Array,
<> 144:ef7eb2e8f9f7 1314 uint32_t Size,
<> 144:ef7eb2e8f9f7 1315 uint32_t Mode,
<> 144:ef7eb2e8f9f7 1316 uint32_t DCSCmd,
<> 144:ef7eb2e8f9f7 1317 uint8_t* ParametersTable)
<> 144:ef7eb2e8f9f7 1318 {
<> 144:ef7eb2e8f9f7 1319 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1320
<> 144:ef7eb2e8f9f7 1321 /* Process locked */
<> 144:ef7eb2e8f9f7 1322 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1323
<> 144:ef7eb2e8f9f7 1324 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1325 assert_param(IS_DSI_READ_PACKET_TYPE(Mode));
<> 144:ef7eb2e8f9f7 1326
<> 144:ef7eb2e8f9f7 1327 if(Size > 2)
<> 144:ef7eb2e8f9f7 1328 {
<> 144:ef7eb2e8f9f7 1329 /* set max return packet size */
<> 144:ef7eb2e8f9f7 1330 HAL_DSI_ShortWrite(hdsi, ChannelNbr, DSI_MAX_RETURN_PKT_SIZE, ((Size)&0xFF), (((Size)>>8)&0xFF));
<> 144:ef7eb2e8f9f7 1331 }
<> 144:ef7eb2e8f9f7 1332
<> 144:ef7eb2e8f9f7 1333 /* Configure the packet to read command */
<> 144:ef7eb2e8f9f7 1334 if (Mode == DSI_DCS_SHORT_PKT_READ)
<> 144:ef7eb2e8f9f7 1335 {
<> 144:ef7eb2e8f9f7 1336 DSI_ConfigPacketHeader(hdsi->Instance, ChannelNbr, Mode, DCSCmd, 0);
<> 144:ef7eb2e8f9f7 1337 }
<> 144:ef7eb2e8f9f7 1338 else if (Mode == DSI_GEN_SHORT_PKT_READ_P0)
<> 144:ef7eb2e8f9f7 1339 {
<> 144:ef7eb2e8f9f7 1340 DSI_ConfigPacketHeader(hdsi->Instance, ChannelNbr, Mode, 0, 0);
<> 144:ef7eb2e8f9f7 1341 }
<> 144:ef7eb2e8f9f7 1342 else if (Mode == DSI_GEN_SHORT_PKT_READ_P1)
<> 144:ef7eb2e8f9f7 1343 {
<> 144:ef7eb2e8f9f7 1344 DSI_ConfigPacketHeader(hdsi->Instance, ChannelNbr, Mode, ParametersTable[0], 0);
<> 144:ef7eb2e8f9f7 1345 }
<> 144:ef7eb2e8f9f7 1346 else if (Mode == DSI_GEN_SHORT_PKT_READ_P2)
<> 144:ef7eb2e8f9f7 1347 {
<> 144:ef7eb2e8f9f7 1348 DSI_ConfigPacketHeader(hdsi->Instance, ChannelNbr, Mode, ParametersTable[0], ParametersTable[1]);
<> 144:ef7eb2e8f9f7 1349 }
<> 144:ef7eb2e8f9f7 1350 else
<> 144:ef7eb2e8f9f7 1351 {
<> 144:ef7eb2e8f9f7 1352 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1353 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1354
<> 144:ef7eb2e8f9f7 1355 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1356 }
<> 144:ef7eb2e8f9f7 1357
<> 144:ef7eb2e8f9f7 1358 /* Get tick */
<> 144:ef7eb2e8f9f7 1359 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1360
<> 144:ef7eb2e8f9f7 1361 /* Check that the payload read FIFO is not empty */
<> 144:ef7eb2e8f9f7 1362 while((hdsi->Instance->GPSR & DSI_GPSR_PRDFE) == DSI_GPSR_PRDFE)
<> 144:ef7eb2e8f9f7 1363 {
<> 144:ef7eb2e8f9f7 1364 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1365 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1366 {
<> 144:ef7eb2e8f9f7 1367 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1368 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1369
<> 144:ef7eb2e8f9f7 1370 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1371 }
<> 144:ef7eb2e8f9f7 1372 }
<> 144:ef7eb2e8f9f7 1373
<> 144:ef7eb2e8f9f7 1374 /* Get the first byte */
<> 144:ef7eb2e8f9f7 1375 *((uint32_t *)Array) = (hdsi->Instance->GPDR);
<> 144:ef7eb2e8f9f7 1376 if (Size > 4)
<> 144:ef7eb2e8f9f7 1377 {
<> 144:ef7eb2e8f9f7 1378 Size -= 4;
<> 144:ef7eb2e8f9f7 1379 Array += 4;
<> 144:ef7eb2e8f9f7 1380 }
<> 144:ef7eb2e8f9f7 1381 else
<> 144:ef7eb2e8f9f7 1382 {
<> 144:ef7eb2e8f9f7 1383 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1384 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1385
<> 144:ef7eb2e8f9f7 1386 return HAL_OK;
<> 144:ef7eb2e8f9f7 1387 }
<> 144:ef7eb2e8f9f7 1388
<> 144:ef7eb2e8f9f7 1389 /* Get tick */
<> 144:ef7eb2e8f9f7 1390 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1391
<> 144:ef7eb2e8f9f7 1392 /* Get the remaining bytes if any */
<> 144:ef7eb2e8f9f7 1393 while(((int)(Size)) > 0)
<> 144:ef7eb2e8f9f7 1394 {
<> 144:ef7eb2e8f9f7 1395 if((hdsi->Instance->GPSR & DSI_GPSR_PRDFE) == 0)
<> 144:ef7eb2e8f9f7 1396 {
<> 144:ef7eb2e8f9f7 1397 *((uint32_t *)Array) = (hdsi->Instance->GPDR);
<> 144:ef7eb2e8f9f7 1398 Size -= 4;
<> 144:ef7eb2e8f9f7 1399 Array += 4;
<> 144:ef7eb2e8f9f7 1400 }
<> 144:ef7eb2e8f9f7 1401
<> 144:ef7eb2e8f9f7 1402 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1403 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1404 {
<> 144:ef7eb2e8f9f7 1405 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1406 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1407
<> 144:ef7eb2e8f9f7 1408 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1409 }
<> 144:ef7eb2e8f9f7 1410 }
<> 144:ef7eb2e8f9f7 1411
<> 144:ef7eb2e8f9f7 1412 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1413 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1414
<> 144:ef7eb2e8f9f7 1415 return HAL_OK;
<> 144:ef7eb2e8f9f7 1416 }
<> 144:ef7eb2e8f9f7 1417
<> 144:ef7eb2e8f9f7 1418 /**
<> 144:ef7eb2e8f9f7 1419 * @brief Enter the ULPM (Ultra Low Power Mode) with the D-PHY PLL running
<> 144:ef7eb2e8f9f7 1420 * (only data lanes are in ULPM)
<> 144:ef7eb2e8f9f7 1421 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1422 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1423 * @retval HAL status
<> 144:ef7eb2e8f9f7 1424 */
<> 144:ef7eb2e8f9f7 1425 HAL_StatusTypeDef HAL_DSI_EnterULPMData(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1426 {
<> 144:ef7eb2e8f9f7 1427 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1428
<> 144:ef7eb2e8f9f7 1429 /* Process locked */
<> 144:ef7eb2e8f9f7 1430 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1431
<> 144:ef7eb2e8f9f7 1432 /* ULPS Request on Data Lanes */
<> 144:ef7eb2e8f9f7 1433 hdsi->Instance->PUCR |= DSI_PUCR_URDL;
<> 144:ef7eb2e8f9f7 1434
<> 144:ef7eb2e8f9f7 1435 /* Get tick */
<> 144:ef7eb2e8f9f7 1436 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1437
<> 144:ef7eb2e8f9f7 1438 /* Wait until the D-PHY active lanes enter into ULPM */
<> 144:ef7eb2e8f9f7 1439 if((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_ONE_DATA_LANE)
<> 144:ef7eb2e8f9f7 1440 {
<> 144:ef7eb2e8f9f7 1441 while((hdsi->Instance->PSR & DSI_PSR_UAN0) != RESET)
<> 144:ef7eb2e8f9f7 1442 {
<> 144:ef7eb2e8f9f7 1443 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1444 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1445 {
<> 144:ef7eb2e8f9f7 1446 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1447 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1448
<> 144:ef7eb2e8f9f7 1449 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1450 }
<> 144:ef7eb2e8f9f7 1451 }
<> 144:ef7eb2e8f9f7 1452 }
<> 144:ef7eb2e8f9f7 1453 else if ((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_TWO_DATA_LANES)
<> 144:ef7eb2e8f9f7 1454 {
<> 144:ef7eb2e8f9f7 1455 while((hdsi->Instance->PSR & (DSI_PSR_UAN0 | DSI_PSR_UAN1)) != RESET)
<> 144:ef7eb2e8f9f7 1456 {
<> 144:ef7eb2e8f9f7 1457 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1458 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1459 {
<> 144:ef7eb2e8f9f7 1460 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1461 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1462
<> 144:ef7eb2e8f9f7 1463 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1464 }
<> 144:ef7eb2e8f9f7 1465 }
<> 144:ef7eb2e8f9f7 1466 }
<> 144:ef7eb2e8f9f7 1467
<> 144:ef7eb2e8f9f7 1468 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1469 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1470
<> 144:ef7eb2e8f9f7 1471 return HAL_OK;
<> 144:ef7eb2e8f9f7 1472 }
<> 144:ef7eb2e8f9f7 1473
<> 144:ef7eb2e8f9f7 1474 /**
<> 144:ef7eb2e8f9f7 1475 * @brief Exit the ULPM (Ultra Low Power Mode) with the D-PHY PLL running
<> 144:ef7eb2e8f9f7 1476 * (only data lanes are in ULPM)
<> 144:ef7eb2e8f9f7 1477 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1478 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1479 * @retval HAL status
<> 144:ef7eb2e8f9f7 1480 */
<> 144:ef7eb2e8f9f7 1481 HAL_StatusTypeDef HAL_DSI_ExitULPMData(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1482 {
<> 144:ef7eb2e8f9f7 1483 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1484
<> 144:ef7eb2e8f9f7 1485 /* Process locked */
<> 144:ef7eb2e8f9f7 1486 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1487
<> 144:ef7eb2e8f9f7 1488 /* Exit ULPS on Data Lanes */
<> 144:ef7eb2e8f9f7 1489 hdsi->Instance->PUCR |= DSI_PUCR_UEDL;
<> 144:ef7eb2e8f9f7 1490
<> 144:ef7eb2e8f9f7 1491 /* Get tick */
<> 144:ef7eb2e8f9f7 1492 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1493
<> 144:ef7eb2e8f9f7 1494 /* Wait until all active lanes exit ULPM */
<> 144:ef7eb2e8f9f7 1495 if((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_ONE_DATA_LANE)
<> 144:ef7eb2e8f9f7 1496 {
<> 144:ef7eb2e8f9f7 1497 while((hdsi->Instance->PSR & DSI_PSR_UAN0) != DSI_PSR_UAN0)
<> 144:ef7eb2e8f9f7 1498 {
<> 144:ef7eb2e8f9f7 1499 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1500 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1501 {
<> 144:ef7eb2e8f9f7 1502 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1503 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1504
<> 144:ef7eb2e8f9f7 1505 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1506 }
<> 144:ef7eb2e8f9f7 1507 }
<> 144:ef7eb2e8f9f7 1508 }
<> 144:ef7eb2e8f9f7 1509 else if ((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_TWO_DATA_LANES)
<> 144:ef7eb2e8f9f7 1510 {
<> 144:ef7eb2e8f9f7 1511 while((hdsi->Instance->PSR & (DSI_PSR_UAN0 | DSI_PSR_UAN1)) != (DSI_PSR_UAN0 | DSI_PSR_UAN1))
<> 144:ef7eb2e8f9f7 1512 {
<> 144:ef7eb2e8f9f7 1513 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1514 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1515 {
<> 144:ef7eb2e8f9f7 1516 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1517 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1518
<> 144:ef7eb2e8f9f7 1519 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1520 }
<> 144:ef7eb2e8f9f7 1521 }
<> 144:ef7eb2e8f9f7 1522 }
<> 144:ef7eb2e8f9f7 1523
<> 144:ef7eb2e8f9f7 1524 /* De-assert the ULPM requests and the ULPM exit bits */
<> 144:ef7eb2e8f9f7 1525 hdsi->Instance->PUCR = 0;
<> 144:ef7eb2e8f9f7 1526
<> 144:ef7eb2e8f9f7 1527 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1528 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1529
<> 144:ef7eb2e8f9f7 1530 return HAL_OK;
<> 144:ef7eb2e8f9f7 1531 }
<> 144:ef7eb2e8f9f7 1532
<> 144:ef7eb2e8f9f7 1533 /**
<> 144:ef7eb2e8f9f7 1534 * @brief Enter the ULPM (Ultra Low Power Mode) with the D-PHY PLL turned off
<> 144:ef7eb2e8f9f7 1535 * (both data and clock lanes are in ULPM)
<> 144:ef7eb2e8f9f7 1536 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1537 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1538 * @retval HAL status
<> 144:ef7eb2e8f9f7 1539 */
<> 144:ef7eb2e8f9f7 1540 HAL_StatusTypeDef HAL_DSI_EnterULPM(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1541 {
<> 144:ef7eb2e8f9f7 1542 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1543
<> 144:ef7eb2e8f9f7 1544 /* Process locked */
<> 144:ef7eb2e8f9f7 1545 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1546
<> 144:ef7eb2e8f9f7 1547 /* Clock lane configuration: no more HS request */
<> 144:ef7eb2e8f9f7 1548 hdsi->Instance->CLCR &= ~DSI_CLCR_DPCC;
<> 144:ef7eb2e8f9f7 1549
<> 144:ef7eb2e8f9f7 1550 /* Use system PLL as byte lane clock source before stopping DSIPHY clock source */
<> 144:ef7eb2e8f9f7 1551 __HAL_RCC_DSI_CONFIG(RCC_DSICLKSOURCE_PLLR);
<> 144:ef7eb2e8f9f7 1552
<> 144:ef7eb2e8f9f7 1553 /* ULPS Request on Clock and Data Lanes */
<> 144:ef7eb2e8f9f7 1554 hdsi->Instance->PUCR |= (DSI_PUCR_URCL | DSI_PUCR_URDL);
<> 144:ef7eb2e8f9f7 1555
<> 144:ef7eb2e8f9f7 1556 /* Get tick */
<> 144:ef7eb2e8f9f7 1557 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1558
<> 144:ef7eb2e8f9f7 1559 /* Wait until all active lanes exit ULPM */
<> 144:ef7eb2e8f9f7 1560 if((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_ONE_DATA_LANE)
<> 144:ef7eb2e8f9f7 1561 {
<> 144:ef7eb2e8f9f7 1562 while((hdsi->Instance->PSR & (DSI_PSR_UAN0 | DSI_PSR_UANC)) != RESET)
<> 144:ef7eb2e8f9f7 1563 {
<> 144:ef7eb2e8f9f7 1564 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1565 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1566 {
<> 144:ef7eb2e8f9f7 1567 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1568 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1569
<> 144:ef7eb2e8f9f7 1570 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1571 }
<> 144:ef7eb2e8f9f7 1572 }
<> 144:ef7eb2e8f9f7 1573 }
<> 144:ef7eb2e8f9f7 1574 else if ((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_TWO_DATA_LANES)
<> 144:ef7eb2e8f9f7 1575 {
<> 144:ef7eb2e8f9f7 1576 while((hdsi->Instance->PSR & (DSI_PSR_UAN0 | DSI_PSR_UAN1 | DSI_PSR_UANC)) != RESET)
<> 144:ef7eb2e8f9f7 1577 {
<> 144:ef7eb2e8f9f7 1578 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1579 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1580 {
<> 144:ef7eb2e8f9f7 1581 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1582 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1583
<> 144:ef7eb2e8f9f7 1584 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1585 }
<> 144:ef7eb2e8f9f7 1586 }
<> 144:ef7eb2e8f9f7 1587 }
<> 144:ef7eb2e8f9f7 1588
<> 144:ef7eb2e8f9f7 1589 /* Turn off the DSI PLL */
<> 144:ef7eb2e8f9f7 1590 __HAL_DSI_PLL_DISABLE(hdsi);
<> 144:ef7eb2e8f9f7 1591
<> 144:ef7eb2e8f9f7 1592 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1593 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1594
<> 144:ef7eb2e8f9f7 1595 return HAL_OK;
<> 144:ef7eb2e8f9f7 1596 }
<> 144:ef7eb2e8f9f7 1597
<> 144:ef7eb2e8f9f7 1598 /**
<> 144:ef7eb2e8f9f7 1599 * @brief Exit the ULPM (Ultra Low Power Mode) with the D-PHY PLL turned off
<> 144:ef7eb2e8f9f7 1600 * (both data and clock lanes are in ULPM)
<> 144:ef7eb2e8f9f7 1601 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1602 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1603 * @retval HAL status
<> 144:ef7eb2e8f9f7 1604 */
<> 144:ef7eb2e8f9f7 1605 HAL_StatusTypeDef HAL_DSI_ExitULPM(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1606 {
<> 144:ef7eb2e8f9f7 1607 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1608
<> 144:ef7eb2e8f9f7 1609 /* Process locked */
<> 144:ef7eb2e8f9f7 1610 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1611
<> 144:ef7eb2e8f9f7 1612 /* Turn on the DSI PLL */
<> 144:ef7eb2e8f9f7 1613 __HAL_DSI_PLL_ENABLE(hdsi);
<> 144:ef7eb2e8f9f7 1614
<> 144:ef7eb2e8f9f7 1615 /* Get tick */
<> 144:ef7eb2e8f9f7 1616 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1617
<> 144:ef7eb2e8f9f7 1618 /* Wait for the lock of the PLL */
<> 144:ef7eb2e8f9f7 1619 while(__HAL_DSI_GET_FLAG(hdsi, DSI_FLAG_PLLLS) == RESET)
<> 144:ef7eb2e8f9f7 1620 {
<> 144:ef7eb2e8f9f7 1621 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1622 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1623 {
<> 144:ef7eb2e8f9f7 1624 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1625 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1626
<> 144:ef7eb2e8f9f7 1627 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1628 }
<> 144:ef7eb2e8f9f7 1629 }
<> 144:ef7eb2e8f9f7 1630
<> 144:ef7eb2e8f9f7 1631 /* Exit ULPS on Clock and Data Lanes */
<> 144:ef7eb2e8f9f7 1632 hdsi->Instance->PUCR |= (DSI_PUCR_UECL | DSI_PUCR_UEDL);
<> 144:ef7eb2e8f9f7 1633
<> 144:ef7eb2e8f9f7 1634 /* Get tick */
<> 144:ef7eb2e8f9f7 1635 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1636
<> 144:ef7eb2e8f9f7 1637 /* Wait until all active lanes exit ULPM */
<> 144:ef7eb2e8f9f7 1638 if((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_ONE_DATA_LANE)
<> 144:ef7eb2e8f9f7 1639 {
<> 144:ef7eb2e8f9f7 1640 while((hdsi->Instance->PSR & (DSI_PSR_UAN0 | DSI_PSR_UANC)) != (DSI_PSR_UAN0 | DSI_PSR_UANC))
<> 144:ef7eb2e8f9f7 1641 {
<> 144:ef7eb2e8f9f7 1642 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1643 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1644 {
<> 144:ef7eb2e8f9f7 1645 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1646 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1647
<> 144:ef7eb2e8f9f7 1648 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1649 }
<> 144:ef7eb2e8f9f7 1650 }
<> 144:ef7eb2e8f9f7 1651 }
<> 144:ef7eb2e8f9f7 1652 else if ((hdsi->Instance->PCONFR & DSI_PCONFR_NL) == DSI_TWO_DATA_LANES)
<> 144:ef7eb2e8f9f7 1653 {
<> 144:ef7eb2e8f9f7 1654 while((hdsi->Instance->PSR & (DSI_PSR_UAN0 | DSI_PSR_UAN1 | DSI_PSR_UANC)) != (DSI_PSR_UAN0 | DSI_PSR_UAN1 | DSI_PSR_UANC))
<> 144:ef7eb2e8f9f7 1655 {
<> 144:ef7eb2e8f9f7 1656 /* Check for the Timeout */
<> 144:ef7eb2e8f9f7 1657 if((HAL_GetTick() - tickstart ) > DSI_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1658 {
<> 144:ef7eb2e8f9f7 1659 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1660 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1661
<> 144:ef7eb2e8f9f7 1662 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1663 }
<> 144:ef7eb2e8f9f7 1664 }
<> 144:ef7eb2e8f9f7 1665 }
<> 144:ef7eb2e8f9f7 1666
<> 144:ef7eb2e8f9f7 1667 /* De-assert the ULPM requests and the ULPM exit bits */
<> 144:ef7eb2e8f9f7 1668 hdsi->Instance->PUCR = 0;
<> 144:ef7eb2e8f9f7 1669
<> 144:ef7eb2e8f9f7 1670 /* Switch the lanbyteclock source in the RCC from system PLL to D-PHY */
<> 144:ef7eb2e8f9f7 1671 __HAL_RCC_DSI_CONFIG(RCC_DSICLKSOURCE_DSIPHY);
<> 144:ef7eb2e8f9f7 1672
<> 144:ef7eb2e8f9f7 1673 /* Restore clock lane configuration to HS */
<> 144:ef7eb2e8f9f7 1674 hdsi->Instance->CLCR |= DSI_CLCR_DPCC;
<> 144:ef7eb2e8f9f7 1675
<> 144:ef7eb2e8f9f7 1676 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1677 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1678
<> 144:ef7eb2e8f9f7 1679 return HAL_OK;
<> 144:ef7eb2e8f9f7 1680 }
<> 144:ef7eb2e8f9f7 1681
<> 144:ef7eb2e8f9f7 1682 /**
<> 144:ef7eb2e8f9f7 1683 * @brief Start test pattern generation
<> 144:ef7eb2e8f9f7 1684 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1685 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1686 * @param Mode: Pattern generator mode
<> 144:ef7eb2e8f9f7 1687 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1688 * 0 : Color bars (horizontal or vertical)
<> 144:ef7eb2e8f9f7 1689 * 1 : BER pattern (vertical only)
<> 144:ef7eb2e8f9f7 1690 * @param Orientation: Pattern generator orientation
<> 144:ef7eb2e8f9f7 1691 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1692 * 0 : Vertical color bars
<> 144:ef7eb2e8f9f7 1693 * 1 : Horizontal color bars
<> 144:ef7eb2e8f9f7 1694 * @retval HAL status
<> 144:ef7eb2e8f9f7 1695 */
<> 144:ef7eb2e8f9f7 1696 HAL_StatusTypeDef HAL_DSI_PatternGeneratorStart(DSI_HandleTypeDef *hdsi, uint32_t Mode, uint32_t Orientation)
<> 144:ef7eb2e8f9f7 1697 {
<> 144:ef7eb2e8f9f7 1698 /* Process locked */
<> 144:ef7eb2e8f9f7 1699 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1700
<> 144:ef7eb2e8f9f7 1701 /* Configure pattern generator mode and orientation */
<> 144:ef7eb2e8f9f7 1702 hdsi->Instance->VMCR &= ~(DSI_VMCR_PGM | DSI_VMCR_PGO);
<> 144:ef7eb2e8f9f7 1703 hdsi->Instance->VMCR |= ((Mode<<20) | (Orientation<<24));
<> 144:ef7eb2e8f9f7 1704
<> 144:ef7eb2e8f9f7 1705 /* Enable pattern generator by setting PGE bit */
<> 144:ef7eb2e8f9f7 1706 hdsi->Instance->VMCR |= DSI_VMCR_PGE;
<> 144:ef7eb2e8f9f7 1707
<> 144:ef7eb2e8f9f7 1708 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1709 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1710
<> 144:ef7eb2e8f9f7 1711 return HAL_OK;
<> 144:ef7eb2e8f9f7 1712 }
<> 144:ef7eb2e8f9f7 1713
<> 144:ef7eb2e8f9f7 1714 /**
<> 144:ef7eb2e8f9f7 1715 * @brief Stop test pattern generation
<> 144:ef7eb2e8f9f7 1716 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1717 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1718 * @retval HAL status
<> 144:ef7eb2e8f9f7 1719 */
<> 144:ef7eb2e8f9f7 1720 HAL_StatusTypeDef HAL_DSI_PatternGeneratorStop(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 1721 {
<> 144:ef7eb2e8f9f7 1722 /* Process locked */
<> 144:ef7eb2e8f9f7 1723 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1724
<> 144:ef7eb2e8f9f7 1725 /* Disable pattern generator by clearing PGE bit */
<> 144:ef7eb2e8f9f7 1726 hdsi->Instance->VMCR &= ~DSI_VMCR_PGE;
<> 144:ef7eb2e8f9f7 1727
<> 144:ef7eb2e8f9f7 1728 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1729 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1730
<> 144:ef7eb2e8f9f7 1731 return HAL_OK;
<> 144:ef7eb2e8f9f7 1732 }
<> 144:ef7eb2e8f9f7 1733
<> 144:ef7eb2e8f9f7 1734 /**
<> 144:ef7eb2e8f9f7 1735 * @brief Set Slew-Rate And Delay Tuning
<> 144:ef7eb2e8f9f7 1736 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1737 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1738 * @param CommDelay: Communication delay to be adjusted.
<> 144:ef7eb2e8f9f7 1739 * This parameter can be any value of @ref DSI_Communication_Delay
<> 144:ef7eb2e8f9f7 1740 * @param Lane: select between clock or data lanes.
<> 144:ef7eb2e8f9f7 1741 * This parameter can be any value of @ref DSI_Lane_Group
<> 144:ef7eb2e8f9f7 1742 * @param Value: Custom value of the slew-rate or delay
<> 144:ef7eb2e8f9f7 1743 * @retval HAL status
<> 144:ef7eb2e8f9f7 1744 */
<> 144:ef7eb2e8f9f7 1745 HAL_StatusTypeDef HAL_DSI_SetSlewRateAndDelayTuning(DSI_HandleTypeDef *hdsi, uint32_t CommDelay, uint32_t Lane, uint32_t Value)
<> 144:ef7eb2e8f9f7 1746 {
<> 144:ef7eb2e8f9f7 1747 /* Process locked */
<> 144:ef7eb2e8f9f7 1748 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1749
<> 144:ef7eb2e8f9f7 1750 /* Check function parameters */
<> 144:ef7eb2e8f9f7 1751 assert_param(IS_DSI_COMMUNICATION_DELAY(CommDelay));
<> 144:ef7eb2e8f9f7 1752 assert_param(IS_DSI_LANE_GROUP(Lane));
<> 144:ef7eb2e8f9f7 1753
<> 144:ef7eb2e8f9f7 1754 switch(CommDelay)
<> 144:ef7eb2e8f9f7 1755 {
<> 144:ef7eb2e8f9f7 1756 case DSI_SLEW_RATE_HSTX:
<> 144:ef7eb2e8f9f7 1757 if(Lane == DSI_CLOCK_LANE)
<> 144:ef7eb2e8f9f7 1758 {
<> 144:ef7eb2e8f9f7 1759 /* High-Speed Transmission Slew Rate Control on Clock Lane */
<> 144:ef7eb2e8f9f7 1760 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_HSTXSRCCL;
<> 144:ef7eb2e8f9f7 1761 hdsi->Instance->WPCR[1] |= Value<<16;
<> 144:ef7eb2e8f9f7 1762 }
<> 144:ef7eb2e8f9f7 1763 else if(Lane == DSI_DATA_LANES)
<> 144:ef7eb2e8f9f7 1764 {
<> 144:ef7eb2e8f9f7 1765 /* High-Speed Transmission Slew Rate Control on Data Lanes */
<> 144:ef7eb2e8f9f7 1766 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_HSTXSRCDL;
<> 144:ef7eb2e8f9f7 1767 hdsi->Instance->WPCR[1] |= Value<<18;
<> 144:ef7eb2e8f9f7 1768 }
<> 144:ef7eb2e8f9f7 1769 break;
<> 144:ef7eb2e8f9f7 1770 case DSI_SLEW_RATE_LPTX:
<> 144:ef7eb2e8f9f7 1771 if(Lane == DSI_CLOCK_LANE)
<> 144:ef7eb2e8f9f7 1772 {
<> 144:ef7eb2e8f9f7 1773 /* Low-Power transmission Slew Rate Compensation on Clock Lane */
<> 144:ef7eb2e8f9f7 1774 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_LPSRCCL;
<> 144:ef7eb2e8f9f7 1775 hdsi->Instance->WPCR[1] |= Value<<6;
<> 144:ef7eb2e8f9f7 1776 }
<> 144:ef7eb2e8f9f7 1777 else if(Lane == DSI_DATA_LANES)
<> 144:ef7eb2e8f9f7 1778 {
<> 144:ef7eb2e8f9f7 1779 /* Low-Power transmission Slew Rate Compensation on Data Lanes */
<> 144:ef7eb2e8f9f7 1780 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_LPSRCDL;
<> 144:ef7eb2e8f9f7 1781 hdsi->Instance->WPCR[1] |= Value<<8;
<> 144:ef7eb2e8f9f7 1782 }
<> 144:ef7eb2e8f9f7 1783 break;
<> 144:ef7eb2e8f9f7 1784 case DSI_HS_DELAY:
<> 144:ef7eb2e8f9f7 1785 if(Lane == DSI_CLOCK_LANE)
<> 144:ef7eb2e8f9f7 1786 {
<> 144:ef7eb2e8f9f7 1787 /* High-Speed Transmission Delay on Clock Lane */
<> 144:ef7eb2e8f9f7 1788 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_HSTXDCL;
<> 144:ef7eb2e8f9f7 1789 hdsi->Instance->WPCR[1] |= Value;
<> 144:ef7eb2e8f9f7 1790 }
<> 144:ef7eb2e8f9f7 1791 else if(Lane == DSI_DATA_LANES)
<> 144:ef7eb2e8f9f7 1792 {
<> 144:ef7eb2e8f9f7 1793 /* High-Speed Transmission Delay on Data Lanes */
<> 144:ef7eb2e8f9f7 1794 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_HSTXDDL;
<> 144:ef7eb2e8f9f7 1795 hdsi->Instance->WPCR[1] |= Value<<2;
<> 144:ef7eb2e8f9f7 1796 }
<> 144:ef7eb2e8f9f7 1797 break;
<> 144:ef7eb2e8f9f7 1798 default:
<> 144:ef7eb2e8f9f7 1799 break;
<> 144:ef7eb2e8f9f7 1800 }
<> 144:ef7eb2e8f9f7 1801
<> 144:ef7eb2e8f9f7 1802 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1803 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1804
<> 144:ef7eb2e8f9f7 1805 return HAL_OK;
<> 144:ef7eb2e8f9f7 1806 }
<> 144:ef7eb2e8f9f7 1807
<> 144:ef7eb2e8f9f7 1808 /**
<> 144:ef7eb2e8f9f7 1809 * @brief Low-Power Reception Filter Tuning
<> 144:ef7eb2e8f9f7 1810 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1811 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1812 * @param Frequency: cutoff frequency of low-pass filter at the input of LPRX
<> 144:ef7eb2e8f9f7 1813 * @retval HAL status
<> 144:ef7eb2e8f9f7 1814 */
<> 144:ef7eb2e8f9f7 1815 HAL_StatusTypeDef HAL_DSI_SetLowPowerRXFilter(DSI_HandleTypeDef *hdsi, uint32_t Frequency)
<> 144:ef7eb2e8f9f7 1816 {
<> 144:ef7eb2e8f9f7 1817 /* Process locked */
<> 144:ef7eb2e8f9f7 1818 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1819
<> 144:ef7eb2e8f9f7 1820 /* Low-Power RX low-pass Filtering Tuning */
<> 144:ef7eb2e8f9f7 1821 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_LPRXFT;
<> 144:ef7eb2e8f9f7 1822 hdsi->Instance->WPCR[1] |= Frequency<<25;
<> 144:ef7eb2e8f9f7 1823
<> 144:ef7eb2e8f9f7 1824 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1825 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1826
<> 144:ef7eb2e8f9f7 1827 return HAL_OK;
<> 144:ef7eb2e8f9f7 1828 }
<> 144:ef7eb2e8f9f7 1829
<> 144:ef7eb2e8f9f7 1830 /**
<> 144:ef7eb2e8f9f7 1831 * @brief Activate an additional current path on all lanes to meet the SDDTx parameter
<> 144:ef7eb2e8f9f7 1832 * defined in the MIPI D-PHY specification
<> 144:ef7eb2e8f9f7 1833 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1834 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1835 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 1836 * @retval HAL status
<> 144:ef7eb2e8f9f7 1837 */
<> 144:ef7eb2e8f9f7 1838 HAL_StatusTypeDef HAL_DSI_SetSDD(DSI_HandleTypeDef *hdsi, FunctionalState State)
<> 144:ef7eb2e8f9f7 1839 {
<> 144:ef7eb2e8f9f7 1840 /* Process locked */
<> 144:ef7eb2e8f9f7 1841 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1842
<> 144:ef7eb2e8f9f7 1843 /* Check function parameters */
<> 144:ef7eb2e8f9f7 1844 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 1845
<> 144:ef7eb2e8f9f7 1846 /* Activate/Disactivate additional current path on all lanes */
<> 144:ef7eb2e8f9f7 1847 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_SDDC;
<> 144:ef7eb2e8f9f7 1848 hdsi->Instance->WPCR[1] |= ((uint32_t)State << 12);
<> 144:ef7eb2e8f9f7 1849
<> 144:ef7eb2e8f9f7 1850 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1851 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1852
<> 144:ef7eb2e8f9f7 1853 return HAL_OK;
<> 144:ef7eb2e8f9f7 1854 }
<> 144:ef7eb2e8f9f7 1855
<> 144:ef7eb2e8f9f7 1856 /**
<> 144:ef7eb2e8f9f7 1857 * @brief Custom lane pins configuration
<> 144:ef7eb2e8f9f7 1858 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1859 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1860 * @param CustomLane: Function to be applyed on selected lane.
<> 144:ef7eb2e8f9f7 1861 * This parameter can be any value of @ref DSI_CustomLane
<> 144:ef7eb2e8f9f7 1862 * @param Lane: select between clock or data lane 0 or data lane 1.
<> 144:ef7eb2e8f9f7 1863 * This parameter can be any value of @ref DSI_Lane_Select
<> 144:ef7eb2e8f9f7 1864 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 1865 * @retval HAL status
<> 144:ef7eb2e8f9f7 1866 */
<> 144:ef7eb2e8f9f7 1867 HAL_StatusTypeDef HAL_DSI_SetLanePinsConfiguration(DSI_HandleTypeDef *hdsi, uint32_t CustomLane, uint32_t Lane, FunctionalState State)
<> 144:ef7eb2e8f9f7 1868 {
<> 144:ef7eb2e8f9f7 1869 /* Process locked */
<> 144:ef7eb2e8f9f7 1870 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1871
<> 144:ef7eb2e8f9f7 1872 /* Check function parameters */
<> 144:ef7eb2e8f9f7 1873 assert_param(IS_DSI_CUSTOM_LANE(CustomLane));
<> 144:ef7eb2e8f9f7 1874 assert_param(IS_DSI_LANE(Lane));
<> 144:ef7eb2e8f9f7 1875 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 1876
<> 144:ef7eb2e8f9f7 1877 switch(CustomLane)
<> 144:ef7eb2e8f9f7 1878 {
<> 144:ef7eb2e8f9f7 1879 case DSI_SWAP_LANE_PINS:
<> 144:ef7eb2e8f9f7 1880 if(Lane == DSI_CLOCK_LANE)
<> 144:ef7eb2e8f9f7 1881 {
<> 144:ef7eb2e8f9f7 1882 /* Swap pins on clock lane */
<> 144:ef7eb2e8f9f7 1883 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_SWCL;
<> 144:ef7eb2e8f9f7 1884 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 6);
<> 144:ef7eb2e8f9f7 1885 }
<> 144:ef7eb2e8f9f7 1886 else if(Lane == DSI_DATA_LANE0)
<> 144:ef7eb2e8f9f7 1887 {
<> 144:ef7eb2e8f9f7 1888 /* Swap pins on data lane 0 */
<> 144:ef7eb2e8f9f7 1889 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_SWDL0;
<> 144:ef7eb2e8f9f7 1890 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 7);
<> 144:ef7eb2e8f9f7 1891 }
<> 144:ef7eb2e8f9f7 1892 else if(Lane == DSI_DATA_LANE1)
<> 144:ef7eb2e8f9f7 1893 {
<> 144:ef7eb2e8f9f7 1894 /* Swap pins on data lane 1 */
<> 144:ef7eb2e8f9f7 1895 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_SWDL1;
<> 144:ef7eb2e8f9f7 1896 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 8);
<> 144:ef7eb2e8f9f7 1897 }
<> 144:ef7eb2e8f9f7 1898 break;
<> 144:ef7eb2e8f9f7 1899 case DSI_INVERT_HS_SIGNAL:
<> 144:ef7eb2e8f9f7 1900 if(Lane == DSI_CLOCK_LANE)
<> 144:ef7eb2e8f9f7 1901 {
<> 144:ef7eb2e8f9f7 1902 /* Invert HS signal on clock lane */
<> 144:ef7eb2e8f9f7 1903 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_HSICL;
<> 144:ef7eb2e8f9f7 1904 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 9);
<> 144:ef7eb2e8f9f7 1905 }
<> 144:ef7eb2e8f9f7 1906 else if(Lane == DSI_DATA_LANE0)
<> 144:ef7eb2e8f9f7 1907 {
<> 144:ef7eb2e8f9f7 1908 /* Invert HS signal on data lane 0 */
<> 144:ef7eb2e8f9f7 1909 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_HSIDL0;
<> 144:ef7eb2e8f9f7 1910 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 10);
<> 144:ef7eb2e8f9f7 1911 }
<> 144:ef7eb2e8f9f7 1912 else if(Lane == DSI_DATA_LANE1)
<> 144:ef7eb2e8f9f7 1913 {
<> 144:ef7eb2e8f9f7 1914 /* Invert HS signal on data lane 1 */
<> 144:ef7eb2e8f9f7 1915 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_HSIDL1;
<> 144:ef7eb2e8f9f7 1916 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 11);
<> 144:ef7eb2e8f9f7 1917 }
<> 144:ef7eb2e8f9f7 1918 break;
<> 144:ef7eb2e8f9f7 1919 default:
<> 144:ef7eb2e8f9f7 1920 break;
<> 144:ef7eb2e8f9f7 1921 }
<> 144:ef7eb2e8f9f7 1922
<> 144:ef7eb2e8f9f7 1923 /* Process unlocked */
<> 144:ef7eb2e8f9f7 1924 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 1925
<> 144:ef7eb2e8f9f7 1926 return HAL_OK;
<> 144:ef7eb2e8f9f7 1927 }
<> 144:ef7eb2e8f9f7 1928
<> 144:ef7eb2e8f9f7 1929 /**
<> 144:ef7eb2e8f9f7 1930 * @brief Set custom timing for the PHY
<> 144:ef7eb2e8f9f7 1931 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1932 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 1933 * @param Timing: PHY timing to be adjusted.
<> 144:ef7eb2e8f9f7 1934 * This parameter can be any value of @ref DSI_PHY_Timing
<> 144:ef7eb2e8f9f7 1935 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 1936 * @param Value: Custom value of the timing
<> 144:ef7eb2e8f9f7 1937 * @retval HAL status
<> 144:ef7eb2e8f9f7 1938 */
<> 144:ef7eb2e8f9f7 1939 HAL_StatusTypeDef HAL_DSI_SetPHYTimings(DSI_HandleTypeDef *hdsi, uint32_t Timing, FunctionalState State, uint32_t Value)
<> 144:ef7eb2e8f9f7 1940 {
<> 144:ef7eb2e8f9f7 1941 /* Process locked */
<> 144:ef7eb2e8f9f7 1942 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 1943
<> 144:ef7eb2e8f9f7 1944 /* Check function parameters */
<> 144:ef7eb2e8f9f7 1945 assert_param(IS_DSI_PHY_TIMING(Timing));
<> 144:ef7eb2e8f9f7 1946 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 1947
<> 144:ef7eb2e8f9f7 1948 switch(Timing)
<> 144:ef7eb2e8f9f7 1949 {
<> 144:ef7eb2e8f9f7 1950 case DSI_TCLK_POST:
<> 144:ef7eb2e8f9f7 1951 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 1952 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_TCLKPOSTEN;
<> 144:ef7eb2e8f9f7 1953 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 27);
<> 144:ef7eb2e8f9f7 1954
<> 144:ef7eb2e8f9f7 1955 if(State)
<> 144:ef7eb2e8f9f7 1956 {
<> 144:ef7eb2e8f9f7 1957 /* Set custom value */
<> 144:ef7eb2e8f9f7 1958 hdsi->Instance->WPCR[4] &= ~DSI_WPCR4_TCLKPOST;
<> 144:ef7eb2e8f9f7 1959 hdsi->Instance->WPCR[4] |= Value & DSI_WPCR4_TCLKPOST;
<> 144:ef7eb2e8f9f7 1960 }
<> 144:ef7eb2e8f9f7 1961
<> 144:ef7eb2e8f9f7 1962 break;
<> 144:ef7eb2e8f9f7 1963 case DSI_TLPX_CLK:
<> 144:ef7eb2e8f9f7 1964 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 1965 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_TLPXCEN;
<> 144:ef7eb2e8f9f7 1966 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 26);
<> 144:ef7eb2e8f9f7 1967
<> 144:ef7eb2e8f9f7 1968 if(State)
<> 144:ef7eb2e8f9f7 1969 {
<> 144:ef7eb2e8f9f7 1970 /* Set custom value */
<> 144:ef7eb2e8f9f7 1971 hdsi->Instance->WPCR[3] &= ~DSI_WPCR3_TLPXC;
<> 144:ef7eb2e8f9f7 1972 hdsi->Instance->WPCR[3] |= (Value << 24) & DSI_WPCR3_TLPXC;
<> 144:ef7eb2e8f9f7 1973 }
<> 144:ef7eb2e8f9f7 1974
<> 144:ef7eb2e8f9f7 1975 break;
<> 144:ef7eb2e8f9f7 1976 case DSI_THS_EXIT:
<> 144:ef7eb2e8f9f7 1977 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 1978 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_THSEXITEN;
<> 144:ef7eb2e8f9f7 1979 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 25);
<> 144:ef7eb2e8f9f7 1980
<> 144:ef7eb2e8f9f7 1981 if(State)
<> 144:ef7eb2e8f9f7 1982 {
<> 144:ef7eb2e8f9f7 1983 /* Set custom value */
<> 144:ef7eb2e8f9f7 1984 hdsi->Instance->WPCR[3] &= ~DSI_WPCR3_THSEXIT;
<> 144:ef7eb2e8f9f7 1985 hdsi->Instance->WPCR[3] |= (Value << 16) & DSI_WPCR3_THSEXIT;
<> 144:ef7eb2e8f9f7 1986 }
<> 144:ef7eb2e8f9f7 1987
<> 144:ef7eb2e8f9f7 1988 break;
<> 144:ef7eb2e8f9f7 1989 case DSI_TLPX_DATA:
<> 144:ef7eb2e8f9f7 1990 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 1991 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_TLPXDEN;
<> 144:ef7eb2e8f9f7 1992 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 24);
<> 144:ef7eb2e8f9f7 1993
<> 144:ef7eb2e8f9f7 1994 if(State)
<> 144:ef7eb2e8f9f7 1995 {
<> 144:ef7eb2e8f9f7 1996 /* Set custom value */
<> 144:ef7eb2e8f9f7 1997 hdsi->Instance->WPCR[3] &= ~DSI_WPCR3_TLPXD;
<> 144:ef7eb2e8f9f7 1998 hdsi->Instance->WPCR[3] |= (Value << 8) & DSI_WPCR3_TLPXD;
<> 144:ef7eb2e8f9f7 1999 }
<> 144:ef7eb2e8f9f7 2000
<> 144:ef7eb2e8f9f7 2001 break;
<> 144:ef7eb2e8f9f7 2002 case DSI_THS_ZERO:
<> 144:ef7eb2e8f9f7 2003 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 2004 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_THSZEROEN;
<> 144:ef7eb2e8f9f7 2005 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 23);
<> 144:ef7eb2e8f9f7 2006
<> 144:ef7eb2e8f9f7 2007 if(State)
<> 144:ef7eb2e8f9f7 2008 {
<> 144:ef7eb2e8f9f7 2009 /* Set custom value */
<> 144:ef7eb2e8f9f7 2010 hdsi->Instance->WPCR[3] &= ~DSI_WPCR3_THSZERO;
<> 144:ef7eb2e8f9f7 2011 hdsi->Instance->WPCR[3] |= Value & DSI_WPCR3_THSZERO;
<> 144:ef7eb2e8f9f7 2012 }
<> 144:ef7eb2e8f9f7 2013
<> 144:ef7eb2e8f9f7 2014 break;
<> 144:ef7eb2e8f9f7 2015 case DSI_THS_TRAIL:
<> 144:ef7eb2e8f9f7 2016 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 2017 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_THSTRAILEN;
<> 144:ef7eb2e8f9f7 2018 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 22);
<> 144:ef7eb2e8f9f7 2019
<> 144:ef7eb2e8f9f7 2020 if(State)
<> 144:ef7eb2e8f9f7 2021 {
<> 144:ef7eb2e8f9f7 2022 /* Set custom value */
<> 144:ef7eb2e8f9f7 2023 hdsi->Instance->WPCR[2] &= ~DSI_WPCR2_THSTRAIL;
<> 144:ef7eb2e8f9f7 2024 hdsi->Instance->WPCR[2] |= (Value << 24) & DSI_WPCR2_THSTRAIL;
<> 144:ef7eb2e8f9f7 2025 }
<> 144:ef7eb2e8f9f7 2026
<> 144:ef7eb2e8f9f7 2027 break;
<> 144:ef7eb2e8f9f7 2028 case DSI_THS_PREPARE:
<> 144:ef7eb2e8f9f7 2029 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 2030 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_THSPREPEN;
<> 144:ef7eb2e8f9f7 2031 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 21);
<> 144:ef7eb2e8f9f7 2032
<> 144:ef7eb2e8f9f7 2033 if(State)
<> 144:ef7eb2e8f9f7 2034 {
<> 144:ef7eb2e8f9f7 2035 /* Set custom value */
<> 144:ef7eb2e8f9f7 2036 hdsi->Instance->WPCR[2] &= ~DSI_WPCR2_THSPREP;
<> 144:ef7eb2e8f9f7 2037 hdsi->Instance->WPCR[2] |= (Value << 16) & DSI_WPCR2_THSPREP;
<> 144:ef7eb2e8f9f7 2038 }
<> 144:ef7eb2e8f9f7 2039
<> 144:ef7eb2e8f9f7 2040 break;
<> 144:ef7eb2e8f9f7 2041 case DSI_TCLK_ZERO:
<> 144:ef7eb2e8f9f7 2042 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 2043 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_TCLKZEROEN;
<> 144:ef7eb2e8f9f7 2044 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 20);
<> 144:ef7eb2e8f9f7 2045
<> 144:ef7eb2e8f9f7 2046 if(State)
<> 144:ef7eb2e8f9f7 2047 {
<> 144:ef7eb2e8f9f7 2048 /* Set custom value */
<> 144:ef7eb2e8f9f7 2049 hdsi->Instance->WPCR[2] &= ~DSI_WPCR2_TCLKZERO;
<> 144:ef7eb2e8f9f7 2050 hdsi->Instance->WPCR[2] |= (Value << 8) & DSI_WPCR2_TCLKZERO;
<> 144:ef7eb2e8f9f7 2051 }
<> 144:ef7eb2e8f9f7 2052
<> 144:ef7eb2e8f9f7 2053 break;
<> 144:ef7eb2e8f9f7 2054 case DSI_TCLK_PREPARE:
<> 144:ef7eb2e8f9f7 2055 /* Enable/Disable custom timing setting */
<> 144:ef7eb2e8f9f7 2056 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_TCLKPREPEN;
<> 144:ef7eb2e8f9f7 2057 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 19);
<> 144:ef7eb2e8f9f7 2058
<> 144:ef7eb2e8f9f7 2059 if(State)
<> 144:ef7eb2e8f9f7 2060 {
<> 144:ef7eb2e8f9f7 2061 /* Set custom value */
<> 144:ef7eb2e8f9f7 2062 hdsi->Instance->WPCR[2] &= ~DSI_WPCR2_TCLKPREP;
<> 144:ef7eb2e8f9f7 2063 hdsi->Instance->WPCR[2] |= Value & DSI_WPCR2_TCLKPREP;
<> 144:ef7eb2e8f9f7 2064 }
<> 144:ef7eb2e8f9f7 2065
<> 144:ef7eb2e8f9f7 2066 break;
<> 144:ef7eb2e8f9f7 2067 default:
<> 144:ef7eb2e8f9f7 2068 break;
<> 144:ef7eb2e8f9f7 2069 }
<> 144:ef7eb2e8f9f7 2070
<> 144:ef7eb2e8f9f7 2071 /* Process unlocked */
<> 144:ef7eb2e8f9f7 2072 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 2073
<> 144:ef7eb2e8f9f7 2074 return HAL_OK;
<> 144:ef7eb2e8f9f7 2075 }
<> 144:ef7eb2e8f9f7 2076
<> 144:ef7eb2e8f9f7 2077 /**
<> 144:ef7eb2e8f9f7 2078 * @brief Force the Clock/Data Lane in TX Stop Mode
<> 144:ef7eb2e8f9f7 2079 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2080 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 2081 * @param Lane: select between clock or data lanes.
<> 144:ef7eb2e8f9f7 2082 * This parameter can be any value of @ref DSI_Lane_Group
<> 144:ef7eb2e8f9f7 2083 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 2084 * @retval HAL status
<> 144:ef7eb2e8f9f7 2085 */
<> 144:ef7eb2e8f9f7 2086 HAL_StatusTypeDef HAL_DSI_ForceTXStopMode(DSI_HandleTypeDef *hdsi, uint32_t Lane, FunctionalState State)
<> 144:ef7eb2e8f9f7 2087 {
<> 144:ef7eb2e8f9f7 2088 /* Process locked */
<> 144:ef7eb2e8f9f7 2089 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 2090
<> 144:ef7eb2e8f9f7 2091 /* Check function parameters */
<> 144:ef7eb2e8f9f7 2092 assert_param(IS_DSI_LANE_GROUP(Lane));
<> 144:ef7eb2e8f9f7 2093 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 2094
<> 144:ef7eb2e8f9f7 2095 if(Lane == DSI_CLOCK_LANE)
<> 144:ef7eb2e8f9f7 2096 {
<> 144:ef7eb2e8f9f7 2097 /* Force/Unforce the Clock Lane in TX Stop Mode */
<> 144:ef7eb2e8f9f7 2098 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_FTXSMCL;
<> 144:ef7eb2e8f9f7 2099 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 12);
<> 144:ef7eb2e8f9f7 2100 }
<> 144:ef7eb2e8f9f7 2101 else if(Lane == DSI_DATA_LANES)
<> 144:ef7eb2e8f9f7 2102 {
<> 144:ef7eb2e8f9f7 2103 /* Force/Unforce the Data Lanes in TX Stop Mode */
<> 144:ef7eb2e8f9f7 2104 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_FTXSMDL;
<> 144:ef7eb2e8f9f7 2105 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 13);
<> 144:ef7eb2e8f9f7 2106 }
<> 144:ef7eb2e8f9f7 2107
<> 144:ef7eb2e8f9f7 2108 /* Process unlocked */
<> 144:ef7eb2e8f9f7 2109 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 2110
<> 144:ef7eb2e8f9f7 2111 return HAL_OK;
<> 144:ef7eb2e8f9f7 2112 }
<> 144:ef7eb2e8f9f7 2113
<> 144:ef7eb2e8f9f7 2114 /**
<> 144:ef7eb2e8f9f7 2115 * @brief Forces LP Receiver in Low-Power Mode
<> 144:ef7eb2e8f9f7 2116 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2117 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 2118 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 2119 * @retval HAL status
<> 144:ef7eb2e8f9f7 2120 */
<> 144:ef7eb2e8f9f7 2121 HAL_StatusTypeDef HAL_DSI_ForceRXLowPower(DSI_HandleTypeDef *hdsi, FunctionalState State)
<> 144:ef7eb2e8f9f7 2122 {
<> 144:ef7eb2e8f9f7 2123 /* Process locked */
<> 144:ef7eb2e8f9f7 2124 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 2125
<> 144:ef7eb2e8f9f7 2126 /* Check function parameters */
<> 144:ef7eb2e8f9f7 2127 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 2128
<> 144:ef7eb2e8f9f7 2129 /* Force/Unforce LP Receiver in Low-Power Mode */
<> 144:ef7eb2e8f9f7 2130 hdsi->Instance->WPCR[1] &= ~DSI_WPCR1_FLPRXLPM;
<> 144:ef7eb2e8f9f7 2131 hdsi->Instance->WPCR[1] |= ((uint32_t)State << 22);
<> 144:ef7eb2e8f9f7 2132
<> 144:ef7eb2e8f9f7 2133 /* Process unlocked */
<> 144:ef7eb2e8f9f7 2134 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 2135
<> 144:ef7eb2e8f9f7 2136 return HAL_OK;
<> 144:ef7eb2e8f9f7 2137 }
<> 144:ef7eb2e8f9f7 2138
<> 144:ef7eb2e8f9f7 2139 /**
<> 144:ef7eb2e8f9f7 2140 * @brief Force Data Lanes in RX Mode after a BTA
<> 144:ef7eb2e8f9f7 2141 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2142 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 2143 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 2144 * @retval HAL status
<> 144:ef7eb2e8f9f7 2145 */
<> 144:ef7eb2e8f9f7 2146 HAL_StatusTypeDef HAL_DSI_ForceDataLanesInRX(DSI_HandleTypeDef *hdsi, FunctionalState State)
<> 144:ef7eb2e8f9f7 2147 {
<> 144:ef7eb2e8f9f7 2148 /* Process locked */
<> 144:ef7eb2e8f9f7 2149 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 2150
<> 144:ef7eb2e8f9f7 2151 /* Check function parameters */
<> 144:ef7eb2e8f9f7 2152 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 2153
<> 144:ef7eb2e8f9f7 2154 /* Force Data Lanes in RX Mode */
<> 144:ef7eb2e8f9f7 2155 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_TDDL;
<> 144:ef7eb2e8f9f7 2156 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 16);
<> 144:ef7eb2e8f9f7 2157
<> 144:ef7eb2e8f9f7 2158 /* Process unlocked */
<> 144:ef7eb2e8f9f7 2159 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 2160
<> 144:ef7eb2e8f9f7 2161 return HAL_OK;
<> 144:ef7eb2e8f9f7 2162 }
<> 144:ef7eb2e8f9f7 2163
<> 144:ef7eb2e8f9f7 2164 /**
<> 144:ef7eb2e8f9f7 2165 * @brief Enable a pull-down on the lanes to prevent from floating states when unused
<> 144:ef7eb2e8f9f7 2166 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2167 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 2168 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 2169 * @retval HAL status
<> 144:ef7eb2e8f9f7 2170 */
<> 144:ef7eb2e8f9f7 2171 HAL_StatusTypeDef HAL_DSI_SetPullDown(DSI_HandleTypeDef *hdsi, FunctionalState State)
<> 144:ef7eb2e8f9f7 2172 {
<> 144:ef7eb2e8f9f7 2173 /* Process locked */
<> 144:ef7eb2e8f9f7 2174 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 2175
<> 144:ef7eb2e8f9f7 2176 /* Check function parameters */
<> 144:ef7eb2e8f9f7 2177 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 2178
<> 144:ef7eb2e8f9f7 2179 /* Enable/Disable pull-down on lanes */
<> 144:ef7eb2e8f9f7 2180 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_PDEN;
<> 144:ef7eb2e8f9f7 2181 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 18);
<> 144:ef7eb2e8f9f7 2182
<> 144:ef7eb2e8f9f7 2183 /* Process unlocked */
<> 144:ef7eb2e8f9f7 2184 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 2185
<> 144:ef7eb2e8f9f7 2186 return HAL_OK;
<> 144:ef7eb2e8f9f7 2187 }
<> 144:ef7eb2e8f9f7 2188
<> 144:ef7eb2e8f9f7 2189 /**
<> 144:ef7eb2e8f9f7 2190 * @brief Switch off the contention detection on data lanes
<> 144:ef7eb2e8f9f7 2191 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2192 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 2193 * @param State: ENABLE or DISABLE
<> 144:ef7eb2e8f9f7 2194 * @retval HAL status
<> 144:ef7eb2e8f9f7 2195 */
<> 144:ef7eb2e8f9f7 2196 HAL_StatusTypeDef HAL_DSI_SetContentionDetectionOff(DSI_HandleTypeDef *hdsi, FunctionalState State)
<> 144:ef7eb2e8f9f7 2197 {
<> 144:ef7eb2e8f9f7 2198 /* Process locked */
<> 144:ef7eb2e8f9f7 2199 __HAL_LOCK(hdsi);
<> 144:ef7eb2e8f9f7 2200
<> 144:ef7eb2e8f9f7 2201 /* Check function parameters */
<> 144:ef7eb2e8f9f7 2202 assert_param(IS_FUNCTIONAL_STATE(State));
<> 144:ef7eb2e8f9f7 2203
<> 144:ef7eb2e8f9f7 2204 /* Contention Detection on Data Lanes OFF */
<> 144:ef7eb2e8f9f7 2205 hdsi->Instance->WPCR[0] &= ~DSI_WPCR0_CDOFFDL;
<> 144:ef7eb2e8f9f7 2206 hdsi->Instance->WPCR[0] |= ((uint32_t)State << 14);
<> 144:ef7eb2e8f9f7 2207
<> 144:ef7eb2e8f9f7 2208 /* Process unlocked */
<> 144:ef7eb2e8f9f7 2209 __HAL_UNLOCK(hdsi);
<> 144:ef7eb2e8f9f7 2210
<> 144:ef7eb2e8f9f7 2211 return HAL_OK;
<> 144:ef7eb2e8f9f7 2212 }
<> 144:ef7eb2e8f9f7 2213
<> 144:ef7eb2e8f9f7 2214 /**
<> 144:ef7eb2e8f9f7 2215 * @}
<> 144:ef7eb2e8f9f7 2216 */
<> 144:ef7eb2e8f9f7 2217
<> 144:ef7eb2e8f9f7 2218 /** @defgroup DSI_Group4 Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 2219 * @brief Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 2220 *
<> 144:ef7eb2e8f9f7 2221 @verbatim
<> 144:ef7eb2e8f9f7 2222 ===============================================================================
<> 144:ef7eb2e8f9f7 2223 ##### Peripheral State and Errors functions #####
<> 144:ef7eb2e8f9f7 2224 ===============================================================================
<> 144:ef7eb2e8f9f7 2225 [..]
<> 144:ef7eb2e8f9f7 2226 This subsection provides functions allowing to
<> 144:ef7eb2e8f9f7 2227 (+) Check the DSI state.
<> 144:ef7eb2e8f9f7 2228 (+) Get error code.
<> 144:ef7eb2e8f9f7 2229
<> 144:ef7eb2e8f9f7 2230 @endverbatim
<> 144:ef7eb2e8f9f7 2231 * @{
<> 144:ef7eb2e8f9f7 2232 */
<> 144:ef7eb2e8f9f7 2233
<> 144:ef7eb2e8f9f7 2234 /**
<> 144:ef7eb2e8f9f7 2235 * @brief Return the DSI state
<> 144:ef7eb2e8f9f7 2236 * @param hdsi: pointer to a DSI_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2237 * the configuration information for the DSI.
<> 144:ef7eb2e8f9f7 2238 * @retval HAL state
<> 144:ef7eb2e8f9f7 2239 */
<> 144:ef7eb2e8f9f7 2240 HAL_DSI_StateTypeDef HAL_DSI_GetState(DSI_HandleTypeDef *hdsi)
<> 144:ef7eb2e8f9f7 2241 {
<> 144:ef7eb2e8f9f7 2242 return hdsi->State;
<> 144:ef7eb2e8f9f7 2243 }
<> 144:ef7eb2e8f9f7 2244
<> 144:ef7eb2e8f9f7 2245 /**
<> 144:ef7eb2e8f9f7 2246 * @}
<> 144:ef7eb2e8f9f7 2247 */
<> 144:ef7eb2e8f9f7 2248
<> 144:ef7eb2e8f9f7 2249 /**
<> 144:ef7eb2e8f9f7 2250 * @}
<> 144:ef7eb2e8f9f7 2251 */
<> 144:ef7eb2e8f9f7 2252 #endif /*STM32F769xx | STM32F779xx */
<> 144:ef7eb2e8f9f7 2253 #endif /* HAL_DSI_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 2254 /**
<> 144:ef7eb2e8f9f7 2255 * @}
<> 144:ef7eb2e8f9f7 2256 */
<> 144:ef7eb2e8f9f7 2257
<> 144:ef7eb2e8f9f7 2258 /**
<> 144:ef7eb2e8f9f7 2259 * @}
<> 144:ef7eb2e8f9f7 2260 */
<> 144:ef7eb2e8f9f7 2261
<> 144:ef7eb2e8f9f7 2262 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/