begriffs open source - cmsis-driver-validation/blob - Source/DV_MCI.c

   1 /*
   2  * Copyright (c) 2015-2020 Arm Limited. All rights reserved.
   3  *
   4  * SPDX-License-Identifier: Apache-2.0
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License); you may
   7  * not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  14  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * -----------------------------------------------------------------------------
  19  *
  20  * Project:     CMSIS-Driver Validation
  21  * Title:       Memory Card Interface (MCI) Driver Validation tests
  22  *
  23  * -----------------------------------------------------------------------------
  24  */
  25
  26
  27 #include "cmsis_dv.h"
  28 #include "DV_MCI_Config.h"
  29 #include "DV_Framework.h"
  30 #include "Driver_MCI.h"
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 // Register Driver_USBD#
  36 extern ARM_DRIVER_MCI CREATE_SYMBOL(Driver_MCI, DRV_MCI);
  37 static ARM_DRIVER_MCI *drv = &CREATE_SYMBOL(Driver_MCI, DRV_MCI);
  38 static ARM_MCI_CAPABILITIES capab;
  39
  40 // Event flags
  41 static uint8_t volatile Event;
  42
  43 // MCI event
  44 static void MCI_DrvEvent (uint32_t event) {
  45   Event |= event;
  46 }
  47
  48 /*-----------------------------------------------------------------------------
  49  *      Tests
  50  *----------------------------------------------------------------------------*/
  51
  52 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  53 /**
  54 \defgroup dv_mci MCI Validation
  55 \brief MCI driver validation
  56 \details
  57 The MCI validation test checks the API interface compliance only.
  58
  59 \defgroup mci_tests Tests
  60 \ingroup dv_mci
  61
  62 @{
  63 */
  64
  65 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  66 /**
  67 \brief Function: MCI_GetCapabilities
  68 \details
  69 The test function \b MCI_GetCapabilities verifies the function \b GetCapabilities.
  70 */
  71 void MCI_GetCapabilities (void) {
  72   /* Get USBD capabilities */
  73   capab = drv->GetCapabilities();
  74   TEST_ASSERT(&capab != NULL);
  75 }
  76
  77 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  78 /**
  79 \brief  Function: MCI_Initialization
  80 \details
  81 The test function \b MCI_Initialization verifies the MCI functions with the sequence:
  82   - \b Initialize without callback
  83   - \b Uninitialize
  84   - \b Initialize with callback
  85   - \b Uninitialize
  86 */
  87 void MCI_Initialization (void) {
  88
  89   /* Initialize without callback */
  90   TEST_ASSERT(drv->Initialize(NULL) == ARM_DRIVER_OK);
  91
  92   /* Uninitialize */
  93   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
  94
  95   /* Initialize with callback */
  96   TEST_ASSERT(drv->Initialize(MCI_DrvEvent) == ARM_DRIVER_OK);
  97
  98   /* Uninitialize */
  99   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 100 }
 101
 102 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 103 /**
 104 \brief  Function: MCI_CheckInvalidInit
 105 \details
 106 The test function \b MCI_CheckInvalidInit verifies the driver behaviour when receiving an invalid initialization sequence:
 107   - \b Uninitialize
 108   - \b PowerControl with Power off
 109   - \b PowerControl with Power on
 110   - \b PowerControl with Power off
 111   - \b Uninitialize
 112 */
 113 void MCI_CheckInvalidInit (void) {
 114
 115   /* Uninitialize */
 116   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 117
 118   /* Power off */
 119   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 120
 121   /* Try to power on */
 122   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) != ARM_DRIVER_OK);
 123
 124   /* Power off */
 125   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 126
 127   /* Uninitialize */
 128   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 129 }
 130
 131 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 132 /**
 133 \brief  Function: MCI_PowerControl
 134 \details
 135 The test function \b MCI_PowerControl verifies the \b PowerControl function with the sequence:
 136  - Initialize
 137  - Power on
 138  - Power low
 139  - Power off
 140  - Uninitialize
 141 */
 142 void MCI_PowerControl (void) {
 143   int32_t val;
 144
 145   /* Initialize with callback */
 146   TEST_ASSERT(drv->Initialize(MCI_DrvEvent) == ARM_DRIVER_OK);
 147
 148   /* Power on */
 149   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 150
 151   /* Power low */
 152   val = drv->PowerControl (ARM_POWER_LOW);
 153   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Low power is not supported"); }
 154   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 155
 156   /* Power off */
 157   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 158
 159   /* Uninitialize */
 160   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 161 }
 162
 163 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 164 /**
 165 \brief  Function: MCI_SetBusSpeedMode
 166 \details
 167 The test function \b MCI_SetBusSpeedMode verifies the \b Control function and sets the bus speed with the sequence:
 168  - Initialize
 169  - Power on
 170  - default speed
 171  - high speed
 172  - SDR12 speed
 173  - SDR25 speed
 174  - SDR50 speed
 175  - SDR104 speed
 176  - DDR50 speed
 177  - Power off
 178  - Uninitialize
 179 */
 180 void MCI_SetBusSpeedMode (void) {
 181   int32_t val;
 182
 183   /* Initialize with callback and power on*/
 184   TEST_ASSERT(drv->Initialize(MCI_DrvEvent) == ARM_DRIVER_OK);
 185   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 186
 187   /* Default speed */
 188   TEST_ASSERT(drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_DEFAULT_SPEED ) == ARM_DRIVER_OK);
 189
 190   /* High speed */
 191   val = drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_DEFAULT_SPEED );
 192   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] High speed is not supported"); }
 193   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 194
 195   /* SDR12 speed */
 196   val = drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_UHS_SDR12 );
 197   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] SDR12 is not supported"); }
 198   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 199
 200   /* SDR25 speed */
 201   val = drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_UHS_SDR25 );
 202   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] SDR25 is not supported"); }
 203   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 204
 205   /* SDR50 speed */
 206   val = drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_UHS_SDR50 );
 207   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] SDR50 is not supported"); }
 208   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 209
 210   /* SDR104 speed */
 211   val = drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_UHS_SDR104 );
 212   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] SDR104 is not supported"); }
 213   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 214
 215   /* DDR50 speed */
 216   val = drv->Control (ARM_MCI_BUS_SPEED_MODE, ARM_MCI_BUS_UHS_DDR50 );
 217   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] DDR50 is not supported"); }
 218   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 219
 220   /* Power off and uninitialize*/
 221   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 222   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 223 }
 224
 225 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 226 /**
 227 \brief  Function: MCI_Config_DataWidth
 228 \details
 229 The test function \b MCI_Config_DataWidth verifies the \b Control function and set the data width with the sequence:
 230  - Initialize
 231  - Power on
 232  - Default data width \token{1}
 233  - Data width \token{4}
 234  - Data width \token{8}
 235  - Data width \token{4 DDR}
 236  - Data width \token{8 DDR}
 237  - Power off
 238  - Uninitialize
 239 */
 240 void MCI_Config_DataWidth (void) {
 241   int32_t val;
 242
 243   /* Initialize with callback and power on*/
 244   TEST_ASSERT(drv->Initialize(MCI_DrvEvent) == ARM_DRIVER_OK);
 245   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 246
 247   /* Default data width 1 */
 248   TEST_ASSERT(drv->Control (ARM_MCI_BUS_DATA_WIDTH, ARM_MCI_BUS_DATA_WIDTH_1 ) == ARM_DRIVER_OK);
 249
 250   /* Data width 4 */
 251   val = drv->Control (ARM_MCI_BUS_DATA_WIDTH, ARM_MCI_BUS_DATA_WIDTH_4 );
 252   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Data width 4 is not supported"); }
 253   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 254
 255   /* Data width 8 */
 256   val = drv->Control (ARM_MCI_BUS_DATA_WIDTH, ARM_MCI_BUS_DATA_WIDTH_8 );
 257   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Data width 8 is not supported"); }
 258   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 259
 260   /* Data width 4 DDR */
 261   val = drv->Control (ARM_MCI_BUS_DATA_WIDTH, ARM_MCI_BUS_DATA_WIDTH_4_DDR );
 262   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Data width 4 DDR is not supported"); }
 263   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 264
 265   /* Data width 8 DDR */
 266   val = drv->Control (ARM_MCI_BUS_DATA_WIDTH, ARM_MCI_BUS_DATA_WIDTH_8_DDR );
 267   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Data width 8 DDR is not supported"); }
 268   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 269
 270   /* Power off and uninitialize*/
 271   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 272   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 273 }
 274
 275 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 276 /**
 277 \brief  Function: MCI_Config_CmdLineMode
 278 \details
 279 The test function \b MCI_Config_CmdLineMode verifies the \b Control function with the sequence:
 280  - Initialize
 281  - Power on
 282  - Default push-pull
 283  - Open Drain
 284  - Power off
 285  - Uninitialize
 286 */
 287 void MCI_Config_CmdLineMode (void) {
 288   int32_t val;
 289
 290   /* Initialize with callback and power on*/
 291   TEST_ASSERT(drv->Initialize(MCI_DrvEvent) == ARM_DRIVER_OK);
 292   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 293
 294   /* Default push-pull */
 295   TEST_ASSERT(drv->Control (ARM_MCI_BUS_CMD_MODE, ARM_MCI_BUS_CMD_PUSH_PULL  ) == ARM_DRIVER_OK);
 296
 297   /* Open Drain */
 298   val = drv->Control (ARM_MCI_BUS_CMD_MODE, ARM_MCI_BUS_CMD_OPEN_DRAIN );
 299   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Open Drain Cmd is not supported"); }
 300   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 301
 302   /* Power off and uninitialize*/
 303   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 304   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 305 }
 306
 307 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 308 /**
 309 \brief  Function: MCI_Config_DriverStrength
 310 \details
 311 The test function \b MCI_Config_DriverStrength verifies the \b Control function and sets the driver strength with the sequence:
 312  - Initialize
 313  - Power on
 314  - Type A
 315  - Type B
 316  - Type C
 317  - Type D
 318  - Power off
 319  - Uninitialize
 320 */
 321 void MCI_Config_DriverStrength (void) {
 322   int32_t val;
 323
 324   /* Initialize with callback and power on*/
 325   TEST_ASSERT(drv->Initialize(MCI_DrvEvent) == ARM_DRIVER_OK);
 326   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 327
 328   /* Type A */
 329   val = drv->Control ( ARM_MCI_DRIVER_STRENGTH, ARM_MCI_DRIVER_TYPE_A );
 330   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Type A is not supported"); }
 331   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 332
 333   /* Type B */
 334   val = drv->Control ( ARM_MCI_DRIVER_STRENGTH, ARM_MCI_DRIVER_TYPE_B );
 335   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Type B is not supported"); }
 336   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 337
 338   /* Type C */
 339   val = drv->Control ( ARM_MCI_DRIVER_STRENGTH, ARM_MCI_DRIVER_TYPE_C );
 340   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Type C is not supported"); }
 341   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 342
 343   /* Type D */
 344   val = drv->Control ( ARM_MCI_DRIVER_STRENGTH, ARM_MCI_DRIVER_TYPE_D );
 345   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Type D is not supported"); }
 346   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 347
 348   /* Power off and uninitialize*/
 349   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 350   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 351 }
 352
 353 /**
 354 @}
 355 */
 356 // end of group dv_mci