rpp/lib/rpp/src/sys/ti_drv_mibspi.c

   1 /** @file mibspi.c
   2 *   @brief MIBSPI Driver Implementation File
   3 *   @date 15.Mar.2012
   4 *   @version 03.01.00
   5 *
   6 */
   7
   8 /* (c) Texas Instruments 2009-2012, All rights reserved. */
   9
  10 /* USER CODE BEGIN (0) */
  11 /* USER CODE END */
  12
  13 #include "sys/ti_drv_mibspi.h"
  14
  15 /* USER CODE BEGIN (1) */
  16 /* USER CODE END */
  17
  18 /** @fn void mibspiInit(void)
  19 *   @brief Initializes the MIBSPI Driver
  20 *
  21 *   This function initializes the MIBSPI module.
  22 */
  23 void mibspiInit(void)
  24 {
  25 int i ;
  26
  27 /* USER CODE BEGIN (2) */
  28 /* USER CODE END */
  29
  30
  31
  32
  33     /** @b intalise @b MIBSPI5 */
  34
  35     /** bring MIBSPI out of reset */
  36     mibspiREG5->GCR0 = 1U;
  37
  38     /** enable MIBSPI RAM Parity */
  39     mibspiREG5->EDEN = 0x00000005U;
  40
  41     /** enable MIBSPI5 multibuffered mode and enable buffer RAM */
  42     mibspiREG5->MIBSPIE = 1U;
  43
  44     /** MIBSPI5 master mode and clock configuration */
  45     mibspiREG5->GCR1 = (1 << 1)  /* CLOKMOD */
  46                   | 1;  /* MASTER */
  47
  48     /** MIBSPI5 enable pin configuration */
  49     mibspiREG5->ENAHIGHZ = 0;  /* ENABLE HIGHZ */
  50
  51     /** - Delays */
  52     mibspiREG5->DELAY = (0 << 24)  /* C2TDELAY */
  53                    | (0 << 16)  /* T2CDELAY */
  54                    | (0 << 8)  /* T2EDELAY */
  55                    | 0;  /* C2EDELAY */
  56
  57     /** - Data Format 0 */
  58     mibspiREG5->FMT0 = (0 << 24)  /* wdelay */
  59                   | (0 << 23)  /* parity Polarity */
  60                   | (0 << 22)  /* parity enable */
  61                   | (0 << 21)  /* wait on enable */
  62                   | (0 << 20)  /* shift direction */
  63                   | (0 << 17)  /* clock polarity */
  64                   | (0 << 16)  /* clock phase */
  65                   | (79 << 8) /* baudrate prescale */
  66                   | 16;  /* data word length */
  67
  68     /** - Data Format 1 */
  69     mibspiREG5->FMT1 = (0 << 24)  /* wdelay */
  70                   | (0 << 23)  /* parity Polarity */
  71                   | (0 << 22)  /* parity enable */
  72                   | (0 << 21)  /* wait on enable */
  73                   | (0 << 20)  /* shift direction */
  74                   | (0 << 17)  /* clock polarity */
  75                   | (0 << 16)  /* clock phase */
  76                   | (79 << 8) /* baudrate prescale */
  77                   | 16;  /* data word length */
  78
  79     /** - Data Format 2 */
  80     mibspiREG5->FMT2 = (0 << 24)  /* wdelay */
  81                   | (0 << 23)  /* parity Polarity */
  82                   | (0 << 22)  /* parity enable */
  83                   | (0 << 21)  /* wait on enable */
  84                   | (0 << 20)  /* shift direction */
  85                   | (0 << 17)  /* clock polarity */
  86                   | (0 << 16)  /* clock phase */
  87                   | (79 << 8) /* baudrate prescale */
  88                   | 16;  /* data word length */
  89
  90     /** - Data Format 3 */
  91     mibspiREG5->FMT3 = (0 << 24)  /* wdelay */
  92                   | (0 << 23)  /* parity Polarity */
  93                   | (0 << 22)  /* parity enable */
  94                   | (0 << 21)  /* wait on enable */
  95                   | (0 << 20)  /* shift direction */
  96                   | (0 << 17)  /* clock polarity */
  97                   | (0 << 16)  /* clock phase */
  98                   | (79 << 8) /* baudrate prescale */
  99                   | 16;  /* data word length */
 100
 101     /** - wait for buffer inialisation complete before accessing MibSPI registers */
 102     while ((mibspiREG5->BUFINIT) != 0) { /* wait */ }
 103
 104     /** - inialise transfer groups */
 105     mibspiREG5->TGCTRL[0] = (1 << 30)  /* oneshot */
 106                        | (0 << 29)  /* pcurrent reset */
 107                        | (TRG_ALWAYS << 20)  /* trigger event */
 108                        | (TRG_DISABLED << 16)  /* trigger source */
 109                        | (0 << 8);  /* start buffer */
 110
 111     mibspiREG5->TGCTRL[1] = (1 << 30)  /* oneshot */
 112                        | (0 << 29)  /* pcurrent reset */
 113                        | (TRG_ALWAYS << 20)  /* trigger event */
 114                        | (TRG_DISABLED << 16)  /* trigger source */
 115                        | (8 << 8);  /* start buffer */
 116
 117     mibspiREG5->TGCTRL[2] = (1 << 30)  /* oneshot */
 118                        | (0 << 29)  /* pcurrent reset */
 119                        | (TRG_ALWAYS << 20)  /* trigger event */
 120                        | (TRG_DISABLED << 16)  /* trigger source */
 121                        | ((8+0) << 8);  /* start buffer */
 122
 123     mibspiREG5->TGCTRL[3] = (1 << 30)  /* oneshot */
 124                        | (0 << 29)  /* pcurrent reset */
 125                        | (TRG_ALWAYS << 20)  /* trigger event */
 126                        | (TRG_DISABLED << 16)  /* trigger source */
 127                        | ((8+0+0) << 8);  /* start buffer */
 128
 129     mibspiREG5->TGCTRL[4] = (1 << 30)  /* oneshot */
 130                        | (0 << 29)  /* pcurrent reset */
 131                        | (TRG_ALWAYS << 20)  /* trigger event */
 132                        | (TRG_DISABLED << 16)  /* trigger source */
 133                        | ((8+0+0+0) << 8);  /* start buffer */
 134
 135     mibspiREG5->TGCTRL[5] = (1 << 30)  /* oneshot */
 136                        | (0 << 29)  /* pcurrent reset */
 137                        | (TRG_ALWAYS << 20)  /* trigger event */
 138                        | (TRG_DISABLED << 16)  /* trigger source */
 139                        | ((8+0+0+0+0) << 8);  /* start buffer */
 140
 141     mibspiREG5->TGCTRL[6] = (1 << 30)  /* oneshot */
 142                        | (0 << 29)  /* pcurrent reset */
 143                        | (TRG_ALWAYS << 20)  /* trigger event */
 144                        | (TRG_DISABLED << 16)  /* trigger source */
 145                        | ((8+0+0+0+0+0) << 8);  /* start buffer */
 146
 147     mibspiREG5->TGCTRL[7] = (1 << 30)  /* oneshot */
 148                        | (0 << 29)  /* pcurrent reset */
 149                        | (TRG_ALWAYS << 20)  /* trigger event */
 150                        | (TRG_DISABLED << 16)  /* trigger source */
 151                        | ((8+0+0+0+0+0+0) << 8);  /* start buffer */
 152
 153
 154     mibspiREG5->TGCTRL[8] = 8+0+0+0+0+0+0+0 << 8;
 155
 156     mibspiREG5->LTGPEND = 8+0+0+0+0+0+0+0-1;
 157
 158     /** - initalise buffer ram */
 159     {   i = 0;
 160
 161         if (8 > 0)
 162         {
 163             while (i < 8-1)
 164             {
 165                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 166                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 167                                          | (0 << 11)  /* lock transmission */
 168                                          | (0 << 8)  /* data format */
 169                                          | CS_0;  /* chip select */
 170             }
 171             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 172                                      | (0 << 12) /* chip select hold */
 173                                      | (0 << 10)  /* enable WDELAY */
 174                                      | (0 << 8)  /* data format */
 175                                      | CS_0;  /* chip select */
 176         }
 177         if (0 > 0)
 178         {
 179             while (i < 8+0-1)
 180             {
 181                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 182                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 183                                          | (0 << 11)  /* lock transmission */
 184                                          | (0 << 8)  /* data format */
 185                                          | CS_1;  /* chip select */
 186             }
 187             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 188                                      | (0 << 12) /* chip select hold */
 189                                      | (0 << 10)  /* enable WDELAY */
 190                                      | (0 << 8)  /* data format */
 191                                      | CS_1;  /* chip select */
 192         }
 193         if (0 > 0)
 194         {
 195             while (i < 8+0+0-1)
 196             {
 197                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 198                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 199                                          | (0 << 11)  /* lock transmission */
 200                                          | (0 << 8)  /* data format */
 201                                          | CS_2;  /* chip select */
 202             }
 203             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 204                                      | (0 << 12) /* chip select hold */
 205                                      | (0 << 10)  /* enable WDELAY */
 206                                      | (0 << 8)  /* data format */
 207                                      | CS_2;  /* chip select */
 208         }
 209         if (0 > 0)
 210         {
 211             while (i < 8+0+0+0-1)
 212             {
 213                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 214                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 215                                          | (0 << 11)  /* lock transmission */
 216                                          | (0 << 8)  /* data format */
 217                                          | CS_3;  /* chip select */
 218             }
 219             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 220                                      | (0 << 12) /* chip select hold */
 221                                      | (0 << 10)  /* enable WDELAY */
 222                                      | (0 << 8)  /* data format */
 223                                      | CS_3;  /* chip select */
 224         }
 225         if (0 > 0)
 226         {
 227             while (i < 8+0+0+0+0-1)
 228             {
 229                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 230                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 231                                          | (0 << 11)  /* lock transmission */
 232                                          | (0 << 8)  /* data format */
 233                                          | CS_4;  /* chip select */
 234             }
 235             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 236                                      | (0 << 12) /* chip select hold */
 237                                      | (0 << 10)  /* enable WDELAY */
 238                                      | (0 << 8)  /* data format */
 239                                      | CS_4;  /* chip select */
 240         }
 241         if (0 > 0)
 242         {
 243             while (i < 8+0+0+0+0+0-1)
 244             {
 245                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 246                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 247                                          | (0 << 11)  /* lock transmission */
 248                                          | (0 << 8)  /* data format */
 249                                          | CS_5;  /* chip select */
 250             }
 251             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 252                                      | (0 << 12) /* chip select hold */
 253                                      | (0 << 10)  /* enable WDELAY */
 254                                      | (0 << 8)  /* data format */
 255                                      | CS_5;  /* chip select */
 256         }
 257         if (0 > 0)
 258         {
 259             while (i < 8+0+0+0+0+0+0-1)
 260             {
 261                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 262                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 263                                          | (0 << 11)  /* lock transmission */
 264                                          | (0 << 8)  /* data format */
 265                                          | CS_6;  /* chip select */
 266             }
 267             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 268                                      | (0 << 12) /* chip select hold */
 269                                      | (0 << 10)  /* enable WDELAY */
 270                                      | (0 << 8)  /* data format */
 271                                      | CS_6;  /* chip select */
 272         }
 273         if (0 > 0)
 274         {
 275             while (i < 8+0+0+0+0+0+0+0-1)
 276             {
 277                 mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 278                                          | (0 << 12)  /* hold chip select Based on Lock selection */
 279                                          | (0 << 11)  /* lock transmission */
 280                                          | (0 << 8)  /* data format */
 281                                          | CS_7;  /* chip select */
 282             }
 283             mibspiRAM5->tx[i++].control = (4 << 13)  /* buffer mode */
 284                                      | (0 << 12) /* chip select hold */
 285                                      | (0 << 10)  /* enable WDELAY */
 286                                      | (0 << 8)  /* data format */
 287                                      | CS_7;  /* chip select */
 288         }
 289     }
 290
 291     /** - set interrupt levels */
 292     mibspiREG5->LVL = (0 << 9)  /* TXINT */
 293                  | (0 << 8)  /* RXINT */
 294                  | (0 << 6)  /* OVRNINT */
 295                  | (0 << 4)  /* BITERR */
 296                  | (0 << 3)  /* DESYNC */
 297                  | (0 << 2)  /* PARERR */
 298                  | (0 << 1) /* TIMEOUT */
 299                  | (0);  /* DLENERR */
 300
 301     /** - clear any pending interrupts */
 302     mibspiREG5->FLG = 0xFFFFU;
 303
 304     /** - enable interrupts */
 305     mibspiREG5->INT0 = (0 << 9)  /* TXINT */
 306                   | (0 << 8)  /* RXINT */
 307                   | (0 << 6)  /* OVRNINT */
 308                   | (0 << 4)  /* BITERR */
 309                   | (0 << 3)  /* DESYNC */
 310                   | (0 << 2)  /* PARERR */
 311                   | (0 << 1) /* TIMEOUT */
 312                   | (0);  /* DLENERR */
 313
 314     /** @b initalise @b MIBSPI5 @b Port */
 315
 316     /** - MIBSPI5 Port output values */
 317     mibspiREG5->PCDOUT =  0        /* SCS[0] */
 318                     | (0 << 1)  /* SCS[1] */
 319                     | (0 << 2)  /* SCS[2] */
 320                     | (0 << 3)  /* SCS[3] */
 321                     | (0 << 8)  /* ENA */
 322                     | (0 << 9)  /* CLK */
 323                     | (0 << 10)  /* SIMO */
 324                     | (0 << 19)
 325                     | (0 << 25)
 326                     | (0 << 26)
 327                     | (0 << 27)
 328                     | (0 << 17)
 329                     | (0 << 18)
 330                     | (0 << 11); /* SOMI */
 331
 332     /** - MIBSPI5 Port direction */
 333     mibspiREG5->PCDIR  =  1        /* SCS[0] */
 334                     | (1 << 1)  /* SCS[1] */
 335                     | (1 << 2)  /* SCS[2] */
 336                     | (1 << 3)  /* SCS[3] */
 337                     | (0 << 8)  /* ENA */
 338                     | (1 << 9)  /* CLK */
 339                     | (1 << 10)  /* SIMO */
 340                     | (0 << 19)
 341                     | (0 << 25)
 342                     | (0 << 26)
 343                     | (0 << 27)
 344                     | (0 << 17)
 345                     | (0 << 18)
 346                     | (0 << 11); /* SOMI */
 347
 348     /** - MIBSPI5 Port open drain enable */
 349     mibspiREG5->PCPDR  =  0        /* SCS[0] */
 350                     | (0 << 1)  /* SCS[1] */
 351                     | (0 << 2)  /* SCS[2] */
 352                     | (0 << 3)  /* SCS[3] */
 353                     | (0 << 8)  /* ENA */
 354                     | (0 << 9)  /* CLK */
 355                     | (0 << 10)  /* SIMO */
 356                     | (0 << 19)
 357                     | (0 << 25)
 358                     | (0 << 26)
 359                     | (0 << 27)
 360                     | (0 << 17)
 361                     | (0 << 18)
 362                     | (0 << 11); /* SOMI */
 363
 364     /** - MIBSPI5 Port pullup / pulldown selection */
 365     mibspiREG5->PCPSL  =  1        /* SCS[0] */
 366                     | (1 << 1)  /* SCS[1] */
 367                     | (1 << 2)  /* SCS[2] */
 368                     | (1 << 3)  /* SCS[3] */
 369                     | (1 << 8)  /* ENA */
 370                     | (1 << 9)  /* CLK */
 371                     | (1 << 10)  /* SIMO */
 372                     | (1 << 19)
 373                     | (1 << 25)
 374                     | (1 << 26)
 375                     | (1 << 27)
 376                     | (1 << 17)
 377                     | (1 << 18)
 378                     | (1 << 11); /* SOMI */
 379
 380     /** - MIBSPI5 Port pullup / pulldown enable*/
 381     mibspiREG5->PCDIS  =  0        /* SCS[0] */
 382                     | (0 << 1)  /* SCS[1] */
 383                     | (0 << 2)  /* SCS[2] */
 384                     | (0 << 3)  /* SCS[3] */
 385                     | (0 << 8)  /* ENA */
 386                     | (0 << 9)  /* CLK */
 387                     | (0 << 10)  /* SIMO */
 388                     | (0 << 19)
 389                     | (0 << 25)
 390                     | (0 << 26)
 391                     | (0 << 27)
 392                     | (0 << 17)
 393                     | (0 << 18)
 394                     | (0 << 11); /* SOMI */
 395
 396     /* MIBSPI5 set all pins to functional */
 397     mibspiREG5->PCFUN  =  1        /* SCS[0] */
 398                     | (1 << 1)  /* SCS[1] */
 399                     | (1 << 2)  /* SCS[2] */
 400                     | (1 << 3)  /* SCS[3] */
 401                     | (1 << 8)  /* ENA */
 402                     | (1 << 9)  /* CLK */
 403                     | (1 << 10)  /* SIMO */
 404                     | (1 << 19)
 405                     | (1 << 25)
 406                     | (1 << 26)
 407                     | (1 << 27)
 408                     | (0 << 17)
 409                     | (0 << 18)
 410                     | (1 << 11); /* SOMI */
 411
 412
 413
 414   /** - Finaly start MIBSPI5 */
 415     mibspiREG5->ENA = 1U;
 416
 417 /* USER CODE BEGIN (3) */
 418 /* USER CODE END */
 419
 420 }
 421
 422
 423 /** @fn void mibspiSetFunctional(mibspiBASE_t *mibspi, uint32_t port)
 424 *   @brief Change functional behavoiur of pins at runtime.
 425 *   @param[in] mibspi   - mibspi module base address
 426 *   @param[in] port  - Value to write to PCFUN register
 427 *
 428 *   Change the value of the PCFUN register at runtime, this allows to
 429 *   dynaimcaly change the functionality of the MIBSPI pins between functional
 430 *   and GIO mode.
 431 */
 432 void mibspiSetFunctional(mibspiBASE_t *mibspi, uint32_t port)
 433 {
 434 /* USER CODE BEGIN (4) */
 435 /* USER CODE END */
 436
 437     mibspi->PCFUN = port;
 438
 439 /* USER CODE BEGIN (5) */
 440 /* USER CODE END */
 441 }
 442
 443
 444 /** @fn void mibspiSetData(mibspiBASE_t *mibspi, uint32_t group, uint16_t data[])
 445 *   @brief Set Buffer Data
 446 *   @param[in] mibspi   - Spi module base address
 447 *   @param[in] group - Transfer group (0..7)
 448 *   @param[in] data  - new data for transfer group
 449 *
 450 *   This function updates the data for the specified transfer group,
 451 *   the length of the data must match the length of the transfer group.
 452 */
 453 void mibspiSetData(mibspiBASE_t *mibspi, uint32_t group, uint16_t data[])
 454 {
 455 /* USER CODE BEGIN (6) */
 456 /* USER CODE END */
 457
 458     mibspiRAM_t *ram    = mibspi == mibspiREG1 ? mibspiRAM1 : (mibspi == mibspiREG3 ? mibspiRAM3 : mibspiRAM5);
 459     uint32_t start  = (mibspi->TGCTRL[group] >> 8) & 0xFF;
 460     uint32_t end    = group == 7 ? (mibspi->LTGPEND + 1) : (mibspi->TGCTRL[group+1] >> 8) & 0xFF;
 461
 462     if (end < start) {end = 128;}
 463
 464     while (start < end)
 465     {
 466         ram->tx[start].data = *data++;
 467         start++;
 468     }
 469 /* USER CODE BEGIN (7) */
 470 /* USER CODE END */
 471 }
 472
 473
 474 /** @fn void mibspiGetData(mibspiBASE_t *mibspi, uint32_t group, uint16_t data[])
 475 *   @brief Retrieves Buffer Data fro receive buffer
 476 *   @param[in]  mibspi   - Spi module base address
 477 *   @param[in]  group - Transfer group (0..7)
 478 *   @param[out] data  - pointer to data array
 479 *
 480 *   @return error flags from data buffer, if there was a receive error on
 481 *           one of the buffers this will be rerflected in the return value.
 482 *
 483 *   This function transfers the data from the specified transfer group receve
 484 *   buffers to the data array,  the length of the data must match the length
 485 *   of the transfer group.
 486 */
 487 uint32_t mibspiGetData(mibspiBASE_t *mibspi, uint32_t group, uint16_t data[])
 488 {
 489 /* USER CODE BEGIN (8) */
 490 /* USER CODE END */
 491
 492     mibspiRAM_t *ram    = mibspi == mibspiREG1 ? mibspiRAM1 : (mibspi == mibspiREG3 ? mibspiRAM3 : mibspiRAM5);
 493     uint32_t start  = (mibspi->TGCTRL[group] >> 8) & 0xFF;
 494     uint32_t end    = group == 7 ? (mibspi->LTGPEND + 1) : (mibspi->TGCTRL[group+1] >> 8) & 0xFF;
 495     uint32_t flags  = 0;
 496
 497     if (end < start) {end = 128;}
 498
 499     while (start < end)
 500     {
 501         flags  |= ram->rx[start].flags;
 502         *data++ = ram->rx[start].data;
 503         start++;
 504     }
 505
 506 /* USER CODE BEGIN (9) */
 507 /* USER CODE END */
 508
 509     return (flags >> 8) & 0x5F;
 510 }
 511
 512
 513 /** @fn void mibspiTransfer(mibspiBASE_t *mibspi, uint32_t group)
 514 *   @brief Transmit Transfer Group
 515 *   @param[in] mibspi   - Spi module base address
 516 *   @param[in] group - Transfer group (0..7)
 517 *
 518 *   Initiates a transfer for the specified transfer group.
 519 */
 520 void mibspiTransfer(mibspiBASE_t *mibspi, uint32_t group)
 521 {
 522 /* USER CODE BEGIN (10) */
 523 /* USER CODE END */
 524
 525     mibspi->TGCTRL[group] |= 0x80000000;
 526
 527 /* USER CODE BEGIN (11) */
 528 /* USER CODE END */
 529 }
 530
 531
 532 /** @fn int mibspiIsTransferComplete(mibspiBASE_t *mibspi, uint32_t group)
 533 *   @brief Check for Transfer Group Ready
 534 *   @param[in] mibspi   - Spi module base address
 535 *   @param[in] group - Transfer group (0..7)
 536 *
 537 *   @return 1 is transfer complete, otherwise 0.
 538 *
 539 *   Checks to see if the transfer for the specified transfer group
 540 *   has finished.
 541 */
 542 int mibspiIsTransferComplete(mibspiBASE_t *mibspi, uint32_t group)
 543 {
 544 /* USER CODE BEGIN (12) */
 545 /* USER CODE END */
 546     return (mibspi->INTFLGRDY >> group) & 1;
 547 }
 548
 549
 550 /** @fn void mibspiEnableLoopback(mibspiBASE_t *mibspi, Loopbacktype_t Loopbacktype)
 551 *   @brief Enable Loopback mode for self test
 552 *   @param[in] mibspi        - Mibspi module base address
 553 *   @param[in] Loopbacktype  - Digital or Analog
 554 *
 555 *   This function enables the Loopback mode for self test.
 556 */
 557 void mibspiEnableLoopback(mibspiBASE_t *mibspi, Loopbacktype_t Loopbacktype)
 558 {
 559 /* USER CODE BEGIN (13) */
 560 /* USER CODE END */
 561
 562     /* Clear Loopback incase enbaled already */
 563     mibspi->IOLPKTSTCR = 0;
 564
 565     /* Enable Loopback either in Analog or Digital Mode */
 566     mibspi->IOLPKTSTCR = 0x00000A00
 567                        | Loopbacktype << 1;
 568
 569 /* USER CODE BEGIN (14) */
 570 /* USER CODE END */
 571 }
 572
 573 /** @fn void mibspiDisableLoopback(mibspiBASE_t *mibspi)
 574 *   @brief Enable Loopback mode for self test
 575 *   @param[in] mibspi        - Mibspi module base address
 576 *
 577 *   This function disable the Loopback mode.
 578 */
 579 void mibspiDisableLoopback(mibspiBASE_t *mibspi)
 580 {
 581 /* USER CODE BEGIN (15) */
 582 /* USER CODE END */
 583
 584     /* Disable Loopback Mode */
 585     mibspi->IOLPKTSTCR = 0x000005000;
 586
 587 /* USER CODE BEGIN (16) */
 588 /* USER CODE END */
 589 }
 590
 591
 592 /** @fn void mibspiEnableGroupNotification(mibspiBASE_t *mibspi, uint32_t group, uint32_t level)
 593 *   @brief Enable Transfer Group interrupt
 594 *   @param[in] mibspi   - Spi module base address
 595 *   @param[in] group - Transfer group (0..7)
 596 *   @param[in] level - Interrupt level
 597 *
 598 *   This function enables the transfer group finished interrupt.
 599 */
 600 void mibspiEnableGroupNotification(mibspiBASE_t *mibspi, uint32_t group, uint32_t level)
 601 {
 602 /* USER CODE BEGIN (17) */
 603 /* USER CODE END */
 604
 605     if (level != 0)
 606     {
 607         mibspi->SETINTLVLRDY = 1 << group;
 608     }
 609     else
 610     {
 611         mibspi->CLRINTLVLRDY = 1 << group;
 612     }
 613     mibspi->SETINTENARDY = 1 << group;
 614
 615 /* USER CODE BEGIN (18) */
 616 /* USER CODE END */
 617 }
 618
 619
 620 /** @fn void mibspiDisableGroupNotification(mibspiBASE_t *mibspi, uint32_t group)
 621 *   @brief Disable Transfer Group interrupt
 622 *   @param[in] mibspi   - Spi module base address
 623 *   @param[in] group - Transfer group (0..7)
 624 *
 625 *   This function disables the transfer group finished interrupt.
 626 */
 627 void mibspiDisableGroupNotification(mibspiBASE_t *mibspi, uint32_t group)
 628 {
 629 /* USER CODE BEGIN (19) */
 630 /* USER CODE END */
 631
 632     mibspi->CLRINTENARDY = 1 << group;
 633
 634 /* USER CODE BEGIN (20) */
 635 /* USER CODE END */
 636 }
 637
 638
 639
 640 /** @fn void mibspi5HighLevelInterrupt(void)
 641 *   @brief Level 0 Interrupt for MIBSPI5
 642 */
 643 #pragma INTERRUPT(mibspi5HighLevelInterrupt, IRQ)
 644
 645 void mibspi5HighLevelInterrupt(void)
 646 {
 647     uint32_t vec = mibspiREG5->INTVECT0;
 648
 649 /* USER CODE BEGIN (29) */
 650 /* USER CODE END */
 651
 652     if (vec > 0x21U)
 653     {
 654         uint32_t flags = mibspiREG5->FLG & (~mibspiREG5->LVL & 0x035F);
 655         mibspiREG5->FLG = flags;
 656         mibspiNotification(mibspiREG5, flags);
 657     }
 658     else
 659     {
 660         mibspiGroupNotification(mibspiREG5, ((vec & 0x3FU) >> 1U) - 1U);
 661     }
 662 /* USER CODE BEGIN (30) */
 663 /* USER CODE END */
 664 }
 665
 666
 667 /** @fn void mibspi5LowLevelInterrupt(void)
 668 *   @brief Level 1 Interrupt for MIBSPI5
 669 */
 670 #pragma INTERRUPT(mibspi5LowLevelInterrupt, IRQ)
 671
 672 void mibspi5LowLevelInterrupt(void)
 673 {
 674     uint32_t vec = mibspiREG5->INTVECT1;
 675
 676 /* USER CODE BEGIN (31) */
 677 /* USER CODE END */
 678
 679     if (vec > 0x21U)
 680     {
 681         uint32_t flags = mibspiREG5->FLG & (mibspiREG5->LVL & 0x035F);
 682         mibspiREG5->FLG = flags;
 683         mibspiNotification(mibspiREG5, flags);
 684     }
 685     else
 686     {
 687         mibspiGroupNotification(mibspiREG5, ((vec & 0x3FU) >> 1U) - 1U);
 688     }
 689 /* USER CODE BEGIN (32) */
 690 /* USER CODE END */
 691 }
 692