Choco OS  V.0.16.9.0
Join to the chocolate world
oc_spi_lld.c
1 /*******************************************************************************************************************************************
2  *
3  * Changing the Hardware On Click Operating System (ChOC)
4  *
5  * @file oc_spi_lld.c
6  *
7  * @brief The file with sources for the spi low level driver (SPI-LLD)
8  *
9  * @author Krzysztof Chmielewski - (Created on: 7 09 2015 20:30:18)
10  * Kamil Drobienko
11  * Krzysztof Dworzynski
12  *
13  * @note Copyright (C) 2015 Krzysztof Chmielewski <krzysztof.marek.chmielewski@gmail.com>
14  * Copyright (C) 2015 Kamil Drobienko <kamildrobienko@gmail.com>
15  * Copyright (C) 2015 Krzysztof Dworzynski <dworniok@gmail.com>
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation; either version 2 of the License, or
20  * (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
30  *
31  ******************************************************************************************************************************************/
32 
33 #include <oc_spi_lld.h>
34 #include <oc_machine.h>
35 #include <oc_bits.h>
36 #include <oc_gpio_mslld.h>
37 #include <oc_machine_defs.h>
38 #include <oc_clock_lld.h>
39 #include <oc_dma_lld.h>
40 #include <oc_array.h>
41 #include <oc_mem_lld.h>
42 #include <oc_math.h>
43 
49 #define _________________________________________MACROS_SECTION_____________________________________________________________________________
50 
51 #define IsRam(address) (oC_MEM_LLD_IsRamAddress(address))
52 #define IsRom(address) (oC_MEM_LLD_IsFlashAddress(address))
53 #define IsChannelCorrect(channel) (oC_Channel_IsCorrect(SPI,channel))
54 #define IsChannelPoweredOn(channel) (oC_Machine_GetPowerStateForChannel(Channel) == oC_Power_On)
55 #define IsChannelUsed(channel) (oC_Bits_IsBitSetU32(ChannelUsedFlags,(uint8_t)oC_Channel_ToIndex(SPI,Channel)))
56 #define IsChannelBusy(channel) (SSISR(channel)->BSY == 1) // SSI Busy Bit
57 #define IsRxFifoFull(channel) (SSISR(channel)->RFF == 1) // SSI Receive FIFO Full
58 #define IsRxFifoEmpty(channel) (SSISR(channel)->RNE == 0) // SSI Receive FIFO Not Empty
59 #define IsTxFifoFull(channel) (SSISR(channel)->TNF == 0) // SSI Transmit FIFO Not Full
60 #define IsTxFifoEmpty(channel) (SSISR(channel)->TFE == 1) // SSI Transmit FIFO Empty
61 
62 #define SSICR0(Channel) oC_Machine_Register(Channel, SSICR0)
63 #define SSICR1(Channel) oC_Machine_Register(Channel, SSICR1)
64 #define SSIDR(Channel) oC_Machine_Register(Channel, SSIDR)
65 #define SSISR(Channel) oC_Machine_Register(Channel, SSISR)
66 #define SSICPSR(Channel) oC_Machine_Register(Channel, SSICPSR)
67 #define SSIDMACTL(Channel) oC_Machine_Register(Channel, SSIDMACTL)
68 #define SSICC(Channel) oC_Machine_Register(Channel, SSICC)
70 #define IsFrameWidthCorrect(FrameWidth) ((FrameWidth) >= oC_MACHINE_SPI_MINIMUM_FRAME_WIDTH) && ((FrameWidth) <= oC_MACHINE_SPI_MAXIMUM_FRAME_WIDTH)
72 #define AreChannelOperationsEnabled(Channel) (SSICR1(Channel)->SSE == 1)
73 #define AreChannelOperationsDisabled(Channel) (SSICR1(Channel)->SSE == 0)
74 
75 #undef __________________________________________MACROS_SECTION_____________________________________________________________________________
76 
77 #define _________________________________________VARIABLES_SECTION__________________________________________________________________________
78 
79 static bool ModuleEnabledFlag = false;
80 static oC_SPI_LLD_Interrupt_t RxFullInterrupt = NULL;
81 static oC_SPI_LLD_Interrupt_t TxEmptyInterrupt = NULL;
82 static uint32_t ChannelUsedFlags = 0;
83 
84 #undef _________________________________________VARIABLES_SECTION__________________________________________________________________________
85 
91 #define ______________________________________LOCAL_PROTOTYPES_SECTION______________________________________________________________________
92 
93 static oC_ErrorCode_t CalculateDivisorsAndWriteRegisters ( oC_SPI_Channel_t Channel, oC_Frequency_t Frequency , oC_Frequency_t AcceptableDifference );
94 
95 #undef ______________________________________LOCAL_PROTOTYPES_SECTION_______________________________________________________________________
96 
102 #define _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
103 
104 //==========================================================================================================================================
109 //==========================================================================================================================================
110 bool oC_SPI_LLD_IsChannelCorrect( oC_SPI_Channel_t Channel )
111 {
112  return oC_Channel_IsCorrect( SPI , Channel);
113 }
114 //==========================================================================================================================================
119 //==========================================================================================================================================
120 bool oC_SPI_LLD_IsChannelIndexCorrect( oC_ChannelIndex_t ChannelIndex )
121 {
122  return ChannelIndex < oC_ModuleChannel_NumberOfElements(SPI);
123 }
124 //==========================================================================================================================================
129 //==========================================================================================================================================
130 oC_ChannelIndex_t oC_SPI_LLD_ChannelToChannelIndex( oC_SPI_Channel_t Channel )
131 {
132  return oC_Channel_ToIndex(SPI,Channel);
133 }
134 //==========================================================================================================================================
139 //==========================================================================================================================================
140 oC_SPI_Channel_t oC_SPI_LLD_ChannelIndexToChannel( oC_ChannelIndex_t Channel )
141 {
142  return oC_Channel_FromIndex(SPI,Channel);
143 }
144 //==========================================================================================================================================
149 //==========================================================================================================================================
150 oC_SPI_Channel_t oC_SPI_LLD_GetChannelOfModulePin( oC_SPI_Pin_t ModulePin )
151 {
152  return oC_ModulePin_GetChannel(ModulePin);
153 }
154 //==========================================================================================================================================
159 //==========================================================================================================================================
160 oC_ErrorCode_t oC_SPI_LLD_TurnOnDriver( void )
161 {
162  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
163 
164  if(oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == false , oC_ErrorCode_ModuleIsTurnedOn))
165  {
166  errorCode = oC_ErrorCode_None;
167  RxFullInterrupt = NULL;
168  TxEmptyInterrupt = NULL;
169  ChannelUsedFlags = 0;
170  ModuleEnabledFlag = true;
171  }
172 
173  return errorCode;
174 }
175 //==========================================================================================================================================
180 //==========================================================================================================================================
181 oC_ErrorCode_t oC_SPI_LLD_TurnOffDriver( void )
182 {
183  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
184 
185  if(oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
186  {
187  ModuleEnabledFlag = false;
188  RxFullInterrupt = NULL;
189  TxEmptyInterrupt = NULL;
190  ChannelUsedFlags = 0;
191  errorCode = oC_ErrorCode_None;
192 
193  oC_SPI_LLD_ForEachChannel(channel)
194  {
195  oC_AssignErrorCode(&errorCode , oC_SPI_LLD_RestoreDefaultStateOnChannel(channel));
196  }
197 
198  }
199 
200  return errorCode;
201 }
202 //==========================================================================================================================================
207 //==========================================================================================================================================
208 oC_ErrorCode_t oC_SPI_LLD_SetDriverInterruptHandlers( oC_SPI_LLD_Interrupt_t RxFull , oC_SPI_LLD_Interrupt_t TxEmpty )
209 {
210  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
211 
212  if(
213  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
214  oC_AssignErrorCodeIfFalse(&errorCode , RxFullInterrupt == NULL , oC_ErrorCode_InterruptHandlerAlreadySet) &&
215  oC_AssignErrorCodeIfFalse(&errorCode , TxEmptyInterrupt == NULL , oC_ErrorCode_InterruptHandlerAlreadySet) &&
216  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(RxFull) || IsRom(RxFull) , oC_ErrorCode_WrongAddress) &&
217  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(TxEmpty) || IsRom(TxEmpty) , oC_ErrorCode_WrongAddress)
218  )
219  {
220  RxFullInterrupt = RxFull;
221  TxEmptyInterrupt = TxEmpty;
222 
223  errorCode = oC_ErrorCode_None;
224  }
225 
226  return errorCode;
227 }
228 //==========================================================================================================================================
233 //==========================================================================================================================================
234 oC_ErrorCode_t oC_SPI_LLD_SetPower( oC_SPI_Channel_t Channel , oC_Power_t Power )
235 {
236  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
237 
238  if(
239  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
240  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel ) &&
241  oC_AssignErrorCodeIfFalse(&errorCode , Power == oC_Power_On || Power == oC_Power_Off , oC_ErrorCode_PowerStateNotCorrect) &&
242  oC_AssignErrorCodeIfFalse(&errorCode , oC_Machine_SetPowerStateForChannel(Channel,Power) , oC_ErrorCode_CannotEnableChannel)
243  )
244  {
245  errorCode = oC_ErrorCode_None;
246  }
247 
248  return errorCode;
249 }
250 //==========================================================================================================================================
255 //==========================================================================================================================================
256 oC_ErrorCode_t oC_SPI_LLD_ReadPower( oC_SPI_Channel_t Channel , oC_Power_t * outPower )
257 {
258  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
259 
260  if(
261  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
262  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
263  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outPower) , oC_ErrorCode_OutputAddressNotInRAM)
264  )
265  {
266  *outPower = oC_Machine_GetPowerStateForChannel(Channel);
267  errorCode = oC_ErrorCode_None;
268  }
269 
270  return errorCode;
271 }
272 //==========================================================================================================================================
277 //==========================================================================================================================================
278 oC_ErrorCode_t oC_SPI_LLD_DisableOperations( oC_SPI_Channel_t Channel )
279 {
280  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
281 
282  if(
283  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
284  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
285  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn)
286  )
287  {
288  while(IsChannelBusy(Channel));
289 
290  SSICR1(Channel)->SSE = 0;
291 
292  errorCode = oC_ErrorCode_None;
293  }
294 
295  return errorCode;
296 }
297 //==========================================================================================================================================
302 //==========================================================================================================================================
303 oC_ErrorCode_t oC_SPI_LLD_EnableOperations( oC_SPI_Channel_t Channel )
304 {
305  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
306 
307  if(
308  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
309  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
310  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn)
311  )
312  {
313  if( AreChannelOperationsEnabled(Channel) )
314  {
315  errorCode = oC_SPI_LLD_DisableOperations(Channel);
316 
317  if( errorCode == oC_ErrorCode_None )
318  {
319  SSICR0(Channel)->FRF = 0;
320  SSICR1(Channel)->SLBY6 = 1;
321  SSICC (Channel)->CS = 0;
323  SSICR1(Channel)->SSE = 1;
324  }
325  }
326  else
327  {
328  SSICR0(Channel)->FRF = 0;
329  SSICR1(Channel)->SLBY6 = 1;
330  SSICC (Channel)->CS = 0;
332  SSICR1(Channel)->SSE = 1;
334  errorCode = oC_ErrorCode_None;
335  }
336 
337  }
338 
339  return errorCode;
340 }
341 //==========================================================================================================================================
346 //==========================================================================================================================================
347 oC_ErrorCode_t oC_SPI_LLD_RestoreDefaultStateOnChannel( oC_SPI_Channel_t Channel )
348 {
349  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
350 
351  if(oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel))
352  {
353  oC_Bits_ClearBitU32(&ChannelUsedFlags,oC_SPI_LLD_ChannelToChannelIndex(Channel));
354 
355  if(oC_Machine_SetPowerStateForChannel(Channel,oC_Power_Off))
356  {
357  errorCode = oC_ErrorCode_None;
358  }
359  }
360 
361  return errorCode;
362 }
363 //==========================================================================================================================================
368 //==========================================================================================================================================
369 oC_ErrorCode_t oC_SPI_LLD_SetBitOrder( oC_SPI_Channel_t Channel , oC_SPI_LLD_BitOrder_t BitOrder )
370 {
371  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
372 
373  if(
374  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
375  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
376  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
377  oC_AssignErrorCodeIfFalse(&errorCode , BitOrder == oC_SPI_LLD_BitOrder_MSBFirst , oC_ErrorCode_BitOrderNotSupported) &&
378  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
379  )
380  {
381  errorCode = oC_ErrorCode_None;
382  }
383 
384  return errorCode;
385 }
386 //==========================================================================================================================================
391 //==========================================================================================================================================
392 oC_ErrorCode_t oC_SPI_LLD_ReadBitOrder( oC_SPI_Channel_t Channel , oC_SPI_LLD_BitOrder_t * outBitOrder )
393 {
394  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
395 
396  if(
397  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
398  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
399  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
400  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outBitOrder) , oC_ErrorCode_OutputAddressNotInRAM)
401  )
402  {
403  *outBitOrder = oC_SPI_LLD_BitOrder_MSBFirst;
404 
405  errorCode = oC_ErrorCode_None;
406  }
407 
408  return errorCode;
409 }
410 //==========================================================================================================================================
415 //==========================================================================================================================================
416 oC_ErrorCode_t oC_SPI_LLD_SetFrameWidth( oC_SPI_Channel_t Channel , oC_SPI_LLD_FrameWidth_t FrameWidth )
417 {
418  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
419 
420  if(
421  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
422  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
423  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
424  oC_AssignErrorCodeIfFalse(&errorCode , IsFrameWidthCorrect(FrameWidth) , oC_ErrorCode_FrameWidthNotSupported) &&
425  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
426  )
427  {
428  SSICR0(Channel)->DSS = (--FrameWidth);
429  errorCode = oC_ErrorCode_None;
430  }
431 
432  return errorCode;
433 }
434 //==========================================================================================================================================
439 //==========================================================================================================================================
440 oC_ErrorCode_t oC_SPI_LLD_ReadFrameWidth( oC_SPI_Channel_t Channel , oC_SPI_LLD_FrameWidth_t * outFrameWidth )
441 {
442  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
443 
444  if(
445  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
446  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
447  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
448  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outFrameWidth) , oC_ErrorCode_OutputAddressNotInRAM)
449  )
450  {
451  *outFrameWidth = SSICR0(Channel)->DSS + 1;
452 
453  errorCode = oC_ErrorCode_None;
454  }
455 
456  return errorCode;
457 }
458 //==========================================================================================================================================
463 //==========================================================================================================================================
464 oC_ErrorCode_t oC_SPI_LLD_SetClockPhase( oC_SPI_Channel_t Channel , oC_SPI_LLD_Phase_t Phase )
465 {
466  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
467 
468  if(
469  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
470  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
471  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
472  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled) &&
473  oC_AssignErrorCodeIfFalse(&errorCode , Phase == oC_SPI_LLD_Phase_FirstEdge ||
474  Phase == oC_SPI_LLD_Phase_SecondEdge , oC_ErrorCode_ClockPhaseNotSupported)
475  )
476  {
477  if (oC_SPI_LLD_Phase_FirstEdge == Phase)
478  {
479  SSICR0(Channel)->SPH = 0;
480  }
481  else
482  {
483  SSICR0(Channel)->SPH = 1;
484  }
485 
486  errorCode = oC_ErrorCode_None;
487  }
488 
489  return errorCode;
490 }
491 //==========================================================================================================================================
496 //==========================================================================================================================================
497 oC_ErrorCode_t oC_SPI_LLD_ReadClockPhase( oC_SPI_Channel_t Channel , oC_SPI_LLD_Phase_t * outPhase )
498 {
499  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
500 
501  if(
502  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
503  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
504  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
505  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outPhase) , oC_ErrorCode_OutputAddressNotInRAM)
506  )
507  {
508  if (0 == SSICR0(Channel)->SPH)
509  {
510  *outPhase = oC_SPI_LLD_Phase_FirstEdge;
511  }
512  else
513  {
514  *outPhase = oC_SPI_LLD_Phase_SecondEdge;
515  }
516 
517  errorCode = oC_ErrorCode_None;
518  }
519 
520  return errorCode;
521 }
522 //==========================================================================================================================================
527 //==========================================================================================================================================
528 oC_ErrorCode_t oC_SPI_LLD_SetClockPolarity( oC_SPI_Channel_t Channel , oC_SPI_LLD_Polarity_t Polarity )
529 {
530  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
531 
532  if(
533  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
534  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
535  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
536  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled) &&
537  oC_AssignErrorCodeIfFalse(&errorCode , Polarity == oC_SPI_LLD_Polarity_HighWhenActive ||
538  Polarity == oC_SPI_LLD_Polarity_LowWhenActive , oC_ErrorCode_ClockPolarityNotSupported)
539  )
540  {
541  if (oC_SPI_LLD_Polarity_HighWhenActive == Polarity)
542  {
543  SSICR0(Channel)->SPO = 1;
544  }
545  else
546  {
547  SSICR0(Channel)->SPO = 0;
548  }
549 
550  errorCode = oC_ErrorCode_None;
551  }
552 
553  return errorCode;
554 }
555 //==========================================================================================================================================
560 //==========================================================================================================================================
561 oC_ErrorCode_t oC_SPI_LLD_ReadClockPolarity( oC_SPI_Channel_t Channel , oC_SPI_LLD_Polarity_t * outPolarity )
562 {
563  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
564 
565  if(
566  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
567  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
568  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
569  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outPolarity) , oC_ErrorCode_OutputAddressNotInRAM)
570  )
571  {
572  if (0 == SSICR0(Channel)->SPO)
573  {
574  *outPolarity = oC_SPI_LLD_Polarity_LowWhenActive;
575  }
576  else
577  {
578  *outPolarity = oC_SPI_LLD_Polarity_HighWhenActive;
579  }
580 
581  errorCode = oC_ErrorCode_None;
582  }
583 
584  return errorCode;
585 }
586 //==========================================================================================================================================
591 //==========================================================================================================================================
592 oC_ErrorCode_t oC_SPI_LLD_SetChipSelectPolarity( oC_SPI_Channel_t Channel , oC_SPI_LLD_Polarity_t Polarity )
593 {
594  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
595 
596  if(
597  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
598  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
599  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
600  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled) &&
601  oC_AssignErrorCodeIfFalse(&errorCode , Polarity == oC_SPI_LLD_Polarity_LowWhenActive , oC_ErrorCode_ChipSelectPolarityNotSupported)
602  )
603  {
604  errorCode = oC_ErrorCode_None;
605  }
606 
607  return errorCode;
608 }
609 //==========================================================================================================================================
614 //==========================================================================================================================================
615 oC_ErrorCode_t oC_SPI_LLD_ReadChipSelectPolarity( oC_SPI_Channel_t Channel , oC_SPI_LLD_Polarity_t * outPolarity )
616 {
617  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
618 
619  if(
620  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
621  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
622  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
623  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outPolarity) , oC_ErrorCode_OutputAddressNotInRAM)
624  )
625  {
626  *outPolarity = oC_SPI_LLD_Polarity_LowWhenActive;
627  errorCode = oC_ErrorCode_None;
628  }
629 
630  return errorCode;
631 }
632 //==========================================================================================================================================
637 //==========================================================================================================================================
638 oC_ErrorCode_t oC_SPI_LLD_SetLoopback( oC_SPI_Channel_t Channel , bool Loopback )
639 {
640  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
641 
642  if(
643  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
644  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
645  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
646  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
647  )
648  {
649  if(Loopback)
650  {
651  SSICR1(Channel)->LBM = 1;
652  }
653  else
654  {
655  SSICR1(Channel)->LBM = 0;
656  }
657 
658  errorCode = oC_ErrorCode_None;
659  }
660 
661  return errorCode;
662 }
663 //==========================================================================================================================================
668 //==========================================================================================================================================
669 oC_ErrorCode_t oC_SPI_LLD_ReadLoopback( oC_SPI_Channel_t Channel , bool * outLoopback )
670 {
671  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
672 
673  if(
674  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
675  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
676  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
677  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outLoopback) , oC_ErrorCode_OutputAddressNotInRAM)
678  )
679  {
680  *outLoopback = SSICR1(Channel)->LBM;
681  errorCode = oC_ErrorCode_None;
682  }
683 
684  return errorCode;
685 }
686 //==========================================================================================================================================
691 //==========================================================================================================================================
692 oC_ErrorCode_t oC_SPI_LLD_SetFrequency( oC_SPI_Channel_t Channel , oC_Frequency_t Frequency , oC_Frequency_t PermissibleDifference )
693 {
694  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
695 
696  if(
697  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
698  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
699  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
700  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled) &&
701  oC_AssignErrorCodeIfFalse(&errorCode , Frequency >=0 , oC_ErrorCode_WrongFrequency)
702  )
703  {
704  oC_SPI_LLD_Mode_t mode;
705  errorCode = oC_SPI_LLD_ReadMode(Channel , &mode);
706 
707  if (mode == oC_SPI_LLD_Mode_Master)
708  {
709  errorCode = CalculateDivisorsAndWriteRegisters(Channel , Frequency , PermissibleDifference);
710  }
711  else
712  {
713  errorCode = oC_ErrorCode_FunctionNotSupportedInCurrentMode;
714  }
715  }
716 
717  return errorCode;
718 }
719 //==========================================================================================================================================
724 //==========================================================================================================================================
725 oC_ErrorCode_t oC_SPI_LLD_ReadFrequency( oC_SPI_Channel_t Channel , oC_Frequency_t * outFrequency )
726 {
727  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
728 
729  if(
730  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
731  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
732  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
733  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outFrequency) , oC_ErrorCode_OutputAddressNotInRAM)
734  )
735  {
736  oC_SPI_LLD_Mode_t mode;
737 
738  if(oC_AssignErrorCode(&errorCode , oC_SPI_LLD_ReadMode(Channel , &mode)))
739  {
740  if(mode == oC_SPI_LLD_Mode_Master)
741  {
742  oC_Frequency_t SystemClockFrequency = oC_CLOCK_LLD_GetClockFrequency();
743 
744  *outFrequency = SystemClockFrequency / (SSICPSR(Channel)->CPSDVSR * (SSICR0(Channel)->SCR + 1));
745  errorCode = oC_ErrorCode_None;
746  }
747  else
748  {
749  errorCode = oC_ErrorCode_FunctionNotSupportedInCurrentMode;
750  }
751  }
752  }
753 
754  return errorCode;
755 }
756 //==========================================================================================================================================
761 //==========================================================================================================================================
762 oC_ErrorCode_t oC_SPI_LLD_SetChannelUsed( oC_SPI_Channel_t Channel )
763 {
764  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
765 
766  if(
767  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet ) &&
768  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel ) &&
769  oC_AssignErrorCodeIfFalse(&errorCode , !oC_SPI_LLD_IsChannelUsed(Channel), oC_ErrorCode_ChannelIsUsed)
770  )
771  {
772  oC_Bits_SetBitU32(&ChannelUsedFlags,(oC_uint32_t) oC_SPI_LLD_ChannelToChannelIndex(Channel));
773  errorCode = oC_ErrorCode_None;
774  }
775 
776  return errorCode;
777 }
778 //==========================================================================================================================================
783 //==========================================================================================================================================
784 oC_ErrorCode_t oC_SPI_LLD_SetChannelUnused( oC_SPI_Channel_t Channel )
785 {
786  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
787 
788  if(
789  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet ) &&
790  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel )
791  )
792  {
793  oC_Bits_ClearBitU32(&ChannelUsedFlags,(oC_uint32_t) oC_SPI_LLD_ChannelToChannelIndex(Channel));
794  errorCode = oC_ErrorCode_None;
795  }
796 
797  return errorCode;
798 }
799 //==========================================================================================================================================
804 //==========================================================================================================================================
805 bool oC_SPI_LLD_IsChannelUsed( oC_SPI_Channel_t Channel )
806 {
807  bool used = false;
808 
809  if( (ModuleEnabledFlag == true) && IsChannelCorrect(Channel))
810  {
811  /*
812  * This assertion fails, when some of lm4f machine has more than 32 SPI channels. To save RAM memory, only 1 bit is used for marking,
813  * that channel is already used. Flags are stored in the uint32_t type, so it can store only 32 channels. If you want to repair this error,
814  * you must change the ChannelUsedFlags type to uint64_t, and then change assertion below to compare with '64' instead of '32'.
815  * Moreover, you should update functions #oC_SPI_LLD_SetChannelUnused and oC_SPI_LLD_SetChannelUsed to use
816  * #oC_Bits_SetBitU64 and #oC_Bits_ClearBitU64 instead of #oC_Bits_SetBitU32 and #oC_Bits_ClearBitU32.
817  * If you do this, it should works.
818  */
819  oC_STATIC_ASSERT(oC_ModuleChannel_NumberOfElements(SPI) <= 32,"The SPI LLD module is not designed for more, than 32 channels - you need to set ChannelUsedFlags to uint64_t if you want to handle it!");
820 
821  used = IsChannelUsed(Channel);
822  }
823 
824  return used;
825 }
826 //==========================================================================================================================================
831 //==========================================================================================================================================
832 bool oC_SPI_LLD_IsModulePinDefined( oC_SPI_Pin_t ModulePin )
833 {
834  oC_Pin_t pin = oC_ModulePin_GetPin(ModulePin);
835  return oC_GPIO_LLD_IsPinDefined(pin);
836 }
837 //==========================================================================================================================================
842 //==========================================================================================================================================
843 oC_ErrorCode_t oC_SPI_LLD_SetMode( oC_SPI_Channel_t Channel, oC_SPI_LLD_Mode_t Mode )
844 {
845  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
846 
847  if(
848  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet ) &&
849  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
850  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
851  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled) &&
852  oC_AssignErrorCodeIfFalse(&errorCode , Mode == oC_SPI_LLD_Mode_Master ||
853  Mode == oC_SPI_LLD_Mode_SlaveDisabledOutput ||
854  Mode == oC_SPI_LLD_Mode_SlaveEnabledOutput , oC_ErrorCode_ModeNotSupported)
855  )
856  {
857  SSICR1(Channel)->MS = (Mode & 1);
858  SSICR1(Channel)->SOD = ((Mode>>1) & 1) ;
860  errorCode = oC_ErrorCode_None;
861  }
862 
863  return errorCode;
864 }
865 //==========================================================================================================================================
870 //==========================================================================================================================================
871 oC_ErrorCode_t oC_SPI_LLD_ReadMode( oC_SPI_Channel_t Channel, oC_SPI_LLD_Mode_t * outMode )
872 {
873  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
874 
875  if(
876  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
877  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
878  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
879  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outMode) , oC_ErrorCode_OutputAddressNotInRAM)
880  )
881  {
882  if ((SSICR1(Channel)->MS == 1) && (SSICR1(Channel)->SOD == 0))
883  {
884  *outMode = oC_SPI_LLD_Mode_SlaveEnabledOutput;
885  }
886  else if ((SSICR1(Channel)->MS == 1) && (SSICR1(Channel)->SOD == 1))
887  {
888  *outMode = oC_SPI_LLD_Mode_SlaveDisabledOutput;
889  }
890  else
891  {
892  *outMode = oC_SPI_LLD_Mode_Master;
893  }
894 
895  errorCode = oC_ErrorCode_None;
896  }
897 
898  return errorCode;
899 }
900 //==========================================================================================================================================
905 //==========================================================================================================================================
906 oC_ErrorCode_t oC_SPI_LLD_ReadModulePinsOfPin( oC_Pins_t Pin , oC_SPI_Pin_t * outPeripheralPinsArray , uint32_t * ArraySize)
907 {
908  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
909 
910  if(
911  oC_AssignErrorCodeIfFalse(&errorCode , oC_GPIO_LLD_IsSinglePin(Pin) , oC_ErrorCode_NotSinglePin ) &&
912  oC_AssignErrorCodeIfFalse(&errorCode , oC_SPI_LLD_IsModulePinDefined(Pin) , oC_ErrorCode_PinNotDefined ) &&
913  oC_AssignErrorCodeIfFalse(&errorCode , oC_MEM_LLD_IsRamAddress(outPeripheralPinsArray) , oC_ErrorCode_OutputAddressNotInRAM ) &&
914  oC_AssignErrorCodeIfFalse(&errorCode , oC_MEM_LLD_IsRamAddress(ArraySize) , oC_ErrorCode_OutputAddressNotInRAM ) &&
915  oC_AssignErrorCodeIfFalse(&errorCode , (*ArraySize) < 255 , oC_ErrorCode_ValueTooBig )
916  )
917  {
918  uint8_t outArrayIndex = 0;
919 
920  errorCode = oC_ErrorCode_None;
921 
922  oC_ModulePin_ForeachDefined(modulePin)
923  {
924  if(modulePin->Pin == Pin && oC_Channel_IsCorrect(SPI,modulePin->Channel))
925  {
926  if(outArrayIndex < (*ArraySize))
927  {
928  outPeripheralPinsArray[outArrayIndex++] = modulePin->ModulePinIndex;
929  }
930  else
931  {
932  errorCode = oC_ErrorCode_OutputArrayToSmall;
933  }
934  }
935  }
936 
937  if(outArrayIndex == 0)
938  {
939  errorCode = oC_ErrorCode_PeripheralPinNotDefined;//module
940  }
941 
942  *ArraySize = outArrayIndex;
943  }
944 
945  return errorCode;
946 }
947 //==========================================================================================================================================
952 //==========================================================================================================================================
953 oC_ErrorCode_t oC_SPI_LLD_ConnectModulePin( oC_SPI_Pin_t ModulePin )
954 {
955  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
956 // oC_SPI_Channel_t channel = oC_SPI_LLD_GetChannelOfModulePin(ModulePin);
957 //TODO: implement this
958  // oC_Pins_t pin = oC_ModulePin_GetPin(ModulePin);
959 //
960 // if(
961 // oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet ) &&
962 // oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(channel) , oC_ErrorCode_WrongChannel ) &&
963 // oC_AssignErrorCodeIfFalse(&errorCode , oC_GPIO_LLD_IsPinDefined(ModulePin) , oC_ErrorCode_PeripheralPinNotDefined )
964 // )
965 // {
966 //
967 // uint8_t digitalFunction = oC_Machine_GetDigitalFunctionOfPeripheralPin(ModulePin);
968 //
969 // if(oC_AssignErrorCode(&errorCode , oC_GPIO_MSLLD_ConnectModulePin( pin , digitalFunction )))
970 // {
971 // errorCode = oC_ErrorCode_None;
972 // }
973 // }
974  errorCode = oC_ErrorCode_None;
975  return errorCode;
976 }
977 //==========================================================================================================================================
982 //==========================================================================================================================================
983 oC_ErrorCode_t oC_SPI_LLD_ConfigureGeneralChipSelectPin( oC_SPI_Channel_t Channel , oC_Pins_t Pin )
984 {
985  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
986  bool pinUnused = false;
987 
988  if(
989  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
990  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel ) &&
991  oC_AssignErrorCodeIfFalse(&errorCode , oC_GPIO_LLD_IsPinDefined(Pin) , oC_ErrorCode_PinNotDefined)
992  )
993  {
994  if(
995  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ArePinsUnused(Pin,&pinUnused)) &&
996  oC_AssignErrorCodeIfFalse(&errorCode , pinUnused , oC_ErrorCode_PinIsUsed) &&
997  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPinsUsed(Pin))
998  )
999  {
1000  if(
1001  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pin)) &&
1002  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetMode(Pin , oC_GPIO_LLD_Mode_Output)) &&
1003  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetCurrent(Pin , oC_GPIO_LLD_Current_Minimum)) &&
1004  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetOutputCircuit(Pin , oC_GPIO_LLD_OutputCircuit_PushPull)) &&
1005  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPull(Pin , oC_GPIO_LLD_Pull_Up)) &&
1006  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pin))
1007  )
1008  {
1009  errorCode = oC_ErrorCode_None;
1010  }
1011  else
1012  {
1013  oC_GPIO_LLD_SetPinsUnused(Pin);
1014  }
1015  }
1016  }
1017 
1018  return errorCode;
1019 }
1020 //==========================================================================================================================================
1025 //==========================================================================================================================================
1026 oC_ErrorCode_t oC_SPI_LLD_UnconfigureGeneralChipSelectPin( oC_SPI_Channel_t Channel , oC_Pins_t Pin )
1027 {
1028 
1029  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1030 
1031  if(
1032  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel ) &&
1033  oC_AssignErrorCodeIfFalse(&errorCode , oC_GPIO_LLD_IsPinDefined(Pin) , oC_ErrorCode_PinNotDefined)
1034  )
1035  {
1036  errorCode = oC_GPIO_LLD_SetPinsUnused(Pin);
1037  }
1038 
1039  return errorCode;
1040 
1041 }
1042 //==========================================================================================================================================
1047 //==========================================================================================================================================
1048 oC_ErrorCode_t oC_SPI_LLD_SetGeneralChipSelectState( oC_SPI_Channel_t Channel , oC_Pins_t Pin , oC_SPI_LLD_State_t State )
1049 {
1050  oC_ErrorCode_t errorCode = oC_ErrorCode_NotImplemented;
1051  if(
1052  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
1053  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel ) &&
1054  oC_AssignErrorCodeIfFalse(&errorCode , oC_GPIO_LLD_IsPinDefined(Pin) , oC_ErrorCode_PinNotDefined) &&
1055  oC_AssignErrorCodeIfFalse(&errorCode , State == oC_SPI_LLD_State_Active ||
1056  State == oC_SPI_LLD_State_NotActive , oC_ErrorCode_StateNotSupported)
1057  )
1058  {
1059  oC_GPIO_LLD_SetPinsState(Pin , State);
1060 
1061  errorCode = oC_ErrorCode_None;
1062  }
1063 
1064  return errorCode;
1065 }
1066 //==========================================================================================================================================
1071 //==========================================================================================================================================
1072 bool oC_SPI_LLD_IsDmaSupportPossible( oC_SPI_Channel_t Channel )
1073 {
1074  bool result = false;
1075  //TODO: loop for all dma channels
1076  if(ModuleEnabledFlag && IsChannelCorrect(Channel))
1077  {
1078  oC_DMA_Channel_t channelRx = 0;
1079  oC_DMA_Channel_t channelTx = 0;
1080 
1081  if(
1082  oC_ErrorOccur(oC_DMA_LLD_FindFreeDmaChannelForPeripheralTrade(&channelRx , Channel, oC_Machine_DmaSignalType_RX)) &&
1083  oC_ErrorOccur(oC_DMA_LLD_FindFreeDmaChannelForPeripheralTrade(&channelRx , Channel, oC_Machine_DmaSignalType_TX))
1084  )
1085  {
1086  result = true;
1087  }
1088  else if(
1089  oC_DMA_LLD_IsChannelSupportedOnDmaChannel(channelRx , Channel , oC_Machine_DmaSignalType_RX) &&
1090  oC_DMA_LLD_IsChannelSupportedOnDmaChannel(channelTx , Channel , oC_Machine_DmaSignalType_RX)
1091  )
1092  {
1093  result = true;
1094  }
1095  }
1096 
1097  return result;
1098 }//==========================================================================================================================================
1103 //==========================================================================================================================================
1104 oC_ErrorCode_t oC_SPI_LLD_Write( oC_SPI_Channel_t Channel , void * Buffer , oC_UInt_t BufferSize , oC_UInt_t ElementSize , oC_IoFlags_t IoFlags )
1105 {
1106  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1107 
1108  if(
1109  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
1110  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1111  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1112  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsEnabled(Channel) , oC_ErrorCode_ChannelOperationsNotEnabled) &&
1113  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(Buffer) || IsRom(Buffer) , oC_ErrorCode_WrongAddress) &&
1114  oC_AssignErrorCodeIfFalse(&errorCode , BufferSize != 0 && ElementSize != 0 , oC_ErrorCode_SizeNotCorrect)
1115  )
1116  {
1117  void * endBuffer = Buffer + (BufferSize * ElementSize);
1118 
1119  for(;Buffer < endBuffer ; Buffer += ElementSize)
1120  {
1121  if( oC_Bits_AreBitsClearU32(IoFlags,oC_IoFlags_WaitForAllElements) && IsTxFifoFull(Channel) )
1122  {
1123  break;
1124  }
1125 
1126  while(IsTxFifoFull(Channel));
1127 
1128  SSIDR(Channel)->DATA = *((uint32_t*)Buffer) & oC_Bits_Mask_U32(0 , 15);
1129  }
1130 
1131  errorCode = oC_ErrorCode_None;
1132  }
1133 
1134  return errorCode;
1135 }
1136 //==========================================================================================================================================
1141 //==========================================================================================================================================
1142 oC_ErrorCode_t oC_SPI_LLD_Read( oC_SPI_Channel_t Channel , void * outBuffer , oC_UInt_t BufferSize , oC_UInt_t ElementSize , oC_IoFlags_t IoFlags )
1143 {
1144  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1145  if(
1146  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
1147  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1148  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1149  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsEnabled(Channel) , oC_ErrorCode_ChannelOperationsNotEnabled) &&
1150  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outBuffer) , oC_ErrorCode_OutputAddressNotInRAM) &&
1151  oC_AssignErrorCodeIfFalse(&errorCode , BufferSize != 0 && ElementSize != 0 , oC_ErrorCode_SizeNotCorrect)
1152  )
1153  {
1154  void * endOutBuffer = outBuffer + (BufferSize * ElementSize);
1155 
1156  for(oC_uint32_t byteIndex = ElementSize , savedData = 0; outBuffer < endOutBuffer ; outBuffer++ , byteIndex++)
1157  {
1158  if(byteIndex == ElementSize)
1159  {
1160  if( oC_Bits_AreBitsClearU32(IoFlags,oC_IoFlags_WaitForAllElements) && IsRxFifoEmpty(Channel) )
1161  {
1162  break;
1163  }
1164 
1165  while(IsRxFifoEmpty(Channel));
1166 
1167  savedData = SSIDR(Channel)->DATA;
1168  byteIndex = 0;
1169  }
1170 
1171  if(byteIndex >= 2)
1172  {
1173  *(oC_uint8_t*)outBuffer = 0;
1174  }
1175  else
1176  {
1177 
1178  *(oC_uint8_t*)outBuffer = savedData >> (byteIndex * 8);
1179  }
1180  }
1181 
1182  errorCode = oC_ErrorCode_None;
1183  }
1184 
1185  return errorCode;
1186  }
1187 
1188 //==========================================================================================================================================
1193 //==========================================================================================================================================
1194 oC_ErrorCode_t oC_SPI_LLD_WriteWithDma( oC_SPI_Channel_t Channel , void * Buffer , oC_UInt_t Size , oC_UInt_t ElementSize , oC_IoFlags_t IoFlags )
1195 {
1196  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1197  oC_DMA_Channel_t channel = 0;
1198 
1199  if(
1200  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
1201  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1202  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1203  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsEnabled(Channel) , oC_ErrorCode_ChannelOperationsNotEnabled) &&
1204  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(Buffer) || IsRom(Buffer) , oC_ErrorCode_WrongAddress) &&
1205  oC_AssignErrorCodeIfFalse(&errorCode , Size != 0 , oC_ErrorCode_SizeNotCorrect) &&
1206  oC_AssignErrorCode(&errorCode , oC_DMA_LLD_FindFreeDmaChannelForPeripheralTrade(&channel,Channel,oC_Machine_DmaSignalType_TX) )
1207  )
1208  {
1209  oC_DMA_LLD_PeripheralTradeConfig_t dmaConfig;
1210 
1211  dmaConfig.Buffer = (void*)Buffer;
1212  dmaConfig.BufferSize = Size;
1213  dmaConfig.ElementSize = ElementSize;
1214  dmaConfig.PeripheralChannel = Channel;
1215  dmaConfig.PeripheralData = (void*)&SSIDR(Channel)->Value;
1216  dmaConfig.Priority = oC_DMA_LLD_Priority_Medium;
1217  dmaConfig.SignalType = oC_Machine_DmaSignalType_TX;
1218  dmaConfig.TransferCompleteEventHandler = NULL;
1219  dmaConfig.TransmitDirection = oC_DMA_LLD_Direction_Transmit;
1220 
1221  SSIDMACTL(Channel)->TXDMAE = 1;
1222 
1223  errorCode = oC_DMA_LLD_ConfigurePeripheralTrade(channel,&dmaConfig);
1224  }
1225 
1226  return errorCode;
1227 }
1228 //==========================================================================================================================================
1233 //==========================================================================================================================================
1234 oC_ErrorCode_t oC_SPI_LLD_ReadWithDma( oC_SPI_Channel_t Channel , void * outBuffer , oC_UInt_t Size , oC_UInt_t ElementSize , oC_IoFlags_t IoFlags )
1235 {
1236  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1237  oC_DMA_Channel_t channel = 0;
1238 
1239  if(
1240  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
1241  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1242  oC_AssignErrorCodeIfFalse(&errorCode , IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1243  oC_AssignErrorCodeIfFalse(&errorCode , AreChannelOperationsEnabled(Channel) , oC_ErrorCode_ChannelOperationsNotEnabled) &&
1244  oC_AssignErrorCodeIfFalse(&errorCode , IsRam(outBuffer) , oC_ErrorCode_OutputAddressNotInRAM) &&
1245  oC_AssignErrorCodeIfFalse(&errorCode , Size > 0 , oC_ErrorCode_SizeNotCorrect) &&
1246  oC_AssignErrorCode(&errorCode , oC_DMA_LLD_FindFreeDmaChannelForPeripheralTrade(&channel,Channel,oC_Machine_DmaSignalType_RX) )
1247  )
1248  {
1249  oC_DMA_LLD_PeripheralTradeConfig_t dmaConfig;
1250 
1251  dmaConfig.Buffer = (void*)outBuffer;
1252  dmaConfig.BufferSize = Size;
1253  dmaConfig.ElementSize = ElementSize;
1254  dmaConfig.PeripheralChannel = Channel;
1255  dmaConfig.PeripheralData = (void*)&SSIDR(Channel)->Value;
1256  dmaConfig.Priority = oC_DMA_LLD_Priority_Medium;
1257  dmaConfig.SignalType = oC_Machine_DmaSignalType_RX;
1258  dmaConfig.TransferCompleteEventHandler = NULL;
1259  dmaConfig.TransmitDirection = oC_DMA_LLD_Direction_Receive;
1260 
1261  SSIDMACTL(Channel)->RXDMAE = 1;
1262 
1263  errorCode = oC_DMA_LLD_ConfigurePeripheralTrade(channel,&dmaConfig);
1264  }
1265 
1266  return errorCode;
1267 }
1268 
1269 #undef _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
1270 
1271 #define ______________________________________LOCAL_FUNCTIONS_SECTION_______________________________________________________________________
1272 
1273 //==========================================================================================================================================
1278 //==========================================================================================================================================
1279 static oC_ErrorCode_t CalculateDivisorsAndWriteRegisters( oC_SPI_Channel_t Channel , oC_Frequency_t Frequency , oC_Frequency_t AcceptableDifference )
1280 {
1281  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1282 
1283  oC_Frequency_t systemClockFrequency = oC_CLOCK_LLD_GetClockFrequency();
1284 
1285  oC_Frequency_t minimumFrequency = oC_MACHINE_SPI_MINIMUM_TRANSMISION_FREQUENCY;
1286  oC_Frequency_t maximumFrequency = (oC_MACHINE_SPI_MAXIMUM_TRANSMISION_FREQUENCY <= (systemClockFrequency / 2)) ?
1287  oC_MACHINE_SPI_MAXIMUM_TRANSMISION_FREQUENCY : (systemClockFrequency / 2);
1288 
1289 
1290  oC_Frequency_t calculatedFrequency = oC_Hz(0);
1291 
1292  oC_uint16_t frequencyRatio = systemClockFrequency / (Frequency);
1293 
1294  oC_uint8_t CPSDVSR = 2;
1295  oC_uint8_t SCR = 0;
1296  errorCode = oC_ErrorCode_FrequencyNotPossible;
1297 
1298  while(CPSDVSR != 0)
1299  {
1300  (bool)(frequencyRatio / CPSDVSR - 1) ?
1301  ( SCR=0 ) : ( SCR = frequencyRatio / CPSDVSR - 1 );
1302 
1303  calculatedFrequency = systemClockFrequency / CPSDVSR * (1 + SCR);
1304 
1305  if( ( oC_ABS(calculatedFrequency,Frequency) > AcceptableDifference ) || (calculatedFrequency > maximumFrequency) )
1306  {
1307  CPSDVSR += 2;
1308  }
1309  else
1310  {
1311  if( (calculatedFrequency >= minimumFrequency) )
1312  {
1313  SSICPSR(Channel)->CPSDVSR = CPSDVSR;
1314  SSICR0(Channel)->SCR = SCR;
1315 
1316  errorCode = oC_ErrorCode_None;
1317  }
1318 
1319  break;
1320  }
1321  }
1322 
1323  return errorCode;
1324 }
1325 
1326 #undef ______________________________________LOCAL_FUNCTIONS_SECTION__________________________________________________________________________
oC_Power_On
Something is powered on.
Definition: oc_stdtypes.h:252
oc_math.h
Basic math operations.
ModuleEnabledFlag
static bool ModuleEnabledFlag
Definition: oc_memman.c:211
oC_Frequency_t
double oC_Frequency_t
type to store frequency
Definition: oc_frequency.h:76
oC_Bits_Mask_U32
#define oC_Bits_Mask_U32(FROM, TO)
Definition: oc_bits.h:73
oC_uint32_t
uint32_t oC_uint32_t
type for 32 bit unsigned integer
Definition: oc_stdtypes.h:56
oc_spi_lld.h
The file with LLD interface for the SPI driver.
oc_mem_lld.h
The file with LLD interface for the MEM driver.
oC_uint16_t
uint16_t oC_uint16_t
type for 16 bit unsigned integer
Definition: oc_stdtypes.h:48
oC_uint8_t
uint8_t oC_uint8_t
type for 8 bit unsigned integer
Definition: oc_stdtypes.h:40
oC_CLOCK_LLD_GetClockFrequency
oC_Frequency_t oC_CLOCK_LLD_GetClockFrequency(void)
returns frequency of the system clock
Definition: oc_clock_lld.c:237
oC_Power_Off
Something is powered off.
Definition: oc_stdtypes.h:251
oc_clock_lld.h
The file with LLD interface for the CLOCK driver.
oC_Channel_t
oC_Channel_t
stores machine channel
Definition: oc_channels.h:573
oC_Channel_IsCorrect
#define oC_Channel_IsCorrect(MODULE_NAME, Channel)
checks if channel is correct
Definition: oc_channels.h:283
oC_ABS
#define oC_ABS(A, B)
Definition: oc_math.h:46
oC_Bits_AreBitsClearU32
static bool oC_Bits_AreBitsClearU32(uint32_t BitMask, uint32_t BitsToCheck)
checks if all bits in field are clear
Definition: oc_bits.h:952
oC_Channel_FromIndex
#define oC_Channel_FromIndex(MODULE_NAME, ChannelIndex)
returns channel according to index in module
Definition: oc_channels.h:313
oC_ModuleChannel_NumberOfElements
#define oC_ModuleChannel_NumberOfElements(MODULE_NAME)
Number of elements in module channel.
Definition: oc_channels.h:465
oc_bits.h
The file with functions for the bits operation.
oc_array.h
Static array definitions.
oc_machine.h
The file with interface for the machine module.
oC_Machine_GetPowerStateForChannel
static oC_Power_t oC_Machine_GetPowerStateForChannel(oC_Channel_t Channel)
returns power state for channel
Definition: oc_machine.h:550
oC_Channel_ToIndex
#define oC_Channel_ToIndex(MODULE_NAME, Channel)
returns index in module according to channel
Definition: oc_channels.h:298
oC_Bits_SetBitU32
static uint32_t oC_Bits_SetBitU32(uint32_t *outVariable, uint8_t BitIndex)
sets bit in the variable
Definition: oc_bits.h:743
oc_dma_lld.h
The file with LLD interface for the DMA driver.
oC_Machine_SetPowerStateForChannel
static bool oC_Machine_SetPowerStateForChannel(oC_Channel_t Channel, oC_Power_t Power)
configures power state for machine channel
Definition: oc_machine.h:593
oC_Power_t
oC_Power_t
stores registers power state
Definition: oc_stdtypes.h:249
oC_MEM_LLD_IsRamAddress
bool oC_MEM_LLD_IsRamAddress(const void *Address)
checks if the pointer is in ram section
Definition: oc_mem_lld.c:400
NULL
#define NULL
pointer to a zero
Definition: oc_null.h:37
oC_Bits_ClearBitU32
static uint32_t oC_Bits_ClearBitU32(uint32_t *outVariable, uint8_t BitIndex)
clear selected bit
Definition: oc_bits.h:814