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

   1 /*
   2  * Copyright (c) 2015-2022 Arm Limited. All rights reserved.
   3  *
   4  * SPDX-License-Identifier: Apache-2.0
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License); you may
   7  * not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  14  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * -----------------------------------------------------------------------------
  19  *
  20  * Project:     CMSIS-Driver Validation
  21  * Title:       Serial Peripheral Interface Bus (SPI) Driver Validation tests
  22  *
  23  * -----------------------------------------------------------------------------
  24  */
  25
  26 #ifndef __DOXYGEN__                     // Exclude form the documentation
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "cmsis_dv.h"
  33 #include "DV_SPI_Config.h"
  34 #include "DV_Framework.h"
  35
  36 #include "Driver_SPI.h"
  37
  38 // Fixed settings for communication with SPI Server (not available through DV_SPI_Config.h)
  39 #define SPI_CFG_SRV_FORMAT        0     // Clock Polarity 0 / Clock Phase 0
  40 #define SPI_CFG_SRV_DATA_BITS     8     // 8 data bits
  41 #define SPI_CFG_SRV_BIT_ORDER     0     // MSB to LSB bit order
  42
  43 #define CMD_LEN                   32UL  // Length of command to SPI Server
  44 #define RESP_GET_VER_LEN          16UL  // Length of response from SPI Server to GET VER command
  45 #define RESP_GET_CAP_LEN          32UL  // Length of response from SPI Server to GET CAP command
  46 #define RESP_GET_CNT_LEN          16UL  // Length of response from SPI Server to GET CNT command
  47
  48 #define OP_SEND                   0UL   // Send operation
  49 #define OP_RECEIVE                1UL   // Receive operation
  50 #define OP_TRANSFER               2UL   // Transfer operation
  51 #define OP_ABORT_SEND             3UL   // Abort send operation
  52 #define OP_ABORT_RECEIVE          4UL   // Abort receive operation
  53 #define OP_ABORT_TRANSFER         5UL   // Abort transfer operation
  54
  55 #define MODE_INACTIVE             0UL   // Inactive mode
  56 #define MODE_MASTER               1UL   // Master mode
  57 #define MODE_SLAVE                2UL   // Slave  mode
  58 #define SS_MODE_MASTER_UNUSED     0UL   // Master mode Slave Select unused
  59 #define SS_MODE_MASTER_SW         1UL   // Master mode Slave Select Software controlled
  60 #define SS_MODE_MASTER_HW_OUTPUT  2UL   // Master mode Slave Select Hardware controlled Output
  61 #define SS_MODE_MASTER_HW_INPUT   3UL   // Master mode Slave Select Hardware monitored Input
  62 #define SS_MODE_SLAVE_HW          0UL   // Slave mode Slave Select Hardware monitored
  63 #define SS_MODE_SLAVE_SW          1UL   // Slave mode Slave Select Software controlled
  64 #define FORMAT_CPOL0_CPHA0        0UL   // Clock Format: Polarity 0, Phase 0
  65 #define FORMAT_CPOL0_CPHA1        1UL   // Clock Format: Polarity 0, Phase 1
  66 #define FORMAT_CPOL1_CPHA0        2UL   // Clock Format: Polarity 1, Phase 0
  67 #define FORMAT_CPOL1_CPHA1        3UL   // Clock Format: Polarity 1, Phase 1
  68 #define FORMAT_TI                 4UL   // Frame Format: Texas Instruments
  69 #define FORMAT_MICROWIRE          5UL   // Frame Format: National Semiconductor Microwire
  70 #define BO_MSB_TO_LSB             0UL   // Bit Order MSB to LSB
  71 #define BO_LSB_TO_MSB             1UL   // Bit Order LSB to MSB
  72
  73 // Testing Configuration definitions
  74 #if    (SPI_CFG_TEST_MODE != 0)
  75 #define SPI_SERVER_USED                 1
  76 #else
  77 #define SPI_SERVER_USED                 0
  78 #endif
  79
  80 // Determine maximum number of items used for testing
  81 #if    (SPI_CFG_DEF_NUM == 0)
  82 #error  Default number of items must not be 0!
  83 #endif
  84
  85 #define SPI_NUM_MAX                     SPI_CFG_DEF_NUM
  86 #if    (SPI_CFG_NUM1 > SPI_NUM_MAX)
  87 #undef  SPI_NUM_MAX
  88 #define SPI_NUM_MAX                     SPI_CFG_NUM1
  89 #endif
  90 #if    (SPI_CFG_NUM2 > SPI_NUM_MAX)
  91 #undef  SPI_NUM_MAX
  92 #define SPI_NUM_MAX                     SPI_CFG_NUM2
  93 #endif
  94 #if    (SPI_CFG_NUM3 > SPI_NUM_MAX)
  95 #undef  SPI_NUM_MAX
  96 #define SPI_NUM_MAX                     SPI_CFG_NUM3
  97 #endif
  98 #if    (SPI_CFG_NUM4 > SPI_NUM_MAX)
  99 #undef  SPI_NUM_MAX
 100 #define SPI_NUM_MAX                     SPI_CFG_NUM4
 101 #endif
 102 #if    (SPI_CFG_NUM5 > SPI_NUM_MAX)
 103 #undef  SPI_NUM_MAX
 104 #define SPI_NUM_MAX                     SPI_CFG_NUM5
 105 #endif
 106
 107 // Calculate maximum required buffer size
 108 #if   ((SPI_CFG_DEF_DATA_BITS > 16) || ((SPI_TC_DATA_BIT_EN_MASK & 0xFFFF0000UL) != 0U))
 109 #define SPI_BUF_MAX                    (SPI_NUM_MAX * 4U)
 110 #elif ((SPI_CFG_DEF_DATA_BITS > 8)  || ((SPI_TC_DATA_BIT_EN_MASK & 0x0000FF00UL) != 0U))
 111 #define SPI_BUF_MAX                    (SPI_NUM_MAX * 2U)
 112 #else
 113 #define SPI_BUF_MAX                    (SPI_NUM_MAX)
 114 #endif
 115 #if    (SPI_SERVER_USED == 1)
 116 // If selected Test Mode is SPI Server take into account SPI Server data bit settings
 117 #if   ((SPI_CFG_SRV_DATA_BITS > 16) && (SPI_BUF_MAX < (SPI_NUM_MAX * 4U)))
 118 #undef  SPI_BUF_MAX
 119 #define SPI_BUF_MAX                    (SPI_NUM_MAX * 4U)
 120 #elif ((SPI_CFG_SRV_DATA_BITS > 8)  && (SPI_BUF_MAX < (SPI_NUM_MAX * 2U)))
 121 #undef  SPI_BUF_MAX
 122 #define SPI_BUF_MAX                    (SPI_NUM_MAX * 2U)
 123 #endif
 124 #endif
 125
 126 typedef struct {                // SPI Server version structure
 127   uint8_t  major;               // Version major number
 128   uint8_t  minor;               // Version minor number
 129   uint16_t patch;               // Version patch (revision) number
 130 } SPI_SERV_VER_t;
 131
 132 typedef struct {                // SPI Server capabilities structure
 133   uint32_t mode_mask;           // Mode and Slave Select mask
 134   uint32_t fmt_mask;            // Clock Format or Frame Format mask
 135   uint32_t db_mask;             // Data Bits mask
 136   uint32_t bo_mask;             // Bit Order mask
 137   uint32_t bs_min;              // Min bus speed
 138   uint32_t bs_max;              // Max bus speed
 139 } SPI_SERV_CAP_t;
 140
 141 // Register Driver_SPI#
 142 #define _ARM_Driver_SPI_(n)         Driver_SPI##n
 143 #define  ARM_Driver_SPI_(n)    _ARM_Driver_SPI_(n)
 144 extern   ARM_DRIVER_SPI         ARM_Driver_SPI_(DRV_SPI);
 145 static   ARM_DRIVER_SPI *drv = &ARM_Driver_SPI_(DRV_SPI);
 146
 147 // Global variables (used in this module only)
 148 static int8_t                   buffers_ok;
 149 static int8_t                   driver_ok;
 150 static int8_t                   server_ok;
 151
 152 static SPI_SERV_VER_t           spi_serv_ver;
 153 static SPI_SERV_CAP_t           spi_serv_cap;
 154
 155 static volatile uint32_t        event;
 156 static volatile uint32_t        duration;
 157 static volatile uint32_t        xfer_count;
 158 static volatile uint32_t        data_count_sample;
 159 static uint32_t                 systick_freq;
 160
 161 static osEventFlagsId_t         event_flags;
 162
 163 static char                     msg_buf[256];
 164
 165 // Allocated buffer pointers
 166 static void                    *ptr_tx_buf_alloc;
 167 static void                    *ptr_rx_buf_alloc;
 168 static void                    *ptr_cmp_buf_alloc;
 169
 170 // Buffer pointers used for data transfers (must be aligned to 4 byte)
 171 static uint8_t                 *ptr_tx_buf;
 172 static uint8_t                 *ptr_rx_buf;
 173 static uint8_t                 *ptr_cmp_buf;
 174
 175 // String representation of various codes
 176 static const char *str_srv_status[] = {
 177   "Ok",
 178   "Failed"
 179 };
 180
 181 static const char *str_test_mode[] = {
 182   "Loopback",
 183   "SPI Server"
 184 };
 185
 186 static const char *str_oper[] = {
 187   "Send    ",
 188   "Receive ",
 189   "Transfer",
 190   "Abort Send    ",
 191   "Abort Receive ",
 192   "Abort Transfer"
 193 };
 194
 195 static const char *str_ss_mode[] = {
 196   "Unused",
 197   "Software controlled",
 198   "Hardware controlled"
 199 };
 200
 201 static const char *str_mode[] = {
 202   "Master",
 203   "Slave"
 204 };
 205
 206 static const char *str_format[] = {
 207   "Clock Polarity 0, Clock Phase 0",
 208   "Clock Polarity 0, Clock Phase 1",
 209   "Clock Polarity 1, Clock Phase 0",
 210   "Clock Polarity 1, Clock Phase 1",
 211   "Texas Instruments",
 212   "National Semiconductor Microwire"
 213 };
 214
 215 static const char *str_bit_order[] = {
 216   "MSB to LSB",
 217   "LSB to MSB"
 218 };
 219
 220 static const char *str_ret[] = {
 221   "ARM_DRIVER_OK",
 222   "ARM_DRIVER_ERROR",
 223   "ARM_DRIVER_ERROR_BUSY",
 224   "ARM_DRIVER_ERROR_TIMEOUT",
 225   "ARM_DRIVER_ERROR_UNSUPPORTED",
 226   "ARM_DRIVER_ERROR_PARAMETER",
 227   "ARM_DRIVER_ERROR_SPECIFIC",
 228   "ARM_SPI_ERROR_MODE",
 229   "ARM_SPI_ERROR_FRAME_FORMAT",
 230   "ARM_SPI_ERROR_DATA_BITS",
 231   "ARM_SPI_ERROR_BIT_ORDER",
 232   "ARM_SPI_ERROR_SS_MODE"
 233 };
 234
 235 // Local functions
 236 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
 237 static int32_t  ComConfigDefault       (void);
 238 static int32_t  ComSendCommand         (const void *data_out, uint32_t len);
 239 static int32_t  ComReceiveResponse     (      void *data_in,  uint32_t len);
 240
 241 static int32_t  CmdGetVer              (void);
 242 static int32_t  CmdGetCap              (void);
 243 static int32_t  CmdSetBufTx            (char pattern);
 244 static int32_t  CmdSetBufRx            (char pattern);
 245 static int32_t  CmdGetBufRx            (uint32_t len);
 246 static int32_t  CmdSetCom              (uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t ss_mode, uint32_t bus_speed);
 247 static int32_t  CmdXfer                (uint32_t num,  uint32_t delay_c, uint32_t delay_t,  uint32_t timeout);
 248 static int32_t  CmdGetCnt              (void);
 249
 250 static int32_t  ServerInit             (void);
 251 static int32_t  ServerCheck            (void);
 252 static int32_t  ServerCheckSupport     (uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t bus_speed);
 253 #endif
 254
 255 static int32_t  IsNotLoopback          (void);
 256 static int32_t  IsNotFrameTI           (void);
 257 static int32_t  IsNotFrameMw           (void);
 258 static int32_t  IsFormatValid          (void);
 259 static int32_t  IsBitOrderValid        (void);
 260
 261 static uint32_t DataBitsToBytes        (uint32_t data_bits);
 262 static int32_t  DriverInit             (void);
 263 static int32_t  BuffersCheck           (void);
 264
 265 static void SPI_DataExchange_Operation (uint32_t operation, uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t ss_mode, uint32_t bus_speed, uint32_t num);
 266
 267 // Helper functions
 268
 269 /*
 270   \fn            void SPI_DrvEvent (uint32_t evt)
 271   \brief         Store event(s) into a global variable.
 272   \detail        This is a callback function called by the driver upon an event(s).
 273   \param[in]     evt            SPI event
 274   \return        none
 275 */
 276 static void SPI_DrvEvent (uint32_t evt) {
 277   event |= evt;
 278
 279   (void)osEventFlagsSet(event_flags, evt);
 280 }
 281
 282 /*
 283   \fn            static uint32_t DataBitsToBytes (uint32_t data_bits)
 284   \brief         Calculate number of bytes used for an item at required data bits.
 285   \return        number of bytes per item
 286 */
 287 static uint32_t DataBitsToBytes (uint32_t data_bits) {
 288   uint32_t ret;
 289
 290   ret = 1U;
 291   if        (data_bits > 16U) {
 292     ret = 4U;
 293   } else if (data_bits > 8U) {
 294     ret = 2U;
 295   }
 296
 297   return ret;
 298 }
 299
 300 /*
 301   \fn            static int32_t DriverInit (void)
 302   \brief         Initialize and power-on the driver.
 303   \return        execution status
 304                    - EXIT_SUCCESS: Driver initialized and powered-up successfully
 305                    - EXIT_FAILURE: Driver initialization or power-up failed
 306 */
 307 static int32_t DriverInit (void) {
 308
 309   if (drv->Initialize    (SPI_DrvEvent)   == ARM_DRIVER_OK) {
 310     if (drv->PowerControl(ARM_POWER_FULL) == ARM_DRIVER_OK) {
 311       return EXIT_SUCCESS;
 312     }
 313   }
 314
 315   TEST_FAIL_MESSAGE("[FAILED] SPI driver initialize or power-up. Check driver Initialize and PowerControl functions! Test aborted!");
 316
 317   return EXIT_FAILURE;
 318 }
 319
 320 /*
 321   \fn            static int32_t BuffersCheck (void)
 322   \brief         Check if buffers are valid.
 323   \return        execution status
 324                    - EXIT_SUCCESS: Buffers are valid
 325                    - EXIT_FAILURE: Buffers are not valid
 326 */
 327 static int32_t BuffersCheck (void) {
 328
 329   if ((ptr_tx_buf  != NULL) &&
 330       (ptr_rx_buf  != NULL) &&
 331       (ptr_cmp_buf != NULL)) {
 332     return EXIT_SUCCESS;
 333   }
 334
 335   TEST_FAIL_MESSAGE("[FAILED] Invalid data buffers! Increase heap memory! Test aborted!");
 336
 337   return EXIT_FAILURE;
 338 }
 339
 340 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
 341
 342 /*
 343   \fn            static int32_t ComConfigDefault (void)
 344   \brief         Configure SPI Communication Interface to SPI Server default communication configuration.
 345   \return        execution status
 346                    - EXIT_SUCCESS: Default configuration set successfully
 347                    - EXIT_FAILURE: Default configuration failed
 348 */
 349 static int32_t ComConfigDefault (void) {
 350   int32_t ret;
 351
 352   ret = EXIT_SUCCESS;
 353
 354   if (drv->Control(ARM_SPI_MODE_MASTER                                                                |
 355                  ((SPI_CFG_SRV_FORMAT    << ARM_SPI_FRAME_FORMAT_Pos)   & ARM_SPI_FRAME_FORMAT_Msk)   |
 356                  ((SPI_CFG_SRV_DATA_BITS << ARM_SPI_DATA_BITS_Pos)      & ARM_SPI_DATA_BITS_Msk)      |
 357                  ((SPI_CFG_SRV_BIT_ORDER << ARM_SPI_BIT_ORDER_Pos)      & ARM_SPI_BIT_ORDER_Msk)      |
 358                  ((SPI_CFG_SRV_SS_MODE   << ARM_SPI_SS_MASTER_MODE_Pos) & ARM_SPI_SS_MASTER_MODE_Msk) ,
 359                    SPI_CFG_SRV_BUS_SPEED) != ARM_DRIVER_OK) {
 360     ret = EXIT_FAILURE;
 361   }
 362
 363   if ((ret == EXIT_SUCCESS) && (SPI_CFG_SRV_SS_MODE == SS_MODE_MASTER_SW)) {
 364     if (drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE) != ARM_DRIVER_OK) {
 365       ret = EXIT_FAILURE;
 366     }
 367   }
 368
 369   if (ret != EXIT_SUCCESS) {
 370     TEST_FAIL_MESSAGE("[FAILED] Configure communication interface to SPI Server default settings. Check driver Control function! Test aborted!");
 371   }
 372
 373   return ret;
 374 }
 375
 376 /**
 377   \fn            static int32_t ComSendCommand (const void *data_out, uint32_t num)
 378   \brief         Send command to SPI Server.
 379   \param[out]    data_out       Pointer to memory containing data to be sent
 380   \param[in]     len            Number of bytes to be sent
 381   \return        execution status
 382                    - EXIT_SUCCESS: Command sent successfully
 383                    - EXIT_FAILURE: Command send failed
 384 */
 385 static int32_t ComSendCommand (const void *data_out, uint32_t len) {
 386    int32_t ret;
 387   uint32_t flags, num, tout;
 388
 389   ret = EXIT_SUCCESS;
 390   num = (len + DataBitsToBytes(SPI_CFG_SRV_DATA_BITS) - 1U) / DataBitsToBytes(SPI_CFG_SRV_DATA_BITS);
 391
 392   ret = ComConfigDefault();
 393
 394   if (ret == EXIT_SUCCESS) {
 395     if (SPI_CFG_SRV_SS_MODE == SS_MODE_MASTER_SW) {
 396       if (drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_ACTIVE) != ARM_DRIVER_OK) {
 397         ret = EXIT_FAILURE;
 398       }
 399     }
 400     if (ret == EXIT_SUCCESS) {
 401       (void)osEventFlagsClear(event_flags, 0x7FFFFFFFU);
 402       if (drv->Send(data_out, num) == ARM_DRIVER_OK) {
 403         flags = osEventFlagsWait(event_flags, ARM_SPI_EVENT_TRANSFER_COMPLETE, osFlagsWaitAny, SPI_CFG_SRV_CMD_TOUT);
 404         if (((flags & 0x80000000U) != 0U) ||
 405             ((flags & ARM_SPI_EVENT_TRANSFER_COMPLETE) == 0U)) {
 406           ret = EXIT_FAILURE;
 407           (void)drv->Control (ARM_SPI_ABORT_TRANSFER, 0U);
 408         }
 409       }
 410     }
 411     if (SPI_CFG_SRV_SS_MODE == SS_MODE_MASTER_SW) {
 412       if (drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE) != ARM_DRIVER_OK) {
 413         ret = EXIT_FAILURE;
 414       }
 415     }
 416   }
 417   (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
 418
 419   return ret;
 420 }
 421
 422 /**
 423   \fn            static int32_t ComReceiveResponse (void *data_in, uint32_t num)
 424   \brief         Receive response from SPI Server.
 425   \param[out]    data_in     Pointer to memory where data will be received
 426   \param[in]     len         Number of data bytes to be received
 427   \return        execution status
 428                    - EXIT_SUCCESS: Command received successfully
 429                    - EXIT_FAILURE: Command reception failed
 430 */
 431 static int32_t ComReceiveResponse (void *data_in, uint32_t len) {
 432    int32_t ret;
 433   uint32_t flags, num, tout;
 434
 435   ret = EXIT_SUCCESS;
 436   num = (len + DataBitsToBytes(SPI_CFG_SRV_DATA_BITS) - 1U) / DataBitsToBytes(SPI_CFG_SRV_DATA_BITS);
 437
 438   ret = ComConfigDefault();
 439
 440   if (ret == EXIT_SUCCESS) {
 441     if (SPI_CFG_SRV_SS_MODE == SS_MODE_MASTER_SW) {
 442       if (drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_ACTIVE) != ARM_DRIVER_OK) {
 443         ret = EXIT_FAILURE;
 444       }
 445     }
 446     if (ret == EXIT_SUCCESS) {
 447       (void)osEventFlagsClear(event_flags, 0x7FFFFFFFU);
 448       if (drv->Receive(data_in, num) == ARM_DRIVER_OK) {
 449         flags = osEventFlagsWait(event_flags, ARM_SPI_EVENT_TRANSFER_COMPLETE, osFlagsWaitAny, SPI_CFG_SRV_CMD_TOUT);
 450         if (((flags & 0x80000000U) != 0U) ||
 451             ((flags & ARM_SPI_EVENT_TRANSFER_COMPLETE) == 0U)) {
 452           ret = EXIT_FAILURE;
 453           (void)drv->Control (ARM_SPI_ABORT_TRANSFER, 0U);
 454         }
 455       }
 456     }
 457     if (SPI_CFG_SRV_SS_MODE == SS_MODE_MASTER_SW) {
 458       if (drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE) != ARM_DRIVER_OK) {
 459         ret = EXIT_FAILURE;
 460       }
 461     }
 462   }
 463   (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
 464
 465   return ret;
 466 }
 467
 468 /**
 469   \fn            static int32_t CmdGetVer (void)
 470   \brief         Get version from SPI Server and check that it is valid.
 471   \return        execution status
 472                    - EXIT_SUCCESS: Version retrieved successfully
 473                    - EXIT_FAILURE: Version retreival failed
 474 */
 475 static int32_t CmdGetVer (void) {
 476   int32_t     ret;
 477   const char *ptr_str;
 478   uint16_t    val16;
 479   uint8_t     val8;
 480
 481   ptr_str = NULL;
 482
 483   memset(&spi_serv_ver, 0, sizeof(spi_serv_ver));
 484
 485   // Send "GET VER" command to SPI Server
 486   memset(ptr_tx_buf, 0, CMD_LEN);
 487   memcpy(ptr_tx_buf, "GET VER", 7);
 488   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 489   (void)osDelay(10U);
 490
 491   if (ret == EXIT_SUCCESS) {
 492     // Receive response to "GET VER" command from SPI Server
 493     memset(ptr_rx_buf, (int32_t)'?', RESP_GET_VER_LEN);
 494     ret = ComReceiveResponse(ptr_rx_buf, RESP_GET_VER_LEN);
 495     (void)osDelay(10U);
 496   }
 497
 498   // Parse version
 499   if (ret == EXIT_SUCCESS) {
 500     // Parse major
 501     ptr_str = (const char *)ptr_rx_buf;
 502     if (sscanf(ptr_str, "%hhx", &val8) == 1) {
 503       spi_serv_ver.major = val8;
 504     } else {
 505       ret = EXIT_FAILURE;
 506     }
 507   }
 508   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 509     // Parse minor
 510     ptr_str = strstr(ptr_str, ".");     // Find '.'
 511     if (ptr_str != NULL) {
 512       ptr_str++;                        // Skip '.'
 513       if (sscanf(ptr_str, "%hhx", &val8) == 1) {
 514         spi_serv_ver.minor = val8;
 515       } else {
 516         ret = EXIT_FAILURE;
 517       }
 518     } else {
 519       ret = EXIT_FAILURE;
 520     }
 521   }
 522   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 523     // Parse patch (revision)
 524     ptr_str = strstr(ptr_str, ".");     // Find next '.'
 525     if (ptr_str != NULL) {
 526       ptr_str++;                        // Skip '.'
 527       if (sscanf(ptr_str, "%hx", &val16) == 1) {
 528         spi_serv_ver.patch = val16;
 529       } else {
 530         ret = EXIT_FAILURE;
 531       }
 532     } else {
 533       ret = EXIT_FAILURE;
 534     }
 535   }
 536
 537   return ret;
 538 }
 539
 540 /**
 541   \fn            static int32_t CmdGetCap (void)
 542   \brief         Get capabilities from SPI Server.
 543   \return        execution status
 544                    - EXIT_SUCCESS: Capabilities retrieved successfully
 545                    - EXIT_FAILURE: Capabilities retreival failed
 546 */
 547 static int32_t CmdGetCap (void) {
 548   int32_t     ret;
 549   const char *ptr_str;
 550   uint32_t    val32;
 551   uint8_t     val8;
 552
 553   ptr_str = NULL;
 554
 555   memset(&spi_serv_cap, 0, sizeof(spi_serv_cap));
 556
 557   // Send "GET CAP" command to SPI Server
 558   memset(ptr_tx_buf, 0, CMD_LEN);
 559   memcpy(ptr_tx_buf, "GET CAP", 7);
 560   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 561   (void)osDelay(10U);
 562
 563   if (ret == EXIT_SUCCESS) {
 564     (void)osDelay(20U);                 // Give SPI Server 20 ms to auto-detect capabilities
 565
 566     // Receive response to "GET CAP" command from SPI Server
 567     memset(ptr_rx_buf, (int32_t)'?', RESP_GET_CAP_LEN);
 568     ret = ComReceiveResponse(ptr_rx_buf, RESP_GET_CAP_LEN);
 569     (void)osDelay(10U);
 570   }
 571
 572   // Parse capabilities
 573   if (ret == EXIT_SUCCESS) {
 574     // Parse mode mask
 575     ptr_str = (const char *)ptr_rx_buf;
 576     if (sscanf(ptr_str, "%hhx", &val8) == 1) {
 577       spi_serv_cap.mode_mask = val8;
 578     } else {
 579       ret = EXIT_FAILURE;
 580     }
 581   }
 582   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 583     // Parse format mask
 584     ptr_str = strstr(ptr_str, ",");     // Find ','
 585     if (ptr_str != NULL) {
 586       ptr_str++;                        // Skip ','
 587       if (sscanf(ptr_str, "%hhx", &val8) == 1) {
 588         spi_serv_cap.fmt_mask = (uint32_t)val8;
 589       } else {
 590         ret = EXIT_FAILURE;
 591       }
 592     } else {
 593       ret = EXIT_FAILURE;
 594     }
 595   }
 596   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 597     // Parse data bit mask
 598     ptr_str = strstr(ptr_str, ",");     // Find next ','
 599     if (ptr_str != NULL) {
 600       ptr_str++;                        // Skip ','
 601       if (sscanf(ptr_str, "%x", &val32) == 1) {
 602         spi_serv_cap.db_mask = val32;
 603       } else {
 604         ret = EXIT_FAILURE;
 605       }
 606     } else {
 607       ret = EXIT_FAILURE;
 608     }
 609   }
 610   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 611     // Parse bit order mask
 612     ptr_str = strstr(ptr_str, ",");     // Find next ','
 613     if (ptr_str != NULL) {
 614       ptr_str++;                        // Skip ','
 615       if (sscanf(ptr_str, "%hhx", &val8) == 1) {
 616         spi_serv_cap.bo_mask = (uint32_t)val8;
 617       } else {
 618         ret = EXIT_FAILURE;
 619       }
 620     } else {
 621       ret = EXIT_FAILURE;
 622     }
 623   }
 624   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 625     // Parse minimum bus speed
 626     ptr_str = strstr(ptr_str, ",");     // Find next ','
 627     if (ptr_str != NULL) {
 628       ptr_str++;                        // Skip ','
 629       if (sscanf(ptr_str, "%u", &val32) == 1) {
 630         spi_serv_cap.bs_min = val32 * 1000U;
 631       } else {
 632         ret = EXIT_FAILURE;
 633       }
 634     } else {
 635       ret = EXIT_FAILURE;
 636     }
 637   }
 638   if ((ret == EXIT_SUCCESS) && (ptr_str != NULL)) {
 639     // Parse maximum bus speed
 640     ptr_str = strstr(ptr_str, ",");     // Find next ','
 641     if (ptr_str != NULL) {
 642       ptr_str++;                        // Skip ','
 643       if (sscanf(ptr_str, "%u", &val32) == 1) {
 644         spi_serv_cap.bs_max = val32 * 1000U;
 645       } else {
 646         ret = EXIT_FAILURE;
 647       }
 648     } else {
 649       ret = EXIT_FAILURE;
 650     }
 651   }
 652
 653   return ret;
 654 }
 655
 656 /**
 657   \fn            static int32_t CmdSetBufTx (char pattern)
 658   \brief         Set Tx buffer of SPI Server to pattern.
 659   \param[in]     pattern        Pattern to fill the buffer with
 660   \return        execution status
 661                    - EXIT_SUCCESS: Command sent successfully
 662                    - EXIT_FAILURE: Command send failed
 663 */
 664 static int32_t CmdSetBufTx (char pattern) {
 665   int32_t ret;
 666
 667   // Send "SET BUF TX" command to SPI Server
 668   memset(ptr_tx_buf, 0, CMD_LEN);
 669   (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "SET BUF TX,0,%02X", (int32_t)pattern);
 670   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 671   (void)osDelay(10U);
 672
 673   if (ret != EXIT_SUCCESS) {
 674     TEST_FAIL_MESSAGE("[FAILED] Set Tx buffer on SPI Server. Check SPI Server! Test aborted!");
 675   }
 676
 677   return ret;
 678 }
 679
 680 /**
 681   \fn            static int32_t CmdSetBufRx (char pattern)
 682   \brief         Set Rx buffer of SPI Server to pattern.
 683   \param[in]     pattern        Pattern to fill the buffer with
 684   \return        execution status
 685                    - EXIT_SUCCESS: Command sent successfully
 686                    - EXIT_FAILURE: Command send failed
 687 */
 688 static int32_t CmdSetBufRx (char pattern) {
 689   int32_t ret;
 690
 691   // Send "SET BUF RX" command to SPI Server
 692   memset(ptr_tx_buf, 0, CMD_LEN);
 693   (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "SET BUF RX,0,%02X", (int32_t)pattern);
 694   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 695   (void)osDelay(10U);
 696
 697   if (ret != EXIT_SUCCESS) {
 698     TEST_FAIL_MESSAGE("[FAILED] Set Rx buffer on SPI Server. Check SPI Server! Test aborted!");
 699   }
 700
 701   return ret;
 702 }
 703
 704 /**
 705   \fn            static int32_t CmdGetBufRx (uint32_t len)
 706   \brief         Get Rx buffer from SPI Server (into global array pointed to by ptr_rx_buf).
 707   \param[in]     len            Number of bytes to read from Rx buffer
 708   \return        execution status
 709                    - EXIT_SUCCESS: Command sent and response received successfully
 710                    - EXIT_FAILURE: Command send or response reception failed
 711 */
 712 static int32_t CmdGetBufRx (uint32_t len) {
 713   int32_t ret;
 714
 715   // Send "GET BUF RX" command to SPI Server
 716   memset(ptr_tx_buf, 0, CMD_LEN);
 717   (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "GET BUF RX,%i", len);
 718   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 719   (void)osDelay(10U);
 720
 721   if (ret == EXIT_SUCCESS) {
 722     // Receive response to "GET BUF RX" command from SPI Server
 723     memset(ptr_rx_buf, (int32_t)'?', len);
 724     ret = ComReceiveResponse(ptr_rx_buf, len);
 725     (void)osDelay(10U);
 726   }
 727
 728   if (ret != EXIT_SUCCESS) {
 729     TEST_FAIL_MESSAGE("[FAILED] Get Rx buffer from SPI Server. Check SPI Server! Test aborted!");
 730   }
 731
 732   return ret;
 733 }
 734
 735 /**
 736   \fn            static int32_t CmdSetCom (uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t ss_mode, uint32_t bus_speed)
 737   \brief         Set communication parameters on SPI Server for next XFER command.
 738   \param[in]     mode           mode (0 = Master, 1 = slave)
 739   \param[in]     format         clock / frame format:
 740                                   - value 0 = clock polarity 0, phase 0
 741                                   - value 1 = clock polarity 0, phase 1
 742                                   - value 2 = clock polarity 1, phase 0
 743                                   - value 3 = clock polarity 1, phase 1
 744                                   - value 4 = Texas Instruments frame format
 745                                   - value 5 = Microwire frame format
 746   \param[in]     data_bits      data bits
 747                                   - values 1 to 32
 748   \param[in]     bit_order      bit order
 749                                   - value 0 = MSB to LSB
 750                                   - value 1 = LSB to MSB
 751   \param[in]     ss_mode        Slave Select mode:
 752                                   - value 0 = not used
 753                                   - value 1 = used (in Master mode driven, in Slave mode monitored as hw input)
 754   \param[in]     bus_speed      bus speed in bits per second (bps)
 755   \return        execution status
 756                    - EXIT_SUCCESS: Command sent successfully
 757                    - EXIT_FAILURE: Command send failed
 758 */
 759 static int32_t CmdSetCom (uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t ss_mode, uint32_t bus_speed) {
 760   int32_t ret, stat;
 761
 762   // Send "SET COM" command to SPI Server
 763   memset(ptr_tx_buf, 0, CMD_LEN);
 764   stat = snprintf((char *)ptr_tx_buf, CMD_LEN, "SET COM %i,%i,%i,%i,%i,%i", mode, format, data_bits, bit_order, ss_mode, bus_speed);
 765   if ((stat > 0) && (stat < CMD_LEN)) {
 766     ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 767     (void)osDelay(10U);
 768   } else {
 769     ret = EXIT_FAILURE;
 770   }
 771
 772   if (ret != EXIT_SUCCESS) {
 773     TEST_FAIL_MESSAGE("[FAILED] Set communication settings on SPI Server. Check SPI Server! Test aborted!");
 774   }
 775
 776   return ret;
 777 }
 778
 779 /**
 780   \fn            static int32_t CmdXfer (uint32_t num, uint32_t delay_c, uint32_t delay_t, uint32_t timeout)
 781   \brief         Activate transfer on SPI Server.
 782   \param[in]     num            number of items (according CMSIS SPI driver specification)
 783   \param[in]     delay_c        delay before control function is called, in milliseconds
 784                                 (0xFFFFFFFF = delay not used)
 785   \param[in]     delay_t        delay after control function is called but before transfer function is called, in milliseconds
 786                                 (0xFFFFFFFF = delay not used)
 787   \param[in]     timeout        timeout in milliseconds, after delay, if delay is specified
 788   \return        execution status
 789                    - EXIT_SUCCESS: Command sent successfully
 790                    - EXIT_FAILURE: Command send failed
 791 */
 792 static int32_t CmdXfer (uint32_t num, uint32_t delay_c, uint32_t delay_t, uint32_t timeout) {
 793   int32_t ret;
 794
 795   // Send "XFER" command to SPI Server
 796   memset(ptr_tx_buf, 0, CMD_LEN);
 797   if        ((delay_c != osWaitForever) && (delay_t != osWaitForever) && (timeout != 0U)) {
 798     (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "XFER %i,%i,%i,%i",    num, delay_c, delay_t, timeout);
 799   } else if ((delay_c != osWaitForever) && (delay_t != osWaitForever)) {
 800     (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "XFER %i,%i,%i",       num, delay_c, delay_t);
 801   } else if  (delay_c != osWaitForever)                                {
 802     (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "XFER %i,%i",          num, delay_c);
 803   } else {
 804     (void)snprintf((char *)ptr_tx_buf, CMD_LEN, "XFER %i",             num);
 805   }
 806   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 807
 808   if (ret != EXIT_SUCCESS) {
 809     TEST_FAIL_MESSAGE("[FAILED] Activate transfer on SPI Server. Check SPI Server! Test aborted!");
 810   }
 811
 812   return ret;
 813 }
 814
 815 /*
 816   \fn            static int32_t CmdGetCnt (void)
 817   \brief         Get XFER command Tx/Rx count from SPI Server.
 818   \return        execution status
 819                    - EXIT_SUCCESS: Operation successful
 820                    - EXIT_FAILURE: Operation failed
 821 */
 822 static int32_t CmdGetCnt (void) {
 823   int32_t     ret;
 824   const char *ptr_str;
 825   uint32_t    val32;
 826
 827   xfer_count = 0U;
 828
 829   // Send "GET CNT" command to SPI Server
 830   memset(ptr_tx_buf, 0, CMD_LEN);
 831   memcpy(ptr_tx_buf, "GET CNT", 7);
 832   ret = ComSendCommand(ptr_tx_buf, CMD_LEN);
 833   (void)osDelay(10U);
 834
 835   if (ret == EXIT_SUCCESS) {
 836     // Receive response to "GET CNT" command from SPI Server
 837     memset(ptr_rx_buf, (int32_t)'?', RESP_GET_CNT_LEN);
 838     ret = ComReceiveResponse(ptr_rx_buf, RESP_GET_CNT_LEN);
 839     (void)osDelay(10U);
 840   }
 841
 842   if (ret == EXIT_SUCCESS) {
 843     // Parse count
 844     ptr_str = (const char *)ptr_rx_buf;
 845     if (sscanf(ptr_str, "%i", &val32) == 1) {
 846       xfer_count = val32;
 847     } else {
 848       ret = EXIT_FAILURE;
 849     }
 850   }
 851
 852   if (ret != EXIT_SUCCESS) {
 853     TEST_FAIL_MESSAGE("[FAILED] Get count from SPI Server. Check SPI Server! Test aborted!");
 854   }
 855
 856   return ret;
 857 }
 858
 859 /*
 860   \fn            static int32_t ServerInit (void)
 861   \brief         Initialize communication with SPI Server, get version and capabilities.
 862   \return        execution status
 863                    - EXIT_SUCCESS: SPI Server initialized successfully
 864                    - EXIT_FAILURE: SPI Server initialization failed
 865 */
 866 static int32_t ServerInit (void) {
 867
 868   if (server_ok == -1) {                // If -1, means it was not yet checked
 869     server_ok = 1;
 870
 871     if (drv->Control(ARM_SPI_MODE_MASTER                                                                |
 872                    ((SPI_CFG_SRV_FORMAT    << ARM_SPI_FRAME_FORMAT_Pos)   & ARM_SPI_FRAME_FORMAT_Msk)   |
 873                    ((SPI_CFG_SRV_DATA_BITS << ARM_SPI_DATA_BITS_Pos)      & ARM_SPI_DATA_BITS_Msk)      |
 874                    ((SPI_CFG_SRV_BIT_ORDER << ARM_SPI_BIT_ORDER_Pos)      & ARM_SPI_BIT_ORDER_Msk)      |
 875                    ((SPI_CFG_SRV_SS_MODE   << ARM_SPI_SS_MASTER_MODE_Pos) & ARM_SPI_SS_MASTER_MODE_Msk) ,
 876                      SPI_CFG_SRV_BUS_SPEED) != ARM_DRIVER_OK) {
 877       server_ok = 0;
 878     }
 879     if ((server_ok == 1) && (SPI_CFG_SRV_SS_MODE == SS_MODE_MASTER_SW)) {
 880       if (drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE) != ARM_DRIVER_OK) {
 881         server_ok = 0;
 882       }
 883     }
 884     if (server_ok == 0) {
 885       TEST_GROUP_INFO("Failed to configure communication interface to SPI Server default settings.\n"\
 886                       "Driver must support basic settings used for communication with SPI Server!");
 887     }
 888
 889     if (server_ok == 1) {
 890       (void)osDelay(10U);
 891       if (CmdGetVer() != EXIT_SUCCESS) {
 892         TEST_GROUP_INFO("Failed to Get version from SPI Server.\nCheck SPI Server!\n");
 893         server_ok = 0;
 894       }
 895     }
 896
 897     if (server_ok == 1) {
 898       if ((spi_serv_ver.major <= 1U) && (spi_serv_ver.minor < 1U)) {
 899         TEST_GROUP_INFO("SPI Server version must be 1.1.0. or higher.\nUpdate SPI Server to newer version!\n");
 900         server_ok = 0;
 901       }
 902     }
 903
 904     if (server_ok == 1) {
 905       if (CmdGetCap() != EXIT_SUCCESS) {
 906         TEST_GROUP_INFO("Failed to Get capabilities from SPI Server.\nCheck SPI Server!\n");
 907         server_ok = 0;
 908       }
 909     }
 910   }
 911
 912   if (server_ok == 1) {
 913     return EXIT_SUCCESS;
 914   }
 915
 916   return EXIT_FAILURE;
 917 }
 918
 919 /*
 920   \fn            static int32_t ServerCheck (void)
 921   \brief         Check if communication with SPI Server is working.
 922   \return        execution status
 923                    - EXIT_SUCCESS: If SPI Server status is ok
 924                    - EXIT_FAILURE: If SPI Server status is fail
 925 */
 926 static int32_t ServerCheck (void) {
 927
 928   if (server_ok == 1) {
 929     return EXIT_SUCCESS;
 930   }
 931
 932   TEST_FAIL_MESSAGE("[FAILED] SPI Server status. Check SPI Server! Test aborted!");
 933   return EXIT_FAILURE;
 934 }
 935
 936 /*
 937   \fn            static int32_t ServerCheckSupport (uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t bus_speed)
 938   \brief         Check if SPI Server supports desired settings.
 939   \param[in]     mode           mode (0 = Master, 1 = slave)
 940   \param[in]     format         clock / frame format:
 941                                   - value 0 = clock polarity 0, phase 0
 942                                   - value 1 = clock polarity 0, phase 1
 943                                   - value 2 = clock polarity 1, phase 0
 944                                   - value 3 = clock polarity 1, phase 1
 945                                   - value 4 = Texas Instruments frame format
 946                                   - value 5 = Microwire frame format
 947   \param[in]     data_bits      data bits
 948                                   - values 1 to 32
 949   \param[in]     bit_order      bit order
 950                                   - value 0 = MSB to LSB
 951                                   - value 1 = LSB to MSB
 952   \param[in]     bus_speed      bus speed in bits per second (bps)
 953   \return        execution status
 954                    - EXIT_SUCCESS: SPI Server supports desired settings
 955                    - EXIT_FAILURE: SPI Server does not support desired settings
 956 */
 957 static int32_t ServerCheckSupport (uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t bus_speed) {
 958
 959   if ((spi_serv_cap.mode_mask & (1UL << (mode - 1U))) == 0U) {
 960     // If SPI Server does not support desired mode
 961     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] SPI Server does not support %s mode! Test aborted!", str_mode[mode - 1U]);
 962     TEST_MESSAGE(msg_buf);
 963     return EXIT_FAILURE;
 964   }
 965   if ((spi_serv_cap.fmt_mask & (1UL << format)) == 0U) {
 966     // If SPI Server does not support desired clock / frame format
 967     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] SPI Server does not support %s clock / frame format! Test aborted!", str_format[format]);
 968     TEST_MESSAGE(msg_buf);
 969     return EXIT_FAILURE;
 970   }
 971   if ((spi_serv_cap.db_mask & (1UL << (data_bits - 1U))) == 0U) {
 972     // If SPI Server does not support desired data bits
 973     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] SPI Server does not support %i data bits! Test aborted!", data_bits);
 974     TEST_MESSAGE(msg_buf);
 975     return EXIT_FAILURE;
 976   }
 977   if ((spi_serv_cap.bo_mask & (1UL << bit_order)) == 0U) {
 978     // If SPI Server does not support desired bit order
 979     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] SPI Server does not support %s bit order! Test aborted!", str_bit_order[bit_order]);
 980     TEST_MESSAGE(msg_buf);
 981     return EXIT_FAILURE;
 982   }
 983   if ((spi_serv_cap.bs_min > bus_speed) ||
 984       (spi_serv_cap.bs_max < bus_speed)) {
 985     // If SPI Server does not support desired bus speed
 986     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] SPI Server does not support %i bps bus speed! Test aborted!", bus_speed);
 987     TEST_MESSAGE(msg_buf);
 988     return EXIT_FAILURE;
 989   }
 990
 991   return EXIT_SUCCESS;
 992 }
 993
 994 #endif                                  // If Test Mode SPI Server is selected
 995
 996 /*
 997   \fn            static int32_t IsNotLoopback (void)
 998   \brief         Check if loopback is not selected.
 999   \detail        This function is used to skip executing a test if it is not supported
1000                  in Loopback mode.
1001   \return        execution status
1002                    - EXIT_SUCCESS: Loopback is not selected
1003                    - EXIT_FAILURE: Loopback is selected
1004 */
1005 static int32_t IsNotLoopback (void) {
1006
1007 #if (SPI_SERVER_USED == 1)
1008   return EXIT_SUCCESS;
1009 #else
1010   TEST_MESSAGE("[WARNING] Test not supported in Loopback Test Mode! Test not executed!");
1011   return EXIT_FAILURE;
1012 #endif
1013 }
1014
1015 /*
1016   \fn            static int32_t IsNotFrameTI (void)
1017   \brief         Check if Default Clock / Frame Format selected is not Texas Instruments.
1018   \detail        This function is used to skip executing a test if it is not supported
1019                  for Texas Instruments Frame Format.
1020   \return        execution status
1021                    - EXIT_SUCCESS: Texas Instruments Frame Format is not selected
1022                    - EXIT_FAILURE: Texas Instruments Frame Format is selected
1023 */
1024 static int32_t IsNotFrameTI (void) {
1025
1026 #if (SPI_CFG_DEF_FORMAT != FORMAT_TI)
1027   return EXIT_SUCCESS;
1028 #else
1029   TEST_MESSAGE("[WARNING] Test not supported for Texas Instruments Frame Format! Test not executed!");
1030   return EXIT_FAILURE;
1031 #endif
1032 }
1033
1034 /*
1035   \fn            static int32_t IsNotFrameMw (void)
1036   \brief         Check if Default Clock / Frame Format selected is not National Semiconductor Microwire.
1037   \detail        This function is used to skip executing a test if it is not supported
1038                  for National Semiconductor Microwire Frame Format.
1039   \return        execution status
1040                    - EXIT_SUCCESS: National Semiconductor Microwire Frame Format is not selected
1041                    - EXIT_FAILURE: National Semiconductor Microwire Frame Format is selected
1042 */
1043 static int32_t IsNotFrameMw (void) {
1044
1045 #if (SPI_CFG_DEF_FORMAT != FORMAT_MICROWIRE)
1046   return EXIT_SUCCESS;
1047 #else
1048   TEST_MESSAGE("[WARNING] Test not supported for National Semiconductor Microwire Frame Format! Test not executed!");
1049   return EXIT_FAILURE;
1050 #endif
1051 }
1052
1053 /*
1054   \fn            static int32_t IsFormatValid (void)
1055   \brief         Check if default format settings are valid.
1056   \detail        This function is used to abort executing a test if Default settings
1057                  specify TI or Microwire Frame Format and Slave Select handling
1058                  other than Hardware controlled.
1059   \return        execution status
1060                    - EXIT_SUCCESS: Format is valid
1061                    - EXIT_FAILURE: Format is not valid
1062 */
1063 static int32_t IsFormatValid (void) {
1064
1065 #if   ((SPI_CFG_DEF_FORMAT == FORMAT_TI) && (SPI_CFG_DEF_SS_MODE != SS_MODE_MASTER_HW_OUTPUT))
1066   TEST_MESSAGE("[WARNING] TI Frame Format works only with Hardware controlled Slave Select! Test not executed!");
1067   return EXIT_FAILURE;
1068 #elif ((SPI_CFG_DEF_FORMAT == FORMAT_MICROWIRE) && (SPI_CFG_DEF_SS_MODE != SS_MODE_MASTER_HW_OUTPUT))
1069   TEST_MESSAGE("[WARNING] Microwire Frame Format works only with Hardware controlled Slave Select! Test not executed!");
1070   return EXIT_FAILURE;
1071 #else
1072   return EXIT_SUCCESS;
1073 #endif
1074 }
1075
1076 /*
1077   \fn            static int32_t IsBitOrderValid (void)
1078   \brief         Check if default bit order settings valid.
1079   \detail        This function is used to abort executing a test if Default settings
1080                  specify TI or Microwire Frame Format and bit order is not MSB to LSB.
1081   \return        execution status
1082                    - EXIT_SUCCESS: bit order
1083                    - EXIT_FAILURE: bit order
1084 */
1085 static int32_t IsBitOrderValid (void) {
1086
1087 #if   ((SPI_CFG_DEF_FORMAT == FORMAT_TI) && (SPI_CFG_DEF_BIT_ORDER != BO_MSB_TO_LSB))
1088   TEST_MESSAGE("[WARNING] TI Frame Format works only with MSB to LSB bit order! Test not executed!");
1089   return EXIT_FAILURE;
1090 #elif ((SPI_CFG_DEF_FORMAT == FORMAT_MICROWIRE) && (SPI_CFG_DEF_BIT_ORDER != BO_MSB_TO_LSB))
1091   TEST_MESSAGE("[WARNING] Microwire Frame Format works only with MSB to LSB bit order! Test not executed!");
1092   return EXIT_FAILURE;
1093 #else
1094   return EXIT_SUCCESS;
1095 #endif
1096 }
1097
1098 /*
1099   \fn            void SPI_DV_Initialize (void)
1100   \brief         Initialize testing environment for SPI testing.
1101   \detail        This function is called by the driver validation framework before SPI testing begins.
1102                  It initializes global variables and allocates memory buffers (from heap) used for the SPI testing.
1103   \return        none
1104 */
1105 void SPI_DV_Initialize (void) {
1106
1107   // Initialize global variables
1108   buffers_ok   = -1;
1109   server_ok    = -1;
1110   driver_ok    = -1;
1111   event        = 0U;
1112   duration     = 0xFFFFFFFFUL;
1113   systick_freq = osKernelGetSysTimerFreq();
1114
1115   memset(&spi_serv_cap, 0, sizeof(spi_serv_cap));
1116   memset(&msg_buf,      0, sizeof(msg_buf));
1117
1118   // Allocate buffers for transmission, reception and comparison
1119   // (maximum size is incremented by 32 bytes to ensure that buffer can be aligned to 32 bytes)
1120
1121   ptr_tx_buf_alloc = malloc(SPI_BUF_MAX + 32U);
1122   if (((uint32_t)ptr_tx_buf_alloc & 31U) != 0U) {
1123     // If allocated memory is not 32 byte aligned, use next 32 byte aligned address for ptr_tx_buf
1124     ptr_tx_buf = (uint8_t *)((((uint32_t)ptr_tx_buf_alloc) + 31U) & (~31U));
1125   } else {
1126     // If allocated memory is 32 byte aligned, use it directly
1127     ptr_tx_buf = (uint8_t *)ptr_tx_buf_alloc;
1128   }
1129   ptr_rx_buf_alloc = malloc(SPI_BUF_MAX + 32U);
1130   if (((uint32_t)ptr_rx_buf_alloc & 31U) != 0U) {
1131     ptr_rx_buf = (uint8_t *)((((uint32_t)ptr_rx_buf_alloc) + 31U) & (~31U));
1132   } else {
1133     ptr_rx_buf = (uint8_t *)ptr_rx_buf_alloc;
1134   }
1135   ptr_cmp_buf_alloc = malloc(SPI_BUF_MAX + 32U);
1136   if (((uint32_t)ptr_cmp_buf_alloc & 31U) != 0U) {
1137     ptr_cmp_buf = (uint8_t *)((((uint32_t)ptr_cmp_buf_alloc) + 31U) & (~31U));
1138   } else {
1139     ptr_cmp_buf = (uint8_t *)ptr_cmp_buf_alloc;
1140   }
1141
1142   event_flags = osEventFlagsNew(NULL);
1143
1144   // Output configuration settings
1145   (void)snprintf(msg_buf,
1146                  sizeof(msg_buf),
1147                  "Test Mode:          %s\n"\
1148                  "Default settings:\n"\
1149                  " - Slave Select:    %s\n"\
1150                  " - Format:          %s\n"\
1151                  " - Data bits:       %i\n"\
1152                  " - Bit order:       %s\n"\
1153                  " - Bus speed:       %i bps\n"\
1154                  " - Number of Items: %i",
1155                  str_test_mode[SPI_CFG_TEST_MODE],
1156                  str_ss_mode  [SPI_CFG_DEF_SS_MODE],
1157                  str_format   [SPI_CFG_DEF_FORMAT],
1158                  SPI_CFG_DEF_DATA_BITS,
1159                  str_bit_order[SPI_CFG_DEF_BIT_ORDER],
1160                  SPI_CFG_DEF_BUS_SPEED,
1161                  SPI_CFG_DEF_NUM);
1162   TEST_GROUP_INFO(msg_buf);
1163
1164 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
1165   // Test communication with SPI Server
1166   int32_t  server_status;
1167   uint32_t str_len;
1168
1169   // Test communication with SPI Server
1170   if (drv->Initialize    (SPI_DrvEvent)   == ARM_DRIVER_OK) {
1171     if (drv->PowerControl(ARM_POWER_FULL) == ARM_DRIVER_OK) {
1172       server_status = ServerInit();
1173     }
1174   }
1175   (void)drv->PowerControl(ARM_POWER_OFF);
1176   (void)drv->Uninitialize();
1177
1178 //(void)snprintf(msg_buf, sizeof(msg_buf), "Server status:    %s\n", str_srv_status[server_status]);
1179 //TEST_GROUP_INFO(msg_buf);
1180 #endif
1181 }
1182
1183 /*
1184   \fn            void SPI_DV_Uninitialize (void)
1185   \brief         De-initialize testing environment after SPI testing.
1186   \detail        This function is called by the driver validation framework after SPI testing is finished.
1187                  It frees memory buffers used for the SPI testing.
1188   \return        none
1189 */
1190 void SPI_DV_Uninitialize (void) {
1191
1192   (void)osEventFlagsDelete(event_flags);
1193
1194   if (ptr_tx_buf_alloc != NULL) {
1195     free(ptr_tx_buf_alloc);
1196     ptr_tx_buf        = NULL;
1197     ptr_tx_buf_alloc  = NULL;
1198   }
1199   if (ptr_rx_buf_alloc != NULL) {
1200     free(ptr_rx_buf_alloc);
1201     ptr_rx_buf        = NULL;
1202     ptr_rx_buf_alloc  = NULL;
1203   }
1204   if (ptr_cmp_buf_alloc != NULL) {
1205     free(ptr_cmp_buf_alloc);
1206     ptr_cmp_buf       = NULL;
1207     ptr_cmp_buf_alloc = NULL;
1208   }
1209 }
1210
1211 #endif                                  // End of exclude form the documentation
1212
1213 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1214 /**
1215 \defgroup dv_spi SPI Validation
1216 \brief SPI driver validation
1217 \details
1218 The SPI validation performs the following tests:
1219 - API interface compliance
1220 - Data exchange with various speeds, transfer sizes and communication settings
1221 - Event signaling
1222
1223 Two Test Modes are available: <b>Loopback</b> and <b>SPI Server</b>.
1224
1225 Test Mode : <b>Loopback</b>
1226 ---------------------------
1227
1228 This test mode allows only limited validation of the SPI Driver.<br>
1229 It is recommended that this test mode is used only as a proof that driver is
1230 good enough to be tested with the <b>SPI Server</b>.
1231
1232 For this purpose following <b>Default settings</b> should be used:
1233  - Slave Select: Not used
1234  - Clock / Frame Format: Clock Polarity 0, Clock Phase 0
1235  - Data Bits: 8
1236  - Bit Order: MSB to LSB
1237  - Bus Speed: same as setting for the SPI Server
1238  - Number of Items: 32
1239
1240 To enable this mode of testing in the <b>DV_SPI_Config.h</b> configuration file select the
1241 <b>Configuration: Test Mode: Loopback</b> setting.
1242
1243 Required pin connection for the <b>Loopback</b> test mode:
1244
1245 \image html spi_loopback_pin_connections.png
1246
1247 \note In this mode following operations / settings cannot be tested:
1248  - SPI slave mode
1249  - Slave Select line functionality
1250  - operation of the Receive function
1251  - data content sent by the Send function
1252  - clock / frame format and bit order settings
1253  - data bit settings other then: 8, 16, 24 and 32
1254  - event signaling
1255
1256 Test Mode : <b>SPI Server</b>
1257 -----------------------------
1258
1259 This test mode allows extensive validation of the SPI Driver.<br>
1260 Results of the Driver Validation in this test mode are relevant as a proof of driver compliance
1261 to the CMSIS-Driver specification.
1262
1263 To perform extensive communication tests, it is required to use an
1264 \ref spi_server "SPI Server" running on a dedicated hardware.
1265
1266 To enable this mode of testing in the <b>DV_SPI_Config.h</b> configuration file select the
1267 <b>Configuration: Test Mode: SPI Server</b> setting.
1268
1269 Required pin connections for the <b>SPI Server</b> test mode:
1270
1271 \image html spi_server_pin_connections.png
1272
1273 \note Slave Select line has to be pulled to Vcc by an external pull-up (for example 10 kOhm).
1274 \note To ensure proper signal quality:
1275        - keep the connecting wires as short as possible
1276        - if possible have SCK and GND wires as a twisted pair and MISO, MOSI and Slave Select
1277          wires separate from each other
1278        - ensure a good Ground (GND) connection between SPI Server and DUT
1279 \note If you experience issues with corrupt data content try reducing bus speed.
1280
1281
1282 \defgroup spi_tests Tests
1283 \ingroup dv_spi
1284 */
1285
1286 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1287 /* SPI Driver Management tests                                                                                              */
1288 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1289 /**
1290 \defgroup spi_tests_drv_mgmt Driver Management
1291 \ingroup spi_tests
1292 \details
1293 These tests verify API and operation of the SPI driver management functions.
1294
1295 The driver management tests verify the following driver functions
1296 (<a href="http://www.keil.com/pack/doc/CMSIS/Driver/html/group__spi__interface__gr.html" target="_blank">SPI Driver function documentation</a>):
1297  - \b GetVersion
1298 \code
1299   ARM_DRIVER_VERSION   GetVersion      (void);
1300 \endcode
1301  - \b GetCapabilities
1302 \code
1303   ARM_SPI_CAPABILITIES GetCapabilities (void);
1304 \endcode
1305  - \b Initialize
1306 \code
1307   int32_t              Initialize      (ARM_SPI_SignalEvent_t cb_event);
1308 \endcode
1309  - \b Uninitialize
1310 \code
1311   int32_t              Uninitialize    (void);
1312 \endcode
1313  - \b PowerControl
1314 \code
1315   int32_t              PowerControl    (ARM_POWER_STATE state);
1316 \endcode
1317
1318 @{
1319 */
1320
1321 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1322 /**
1323 \brief Function: Function SPI_GetVersion
1324 \details
1325 The function \b SPI_GetVersion verifies the \b GetVersion function.
1326 \code
1327   ARM_DRIVER_VERSION GetVersion (void);
1328 \endcode
1329
1330 Testing sequence:
1331   - Driver is uninitialized and peripheral is powered-off:
1332     - Call GetVersion function
1333     - Assert that GetVersion function returned version structure with API and implementation versions higher or equal to 1.0
1334 */
1335 void SPI_GetVersion (void) {
1336   ARM_DRIVER_VERSION ver;
1337
1338   ver = drv->GetVersion();
1339
1340   // Assert that GetVersion function returned version structure with API and implementation versions higher or equal to 1.0
1341   TEST_ASSERT((ver.api >= ARM_DRIVER_VERSION_MAJOR_MINOR(1UL,0UL)) && (ver.drv >= ARM_DRIVER_VERSION_MAJOR_MINOR(1UL,0UL)));
1342
1343   (void)snprintf(msg_buf, sizeof(msg_buf), "[INFO] Driver API version %d.%d, Driver version %d.%d", (ver.api >> 8), (ver.api & 0xFFU), (ver.drv >> 8), (ver.drv & 0xFFU));
1344   TEST_MESSAGE(msg_buf);
1345 }
1346
1347 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1348 /**
1349 \brief Function: Function SPI_GetCapabilities
1350 \details
1351 The function \b SPI_GetCapabilities verifies the \b GetCapabilities function.
1352 \code
1353   ARM_SPI_CAPABILITIES GetCapabilities (void);
1354 \endcode
1355
1356 Testing sequence:
1357   - Driver is uninitialized and peripheral is powered-off:
1358     - Call GetCapabilities function
1359     - Assert that GetCapabilities function returned capabilities structure with reserved field 0
1360 */
1361 void SPI_GetCapabilities (void) {
1362   ARM_SPI_CAPABILITIES cap;
1363
1364   cap = drv->GetCapabilities();
1365
1366   // Assert that GetCapabilities function returned capabilities structure with reserved field 0
1367   TEST_ASSERT_MESSAGE((cap.reserved == 0U), "[FAILED] Capabilities reserved field must be 0");
1368 }
1369
1370 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1371 /**
1372 \brief Function: Function SPI_Initialize_Uninitialize
1373 \details
1374 The function \b SPI_Initialize_Uninitialize verifies the \b Initialize and \b Uninitialize functions.
1375 \code
1376   int32_t Initialize (ARM_SPI_SignalEvent_t cb_event);
1377 \endcode
1378 \code
1379   int32_t Uninitialize (void);
1380 \endcode
1381
1382 Testing sequence:
1383   - Driver is uninitialized and peripheral is powered-off:
1384     - Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_ERROR status
1385     - Call PowerControl(ARM_POWER_LOW) function and assert that it returned ARM_DRIVER_ERROR status
1386     - Call PowerControl(ARM_POWER_OFF) function and assert that it returned ARM_DRIVER_ERROR status
1387     - Call Send function and assert that it returned ARM_DRIVER_ERROR status
1388     - Call Receive function and assert that it returned ARM_DRIVER_ERROR status
1389     - Call Transfer function and assert that it returned ARM_DRIVER_ERROR status
1390     - Call GetDataCount function and assert that it returned 0
1391     - Call Control function and assert that it returned ARM_DRIVER_ERROR status
1392     - Call GetStatus function
1393     - Assert that GetStatus function returned status structure with busy flag 0
1394     - Assert that GetStatus function returned status structure with data_lost flag 0
1395     - Assert that GetStatus function returned status structure with mode_fault flag 0
1396     - Assert that GetStatus function returned status structure with reserved field 0
1397     - Call Initialize function (without callback specified) and assert that it returned ARM_DRIVER_OK status
1398   - Driver is initialized and peripheral is powered-off:
1399     - Call Initialize function (without callback specified) again and assert that it returned ARM_DRIVER_OK status
1400     - Call Uninitialize function and assert that it returned ARM_DRIVER_OK status
1401   - Driver is uninitialized and peripheral is powered-off:
1402     - Call Initialize function (with callback specified) and assert that it returned ARM_DRIVER_OK status
1403   - Driver is initialized and peripheral is powered-off:
1404     - Call Initialize function (with callback specified) again and assert that it returned ARM_DRIVER_OK status
1405     - Call Uninitialize function and assert that it returned ARM_DRIVER_OK status
1406   - Driver is uninitialized and peripheral is powered-off:
1407     - Call Uninitialize function again and assert that it returned ARM_DRIVER_OK status
1408     - Call Initialize function (without callback specified) and assert that it returned ARM_DRIVER_OK status
1409   - Driver is initialized and peripheral is powered-off:
1410     - Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_OK status
1411   - Driver is initialized and peripheral is powered-on:
1412     - Call Control function and assert that it returned ARM_DRIVER_OK status
1413     - Call Transfer function and assert that it returned ARM_DRIVER_OK status
1414     - Call GetStatus function
1415     - Assert that GetStatus function returned status structure with busy flag 1
1416     - Call Uninitialize function with transfer active and assert that it returned ARM_DRIVER_OK status<br>
1417       (this must unconditionally terminate active transfer, power-off the peripheral and uninitialize the driver)
1418   - Driver is uninitialized and peripheral is powered-off:
1419     - Call GetStatus function
1420     - Assert that GetStatus function returned status structure with busy flag 0
1421 */
1422 void SPI_Initialize_Uninitialize (void) {
1423   ARM_SPI_STATUS stat;
1424
1425   // Driver is uninitialized and peripheral is powered-off:
1426   // Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_ERROR status
1427   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_ERROR);
1428
1429   // Call PowerControl(ARM_POWER_LOW) function and assert that it returned ARM_DRIVER_ERROR status
1430   TEST_ASSERT(drv->PowerControl (ARM_POWER_LOW) == ARM_DRIVER_ERROR);
1431
1432   // Call PowerControl(ARM_POWER_OFF) function and assert that it returned ARM_DRIVER_ERROR status
1433   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_ERROR);
1434
1435   // Call Send function and assert that it returned ARM_DRIVER_ERROR status
1436   TEST_ASSERT(drv->Send (ptr_tx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_ERROR);
1437
1438   // Call Receive function and assert that it returned ARM_DRIVER_ERROR status
1439   TEST_ASSERT(drv->Receive (ptr_rx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_ERROR);
1440
1441   // Call Transfer function and assert that it returned ARM_DRIVER_ERROR status
1442   TEST_ASSERT(drv->Transfer (ptr_tx_buf, ptr_rx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_ERROR);
1443
1444   // Call GetDataCount function and assert that it returned 0
1445   TEST_ASSERT(drv->GetDataCount () == 0U);
1446
1447   // Call Control function and assert that it returned ARM_DRIVER_ERROR status
1448   TEST_ASSERT(drv->Control (ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(SPI_CFG_DEF_DATA_BITS), SPI_CFG_DEF_BUS_SPEED) == ARM_DRIVER_ERROR);
1449
1450   // Call GetStatus function
1451   stat = drv->GetStatus();
1452
1453   // Assert that GetStatus function returned status structure with busy flag 0
1454   TEST_ASSERT(stat.busy == 0U);
1455
1456   // Assert that GetStatus function returned status structure with data_lost flag 0
1457   TEST_ASSERT(stat.data_lost == 0U);
1458
1459   // Assert that GetStatus function returned status structure with mode_fault flag 0
1460   TEST_ASSERT(stat.mode_fault == 0U);
1461
1462   // Assert that GetStatus function returned status structure with reserved field 0
1463   TEST_ASSERT(stat.reserved == 0U);
1464
1465   // Call Initialize function (without callback specified) and assert that it returned ARM_DRIVER_OK status
1466   TEST_ASSERT(drv->Initialize (NULL) == ARM_DRIVER_OK);
1467
1468   // Driver is initialized and peripheral is powered-off:
1469   // Call Initialize function (without callback specified) again and assert that it returned ARM_DRIVER_OK status
1470   TEST_ASSERT(drv->Initialize (NULL) == ARM_DRIVER_OK);
1471
1472   // Call Uninitialize function and assert that it returned ARM_DRIVER_OK status
1473   TEST_ASSERT(drv->Uninitialize () == ARM_DRIVER_OK);
1474
1475   // Driver is uninitialized and peripheral is powered-off:
1476   // Call Initialize function (with callback specified) and assert that it returned ARM_DRIVER_OK status
1477   TEST_ASSERT(drv->Initialize (SPI_DrvEvent) == ARM_DRIVER_OK);
1478
1479   // Driver is initialized and peripheral is powered-off:
1480   // Call Initialize function (with callback specified) again and assert that it returned ARM_DRIVER_OK status
1481   TEST_ASSERT(drv->Initialize (SPI_DrvEvent) == ARM_DRIVER_OK);
1482
1483   // Call Uninitialize function and assert that it returned ARM_DRIVER_OK status
1484   TEST_ASSERT(drv->Uninitialize () == ARM_DRIVER_OK);
1485
1486   // Driver is uninitialized and peripheral is powered-off:
1487   // Call Uninitialize function again and assert that it returned ARM_DRIVER_OK status
1488   TEST_ASSERT(drv->Uninitialize () == ARM_DRIVER_OK);
1489
1490   // Call Initialize function (without callback specified) and assert that it returned ARM_DRIVER_OK status
1491   TEST_ASSERT(drv->Initialize (NULL) == ARM_DRIVER_OK);
1492
1493   // Driver is initialized and peripheral is powered-off:
1494   // Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_OK status
1495   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
1496
1497   // Driver is initialized and peripheral is powered-on:
1498   // Call Control function and assert that it returned ARM_DRIVER_OK status
1499   TEST_ASSERT(drv->Control (ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(SPI_CFG_DEF_DATA_BITS), SPI_CFG_DEF_BUS_SPEED) == ARM_DRIVER_OK);
1500
1501   // Call Transfer function and assert that it returned ARM_DRIVER_OK status
1502   TEST_ASSERT(drv->Transfer (ptr_tx_buf, ptr_rx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_OK);
1503
1504   // Call GetStatus function
1505   stat = drv->GetStatus();
1506
1507   // Assert that GetStatus function returned status structure with busy flag 1
1508   TEST_ASSERT(stat.busy == 1U);
1509
1510   // Call Uninitialize function and assert that it returned ARM_DRIVER_OK status
1511   // (this must unconditionally terminate active transfer, power-off the peripheral and uninitialize the driver)
1512   TEST_ASSERT(drv->Uninitialize () == ARM_DRIVER_OK);
1513
1514   // Driver is uninitialized and peripheral is powered-off:
1515   // Call GetStatus function
1516   stat = drv->GetStatus();
1517
1518   // Assert that GetStatus function returned status structure with busy flag 0
1519   TEST_ASSERT(stat.busy == 0U);
1520
1521 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
1522   // Ensure that SPI Server (if used) is ready for command reception
1523   (void)osDelay(20U);
1524 #endif
1525 }
1526
1527 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1528 /**
1529 \brief Function: Function SPI_PowerControl
1530 \details
1531 The function \b SPI_PowerControl verifies the \b PowerControl function.
1532 \code
1533   int32_t PowerControl (ARM_POWER_STATE state);
1534 \endcode
1535
1536 Testing sequence:
1537   - Driver is initialized and peripheral is powered-off:
1538     - Call Send function and assert that it returned ARM_DRIVER_ERROR status
1539     - Call Receive function and assert that it returned ARM_DRIVER_ERROR status
1540     - Call Transfer function and assert that it returned ARM_DRIVER_ERROR status
1541     - Call GetDataCount function and assert that it returned 0
1542     - Call Control function and assert that it returned ARM_DRIVER_ERROR status
1543     - Call GetStatus function
1544     - Assert that GetStatus function returned status structure with busy flag 0
1545     - Assert that GetStatus function returned status structure with data_lost flag 0
1546     - Assert that GetStatus function returned status structure with mode_fault flag 0
1547     - Assert that GetStatus function returned status structure with reserved field 0
1548     - Call PowerControl(ARM_POWER_OFF) and assert that it returned ARM_DRIVER_OK status
1549     - Call PowerControl(ARM_POWER_OFF) again and assert that it returned ARM_DRIVER_OK status
1550     - Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_OK status
1551   - Driver is initialized and peripheral is powered-on:
1552     - Call PowerControl(ARM_POWER_FULL) function again and assert that it returned ARM_DRIVER_OK status
1553     - Call PowerControl(ARM_POWER_OFF) and assert that it returned ARM_DRIVER_OK status
1554   - Driver is initialized and peripheral is powered-off:
1555     - Call PowerControl(ARM_POWER_OFF) again and assert that it returned ARM_DRIVER_OK status
1556     - Call PowerControl(ARM_POWER_LOW) function
1557   - Driver is initialized and peripheral is powered-on or in low-power mode:
1558     - Assert that PowerControl(ARM_POWER_LOW) function returned ARM_DRIVER_OK or ARM_DRIVER_ERROR_UNSUPPORTED status
1559     - Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_OK status
1560   - Driver is initialized and peripheral is powered-on:
1561     - Call Control function and assert that it returned ARM_DRIVER_OK status
1562     - Call Transfer function and assert that it returned ARM_DRIVER_OK status
1563     - Call GetStatus function
1564     - Assert that GetStatus function returned status structure with busy flag 1
1565     - Call PowerControl(ARM_POWER_OFF) function with transfer active and assert that it returned ARM_DRIVER_OK status<br>
1566       (this must unconditionally terminate active transfer and power-off the peripheral)
1567   - Driver is initialized and peripheral is powered-off:
1568     - Call GetStatus function
1569     - Assert that GetStatus function returned status structure with busy flag 0
1570 */
1571 void SPI_PowerControl (void) {
1572   int32_t        ret;
1573   ARM_SPI_STATUS stat;
1574
1575   (void)drv->Initialize (NULL);
1576
1577   // Driver is initialized and peripheral is powered-off:
1578   // Call Send function and assert that it returned ARM_DRIVER_ERROR status
1579   TEST_ASSERT(drv->Send (ptr_tx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_ERROR);
1580
1581   // Call Receive function and assert that it returned ARM_DRIVER_ERROR status
1582   TEST_ASSERT(drv->Receive (ptr_rx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_ERROR);
1583
1584   // Call Transfer function and assert that it returned ARM_DRIVER_ERROR status
1585   TEST_ASSERT(drv->Transfer (ptr_tx_buf, ptr_rx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_ERROR);
1586
1587   // Call GetDataCount function and assert that it returned 0
1588   TEST_ASSERT(drv->GetDataCount () == 0U);
1589
1590   // Call Control function and assert that it returned ARM_DRIVER_ERROR status
1591   TEST_ASSERT(drv->Control (ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(SPI_CFG_DEF_DATA_BITS), SPI_CFG_DEF_BUS_SPEED) == ARM_DRIVER_ERROR);
1592
1593   // Call GetStatus function
1594   stat = drv->GetStatus();
1595
1596   // Assert that GetStatus function returned status structure with busy flag 0
1597   TEST_ASSERT(stat.busy == 0U);
1598
1599   // Assert that GetStatus function returned status structure with data_lost flag 0
1600   TEST_ASSERT(stat.data_lost == 0U);
1601
1602   // Assert that GetStatus function returned status structure with mode_fault flag 0
1603   TEST_ASSERT(stat.mode_fault == 0U);
1604
1605   // Assert that GetStatus function returned status structure with reserved field 0
1606   TEST_ASSERT(stat.reserved == 0U);
1607
1608   // Call PowerControl(ARM_POWER_OFF) and assert that it returned ARM_DRIVER_OK status
1609   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
1610
1611   // Call PowerControl(ARM_POWER_OFF) again and assert that it returned ARM_DRIVER_OK status
1612   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
1613
1614   // Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_OK status
1615   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
1616
1617   // Driver is initialized and peripheral is powered-on:
1618   // Call PowerControl(ARM_POWER_FULL) function again and assert that it returned ARM_DRIVER_OK status
1619   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
1620
1621   // Call PowerControl(ARM_POWER_OFF) and assert that it returned ARM_DRIVER_OK status
1622   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
1623
1624   // Driver is initialized and peripheral is powered-off:
1625   // Call PowerControl(ARM_POWER_OFF) again and assert that it returned ARM_DRIVER_OK status
1626   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
1627
1628   // Call PowerControl(ARM_POWER_LOW) function
1629   ret = drv->PowerControl (ARM_POWER_LOW);
1630
1631   // Driver is initialized and peripheral is powered-on or in low-power mode:
1632   // Assert that PowerControl(ARM_POWER_LOW) function returned ARM_DRIVER_OK or ARM_DRIVER_ERROR_UNSUPPORTED status
1633   TEST_ASSERT((ret == ARM_DRIVER_OK) || (ret == ARM_DRIVER_ERROR_UNSUPPORTED));
1634   if (ret == ARM_DRIVER_ERROR_UNSUPPORTED) {
1635     TEST_MESSAGE("[WARNING] PowerControl (ARM_POWER_LOW) is not supported");
1636   }
1637
1638   // Call PowerControl(ARM_POWER_FULL) function and assert that it returned ARM_DRIVER_OK status
1639   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
1640
1641   // Driver is initialized and peripheral is powered-on:
1642   // Call Control function and assert that it returned ARM_DRIVER_OK status
1643   TEST_ASSERT(drv->Control (ARM_SPI_MODE_MASTER | ARM_SPI_DATA_BITS(SPI_CFG_DEF_DATA_BITS), SPI_CFG_DEF_BUS_SPEED) == ARM_DRIVER_OK);
1644
1645   // Call Transfer function and assert that it returned ARM_DRIVER_OK status
1646   TEST_ASSERT(drv->Transfer (ptr_tx_buf, ptr_rx_buf, SPI_CFG_DEF_NUM) == ARM_DRIVER_OK);
1647
1648   // Call GetStatus function
1649   stat = drv->GetStatus();
1650
1651   // Assert that GetStatus function returned status structure with busy flag 1
1652   TEST_ASSERT(stat.busy == 1U);
1653
1654   // Call PowerControl(ARM_POWER_OFF) function with transfer active and assert that it returned ARM_DRIVER_OK status
1655   // (this must unconditionally terminate active transfer and power-off the peripheral)
1656   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
1657
1658   // Driver is initialized and peripheral is powered-off:
1659   // Call GetStatus function
1660   stat = drv->GetStatus();
1661
1662   // Assert that GetStatus function returned status structure with busy flag 0
1663   TEST_ASSERT(stat.busy == 0U);
1664
1665   (void)drv->Uninitialize ();
1666
1667 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
1668   // Ensure that SPI Server (if used) is ready for command reception
1669   (void)osDelay(20U);
1670 #endif
1671 }
1672
1673 /**
1674 @}
1675 */
1676 // End of spi_tests_drv_mgmt
1677
1678 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1679 /* SPI Data Exchange tests                                                                                                  */
1680 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
1681 /**
1682 \defgroup spi_tests_data_xchg Data Exchange
1683 \ingroup spi_tests
1684 \details
1685 These tests verify API and operation of the SPI data exchange functions.
1686
1687 The data exchange tests verify the following driver functions
1688 (<a href="http://www.keil.com/pack/doc/CMSIS/Driver/html/group__spi__interface__gr.html" target="_blank">SPI Driver function documentation</a>):
1689  - \b Send
1690 \code
1691   int32_t        Send         (const void *data,                    uint32_t num);
1692 \endcode
1693  - \b Receive
1694 \code
1695   int32_t        Receive      (      void *data,                    uint32_t num);
1696 \endcode
1697  - \b Transfer
1698 \code
1699   int32_t        Transfer     (const void *data_out, void *data_in, uint32_t num);
1700 \endcode
1701  - \b GetDataCount
1702 \code
1703   uint32_t       GetDataCount (void);
1704 \endcode
1705  - \b Control
1706 \code
1707   int32_t        Control      (uint32_t control, uint32_t arg);
1708 \endcode
1709  - \b GetStatus
1710 \code
1711   ARM_SPI_STATUS GetStatus    (void);
1712 \endcode
1713  - \b SignalEvent
1714 \code
1715   void (*ARM_SPI_SignalEvent_t) (uint32_t event);
1716 \endcode
1717
1718 All of these tests execute a data exchange and check the result of this data exchange.
1719
1720 Data exchange test procedure when Test Mode <b>SPI Server</b> is selected:
1721   - send command "SET BUF TX,.." to the SPI Server: Set Tx buffer
1722   - send command "SET BUF RX,.." to the SPI Server: Set Rx buffer
1723   - send command "SET COM .."    to the SPI Server: Set communication settings for the next XFER command
1724   - send command "XFER .."       to the SPI Server: Specify transfer
1725   - driver Control: Configure the SPI interface
1726   - driver Control: Set the default Tx value
1727   - driver Send/Receive/Transfer: Start the requested operation
1728   - driver GetStatus/SignalEvent: Wait for the current operation to finish or time-out<br>
1729     (operation is finished when busy flag is 0 and completed event was signaled)
1730   - assert that operation has finished in expected time
1731   - assert that ARM_SPI_EVENT_TRANSFER_COMPLETE event was signaled
1732   - driver GetStatus: Assert that busy flag is 0
1733   - driver GetDataCount: Assert that number of transferred items is same as requested
1734   - if operation has timed out call driver Control function to Abort operation and wait timeout time<br>
1735     to make sure that the SPI Server is ready for the next command
1736   - assert that received content is as expected
1737   - send command "GET BUF RX,.." to the SPI Server: Get Rx buffer
1738   - assert that sent content (read from the SPI Server's receive buffer) is as expected
1739
1740 Data exchange <b>Abort</b> test procedure when Test Mode <b>SPI Server</b> is selected:
1741   - send command "SET BUF TX,.." to the SPI Server: Set Tx buffer
1742   - send command "SET BUF RX,.." to the SPI Server: Set Rx buffer
1743   - send command "SET COM .."    to the SPI Server: Set communication settings for the next XFER command
1744   - send command "XFER .."       to the SPI Server: Specify transfer
1745   - driver Control: Configure the SPI interface
1746   - driver Control: Set the default Tx value
1747   - driver Send/Receive/Transfer: Start the requested operation
1748   - wait up to 1 ms
1749   - driver Control: Abort the current operation
1750   - driver GetStatus: Assert that busy flag is 0
1751   - driver GetDataCount: Assert that number of transferred items is less than requested
1752
1753 Data exchange test procedure when Test Mode <b>Loopback</b> is selected:
1754   - driver Control: Configure the SPI interface
1755   - driver Control: Set the default Tx value
1756   - driver Send/Transfer: Start the requested operation
1757   - driver GetStatus/SignalEvent: Wait for the current operation to finish or time-out<br>
1758     (operation is finished when busy flag is 0 and completed event was signaled)
1759   - assert that operation has finished in expected time
1760   - assert that ARM_SPI_EVENT_TRANSFER_COMPLETE event was signaled
1761   - driver GetStatus: Assert that busy flag is 0
1762   - driver GetDataCount: Assert that number of transferred items is same as requested
1763   - if operation has timed out call driver Control function to Abort operation
1764   - assert that received content is as expected (for Transfer operation only)
1765
1766 \note Limitations of Data Exchange tests if Test Mode <b>Loopback</b> is selected:
1767  - only Master mode with Slave Select not used can be tested
1768  - Receive function cannot be tested
1769  - format tests are not supported
1770  - only 8, 16, 24 and 32 data bit tests are supported
1771  - bit order tests are not supported
1772 @{
1773 */
1774
1775 #ifndef __DOXYGEN__                     // Exclude form the documentation
1776 /*
1777   \brief         Execute SPI data exchange or abort operation.
1778   \param[in]     operation      operation (OP_SEND .. OP_ABORT_TRANSFER)
1779   \param[in]     mode           mode (MODE_MASTER or MODE_SLAVE)
1780   \param[in]     format         clock/frame format (0 = polarity0/phase0 .. 5 = Microwire)
1781   \param[in]     data_bits      data bits (1 .. 32)
1782   \param[in]     bit_order      bit order (BO_MSB_TO_LSB or BO_LSB_TO_MSB)
1783   \param[in]     ss_mode        Slave Select mode (SS_MODE_xxx)
1784   \param[in]     bus_speed      bus speed in bits per second (bps)
1785   \param[in]     num            number of items to send, receive or transfer
1786   \return        none
1787 */
1788 static void SPI_DataExchange_Operation (uint32_t operation, uint32_t mode, uint32_t format, uint32_t data_bits, uint32_t bit_order, uint32_t ss_mode, uint32_t bus_speed, uint32_t num) {
1789   // volatile specifier is used to prevent compiler from optimizing variables
1790   // in a way that they cannot be seen with a debugger
1791   volatile  int32_t       stat, def_tx_stat;
1792   volatile uint32_t       drv_mode, drv_format, drv_data_bits, drv_bit_order, drv_ss_mode;
1793   volatile uint32_t       srv_mode, srv_ss_mode;
1794   volatile ARM_SPI_STATUS spi_stat;
1795   volatile uint32_t       data_count;
1796            uint32_t       start_cnt;
1797            uint32_t       val, i;
1798   volatile uint32_t       srv_delay_c, srv_delay_t;
1799   volatile uint32_t       drv_delay_c, drv_delay_t;
1800            uint32_t       timeout, start_tick, curr_tick;
1801            uint8_t        chk_data;
1802
1803   // Prepare parameters for SPI Server and Driver configuration
1804   switch (mode) {
1805     case MODE_INACTIVE:
1806       TEST_FAIL_MESSAGE("[FAILED] Inactive mode! Data exchange operation aborted!");
1807       return;
1808     case MODE_MASTER:
1809       // When Master mode is tested, time diagram is as follows:
1810       // XFER                                                ¯|¯
1811       // ... 4 ms                                             .
1812       // Slave Control (SPI Server)                           .
1813       // ... 4 ms                                             .
1814       // Master Control (SPI Client (DUT))                    .
1815       // ... 4 ms                                    SPI_CFG_XFER_TIMEOUT
1816       // Slave Transfer (SPI Server)                          .
1817       // ... 4 ms                                             .
1818       // Master Send/Receive/Transfer (SPI Client (DUT))      .
1819       // ... data exchange                                   _|_
1820       drv_mode    = ARM_SPI_MODE_MASTER;
1821       srv_mode    = 1U;
1822       srv_delay_c = 4U;
1823       srv_delay_t = 8U;
1824       drv_delay_c = 8U;
1825       drv_delay_t = 8U;
1826       break;
1827     case MODE_SLAVE:
1828       // When Slave mode is tested, time diagram is as follows:
1829       // XFER                                                ¯|¯
1830       // ... 4 ms                                             .
1831       // Slave Control (SPI Client (DUT))                     .
1832       // ... 4 ms                                             .
1833       // Master Control (SPI Server)                          .
1834       // ... 4 ms                                    SPI_CFG_XFER_TIMEOUT
1835       // Slave Transfer (SPI Client (DUT))                    .
1836       // ... 4 ms                                             .
1837       // Master Send/Receive/Transfer (SPI Server)            .
1838       // ... data exchange                                   _|_
1839       drv_mode    = ARM_SPI_MODE_SLAVE;
1840       srv_mode    = 0U;
1841       srv_delay_c = 8U;
1842       srv_delay_t = 8U;
1843       drv_delay_c = 4U;
1844       drv_delay_t = 8U;
1845       break;
1846     default:
1847       TEST_FAIL_MESSAGE("[FAILED] Unknown mode! Data exchange operation aborted!");
1848       return;
1849   }
1850
1851
1852   switch (format) {
1853     case FORMAT_CPOL0_CPHA0:
1854       drv_format = ARM_SPI_CPOL0_CPHA0;
1855       break;
1856     case FORMAT_CPOL0_CPHA1:
1857       drv_format = ARM_SPI_CPOL0_CPHA1;
1858       break;
1859     case FORMAT_CPOL1_CPHA0:
1860       drv_format = ARM_SPI_CPOL1_CPHA0;
1861       break;
1862     case FORMAT_CPOL1_CPHA1:
1863       drv_format = ARM_SPI_CPOL1_CPHA1;
1864       break;
1865     case FORMAT_TI:
1866       drv_format = ARM_SPI_TI_SSI;
1867       break;
1868     case FORMAT_MICROWIRE:
1869       drv_format = ARM_SPI_MICROWIRE;
1870       break;
1871     default:
1872       TEST_FAIL_MESSAGE("[FAILED] Unknown clock / frame format! Data exchange operation aborted!");
1873       return;
1874   }
1875
1876   if ((data_bits > 0U) && (data_bits <= 32U)) {
1877     drv_data_bits = ARM_SPI_DATA_BITS(data_bits);
1878   } else {
1879     TEST_FAIL_MESSAGE("[FAILED] Data bits not in range 1 to 32! Data exchange operation aborted!");
1880     return;
1881   }
1882
1883   switch (bit_order) {
1884     case BO_MSB_TO_LSB:
1885       drv_bit_order = ARM_SPI_MSB_LSB;
1886       break;
1887     case BO_LSB_TO_MSB:
1888       drv_bit_order = ARM_SPI_LSB_MSB;
1889       break;
1890     default:
1891       TEST_FAIL_MESSAGE("[FAILED] Unknown bit order! Data exchange operation aborted!");
1892       return;
1893   }
1894
1895   if (mode == MODE_MASTER) {
1896     switch (ss_mode) {
1897       case SS_MODE_MASTER_UNUSED:
1898         drv_ss_mode = ARM_SPI_SS_MASTER_UNUSED;
1899         srv_ss_mode = 0U;
1900         break;
1901       case SS_MODE_MASTER_SW:
1902         drv_ss_mode = ARM_SPI_SS_MASTER_SW;
1903         srv_ss_mode = 1U;
1904         break;
1905       case SS_MODE_MASTER_HW_OUTPUT:
1906         drv_ss_mode = ARM_SPI_SS_MASTER_HW_OUTPUT;
1907         srv_ss_mode = 1U;
1908         break;
1909       case SS_MODE_MASTER_HW_INPUT:
1910         drv_ss_mode = ARM_SPI_SS_MASTER_UNUSED;
1911         srv_ss_mode = 0U;
1912         break;
1913       default:
1914         TEST_FAIL_MESSAGE("[FAILED] Unknown Slave Select mode! Data exchange operation aborted!");
1915         return;
1916     }
1917   } else {
1918     switch (ss_mode) {
1919       case SS_MODE_SLAVE_HW:
1920         drv_ss_mode = ARM_SPI_SS_SLAVE_HW;
1921         srv_ss_mode = 1U;
1922         break;
1923       case SS_MODE_SLAVE_SW:
1924         drv_ss_mode = ARM_SPI_SS_SLAVE_SW;
1925         srv_ss_mode = 0U;
1926         break;
1927       default:
1928         TEST_FAIL_MESSAGE("[FAILED] Unknown Slave Select mode! Data exchange operation aborted!");
1929         return;
1930     }
1931   }
1932
1933   // Total transfer timeout (16 ms is overhead before transfer starts)
1934   timeout = SPI_CFG_XFER_TIMEOUT + 16U;
1935
1936   // Check that SPI status is not busy before starting data exchange test
1937   spi_stat = drv->GetStatus();          // Get SPI status
1938   if (spi_stat.busy != 0U) {
1939     // If busy flag is active
1940     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s", str_oper[operation], "Busy active before operation! Data exchange operation aborted!");
1941   }
1942   TEST_ASSERT_MESSAGE(spi_stat.busy == 0U, msg_buf);
1943
1944   do {
1945 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
1946     if (CmdSetBufTx('S')   != EXIT_SUCCESS) { break; }
1947     if (CmdSetBufRx('?')   != EXIT_SUCCESS) { break; }
1948     if (CmdSetCom  (srv_mode, format, data_bits, bit_order, srv_ss_mode, bus_speed) != EXIT_SUCCESS) { break; }
1949     if (CmdXfer    (num, srv_delay_c, srv_delay_t, SPI_CFG_XFER_TIMEOUT) != EXIT_SUCCESS)            { break; }
1950     (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
1951 #else                                   // If Test Mode Loopback is selected
1952     // Remove warnings for unused variables
1953     (void)srv_mode;
1954     (void)srv_ss_mode;
1955     (void)srv_delay_c;
1956     (void)srv_delay_t;
1957 #endif
1958     start_tick = osKernelGetTickCount();
1959
1960     // Initialize buffers
1961     memset(ptr_tx_buf,  (int32_t)'!' , SPI_BUF_MAX);
1962     memset(ptr_tx_buf,  (int32_t)'T' , num * DataBitsToBytes(data_bits));
1963     memset(ptr_rx_buf,  (int32_t)'?' , SPI_BUF_MAX);
1964     memset(ptr_cmp_buf, (int32_t)'?' , SPI_BUF_MAX);
1965
1966     // Configure required communication settings
1967     (void)osDelay(drv_delay_c);         // Wait specified time before calling Control function
1968     if (mode == MODE_MASTER) {
1969       stat = drv->Control (drv_mode | drv_format | drv_data_bits | drv_bit_order | drv_ss_mode, bus_speed);
1970     } else {
1971       // For Slave mode bus speed argument is not used
1972       stat = drv->Control (drv_mode | drv_format | drv_data_bits | drv_bit_order | drv_ss_mode, 0U);
1973     }
1974     if (stat != ARM_DRIVER_OK) {
1975       // If configuration has failed
1976       (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s! Data exchange operation aborted!", str_oper[operation], "Control function returned", str_ret[-stat]);
1977     }
1978     // Assert that Control function returned ARM_DRIVER_OK
1979     TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
1980
1981     // Set default Tx value to 'D' byte values (only for master mode)
1982     if (mode == MODE_MASTER) {
1983       val = ((uint32_t)'D' << 24) | ((uint32_t)'D' << 16) | ((uint32_t)'D' << 8) | (uint32_t)'D';
1984       stat = drv->Control (ARM_SPI_SET_DEFAULT_TX_VALUE, val);
1985       def_tx_stat = stat;
1986       if ((stat != ARM_DRIVER_OK) && (stat != ARM_DRIVER_ERROR_UNSUPPORTED)) {
1987         // If set default Tx value has failed
1988         (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s", str_oper[operation], "Set default Tx value returned", str_ret[-stat]);
1989       }
1990       // Assert that Control function returned ARM_DRIVER_OK or ARM_DRIVER_ERROR_UNSUPPORTED
1991       TEST_ASSERT_MESSAGE((stat == ARM_DRIVER_OK) || (stat == ARM_DRIVER_ERROR_UNSUPPORTED), msg_buf);
1992
1993       if (stat == ARM_DRIVER_ERROR_UNSUPPORTED) {
1994         // If set default Tx value is not supported
1995         (void)snprintf(msg_buf, sizeof(msg_buf), "[WARNING] %s: %s", str_oper[operation], "Set default Tx value is not supported");
1996         TEST_MESSAGE(msg_buf);
1997       }
1998     } else {
1999       // For slave mode default Tx is not tested
2000       def_tx_stat = ARM_DRIVER_ERROR_UNSUPPORTED;
2001     }
2002     (void)osDelay(drv_delay_t);         // Wait specified time before calling Send/Receive/Transfer function
2003
2004     // Prepare local variables
2005     event             = 0U;
2006     duration          = 0xFFFFFFFFUL;
2007     data_count        = 0U;
2008     data_count_sample = 0U;
2009     chk_data          = 1U;
2010     start_cnt         = osKernelGetSysTimerCount();
2011
2012     if (((mode == MODE_MASTER) && (ss_mode == SS_MODE_MASTER_SW)) ||
2013         ((mode == MODE_SLAVE)  && (ss_mode == SS_MODE_SLAVE_SW)))  {
2014       // If operation requires software Slave Select driving, activate Slave Select
2015       stat = drv->Control (ARM_SPI_CONTROL_SS, ARM_SPI_SS_ACTIVE);
2016       if (stat != ARM_DRIVER_OK) {
2017         // If driving of Slave Select to active state has failed
2018         (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s", str_oper[operation], "Control function returned", str_ret[-stat]);
2019       }
2020       // Assert that Control function returned ARM_DRIVER_OK
2021       TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
2022     }
2023
2024     // Start the data exchange operation
2025     switch (operation & 0x0FU) {
2026       case OP_SEND:
2027       case OP_ABORT_SEND:
2028         stat = drv->Send(ptr_tx_buf, num);
2029         if (stat != ARM_DRIVER_OK) {
2030           // If Send activation has failed
2031           (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s! Data exchange operation aborted!", str_oper[operation], "Send function returned", str_ret[-stat]);
2032         }
2033         // Assert that Send function returned ARM_DRIVER_OK
2034         TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
2035         break;
2036       case OP_RECEIVE:
2037       case OP_ABORT_RECEIVE:
2038         stat = drv->Receive(ptr_rx_buf, num);
2039         if (stat != ARM_DRIVER_OK) {
2040           // If Receive activation has failed
2041           (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s! Data exchange operation aborted!", str_oper[operation], "Receive function returned", str_ret[-stat]);
2042         }
2043         // Assert that Receive function returned ARM_DRIVER_OK
2044         TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
2045         break;
2046       case OP_TRANSFER:
2047       case OP_ABORT_TRANSFER:
2048         stat = drv->Transfer(ptr_tx_buf, ptr_rx_buf, num);
2049         if (stat != ARM_DRIVER_OK) {
2050           // If Transfer activation has failed
2051           (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s! Data exchange operation aborted!", str_oper[operation], "Transfer function returned", str_ret[-stat]);
2052         }
2053         // Assert that Transfer function returned ARM_DRIVER_OK
2054         TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
2055         break;
2056       default:
2057         TEST_FAIL_MESSAGE("[FAILED] Unknown operation! Data exchange operation aborted!");
2058         return;
2059     }
2060     if (stat != ARM_DRIVER_OK) {
2061       // If Send/Receive/Transfer start has failed
2062       (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
2063     }
2064
2065     if ((operation == OP_ABORT_SEND)     ||     // This IF block tests only abort functionality
2066         (operation == OP_ABORT_RECEIVE)  ||
2067         (operation == OP_ABORT_TRANSFER)) {
2068       (void)osDelay(1U);                        // Wait short time before doing Abort
2069       stat = drv->Control (ARM_SPI_ABORT_TRANSFER, 0U);
2070       if (stat != ARM_DRIVER_OK) {
2071         // If Abort has failed
2072         (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s", str_oper[operation], "Control function returned", str_ret[-stat]);
2073       }
2074       // Assert that Control function returned ARM_DRIVER_OK
2075       TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
2076
2077       if (((mode == MODE_MASTER) && (ss_mode == SS_MODE_MASTER_SW)) ||
2078           ((mode == MODE_SLAVE)  && (ss_mode == SS_MODE_SLAVE_SW)))  {
2079         // If operation requires software Slave Select driving, deactivate Slave Select
2080         drv->Control(ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE);
2081       }
2082       spi_stat = drv->GetStatus();              // Get SPI status
2083       if (spi_stat.busy != 0U) {
2084         // If busy flag is still active
2085         (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s", str_oper[operation], "Busy still active after Abort");
2086       }
2087       // Assert that busy flag is not active
2088       TEST_ASSERT_MESSAGE(spi_stat.busy == 0U, msg_buf);
2089
2090       data_count = drv->GetDataCount();         // Get data count
2091       if (data_count >= num) {
2092         // If data count is more or equal to number of items then Abort has failed
2093         (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %i %s %i %s", str_oper[operation], "GetDataCount returned", data_count, "after Abort of", num, "items");
2094       }
2095       // Assert data count is less then number of items requested for exchange
2096       TEST_ASSERT_MESSAGE(data_count < num, msg_buf);
2097
2098 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
2099       // Deactivate SPI
2100       (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
2101
2102       // Wait until timeout expires
2103       curr_tick = osKernelGetTickCount();
2104       if ((curr_tick - start_tick) < timeout) {
2105         (void)osDelay(timeout - (curr_tick - start_tick));
2106       }
2107       (void)osDelay(20U);                       // Wait for SPI Server to start reception of next command
2108 #endif
2109
2110       return;                                   // Here Abort test is finished, exit
2111     }
2112
2113     // Wait for operation to finish (status busy is 0 and event complete signaled, or timeout)
2114     do {
2115       if (data_count_sample == 0U) {
2116         // Store first data count different than 0
2117         data_count_sample = drv->GetDataCount();  // Get data count
2118       }
2119       if ((drv->GetStatus().busy == 0U) && ((event & ARM_SPI_EVENT_TRANSFER_COMPLETE) != 0U)) {
2120         duration = osKernelGetSysTimerCount() - start_cnt;
2121         break;
2122       }
2123     } while ((osKernelGetTickCount() - start_tick) < timeout);
2124
2125     if (duration == 0xFFFFFFFFUL) {
2126       // If operation has timed out
2127       (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s", str_oper[operation], "Operation timed out");
2128     }
2129     // Assert that operation has finished in expected time
2130     TEST_ASSERT_MESSAGE(duration != 0xFFFFFFFFUL, msg_buf);
2131
2132     if (((mode == MODE_MASTER) && (ss_mode == SS_MODE_MASTER_SW)) ||
2133         ((mode == MODE_SLAVE)  && (ss_mode == SS_MODE_SLAVE_SW)))  {
2134       // If operation requires software Slave Select driving, deactivate Slave Select
2135       stat = drv->Control (ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE);
2136       if (stat != ARM_DRIVER_OK) {
2137         // If driving of Slave Select to inactive state has failed
2138         (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %s", str_oper[operation], "Control function returned", str_ret[-stat]);
2139       }
2140       // Assert that Control function returned ARM_DRIVER_OK
2141       TEST_ASSERT_MESSAGE(stat == ARM_DRIVER_OK, msg_buf);
2142     }
2143
2144     if ((event & ARM_SPI_EVENT_TRANSFER_COMPLETE) == 0U) {
2145       // If transfer complete event was not signaled
2146       (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s", str_oper[operation], "ARM_SPI_EVENT_TRANSFER_COMPLETE was not signaled");
2147       chk_data = 0U;                            // Do not check transferred content
2148     }
2149     // Assert that ARM_SPI_EVENT_TRANSFER_COMPLETE was signaled
2150     TEST_ASSERT_MESSAGE((event & ARM_SPI_EVENT_TRANSFER_COMPLETE) != 0U, msg_buf);
2151
2152     spi_stat = drv->GetStatus();                // Get SPI status
2153     if (spi_stat.busy != 0U) {
2154       // If busy flag is still active
2155       (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s", str_oper[operation], "Busy still active after operation");
2156       chk_data = 0U;                            // Do not check transferred content
2157     }
2158     // Assert that busy flag is not active
2159     TEST_ASSERT_MESSAGE(spi_stat.busy == 0U, msg_buf);
2160
2161     if ((event & ARM_SPI_EVENT_DATA_LOST) != 0U) {
2162       // If data lost was signaled during the transfer
2163       (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s", str_oper[operation], "ARM_SPI_EVENT_DATA_LOST was signaled");
2164       chk_data = 0U;                            // Do not check transferred content
2165     }
2166     // Assert that ARM_SPI_EVENT_DATA_LOST was not signaled
2167     TEST_ASSERT_MESSAGE((event & ARM_SPI_EVENT_DATA_LOST) == 0U, msg_buf);
2168
2169     data_count = drv->GetDataCount();           // Get data count
2170     if (data_count != num) {
2171       // If data count is different then number of items, then operation has failed
2172       (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s %i %s %i %s", str_oper[operation], "GetDataCount returned", data_count, "expected was", num, "items");
2173       chk_data = 0U;                            // Do not check transferred content
2174     }
2175     // Assert that data count is equal to number of items requested for exchange
2176     TEST_ASSERT_MESSAGE(data_count == num, msg_buf);
2177
2178     if ((drv->GetStatus().busy != 0U) || ((event & ARM_SPI_EVENT_TRANSFER_COMPLETE) == 0U)) {
2179       // If transfer did not finish in time, abort it
2180       (void)drv->Control(ARM_SPI_ABORT_TRANSFER, 0U);
2181     }
2182
2183 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
2184     // Deactivate SPI
2185     (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
2186
2187     // Wait until timeout expires
2188     curr_tick = osKernelGetTickCount();
2189     if ((curr_tick - start_tick) < timeout) {
2190       (void)osDelay(timeout - (curr_tick - start_tick));
2191     }
2192     (void)osDelay(20U);                 // Wait for SPI Server to start reception of next command
2193
2194     if (chk_data != 0U) {               // If transferred content should be checked
2195       // Check received content for receive and transfer operations
2196       if ((operation == OP_RECEIVE) || (operation == OP_TRANSFER)) {
2197         memset(ptr_cmp_buf, (int32_t)'S', num * DataBitsToBytes(data_bits));
2198         stat = memcmp(ptr_rx_buf, ptr_cmp_buf, num * DataBitsToBytes(data_bits));
2199         if (stat != 0) {
2200           // If data received mismatches
2201           // Find on which byte mismatch starts
2202           for (i = 0U; i < (num * DataBitsToBytes(data_bits)); i++) {
2203             if (ptr_rx_buf[i] != ptr_cmp_buf[i]) {
2204               break;
2205             }
2206           }
2207           (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s byte %i, received was 0x%02X, expected was 0x%02X", str_oper[operation], "Received data mismatches on", i, ptr_rx_buf[i], ptr_cmp_buf[i]);
2208         }
2209         // Assert that data received is same as expected
2210         TEST_ASSERT_MESSAGE(stat == 0, msg_buf);
2211       }
2212
2213       // Check sent content (by checking SPI Server's received buffer content)
2214       if ((mode == MODE_MASTER) || (operation != OP_RECEIVE) || (def_tx_stat == ARM_DRIVER_OK)) {
2215         // Check sent data in all cases except Slave mode Receive operation
2216         // with Default Tx not working or unsupported
2217         if (CmdGetBufRx(SPI_BUF_MAX) != EXIT_SUCCESS) { break; }
2218
2219         if ((operation == OP_RECEIVE) && (def_tx_stat == ARM_DRIVER_OK)) {
2220           // Expected data received by SPI Server should be default Tx value
2221           memset(ptr_cmp_buf, (int32_t)'D', num * DataBitsToBytes(data_bits));
2222         }
2223         if ((operation == OP_SEND) || (operation == OP_TRANSFER)) {
2224           // Expected data received by SPI Server should be what was sent
2225           memset(ptr_cmp_buf, (int32_t)'T', num * DataBitsToBytes(data_bits));
2226         }
2227
2228         stat = memcmp(ptr_rx_buf, ptr_cmp_buf, num * DataBitsToBytes(data_bits));
2229         if (stat != 0) {
2230           // If data sent mismatches
2231           // Find on which byte mismatch starts
2232           for (i = 0U; i < (num * DataBitsToBytes(data_bits)); i++) {
2233             if (ptr_rx_buf[i] != ptr_cmp_buf[i]) {
2234               break;
2235             }
2236           }
2237           if (operation == OP_RECEIVE) {
2238             // If sent was default Tx value, 'D' bytes
2239             (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s byte %i, SPI Server received 0x%02X, sent was 0x%02X", str_oper[operation], "Default Tx data mismatches on", i, ptr_rx_buf[i], ptr_cmp_buf[i]);
2240           } else {
2241             // If sent was 'T' bytes
2242             (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s byte %i, SPI Server received 0x%02X, sent was 0x%02X", str_oper[operation], "Sent data mismatches on", i, ptr_rx_buf[i], ptr_cmp_buf[i]);
2243           }
2244         }
2245         // Assert data sent is same as expected
2246         TEST_ASSERT_MESSAGE(stat == 0, msg_buf);
2247       }
2248     }
2249 #else                                   // If Test Mode Loopback is selected
2250     if (chk_data != 0U) {               // If transferred content should be checked
2251       if (operation == OP_TRANSFER) {
2252         memset(ptr_cmp_buf, (int32_t)('T' & ((1U << data_bits) - 1U)), num * DataBitsToBytes(data_bits));
2253         if ((data_bits > 8U) && (data_bits < 16U)) {
2254           for (i = 1U; i < (num * DataBitsToBytes(data_bits)); i+= DataBitsToBytes(data_bits)) {
2255             ptr_cmp_buf[i] = 'T' & ((1U << (data_bits - 8U)) - 1U);
2256           }
2257         } else if ((data_bits > 16U) && (data_bits < 32U)) {
2258           for (i = 2U; i < (num * DataBitsToBytes(data_bits)); i+= DataBitsToBytes(data_bits)) {
2259             if (data_bits <= 24U) {
2260               ptr_cmp_buf[i  ] = 'T' & ((1U << (data_bits - 16U)) - 1U);
2261               ptr_cmp_buf[i+1] = 0U;
2262             } else {
2263               ptr_cmp_buf[i+1] = 'T' & ((1U << (data_bits - 24U)) - 1U);
2264             }
2265           }
2266         }
2267         stat = memcmp(ptr_rx_buf, ptr_cmp_buf, num * DataBitsToBytes(data_bits));
2268         if (stat != 0) {
2269           // If data received mismatches
2270           // Find on which byte mismatch starts
2271           for (i = 0U; i < (num * DataBitsToBytes(data_bits)); i++) {
2272             if (ptr_rx_buf[i] != ptr_cmp_buf[i]) {
2273               break;
2274             }
2275           }
2276           (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] %s: %s byte %i, received was 0x%02X, expected was 0x%02X", str_oper[operation], "Received data mismatches on", i, ptr_rx_buf[i], ptr_cmp_buf[i]);
2277         }
2278         // Assert that data received is same as expected
2279         TEST_ASSERT_MESSAGE(stat == 0, msg_buf);
2280       }
2281     }
2282 #endif
2283
2284     return;
2285   } while (false);
2286
2287 #if (SPI_SERVER_USED == 1)              // If Test Mode SPI Server is selected
2288   TEST_FAIL_MESSAGE("[FAILED] Problems in communication with SPI Server. Test aborted!");
2289 #endif
2290 }
2291
2292 #endif                                  // End of exclude form the documentation
2293
2294 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2295 /**
2296 \brief Function: Function SPI_Mode_Master_SS_Unused
2297 \details
2298 The function \b SPI_Mode_Master_SS_Unused verifies data exchange:
2299  - in <b>Master Mode</b> with <b>Slave Select line not used</b>
2300  - with default clock / frame format
2301  - with default data bits
2302  - with default bit order
2303  - at default bus speed
2304  - for default number of data items
2305
2306 \note In Test Mode <b>Loopback</b> Receive function is not checked
2307 */
2308 void SPI_Mode_Master_SS_Unused (void) {
2309
2310   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2311   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2312   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2313   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2314 #if  (SPI_SERVER_USED == 1)
2315   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2316   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2317 #endif
2318
2319   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_UNUSED, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2320 #if (SPI_SERVER_USED == 1)
2321   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_UNUSED, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2322 #endif
2323   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_UNUSED, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2324 }
2325
2326 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2327 /**
2328 \brief Function: Function SPI_Mode_Master_SS_Sw_Ctrl
2329 \details
2330 The function \b SPI_Mode_Master_SS_Sw_Ctrl verifies data exchange:
2331  - in <b>Master Mode</b> with <b>Slave Select line Software controlled</b>
2332  - with default clock / frame format
2333  - with default data bits
2334  - with default bit order
2335  - at default bus speed
2336  - for default number of data items
2337
2338 \note In Test Mode <b>Loopback</b> this test is not executed
2339 */
2340 void SPI_Mode_Master_SS_Sw_Ctrl (void) {
2341
2342   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2343   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2344   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2345   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2346   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2347 #if  (SPI_SERVER_USED == 1)
2348   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2349   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2350 #endif
2351
2352   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_SW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2353   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_SW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2354   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_SW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2355 }
2356
2357 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2358 /**
2359 \brief Function: Function SPI_Mode_Master_SS_Hw_Ctrl_Out
2360 \details
2361 The function \b SPI_Mode_Master_SS_Hw_Ctrl_Out verifies data exchange:
2362  - in <b>Master Mode</b> with <b>Slave Select line Hardware controlled Output</b>
2363  - with default clock / frame format
2364  - with default data bits
2365  - with default bit order
2366  - at default bus speed
2367  - for default number of data items
2368
2369 \note In Test Mode <b>Loopback</b> this test not executed
2370 */
2371 void SPI_Mode_Master_SS_Hw_Ctrl_Out (void) {
2372
2373   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2374   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2375   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2376 #if  (SPI_SERVER_USED == 1)
2377   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2378   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2379 #endif
2380
2381   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2382   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2383   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2384 }
2385
2386 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2387 /**
2388 \brief Function: Function SPI_Mode_Master_SS_Hw_Mon_In
2389 \details
2390 The function \b SPI_Mode_Master_SS_Hw_Mon_In verifies data exchange:
2391  - in <b>Master Mode</b> with <b>Slave Select line Hardware monitored Input</b>
2392  - with default clock / frame format
2393  - with default data bits
2394  - with default bit order
2395  - at default bus speed
2396  - for default number of data items
2397
2398 \note In Test Mode <b>Loopback</b> this test not executed
2399 */
2400 void SPI_Mode_Master_SS_Hw_Mon_In (void) {
2401
2402   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2403   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2404   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2405   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2406   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2407 #if  (SPI_SERVER_USED == 1)
2408   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2409   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2410 #endif
2411
2412   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_HW_INPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2413   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_HW_INPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2414   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_MASTER_HW_INPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2415 }
2416
2417 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2418 /**
2419 \brief Function: Function SPI_Mode_Slave_SS_Hw_Mon
2420 \details
2421 The function \b SPI_Mode_Slave_SS_Hw_Mon verifies data exchange:
2422  - in <b>Slave Mode</b> with <b>Slave Select line Hardware monitored</b>
2423  - with default clock / frame format
2424  - with default data bits
2425  - with default bit order
2426  - at default bus speed
2427  - for default number of data items
2428
2429 \note In Test Mode <b>Loopback</b> this test not executed
2430 */
2431 void SPI_Mode_Slave_SS_Hw_Mon (void) {
2432
2433   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2434   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2435   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2436 #if  (SPI_SERVER_USED == 1)
2437   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2438   if (ServerCheckSupport(MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2439 #endif
2440
2441   SPI_DataExchange_Operation(OP_SEND,     MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_SLAVE_HW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2442   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_SLAVE_HW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2443   SPI_DataExchange_Operation(OP_TRANSFER, MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_SLAVE_HW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2444 }
2445
2446 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2447 /**
2448 \brief Function: Function SPI_Mode_Slave_SS_Sw_Ctrl
2449 \details
2450 The function \b SPI_Mode_Slave_SS_Sw_Ctrl verifies data exchange:
2451  - in <b>Slave Mode</b> with <b>Slave Select line Software controlled</b>
2452  - with default clock / frame format
2453  - with default data bits
2454  - with default bit order
2455  - at default bus speed
2456  - for default number of data items
2457
2458 \note In Test Mode <b>Loopback</b> this test not executed
2459 */
2460 void SPI_Mode_Slave_SS_Sw_Ctrl (void) {
2461
2462   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2463   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2464   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2465   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2466   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2467 #if  (SPI_SERVER_USED == 1)
2468   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2469   if (ServerCheckSupport(MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2470 #endif
2471
2472   SPI_DataExchange_Operation(OP_SEND,     MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_SLAVE_SW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2473   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_SLAVE_SW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2474   SPI_DataExchange_Operation(OP_TRANSFER, MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SS_MODE_SLAVE_SW, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2475 }
2476
2477 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2478 /**
2479 \brief Function: Function SPI_Format_Clock_Pol0_Pha0
2480 \details
2481 The function \b SPI_Format_Clock_Pol0_Pha0 verifies data exchange:
2482  - in Master Mode with default Slave Select mode
2483  - with clock format: <b>polarity 0 / phase 0</b>
2484  - with default data bits
2485  - with default bit order
2486  - at default bus speed
2487  - for default number of data items
2488
2489 \note In Test Mode <b>Loopback</b> this test not executed
2490 */
2491 void SPI_Format_Clock_Pol0_Pha0 (void) {
2492
2493   if (IsNotLoopback()    != EXIT_SUCCESS) {              return; }
2494   if (DriverInit()       != EXIT_SUCCESS) { TEST_FAIL(); return; }
2495   if (BuffersCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2496 #if  (SPI_SERVER_USED == 1)
2497   if (ServerCheck()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2498   if (ServerCheckSupport(MODE_SLAVE, FORMAT_CPOL0_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2499 #endif
2500
2501   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, FORMAT_CPOL0_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2502   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, FORMAT_CPOL0_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2503   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, FORMAT_CPOL0_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2504 }
2505
2506 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2507 /**
2508 \brief Function: Function SPI_Format_Clock_Pol0_Pha1
2509 \details
2510 The function \b SPI_Format_Clock_Pol0_Pha1 verifies data exchange:
2511  - in Master Mode with default Slave Select mode
2512  - with clock format: <b>polarity 0 / phase 1</b>
2513  - with default data bits
2514  - with default bit order
2515  - at default bus speed
2516  - for default number of data items
2517
2518 \note In Test Mode <b>Loopback</b> this test not executed
2519 */
2520 void SPI_Format_Clock_Pol0_Pha1 (void) {
2521
2522   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2523   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2524   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2525 #if  (SPI_SERVER_USED == 1)
2526   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2527   if (ServerCheckSupport(MODE_SLAVE, FORMAT_CPOL0_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2528 #endif
2529
2530   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, FORMAT_CPOL0_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2531   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, FORMAT_CPOL0_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2532   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, FORMAT_CPOL0_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2533 }
2534
2535 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2536 /**
2537 \brief Function: Function SPI_Format_Clock_Pol1_Pha0
2538 \details
2539 The function \b SPI_Format_Clock_Pol1_Pha0 verifies data exchange:
2540  - in Master Mode with default Slave Select mode
2541  - with clock format: <b>polarity 1 / phase 0</b>
2542  - with default data bits
2543  - with default bit order
2544  - at default bus speed
2545  - for default number of data items
2546
2547 \note In Test Mode <b>Loopback</b> this test not executed
2548 */
2549 void SPI_Format_Clock_Pol1_Pha0 (void) {
2550
2551   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2552   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2553   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2554 #if  (SPI_SERVER_USED == 1)
2555   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2556   if (ServerCheckSupport(MODE_SLAVE, FORMAT_CPOL1_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2557 #endif
2558
2559   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, FORMAT_CPOL1_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2560   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, FORMAT_CPOL1_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2561   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, FORMAT_CPOL1_CPHA0, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2562 }
2563
2564 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2565 /**
2566 \brief Function: Function SPI_Format_Clock_Pol1_Pha1
2567 \details
2568 The function \b SPI_Format_Clock_Pol1_Pha1 verifies data exchange:
2569  - in Master Mode with default Slave Select mode
2570  - with clock format: <b>polarity 1 / phase 1</b>
2571  - with default data bits
2572  - with default bit order
2573  - at default bus speed
2574  - for default number of data items
2575
2576 \note In Test Mode <b>Loopback</b> this test not executed
2577 */
2578 void SPI_Format_Clock_Pol1_Pha1 (void) {
2579
2580   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2581   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2582   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2583 #if  (SPI_SERVER_USED == 1)
2584   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2585   if (ServerCheckSupport(MODE_SLAVE, FORMAT_CPOL1_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2586 #endif
2587
2588   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, FORMAT_CPOL1_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2589   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, FORMAT_CPOL1_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2590   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, FORMAT_CPOL1_CPHA1, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2591 }
2592
2593 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2594 /**
2595 \brief Function: Function SPI_Format_Frame_TI
2596 \details
2597 The function \b SPI_Format_Frame_TI verifies data exchange:
2598  - in <b>Master Mode</b> with <b>Slave Select line Hardware controlled Output</b>
2599  - with <b>Texas Instruments frame format</b>
2600  - with default data bits
2601  - with bit order <b>from MSB to LSB</b>
2602  - at default bus speed
2603  - for default number of data items
2604
2605 \note In Test Mode <b>Loopback</b> this test not executed
2606 */
2607 void SPI_Format_Frame_TI (void) {
2608
2609   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2610   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2611   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2612   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2613 #if  (SPI_SERVER_USED == 1)
2614   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2615   if (ServerCheckSupport(MODE_SLAVE, FORMAT_TI, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2616 #endif
2617
2618   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, FORMAT_TI, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2619   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, FORMAT_TI, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2620   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, FORMAT_TI, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2621 }
2622
2623 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2624 /**
2625 \brief Function: Function SPI_Format_Clock_Microwire
2626 \details
2627 The function \b SPI_Format_Clock_Microwire verifies data exchange:
2628  - in <b>Master Mode</b> with <b>Slave Select line Hardware controlled Output</b>
2629  - with <b>National Semiconductor Microwire frame format</b>
2630  - with default data bits
2631  - with bit order <b>from MSB to LSB</b>
2632  - at default bus speed
2633  - for default number of data items
2634
2635 \note In Test Mode <b>Loopback</b> this test not executed
2636 */
2637 void SPI_Format_Clock_Microwire (void) {
2638
2639   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
2640   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2641   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2642   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2643 #if  (SPI_SERVER_USED == 1)
2644   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2645   if (ServerCheckSupport(MODE_SLAVE, FORMAT_MICROWIRE, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2646 #endif
2647
2648   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, FORMAT_MICROWIRE, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2649   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, FORMAT_MICROWIRE, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2650   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, FORMAT_MICROWIRE, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SS_MODE_MASTER_HW_OUTPUT, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2651 }
2652
2653 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2654 /**
2655 \brief Function: Function SPI_Data_Bits_1
2656 \details
2657 The function \b SPI_Data_Bits_1 verifies data exchange:
2658  - in Master Mode with default Slave Select mode
2659  - with default clock / frame format
2660  - with <b>1 data bits</b> per frame
2661  - with default bit order
2662  - at default bus speed
2663  - for default number of data items
2664 */
2665 void SPI_Data_Bits_1 (void) {
2666
2667   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2668   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2669   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2670   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2671 #if  (SPI_SERVER_USED == 1)
2672   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2673   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 1U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2674 #endif
2675
2676   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 1U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2677   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 1U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2678   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 1U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2679 }
2680
2681 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2682 /**
2683 \brief Function: Function SPI_Data_Bits_2
2684 \details
2685 The function \b SPI_Data_Bits_2 verifies data exchange:
2686  - in Master Mode with default Slave Select mode
2687  - with default clock / frame format
2688  - with <b>2 data bits</b> per frame
2689  - with default bit order
2690  - at default bus speed
2691  - for default number of data items
2692 */
2693 void SPI_Data_Bits_2 (void) {
2694
2695   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2696   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2697   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2698   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2699 #if  (SPI_SERVER_USED == 1)
2700   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2701   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 2U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2702 #endif
2703
2704   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 2U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2705   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 2U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2706   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 2U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2707 }
2708
2709 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2710 /**
2711 \brief Function: Function SPI_Data_Bits_3
2712 \details
2713 The function \b SPI_Data_Bits_3 verifies data exchange:
2714  - in Master Mode with default Slave Select mode
2715  - with default clock / frame format
2716  - with <b>3 data bits</b> per frame
2717  - with default bit order
2718  - at default bus speed
2719  - for default number of data items
2720 */
2721 void SPI_Data_Bits_3 (void) {
2722
2723   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
2724   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
2725   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2726   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2727 #if  (SPI_SERVER_USED == 1)
2728   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2729   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 3U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2730 #endif
2731
2732   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 3U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2733   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 3U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2734   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 3U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2735 }
2736
2737 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2738 /**
2739 \brief Function: Function SPI_Data_Bits_4
2740 \details
2741 The function \b SPI_Data_Bits_4 verifies data exchange:
2742  - in Master Mode with default Slave Select mode
2743  - with default clock / frame format
2744  - with <b>4 data bits</b> per frame
2745  - with default bit order
2746  - at default bus speed
2747  - for default number of data items
2748 */
2749 void SPI_Data_Bits_4 (void) {
2750
2751   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2752   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2753   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2754   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2755 #if  (SPI_SERVER_USED == 1)
2756   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2757   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 4U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2758 #endif
2759
2760   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 4U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2761   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 4U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2762   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 4U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2763 }
2764
2765 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2766 /**
2767 \brief Function: Function SPI_Data_Bits_5
2768 \details
2769 The function \b SPI_Data_Bits_5 verifies data exchange:
2770  - in Master Mode with default Slave Select mode
2771  - with default clock / frame format
2772  - with <b>5 data bits</b> per frame
2773  - with default bit order
2774  - at default bus speed
2775  - for default number of data items
2776 */
2777 void SPI_Data_Bits_5 (void) {
2778
2779   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2780   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2781   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2782   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2783 #if  (SPI_SERVER_USED == 1)
2784   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2785   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 5U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2786 #endif
2787
2788   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 5U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2789   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 5U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2790   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 5U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2791 }
2792
2793 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2794 /**
2795 \brief Function: Function SPI_Data_Bits_6
2796 \details
2797 The function \b SPI_Data_Bits_6 verifies data exchange:
2798  - in Master Mode with default Slave Select mode
2799  - with default clock / frame format
2800  - with <b>6 data bits</b> per frame
2801  - with default bit order
2802  - at default bus speed
2803  - for default number of data items
2804 */
2805 void SPI_Data_Bits_6 (void) {
2806
2807   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2808   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2809   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2810   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2811 #if  (SPI_SERVER_USED == 1)
2812   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2813   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 6U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2814 #endif
2815
2816   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 6U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2817   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 6U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2818   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 6U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2819 }
2820
2821 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2822 /**
2823 \brief Function: Function SPI_Data_Bits_7
2824 \details
2825 The function \b SPI_Data_Bits_7 verifies data exchange:
2826  - in Master Mode with default Slave Select mode
2827  - with default clock / frame format
2828  - with <b>7 data bits</b> per frame
2829  - with default bit order
2830  - at default bus speed
2831  - for default number of data items
2832 */
2833 void SPI_Data_Bits_7 (void) {
2834
2835   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2836   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2837   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2838   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2839 #if  (SPI_SERVER_USED == 1)
2840   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2841   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 7U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2842 #endif
2843
2844   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 7U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2845   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 7U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2846   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 7U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2847 }
2848
2849 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2850 /**
2851 \brief Function: Function SPI_Data_Bits_8
2852 \details
2853 The function \b SPI_Data_Bits_8 verifies data exchange:
2854  - in Master Mode with default Slave Select mode
2855  - with default clock / frame format
2856  - with <b>8 data bits</b> per frame
2857  - with default bit order
2858  - at default bus speed
2859  - for default number of data items
2860 */
2861 void SPI_Data_Bits_8 (void) {
2862
2863   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2864   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2865   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2866   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2867 #if  (SPI_SERVER_USED == 1)
2868   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2869   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 8U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2870 #endif
2871
2872   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 8U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2873   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 8U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2874   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 8U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2875 }
2876
2877 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2878 /**
2879 \brief Function: Function SPI_Data_Bits_9
2880 \details
2881 The function \b SPI_Data_Bits_9 verifies data exchange:
2882  - in Master Mode with default Slave Select mode
2883  - with default clock / frame format
2884  - with <b>9 data bits</b> per frame
2885  - with default bit order
2886  - at default bus speed
2887  - for default number of data items
2888 */
2889 void SPI_Data_Bits_9 (void) {
2890
2891   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2892   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2893   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2894   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2895 #if  (SPI_SERVER_USED == 1)
2896   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2897   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 9U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2898 #endif
2899
2900   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 9U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2901   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 9U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2902   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 9U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2903 }
2904
2905 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2906 /**
2907 \brief Function: Function SPI_Data_Bits_10
2908 \details
2909 The function \b SPI_Data_Bits_10 verifies data exchange:
2910  - in Master Mode with default Slave Select mode
2911  - with default clock / frame format
2912  - with <b>10 data bits</b> per frame
2913  - with default bit order
2914  - at default bus speed
2915  - for default number of data items
2916 */
2917 void SPI_Data_Bits_10 (void) {
2918
2919   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2920   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2921   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2922   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2923 #if  (SPI_SERVER_USED == 1)
2924   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2925   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 10U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2926 #endif
2927
2928   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 10U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2929   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 10U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2930   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 10U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2931 }
2932
2933 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2934 /**
2935 \brief Function: Function SPI_Data_Bits_11
2936 \details
2937 The function \b SPI_Data_Bits_11 verifies data exchange:
2938  - in Master Mode with default Slave Select mode
2939  - with default clock / frame format
2940  - with <b>11 data bits</b> per frame
2941  - with default bit order
2942  - at default bus speed
2943  - for default number of data items
2944 */
2945 void SPI_Data_Bits_11 (void) {
2946
2947   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2948   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2949   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2950   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2951 #if  (SPI_SERVER_USED == 1)
2952   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2953   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 11U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2954 #endif
2955
2956   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 11U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2957   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 11U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2958   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 11U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2959 }
2960
2961 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2962 /**
2963 \brief Function: Function SPI_Data_Bits_12
2964 \details
2965 The function \b SPI_Data_Bits_12 verifies data exchange:
2966  - in Master Mode with default Slave Select mode
2967  - with default clock / frame format
2968  - with <b>12 data bits</b> per frame
2969  - with default bit order
2970  - at default bus speed
2971  - for default number of data items
2972 */
2973 void SPI_Data_Bits_12 (void) {
2974
2975   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
2976   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
2977   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
2978   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
2979 #if  (SPI_SERVER_USED == 1)
2980   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
2981   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 12U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
2982 #endif
2983
2984   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 12U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2985   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 12U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2986   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 12U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
2987 }
2988
2989 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
2990 /**
2991 \brief Function: Function SPI_Data_Bits_13
2992 \details
2993 The function \b SPI_Data_Bits_13 verifies data exchange:
2994  - in Master Mode with default Slave Select mode
2995  - with default clock / frame format
2996  - with <b>13 data bits</b> per frame
2997  - with default bit order
2998  - at default bus speed
2999  - for default number of data items
3000 */
3001 void SPI_Data_Bits_13 (void) {
3002
3003   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3004   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3005   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3006   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3007 #if  (SPI_SERVER_USED == 1)
3008   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3009   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 13U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3010 #endif
3011
3012   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 13U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3013   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 13U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3014   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 13U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3015 }
3016
3017 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3018 /**
3019 \brief Function: Function SPI_Data_Bits_14
3020 \details
3021 The function \b SPI_Data_Bits_14 verifies data exchange:
3022  - in Master Mode with default Slave Select mode
3023  - with default clock / frame format
3024  - with <b>14 data bits</b> per frame
3025  - with default bit order
3026  - at default bus speed
3027  - for default number of data items
3028 */
3029 void SPI_Data_Bits_14 (void) {
3030
3031   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3032   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3033   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3034   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3035 #if  (SPI_SERVER_USED == 1)
3036   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3037   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 14U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3038 #endif
3039
3040   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 14U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3041   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 14U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3042   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 14U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3043 }
3044
3045 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3046 /**
3047 \brief Function: Function SPI_Data_Bits_15
3048 \details
3049 The function \b SPI_Data_Bits_15 verifies data exchange:
3050  - in Master Mode with default Slave Select mode
3051  - with default clock / frame format
3052  - with <b>15 data bits</b> per frame
3053  - with default bit order
3054  - at default bus speed
3055  - for default number of data items
3056 */
3057 void SPI_Data_Bits_15 (void) {
3058
3059   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3060   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3061   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3062   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3063 #if  (SPI_SERVER_USED == 1)
3064   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3065   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 15U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3066 #endif
3067
3068   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 15U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3069   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 15U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3070   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 15U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3071 }
3072
3073 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3074 /**
3075 \brief Function: Function SPI_Data_Bits_16
3076 \details
3077 The function \b SPI_Data_Bits_16 verifies data exchange:
3078  - in Master Mode with default Slave Select mode
3079  - with default clock / frame format
3080  - with <b>16 data bits</b> per frame
3081  - with default bit order
3082  - at default bus speed
3083  - for default number of data items
3084 */
3085 void SPI_Data_Bits_16 (void) {
3086
3087   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3088   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3089   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3090   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3091 #if  (SPI_SERVER_USED == 1)
3092   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3093   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 16U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3094 #endif
3095
3096   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 16U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3097   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 16U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3098   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 16U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3099 }
3100
3101 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3102 /**
3103 \brief Function: Function SPI_Data_Bits_17
3104 \details
3105 The function \b SPI_Data_Bits_17 verifies data exchange:
3106  - in Master Mode with default Slave Select mode
3107  - with default clock / frame format
3108  - with <b>17 data bits</b> per frame
3109  - with default bit order
3110  - at default bus speed
3111  - for default number of data items
3112 */
3113 void SPI_Data_Bits_17 (void) {
3114
3115   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3116   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3117   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3118   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3119 #if  (SPI_SERVER_USED == 1)
3120   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3121   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 17U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3122 #endif
3123
3124   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 17U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3125   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 17U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3126   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 17U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3127 }
3128
3129 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3130 /**
3131 \brief Function: Function SPI_Data_Bits_18
3132 \details
3133 The function \b SPI_Data_Bits_18 verifies data exchange:
3134  - in Master Mode with default Slave Select mode
3135  - with default clock / frame format
3136  - with <b>18 data bits</b> per frame
3137  - with default bit order
3138  - at default bus speed
3139  - for default number of data items
3140 */
3141 void SPI_Data_Bits_18 (void) {
3142
3143   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3144   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3145   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3146   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3147 #if  (SPI_SERVER_USED == 1)
3148   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3149   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 18U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3150 #endif
3151
3152   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 18U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3153   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 18U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3154   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 18U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3155 }
3156
3157 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3158 /**
3159 \brief Function: Function SPI_Data_Bits_19
3160 \details
3161 The function \b SPI_Data_Bits_19 verifies data exchange:
3162  - in Master Mode with default Slave Select mode
3163  - with default clock / frame format
3164  - with <b>19 data bits</b> per frame
3165  - with default bit order
3166  - at default bus speed
3167  - for default number of data items
3168 */
3169 void SPI_Data_Bits_19 (void) {
3170
3171   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3172   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3173   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3174   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3175 #if  (SPI_SERVER_USED == 1)
3176   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3177   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 19U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3178 #endif
3179
3180   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 19U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3181   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 19U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3182   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 19U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3183 }
3184
3185 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3186 /**
3187 \brief Function: Function SPI_Data_Bits_20
3188 \details
3189 The function \b SPI_Data_Bits_20 verifies data exchange:
3190  - in Master Mode with default Slave Select mode
3191  - with default clock / frame format
3192  - with <b>20 data bits</b> per frame
3193  - with default bit order
3194  - at default bus speed
3195  - for default number of data items
3196 */
3197 void SPI_Data_Bits_20 (void) {
3198
3199   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3200   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3201   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3202   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3203 #if  (SPI_SERVER_USED == 1)
3204   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3205   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 20U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3206 #endif
3207
3208   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 20U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3209   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 20U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3210   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 20U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3211 }
3212
3213 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3214 /**
3215 \brief Function: Function SPI_Data_Bits_21
3216 \details
3217 The function \b SPI_Data_Bits_21 verifies data exchange:
3218  - in Master Mode with default Slave Select mode
3219  - with default clock / frame format
3220  - with <b>21 data bits</b> per frame
3221  - with default bit order
3222  - at default bus speed
3223  - for default number of data items
3224 */
3225 void SPI_Data_Bits_21 (void) {
3226
3227   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3228   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3229   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3230   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3231 #if  (SPI_SERVER_USED == 1)
3232   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3233   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 21U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3234 #endif
3235
3236   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 21U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3237   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 21U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3238   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 21U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3239 }
3240
3241 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3242 /**
3243 \brief Function: Function SPI_Data_Bits_22
3244 \details
3245 The function \b SPI_Data_Bits_22 verifies data exchange:
3246  - in Master Mode with default Slave Select mode
3247  - with default clock / frame format
3248  - with <b>22 data bits</b> per frame
3249  - with default bit order
3250  - at default bus speed
3251  - for default number of data items
3252 */
3253 void SPI_Data_Bits_22 (void) {
3254
3255   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3256   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3257   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3258   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3259 #if  (SPI_SERVER_USED == 1)
3260   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3261   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 22U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3262 #endif
3263
3264   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 22U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3265   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 22U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3266   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 22U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3267 }
3268
3269 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3270 /**
3271 \brief Function: Function SPI_Data_Bits_23
3272 \details
3273 The function \b SPI_Data_Bits_23 verifies data exchange:
3274  - in Master Mode with default Slave Select mode
3275  - with default clock / frame format
3276  - with <b>23 data bits</b> per frame
3277  - with default bit order
3278  - at default bus speed
3279  - for default number of data items
3280 */
3281 void SPI_Data_Bits_23 (void) {
3282
3283   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3284   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3285   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3286   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3287 #if  (SPI_SERVER_USED == 1)
3288   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3289   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 23U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3290 #endif
3291
3292   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 23U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3293   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 23U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3294   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 23U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3295 }
3296
3297 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3298 /**
3299 \brief Function: Function SPI_Data_Bits_24
3300 \details
3301 The function \b SPI_Data_Bits_24 verifies data exchange:
3302  - in Master Mode with default Slave Select mode
3303  - with default clock / frame format
3304  - with <b>24 data bits</b> per frame
3305  - with default bit order
3306  - at default bus speed
3307  - for default number of data items
3308 */
3309 void SPI_Data_Bits_24 (void) {
3310
3311   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3312   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3313   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3314   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3315 #if  (SPI_SERVER_USED == 1)
3316   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3317   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 24U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3318 #endif
3319
3320   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 24U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3321   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 24U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3322   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 24U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3323 }
3324
3325 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3326 /**
3327 \brief Function: Function SPI_Data_Bits_25
3328 \details
3329 The function \b SPI_Data_Bits_25 verifies data exchange:
3330  - in Master Mode with default Slave Select mode
3331  - with default clock / frame format
3332  - with <b>25 data bits</b> per frame
3333  - with default bit order
3334  - at default bus speed
3335  - for default number of data items
3336 */
3337 void SPI_Data_Bits_25 (void) {
3338
3339   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3340   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3341   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3342   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3343 #if  (SPI_SERVER_USED == 1)
3344   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3345   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 25U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3346 #endif
3347
3348   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 25U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3349   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 25U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3350   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 25U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3351 }
3352
3353 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3354 /**
3355 \brief Function: Function SPI_Data_Bits_26
3356 \details
3357 The function \b SPI_Data_Bits_26 verifies data exchange:
3358  - in Master Mode with default Slave Select mode
3359  - with default clock / frame format
3360  - with <b>26 data bits</b> per frame
3361  - with default bit order
3362  - at default bus speed
3363  - for default number of data items
3364 */
3365 void SPI_Data_Bits_26 (void) {
3366
3367   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3368   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3369   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3370   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3371 #if  (SPI_SERVER_USED == 1)
3372   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3373   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 26U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3374 #endif
3375
3376   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 26U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3377   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 26U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3378   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 26U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3379 }
3380
3381 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3382 /**
3383 \brief Function: Function SPI_Data_Bits_27
3384 \details
3385 The function \b SPI_Data_Bits_27 verifies data exchange:
3386  - in Master Mode with default Slave Select mode
3387  - with default clock / frame format
3388  - with <b>27 data bits</b> per frame
3389  - with default bit order
3390  - at default bus speed
3391  - for default number of data items
3392 */
3393 void SPI_Data_Bits_27 (void) {
3394
3395   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3396   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3397   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3398   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3399 #if  (SPI_SERVER_USED == 1)
3400   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3401   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 27U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3402 #endif
3403
3404   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 27U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3405   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 27U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3406   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 27U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3407 }
3408
3409 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3410 /**
3411 \brief Function: Function SPI_Data_Bits_28
3412 \details
3413 The function \b SPI_Data_Bits_28 verifies data exchange:
3414  - in Master Mode with default Slave Select mode
3415  - with default clock / frame format
3416  - with <b>28 data bits</b> per frame
3417  - with default bit order
3418  - at default bus speed
3419  - for default number of data items
3420 */
3421 void SPI_Data_Bits_28 (void) {
3422
3423   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3424   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3425   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3426   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3427 #if  (SPI_SERVER_USED == 1)
3428   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3429   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 28U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3430 #endif
3431
3432   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 28U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3433   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 28U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3434   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 28U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3435 }
3436
3437 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3438 /**
3439 \brief Function: Function SPI_Data_Bits_29
3440 \details
3441 The function \b SPI_Data_Bits_29 verifies data exchange:
3442  - in Master Mode with default Slave Select mode
3443  - with default clock / frame format
3444  - with <b>29 data bits</b> per frame
3445  - with default bit order
3446  - at default bus speed
3447  - for default number of data items
3448 */
3449 void SPI_Data_Bits_29 (void) {
3450
3451   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3452   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3453   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3454   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3455 #if  (SPI_SERVER_USED == 1)
3456   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3457   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 29U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3458 #endif
3459
3460   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 29U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3461   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 29U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3462   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 29U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3463 }
3464
3465 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3466 /**
3467 \brief Function: Function SPI_Data_Bits_30
3468 \details
3469 The function \b SPI_Data_Bits_30 verifies data exchange:
3470  - in Master Mode with default Slave Select mode
3471  - with default clock / frame format
3472  - with <b>30 data bits</b> per frame
3473  - with default bit order
3474  - at default bus speed
3475  - for default number of data items
3476 */
3477 void SPI_Data_Bits_30 (void) {
3478
3479   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3480   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3481   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3482   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3483 #if  (SPI_SERVER_USED == 1)
3484   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3485   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 30U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3486 #endif
3487
3488   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 30U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3489   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 30U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3490   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 30U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3491 }
3492
3493 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3494 /**
3495 \brief Function: Function SPI_Data_Bits_31
3496 \details
3497 The function \b SPI_Data_Bits_31 verifies data exchange:
3498  - in Master Mode with default Slave Select mode
3499  - with default clock / frame format
3500  - with <b>31 data bits</b> per frame
3501  - with default bit order
3502  - at default bus speed
3503  - for default number of data items
3504 */
3505 void SPI_Data_Bits_31 (void) {
3506
3507   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3508   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3509   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3510   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3511 #if  (SPI_SERVER_USED == 1)
3512   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3513   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 31U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3514 #endif
3515
3516   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 31U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3517   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 31U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3518   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 31U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3519 }
3520
3521 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3522 /**
3523 \brief Function: Function SPI_Data_Bits_32
3524 \details
3525 The function \b SPI_Data_Bits_32 verifies data exchange:
3526  - in Master Mode with default Slave Select mode
3527  - with default clock / frame format
3528  - with <b>32 data bits</b> per frame
3529  - with default bit order
3530  - at default bus speed
3531  - for default number of data items
3532 */
3533 void SPI_Data_Bits_32 (void) {
3534
3535   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3536   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3537   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3538   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3539 #if  (SPI_SERVER_USED == 1)
3540   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3541   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, 32U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3542 #endif
3543
3544   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, 32U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3545   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, 32U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3546   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, 32U, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3547 }
3548
3549 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3550 /**
3551 \brief Function: Function SPI_Bit_Order_MSB_LSB
3552 \details
3553 The function \b SPI_Bit_Order_MSB_LSB verifies data exchange:
3554  - in Master Mode with default Slave Select mode
3555  - with default clock / frame format
3556  - with default data bits
3557  - with bit order <b>from MSB to LSB</b>
3558  - at default bus speed
3559  - for default number of data items
3560
3561 \note In Test Mode <b>Loopback</b> this test is not executed
3562 */
3563 void SPI_Bit_Order_MSB_LSB (void) {
3564
3565   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
3566   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3567   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3568   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3569 #if  (SPI_SERVER_USED == 1)
3570   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3571   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3572 #endif
3573
3574   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3575   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3576   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_MSB_TO_LSB, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3577 }
3578
3579 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3580 /**
3581 \brief Function: Function SPI_Bit_Order_LSB_MSB
3582 \details
3583 The function \b SPI_Bit_Order_LSB_MSB verifies data exchange:
3584  - in Master Mode with default Slave Select mode
3585  - with default clock / frame format
3586  - with default data bits
3587  - with bit order <b>from LSB to MSB</b>
3588  - at default bus speed
3589  - for default number of data items
3590
3591 \note In Test Mode <b>Loopback</b> this test is not executed
3592 */
3593 void SPI_Bit_Order_LSB_MSB (void) {
3594
3595   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
3596   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3597   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3598   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3599   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3600 #if  (SPI_SERVER_USED == 1)
3601   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3602   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_LSB_TO_MSB, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3603 #endif
3604
3605   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_LSB_TO_MSB, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3606   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_LSB_TO_MSB, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3607   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, BO_LSB_TO_MSB, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3608 }
3609
3610 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3611 /**
3612 \brief Function: Function SPI_Bus_Speed_Min
3613 \details
3614 The function \b SPI_Bus_Speed_Min verifies data exchange:
3615  - in Master Mode with default Slave Select mode
3616  - with default clock / frame format
3617  - with default data bits
3618  - with default bit order
3619  - at <b>minimum bus speed</b> (define <c>SPI_CFG_MIN_BUS_SPEED</c> in DV_SPI_Config.h)
3620  - for default number of data items
3621
3622 This test function checks the following requirements:
3623  - measured bus speed is not 25% lower, or higher than requested
3624  - bus speed value returned by the driver is not negative
3625  - bus speed value returned by the driver is not higher then requested
3626  - bus speed value returned by the driver is not lower then 75% of requested
3627 */
3628 void SPI_Bus_Speed_Min (void) {
3629   volatile uint64_t bps;
3630   volatile  int32_t ret_bus_speed;
3631
3632   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3633   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3634   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3635   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3636 #if  (SPI_SERVER_USED == 1)
3637   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3638   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_MIN_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3639 #endif
3640
3641   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_MIN_BUS_SPEED, SPI_CFG_DEF_NUM);
3642   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_MIN_BUS_SPEED, SPI_CFG_DEF_NUM);
3643   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_MIN_BUS_SPEED, SPI_CFG_DEF_NUM);
3644
3645   if (duration != 0xFFFFFFFFU) {        // If Transfer finished before timeout
3646     if (duration != 0U) {               // If duration of transfer was more than 0 SysTick counts
3647       bps = ((uint64_t)systick_freq * SPI_CFG_DEF_DATA_BITS * SPI_CFG_DEF_NUM) / duration;
3648       if ((bps < ((SPI_CFG_MIN_BUS_SPEED * 3) / 4)) ||
3649           (bps >   SPI_CFG_MIN_BUS_SPEED)) {
3650         // If measured bus speed is 25% lower, or higher than requested
3651         (void)snprintf(msg_buf, sizeof(msg_buf), "[WARNING] At requested bus speed of %i bps, effective bus speed is %i bps", SPI_CFG_MIN_BUS_SPEED, (uint32_t)bps);
3652         TEST_MESSAGE(msg_buf);
3653       }
3654     }
3655   }
3656
3657   drv->Control (ARM_SPI_SET_BUS_SPEED, SPI_CFG_MIN_BUS_SPEED);
3658   ret_bus_speed = drv->Control (ARM_SPI_GET_BUS_SPEED, 0U);
3659   if (ret_bus_speed < 0) {
3660     // If bus speed value returned by the driver is negative
3661     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] Get bus speed returned negative value %i", ret_bus_speed);
3662     TEST_FAIL_MESSAGE(msg_buf);
3663   } else if ((uint32_t)ret_bus_speed > SPI_CFG_MIN_BUS_SPEED) {
3664     // If bus speed value returned by the driver is higher then requested
3665     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] Get bus speed returned %i bps instead of requested %i bps", ret_bus_speed, SPI_CFG_MIN_BUS_SPEED);
3666     TEST_FAIL_MESSAGE(msg_buf);
3667   } else if ((uint32_t)ret_bus_speed < ((SPI_CFG_MIN_BUS_SPEED * 3) / 4)) {
3668     // If bus speed value returned by the driver is lower then 75% of requested
3669     (void)snprintf(msg_buf, sizeof(msg_buf), "[WARNING] Get bus speed returned %i bps instead of requested %i bps", ret_bus_speed, SPI_CFG_MIN_BUS_SPEED);
3670     TEST_MESSAGE(msg_buf);
3671   }
3672 }
3673
3674 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3675 /**
3676 \brief Function: Function SPI_Bus_Speed_Max
3677 \details
3678 The function \b SPI_Bus_Speed_Max verifies data exchange:
3679  - in Master Mode with default Slave Select mode
3680  - with default clock / frame format
3681  - with default data bits
3682  - with default bit order
3683  - at <b>maximum bus speed</b> (define <c>SPI_CFG_MAX_BUS_SPEED</c> in DV_SPI_Config.h)
3684  - for default number of data items
3685
3686 This test function checks the following requirements:
3687  - measured bus speed is not 25% lower, or higher than requested
3688  - bus speed value returned by the driver is not negative
3689  - bus speed value returned by the driver is not higher then requested
3690  - bus speed value returned by the driver is not lower then 75% of requested
3691 */
3692 void SPI_Bus_Speed_Max (void) {
3693   volatile uint64_t bps;
3694   volatile  int32_t ret_bus_speed;
3695
3696   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3697   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3698   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3699   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3700 #if  (SPI_SERVER_USED == 1)
3701   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3702   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_MAX_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3703 #endif
3704
3705   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_MAX_BUS_SPEED, SPI_CFG_DEF_NUM);
3706   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_MAX_BUS_SPEED, SPI_CFG_DEF_NUM);
3707   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_MAX_BUS_SPEED, SPI_CFG_DEF_NUM);
3708
3709   if (duration != 0xFFFFFFFFU) {        // If Transfer finished before timeout
3710     if (duration != 0U) {               // If duration of transfer was more than 0 SysTick counts
3711       bps = ((uint64_t)systick_freq * SPI_CFG_DEF_DATA_BITS * SPI_CFG_DEF_NUM) / duration;
3712       if ((bps < ((SPI_CFG_MAX_BUS_SPEED * 3) / 4)) ||
3713           (bps >   SPI_CFG_MAX_BUS_SPEED)) {
3714         // If measured bus speed is 25% lower, or higher than requested
3715         (void)snprintf(msg_buf, sizeof(msg_buf), "[WARNING] At requested bus speed of %i bps, effective bus speed is %i bps", SPI_CFG_MAX_BUS_SPEED, (uint32_t)bps);
3716         TEST_MESSAGE(msg_buf);
3717       }
3718     }
3719   }
3720
3721   drv->Control (ARM_SPI_SET_BUS_SPEED, SPI_CFG_MAX_BUS_SPEED);
3722   ret_bus_speed = drv->Control (ARM_SPI_GET_BUS_SPEED, 0U);
3723   if (ret_bus_speed < 0) {
3724     // If bus speed value returned by the driver is negative
3725     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] Get bus speed returned negative value %i", ret_bus_speed);
3726     TEST_FAIL_MESSAGE(msg_buf);
3727   } else if ((uint32_t)ret_bus_speed > SPI_CFG_MAX_BUS_SPEED) {
3728     // If bus speed value returned by the driver is higher then requested
3729     (void)snprintf(msg_buf, sizeof(msg_buf), "[FAILED] Get bus speed returned %i bps instead of requested %i bps", ret_bus_speed, SPI_CFG_MAX_BUS_SPEED);
3730     TEST_FAIL_MESSAGE(msg_buf);
3731   } else if ((uint32_t)ret_bus_speed < ((SPI_CFG_MAX_BUS_SPEED * 3) / 4)) {
3732     // If bus speed value returned by the driver is lower then 75% of requested
3733     (void)snprintf(msg_buf, sizeof(msg_buf), "[WARNING] Get bus speed returned %i bps instead of requested %i bps", ret_bus_speed, SPI_CFG_MAX_BUS_SPEED);
3734     TEST_MESSAGE(msg_buf);
3735   }
3736 }
3737
3738 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3739 /**
3740 \brief Function: Function SPI_Number_Of_Items
3741 \details
3742 The function \b SPI_Number_Of_Items verifies data exchange:
3743  - in Master Mode with default Slave Select mode
3744  - with default clock / frame format
3745  - with default data bits
3746  - with default bit order
3747  - at default bus speed
3748  - for <b>different number of items</b> (defines <c>SPI_CFG_NUM1 .. SPI_CFG_NUM5</c> in DV_SPI_Config.h)
3749 */
3750 void SPI_Number_Of_Items (void) {
3751
3752   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3753   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3754   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3755   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3756 #if  (SPI_SERVER_USED == 1)
3757   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3758   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3759 #endif
3760
3761 #if (SPI_CFG_NUM1 != 0U)
3762   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM1);
3763   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM1);
3764   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM1);
3765 #endif
3766
3767 #if (SPI_CFG_NUM2 != 0U)
3768   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM2);
3769   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM2);
3770   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM2);
3771 #endif
3772
3773 #if (SPI_CFG_NUM3 != 0U)
3774   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM3);
3775   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM3);
3776   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM3);
3777 #endif
3778
3779 #if (SPI_CFG_NUM4 != 0U)
3780   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM4);
3781   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM4);
3782   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM4);
3783 #endif
3784
3785 #if (SPI_CFG_NUM5 != 0U)
3786   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM5);
3787   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM5);
3788   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_NUM5);
3789 #endif
3790 }
3791
3792 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3793 /**
3794 \brief Function: Function SPI_GetDataCount
3795 \details
3796 The function \b SPI_GetDataCount verifies \b GetDataCount function (count changing) during data exchange:
3797  - in Master Mode with default Slave Select mode
3798  - with default clock / frame format
3799  - with default data bits
3800  - with default bit order
3801  - at default bus speed
3802 */
3803 void SPI_GetDataCount (void) {
3804
3805   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3806   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3807   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3808   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3809 #if  (SPI_SERVER_USED == 1)
3810   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3811   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3812 #endif
3813
3814   SPI_DataExchange_Operation(OP_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3815   TEST_ASSERT_MESSAGE((data_count_sample != 0U) && (data_count_sample != SPI_CFG_DEF_NUM), "[FAILED] GetDataCount was not changing during the Send!");
3816
3817   SPI_DataExchange_Operation(OP_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3818   TEST_ASSERT_MESSAGE((data_count_sample != 0U) && (data_count_sample != SPI_CFG_DEF_NUM), "[FAILED] GetDataCount was not changing during the Receive!");
3819
3820   SPI_DataExchange_Operation(OP_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3821   TEST_ASSERT_MESSAGE((data_count_sample != 0U) && (data_count_sample != SPI_CFG_DEF_NUM), "[FAILED] GetDataCount was not changing during the Transfer!");
3822 }
3823
3824 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3825 /**
3826 \brief Function: Function SPI_Abort
3827 \details
3828 The function \b SPI_Abort verifies \b Abort function abort of data exchange:
3829  - in Master Mode with default Slave Select mode
3830  - with default clock / frame format
3831  - with default data bits
3832  - with default bit order
3833  - at default bus speed
3834 */
3835 void SPI_Abort (void) {
3836
3837   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3838   if (IsBitOrderValid() != EXIT_SUCCESS) {              return; }
3839   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3840   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3841 #if  (SPI_SERVER_USED == 1)
3842   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3843   if (ServerCheckSupport(MODE_SLAVE, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3844 #endif
3845
3846   SPI_DataExchange_Operation(OP_ABORT_SEND,     MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3847   SPI_DataExchange_Operation(OP_ABORT_RECEIVE,  MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3848   SPI_DataExchange_Operation(OP_ABORT_TRANSFER, MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_SS_MODE, SPI_CFG_DEF_BUS_SPEED, SPI_CFG_DEF_NUM);
3849 }
3850
3851 /**
3852 @}
3853 */
3854 // End of spi_tests_data_xchg
3855
3856 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3857 /* SPI Event tests                                                                                                          */
3858 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3859 /**
3860 \defgroup spi_tests_evt Event
3861 \ingroup spi_tests
3862 \details
3863 These tests verify API and operation of the SPI event signaling, except ARM_SPI_EVENT_TRANSFER_COMPLETE
3864 signal which is tested in the Data Exchange tests.
3865
3866 The event tests verify the following driver function
3867 (<a href="http://www.keil.com/pack/doc/CMSIS/Driver/html/group__spi__interface__gr.html" target="_blank">SPI Driver function documentation</a>):
3868  - \b SignalEvent
3869 \code
3870   void (*ARM_SPI_SignalEvent_t) (uint32_t event);
3871 \endcode
3872
3873 \note In Test Mode <b>Loopback</b> these tests are not executed
3874 @{
3875 */
3876
3877 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3878 /**
3879 \brief Function: Function SPI_DataLost
3880 \details
3881 The function \b SPI_DataLost verifies signaling of the <b>ARM_SPI_EVENT_DATA_LOST</b> event:
3882  - in <b>Slave Mode</b> with <b>Slave Select line Hardware monitored</b>
3883  - with default clock / frame format
3884  - with default data bits
3885  - with default bit order
3886  - at default bus speed
3887
3888 it also checks that status data_lost flag was activated.
3889 */
3890 void SPI_DataLost (void) {
3891
3892   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
3893   if (IsFormatValid()   != EXIT_SUCCESS) {              return; }
3894   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3895   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3896 #if  (SPI_SERVER_USED == 1)
3897   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3898   if (ServerCheckSupport(MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3899
3900   do {
3901     if (CmdSetCom  (0U, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, 1U, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { break; }
3902     if (CmdXfer    (1U, 8U, 8U, SPI_CFG_XFER_TIMEOUT) != EXIT_SUCCESS) { break; }
3903     drv->Control   (ARM_SPI_MODE_INACTIVE, 0U);
3904
3905     event = 0U;
3906     (void)osDelay(4U);
3907     (void)drv->Control (ARM_SPI_MODE_SLAVE                                                                 |
3908                       ((SPI_CFG_DEF_FORMAT    << ARM_SPI_FRAME_FORMAT_Pos)   & ARM_SPI_FRAME_FORMAT_Msk)   |
3909                       ((SPI_CFG_DEF_DATA_BITS << ARM_SPI_DATA_BITS_Pos)      & ARM_SPI_DATA_BITS_Msk)      |
3910                       ((SPI_CFG_DEF_BIT_ORDER << ARM_SPI_BIT_ORDER_Pos)      & ARM_SPI_BIT_ORDER_Msk)      |
3911                         ARM_SPI_SS_SLAVE_HW                                                                ,
3912                         0U);
3913
3914     (void)osDelay(SPI_CFG_XFER_TIMEOUT+20U);    // Wait for SPI Server to timeout
3915
3916     (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
3917     (void)osDelay(20U);                 // Wait for SPI Server to start reception of next command
3918
3919     // Assert that event ARM_SPI_EVENT_DATA_LOST was signaled
3920     TEST_ASSERT_MESSAGE((event & ARM_SPI_EVENT_DATA_LOST) != 0U, "[FAILED] Event ARM_SPI_EVENT_DATA_LOST was not signaled!");
3921
3922     // Assert that status data_lost flag is active
3923     TEST_ASSERT_MESSAGE(drv->GetStatus().data_lost != 0U, "[FAILED] Status data_lost flag was not activated!");
3924
3925     return;
3926   } while (false);
3927 #endif
3928 }
3929
3930 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
3931 /**
3932 \brief Function: Function SPI_ModeFault
3933 \details
3934 The function \b SPI_ModeFault verifies signaling of the <b>ARM_SPI_EVENT_MODE_FAULT</b> event:
3935  - in <b>Master Mode</b> with <b>Slave Select line Hardware monitored Input</b>
3936  - with default clock / frame format
3937  - with default data bits
3938  - with default bit order
3939  - at default bus speed
3940
3941 it also checks that status mode_fault flag was activated.
3942 */
3943 void SPI_ModeFault (void) {
3944
3945   if (IsNotLoopback()   != EXIT_SUCCESS) {              return; }
3946   if (IsNotFrameTI()    != EXIT_SUCCESS) {              return; }
3947   if (IsNotFrameMw()    != EXIT_SUCCESS) {              return; }
3948   if (DriverInit()      != EXIT_SUCCESS) { TEST_FAIL(); return; }
3949   if (BuffersCheck()    != EXIT_SUCCESS) { TEST_FAIL(); return; }
3950 #if  (SPI_SERVER_USED == 1)
3951   if (ServerCheck()     != EXIT_SUCCESS) { TEST_FAIL(); return; }
3952   if (ServerCheckSupport(MODE_MASTER, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { TEST_FAIL(); return; }
3953
3954   do {
3955     if (CmdSetCom  (0U, SPI_CFG_DEF_FORMAT, SPI_CFG_DEF_DATA_BITS, SPI_CFG_DEF_BIT_ORDER, 1U, SPI_CFG_DEF_BUS_SPEED) != EXIT_SUCCESS) { break; }
3956     if (CmdXfer    (1U, 8U, 8U, SPI_CFG_XFER_TIMEOUT) != EXIT_SUCCESS) { break; }
3957     drv->Control   (ARM_SPI_MODE_INACTIVE, 0U);
3958
3959     event = 0U;
3960     (void)osDelay(4U);
3961     (void)drv->Control (ARM_SPI_MODE_MASTER                                                              |
3962                       ((SPI_CFG_DEF_FORMAT    << ARM_SPI_FRAME_FORMAT_Pos)   & ARM_SPI_FRAME_FORMAT_Msk) |
3963                       ((SPI_CFG_DEF_DATA_BITS << ARM_SPI_DATA_BITS_Pos)      & ARM_SPI_DATA_BITS_Msk)    |
3964                       ((SPI_CFG_DEF_BIT_ORDER << ARM_SPI_BIT_ORDER_Pos)      & ARM_SPI_BIT_ORDER_Msk)    |
3965                         ARM_SPI_SS_MASTER_HW_INPUT                                                       ,
3966                         SPI_CFG_DEF_BUS_SPEED);
3967
3968     (void)osDelay(SPI_CFG_XFER_TIMEOUT+20U);    // Wait for SPI Server to timeout
3969
3970     (void)drv->Control(ARM_SPI_MODE_INACTIVE, 0U);
3971     (void)osDelay(20U);                 // Wait for SPI Server to start reception of next command
3972
3973     // Assert that event ARM_SPI_EVENT_MODE_FAULT was signaled
3974     TEST_ASSERT_MESSAGE((event & ARM_SPI_EVENT_MODE_FAULT) != 0U, "[FAILED] Event ARM_SPI_EVENT_MODE_FAULT was not signaled!");
3975
3976     // Assert that status mode_fault flag is active
3977     TEST_ASSERT_MESSAGE(drv->GetStatus().mode_fault != 0U, "[FAILED] Status mode_fault flag was not activated!");
3978
3979     return;
3980   } while (false);
3981 #endif
3982 }
3983
3984 /**
3985 @}
3986 */
3987 // End of spi_tests_evt