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
   8 #include "cmsis_dv.h"
   9 #include "DV_Config.h"
  10 #include "DV_Framework.h"
  11 #include "Driver_SPI.h"
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16 // SPI buffer type
  17 #if (SPI_DATA_BITS>16U)
  18 typedef uint32_t buf_t;
  19 #elif (SPI_DATA_BITS>8U)
  20 typedef uint16_t buf_t;
  21 #else
  22 typedef uint8_t buf_t;
  23 #endif
  24
  25 // SPI buffer pointers
  26 static buf_t *buffer_out;
  27 static buf_t *buffer_in;
  28
  29 // SPI baudrates (kHz)
  30 static const uint32_t SPI_BR[] =  {
  31 #if (SPI_BR_1>0)
  32   SPI_BR_1,
  33 #endif
  34 #if (SPI_BR_2>0)
  35   SPI_BR_2,
  36 #endif
  37 #if (SPI_BR_3>0)
  38   SPI_BR_3,
  39 #endif
  40 #if (SPI_BR_4>0)
  41   SPI_BR_4,
  42 #endif
  43 #if (SPI_BR_5>0)
  44   SPI_BR_5,
  45 #endif
  46 #if (SPI_BR_6>0)
  47   SPI_BR_6,
  48 #endif
  49 };
  50 static const uint32_t SPI_BR_NUM = ARRAY_SIZE(SPI_BR);
  51
  52 // Register Driver_SPI#
  53 extern ARM_DRIVER_SPI CREATE_SYMBOL(Driver_SPI, DRV_SPI);
  54 static ARM_DRIVER_SPI *drv = &CREATE_SYMBOL(Driver_SPI, DRV_SPI);
  55 static ARM_SPI_CAPABILITIES capab;
  56
  57 static char str[128];
  58
  59 // Event flags
  60 static uint8_t volatile Event;
  61
  62 // SPI event
  63 static void SPI_DrvEvent (uint32_t event) {
  64   Event |= event;
  65 }
  66
  67 // SPI transfer
  68 int8_t SPI_RunTransfer (void *out, void *in, uint32_t cnt);
  69 int8_t SPI_RunTransfer (void *out, void *in, uint32_t cnt) {
  70   uint32_t tick;
  71
  72   Event &= ~ARM_SPI_EVENT_TRANSFER_COMPLETE;
  73   drv->Transfer (out, in, cnt);
  74
  75   tick = GET_SYSTICK();
  76   do {
  77     if (Event & ARM_SPI_EVENT_TRANSFER_COMPLETE) {
  78       return 0;
  79     }
  80   }
  81   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
  82
  83   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
  84   return -1;
  85 }
  86
  87 // SPI send
  88 int8_t SPI_RunSend (void *out, uint32_t cnt);
  89 int8_t SPI_RunSend (void *out, uint32_t cnt) {
  90   uint32_t tick;
  91
  92   Event &= ~ARM_SPI_EVENT_TRANSFER_COMPLETE;
  93   drv->Send (out, cnt);
  94
  95   tick = GET_SYSTICK();
  96   do {
  97     if (Event & ARM_SPI_EVENT_TRANSFER_COMPLETE) {
  98       return 0;
  99     }
 100   }
 101   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 102
 103   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 104   return -1;
 105 }
 106
 107 // SPI send without callback
 108 int8_t SPI_RunSend_NoCallback (void *out, uint32_t cnt);
 109 int8_t SPI_RunSend_NoCallback (void *out, uint32_t cnt) {
 110   uint32_t tick;
 111
 112   drv->Send (out, cnt);
 113
 114   tick = GET_SYSTICK();
 115   do {
 116     if (drv->GetDataCount() == cnt) {
 117       return 0;
 118     }
 119     if (drv->GetStatus().data_lost) {
 120       return -1;
 121     }
 122   }
 123   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 124
 125   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 126   return -1;
 127 }
 128
 129 // SPI receive
 130 int8_t SPI_RunReceive (void *in, uint32_t cnt);
 131 int8_t SPI_RunReceive (void *in, uint32_t cnt) {
 132   uint32_t tick;
 133
 134   Event &= ~ARM_SPI_EVENT_TRANSFER_COMPLETE;
 135   drv->Receive (in, cnt);
 136
 137   tick = GET_SYSTICK();
 138   do {
 139     if (Event & ARM_SPI_EVENT_TRANSFER_COMPLETE) {
 140       return 0;
 141     }
 142   }
 143   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 144
 145   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 146   return -1;
 147 }
 148
 149 // SPI receive
 150 int8_t SPI_RunReceiveNoCallback (void *in, uint32_t cnt);
 151 int8_t SPI_RunReceiveNoCallback (void *in, uint32_t cnt) {
 152   uint32_t tick;
 153
 154   Event &= ~0x01;
 155   drv->Receive (in, cnt);
 156
 157   tick = GET_SYSTICK();
 158   do {
 159     if (drv->GetDataCount() == cnt) {
 160       return 0;
 161     }
 162     if (drv->GetStatus().data_lost) {
 163       return -1;
 164     }
 165   }
 166   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(SPI_TRANSFER_TIMEOUT));
 167
 168   drv->Control(ARM_SPI_ABORT_TRANSFER, 0);
 169   return -1;
 170 }
 171
 172 /*-----------------------------------------------------------------------------
 173  *      Test cases
 174  *----------------------------------------------------------------------------*/
 175
 176 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 177 /**
 178 \defgroup spi_funcs SPI Validation
 179 \brief SPI test cases
 180 \details
 181 The SPI validation test performs the following checks:
 182 - API interface compliance.
 183 - Data communication with various transfer sizes and communication parameters.
 184 - Transfer speed of the data communication.
 185 - Loopback communication.
 186
 187 \anchor spi_loop_back_setup
 188 Loopback Communication Setup
 189 ----------------------------
 190
 191 To perform loopback communication tests, it is required to connect the SPI's \b MISO signal to the \b MOSI signal (refer to
 192 the schematics of your target hardware for detailed pinout information).
 193 @{
 194 */
 195
 196 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 197 /**
 198 \brief Test case: SPI_GetCapabilities
 199 \details
 200 The test case \b SPI_GetCapabilities verifies the function \b GetCapabilities.
 201 */
 202 void SPI_GetCapabilities (void) {
 203   /* Get SPI capabilities */
 204   capab = drv->GetCapabilities();
 205   TEST_ASSERT(&capab != NULL);
 206 }
 207
 208 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 209 /**
 210 \brief  Test case: SPI_Initialization
 211 \details
 212 The test case \b SPI_Initialization verifies the SPI functions with the sequence:
 213   - \b Initialize without callback
 214   - \b Uninitialize
 215   - \b Initialize with callback
 216   - \b Uninitialize
 217 */
 218 void SPI_Initialization (void) {
 219
 220   /* Initialize without callback */
 221   TEST_ASSERT(drv->Initialize(NULL) == ARM_DRIVER_OK);
 222
 223   /* Uninitialize */
 224   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 225
 226   /* Initialize with callback */
 227   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 228
 229   /* Uninitialize */
 230   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 231 }
 232
 233 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 234 /**
 235 \brief  Test case: SPI_CheckInvalidInit
 236 \details
 237 The test case \b SPI_CheckInvalidInit verifies the driver behavior when receiving an invalid initialization sequence:
 238   - \b Uninitialize
 239   - \b PowerControl with Power off
 240   - \b PowerControl with Power on
 241   - \b Control
 242   - \b PowerControl with Power off
 243   - \b Uninitialize
 244 */
 245 void SPI_CheckInvalidInit (void) {
 246
 247   /* Uninitialize */
 248   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 249
 250   /* Power off */
 251   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 252
 253   /* Try to power on */
 254   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) != ARM_DRIVER_OK);
 255
 256   /* Try to set configuration */
 257   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)
 258     != ARM_DRIVER_OK);
 259
 260   /* Power off */
 261   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 262
 263   /* Uninitialize */
 264   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 265 }
 266
 267 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 268 /**
 269 \brief  Test case: SPI_PowerControl
 270 \details
 271 The test case \b SPI_PowerControl verifies the \b PowerControl function with the sequence:
 272  - Initialize with callback
 273  - Power on
 274  - Power low
 275  - Power off
 276  - Uninitialize
 277 */
 278 void SPI_PowerControl (void) {
 279   int32_t val;
 280
 281   /* Initialize with callback */
 282   TEST_ASSERT(drv->Initialize(SPI_DrvEvent) == ARM_DRIVER_OK);
 283
 284   /* Power on */
 285   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 286
 287   /* Power low */
 288   val = drv->PowerControl (ARM_POWER_LOW);
 289   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Low power is not supported"); }
 290   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 291
 292   /* Power off */
 293   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 294
 295   /* Uninitialize */
 296   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 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