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