S32 SDK
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 
18 #include "spi_pal.h"
19 #include "device_registers.h"
20 
21 /* Include PD files */
22 #if (defined (SPI_OVER_LPSPI))
23  #include "lpspi_master_driver.h"
24  #include "lpspi_slave_driver.h"
25 #endif
26 
27 #if (defined (SPI_OVER_FLEXIO))
28  #include "flexio.h"
29  #include "flexio_spi_driver.h"
30 #endif
31 
32 #if (defined (SPI_OVER_DSPI))
33  #include "dspi_driver.h"
34 #endif
35 
36 
37 /* Define state structures for LPSPI */
38 #if (defined(SPI_OVER_LPSPI))
39 
40  lpspi_state_t LpspiState[NO_OF_LPSPI_INSTS_FOR_SPI];
42  static spi_instance_t LpspiStateInstanceMapping[NO_OF_LPSPI_INSTS_FOR_SPI];
44  static bool LpspiStateIsAllocated[NO_OF_LPSPI_INSTS_FOR_SPI];
45 #endif
46 
47 /* Define state structures for SPI over FLEXIO */
48 #if (defined(SPI_OVER_FLEXIO))
49 
50  flexio_spi_master_state_t FlexioSpiState[NO_OF_FLEXIO_INSTS_FOR_SPI];
51  flexio_device_state_t FlexioState;
53  static spi_instance_t FlexioSpiStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_SPI];
55  static bool FlexioSpiStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_SPI];
56 #endif
57 
58 /* Define state structures for DSPI */
59 #if (defined(SPI_OVER_DSPI))
60 
61  dspi_state_t dspiState[NO_OF_DSPI_INSTS_FOR_SPI];
63  static spi_instance_t DspiStateInstanceMapping[NO_OF_DSPI_INSTS_FOR_SPI];
65  static bool DspiStateIsAllocated[NO_OF_DSPI_INSTS_FOR_SPI];
66 #endif
67 
68 /*FUNCTION**********************************************************************
69  *
70  * Function Name : SpiAllocateState
71  * Description : Allocates one of the available state structure.
72  *
73  *END**************************************************************************/
74 static uint8_t SpiAllocateState(bool* isAllocated, spi_instance_t* instanceMapping, spi_instance_t instance, uint8_t numberOfinstances)
75 {
76  uint8_t i;
77  /* Allocate one of the LPSPI state structure for this instance */
78  for (i = 0;i < numberOfinstances;i++)
79  {
80  if (isAllocated[i] == false)
81  {
82  instanceMapping[i] = instance;
83  isAllocated[i] = true;
84  break;
85  }
86  }
87  return i;
88 }
89 
90 /*FUNCTION**********************************************************************
91  *
92  * Function Name : SpiFreeState
93  * Description : Deallocates one of the available state structure.
94  *
95  *END**************************************************************************/
96 static void SpiFreeState(bool* isAllocated, spi_instance_t* instanceMapping, spi_instance_t instance, uint8_t numberOfinstances)
97 {
98  uint8_t i;
99  /* Allocate one of the LPSPI state structure for this instance */
100  for (i = 0;i < numberOfinstances;i++)
101  {
102  if (instanceMapping[i] == instance)
103  {
104  isAllocated[i] = false;
105  break;
106  }
107  }
108 }
109 
110 #if (defined(SPI_OVER_FLEXIO))
111 /*FUNCTION**********************************************************************
112  *
113  * Function Name : FindFlexioState
114  * Description : Search the state structure of the flexio instance
115  *
116  *END**************************************************************************/
117 static uint8_t FindFlexioState(spi_instance_t instance)
118 {
119  uint8_t i;
120  for (i = 0;i<NO_OF_FLEXIO_INSTS_FOR_SPI;i++)
121  {
122  if (FlexioSpiStateInstanceMapping[i] == instance)
123  {
124  break;
125  }
126  }
127  return i;
128 }
129 #endif
130 
131 /*FUNCTION**********************************************************************
132  *
133  * Function Name : SPI_MasterInit
134  * Description : Configures the SPI in master mode
135  *
136  *END**************************************************************************/
138 {
139  status_t status = STATUS_SUCCESS;
140  uint8_t index = 0;
141 
142  /* Define SPI PAL over LPSPI */
143  #if (defined (SPI_OVER_LPSPI))
144  if (instance <= LPSPI_HIGH_INDEX)
145  {
146  lpspi_master_config_t lpspiConfig;
147  lpspiConfig.bitsPerSec = config->baudRate;
148  lpspiConfig.whichPcs = (lpspi_which_pcs_t)config->ssPin;
149  lpspiConfig.pcsPolarity = (lpspi_signal_polarity_t)config->ssPolarity;
150  lpspiConfig.bitcount = config->frameSize;
151  CLOCK_SYS_GetFreq((clock_names_t)((uint32_t)PCC_LPSPI0_CLOCK + instance) ,&lpspiConfig.lpspiSrcClk);
152  lpspiConfig.clkPhase = (lpspi_clock_phase_t)config->clockPhase;
153  lpspiConfig.clkPolarity = (lpspi_sck_polarity_t)config->clockPolarity;
154  lpspiConfig.lsbFirst = config->bitOrder;
155  lpspiConfig.transferType = (lpspi_transfer_type)config->transferType;
156  lpspiConfig.rxDMAChannel = config->rxDMAChannel;
157  lpspiConfig.txDMAChannel = config->txDMAChannel;
158  lpspiConfig.callback = config->callback;
159  lpspiConfig.callbackParam = config->callbackParam;
160  lpspiConfig.isPcsContinuous = false;
161  /* Allocate one of the LPSPI state structure for this instance */
162  index = SpiAllocateState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance, NO_OF_LPSPI_INSTS_FOR_SPI);
163  status = LPSPI_DRV_MasterInit(instance, (lpspi_state_t*)(&LpspiState[index]), &lpspiConfig);
164  }
165  #endif
166 
167  /* Define SPI PAL over FLEXIO */
168  #if (defined (SPI_OVER_FLEXIO))
169  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
170  {
171  /* FlexIO driver can be used only for the following frame sizes: 8,16 or 32 */
172  DEV_ASSERT((config->frameSize==8) || (config->frameSize==16) || (config->frameSize==32));
173  flexio_spi_master_user_config_t flexioConfig;
174  flexioConfig.baudRate = config->baudRate;
175  switch(config->transferType)
176  {
177  case SPI_USING_DMA: flexioConfig.driverType = FLEXIO_DRIVER_TYPE_DMA; break;
179  }
180  flexioConfig.bitOrder = (flexio_spi_transfer_bit_order_t)config->bitOrder;
181  flexioConfig.transferSize = (flexio_spi_transfer_size_t)(config->frameSize>>3U);
182  flexioConfig.clockPolarity = (uint8_t)config->clockPolarity;
183  flexioConfig.clockPhase = (uint8_t)config->clockPhase;
184  flexioConfig.mosiPin = ((extension_flexio_for_spi_t*)(config->extension))->mosiPin;
185  flexioConfig.misoPin = ((extension_flexio_for_spi_t*)(config->extension))->misoPin;
186  flexioConfig.sckPin = ((extension_flexio_for_spi_t*)(config->extension))->sckPin;
187  flexioConfig.ssPin = ((extension_flexio_for_spi_t*)(config->extension))->ssPin;
188  /* Link Flexio Callbacks to the callbacks defined in PAL */
189  flexioConfig.callback = config->callback;
190  /* Store the callbacks defined by the user in PAL internal callbacks vector */
191  flexioConfig.callbackParam = config->callbackParam;
192  flexioConfig.rxDMAChannel = config->rxDMAChannel;
193  flexioConfig.txDMAChannel = config->txDMAChannel;
194  status = FLEXIO_DRV_InitDevice(0U, &FlexioState);
195  if (status == STATUS_SUCCESS)
196  {
197  /* Allocate one of the Flexio state structure for this instance */
198  index = SpiAllocateState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_SPI);
199  status = FLEXIO_SPI_DRV_MasterInit(0U, &flexioConfig, (flexio_spi_master_state_t*)&FlexioSpiState[index]);
200  }
201  }
202  #endif
203 
204  /* Define SPI PAL over DSPI */
205  #if (defined (SPI_OVER_DSPI))
206  dspi_master_config_t dspiConfig;
207  dspiConfig.bitsPerSec = config->baudRate;
208  dspiConfig.bitcount = config->frameSize;
209  dspiConfig.clkPhase = (dspi_clock_phase_t)config->clockPhase;
210  dspiConfig.clkPolarity = (dspi_polarity_t)config->clockPolarity;
211  dspiConfig.isClkContinuous = false;
212  dspiConfig.lsbFirst = config->bitOrder;
213  dspiConfig.transferType = (dspi_transfer_type_t)config->transferType;
214  dspiConfig.rxDMAChannel = config->rxDMAChannel;
215  dspiConfig.txDMAChannel = config->txDMAChannel;
216  dspiConfig.whichPCS = config->ssPin;
217  dspiConfig.pcsPolarity = (dspi_polarity_t)config->ssPolarity;
218  dspiConfig.callback = config->callback;
219  dspiConfig.callbackParam = config->callbackParam;
220  /* Allocate one of the DSPI state structure for this instance */
221  index = SpiAllocateState(DspiStateIsAllocated, DspiStateInstanceMapping, instance, NO_OF_DSPI_INSTS_FOR_SPI);
222  status = DSPI_MasterInit((dspi_instance_t)instance, (dspi_state_t*)&dspiState[index] ,&dspiConfig);
223  #endif
224  return status;
225 }
226 
227 /*FUNCTION**********************************************************************
228  *
229  * Function Name : SPI_MasterTransfer
230  * Description : Initializes a non-blocking master transfer
231  *
232  *END**************************************************************************/
233 status_t SPI_MasterTransfer(spi_instance_t instance, void* txBuffer, void* rxBuffer, uint16_t numberOfFrames)
234 {
235  status_t status = STATUS_SUCCESS;
236 
237  /* Define SPI PAL over LPSPI */
238  #if defined(SPI_OVER_LPSPI)
239  if (instance <= LPSPI_HIGH_INDEX)
240  {
241  status = LPSPI_DRV_MasterTransfer((uint32_t)instance, txBuffer, rxBuffer, numberOfFrames);
242  }
243  #endif
244 
245  /* Define SPI PAL over FLEXIO */
246  #if defined(SPI_OVER_FLEXIO)
247  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
248  {
249  status = FLEXIO_SPI_DRV_MasterTransfer(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames);
250  }
251  #endif
252 
253  /* Define SPI PAL over DSPI */
254  #if (defined(SPI_OVER_DSPI))
255  status = DSPI_MasterTransfer((dspi_instance_t)instance, txBuffer, rxBuffer, numberOfFrames);
256  #endif
257  return status;
258 }
259 
260 /*FUNCTION**********************************************************************
261  *
262  * Function Name : SPI_MasterTransferBlocking
263  * Description : Initializes a blocking master transfer with time-out
264  *
265  *END**************************************************************************/
266 status_t SPI_MasterTransferBlocking(spi_instance_t instance, void* txBuffer, void* rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
267 {
268  status_t status = STATUS_SUCCESS;
269 
270  /* Define SPI PAL over LPSPI */
271  #if defined(SPI_OVER_LPSPI)
272  if (instance <= LPSPI_HIGH_INDEX)
273  {
274  status = LPSPI_DRV_MasterTransferBlocking((uint32_t)instance, txBuffer, rxBuffer, numberOfFrames, timeout);
275  }
276  #endif
277 
278  /* Define SPI PAL over FLEXIO */
279  #if defined(SPI_OVER_FLEXIO)
280  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
281  {
282  status = FLEXIO_SPI_DRV_MasterTransferBlocking(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames, timeout);
283  }
284  #endif
285 
286  /* Define SPI PAL over DSPI */
287  #if (defined(SPI_OVER_DSPI))
288  status = DSPI_MasterTransferBlocking((dspi_instance_t)instance, txBuffer, rxBuffer, numberOfFrames, timeout);
289  #endif
290  return status;
291 }
292 
293 /*FUNCTION**********************************************************************
294  *
295  * Function Name : SPI_SlaveInit
296  * Description : Configures the SPI in slave mode
297  *
298  *END**************************************************************************/
300 {
301  status_t status = STATUS_SUCCESS;
302  uint8_t index = 0;
303 
304  /* Define SPI PAL over LPSPI */
305  #if (defined (SPI_OVER_LPSPI))
306  if (instance <= LPSPI_HIGH_INDEX)
307  {
308  lpspi_slave_config_t lpspiConfig;
309  lpspiConfig.pcsPolarity = (lpspi_signal_polarity_t)config->ssPolarity;
310  lpspiConfig.bitcount = config->frameSize;
311  lpspiConfig.clkPhase = (lpspi_clock_phase_t)config->clockPhase;
312  lpspiConfig.clkPolarity = (lpspi_sck_polarity_t)config->clockPolarity;
313  lpspiConfig.lsbFirst = config->bitOrder;
314  lpspiConfig.transferType = (lpspi_transfer_type)config->transferType;
315  lpspiConfig.rxDMAChannel = config->rxDMAChannel;
316  lpspiConfig.txDMAChannel = config->txDMAChannel;
317  lpspiConfig.callback = config->callback;
318  lpspiConfig.callbackParam = config->callbackParam;
319  lpspiConfig.whichPcs = (lpspi_which_pcs_t)0U;
320  /* Allocate one of the LPSPI state structure for this instance */
321  index = SpiAllocateState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance, NO_OF_LPSPI_INSTS_FOR_SPI);
322  status = LPSPI_DRV_SlaveInit(instance, (lpspi_state_t*)(&LpspiState[index]), &lpspiConfig);
323  }
324  #endif
325 
326  /* Define SPI PAL over FLEXIO */
327  #if (defined (SPI_OVER_FLEXIO))
328  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
329  {
330  /* FlexIO driver can be used only for the following frame sizes: 8,16 or 32 */
331  DEV_ASSERT((config->frameSize==8) || (config->frameSize==16) || (config->frameSize==32));
332  flexio_spi_slave_user_config_t flexioConfig;
333  switch(config->transferType)
334  {
335  case SPI_USING_DMA: flexioConfig.driverType = FLEXIO_DRIVER_TYPE_DMA; break;
337  }
338  flexioConfig.bitOrder = (flexio_spi_transfer_bit_order_t)config->bitOrder;
339  flexioConfig.transferSize = (flexio_spi_transfer_size_t)(config->frameSize>>3U);
340  flexioConfig.clockPolarity = (uint8_t)config->clockPolarity;
341  flexioConfig.clockPhase = (uint8_t)config->clockPhase;
342  flexioConfig.mosiPin = ((extension_flexio_for_spi_t*)(config->extension))->mosiPin;
343  flexioConfig.misoPin = ((extension_flexio_for_spi_t*)(config->extension))->misoPin;
344  flexioConfig.sckPin = ((extension_flexio_for_spi_t*)(config->extension))->sckPin;
345  flexioConfig.ssPin = ((extension_flexio_for_spi_t*)(config->extension))->ssPin;
346  /* Link Flexio Callbacks to the callbacks defined in PAL */
347  flexioConfig.callback = config->callback;
348  /* Store the callbacks defined by the user in PAL internal callbacks vector */
349  flexioConfig.callbackParam = config->callbackParam;
350  flexioConfig.rxDMAChannel = config->rxDMAChannel;
351  flexioConfig.txDMAChannel = config->txDMAChannel;
352  status = FLEXIO_DRV_InitDevice(0U, &FlexioState);
353  if (status == STATUS_SUCCESS)
354  {
355  /* Allocate one of the Flexio state structure for this instance */
356  index = SpiAllocateState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_SPI);
357  status = FLEXIO_SPI_DRV_SlaveInit(0U, &flexioConfig, (flexio_spi_master_state_t*)&FlexioSpiState[index]);
358  }
359  }
360  #endif
361 
362  /* Define SPI PAL over DSPI */
363  #if (defined (SPI_OVER_DSPI))
364  dspi_slave_config_t dspiConfig;
365  dspiConfig.bitcount = config->frameSize;
366  dspiConfig.clkPhase = (dspi_clock_phase_t)config->clockPhase;
367  dspiConfig.clkPolarity = (dspi_polarity_t)config->clockPolarity;
368  dspiConfig.transferType = (dspi_transfer_type_t)config->transferType;
369  dspiConfig.rxDMAChannel = config->rxDMAChannel;
370  dspiConfig.txDMAChannel = config->txDMAChannel;
371  dspiConfig.pcsPolarity = (dspi_polarity_t)config->ssPolarity;
372  dspiConfig.callback = config->callback;
373  dspiConfig.callbackParam = config->callbackParam;
374  /* Allocate one of the DSPI state structure for this instance */
375  index = SpiAllocateState(DspiStateIsAllocated, DspiStateInstanceMapping, instance, NO_OF_DSPI_INSTS_FOR_SPI);
376  status = DSPI_SlaveInit((dspi_instance_t)instance, (dspi_state_t*)&dspiState[index] ,&dspiConfig);
377  #endif
378  return status;
379 }
380 
381 /*FUNCTION**********************************************************************
382  *
383  * Function Name : SPI_SlaveTransfer
384  * Description : Initializes a non-blocking slave transfer
385  *
386  *END**************************************************************************/
387 status_t SPI_SlaveTransfer(spi_instance_t instance, void* txBuffer, void* rxBuffer, uint16_t numberOfFrames)
388 {
389  status_t status = STATUS_SUCCESS;
390 
391  /* Define SPI PAL over LPSPI */
392  #if defined(SPI_OVER_LPSPI)
393  if (instance <= LPSPI_HIGH_INDEX)
394  {
395  status = LPSPI_DRV_SlaveTransfer((uint32_t)instance, txBuffer, rxBuffer, numberOfFrames);
396  }
397  #endif
398 
399  /* Define SPI PAL over FLEXIO */
400  #if defined(SPI_OVER_FLEXIO)
401  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
402  {
403  status = FLEXIO_SPI_DRV_SlaveTransfer(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames);
404  }
405  #endif
406 
407  /* Define SPI PAL over DSPI */
408  #if (defined(SPI_OVER_DSPI))
409  status = DSPI_SlaveTransfer((dspi_instance_t)instance, txBuffer, rxBuffer, numberOfFrames);
410  #endif
411  return status;
412 }
413 
414 /*FUNCTION**********************************************************************
415  *
416  * Function Name : SPI_SlaveTransferBlocking
417  * Description : Initializes a blocking slave transfer with timeout
418  *
419  *END**************************************************************************/
420 status_t SPI_SlaveTransferBlocking(spi_instance_t instance, void* txBuffer, void* rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
421 {
422  status_t status = STATUS_SUCCESS;
423 
424  /* Define SPI PAL over LPSPI */
425  #if defined(SPI_OVER_LPSPI)
426  if (instance <= LPSPI_HIGH_INDEX)
427  {
428  status = LPSPI_DRV_SlaveTransferBlocking((uint32_t)instance, txBuffer, rxBuffer, numberOfFrames, timeout);
429  }
430  #endif
431 
432  /* Define SPI PAL over FLEXIO */
433  #if defined(SPI_OVER_FLEXIO)
434  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
435  {
436  status = FLEXIO_SPI_DRV_SlaveTransferBlocking(&(FlexioSpiState[FindFlexioState(instance)]), txBuffer, rxBuffer, numberOfFrames, timeout);
437  }
438  #endif
439 
440  /* Define SPI PAL over DSPI */
441  #if (defined(SPI_OVER_DSPI))
442  status = DSPI_SlaveTransferBlocking((dspi_instance_t)instance, txBuffer, rxBuffer, numberOfFrames, timeout);
443  #endif
444  return status;
445 }
446 
447 /*FUNCTION**********************************************************************
448  *
449  * Function Name : SPI_GetDefaultMasterConfig
450  * Description : Gets the default configuration structure for master
451  *
452  *END**************************************************************************/
454 {
455  config->baudRate = 100000U;
456  config->ssPolarity = SPI_ACTIVE_HIGH;
457  config->frameSize = 8U;
458  config->clockPhase = READ_ON_ODD_EDGE;
459  config->clockPolarity = SPI_ACTIVE_HIGH;
462  config->rxDMAChannel = 255U;
463  config->txDMAChannel = 255U;
464  config->callback = NULL;
465  config->callbackParam = NULL;
466  config->ssPin = 0;
467  config->extension = NULL;
468  return STATUS_SUCCESS;
469 }
470 
471 /*FUNCTION**********************************************************************
472  *
473  * Function Name : SPI_GetDefaultSlaveConfig
474  * Description : Gets the default configuration structure for slave
475  *
476  *END**************************************************************************/
478 {
479  config->ssPolarity = SPI_ACTIVE_HIGH;
480  config->frameSize = 8U;
481  config->clockPhase = READ_ON_ODD_EDGE;
482  config->clockPolarity = SPI_ACTIVE_HIGH;
485  config->rxDMAChannel = 255U;
486  config->txDMAChannel = 255U;
487  config->callback = NULL;
488  config->callbackParam = NULL;
489  config->extension = NULL;
490  return STATUS_SUCCESS;
491 }
492 
493 /*FUNCTION**********************************************************************
494  *
495  * Function Name : SPI_MasterDeinit
496  * Description : De-initializes the spi master module
497  *
498  *END**************************************************************************/
500 {
501  status_t status = STATUS_SUCCESS;
502 
503  /* Define SPI PAL over LPSPI */
504  #if defined(SPI_OVER_LPSPI)
505  if (instance <= LPSPI_HIGH_INDEX)
506  {
507  status = LPSPI_DRV_MasterDeinit((uint32_t)instance);
508  if (status == STATUS_SUCCESS)
509  {
510  SpiFreeState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance, NO_OF_LPSPI_INSTS_FOR_SPI);
511  }
512  }
513  #endif
514 
515  /* Define SPI PAL over FLEXIO */
516  #if defined(SPI_OVER_FLEXIO)
517  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
518  {
519  status = FLEXIO_SPI_DRV_MasterDeinit(&(FlexioSpiState[FindFlexioState(instance)]));
520  if (status == STATUS_SUCCESS)
521  {
522  SpiFreeState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_SPI);
523  }
524  }
525  #endif
526 
527  /* Define SPI PAL over DSPI */
528  #if (defined(SPI_OVER_DSPI))
529  status = DSPI_Deinit((dspi_instance_t)instance);
530  if (status == STATUS_SUCCESS)
531  {
532  SpiFreeState(DspiStateIsAllocated, DspiStateInstanceMapping, instance, NO_OF_DSPI_INSTS_FOR_SPI);
533  }
534  #endif
535  return status;
536 }
537 
538 /*FUNCTION**********************************************************************
539  *
540  * Function Name : SPI_SlaveDeinit
541  * Description : De-initializes the spi slave module
542  *
543  *END**************************************************************************/
545 {
546  status_t status = STATUS_SUCCESS;
547 
548  /* Define SPI PAL over LPSPI */
549  #if defined(SPI_OVER_LPSPI)
550  if (instance <= LPSPI_HIGH_INDEX)
551  {
552  status = LPSPI_DRV_SlaveDeinit((uint32_t)instance);
553  }
554  #endif
555 
556  /* Define SPI PAL over FLEXIO */
557  #if defined(SPI_OVER_FLEXIO)
558  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
559  {
560  status = FLEXIO_SPI_DRV_SlaveDeinit(&(FlexioSpiState[FindFlexioState(instance)]));
561  }
562  #endif
563 
564  /* Define SPI PAL over DSPI */
565  #if (defined(SPI_OVER_DSPI))
566  status = DSPI_Deinit((dspi_instance_t)instance);
567  #endif
568  return status;
569 }
570 
571 /*FUNCTION**********************************************************************
572  *
573  * Function Name : SPI_SetSS
574  * Description : Changes the SS, if this feature is available.
575  *
576  *END**************************************************************************/
577 status_t SPI_SetSS(spi_instance_t instance, uint8_t ssPin)
578 {
579  status_t status = STATUS_SUCCESS;
580  (void)ssPin;
581 
582  /* Define SPI PAL over LPSPI */
583  #if defined(SPI_OVER_LPSPI)
584  if (instance <= LPSPI_HIGH_INDEX)
585  {
586  status = STATUS_UNSUPPORTED;
587  }
588  #endif
589 
590  /* Define SPI PAL over FLEXIO */
591  #if defined(SPI_OVER_FLEXIO)
592  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
593  {
594  status = STATUS_UNSUPPORTED;
595  }
596  #endif
597 
598  /* Define SPI PAL over DSPI */
599  #if (defined(SPI_OVER_DSPI))
600  status = DSPI_UpdateCS((dspi_instance_t)instance, ssPin);
601  #endif
602  return status;
603 }
604 
605 
606 /*FUNCTION**********************************************************************
607  *
608  * Function Name : SPI_GetStatus
609  * Description : Gets the status of the last transfer
610  *
611  *END**************************************************************************/
613 {
614  status_t status = STATUS_SUCCESS;
615 
616  /* Define SPI PAL over LPSPI */
617  #if defined(SPI_OVER_LPSPI)
618  if (instance <= LPSPI_HIGH_INDEX)
619  {
620  status = STATUS_UNSUPPORTED;
621  }
622  #endif
623 
624  /* Define SPI PAL over FLEXIO */
625  #if defined(SPI_OVER_FLEXIO)
626  if ((instance >= FLEXIO_SPI_LOW_INDEX) && (instance <= FLEXIO_SPI_HIGH_INDEX))
627  {
628  status = STATUS_UNSUPPORTED;
629  }
630  #endif
631 
632  /* Define SPI PAL over DSPI */
633  #if (defined(SPI_OVER_DSPI))
634  status = STATUS_UNSUPPORTED;
635  #endif
636  return status;
637 }
638 
639 /*******************************************************************************
640  * EOF
641  ******************************************************************************/
spi_callback_t callback
Definition: spi_pal.h:90
spi_clock_phase_t clockPhase
Definition: spi_pal.h:85
uint8_t rxDMAChannel
Definition: spi_pal.h:88
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:83
lpspi_signal_polarity_t pcsPolarity
#define PCC_LPSPI0_CLOCK
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.
#define FLEXIO_SPI_HIGH_INDEX
void * callbackParam
Definition: spi_pal.h:91
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:106
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 SPI_MasterTransferBlocking(spi_instance_t instance, void *txBuffer, void *rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
Initializes a blocking master transfer.
Definition: spi_pal.c:266
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:109
uint8_t frameSize
Definition: spi_pal.h:81
Defines the extension structure for the SPI over FLEXIO.
Definition: spi_pal.h:116
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 an interrupt and a non-blocking call. ...
uint32_t baudRate
Definition: spi_pal.h:80
status_t SPI_GetDefaultMasterConfig(spi_master_t *config)
Gets the default configuration structure for master.
Definition: spi_pal.c:453
lpspi_clock_phase_t clkPhase
status_t SPI_SlaveTransfer(spi_instance_t instance, void *txBuffer, void *rxBuffer, uint16_t numberOfFrames)
Initializes a non-blocking slave transfer.
Definition: spi_pal.c:387
#define DEV_ASSERT(x)
Definition: devassert.h:77
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.
status_t SPI_MasterInit(spi_instance_t instance, spi_master_t *config)
Initializes the SPI module in master mode.
Definition: spi_pal.c:137
uint8_t txDMAChannel
Definition: spi_pal.h:89
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 interrupt and a blocking call.
static void SpiFreeState(bool *isAllocated, spi_instance_t *instanceMapping, spi_instance_t instance, uint8_t numberOfinstances)
Definition: spi_pal.c:96
status_t SPI_SlaveTransferBlocking(spi_instance_t instance, void *txBuffer, void *rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
Initializes a blocking slave transfer.
Definition: spi_pal.c:420
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:104
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
#define FLEXIO_SPI_LOW_INDEX
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:44
clock_names_t
Clock names.
spi_transfer_bit_order_t bitOrder
Definition: spi_pal.h:101
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...
spi_instance_t
uint8_t ssPin
Definition: spi_pal.h:86
spi_polarity_t clockPolarity
Definition: spi_pal.h:102
Defines the configuration structure for SPI slave.
Definition: spi_pal.h:98
uint8_t frameSize
Definition: spi_pal.h:100
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.
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:92
flexio_spi_transfer_bit_order_t bitOrder
uint8_t txDMAChannel
Definition: spi_pal.h:107
spi_transfer_type_t transferType
Definition: spi_pal.h:105
spi_transfer_bit_order_t bitOrder
Definition: spi_pal.h:82
Defines the configuration structure for SPI master.
Definition: spi_pal.h:78
lpspi_sck_polarity_t
LPSPI Clock Signal (SCK) Polarity configuration. Implements : lpspi_sck_polarity_t_Class.
flexio_spi_transfer_size_t
Size of transferred data in bytes Implements : flexio_spi_transfer_size_t_Class.
status_t SPI_SetSS(spi_instance_t instance, uint8_t ssPin)
Update the SS.
Definition: spi_pal.c:577
status_t SPI_MasterDeinit(spi_instance_t instance)
De-initializes the spi master module.
Definition: spi_pal.c:499
spi_polarity_t ssPolarity
Definition: spi_pal.h:84
lpspi_which_pcs_t whichPcs
void * extension
Definition: spi_pal.h:110
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:477
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 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:103
status_t SPI_SlaveInit(spi_instance_t instance, spi_slave_t *config)
Initializes the SPI module in slave mode.
Definition: spi_pal.c:299
status_t LPSPI_DRV_SlaveDeinit(uint32_t instance)
Shuts down an LPSPI instance interrupt mechanism.
lpspi_sck_polarity_t clkPolarity
Master internal context structure.
status_t SPI_GetStatus(spi_instance_t instance)
Gets the status of the last transfer.
Definition: spi_pal.c:612
status_t SPI_MasterTransfer(spi_instance_t instance, void *txBuffer, void *rxBuffer, uint16_t numberOfFrames)
Initializes a non-blocking master transfer.
Definition: spi_pal.c:233
spi_callback_t callback
Definition: spi_pal.h:108
status_t SPI_SlaveDeinit(spi_instance_t instance)
De-initializes the spi slave module.
Definition: spi_pal.c:544
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
Definition: flexio_common.c:89
#define LPSPI_HIGH_INDEX
static uint8_t SpiAllocateState(bool *isAllocated, spi_instance_t *instanceMapping, spi_instance_t instance, uint8_t numberOfinstances)
Definition: spi_pal.c:74
spi_transfer_type_t transferType
Definition: spi_pal.h:87