spi_pal.c
Go to the documentation of this file.
1 /*
2  * Copyright 2017 NXP
3  * All rights reserved.
4  *
5  * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
6  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
7  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
8  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
9  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
10  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
11  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
13  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
14  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
15  * THE POSSIBILITY OF SUCH DAMAGE.
16  */
17 
61 #include "spi_pal.h"
62 #include "device_registers.h"
63 
64 /* Include PD files */
65 #if (defined (SPI_OVER_LPSPI))
66  #include "lpspi_master_driver.h"
67  #include "lpspi_slave_driver.h"
68 #endif
69 
70 #if (defined (SPI_OVER_FLEXIO))
71  #include "flexio.h"
72  #include "flexio_spi_driver.h"
73 #endif
74 
75 #if (defined (SPI_OVER_DSPI))
76  #include "dspi_driver.h"
77 #endif
78 
79 
80 /* Define state structures for LPSPI */
81 #if (defined(SPI_OVER_LPSPI))
82 
83  static lpspi_state_t LpspiState[NO_OF_LPSPI_INSTS_FOR_SPI];
85  static uint32_t LpspiStateInstanceMapping[NO_OF_LPSPI_INSTS_FOR_SPI];
87  static bool LpspiStateIsAllocated[NO_OF_LPSPI_INSTS_FOR_SPI];
90 #endif
91 
92 /* Define state structures for SPI over FLEXIO */
93 #if (defined(SPI_OVER_FLEXIO))
94 
95  static flexio_spi_master_state_t FlexioSpiState[NO_OF_FLEXIO_INSTS_FOR_SPI];
96  static flexio_device_state_t FlexioState;
98  static uint32_t FlexioSpiStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_SPI];
100  static bool FlexioSpiStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_SPI];
101 #endif
102 
103 /* Define state structures for DSPI */
104 #if (defined(SPI_OVER_DSPI))
105 
106  static dspi_state_t dspiState[NO_OF_DSPI_INSTS_FOR_SPI];
108  static uint32_t DspiStateInstanceMapping[NO_OF_DSPI_INSTS_FOR_SPI];
110  static bool DspiStateIsAllocated[NO_OF_DSPI_INSTS_FOR_SPI];
111 #endif
112 
113 /*FUNCTION**********************************************************************
114  *
115  * Function Name : SpiAllocateState
116  * Description : Allocates one of the available state structure.
117  *
118  *END**************************************************************************/
119 static uint8_t SpiAllocateState(bool* isAllocated, uint32_t* instanceMapping, uint32_t instance, uint8_t numberOfinstances)
120 {
121  uint8_t i;
122  /* Allocate one of the LPSPI state structure for this instance */
123  for (i = 0;i < numberOfinstances;i++)
124  {
125  if (isAllocated[i] == false)
126  {
127  instanceMapping[i] = instance;
128  isAllocated[i] = true;
129  break;
130  }
131  }
132  return i;
133 }
134 
135 /*FUNCTION**********************************************************************
136  *
137  * Function Name : SpiFreeState
138  * Description : Deallocates one of the available state structure.
139  *
140  *END**************************************************************************/
141 static void SpiFreeState(bool* isAllocated, const uint32_t* instanceMapping, uint32_t instance, uint8_t numberOfinstances)
142 {
143  uint8_t i;
144  /* Allocate one of the LPSPI state structure for this instance */
145  for (i = 0;i < numberOfinstances;i++)
146  {
147  if (instanceMapping[i] == instance)
148  {
149  isAllocated[i] = false;
150  break;
151  }
152  }
153 }
154 
155 #if (defined(SPI_OVER_FLEXIO))
156 /*FUNCTION**********************************************************************
157  *
158  * Function Name : FindFlexioState
159  * Description : Search the state structure of the flexio instance
160  *
161  *END**************************************************************************/
162 static uint8_t FindFlexioState(const spi_instance_t * const instance)
163 {
164  uint8_t i;
165  for (i = 0;i<NO_OF_FLEXIO_INSTS_FOR_SPI;i++)
166  {
167  if (FlexioSpiStateInstanceMapping[i] == instance->instIdx)
168  {
169  break;
170  }
171  }
172  return i;
173 }
174 #endif
175 
176 #if (defined(SPI_OVER_DSPI))
177 /*FUNCTION**********************************************************************
178  *
179  * Function Name : GetDspiIndex
180  * Description : Get DSPI instances.
181  *
182  *END**************************************************************************/
183 static uint32_t GetDspiIndex(const spi_instance_t * const instance)
184 {
185  uint32_t inst;
186  if (instance->instType == SPI_INST_TYPE_DSPI)
187  {
188  inst = instance->instIdx;
189  }
190  else
191  {
192  inst = instance->instIdx + DSPI_INSTANCE_COUNT;
193  }
194  return inst;
195 }
196 #endif
197 
198 /*FUNCTION**********************************************************************
199  *
200  * Function Name : SPI_MasterInit
201  * Description : Configures the SPI in master mode
202  * Implements : SPI_MasterInit_Activity
203  *
204  *END**************************************************************************/
205 status_t SPI_MasterInit(const spi_instance_t * const instance, const spi_master_t *config)
206 {
207  status_t status = STATUS_ERROR;
208  uint8_t index = 0;
209 
210  /* Define SPI PAL over LPSPI */
211  #if (defined (SPI_OVER_LPSPI))
212  if (instance->instType == SPI_INST_TYPE_LPSPI)
213  {
214  lpspi_master_config_t lpspiConfig;
215  lpspiConfig.bitsPerSec = config->baudRate;
216  lpspiConfig.whichPcs = (lpspi_which_pcs_t)config->ssPin;
217  lpspiConfig.pcsPolarity = (lpspi_signal_polarity_t)(!(bool)(config->ssPolarity));
218  lpspiConfig.bitcount = config->frameSize;
219  (void)CLOCK_SYS_GetFreq(g_lpspiClock[(uint32_t)instance->instIdx] ,&lpspiConfig.lpspiSrcClk);
220  lpspiConfig.clkPhase = (lpspi_clock_phase_t)config->clockPhase;
221  lpspiConfig.clkPolarity = (lpspi_sck_polarity_t)config->clockPolarity;
222  lpspiConfig.lsbFirst = config->bitOrder;
223  lpspiConfig.transferType = (lpspi_transfer_type)config->transferType;
224  lpspiConfig.rxDMAChannel = config->rxDMAChannel;
225  lpspiConfig.txDMAChannel = config->txDMAChannel;
226  lpspiConfig.callback = config->callback;
227  lpspiConfig.callbackParam = config->callbackParam;
228  lpspiConfig.isPcsContinuous = false;
229  /* Allocate one of the LPSPI state structure for this instance */
230  index = SpiAllocateState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
231  status = LPSPI_DRV_MasterInit(instance->instIdx, (lpspi_state_t*)(&LpspiState[index]), &lpspiConfig);
232  }
233  else
234  #endif
235 
236  /* Define SPI PAL over FLEXIO */
237  #if (defined (SPI_OVER_FLEXIO))
238  if (instance->instType == SPI_INST_TYPE_FLEXIO)
239  {
240  /* FlexIO driver can be used only for the following frame sizes: 8,16 or 32 */
241  DEV_ASSERT((config->frameSize == (uint32_t)8) || (config->frameSize == (uint32_t)16) || (config->frameSize == (uint32_t)32));
242  /* FlexIO driver can be used only when SS is active low */
243  DEV_ASSERT((config->ssPolarity) == SPI_ACTIVE_LOW);
244  flexio_spi_master_user_config_t flexioConfig;
245  flexioConfig.baudRate = config->baudRate;
246  switch(config->transferType)
247  {
248  case SPI_USING_DMA: flexioConfig.driverType = FLEXIO_DRIVER_TYPE_DMA; break;
250  default : /*Nothing to do */ break;
251  }
252  flexioConfig.bitOrder = (flexio_spi_transfer_bit_order_t)config->bitOrder;
253  switch (config->frameSize)
254  {
255  case 8U : flexioConfig.transferSize = FLEXIO_SPI_TRANSFER_1BYTE; break;
256  case 16U : flexioConfig.transferSize = FLEXIO_SPI_TRANSFER_2BYTE; break;
257  case 32U : flexioConfig.transferSize = FLEXIO_SPI_TRANSFER_4BYTE; break;
258  default : /* Nothing to do */ break;
259  }
260  flexioConfig.clockPolarity = (uint8_t)config->clockPolarity;
261  flexioConfig.clockPhase = (uint8_t)config->clockPhase;
262  flexioConfig.mosiPin = ((extension_flexio_for_spi_t*)(config->extension))->mosiPin;
263  flexioConfig.misoPin = ((extension_flexio_for_spi_t*)(config->extension))->misoPin;
264  flexioConfig.sckPin = ((extension_flexio_for_spi_t*)(config->extension))->sckPin;
265  flexioConfig.ssPin = ((extension_flexio_for_spi_t*)(config->extension))->ssPin;
266  /* Link Flexio Callbacks to the callbacks defined in PAL */
267  flexioConfig.callback = config->callback;
268  /* Store the callbacks defined by the user in PAL internal callbacks vector */
269  flexioConfig.callbackParam = config->callbackParam;
270  flexioConfig.rxDMAChannel = config->rxDMAChannel;
271  flexioConfig.txDMAChannel = config->txDMAChannel;
272  status = FLEXIO_DRV_InitDevice(0U, &FlexioState);
273  if (status == STATUS_SUCCESS)
274  {
275  /* Allocate one of the Flexio state structure for this instance */
276  index = SpiAllocateState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
277  status = FLEXIO_SPI_DRV_MasterInit(0U, &flexioConfig, (flexio_spi_master_state_t*)&FlexioSpiState[index]);
278  }
279  }
280  else
281  #endif
282 
283  /* Define SPI PAL over DSPI */
284  #if (defined(SPI_OVER_DSPI))
285  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
286  {
287  uint32_t inst = GetDspiIndex(instance);
288 
289  dspi_master_config_t dspiConfig;
290  dspiConfig.bitsPerSec = config->baudRate;
291  dspiConfig.bitcount = config->frameSize;
292  dspiConfig.clkPhase = (dspi_clock_phase_t)config->clockPhase;
293  dspiConfig.clkPolarity = (dspi_polarity_t)config->clockPolarity;
294  dspiConfig.isClkContinuous = false;
295  dspiConfig.lsbFirst = config->bitOrder;
296  /* If extended mode is not available DMA is not available in master mode */
297  #if(defined(FEATURE_DSPI_HAS_EXTENDED_MODE))
298  dspiConfig.transferType = (dspi_transfer_type_t)config->transferType;
299  #else
300  dspiConfig.transferType = DSPI_USING_INTERRUPTS;
301  #endif
302  dspiConfig.rxDMAChannel = config->rxDMAChannel;
303  dspiConfig.txDMAChannel = config->txDMAChannel;
304  dspiConfig.whichPCS = config->ssPin;
305  dspiConfig.pcsPolarity = (dspi_polarity_t)config->ssPolarity;
306  dspiConfig.callback = config->callback;
307  dspiConfig.callbackParam = config->callbackParam;
308  /* Allocate one of the DSPI state structure for this instance */
309  index = SpiAllocateState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
310  status = DSPI_MasterInit((dspi_instance_t)inst, (dspi_state_t*)&dspiState[index] ,&dspiConfig);
311  }
312  else
313  #endif
314  {
315  DEV_ASSERT(0);
316  }
317  return status;
318 }
319 
320 /*FUNCTION**********************************************************************
321  *
322  * Function Name : SPI_MasterTransfer
323  * Description : Initializes a non-blocking master transfer
324  * Implements : SPI_MasterTransfer_Activity
325  *
326  *END**************************************************************************/
327 status_t SPI_MasterTransfer(const spi_instance_t * const instance, const void* txBuffer, void* rxBuffer, uint16_t numberOfFrames)
328 {
329  status_t status = STATUS_ERROR;
330 
331  /* Define SPI PAL over LPSPI */
332  #if defined(SPI_OVER_LPSPI)
333  if (instance->instType == SPI_INST_TYPE_LPSPI)
334  {
335  status = LPSPI_DRV_MasterTransfer(instance->instIdx, txBuffer, rxBuffer, numberOfFrames);
336  }
337  else
338  #endif
339 
340  /* Define SPI PAL over FLEXIO */
341  #if defined(SPI_OVER_FLEXIO)
342  if (instance->instType == SPI_INST_TYPE_FLEXIO)
343  {
344  status = FLEXIO_SPI_DRV_MasterTransfer(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames);
345  }
346  else
347  #endif
348 
349  /* Define SPI PAL over DSPI */
350  #if (defined(SPI_OVER_DSPI))
351  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
352  {
353  uint32_t inst = GetDspiIndex(instance);
354 
355  status = DSPI_MasterTransfer((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames);
356  }
357  else
358  #endif
359  {
360  DEV_ASSERT(0);
361  }
362  return status;
363 }
364 
365 /*FUNCTION**********************************************************************
366  *
367  * Function Name : SPI_MasterTransferBlocking
368  * Description : Initializes a blocking master transfer with time-out
369  * Implements : SPI_MasterTransferBlocking_Activity
370  *
371  *END**************************************************************************/
372 status_t SPI_MasterTransferBlocking(const spi_instance_t * const instance, const void* txBuffer, void* rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
373 {
374  status_t status = STATUS_ERROR;
375 
376  /* Define SPI PAL over LPSPI */
377  #if defined(SPI_OVER_LPSPI)
378  if (instance->instType == SPI_INST_TYPE_LPSPI)
379  {
380  status = LPSPI_DRV_MasterTransferBlocking(instance->instIdx, txBuffer, rxBuffer, numberOfFrames, timeout);
381  }
382  else
383  #endif
384 
385  /* Define SPI PAL over FLEXIO */
386  #if defined(SPI_OVER_FLEXIO)
387  if (instance->instType == SPI_INST_TYPE_FLEXIO)
388  {
389  status = FLEXIO_SPI_DRV_MasterTransferBlocking(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames, timeout);
390  }
391  else
392  #endif
393 
394  /* Define SPI PAL over DSPI */
395  #if (defined(SPI_OVER_DSPI))
396  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
397  {
398  uint32_t inst = GetDspiIndex(instance);
399 
400  status = DSPI_MasterTransferBlocking((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames, timeout);
401  }
402  else
403  #endif
404  {
405  DEV_ASSERT(0);
406  }
407  return status;
408 }
409 
410 /*FUNCTION**********************************************************************
411  *
412  * Function Name : SPI_SlaveInit
413  * Description : Configures the SPI in slave mode
414  * Implements : SPI_SlaveInit_Activity
415  *
416  *END**************************************************************************/
417 status_t SPI_SlaveInit(const spi_instance_t * const instance, const spi_slave_t *config)
418 {
419  status_t status = STATUS_ERROR;
420  uint8_t index = 0;
421 
422  /* Define SPI PAL over LPSPI */
423  #if (defined (SPI_OVER_LPSPI))
424  if (instance->instType == SPI_INST_TYPE_LPSPI)
425  {
426  lpspi_slave_config_t lpspiConfig;
427  lpspiConfig.pcsPolarity = (lpspi_signal_polarity_t)(!(bool)(config->ssPolarity));
428  lpspiConfig.bitcount = config->frameSize;
429  lpspiConfig.clkPhase = (lpspi_clock_phase_t)config->clockPhase;
430  lpspiConfig.clkPolarity = (lpspi_sck_polarity_t)config->clockPolarity;
431  lpspiConfig.lsbFirst = config->bitOrder;
432  lpspiConfig.transferType = (lpspi_transfer_type)config->transferType;
433  lpspiConfig.rxDMAChannel = config->rxDMAChannel;
434  lpspiConfig.txDMAChannel = config->txDMAChannel;
435  lpspiConfig.callback = config->callback;
436  lpspiConfig.callbackParam = config->callbackParam;
437  lpspiConfig.whichPcs = (lpspi_which_pcs_t)0U;
438  /* Allocate one of the LPSPI state structure for this instance */
439  index = SpiAllocateState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
440  status = LPSPI_DRV_SlaveInit(instance->instIdx, (lpspi_state_t*)(&LpspiState[index]), &lpspiConfig);
441  }
442  else
443  #endif
444 
445  /* Define SPI PAL over FLEXIO */
446  #if (defined (SPI_OVER_FLEXIO))
447  if (instance->instType == SPI_INST_TYPE_FLEXIO)
448  {
449  /* FlexIO driver can be used only for the following frame sizes: 8,16 or 32 */
450  DEV_ASSERT((config->frameSize == 8U) || (config->frameSize == 16U) || (config->frameSize == 32U));
451  /* FlexIO driver can be used only when SS is active low */
452  DEV_ASSERT((config->ssPolarity) == SPI_ACTIVE_LOW);
453  flexio_spi_slave_user_config_t flexioConfig;
454  switch(config->transferType)
455  {
456  case SPI_USING_DMA: flexioConfig.driverType = FLEXIO_DRIVER_TYPE_DMA; break;
458  default : /*Nothing to do */ break;
459  }
460  flexioConfig.bitOrder = (flexio_spi_transfer_bit_order_t)config->bitOrder;
461  switch (config->frameSize)
462  {
463  case 8U : flexioConfig.transferSize = FLEXIO_SPI_TRANSFER_1BYTE; break;
464  case 16U : flexioConfig.transferSize = FLEXIO_SPI_TRANSFER_2BYTE; break;
465  case 32U : flexioConfig.transferSize = FLEXIO_SPI_TRANSFER_4BYTE; break;
466  default: /* Nothing to do */ break;
467  }
468  flexioConfig.clockPolarity = (uint8_t)config->clockPolarity;
469  flexioConfig.clockPhase = (uint8_t)config->clockPhase;
470  flexioConfig.mosiPin = ((extension_flexio_for_spi_t*)(config->extension))->mosiPin;
471  flexioConfig.misoPin = ((extension_flexio_for_spi_t*)(config->extension))->misoPin;
472  flexioConfig.sckPin = ((extension_flexio_for_spi_t*)(config->extension))->sckPin;
473  flexioConfig.ssPin = ((extension_flexio_for_spi_t*)(config->extension))->ssPin;
474  /* Link Flexio Callbacks to the callbacks defined in PAL */
475  flexioConfig.callback = config->callback;
476  /* Store the callbacks defined by the user in PAL internal callbacks vector */
477  flexioConfig.callbackParam = config->callbackParam;
478  flexioConfig.rxDMAChannel = config->rxDMAChannel;
479  flexioConfig.txDMAChannel = config->txDMAChannel;
480  status = FLEXIO_DRV_InitDevice(0U, &FlexioState);
481  if (status == STATUS_SUCCESS)
482  {
483  /* Allocate one of the Flexio state structure for this instance */
484  index = SpiAllocateState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
485  status = FLEXIO_SPI_DRV_SlaveInit(0U, &flexioConfig, (flexio_spi_master_state_t*)&FlexioSpiState[index]);
486  }
487  }
488  else
489  #endif
490 
491  /* Define SPI PAL over DSPI */
492  #if (defined(SPI_OVER_DSPI))
493  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
494  {
495  /* DSPI in slave mode works only in active low mode */
497  uint32_t inst = GetDspiIndex(instance);
498  dspi_slave_config_t dspiConfig;
499  dspiConfig.bitcount = config->frameSize;
500  dspiConfig.clkPhase = (dspi_clock_phase_t)config->clockPhase;
501  dspiConfig.clkPolarity = (dspi_polarity_t)config->clockPolarity;
502  dspiConfig.transferType = (dspi_transfer_type_t)config->transferType;
503  dspiConfig.rxDMAChannel = config->rxDMAChannel;
504  dspiConfig.txDMAChannel = config->txDMAChannel;
505  dspiConfig.callback = config->callback;
506  dspiConfig.callbackParam = config->callbackParam;
507  /* Allocate one of the DSPI state structure for this instance */
508  index = SpiAllocateState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
509  status = DSPI_SlaveInit((dspi_instance_t)inst, (dspi_state_t*)&dspiState[index] ,&dspiConfig);
510  }
511  else
512  #endif
513  {
514  DEV_ASSERT(0);
515  }
516  return status;
517 }
518 
519 /*FUNCTION**********************************************************************
520  *
521  * Function Name : SPI_SlaveTransfer
522  * Description : Initializes a non-blocking slave transfer
523  * Implements : SPI_SlaveTransfer_Activity
524  *
525  *END**************************************************************************/
526 status_t SPI_SlaveTransfer(const spi_instance_t * const instance, const void* txBuffer, void* rxBuffer, uint16_t numberOfFrames)
527 {
528  status_t status = STATUS_ERROR;
529 
530  /* Define SPI PAL over LPSPI */
531  #if defined(SPI_OVER_LPSPI)
532  if (instance->instType == SPI_INST_TYPE_LPSPI)
533  {
534  status = LPSPI_DRV_SlaveTransfer(instance->instIdx, txBuffer, rxBuffer, numberOfFrames);
535  }
536  else
537  #endif
538 
539  /* Define SPI PAL over FLEXIO */
540  #if defined(SPI_OVER_FLEXIO)
541  if (instance->instType == SPI_INST_TYPE_FLEXIO)
542  {
543  status = FLEXIO_SPI_DRV_SlaveTransfer(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames);
544  }
545  else
546  #endif
547 
548  /* Define SPI PAL over DSPI */
549  #if (defined(SPI_OVER_DSPI))
550  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
551  {
552  uint32_t inst = GetDspiIndex(instance);
553  status = DSPI_SlaveTransfer((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames);
554  }
555  else
556  #endif
557  {
558  DEV_ASSERT(0);
559  }
560  return status;
561 }
562 
563 /*FUNCTION**********************************************************************
564  *
565  * Function Name : SPI_SlaveTransferBlocking
566  * Description : Initializes a blocking slave transfer with timeout
567  * Implements : SPI_SlaveTransferBlocking_Activity
568  *
569  *END**************************************************************************/
570 status_t SPI_SlaveTransferBlocking(const spi_instance_t * const instance, const void* txBuffer, void* rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
571 {
572  status_t status = STATUS_ERROR;
573 
574  /* Define SPI PAL over LPSPI */
575  #if defined(SPI_OVER_LPSPI)
576  if (instance->instType == SPI_INST_TYPE_LPSPI)
577  {
578  status = LPSPI_DRV_SlaveTransferBlocking(instance->instIdx, txBuffer, rxBuffer, numberOfFrames, timeout);
579  }
580  else
581  #endif
582 
583  /* Define SPI PAL over FLEXIO */
584  #if defined(SPI_OVER_FLEXIO)
585  if (instance->instType == SPI_INST_TYPE_FLEXIO)
586  {
587  status = FLEXIO_SPI_DRV_SlaveTransferBlocking(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames, timeout);
588  }
589  #endif
590 
591  /* Define SPI PAL over DSPI */
592  #if (defined(SPI_OVER_DSPI))
593  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
594  {
595  uint32_t inst = GetDspiIndex(instance);
596  status = DSPI_SlaveTransferBlocking((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames, timeout);
597  }
598  else
599  #endif
600  {
601  DEV_ASSERT(0);
602  }
603  return status;
604 }
605 
606 /*FUNCTION**********************************************************************
607  *
608  * Function Name : SPI_GetDefaultMasterConfig
609  * Description : Gets the default configuration structure for master
610  * Implements : SPI_GetDefaultMasterConfig_Activity
611  *
612  *END**************************************************************************/
614 {
615  config->baudRate = 100000U;
616  config->ssPolarity = SPI_ACTIVE_HIGH;
617  config->frameSize = 8U;
618  config->clockPhase = READ_ON_ODD_EDGE;
619  config->clockPolarity = SPI_ACTIVE_HIGH;
622  config->rxDMAChannel = 255U;
623  config->txDMAChannel = 255U;
624  config->callback = NULL;
625  config->callbackParam = NULL;
626  config->ssPin = 0;
627  config->extension = NULL;
628  return STATUS_SUCCESS;
629 }
630 
631 /*FUNCTION**********************************************************************
632  *
633  * Function Name : SPI_GetDefaultSlaveConfig
634  * Description : Gets the default configuration structure for slave
635  * Implements : SPI_GetDefaultSlaveConfig_Activity
636  *
637  *END**************************************************************************/
639 {
640  config->ssPolarity = SPI_ACTIVE_HIGH;
641  config->frameSize = 8U;
642  config->clockPhase = READ_ON_ODD_EDGE;
643  config->clockPolarity = SPI_ACTIVE_HIGH;
646  config->rxDMAChannel = 255U;
647  config->txDMAChannel = 255U;
648  config->callback = NULL;
649  config->callbackParam = NULL;
650  config->extension = NULL;
651  return STATUS_SUCCESS;
652 }
653 
654 /*FUNCTION**********************************************************************
655  *
656  * Function Name : SPI_MasterDeinit
657  * Description : De-initializes the spi master module
658  * Implements : SPI_MasterDeinit_Activity
659  *
660  *END**************************************************************************/
661 status_t SPI_MasterDeinit(const spi_instance_t * const instance)
662 {
663  status_t status = STATUS_ERROR;
664 
665  /* Define SPI PAL over LPSPI */
666  #if defined(SPI_OVER_LPSPI)
667  if (instance->instType == SPI_INST_TYPE_LPSPI)
668  {
669  status = LPSPI_DRV_MasterDeinit(instance->instIdx);
670  if (status == STATUS_SUCCESS)
671  {
672  SpiFreeState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
673  }
674  }
675  else
676  #endif
677 
678  /* Define SPI PAL over FLEXIO */
679  #if defined(SPI_OVER_FLEXIO)
680  if (instance->instType == SPI_INST_TYPE_FLEXIO)
681  {
682  status = FLEXIO_SPI_DRV_MasterDeinit(&(FlexioSpiState[FindFlexioState(instance)]));
683  if (status == STATUS_SUCCESS)
684  {
685  SpiFreeState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
686  }
687  }
688  else
689  #endif
690 
691  /* Define SPI PAL over DSPI */
692  #if (defined(SPI_OVER_DSPI))
693  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
694  {
695  uint32_t inst = GetDspiIndex(instance);
696  status = DSPI_Deinit((dspi_instance_t)inst);
697  if (status == STATUS_SUCCESS)
698  {
699  SpiFreeState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
700  }
701  }
702  else
703  #endif
704  {
705  DEV_ASSERT(0);
706  }
707  return status;
708 }
709 
710 /*FUNCTION**********************************************************************
711  *
712  * Function Name : SPI_SlaveDeinit
713  * Description : De-initializes the spi slave module
714  * Implements : SPI_SlaveDeinit_Activity
715  *
716  *END**************************************************************************/
717 status_t SPI_SlaveDeinit(const spi_instance_t * const instance)
718 {
719  status_t status = STATUS_ERROR;
720 
721  /* Define SPI PAL over LPSPI */
722  #if defined(SPI_OVER_LPSPI)
723  if (instance->instType == SPI_INST_TYPE_LPSPI)
724  {
725  status = LPSPI_DRV_SlaveDeinit(instance->instIdx);
726  if (status == STATUS_SUCCESS)
727  {
728  SpiFreeState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
729  }
730  }
731  else
732  #endif
733 
734  /* Define SPI PAL over FLEXIO */
735  #if defined(SPI_OVER_FLEXIO)
736  if (instance->instType == SPI_INST_TYPE_FLEXIO)
737  {
738  status = FLEXIO_SPI_DRV_SlaveDeinit(&(FlexioSpiState[FindFlexioState(instance)]));
739  if (status == STATUS_SUCCESS)
740  {
741  SpiFreeState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
742  }
743  }
744  else
745  #endif
746 
747  /* Define SPI PAL over DSPI */
748  #if (defined(SPI_OVER_DSPI))
749  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
750  {
751  uint32_t inst = GetDspiIndex(instance);
752  status = DSPI_Deinit((dspi_instance_t)inst);
753  if (status == STATUS_SUCCESS)
754  {
755  SpiFreeState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
756  }
757  }
758  else
759  #endif
760  {
761  DEV_ASSERT(0);
762  }
763  return status;
764 }
765 
766 /*FUNCTION**********************************************************************
767  *
768  * Function Name : SPI_SetSS
769  * Description : Changes the SS, if this feature is available.
770  * Implements : SPI_SetSS_Activity
771  *
772  *END**************************************************************************/
773 status_t SPI_SetSS(const spi_instance_t * const instance, uint8_t ss)
774 {
775  status_t status = STATUS_ERROR;
776 
777  /* Define SPI PAL over LPSPI */
778  #if defined(SPI_OVER_LPSPI)
779  if (instance->instType == SPI_INST_TYPE_LPSPI)
780  {
782  }
783  else
784  #endif
785 
786  /* Define SPI PAL over FLEXIO */
787  #if defined(SPI_OVER_FLEXIO)
788  if (instance->instType == SPI_INST_TYPE_FLEXIO)
789  {
790  (void)ss;
791  status = STATUS_UNSUPPORTED;
792  }
793  else
794  #endif
795 
796  /* Define SPI PAL over DSPI */
797  #if (defined(SPI_OVER_DSPI))
798  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
799  {
800  uint32_t inst = GetDspiIndex(instance);
801  status = DSPI_UpdateCS((dspi_instance_t)inst, ss);
802  }
803  else
804  #endif
805  {
806  DEV_ASSERT(0);
807  }
808  return status;
809 }
810 
811 
812 /*FUNCTION**********************************************************************
813  *
814  * Function Name : SPI_GetStatus
815  * Description : Gets the status of the last transfer
816  * Implements : SPI_GetStatus_Activity
817  *
818  *END**************************************************************************/
819 status_t SPI_GetStatus(const spi_instance_t * const instance)
820 {
821  status_t status = STATUS_ERROR;
822 
823  /* Define SPI PAL over LPSPI */
824  #if defined(SPI_OVER_LPSPI)
825  if (instance->instType == SPI_INST_TYPE_LPSPI)
826  {
827  uint8_t i;
828  /* Find the state structure associated to current instance */
829  for (i = 0; i < NO_OF_LPSPI_INSTS_FOR_SPI; i++)
830  {
831  if (LpspiStateInstanceMapping[i] == instance->instIdx)
832  {
833  return (status_t)(LpspiState[i].isTransferInProgress ? STATUS_BUSY : STATUS_SUCCESS);
834  }
835  }
836  }
837  else
838  #endif
839 
840  /* Define SPI PAL over FLEXIO */
841  #if defined(SPI_OVER_FLEXIO)
842  if (instance->instType == SPI_INST_TYPE_FLEXIO)
843  {
844  if(STATUS_SUCCESS == FLEXIO_SPI_DRV_MasterGetStatus(&FlexioSpiState[FindFlexioState(instance)], NULL))
845  {
846  status = STATUS_SUCCESS;
847  }
848  else
849  {
850  status= STATUS_BUSY;
851  }
852  }
853  else
854  #endif
855 
856  /* Define SPI PAL over DSPI */
857  #if (defined(SPI_OVER_DSPI))
858  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
859  {
860  dspi_transfer_status_t dspiStatus;
861  uint32_t inst = GetDspiIndex(instance);
862  (void)DSPI_GetTransferStatus((dspi_instance_t)inst, &dspiStatus);
863  if (dspiStatus == DSPI_TRANSFER_OK)
864  {
865  status = STATUS_SUCCESS;
866  }
867  else
868  {
869  status= STATUS_BUSY;
870  }
871  }
872  else
873  #endif
874  {
875  DEV_ASSERT(0);
876  }
877  return status;
878 }
879 
880 /*FUNCTION**********************************************************************
881  *
882  * Function Name : DSPI_MasterSetDelay
883  * Description : Gets the status of the last transfer
884  * Implements : DSPI_MasterSetDelay_Activity
885  *
886  *END**************************************************************************/
887 status_t SPI_MasterSetDelay(const spi_instance_t * const instance, uint32_t delayBetweenTransfers,
888  uint32_t delaySCKtoPCS, uint32_t delayPCStoSCK)
889 {
890  status_t status = STATUS_ERROR;
891 
892  /* Define SPI PAL over LPSPI */
893  #if defined(SPI_OVER_LPSPI)
894  if (instance->instType == SPI_INST_TYPE_LPSPI)
895  {
896  status = LPSPI_DRV_MasterSetDelay(instance->instIdx, delayBetweenTransfers, delaySCKtoPCS, delayPCStoSCK);
897  }
898  else
899  #endif
900 
901  /* Define SPI PAL over FLEXIO */
902  #if defined(SPI_OVER_FLEXIO)
903  if (instance->instType == SPI_INST_TYPE_FLEXIO)
904  {
905  status = STATUS_UNSUPPORTED;
906  }
907  else
908  #endif
909 
910  /* Define SPI PAL over DSPI */
911  #if (defined(SPI_OVER_DSPI))
912  if ((instance->instType == SPI_INST_TYPE_SPI) || (instance->instType == SPI_INST_TYPE_DSPI))
913  {
914  uint32_t inst = GetDspiIndex(instance);
915  status = DSPI_MasterSetDelay((dspi_instance_t)inst, delayBetweenTransfers, delaySCKtoPCS, delayPCStoSCK);
916  }
917  else
918  #endif
919  {
920  DEV_ASSERT(0);
921  }
922  return status;
923 }
924 
925 /*******************************************************************************
926  * EOF
927  ******************************************************************************/
spi_callback_t callback
Definition: spi_pal.h:96
spi_clock_phase_t clockPhase
Definition: spi_pal.h:91
#define LPSPI_INSTANCE_COUNT
Definition: S32K118.h:6049
uint8_t rxDMAChannel
Definition: spi_pal.h:94
status_t SPI_SlaveTransferBlocking(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
Initializes a blocking slave transfer.
Definition: spi_pal.c:570
Runtime state structure for the LPSPI master driver.
Data structure containing information about a device on the SPI bus.
flexio_spi_transfer_size_t transferSize
spi_polarity_t clockPolarity
Definition: spi_pal.h:89
lpspi_signal_polarity_t pcsPolarity
status_t FLEXIO_SPI_DRV_MasterTransferBlocking(flexio_spi_master_state_t *master, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize, uint32_t timeout)
Perform a blocking SPI master transaction.
status_t SPI_SetSS(const spi_instance_t *const instance, uint8_t ss)
Update the SS.
Definition: spi_pal.c:773
status_t LPSPI_DRV_SetPcs(uint32_t instance, lpspi_which_pcs_t whichPcs, lpspi_signal_polarity_t polarity)
Select the chip to communicate with.
status_t SPI_SlaveTransfer(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames)
Initializes a non-blocking slave transfer.
Definition: spi_pal.c:526
void * callbackParam
Definition: spi_pal.h:97
status_t LPSPI_DRV_MasterDeinit(uint32_t instance)
Shuts down a LPSPI instance.
lpspi_transfer_type transferType
lpspi_signal_polarity_t pcsPolarity
status_t FLEXIO_SPI_DRV_MasterTransfer(flexio_spi_master_state_t *master, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize)
Perform a non-blocking SPI master transaction.
flexio_spi_transfer_bit_order_t
Order in which the data bits are transferred Implements : flexio_spi_transfer_bit_order_t_Class.
uint8_t rxDMAChannel
Definition: spi_pal.h:113
flexio_spi_transfer_bit_order_t bitOrder
status_t LPSPI_DRV_MasterInit(uint32_t instance, lpspi_state_t *lpspiState, const lpspi_master_config_t *spiConfig)
Initializes a LPSPI instance for interrupt driven master mode operation.
status_t LPSPI_DRV_MasterTransfer(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount)
Performs an interrupt driven non-blocking SPI master mode transfer.
lpspi_which_pcs_t whichPcs
void * callbackParam
Definition: spi_pal.h:116
uint8_t frameSize
Definition: spi_pal.h:87
status_t LPSPI_DRV_SlaveTransfer(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount)
Starts the transfer data on LPSPI bus using a non-blocking call.
uint32_t baudRate
Definition: spi_pal.h:86
status_t SPI_GetDefaultMasterConfig(spi_master_t *config)
Gets the default configuration structure for master.
Definition: spi_pal.c:613
lpspi_clock_phase_t clkPhase
#define DEV_ASSERT(x)
Definition: devassert.h:77
status_t FLEXIO_SPI_DRV_MasterGetStatus(flexio_spi_master_state_t *master, uint32_t *bytesRemaining)
Get the status of the current non-blocking SPI master transaction.
Slave configuration structure.
static status_t FLEXIO_SPI_DRV_SlaveTransfer(flexio_spi_slave_state_t *slave, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize)
Perform a non-blocking SPI slave transaction.
uint8_t txDMAChannel
Definition: spi_pal.h:95
flexio_driver_type_t driverType
status_t LPSPI_DRV_SlaveTransferBlocking(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount, uint32_t timeout)
Transfers data on LPSPI bus using a blocking call.
lpspi_clock_phase_t clkPhase
status_t CLOCK_SYS_GetFreq(clock_names_t clockName, uint32_t *frequency)
Gets the clock frequency for a specific clock name.
spi_clock_phase_t clockPhase
Definition: spi_pal.h:111
status_t LPSPI_DRV_MasterTransferBlocking(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount, uint32_t timeout)
Performs an interrupt driven blocking SPI master mode transfer.
lpspi_sck_polarity_t clkPolarity
flexio_spi_transfer_size_t transferSize
status_t LPSPI_DRV_MasterSetDelay(uint32_t instance, uint32_t delayBetwenTransfers, uint32_t delaySCKtoPCS, uint32_t delayPCStoSCK)
Configures the LPSPI master mode bus timing delay options.
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:44
spi_transfer_bit_order_t bitOrder
Definition: spi_pal.h:108
lpspi_signal_polarity_t
LPSPI Signal (PCS and Host Request) Polarity configuration. Implements : lpspi_signal_polarity_t_Clas...
Master configuration structure.
lpspi_transfer_type
Type of LPSPI transfer (based on interrupts or DMA). Implements : lpspi_transfer_type_Class.
static status_t FLEXIO_SPI_DRV_SlaveTransferBlocking(flexio_spi_slave_state_t *slave, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize, uint32_t timeout)
Perform a blocking SPI slave transaction.
status_t LPSPI_DRV_SlaveInit(uint32_t instance, lpspi_state_t *lpspiState, const lpspi_slave_config_t *slaveConfig)
Initializes a LPSPI instance for a slave mode operation, using interrupt mechanism.
lpspi_which_pcs_t
LPSPI Peripheral Chip Select (PCS) configuration (which PCS to configure). Implements : lpspi_which_p...
uint8_t ssPin
Definition: spi_pal.h:92
spi_polarity_t clockPolarity
Definition: spi_pal.h:109
Defines the configuration structure for SPI slave Implements: spi_slave_t_Class.
Definition: spi_pal.h:105
uint8_t frameSize
Definition: spi_pal.h:107
status_t SPI_GetStatus(const spi_instance_t *const instance)
Gets the status of the last transfer.
Definition: spi_pal.c:819
status_t FLEXIO_SPI_DRV_SlaveInit(uint32_t instance, const flexio_spi_slave_user_config_t *userConfigPtr, flexio_spi_slave_state_t *slave)
Initialize the FLEXIO_SPI slave mode driver.
#define FEATURE_LPSPI_CLOCKS_NAMES
User configuration structure for the SPI slave driver. Implements : lpspi_slave_config_t_Class.
lpspi_clock_phase_t
LPSPI clock phase configuration. Implements : lpspi_clock_phase_t_Class.
void * extension
Definition: spi_pal.h:98
flexio_spi_transfer_bit_order_t bitOrder
uint8_t txDMAChannel
Definition: spi_pal.h:114
spi_transfer_type_t transferType
Definition: spi_pal.h:112
spi_transfer_bit_order_t bitOrder
Definition: spi_pal.h:88
Defines the configuration structure for SPI master Implements : spi_master_t_Class.
Definition: spi_pal.h:84
lpspi_sck_polarity_t
LPSPI Clock Signal (SCK) Polarity configuration. Implements : lpspi_sck_polarity_t_Class.
status_t SPI_MasterDeinit(const spi_instance_t *const instance)
De-initializes the spi master module.
Definition: spi_pal.c:661
static void SpiFreeState(bool *isAllocated, const uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfinstances)
Definition: spi_pal.c:141
spi_polarity_t ssPolarity
Definition: spi_pal.h:90
lpspi_which_pcs_t whichPcs
Structure storing PAL instance information.
void * extension
Definition: spi_pal.h:117
volatile bool isTransferInProgress
static status_t FLEXIO_SPI_DRV_SlaveDeinit(flexio_spi_slave_state_t *slave)
De-initialize the FLEXIO_SPI slave mode driver.
status_t SPI_GetDefaultSlaveConfig(spi_slave_t *config)
Gets the default configuration structure for slave.
Definition: spi_pal.c:638
status_t FLEXIO_SPI_DRV_MasterInit(uint32_t instance, const flexio_spi_master_user_config_t *userConfigPtr, flexio_spi_master_state_t *master)
Initialize the FLEXIO_SPI master mode driver.
status_t SPI_MasterInit(const spi_instance_t *const instance, const spi_master_t *config)
Initializes the SPI module in master mode.
Definition: spi_pal.c:205
status_t SPI_MasterTransfer(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames)
Initializes a non-blocking master transfer.
Definition: spi_pal.c:327
status_t FLEXIO_SPI_DRV_MasterDeinit(flexio_spi_master_state_t *master)
De-initialize the FLEXIO_SPI master mode driver.
lpspi_transfer_type transferType
spi_polarity_t ssPolarity
Definition: spi_pal.h:110
status_t LPSPI_DRV_SlaveDeinit(uint32_t instance)
Shuts down an LPSPI instance interrupt mechanism.
status_t SPI_MasterSetDelay(const spi_instance_t *const instance, uint32_t delayBetweenTransfers, uint32_t delaySCKtoPCS, uint32_t delayPCStoSCK)
Configures the SPI_PAL master mode bus timing delay options.
Definition: spi_pal.c:887
status_t SPI_SlaveInit(const spi_instance_t *const instance, const spi_slave_t *config)
Initializes the SPI module in slave mode.
Definition: spi_pal.c:417
lpspi_sck_polarity_t clkPolarity
Master internal context structure.
clock_names_t
Clock names.
spi_callback_t callback
Definition: spi_pal.h:115
spi_inst_type_t instType
status_t SPI_MasterTransferBlocking(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
Initializes a blocking master transfer.
Definition: spi_pal.c:372
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
Definition: flexio_common.c:89
spi_transfer_type_t transferType
Definition: spi_pal.h:93
status_t SPI_SlaveDeinit(const spi_instance_t *const instance)
De-initializes the spi slave module.
Definition: spi_pal.c:717
static uint8_t SpiAllocateState(bool *isAllocated, uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfinstances)
Definition: spi_pal.c:119