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

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