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