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_STM32F1/device/stm32f1xx_hal_pccard.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
187:0387e8f68319 
mbed library release version 165

Who changed what in which revision?

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