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

   1 /*-----------------------------------------------------------------------------
   2  *      Name:         DV_SPI.c
   3  *      Purpose:      SPI 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_SPI.h"
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 // SPI buffer type
  16 #if (SPI_DATA_BITS>16U)
  17 typedef uint32_t buf_t;
  18 #elif (SPI_DATA_BITS>8U)
  19 typedef uint16_t buf_t;
  20 #else
  21 typedef uint8_t buf_t;
  22 #endif
  23
  24 // SPI buffer pointers
  25 static buf_t *buffer_out;
  26 static buf_t *buffer_in;
  27
  28 // SPI baudrates (kHz)
  29 static const uint32_t SPI_BR[] =  {
  30 #if (SPI_BR_1>0)
  31   SPI_BR_1,
  32 #endif
  33 #if (SPI_BR_2>0)
  34   SPI_BR_2,
  35 #endif
  36 #if (SPI_BR_3>0)
  37   SPI_BR_3,
  38 #endif
  39 #if (SPI_BR_4>0)
  40   SPI_BR_4,
  41 #endif
  42 #if (SPI_BR_5>0)
  43   SPI_BR_5,
  44 #endif
  45 #if (SPI_BR_6>0)
  46   SPI_BR_6,
  47 #endif
  48 };
  49 static const uint32_t SPI_BR_NUM = ARRAY_SIZE(SPI_BR);
  50
  51 // Register Driver_SPI#
  52 extern ARM_DRIVER_SPI CREATE_SYMBOL(Driver_SPI, DRV_SPI);
  53 static ARM_DRIVER_SPI *drv = &CREATE_SYMBOL(Driver_SPI, DRV_SPI);
  54 static ARM_SPI_CAPABILITIES capab;
  55
  56 static char str[128];
  57
  58 // Event flags
  59 static uint8_t volatile Event;
  60
  61 // SPI event
  62 static void SPI_DrvEvent (uint32_t event) {
  63   Event |= event;
  64 }
  65
  66 // SPI transfer
  67 int8_t SPI_RunTransfer (void *out, void *in, uint32_t cnt);
  68 int8_t SPI_RunTransfer (void *out, void *in, uint32_t cnt) {
  69   uint32_t tick;
  70
  71   Event &= ~ARM_SPI_EVENT_TRANSFER_COMPLETE;
  72   drv->Transfer (out, in, cnt);
  73
  74   tick = GET_SYSTICK();
  75   do {
  76     if (Event & ARM_SPI_EVENT_TRANSFER_COMPLETE) {
  77       return 0;
  78     }
  79   }
  80   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
  81
  82   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
  83   return -1;
  84 }
  85
  86 // SPI send
  87 int8_t SPI_RunSend (void *out, uint32_t cnt);
  88 int8_t SPI_RunSend (void *out, uint32_t cnt) {
  89   uint32_t tick;
  90
  91   Event &= ~ARM_SPI_EVENT_TRANSFER_COMPLETE;
  92   drv->Send (out, cnt);
  93
  94   tick = GET_SYSTICK();
  95   do {
  96     if (Event & ARM_SPI_EVENT_TRANSFER_COMPLETE) {
  97       return 0;
  98     }
  99   }
 100   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 101
 102   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 103   return -1;
 104 }
 105
 106 // SPI send without callback
 107 int8_t SPI_RunSend_NoCallback (void *out, uint32_t cnt);
 108 int8_t SPI_RunSend_NoCallback (void *out, uint32_t cnt) {
 109   uint32_t tick;
 110
 111   drv->Send (out, cnt);
 112
 113   tick = GET_SYSTICK();
 114   do {
 115     if (drv->GetDataCount() == cnt) {
 116       return 0;
 117     }
 118     if (drv->GetStatus().data_lost) {
 119       return -1;
 120     }
 121   }
 122   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 123
 124   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 125   return -1;
 126 }
 127
 128 // SPI receive
 129 int8_t SPI_RunReceive (void *in, uint32_t cnt);
 130 int8_t SPI_RunReceive (void *in, uint32_t cnt) {
 131   uint32_t tick;
 132
 133   Event &= ~ARM_SPI_EVENT_TRANSFER_COMPLETE;
 134   drv->Receive (in, cnt);
 135
 136   tick = GET_SYSTICK();
 137   do {
 138     if (Event & ARM_SPI_EVENT_TRANSFER_COMPLETE) {
 139       return 0;
 140     }
 141   }
 142   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 143
 144   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 145   return -1;
 146 }
 147
 148 // SPI receive
 149 int8_t SPI_RunReceiveNoCallback (void *in, uint32_t cnt);
 150 int8_t SPI_RunReceiveNoCallback (void *in, uint32_t cnt) {
 151   uint32_t tick;
 152
 153   Event &= ~0x01;
 154   drv->Receive (in, cnt);
 155
 156   tick = GET_SYSTICK();
 157   do {
 158     if (drv->GetDataCount() == cnt) {
 159       return 0;
 160     }
 161     if (drv->GetStatus().data_lost) {
 162       return -1;
 163     }
 164   }
 165   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 166
 167   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 168   return -1;
 169 }
 170
 171 /*-----------------------------------------------------------------------------
 172  *      Test cases
 173  *----------------------------------------------------------------------------*/
 174
 175 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 176 /**
 177 \defgroup spi_funcs SPI Validation
 178 \brief SPI test cases
 179 \details
 180 The SPI validation test performs the following checks:
 181 - API interface compliance.
 182 - Data communication with various transfer sizes and communication parameters.
 183 - Transfer speed of the data communication.
 184 - Loopback communication.
 185
 186 \anchor spi_loop_back_setup
 187 Loopback Communication Setup
 188 ----------------------------
 189
 190 To perform loopback communication tests, it is required to connect the SPI's \b MISO signal to the \b MOSI signal (refer to
 191 the schematics of your target hardware for detailed pinout information).
 192 @{
 193 */
 194
 195 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 196 /**
 197 \brief Test case: SPI_GetCapabilities
 198 \details
 199 The test case \b SPI_GetCapabilities verifies the function \b GetCapabilities.
 200 */
 201 void SPI_GetCapabilities (void) {
 202   /* Get SPI capabilities */
 203   capab = drv->GetCapabilities();
 204   TEST_ASSERT(&capab != NULL);
 205 }
 206
 207 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 208 /**
 209 \brief  Test case: SPI_Initialization
 210 \details
 211 The test case \b SPI_Initialization verifies the SPI functions with the sequence:
 212   - \b Initialize without callback
 213   - \b Uninitialize
 214   - \b Initialize with callback
 215   - \b Uninitialize
 216 */
 217 void SPI_Initialization (void) {
 218
 219   /* Initialize without callback */
 220   TEST_ASSERT(drv->Initialize(NULL) == ARM_DRIVER_OK);
 221
 222   /* Uninitialize */
 223   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 224
 225   /* Initialize with callback */
 226   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 227
 228   /* Uninitialize */
 229   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 230 }
 231
 232 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 233 /**
 234 \brief  Test case: SPI_CheckInvalidInit
 235 \details
 236 The test case \b SPI_CheckInvalidInit verifies the driver behaviour when receiving an invalid initialization sequence:
 237   - \b Uninitialize
 238   - \b PowerControl with Power off
 239   - \b PowerControl with Power on
 240   - \b Control
 241   - \b PowerControl with Power off
 242   - \b Uninitialize
 243 */
 244 void SPI_CheckInvalidInit (void) {
 245
 246   /* Uninitialize */
 247   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 248
 249   /* Power off */
 250   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 251
 252   /* Try to power on */
 253   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) != ARM_DRIVER_OK);
 254
 255   /* Try to set configuration */
 256   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(8) | ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000)
 257     != ARM_DRIVER_OK);
 258
 259   /* Power off */
 260   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 261
 262   /* Uninitialize */
 263   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 264 }
 265
 266 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 267 /**
 268 \brief  Test case: SPI_PowerControl
 269 \details
 270 The test case \b SPI_PowerControl verifies the \b PowerControl function with the sequence:
 271  - Initialize with callback
 272  - Power on
 273  - Power low
 274  - Power off
 275  - Uninitialize
 276 */
 277 void SPI_PowerControl (void) {
 278   int32_t val;
 279
 280   /* Initialize with callback */
 281   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 282
 283   /* Power on */
 284   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 285
 286   /* Power low */
 287   val = drv->PowerControl (ARM_POWER_LOW);
 288   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Low power is not supported"); }
 289   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 290
 291   /* Power off */
 292   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 293
 294   /* Uninitialize */
 295   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 296
 297 }
 298
 299 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 300 /**
 301 \brief  Test case: SPI_Config_PolarityPhase
 302 \details
 303 The test case \b SPI_Config_PolarityPhase verifies the \b Control function with the sequence:
 304  - Initialize with callback
 305  - Power on
 306  - Set basic SPI bus configuration
 307  - Change polarity
 308  - Change phase
 309  - Change polarity and phase
 310  - Power off
 311  - Uninitialize
 312 */
 313 void SPI_Config_PolarityPhase (void) {
 314
 315   /* Initialize with callback and power on*/
 316   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 317   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 318
 319   /* Set basic SPI bus configuration*/
 320   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS), SPI_BR[0]*1000) == ARM_DRIVER_OK);
 321
 322   /* Change polarity */
 323   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL1_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS), SPI_BR[0]*1000) == ARM_DRIVER_OK);
 324
 325   /* Change phase */
 326   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA1 | ARM_SPI_DATA_BITS(SPI_DATA_BITS), SPI_BR[0]*1000) == ARM_DRIVER_OK);
 327
 328   /* Change polarity and phase */
 329   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL1_CPHA1 | ARM_SPI_DATA_BITS(SPI_DATA_BITS), SPI_BR[0]*1000) == ARM_DRIVER_OK);
 330
 331   /* Power off and uninitialize*/
 332   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 333   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 334 }
 335
 336 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 337 /**
 338 \brief  Test case: SPI_Config_DataBits
 339 \details
 340 The test case \b SPI_Config_DataBits verifies the \b Control function with the sequence:
 341  - Initialize with callback
 342  - Power on
 343  - Data bits = \token{8}
 344  - Data bits = \token{16}
 345  - Power off
 346  - Uninitialize
 347 */
 348 void SPI_Config_DataBits (void) {
 349   int32_t val;
 350
 351   /* Initialize with callback and power on*/
 352   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 353   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 354
 355   /* Data bits = 8 */
 356   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(8), SPI_BR[0]*1000);
 357   if (val == ARM_SPI_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 8 are not supported"); }
 358   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 359
 360   /* Data bits = 16 */
 361   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(16), SPI_BR[0]*1000);
 362   if (val == ARM_SPI_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 16 are not supported"); }
 363   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 364
 365   /* Power off and uninitialize*/
 366   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 367   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 368 }
 369
 370 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 371 /**
 372 \brief  Test case: SPI_Config_BitOrder
 373 \details
 374 The test case \b SPI_Config_BitOrder verifies the \b Control function with the sequence:
 375  - Initialize with callback
 376  - Power on
 377  - Bit order LSB_MSB
 378  - Bit order MSB_LSB
 379  - Power off
 380  - Uninitialize
 381 */
 382 void SPI_Config_BitOrder (void) {
 383   int32_t val;
 384
 385   /* Initialize with callback and power on*/
 386   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 387   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 388
 389   /* Bit order LSB_MSB */
 390   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(8) | ARM_SPI_LSB_MSB, SPI_BR[0]*1000);
 391   if (val == ARM_SPI_ERROR_BIT_ORDER) { TEST_MESSAGE("[WARNING] Bit order LSB_MSB is not supported"); }
 392   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 393
 394   /* Bit order MSB_LSB */
 395   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(8) | ARM_SPI_MSB_LSB, SPI_BR[0]*1000);
 396   if (val == ARM_SPI_ERROR_BIT_ORDER) { TEST_MESSAGE("[WARNING] Bit order MSB_LSB is not supported"); }
 397   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 398
 399   /* Power off and uninitialize*/
 400   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 401   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 402 }
 403
 404 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 405 /**
 406 \brief  Test case: SPI_Config_SSMode
 407 \details
 408 The test case \b SPI_Config_SSMode verifies the \b Control function with the sequence:
 409  - Initialize with callback
 410  - Power on
 411  - SS Mode MASTER_HW_OUTPUT
 412  - SS Mode MASTER_HW_INPUT
 413  - SS Mode MASTER_SW
 414  - Power off
 415  - Uninitialize
 416 */
 417 void SPI_Config_SSMode (void) {
 418   int32_t val;
 419
 420   /* Initialize with callback and power on*/
 421   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 422   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 423
 424   /* SS Mode MASTER_HW_OUTPUT */
 425   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(8) | ARM_SPI_SS_MASTER_HW_OUTPUT, SPI_BR[0]*1000);
 426   if (val == ARM_SPI_ERROR_SS_MODE) { TEST_MESSAGE("[WARNING] Slave select MASTER_HW_OUTPUT is not supported"); }
 427   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 428
 429   /* SS Mode MASTER_HW_INPUT */
 430   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(8) | ARM_SPI_SS_MASTER_HW_INPUT, SPI_BR[0]*1000);
 431   if (val == ARM_SPI_ERROR_SS_MODE) { TEST_MESSAGE("[WARNING] Slave select MASTER_HW_INPUT is not supported"); }
 432   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 433
 434   /* SS Mode MASTER_SW */
 435   val = drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(8) | ARM_SPI_SS_MASTER_SW, SPI_BR[0]*1000);
 436   if (val == ARM_SPI_ERROR_SS_MODE) { TEST_MESSAGE("[WARNING] Slave select MASTER_SW is not supported"); }
 437   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 438
 439   /* Power off and uninitialize*/
 440   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 441   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 442 }
 443
 444 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 445 /**
 446 \brief  Test case: SPI_Config_CommonParams
 447 \details
 448 The test case \b SPI_Config_CommonParams verifies the \b Control function with the sequence:
 449  - Initialize with callback
 450  - Power on
 451  - Configure SPI bus
 452  - Power off
 453  - Uninitialize
 454 */
 455 void  SPI_Config_CommonParams (void) {
 456
 457   /* Initialize with callback and power on*/
 458   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 459   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 460
 461   /* Configure SPI bus */
 462   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS) |
 463     ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000) == ARM_DRIVER_OK);
 464
 465   /* Power off and uninitialize*/
 466   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 467   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 468 }
 469
 470 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 471 /**
 472 \brief  Test case: SPI_Config_BusSpeed
 473 \details
 474 The test case \b SPI_Config_BusSpeed verifies the \b Control function and tests bus speeds with the sequence:
 475  - Initialize with callback
 476  - Power on
 477  - Change bus speed with specific control parameter
 478  - Read bus speed
 479  - Change bus speed with general control parameter
 480  - Read bus speed
 481  - Power off
 482  - Uninitialize
 483
 484  \note Typically, the SPI bus speed is limited to a maximum number. This means that for a bus speed of 25 MHz, values below
 485  25 MHz are also acceptable. If this test returns a higher value than the one that is being set, you need to check the
 486  driver.
 487 */
 488 void SPI_Config_BusSpeed (void) {
 489   int32_t val;
 490   uint32_t speed;
 491
 492   /* Initialize with callback, power on and configure SPI bus */
 493   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 494   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 495   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS) |
 496     ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000) == ARM_DRIVER_OK);
 497
 498   /* Test bus speeds */
 499   for (speed=0; speed<SPI_BR_NUM; speed++) {
 500
 501     /* Change bus speed with specific control parameter*/
 502     TEST_ASSERT (drv->Control(ARM_SPI_SET_BUS_SPEED, SPI_BR[speed]*1000)
 503        == ARM_DRIVER_OK);
 504
 505     /* Read bus speed */
 506     val = drv->Control(ARM_SPI_GET_BUS_SPEED,0)/1000;
 507     if ((uint32_t)val != SPI_BR[speed]) {
 508       snprintf(str,sizeof(str),"[WARNING] Specific control set speed: %dkHz, Get speed: %dkHz",SPI_BR[speed], val);
 509       TEST_MESSAGE(str);
 510     } else TEST_PASS();
 511
 512     /* Change bus speed with general control parameter*/
 513     TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(8) | ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_SW, SPI_BR[speed]*1000)
 514        == ARM_DRIVER_OK);
 515
 516     /* Read bus speed */
 517     val = drv->Control(ARM_SPI_GET_BUS_SPEED,0)/1000;
 518     if ((uint32_t)val != SPI_BR[speed]) {
 519       snprintf(str,sizeof(str),"[WARNING] General control set speed: %dkHz, Get speed: %dkHz",SPI_BR[speed], val);
 520       TEST_MESSAGE(str);
 521     } else TEST_PASS();
 522
 523   }
 524
 525   /* Power off and uninitialize*/
 526   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 527   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 528 }
 529
 530 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 531 /**
 532 \brief  Test case: SPI_Send
 533 \details
 534 The test case \b SPI_Send verifies the function \b Send with the sequence:
 535  - Initialize with callback
 536  - Power on
 537  - Send using callback
 538  - Send without callback
 539  - Power off
 540  - Uninitialize
 541 */
 542 void SPI_Send (void) {
 543   uint16_t cnt;
 544
 545   /* Allocate buffer */
 546   buffer_out = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 547   TEST_ASSERT(buffer_out != NULL);
 548
 549   /* Initialize with callback, power on and configure SPI bus */
 550   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 551   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 552   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS) |
 553     ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000) == ARM_DRIVER_OK);
 554
 555   /* Send data chunks */
 556   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 557
 558     /* Send using callback */
 559     if (SPI_RunSend(buffer_out, BUFFER[cnt]) != ARM_DRIVER_OK) {
 560       snprintf(str,sizeof(str),"[FAILED] Fail to send %d bytes",BUFFER[cnt]);
 561       TEST_FAIL_MESSAGE(str);
 562     } else TEST_PASS();
 563
 564     /* Send without callback */
 565     if (SPI_RunSend_NoCallback(buffer_out, BUFFER[cnt]) != ARM_DRIVER_OK) {
 566       snprintf(str,sizeof(str),"[FAILED] Fail to send without callback %d bytes",BUFFER[cnt]);
 567       TEST_FAIL_MESSAGE(str);
 568     } else TEST_PASS();
 569   }
 570
 571   /* Power off and uninitialize*/
 572   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 573   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 574
 575   /* Free buffer */
 576   free(buffer_out);
 577 }
 578
 579 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 580 /**
 581 \brief  Test case: SPI_Receive
 582 \details
 583 The test case \b SPI_Receive verifies the function \b Receive with the sequence:
 584  - Initialize with callback
 585  - Power on
 586  - Receive using callback
 587  - Receive without callback
 588  - Power off
 589  - Uninitialize
 590 */
 591 void SPI_Receive (void) {
 592   uint16_t cnt;
 593
 594   /* Allocate buffer */
 595   buffer_in = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 596   TEST_ASSERT(buffer_in != NULL);
 597
 598   /* Initialize with callback, power on and configure SPI bus */
 599   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 600   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 601   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS) |
 602     ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000) == ARM_DRIVER_OK);
 603
 604   /* Receive data chunks */
 605   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 606
 607     /* Receive using callback */
 608     if (SPI_RunReceive(buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 609       snprintf(str,sizeof(str),"[FAILED] Fail to receive %d bytes",BUFFER[cnt]);
 610       TEST_FAIL_MESSAGE(str);
 611     } else TEST_PASS();
 612
 613     /* Receive without callback */
 614     if (SPI_RunReceiveNoCallback(buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 615       snprintf(str,sizeof(str),"[FAILED] Fail to receive without callback %d bytes",BUFFER[cnt]);
 616       TEST_FAIL_MESSAGE(str);
 617     } else TEST_PASS();
 618   }
 619
 620   /* Power off and uninitialize*/
 621   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 622   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 623
 624   /* Free buffer */
 625   free(buffer_in);
 626 }
 627
 628 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 629 /**
 630 \brief  Test case: SPI_Loopback_CheckBusSpeed
 631 \details
 632 The test case \b SPI_Loopback_CheckBusSpeed verifies the \b Control function, configures various bus speeds, and measures
 633 the transfer time with this sequence:
 634  - Initialize with callback
 635  - Power on
 636  - Change bus speed with specific control parameter
 637  - Measure transfer time
 638  - Power off
 639  - Uninitialize
 640
 641  \note If this test issues errors or warnings, refer to the \ref test_results section for more information.
 642 */
 643 void SPI_Loopback_CheckBusSpeed (void) {
 644   uint16_t cnt;
 645   int32_t val;
 646   uint32_t speed;
 647   uint32_t ticks_measured;
 648   uint32_t ticks_expected;
 649   double rate;
 650
 651   /* Allocate buffer */
 652   buffer_out = malloc(BUFFER_SIZE_BR*sizeof(buf_t));
 653   TEST_ASSERT(buffer_out != NULL);
 654   buffer_in = malloc(BUFFER_SIZE_BR*sizeof(buf_t));
 655   TEST_ASSERT(buffer_in != NULL);
 656
 657   /* Initialize with callback, power on and configure SPI bus */
 658   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 659   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 660   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS) |
 661     ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000) == ARM_DRIVER_OK);
 662
 663   /* Set Local Loopback */
 664   SPI_LOCAL_LOOPBACK();
 665
 666   /* Test bus speeds */
 667   for (speed=0; speed<SPI_BR_NUM; speed++) {
 668
 669     /* Set output buffer with random data */
 670     srand(GET_SYSTICK());
 671     for (cnt = 0; cnt<BUFFER_SIZE_BR; cnt++) {
 672       buffer_out[cnt] = (buf_t)rand()&((1U<<SPI_DATA_BITS)-1U);
 673     }
 674
 675     /* Change bus speed with specific control parameter*/
 676     TEST_ASSERT (drv->Control(ARM_SPI_SET_BUS_SPEED, SPI_BR[speed]*1000)
 677        == ARM_DRIVER_OK);
 678
 679     /* Read bus speed */
 680     val = drv->Control(ARM_SPI_GET_BUS_SPEED,0)/1000;
 681
 682     /* Measure transfer time */
 683     ticks_measured = GET_SYSTICK();
 684     SPI_RunTransfer(buffer_out, buffer_in, BUFFER_SIZE_BR);
 685     ticks_measured = GET_SYSTICK() - ticks_measured;
 686     ticks_expected = SYSTICK_MICROSEC(BUFFER_SIZE_BR*1000/(uint32_t)val);
 687     ticks_expected *= SPI_DATA_BITS;
 688
 689     rate = (double)ticks_measured/ticks_expected;
 690
 691     if ((rate>(1.0+(double)MIN_BUS_SPEED/100))||(rate<1.0)) {
 692       snprintf(str,sizeof(str),"[WARNING] At %dkHz: measured time is %f x expected time", val, rate);
 693       TEST_MESSAGE(str);
 694     } else TEST_PASS();
 695
 696     /* Check received data against sent data*/
 697     if (memcmp(buffer_in, buffer_out, BUFFER_SIZE_BR)!=0) {
 698       snprintf(str,sizeof(str),"[FAILED] At %dkHz: fail to check block of %d bytes", val, BUFFER_SIZE_BR);
 699       TEST_FAIL_MESSAGE(str);
 700     } else TEST_PASS();
 701   }
 702
 703   /* Power off and uninitialize*/
 704   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 705   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 706
 707   /* Free buffer */
 708   free(buffer_out);
 709   free(buffer_in);
 710 }
 711
 712 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 713 /**
 714 \brief  Test case: SPI_Loopback_Transfer
 715 \details
 716 The test case \b SPI_Loopback_Transfer verifies the function \b Transfer with the sequence:
 717  - Initialize with callback
 718  - Power on
 719  - Transfer data
 720  - Check received data against sent data
 721  - Power off
 722  - Uninitialize
 723 */
 724 void SPI_Loopback_Transfer (void) {
 725   uint16_t cnt, i;
 726   uint8_t pattern[] = BUFFER_PATTERN;
 727
 728   /* Allocate buffer */
 729   buffer_out = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 730   TEST_ASSERT(buffer_out != NULL);
 731   buffer_in = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 732   TEST_ASSERT(buffer_in != NULL);
 733
 734   /* Initialize with callback, power on and configure SPI bus */
 735   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 736   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 737   TEST_ASSERT(drv->Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(SPI_DATA_BITS) |
 738     ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_UNUSED, SPI_BR[0]*1000) == ARM_DRIVER_OK);
 739
 740   /* Set Local Loopback */
 741   SPI_LOCAL_LOOPBACK();
 742
 743   /* Set output buffer pattern*/
 744   for (cnt = 0; cnt<BUFFER[BUFFER_NUM-1];) {
 745     for (i = 0; i<ARRAY_SIZE(pattern);) {
 746       buffer_out[cnt] = pattern[i++];
 747       if (SPI_DATA_BITS>8U) {
 748         buffer_out[cnt] |= pattern[i++]<<8U;
 749       }
 750       if (SPI_DATA_BITS>16U) {
 751         buffer_out[cnt] |= pattern[i++]<<16U;
 752         buffer_out[cnt] |= pattern[i++]<<24U;
 753       }
 754       buffer_out[cnt++] &= (1U<<SPI_DATA_BITS)-1U;
 755     }
 756   }
 757
 758   /* Transfer data chunks */
 759   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 760     /* Clear input buffer */
 761     memset(buffer_in,0,BUFFER[cnt]);
 762     if (SPI_RunTransfer(buffer_out, buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 763       snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",BUFFER[cnt]);
 764       TEST_FAIL_MESSAGE(str);
 765     } else TEST_PASS();
 766     if (memcmp(buffer_in, buffer_out, BUFFER[cnt])!=0) {
 767       snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",BUFFER[cnt]);
 768       TEST_FAIL_MESSAGE(str);
 769     } else TEST_PASS();
 770   }
 771
 772   /* Set output buffer with random data */
 773   srand(GET_SYSTICK());
 774   for (cnt = 0; cnt<BUFFER[BUFFER_NUM-1]; cnt++) {
 775     buffer_out[cnt] = (buf_t)rand()&((1U<<SPI_DATA_BITS)-1U);
 776   }
 777
 778   /* Transfer data chunks */
 779   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 780     /* Clear input buffer */
 781     memset(buffer_in,0,BUFFER[cnt]);
 782     if (SPI_RunTransfer(buffer_out, buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 783       snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",BUFFER[cnt]);
 784       TEST_FAIL_MESSAGE(str);
 785     } else TEST_PASS();
 786     if (memcmp(buffer_in, buffer_out, BUFFER[cnt])!=0) {
 787       snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",BUFFER[cnt]);
 788       TEST_FAIL_MESSAGE(str);
 789     } else TEST_PASS();
 790   }
 791
 792   /* Power off and uninitialize*/
 793   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 794   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 795
 796   /* Free buffer */
 797   free(buffer_out);
 798   free(buffer_in);
 799 }
 800
 801 /**
 802 @}
 803 */
 804 // end of group spi_funcs