Johannes Stratmann / mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

Fork of mbed-dev by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F2/stm32f2xx_hal_pccard.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
This updates the lib to the mbed lib v125

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f2xx_hal_pccard.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.1.3
<> 144:ef7eb2e8f9f7 6 * @date 29-June-2016
<> 144:ef7eb2e8f9f7 7 * @brief PCCARD HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides a generic firmware to drive PCCARD memories mounted
<> 144:ef7eb2e8f9f7 9 * as external device.
<> 144:ef7eb2e8f9f7 10 *
<> 144:ef7eb2e8f9f7 11 @verbatim
<> 144:ef7eb2e8f9f7 12 ===============================================================================
<> 144:ef7eb2e8f9f7 13 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 14 ===============================================================================
<> 144:ef7eb2e8f9f7 15 [..]
<> 144:ef7eb2e8f9f7 16 This driver is a generic layered driver which contains a set of APIs used to
<> 144:ef7eb2e8f9f7 17 control PCCARD/compact flash memories. It uses the FSMC layer functions
<> 144:ef7eb2e8f9f7 18 to interface with PCCARD devices. This driver is used for:
<> 144:ef7eb2e8f9f7 19
<> 144:ef7eb2e8f9f7 20 (+) PCCARD/Compact Flash memory configuration sequence using the function
<> 144:ef7eb2e8f9f7 21 HAL_PCCARD_Init()/HAL_CF_Init() with control and timing parameters for
<> 144:ef7eb2e8f9f7 22 both common and attribute spaces.
<> 144:ef7eb2e8f9f7 23
<> 144:ef7eb2e8f9f7 24 (+) Read PCCARD/Compact Flash memory maker and device IDs using the function
<> 144:ef7eb2e8f9f7 25 HAL_PCCARD_Read_ID()/HAL_CF_Read_ID(). The read information is stored in
<> 144:ef7eb2e8f9f7 26 the CompactFlash_ID structure declared by the function caller.
<> 144:ef7eb2e8f9f7 27
<> 144:ef7eb2e8f9f7 28 (+) Access PCCARD/Compact Flash memory by read/write operations using the functions
<> 144:ef7eb2e8f9f7 29 HAL_PCCARD_Read_Sector()/ HAL_PCCARD_Write_Sector() -
<> 144:ef7eb2e8f9f7 30 HAL_CF_Read_Sector()/HAL_CF_Write_Sector(), to read/write sector.
<> 144:ef7eb2e8f9f7 31
<> 144:ef7eb2e8f9f7 32 (+) Perform PCCARD/Compact Flash Reset chip operation using the function
<> 144:ef7eb2e8f9f7 33 HAL_PCCARD_Reset()/HAL_CF_Reset.
<> 144:ef7eb2e8f9f7 34
<> 144:ef7eb2e8f9f7 35 (+) Perform PCCARD/Compact Flash erase sector operation using the function
<> 144:ef7eb2e8f9f7 36 HAL_PCCARD_Erase_Sector()/HAL_CF_Erase_Sector.
<> 144:ef7eb2e8f9f7 37
<> 144:ef7eb2e8f9f7 38 (+) Read the PCCARD/Compact Flash status operation using the function
<> 144:ef7eb2e8f9f7 39 HAL_PCCARD_ReadStatus()/HAL_CF_ReadStatus().
<> 144:ef7eb2e8f9f7 40
<> 144:ef7eb2e8f9f7 41 (+) You can monitor the PCCARD/Compact Flash device HAL state by calling
<> 144:ef7eb2e8f9f7 42 the function HAL_PCCARD_GetState()/HAL_CF_GetState()
<> 144:ef7eb2e8f9f7 43
<> 144:ef7eb2e8f9f7 44 [..]
<> 144:ef7eb2e8f9f7 45 (@) This driver is a set of generic APIs which handle standard PCCARD/compact flash
<> 144:ef7eb2e8f9f7 46 operations. If a PCCARD/Compact Flash device contains different operations
<> 144:ef7eb2e8f9f7 47 and/or implementations, it should be implemented separately.
<> 144:ef7eb2e8f9f7 48
<> 144:ef7eb2e8f9f7 49 @endverbatim
<> 144:ef7eb2e8f9f7 50 ******************************************************************************
<> 144:ef7eb2e8f9f7 51 * @attention
<> 144:ef7eb2e8f9f7 52 *
<> 144:ef7eb2e8f9f7 53 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 54 *
<> 144:ef7eb2e8f9f7 55 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 56 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 57 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 58 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 59 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 60 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 61 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 62 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 63 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 64 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 65 *
<> 144:ef7eb2e8f9f7 66 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 67 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 68 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 69 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 70 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 71 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 72 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 73 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 74 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 75 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 76 *
<> 144:ef7eb2e8f9f7 77 ******************************************************************************
<> 144:ef7eb2e8f9f7 78 */
<> 144:ef7eb2e8f9f7 79
<> 144:ef7eb2e8f9f7 80 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 81 #include "stm32f2xx_hal.h"
<> 144:ef7eb2e8f9f7 82
<> 144:ef7eb2e8f9f7 83 /** @addtogroup STM32F2xx_HAL_Driver
<> 144:ef7eb2e8f9f7 84 * @{
<> 144:ef7eb2e8f9f7 85 */
<> 144:ef7eb2e8f9f7 86
<> 144:ef7eb2e8f9f7 87 #ifdef HAL_PCCARD_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 88 /** @defgroup PCCARD PCCARD
<> 144:ef7eb2e8f9f7 89 * @brief PCCARD HAL module driver
<> 144:ef7eb2e8f9f7 90 * @{
<> 144:ef7eb2e8f9f7 91 */
<> 144:ef7eb2e8f9f7 92 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 93 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 94
<> 144:ef7eb2e8f9f7 95 /** @defgroup PCCARD_Private_Defines PCCARD Private Defines
<> 144:ef7eb2e8f9f7 96 * @{
<> 144:ef7eb2e8f9f7 97 */
<> 144:ef7eb2e8f9f7 98 #define PCCARD_TIMEOUT_READ_ID (uint32_t)0x0000FFFFU
<> 144:ef7eb2e8f9f7 99 #define PCCARD_TIMEOUT_READ_WRITE_SECTOR (uint32_t)0x0000FFFFU
<> 144:ef7eb2e8f9f7 100 #define PCCARD_TIMEOUT_ERASE_SECTOR (uint32_t)0x00000400U
<> 144:ef7eb2e8f9f7 101 #define PCCARD_TIMEOUT_STATUS (uint32_t)0x01000000U
<> 144:ef7eb2e8f9f7 102
<> 144:ef7eb2e8f9f7 103 #define PCCARD_STATUS_OK (uint8_t)0x58U
<> 144:ef7eb2e8f9f7 104 #define PCCARD_STATUS_WRITE_OK (uint8_t)0x50U
<> 144:ef7eb2e8f9f7 105 /**
<> 144:ef7eb2e8f9f7 106 * @}
<> 144:ef7eb2e8f9f7 107 */
<> 144:ef7eb2e8f9f7 108
<> 144:ef7eb2e8f9f7 109 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 110 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 111 /* Private function ----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 112 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 113 /** @defgroup PCCARD_Exported_Functions PCCARD Exported Functions
<> 144:ef7eb2e8f9f7 114 * @{
<> 144:ef7eb2e8f9f7 115 */
<> 144:ef7eb2e8f9f7 116
<> 144:ef7eb2e8f9f7 117 /** @defgroup PCCARD_Exported_Functions_Group1 Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 118 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 119 *
<> 144:ef7eb2e8f9f7 120 @verbatim
<> 144:ef7eb2e8f9f7 121 ==============================================================================
<> 144:ef7eb2e8f9f7 122 ##### PCCARD Initialization and de-initialization functions #####
<> 144:ef7eb2e8f9f7 123 ==============================================================================
<> 144:ef7eb2e8f9f7 124 [..]
<> 144:ef7eb2e8f9f7 125 This section provides functions allowing to initialize/de-initialize
<> 144:ef7eb2e8f9f7 126 the PCCARD memory
<> 144:ef7eb2e8f9f7 127
<> 144:ef7eb2e8f9f7 128 @endverbatim
<> 144:ef7eb2e8f9f7 129 * @{
<> 144:ef7eb2e8f9f7 130 */
<> 144:ef7eb2e8f9f7 131
<> 144:ef7eb2e8f9f7 132 /**
<> 144:ef7eb2e8f9f7 133 * @brief Perform the PCCARD memory Initialization sequence
<> 144:ef7eb2e8f9f7 134 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 135 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 136 * @param ComSpaceTiming: Common space timing structure
<> 144:ef7eb2e8f9f7 137 * @param AttSpaceTiming: Attribute space timing structure
<> 144:ef7eb2e8f9f7 138 * @param IOSpaceTiming: IO space timing structure
<> 144:ef7eb2e8f9f7 139 * @retval HAL status
<> 144:ef7eb2e8f9f7 140 */
<> 144:ef7eb2e8f9f7 141 HAL_StatusTypeDef HAL_PCCARD_Init(PCCARD_HandleTypeDef *hpccard, FSMC_NAND_PCC_TimingTypeDef *ComSpaceTiming, FSMC_NAND_PCC_TimingTypeDef *AttSpaceTiming, FSMC_NAND_PCC_TimingTypeDef *IOSpaceTiming)
<> 144:ef7eb2e8f9f7 142 {
<> 144:ef7eb2e8f9f7 143 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 144 if(hpccard == NULL)
<> 144:ef7eb2e8f9f7 145 {
<> 144:ef7eb2e8f9f7 146 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 147 }
<> 144:ef7eb2e8f9f7 148
<> 144:ef7eb2e8f9f7 149 if(hpccard->State == HAL_PCCARD_STATE_RESET)
<> 144:ef7eb2e8f9f7 150 {
<> 144:ef7eb2e8f9f7 151 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 152 hpccard->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 153 /* Initialize the low level hardware (MSP) */
<> 144:ef7eb2e8f9f7 154 HAL_PCCARD_MspInit(hpccard);
<> 144:ef7eb2e8f9f7 155 }
<> 144:ef7eb2e8f9f7 156
<> 144:ef7eb2e8f9f7 157 /* Initialize the PCCARD state */
<> 144:ef7eb2e8f9f7 158 hpccard->State = HAL_PCCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 159
<> 144:ef7eb2e8f9f7 160 /* Initialize PCCARD control Interface */
<> 144:ef7eb2e8f9f7 161 FSMC_PCCARD_Init(hpccard->Instance, &(hpccard->Init));
<> 144:ef7eb2e8f9f7 162
<> 144:ef7eb2e8f9f7 163 /* Init PCCARD common space timing Interface */
<> 144:ef7eb2e8f9f7 164 FSMC_PCCARD_CommonSpace_Timing_Init(hpccard->Instance, ComSpaceTiming);
<> 144:ef7eb2e8f9f7 165
<> 144:ef7eb2e8f9f7 166 /* Init PCCARD attribute space timing Interface */
<> 144:ef7eb2e8f9f7 167 FSMC_PCCARD_AttributeSpace_Timing_Init(hpccard->Instance, AttSpaceTiming);
<> 144:ef7eb2e8f9f7 168
<> 144:ef7eb2e8f9f7 169 /* Init PCCARD IO space timing Interface */
<> 144:ef7eb2e8f9f7 170 FSMC_PCCARD_IOSpace_Timing_Init(hpccard->Instance, IOSpaceTiming);
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /* Enable the PCCARD device */
<> 144:ef7eb2e8f9f7 173 __FSMC_PCCARD_ENABLE(hpccard->Instance);
<> 144:ef7eb2e8f9f7 174
<> 144:ef7eb2e8f9f7 175 /* Update the PCCARD state */
<> 144:ef7eb2e8f9f7 176 hpccard->State = HAL_PCCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 177
<> 144:ef7eb2e8f9f7 178 return HAL_OK;
<> 144:ef7eb2e8f9f7 179
<> 144:ef7eb2e8f9f7 180 }
<> 144:ef7eb2e8f9f7 181
<> 144:ef7eb2e8f9f7 182 /**
<> 144:ef7eb2e8f9f7 183 * @brief Perform the PCCARD memory De-initialization sequence
<> 144:ef7eb2e8f9f7 184 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 185 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 186 * @retval HAL status
<> 144:ef7eb2e8f9f7 187 */
<> 144:ef7eb2e8f9f7 188 HAL_StatusTypeDef HAL_PCCARD_DeInit(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 189 {
<> 144:ef7eb2e8f9f7 190 /* De-Initialize the low level hardware (MSP) */
<> 144:ef7eb2e8f9f7 191 HAL_PCCARD_MspDeInit(hpccard);
<> 144:ef7eb2e8f9f7 192
<> 144:ef7eb2e8f9f7 193 /* Configure the PCCARD registers with their reset values */
<> 144:ef7eb2e8f9f7 194 FSMC_PCCARD_DeInit(hpccard->Instance);
<> 144:ef7eb2e8f9f7 195
<> 144:ef7eb2e8f9f7 196 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 197 hpccard->State = HAL_PCCARD_STATE_RESET;
<> 144:ef7eb2e8f9f7 198
<> 144:ef7eb2e8f9f7 199 /* Release Lock */
<> 144:ef7eb2e8f9f7 200 __HAL_UNLOCK(hpccard);
<> 144:ef7eb2e8f9f7 201
<> 144:ef7eb2e8f9f7 202 return HAL_OK;
<> 144:ef7eb2e8f9f7 203 }
<> 144:ef7eb2e8f9f7 204
<> 144:ef7eb2e8f9f7 205 /**
<> 144:ef7eb2e8f9f7 206 * @brief PCCARD MSP Init
<> 144:ef7eb2e8f9f7 207 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 208 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 209 * @retval None
<> 144:ef7eb2e8f9f7 210 */
<> 144:ef7eb2e8f9f7 211 __weak void HAL_PCCARD_MspInit(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 212 {
<> 144:ef7eb2e8f9f7 213 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 214 UNUSED(hpccard);
<> 144:ef7eb2e8f9f7 215 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 216 the HAL_PCCARD_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 217 */
<> 144:ef7eb2e8f9f7 218 }
<> 144:ef7eb2e8f9f7 219
<> 144:ef7eb2e8f9f7 220 /**
<> 144:ef7eb2e8f9f7 221 * @brief PCCARD MSP DeInit
<> 144:ef7eb2e8f9f7 222 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 223 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 224 * @retval None
<> 144:ef7eb2e8f9f7 225 */
<> 144:ef7eb2e8f9f7 226 __weak void HAL_PCCARD_MspDeInit(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 227 {
<> 144:ef7eb2e8f9f7 228 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 229 UNUSED(hpccard);
<> 144:ef7eb2e8f9f7 230 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 231 the HAL_PCCARD_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 232 */
<> 144:ef7eb2e8f9f7 233 }
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 /**
<> 144:ef7eb2e8f9f7 236 * @}
<> 144:ef7eb2e8f9f7 237 */
<> 144:ef7eb2e8f9f7 238
<> 144:ef7eb2e8f9f7 239 /** @defgroup PCCARD_Exported_Functions_Group2 Input and Output functions
<> 144:ef7eb2e8f9f7 240 * @brief Input Output and memory control functions
<> 144:ef7eb2e8f9f7 241 *
<> 144:ef7eb2e8f9f7 242 @verbatim
<> 144:ef7eb2e8f9f7 243 ==============================================================================
<> 144:ef7eb2e8f9f7 244 ##### PCCARD Input and Output functions #####
<> 144:ef7eb2e8f9f7 245 ==============================================================================
<> 144:ef7eb2e8f9f7 246 [..]
<> 144:ef7eb2e8f9f7 247 This section provides functions allowing to use and control the PCCARD memory
<> 144:ef7eb2e8f9f7 248
<> 144:ef7eb2e8f9f7 249 @endverbatim
<> 144:ef7eb2e8f9f7 250 * @{
<> 144:ef7eb2e8f9f7 251 */
<> 144:ef7eb2e8f9f7 252
<> 144:ef7eb2e8f9f7 253 /**
<> 144:ef7eb2e8f9f7 254 * @brief Read Compact Flash's ID.
<> 144:ef7eb2e8f9f7 255 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 256 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 257 * @param CompactFlash_ID: Compact flash ID structure.
<> 144:ef7eb2e8f9f7 258 * @param pStatus: pointer to compact flash status
<> 144:ef7eb2e8f9f7 259 * @retval HAL status
<> 144:ef7eb2e8f9f7 260 *
<> 144:ef7eb2e8f9f7 261 */
<> 144:ef7eb2e8f9f7 262 HAL_StatusTypeDef HAL_PCCARD_Read_ID(PCCARD_HandleTypeDef *hpccard, uint8_t CompactFlash_ID[], uint8_t *pStatus)
<> 144:ef7eb2e8f9f7 263 {
<> 144:ef7eb2e8f9f7 264 uint32_t timeout = PCCARD_TIMEOUT_READ_ID, index = 0U;
<> 144:ef7eb2e8f9f7 265 uint8_t status = 0U;
<> 144:ef7eb2e8f9f7 266
<> 144:ef7eb2e8f9f7 267 /* Process Locked */
<> 144:ef7eb2e8f9f7 268 __HAL_LOCK(hpccard);
<> 144:ef7eb2e8f9f7 269
<> 144:ef7eb2e8f9f7 270 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 271 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 272 {
<> 144:ef7eb2e8f9f7 273 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 274 }
<> 144:ef7eb2e8f9f7 275
<> 144:ef7eb2e8f9f7 276 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 277 hpccard->State = HAL_PCCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 278
<> 144:ef7eb2e8f9f7 279
<> 144:ef7eb2e8f9f7 280
<> 144:ef7eb2e8f9f7 281 /* Initialize the PCCARD status */
<> 144:ef7eb2e8f9f7 282 *pStatus = PCCARD_READY;
<> 144:ef7eb2e8f9f7 283
<> 144:ef7eb2e8f9f7 284 /* Send the Identify Command */
<> 144:ef7eb2e8f9f7 285 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD) = 0xECECU;
<> 144:ef7eb2e8f9f7 286
<> 144:ef7eb2e8f9f7 287 /* Read PCCARD IDs and timeout treatment */
<> 144:ef7eb2e8f9f7 288 do
<> 144:ef7eb2e8f9f7 289 {
<> 144:ef7eb2e8f9f7 290 /* Read the PCCARD status */
<> 144:ef7eb2e8f9f7 291 status = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 292
<> 144:ef7eb2e8f9f7 293 timeout--;
<> 144:ef7eb2e8f9f7 294 }while((status != PCCARD_STATUS_OK) && timeout);
<> 144:ef7eb2e8f9f7 295
<> 144:ef7eb2e8f9f7 296 if(timeout == 0U)
<> 144:ef7eb2e8f9f7 297 {
<> 144:ef7eb2e8f9f7 298 *pStatus = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 299 }
<> 144:ef7eb2e8f9f7 300 else
<> 144:ef7eb2e8f9f7 301 {
<> 144:ef7eb2e8f9f7 302 /* Read PCCARD ID bytes */
<> 144:ef7eb2e8f9f7 303 for(index = 0U; index < 16U; index++)
<> 144:ef7eb2e8f9f7 304 {
<> 144:ef7eb2e8f9f7 305 CompactFlash_ID[index] = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_DATA);
<> 144:ef7eb2e8f9f7 306 }
<> 144:ef7eb2e8f9f7 307 }
<> 144:ef7eb2e8f9f7 308
<> 144:ef7eb2e8f9f7 309 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 310 hpccard->State = HAL_PCCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 311
<> 144:ef7eb2e8f9f7 312 /* Process unlocked */
<> 144:ef7eb2e8f9f7 313 __HAL_UNLOCK(hpccard);
<> 144:ef7eb2e8f9f7 314
<> 144:ef7eb2e8f9f7 315 return HAL_OK;
<> 144:ef7eb2e8f9f7 316 }
<> 144:ef7eb2e8f9f7 317
<> 144:ef7eb2e8f9f7 318 /**
<> 144:ef7eb2e8f9f7 319 * @brief Read sector from PCCARD memory
<> 144:ef7eb2e8f9f7 320 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 321 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 322 * @param pBuffer: pointer to destination read buffer
<> 144:ef7eb2e8f9f7 323 * @param SectorAddress: Sector address to read
<> 144:ef7eb2e8f9f7 324 * @param pStatus: pointer to PCCARD status
<> 144:ef7eb2e8f9f7 325 * @retval HAL status
<> 144:ef7eb2e8f9f7 326 */
<> 144:ef7eb2e8f9f7 327 HAL_StatusTypeDef HAL_PCCARD_Read_Sector(PCCARD_HandleTypeDef *hpccard, uint16_t *pBuffer, uint16_t SectorAddress, uint8_t *pStatus)
<> 144:ef7eb2e8f9f7 328 {
<> 144:ef7eb2e8f9f7 329 uint32_t timeout = PCCARD_TIMEOUT_READ_WRITE_SECTOR, index = 0U;
<> 144:ef7eb2e8f9f7 330 uint8_t status = 0U;
<> 144:ef7eb2e8f9f7 331
<> 144:ef7eb2e8f9f7 332 /* Process Locked */
<> 144:ef7eb2e8f9f7 333 __HAL_LOCK(hpccard);
<> 144:ef7eb2e8f9f7 334
<> 144:ef7eb2e8f9f7 335 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 336 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 337 {
<> 144:ef7eb2e8f9f7 338 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 339 }
<> 144:ef7eb2e8f9f7 340
<> 144:ef7eb2e8f9f7 341 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 342 hpccard->State = HAL_PCCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 343
<> 144:ef7eb2e8f9f7 344 /* Initialize PCCARD status */
<> 144:ef7eb2e8f9f7 345 *pStatus = PCCARD_READY;
<> 144:ef7eb2e8f9f7 346
<> 144:ef7eb2e8f9f7 347 /* Set the parameters to write a sector */
<> 144:ef7eb2e8f9f7 348 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_CYLINDER_HIGH) = (uint16_t)0x00U;
<> 144:ef7eb2e8f9f7 349 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_SECTOR_COUNT) = ((uint16_t)0x0100U ) | ((uint16_t)SectorAddress);
<> 144:ef7eb2e8f9f7 350 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD) = (uint16_t)0xE4A0U;
<> 144:ef7eb2e8f9f7 351
<> 144:ef7eb2e8f9f7 352 do
<> 144:ef7eb2e8f9f7 353 {
<> 144:ef7eb2e8f9f7 354 /* wait till the Status = 0x80 */
<> 144:ef7eb2e8f9f7 355 status = *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 356 timeout--;
<> 144:ef7eb2e8f9f7 357 }while((status == 0x80U) && timeout);
<> 144:ef7eb2e8f9f7 358
<> 144:ef7eb2e8f9f7 359 if(timeout == 0U)
<> 144:ef7eb2e8f9f7 360 {
<> 144:ef7eb2e8f9f7 361 *pStatus = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 362 }
<> 144:ef7eb2e8f9f7 363
<> 144:ef7eb2e8f9f7 364 timeout = PCCARD_TIMEOUT_READ_WRITE_SECTOR;
<> 144:ef7eb2e8f9f7 365
<> 144:ef7eb2e8f9f7 366 do
<> 144:ef7eb2e8f9f7 367 {
<> 144:ef7eb2e8f9f7 368 /* wait till the Status = PCCARD_STATUS_OK */
<> 144:ef7eb2e8f9f7 369 status = *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 370 timeout--;
<> 144:ef7eb2e8f9f7 371 }while((status != PCCARD_STATUS_OK) && timeout);
<> 144:ef7eb2e8f9f7 372
<> 144:ef7eb2e8f9f7 373 if(timeout == 0U)
<> 144:ef7eb2e8f9f7 374 {
<> 144:ef7eb2e8f9f7 375 *pStatus = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 376 }
<> 144:ef7eb2e8f9f7 377
<> 144:ef7eb2e8f9f7 378 /* Read bytes */
<> 144:ef7eb2e8f9f7 379 for(; index < PCCARD_SECTOR_SIZE; index++)
<> 144:ef7eb2e8f9f7 380 {
<> 144:ef7eb2e8f9f7 381 *(uint16_t *)pBuffer++ = *(uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR);
<> 144:ef7eb2e8f9f7 382 }
<> 144:ef7eb2e8f9f7 383
<> 144:ef7eb2e8f9f7 384 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 385 hpccard->State = HAL_PCCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 386
<> 144:ef7eb2e8f9f7 387 /* Process unlocked */
<> 144:ef7eb2e8f9f7 388 __HAL_UNLOCK(hpccard);
<> 144:ef7eb2e8f9f7 389
<> 144:ef7eb2e8f9f7 390 return HAL_OK;
<> 144:ef7eb2e8f9f7 391 }
<> 144:ef7eb2e8f9f7 392
<> 144:ef7eb2e8f9f7 393
<> 144:ef7eb2e8f9f7 394 /**
<> 144:ef7eb2e8f9f7 395 * @brief Write sector to PCCARD memory
<> 144:ef7eb2e8f9f7 396 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 397 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 398 * @param pBuffer: pointer to source write buffer
<> 144:ef7eb2e8f9f7 399 * @param SectorAddress: Sector address to write
<> 144:ef7eb2e8f9f7 400 * @param pStatus: pointer to PCCARD status
<> 144:ef7eb2e8f9f7 401 * @retval HAL status
<> 144:ef7eb2e8f9f7 402 */
<> 144:ef7eb2e8f9f7 403 HAL_StatusTypeDef HAL_PCCARD_Write_Sector(PCCARD_HandleTypeDef *hpccard, uint16_t *pBuffer, uint16_t SectorAddress, uint8_t *pStatus)
<> 144:ef7eb2e8f9f7 404 {
<> 144:ef7eb2e8f9f7 405 uint32_t timeout = PCCARD_TIMEOUT_READ_WRITE_SECTOR, index = 0U;
<> 144:ef7eb2e8f9f7 406 uint8_t status = 0U;
<> 144:ef7eb2e8f9f7 407
<> 144:ef7eb2e8f9f7 408 /* Process Locked */
<> 144:ef7eb2e8f9f7 409 __HAL_LOCK(hpccard);
<> 144:ef7eb2e8f9f7 410
<> 144:ef7eb2e8f9f7 411 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 412 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 413 {
<> 144:ef7eb2e8f9f7 414 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 415 }
<> 144:ef7eb2e8f9f7 416
<> 144:ef7eb2e8f9f7 417 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 418 hpccard->State = HAL_PCCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 419
<> 144:ef7eb2e8f9f7 420 /* Initialize PCCARD status */
<> 144:ef7eb2e8f9f7 421 *pStatus = PCCARD_READY;
<> 144:ef7eb2e8f9f7 422
<> 144:ef7eb2e8f9f7 423 /* Set the parameters to write a sector */
<> 144:ef7eb2e8f9f7 424 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_CYLINDER_HIGH) = (uint16_t)0x00U;
<> 144:ef7eb2e8f9f7 425 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_SECTOR_COUNT) = ((uint16_t)0x0100U ) | ((uint16_t)SectorAddress);
<> 144:ef7eb2e8f9f7 426 *(__IO uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD) = (uint16_t)0x30A0U;
<> 144:ef7eb2e8f9f7 427
<> 144:ef7eb2e8f9f7 428 do
<> 144:ef7eb2e8f9f7 429 {
<> 144:ef7eb2e8f9f7 430 /* Wait till the Status = PCCARD_STATUS_OK */
<> 144:ef7eb2e8f9f7 431 status = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 432 timeout--;
<> 144:ef7eb2e8f9f7 433 }while((status != PCCARD_STATUS_OK) && timeout);
<> 144:ef7eb2e8f9f7 434
<> 144:ef7eb2e8f9f7 435 if(timeout == 0U)
<> 144:ef7eb2e8f9f7 436 {
<> 144:ef7eb2e8f9f7 437 *pStatus = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 438 }
<> 144:ef7eb2e8f9f7 439
<> 144:ef7eb2e8f9f7 440 /* Write bytes */
<> 144:ef7eb2e8f9f7 441 for(; index < PCCARD_SECTOR_SIZE; index++)
<> 144:ef7eb2e8f9f7 442 {
<> 144:ef7eb2e8f9f7 443 *(uint16_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR) = *(uint16_t *)pBuffer++;
<> 144:ef7eb2e8f9f7 444 }
<> 144:ef7eb2e8f9f7 445
<> 144:ef7eb2e8f9f7 446 do
<> 144:ef7eb2e8f9f7 447 {
<> 144:ef7eb2e8f9f7 448 /* Wait till the Status = PCCARD_STATUS_WRITE_OK */
<> 144:ef7eb2e8f9f7 449 status = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 450 timeout--;
<> 144:ef7eb2e8f9f7 451 }while((status != PCCARD_STATUS_WRITE_OK) && timeout);
<> 144:ef7eb2e8f9f7 452
<> 144:ef7eb2e8f9f7 453 if(timeout == 0U)
<> 144:ef7eb2e8f9f7 454 {
<> 144:ef7eb2e8f9f7 455 *pStatus = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 456 }
<> 144:ef7eb2e8f9f7 457
<> 144:ef7eb2e8f9f7 458 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 459 hpccard->State = HAL_PCCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 460
<> 144:ef7eb2e8f9f7 461 /* Process unlocked */
<> 144:ef7eb2e8f9f7 462 __HAL_UNLOCK(hpccard);
<> 144:ef7eb2e8f9f7 463
<> 144:ef7eb2e8f9f7 464 return HAL_OK;
<> 144:ef7eb2e8f9f7 465 }
<> 144:ef7eb2e8f9f7 466
<> 144:ef7eb2e8f9f7 467
<> 144:ef7eb2e8f9f7 468 /**
<> 144:ef7eb2e8f9f7 469 * @brief Erase sector from PCCARD memory
<> 144:ef7eb2e8f9f7 470 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 471 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 472 * @param SectorAddress: Sector address to erase
<> 144:ef7eb2e8f9f7 473 * @param pStatus: pointer to PCCARD status
<> 144:ef7eb2e8f9f7 474 * @retval HAL status
<> 144:ef7eb2e8f9f7 475 */
<> 144:ef7eb2e8f9f7 476 HAL_StatusTypeDef HAL_PCCARD_Erase_Sector(PCCARD_HandleTypeDef *hpccard, uint16_t SectorAddress, uint8_t *pStatus)
<> 144:ef7eb2e8f9f7 477 {
<> 144:ef7eb2e8f9f7 478 uint32_t timeout = PCCARD_TIMEOUT_ERASE_SECTOR;
<> 144:ef7eb2e8f9f7 479 uint8_t status = 0U;
<> 144:ef7eb2e8f9f7 480
<> 144:ef7eb2e8f9f7 481 /* Process Locked */
<> 144:ef7eb2e8f9f7 482 __HAL_LOCK(hpccard);
<> 144:ef7eb2e8f9f7 483
<> 144:ef7eb2e8f9f7 484 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 485 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 486 {
<> 144:ef7eb2e8f9f7 487 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 488 }
<> 144:ef7eb2e8f9f7 489
<> 144:ef7eb2e8f9f7 490 /* Update the PCCARD controller state */
<> 144:ef7eb2e8f9f7 491 hpccard->State = HAL_PCCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 492
<> 144:ef7eb2e8f9f7 493 /* Initialize PCCARD status */
<> 144:ef7eb2e8f9f7 494 *pStatus = PCCARD_READY;
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 /* Set the parameters to write a sector */
<> 144:ef7eb2e8f9f7 497 *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_CYLINDER_LOW) = 0x00U;
<> 144:ef7eb2e8f9f7 498 *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_CYLINDER_HIGH) = 0x00U;
<> 144:ef7eb2e8f9f7 499 *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_SECTOR_NUMBER) = SectorAddress;
<> 144:ef7eb2e8f9f7 500 *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_SECTOR_COUNT) = 0x01U;
<> 144:ef7eb2e8f9f7 501 *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_CARD_HEAD) = 0xA0U;
<> 144:ef7eb2e8f9f7 502 *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD) = ATA_ERASE_SECTOR_CMD;
<> 144:ef7eb2e8f9f7 503
<> 144:ef7eb2e8f9f7 504 /* wait till the PCCARD is ready */
<> 144:ef7eb2e8f9f7 505 status = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 506
<> 144:ef7eb2e8f9f7 507 while((status != PCCARD_STATUS_WRITE_OK) && timeout)
<> 144:ef7eb2e8f9f7 508 {
<> 144:ef7eb2e8f9f7 509 status = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 510 timeout--;
<> 144:ef7eb2e8f9f7 511 }
<> 144:ef7eb2e8f9f7 512
<> 144:ef7eb2e8f9f7 513 if(timeout == 0)
<> 144:ef7eb2e8f9f7 514 {
<> 144:ef7eb2e8f9f7 515 *pStatus = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 516 }
<> 144:ef7eb2e8f9f7 517
<> 144:ef7eb2e8f9f7 518 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 519 hpccard->State = HAL_PCCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 520
<> 144:ef7eb2e8f9f7 521 /* Process unlocked */
<> 144:ef7eb2e8f9f7 522 __HAL_UNLOCK(hpccard);
<> 144:ef7eb2e8f9f7 523
<> 144:ef7eb2e8f9f7 524 return HAL_OK;
<> 144:ef7eb2e8f9f7 525 }
<> 144:ef7eb2e8f9f7 526
<> 144:ef7eb2e8f9f7 527 /**
<> 144:ef7eb2e8f9f7 528 * @brief Reset the PCCARD memory
<> 144:ef7eb2e8f9f7 529 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 530 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 531 * @retval HAL status
<> 144:ef7eb2e8f9f7 532 */
<> 144:ef7eb2e8f9f7 533 HAL_StatusTypeDef HAL_PCCARD_Reset(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 534 {
<> 144:ef7eb2e8f9f7 535 /* Process Locked */
<> 144:ef7eb2e8f9f7 536 __HAL_LOCK(hpccard);
<> 144:ef7eb2e8f9f7 537
<> 144:ef7eb2e8f9f7 538 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 539 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 540 {
<> 144:ef7eb2e8f9f7 541 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 542 }
<> 144:ef7eb2e8f9f7 543
<> 144:ef7eb2e8f9f7 544 /* Provide a SW reset and Read and verify the:
<> 144:ef7eb2e8f9f7 545 - PCCard Configuration Option Register at address 0x98000200 --> 0x80
<> 144:ef7eb2e8f9f7 546 - Card Configuration and Status Register at address 0x98000202 --> 0x00
<> 144:ef7eb2e8f9f7 547 - Pin Replacement Register at address 0x98000204 --> 0x0C
<> 144:ef7eb2e8f9f7 548 - Socket and Copy Register at address 0x98000206 --> 0x00
<> 144:ef7eb2e8f9f7 549 */
<> 144:ef7eb2e8f9f7 550
<> 144:ef7eb2e8f9f7 551 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 552 hpccard->State = HAL_PCCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 553
<> 144:ef7eb2e8f9f7 554 *(__IO uint8_t *)(PCCARD_ATTRIBUTE_SPACE_ADDRESS | ATA_CARD_CONFIGURATION ) = 0x01U;
<> 144:ef7eb2e8f9f7 555
<> 144:ef7eb2e8f9f7 556 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 557 hpccard->State = HAL_PCCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 558
<> 144:ef7eb2e8f9f7 559 /* Process unlocked */
<> 144:ef7eb2e8f9f7 560 __HAL_UNLOCK(hpccard);
<> 144:ef7eb2e8f9f7 561
<> 144:ef7eb2e8f9f7 562 return HAL_OK;
<> 144:ef7eb2e8f9f7 563 }
<> 144:ef7eb2e8f9f7 564
<> 144:ef7eb2e8f9f7 565 /**
<> 144:ef7eb2e8f9f7 566 * @brief This function handles PCCARD device interrupt request.
<> 144:ef7eb2e8f9f7 567 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 568 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 569 * @retval HAL status
<> 144:ef7eb2e8f9f7 570 */
<> 144:ef7eb2e8f9f7 571 void HAL_PCCARD_IRQHandler(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 572 {
<> 144:ef7eb2e8f9f7 573 /* Check PCCARD interrupt Rising edge flag */
<> 144:ef7eb2e8f9f7 574 if(__FSMC_PCCARD_GET_FLAG(hpccard->Instance, FSMC_FLAG_RISING_EDGE))
<> 144:ef7eb2e8f9f7 575 {
<> 144:ef7eb2e8f9f7 576 /* PCCARD interrupt callback*/
<> 144:ef7eb2e8f9f7 577 HAL_PCCARD_ITCallback(hpccard);
<> 144:ef7eb2e8f9f7 578
<> 144:ef7eb2e8f9f7 579 /* Clear PCCARD interrupt Rising edge pending bit */
<> 144:ef7eb2e8f9f7 580 __FSMC_PCCARD_CLEAR_FLAG(hpccard->Instance, FSMC_FLAG_RISING_EDGE);
<> 144:ef7eb2e8f9f7 581 }
<> 144:ef7eb2e8f9f7 582
<> 144:ef7eb2e8f9f7 583 /* Check PCCARD interrupt Level flag */
<> 144:ef7eb2e8f9f7 584 if(__FSMC_PCCARD_GET_FLAG(hpccard->Instance, FSMC_FLAG_LEVEL))
<> 144:ef7eb2e8f9f7 585 {
<> 144:ef7eb2e8f9f7 586 /* PCCARD interrupt callback*/
<> 144:ef7eb2e8f9f7 587 HAL_PCCARD_ITCallback(hpccard);
<> 144:ef7eb2e8f9f7 588
<> 144:ef7eb2e8f9f7 589 /* Clear PCCARD interrupt Level pending bit */
<> 144:ef7eb2e8f9f7 590 __FSMC_PCCARD_CLEAR_FLAG(hpccard->Instance, FSMC_FLAG_LEVEL);
<> 144:ef7eb2e8f9f7 591 }
<> 144:ef7eb2e8f9f7 592
<> 144:ef7eb2e8f9f7 593 /* Check PCCARD interrupt Falling edge flag */
<> 144:ef7eb2e8f9f7 594 if(__FSMC_PCCARD_GET_FLAG(hpccard->Instance, FSMC_FLAG_FALLING_EDGE))
<> 144:ef7eb2e8f9f7 595 {
<> 144:ef7eb2e8f9f7 596 /* PCCARD interrupt callback*/
<> 144:ef7eb2e8f9f7 597 HAL_PCCARD_ITCallback(hpccard);
<> 144:ef7eb2e8f9f7 598
<> 144:ef7eb2e8f9f7 599 /* Clear PCCARD interrupt Falling edge pending bit */
<> 144:ef7eb2e8f9f7 600 __FSMC_PCCARD_CLEAR_FLAG(hpccard->Instance, FSMC_FLAG_FALLING_EDGE);
<> 144:ef7eb2e8f9f7 601 }
<> 144:ef7eb2e8f9f7 602
<> 144:ef7eb2e8f9f7 603 /* Check PCCARD interrupt FIFO empty flag */
<> 144:ef7eb2e8f9f7 604 if(__FSMC_PCCARD_GET_FLAG(hpccard->Instance, FSMC_FLAG_FEMPT))
<> 144:ef7eb2e8f9f7 605 {
<> 144:ef7eb2e8f9f7 606 /* PCCARD interrupt callback*/
<> 144:ef7eb2e8f9f7 607 HAL_PCCARD_ITCallback(hpccard);
<> 144:ef7eb2e8f9f7 608
<> 144:ef7eb2e8f9f7 609 /* Clear PCCARD interrupt FIFO empty pending bit */
<> 144:ef7eb2e8f9f7 610 __FSMC_PCCARD_CLEAR_FLAG(hpccard->Instance, FSMC_FLAG_FEMPT);
<> 144:ef7eb2e8f9f7 611 }
<> 144:ef7eb2e8f9f7 612 }
<> 144:ef7eb2e8f9f7 613
<> 144:ef7eb2e8f9f7 614 /**
<> 144:ef7eb2e8f9f7 615 * @brief PCCARD interrupt feature callback
<> 144:ef7eb2e8f9f7 616 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 617 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 618 * @retval None
<> 144:ef7eb2e8f9f7 619 */
<> 144:ef7eb2e8f9f7 620 __weak void HAL_PCCARD_ITCallback(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 621 {
<> 144:ef7eb2e8f9f7 622 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 623 UNUSED(hpccard);
<> 144:ef7eb2e8f9f7 624 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 625 the HAL_PCCARD_ITCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 626 */
<> 144:ef7eb2e8f9f7 627 }
<> 144:ef7eb2e8f9f7 628
<> 144:ef7eb2e8f9f7 629 /**
<> 144:ef7eb2e8f9f7 630 * @}
<> 144:ef7eb2e8f9f7 631 */
<> 144:ef7eb2e8f9f7 632
<> 144:ef7eb2e8f9f7 633 /** @defgroup PCCARD_Exported_Functions_Group3 State functions
<> 144:ef7eb2e8f9f7 634 * @brief Peripheral State functions
<> 144:ef7eb2e8f9f7 635 *
<> 144:ef7eb2e8f9f7 636 @verbatim
<> 144:ef7eb2e8f9f7 637 ==============================================================================
<> 144:ef7eb2e8f9f7 638 ##### PCCARD State functions #####
<> 144:ef7eb2e8f9f7 639 ==============================================================================
<> 144:ef7eb2e8f9f7 640 [..]
<> 144:ef7eb2e8f9f7 641 This subsection permits to get in run-time the status of the PCCARD controller
<> 144:ef7eb2e8f9f7 642 and the data flow.
<> 144:ef7eb2e8f9f7 643
<> 144:ef7eb2e8f9f7 644 @endverbatim
<> 144:ef7eb2e8f9f7 645 * @{
<> 144:ef7eb2e8f9f7 646 */
<> 144:ef7eb2e8f9f7 647
<> 144:ef7eb2e8f9f7 648 /**
<> 144:ef7eb2e8f9f7 649 * @brief return the PCCARD controller state
<> 144:ef7eb2e8f9f7 650 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 651 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 652 * @retval HAL state
<> 144:ef7eb2e8f9f7 653 */
<> 144:ef7eb2e8f9f7 654 HAL_PCCARD_StateTypeDef HAL_PCCARD_GetState(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 655 {
<> 144:ef7eb2e8f9f7 656 return hpccard->State;
<> 144:ef7eb2e8f9f7 657 }
<> 144:ef7eb2e8f9f7 658
<> 144:ef7eb2e8f9f7 659 /**
<> 144:ef7eb2e8f9f7 660 * @brief Get the compact flash memory status
<> 144:ef7eb2e8f9f7 661 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 662 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 663 * @retval New status of the PCCARD operation. This parameter can be:
<> 144:ef7eb2e8f9f7 664 * - CompactFlash_TIMEOUT_ERROR: when the previous operation generate
<> 144:ef7eb2e8f9f7 665 * a Timeout error
<> 144:ef7eb2e8f9f7 666 * - CompactFlash_READY: when memory is ready for the next operation
<> 144:ef7eb2e8f9f7 667 */
<> 144:ef7eb2e8f9f7 668 HAL_PCCARD_StatusTypeDef HAL_PCCARD_GetStatus(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 669 {
<> 144:ef7eb2e8f9f7 670 uint32_t timeout = PCCARD_TIMEOUT_STATUS, status_pccard = 0U;
<> 144:ef7eb2e8f9f7 671
<> 144:ef7eb2e8f9f7 672 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 673 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 674 {
<> 144:ef7eb2e8f9f7 675 return HAL_PCCARD_STATUS_ONGOING;
<> 144:ef7eb2e8f9f7 676 }
<> 144:ef7eb2e8f9f7 677
<> 144:ef7eb2e8f9f7 678 status_pccard = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 679
<> 144:ef7eb2e8f9f7 680 while((status_pccard == PCCARD_BUSY) && timeout)
<> 144:ef7eb2e8f9f7 681 {
<> 144:ef7eb2e8f9f7 682 status_pccard = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 683 timeout--;
<> 144:ef7eb2e8f9f7 684 }
<> 144:ef7eb2e8f9f7 685
<> 144:ef7eb2e8f9f7 686 if(timeout == 0)
<> 144:ef7eb2e8f9f7 687 {
<> 144:ef7eb2e8f9f7 688 status_pccard = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 689 }
<> 144:ef7eb2e8f9f7 690
<> 144:ef7eb2e8f9f7 691 /* Return the operation status */
<> 144:ef7eb2e8f9f7 692 return (HAL_PCCARD_StatusTypeDef) status_pccard;
<> 144:ef7eb2e8f9f7 693 }
<> 144:ef7eb2e8f9f7 694
<> 144:ef7eb2e8f9f7 695 /**
<> 144:ef7eb2e8f9f7 696 * @brief Reads the Compact Flash memory status using the Read status command
<> 144:ef7eb2e8f9f7 697 * @param hpccard: pointer to a PCCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 698 * the configuration information for PCCARD module.
<> 144:ef7eb2e8f9f7 699 * @retval The status of the Compact Flash memory. This parameter can be:
<> 144:ef7eb2e8f9f7 700 * - CompactFlash_BUSY: when memory is busy
<> 144:ef7eb2e8f9f7 701 * - CompactFlash_READY: when memory is ready for the next operation
<> 144:ef7eb2e8f9f7 702 * - CompactFlash_ERROR: when the previous operation generates error
<> 144:ef7eb2e8f9f7 703 */
<> 144:ef7eb2e8f9f7 704 HAL_PCCARD_StatusTypeDef HAL_PCCARD_ReadStatus(PCCARD_HandleTypeDef *hpccard)
<> 144:ef7eb2e8f9f7 705 {
<> 144:ef7eb2e8f9f7 706 uint8_t data = 0, status_pccard = PCCARD_BUSY;
<> 144:ef7eb2e8f9f7 707
<> 144:ef7eb2e8f9f7 708 /* Check the PCCARD controller state */
<> 144:ef7eb2e8f9f7 709 if(hpccard->State == HAL_PCCARD_STATE_BUSY)
<> 144:ef7eb2e8f9f7 710 {
<> 144:ef7eb2e8f9f7 711 return HAL_PCCARD_STATUS_ONGOING;
<> 144:ef7eb2e8f9f7 712 }
<> 144:ef7eb2e8f9f7 713
<> 144:ef7eb2e8f9f7 714 /* Read status operation */
<> 144:ef7eb2e8f9f7 715 data = *(__IO uint8_t *)(PCCARD_IO_SPACE_PRIMARY_ADDR | ATA_STATUS_CMD_ALTERNATE);
<> 144:ef7eb2e8f9f7 716
<> 144:ef7eb2e8f9f7 717 if((data & PCCARD_TIMEOUT_ERROR) == PCCARD_TIMEOUT_ERROR)
<> 144:ef7eb2e8f9f7 718 {
<> 144:ef7eb2e8f9f7 719 status_pccard = PCCARD_TIMEOUT_ERROR;
<> 144:ef7eb2e8f9f7 720 }
<> 144:ef7eb2e8f9f7 721 else if((data & PCCARD_READY) == PCCARD_READY)
<> 144:ef7eb2e8f9f7 722 {
<> 144:ef7eb2e8f9f7 723 status_pccard = PCCARD_READY;
<> 144:ef7eb2e8f9f7 724 }
<> 144:ef7eb2e8f9f7 725
<> 144:ef7eb2e8f9f7 726 return (HAL_PCCARD_StatusTypeDef) status_pccard;
<> 144:ef7eb2e8f9f7 727 }
<> 144:ef7eb2e8f9f7 728
<> 144:ef7eb2e8f9f7 729 /**
<> 144:ef7eb2e8f9f7 730 * @}
<> 144:ef7eb2e8f9f7 731 */
<> 144:ef7eb2e8f9f7 732
<> 144:ef7eb2e8f9f7 733 /**
<> 144:ef7eb2e8f9f7 734 * @}
<> 144:ef7eb2e8f9f7 735 */
<> 144:ef7eb2e8f9f7 736
<> 144:ef7eb2e8f9f7 737 #endif /* HAL_PCCARD_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 738
<> 144:ef7eb2e8f9f7 739 /**
<> 144:ef7eb2e8f9f7 740 * @}
<> 144:ef7eb2e8f9f7 741 */
<> 144:ef7eb2e8f9f7 742
<> 144:ef7eb2e8f9f7 743 /**
<> 144:ef7eb2e8f9f7 744 * @}
<> 144:ef7eb2e8f9f7 745 */
<> 144:ef7eb2e8f9f7 746
<> 144:ef7eb2e8f9f7 747 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/