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