iLLD_TC27xC  1.0
IfxMultican_Can.c
Go to the documentation of this file.
1 /**
2  * \file IfxMultican_Can.c
3  * \brief MULTICAN CAN details
4  *
5  * \version iLLD_0_1_0_10
6  * \copyright Copyright (c) 2013 Infineon Technologies AG. All rights reserved.
7  *
8  *
9  * IMPORTANT NOTICE
10  *
11  *
12  * Infineon Technologies AG (Infineon) is supplying this file for use
13  * exclusively with Infineon's microcontroller products. This file can be freely
14  * distributed within development tools that are supporting such microcontroller
15  * products.
16  *
17  * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
18  * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
20  * INFINEON SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL,
21  * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
22  *
23  */
24 
25 /******************************************************************************/
26 /*----------------------------------Includes----------------------------------*/
27 /******************************************************************************/
28 
29 #include "IfxMultican_Can.h"
30 #include "Scu/Std/IfxScuCcu.h"
31 #include "_Reg/IfxScu_regdef.h"
32 
33 /******************************************************************************/
34 /*-------------------------Function Implementations---------------------------*/
35 /******************************************************************************/
36 
38 {
39  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, msgObj->msgObjId);
40 
41  Ifx_CAN_MO_AR ar;
42  Ifx_CAN_MO_AMR amr;
43  Ifx_CAN_MO_FCR fcr;
44 
45  ar.U = hwObj->AR.U;
46  amr.U = hwObj->AMR.U;
47  fcr.U = hwObj->FCR.U;
48 
49  // TODO: distinguish remote frame
50  config->frame = (hwObj->STAT.B.DIR != 0) ? IfxMultican_Frame_transmit : IfxMultican_Frame_receive;
51 
52  config->control.singleDataTransfer = fcr.B.SDT;
53  config->control.messageLen = (IfxMultican_DataLengthCode)fcr.B.DLC;
54  config->control.extendedFrame = ar.B.IDE;
55  config->control.matchingId = amr.B.MIDE;
56 
57  config->messageId = ar.B.ID >> ((config->control.extendedFrame != 0) ? 0 : 18);
58  config->priority = ar.B.PRI;
59  config->acceptanceMask = amr.B.AM >> ((config->control.extendedFrame != 0) ? 0 : 18);
60 
61  // TODO: check if these parameters are used:
62  //config->control.singleTransmitTrial = FALSE;
63  //config->firstId = 0;
64  //config->lastId = 0;
65 
66  // TODO: config->nodeId;
67 }
68 
69 
71 {
72  msgObj->node = config->node;
73  msgObj->msgObjId = config->msgObjId;
74  msgObj->msgObjCount = config->msgObjCount;
75  msgObj->fifoPointer = 0;
76 
77  Ifx_CAN *mcanSFR = msgObj->node->mcan;
78 
79  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(mcanSFR, msgObj->msgObjId);
80 
82 
83  boolean longFrame = (config->control.messageLen > IfxMultican_DataLengthCode_8) ? TRUE : FALSE;
84 
85  /* check for the receive frame */
86  boolean receiveFrame = (config->frame == IfxMultican_Frame_receive) ||
89 
90  /* check for the transmit frame */
91  boolean transmitFrame = ((config->frame == IfxMultican_Frame_transmit) ||
93  (config->frame == IfxMultican_Frame_remoteRequest)) &&
94  (config->gatewayTransfers != 1);
95 
96  /* check for gateway source object */
97  boolean gatewaySourceObj = (config->gatewayTransfers != 0) ? TRUE : FALSE;
98 
99  /* check for the receive FIFO and trabsmit FIFO */
100  boolean receiveFifo = FALSE, transmitFifo = FALSE;
101 
102  if (config->gatewayTransfers != 1)
103  {
104  receiveFifo = (config->msgObjCount > 1) && (receiveFrame);
105  transmitFifo = (config->msgObjCount > 1) && (transmitFrame);
106  }
107 
108  /* check for the gateway FIFO */
109  boolean gatewayFifo = (config->msgObjCount > 1) && (gatewaySourceObj);
110 
111  /* will be used for Fifo slave objects */
112  IfxMultican_MsgObjId objId, firstSlaveObjId, lastSlaveObjId, gatewayDstObjId = 0;
113 
114  /* select the first slave object */
115  if (!config->firstSlaveObjId)
116  { // if not selected
117  firstSlaveObjId = config->msgObjId + 1;
118  }
119  else
120  {
121  firstSlaveObjId = config->firstSlaveObjId;
122  }
123 
124  /* select the last slave object */
125  lastSlaveObjId = firstSlaveObjId + (config->msgObjCount - 1);
126 
127  uint32 i;
128 
129  /* for standard and FIFO (Tx & Rx) base objects */
130  {
131  /* MSGVAL: Set message as not valid */
133 
134  /* reset RXPND */
136 
137  /* reset TXPND */
139 
140  /* reset RXUPD */
142 
143  /* reset NEWDAT */
145 
146  /* reset MSGLST */
148 
149  /* reset RTSEL */
151 
152  /* reset RXPND */
154 
155  if ((config->frame == IfxMultican_Frame_receive) || (config->frame == IfxMultican_Frame_remoteAnswer))
156  {
157  /* set RXEN, in case of recieve frame or remote answer*/
159  }
160 
161  /* in case of transmit frame */
162  if ((transmitFrame) && (config->gatewayTransfers != 1))
163  {
164  /* set TXEN0 */
166 
167  /* set TXEN1 */
169 
170  /* reset RTSEL */
172 
173  /* MSGVAL: Set message as valid */
175  }
176 
177  if (((config->frame == IfxMultican_Frame_transmit) || (config->frame == IfxMultican_Frame_remoteAnswer)) && (config->gatewayTransfers != 1))
178  {
179  /* set DIR, in case of transmit frame or remote answer*/
181  }
182  else
183  {
184  /* clear DIR, in case of receive frame or gateway transfers*/
186  }
187  }
188  {
189  /* for standard message object */
190  if (config->msgObjCount == 1)
191  {
192  /* gateway transfers */
193  if (gatewaySourceObj)
194  {
195  /* select Gateway Source mode for FCR.MMC */
197 
198  /* select the gateway destination object as the next object if not selected */
199  if (!config->gatewayConfig.gatewayDstObjId)
200  {
201  gatewayDstObjId = msgObj->msgObjId + 1;
202  }
203  else
204  {
205  gatewayDstObjId = config->gatewayConfig.gatewayDstObjId;
206  }
207  }
208  /* long frame CAN FD */
209  /* FDEN = 1, EDL = 1 and BRS = 0/1 */
210  else if (config->node->fastNode && longFrame)
211  {
212  /* select CAN FD object mode for FCR.MMC */
214  }
215  /* standard frame */
216  /* FDEN = 0/1, EDL = 0 and BRS = 0 (BRS = 1 also has no effect here) */
217  else
218  {
219  /* select standard object for FCR.MMC */
221  }
222  }
223  /* for receive FIFO base object */
224  else if (receiveFifo)
225  {
226  /* select receive FIFO base object for FCR.MMC */
228  }
229  /* for transmit FIFO base object */
230  else if (transmitFifo)
231  {
232  /* select transmit FIFO base object for FCR.MMC */
234  }
235  /* for gateway FIFO source object */
236  else if (gatewayFifo)
237  {
238  /* select transmit Gateway Source for FCR.MMC */
240  }
241  else
242  {}
243 
244  /* for standard and FIFO (Tx & Rx) base objects */
245  /* enable receive interrupt FCR.RXIE if choosen in case of receive frame */
246  boolean receiveInterruptEnabled = (config->rxInterrupt.enabled) && (receiveFrame);
247  IfxMultican_MsgObj_setReceiveInterrupt(hwObj, receiveInterruptEnabled);
248 
249  /* enable transmit interrupt FCR.TXIE if choosen in case of transmit frame */
250  boolean transmitInterruptEnabled = (config->txInterrupt.enabled) && (transmitFrame);
251  IfxMultican_MsgObj_setTransmitInterrupt(hwObj, transmitInterruptEnabled);
252 
253  /* set FCR.RMM in case of remote answer */
254  boolean remoteMonitoringEnabled = (config->frame == IfxMultican_Frame_remoteAnswer);
255  IfxMultican_MsgObj_setRemoteMonitoring(hwObj, remoteMonitoringEnabled);
256 
257  /* long frame CAN FD */
258  /* FDEN = 1, EDL = 1 and BRS = 0/1 */
259  /* in case of recieve Msg Obj, it recieves long and long+fast frames */
260  if (config->node->fastNode && longFrame)
261  {
262  /* enable extended data length */
264 
265  /* set data length code FCR.DLC */
267 
268  /* set bit rate switch (fast bit rate enable/disable) */
270  }
271  /* standard frame */
272  /* FDEN = 0/1, EDL = 0 and BRS = 0 (BRS = 1 also has no effect here) */
273  /* in case of recieve Msg Obj, it recieves only standard frames */
274  else
275  {
276  /* set data length code FCR.DLC */
278  }
279 
280  /* only for standard message object */
281  if ((config->msgObjCount == 1) && (!gatewaySourceObj))
282  {
283  /* set single transmit trial FCR.STT if choosen */
285 
286  /* set single data transfer FCR.SDT if choosen */
288  }
289  /* for FIFO (Tx or Rx) base object and gateway objects*/
290  else
291  {
292  /* clear single transmit trial FCR.STT */
294 
295  /* clear single data transfer FCR.SDT */
297 
298  /* enable overflow interrupt FCR.OVIE,This interrupt request is generated */
299  /* on interrupt node TXINP if TXIE is enabled, in case of receive FIFO */
300  /* on interrupt node RXINP if RXIE is enabled, in case of transmit FIFO */
301 // IfxMultican_MsgObj_setOverflowInterrupt(hwObj, TRUE);
302  }
303  }
304 
305  {
306  /* for standard message object */
307  if (config->msgObjCount == 1)
308  {
309  /* long frame CAN FD */
310  if (longFrame)
311  {
312  /* set bottom pointer FGPR.BOT */
314 
315  /* set top pointer FGPR.TOP */
317  }
318  /* standard gateway transfers */
319  else if (gatewaySourceObj)
320  {
321  /* set (current pointer) FGPR.CUR, to gateway destination object */
322  IfxMultican_MsgObj_setCurrentObjectPointer(hwObj, gatewayDstObjId);
323  }
324  /* standard frame */
325  else
326  {
327  /* clear all pointers */
329  }
330  }
331 
332  /* for FIFO (Tx or Rx) base object and gateway FIFO object */
333  else
334  {
335  /* set bottom pointer FGPR.BOT, to the next message object (first FIFO slave object) */
336  IfxMultican_MsgObj_setBottomObjectPointer(hwObj, firstSlaveObjId);
337 
338  /* store the first slave object Id as the fifoPointer in msgObj structure for FIFO transfers */
339  msgObj->fifoPointer = firstSlaveObjId;
340 
341  /* set top pointer FGPR.TOP, to the last FIFO slave object */
342  IfxMultican_MsgObj_setTopObjectPointer(hwObj, lastSlaveObjId);
343 
344  /* set start of FIFO (current pointer) FGPR.CUR, to first FIFO slave object (bottom pointer) */
345  IfxMultican_MsgObj_setCurrentObjectPointer(hwObj, firstSlaveObjId);
346 
347  if (receiveFifo || transmitFifo)
348  {
349  /* set select object pointer FGPR.SEL to one object before last FIFO slave object */
350  IfxMultican_MsgObj_setSelectObjectPointer(hwObj, lastSlaveObjId - 1);
351  }
352  }
353  }
354 
355  {
356  /* for standard, gateway and FIFO (Tx & Rx) base objects */
357  /* set the given acceptance mask */
359 
360  /* enable matching ID if choosen */
362  }
363 
364  {
365  /* for standard, gateway and FIFO (Tx & Rx) base objects */
366  /* set message ID */
368 
369  /* set identifier extension if extended frame is choosen */
371 
372  /* set filtering priority */
374  }
375 
376  /* for standard, gateway and FIFO (Tx & Rx) base objects */
377  /* clear both data registers DATAL and DATAH */
379 
380  {
381  /* for standard, gateway and FIFO (Tx & Rx) base objects */
382  /* select IPR.RXINP */
384 
385  /* select IPR.TXINP */
387 
388  /* set IPR.MNP */
390  }
391 
392  /* for each receive FIFO slave object */
393  if (receiveFifo)
394  {
395  for (i = 0; i < config->msgObjCount; i++)
396  {
397  objId = firstSlaveObjId + i; /* increment the message object ID */
398 
399  Ifx_CAN_MO *hwSlaveObj = IfxMultican_MsgObj_getPointer(mcanSFR, objId);
400 
401  /* clear all RXEN flag */
403 
404  /* set data length code */
406 
407  /* clear DATAL and DATAH registers */
409  }
410  }
411 
412  /* for each transmit FIFO slave object */
413  if (transmitFifo)
414  {
415  /* configure each transmit FIFO slave object as an independent transmit object */
416  for (i = 0; i < config->msgObjCount; i++)
417  {
418  objId = firstSlaveObjId + i; /* increment the message object ID */
419 
420  Ifx_CAN_MO *hwSlaveObj = IfxMultican_MsgObj_getPointer(mcanSFR, objId);
421 
422  /* set message mode as transmit FIFO slave mode */
424 
425  /* point current pointer(FGPR.CUR) back to the base FIFO object */
427 
428  /* set data length code */
430 
431  /* clear DATAL and DATAH registers */
433 
434  /* set the given acceptance mask */
436 
437  /* enable matching ID if choosen */
439 
440  /* set message ID */
441  IfxMultican_MsgObj_setMessageId(hwSlaveObj, config->messageId, config->control.extendedFrame);
442 
443  /* set identifier extension if extended frame is choosen */
445 
446  /* set filtering priority */
447  IfxMultican_MsgObj_setPriorityClass(hwSlaveObj, config->priority);
448 
449  /* set TXEN0 */
451 
452  /* clear all TXEN1 flags expect for the slave object in the FGPR.CUR of the base FIFO object */
453  if (objId == firstSlaveObjId)
454  {
456  }
457  else
458  {
460  }
461 
462  /* set DIR, in case of transmit frame or remote answer*/
463  if ((config->frame == IfxMultican_Frame_transmit) || (config->frame == IfxMultican_Frame_remoteAnswer))
464  {
466  }
467  }
468  }
469 
470  {
471  /* for standard, gateway and FIFO (Tx & Rx) base objects */
472  /* Configuration of the CAN Message Object List Structure */
473  /* Allocate MO for the node associated list */
474  /* Append message object to the end of the list */
475  IfxMultican_setListCommand(mcanSFR, 0x2, msgObj->node->nodeId + 1, msgObj->msgObjId);
476 
477  /* long frame CAN FD */
478  if (longFrame)
479  {
480  /* Allocate MO with extended Data fields slected by FGPR.B.TOP and FGPR.B.BOT, for the unallocated list (0) */
481  /* Append message object to the end of the list(0) */
482  IfxMultican_setListCommand(mcanSFR, 0x2, 0, config->control.topMsgObjId);
483  IfxMultican_setListCommand(mcanSFR, 0x2, 0, config->control.bottomMsgObjId);
484  }
485 
486  /* for all standard FIFO (Tx and Rx) and gateway FIFO slave objects */
487  if (config->msgObjCount > 1)
488  {
489  for (i = 0; i < config->msgObjCount; i++)
490  {
491  objId = firstSlaveObjId + i;
492 
493  IfxMultican_setListCommand(mcanSFR, 0x2, msgObj->node->nodeId + 1, objId);
494  }
495  }
496  }
497 
498  /* for standard and receive FIFO base objects */
499  if (config->frame == IfxMultican_Frame_receive)
500  {
501  /* set RTSEL */
503 
504  /* MSGVAL: Set message as valid */
506  }
507 
508  /* for each receive FIFO slave object */
509  if (config->msgObjCount > 1)
510  {
511  IfxMultican_MsgObjId nextFifoObj;
512 
513  for (i = 0; i < config->msgObjCount; i++)
514  {
515  objId = firstSlaveObjId + i;
516 
517  Ifx_CAN_MO *hwSlaveObj = IfxMultican_MsgObj_getPointer(mcanSFR, objId);
518 
519  /* for receive FIFO and gateway FIFO */
520  if (!transmitFifo)
521  {
522  /* MSGVAL: Set message as valid */
524  }
525 
526  /* for transmit FIFO and receive FIFO */
527  if (!gatewayFifo)
528  {
529  /* store the next FIFO object number in the bottom pointer (FGPR.BOT) of the current FIFO object (for ease of use in transfers)*/
530  /* if it is the last FIFO object */
531  if (i == (config->msgObjCount - 1))
532  { /* wrap around the FIFO by making the next pointer of last object as the first FIFO object */
533  nextFifoObj = firstSlaveObjId;
534  }
535  else
536  {
537  nextFifoObj = objId + 1;
538  }
539 
540  IfxMultican_MsgObj_setBottomObjectPointer(hwSlaveObj, nextFifoObj);
541  }
542  }
543  }
544 
545  if (gatewaySourceObj)
546  {
547  /* set FCR.DLCC if chosen*/
549 
550  /* set FCR.DATC if chosen*/
552 
553  /* set FCR.IDC if chosen*/
555 
556  /* set FCR.GDFS if chosen*/
558  }
559 
560  return status;
561 }
562 
563 
565 {
566  // @$GENTABLE(MsgObjConfig,defaultConfig);
567 
568  config->node = node;
569  config->msgObjId = 0;
570  config->msgObjCount = 1;
571 
573 
574  config->control.topMsgObjId = 252;
575  config->control.bottomMsgObjId = 253;
576  config->control.fastBitRate = FALSE; /* fast bit rate enable/disable */
577 
578  config->control.extendedFrame = FALSE;
579  config->control.matchingId = FALSE;
580  config->control.singleDataTransfer = FALSE;
582  config->acceptanceMask = 0x7FFFFFFFUL;
583  config->messageId = 0;
584 
587  config->rxInterrupt.enabled = FALSE;
588  config->rxInterrupt.srcId = 0;
589  config->txInterrupt.enabled = FALSE;
590  config->txInterrupt.srcId = 0;
591 
592  config->firstSlaveObjId = 0;
593 
594  config->gatewayTransfers = FALSE;
596  config->gatewayConfig.copyData = TRUE;
597  config->gatewayConfig.copyId = TRUE;
599  config->gatewayConfig.gatewayDstObjId = 0;
600 }
601 
602 
604 {
605  if (msgObj->msgObjCount > 1)
606  {
607  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, msgObj->fifoPointer);
608  return IfxMultican_MsgObj_isRxPending(hwObj);
609  }
610  else
611  {
612  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, msgObj->msgObjId);
613  return IfxMultican_MsgObj_isRxPending(hwObj);
614  }
615 }
616 
617 
619 {
620  if (msgObj->msgObjCount > 1)
621  {
622  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, msgObj->fifoPointer);
623 
624  return IfxMultican_MsgObj_isTxPending(hwObj);
625  }
626  else
627  {
628  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, msgObj->msgObjId);
629 
630  return IfxMultican_MsgObj_isTxPending(hwObj);
631  }
632 }
633 
634 
636 {
638  IfxMultican_MsgObjId objId;
639 
640  if (msgObj->msgObjCount > 1)
641  {
642  /* for FIFO message Objects */
643  objId = msgObj->fifoPointer;
644  }
645  else
646  {
647  /* for standard message Objects */
648  objId = msgObj->msgObjId;
649  }
650 
651  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, objId);
652 
653  /* clear pending flag */
655 
656  /* read the message object */
657  status = IfxMultican_MsgObj_readMessage(hwObj, msg);
658 
659  /* if successfull: */
660  if (status == IfxMultican_Status_noError)
661  {
662  if (msgObj->msgObjCount > 1)
663  {
664  /* set next message object(MOSTAT.PNEXT) of the current object as the next txFIFO slave object */
666  }
667  else
668  {}
669  }
670 
671  return status;
672 }
673 
674 
676 {
678  IfxMultican_MsgObjId objId;
679 
680  if (msgObj->msgObjCount > 1)
681  {
682  /* for FIFO message Objects */
683  objId = msgObj->fifoPointer;
684 
685  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, msgObj->msgObjId);
686 
687  /* set message as valid, in case of FIFO mSGVAL has to be set before setting it to each slave object */
689  }
690  else
691  {
692  /* for standard message Objects */
693  objId = msgObj->msgObjId;
694  }
695 
696  Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(msgObj->node->mcan, objId);
697 
698  /* send the message */
699  status = IfxMultican_MsgObj_sendMessage(hwObj, msg);
700 
701  /* if successfull: */
702  if (status == IfxMultican_Status_noError)
703  {
704  if (msgObj->msgObjCount > 1)
705  {
706  /* set next message object(MOSTAT.PNEXT) of the current object as the next txFIFO slave object */
708  }
709  else
710  {}
711  }
712 
713  return status;
714 }
715 
716 
718 {
719  Ifx_CAN_N *hwNode = node->node;
720 
721  IfxMultican_Can mcan;
722 
723  mcan.mcan = node->mcan;
724 
726 
727  IfxMultican_calcTimingFromBTR(fcan, hwNode->BTR.U, &config->baudrate, &config->samplePoint, &config->synchJumpWidth);
728 
729  config->loopBackMode = (hwNode->PCR.B.LBM != 0) ? TRUE : FALSE;
730  config->analyzerMode = (hwNode->CR.B.CALM != 0) ? TRUE : FALSE;
731 
732  //config->rxPin; // TODO
733  //config->txPin; // TODO
734 }
735 
736 
738 {
739  Ifx_CAN_N *hwNode = IfxMultican_Node_getPointer(config->module, config->nodeId);
741 
742  node->mcan = config->module;
743  node->node = hwNode;
744  node->nodeId = config->nodeId;
745  node->fastNode = FALSE;
746 
747  { /* Configure node control */
748  IfxMultican_Node_resetControlRegister(hwNode); // default value 0x00000041
749 // IfxMultican_Node_enableConfigurationChange(hwNode);
755  }
756 
757  { /* Configure the interrupt source to service request node */
758  IfxMultican_Node_resetInterruptPointers(hwNode); // default value 0x00000041
764  }
765 
766  { /* NECNT write enabled only of NCR.CCE set */
771  }
772 
773  { /* NPCR write enabled only of NCR.CCE set */
775 
776  if (config->txPin != NULL_PTR)
777  {
778  status |= (IfxMultican_Node_initTxPin(hwNode, config->txPin, config->txPinMode));
779  }
780 
781  if (config->rxPin != NULL_PTR)
782  {
783  status |= (IfxMultican_Node_initRxPin(hwNode, config->rxPin, config->rxPinMode));
784  }
785  }
786 
787  {
788  IfxMultican_Can mcan;
789  mcan.mcan = node->mcan;
790 
792 
793  if (!config->flexibleDataRate)
794  {
795  IfxMultican_Node_setBitTiming(hwNode, fcan, config->baudrate, config->samplePoint, config->synchJumpWidth);
796  }
797  else
798  {
800  node->fastNode = TRUE;
801 
804 
805  if (config->fdConfig.loopDelayOffset)
806  {
809  }
810  }
811  }
812 
813  { /* Configuration of the Frame Counter */
816  }
817 
818  /* Configuration of the TTCAN Functionality: Not implemented */
819 
820  return status;
821 }
822 
823 
825 {
826  config->module = mcan->mcan;
827 
828  config->nodeId = IfxMultican_NodeId_0;
829 
830  config->loopBackMode = FALSE;
831  config->analyzerMode = FALSE;
832 
833  config->baudrate = 500000;
834  config->samplePoint = 8000;
835  config->synchJumpWidth = 2000;
836 
837  config->flexibleDataRate = FALSE;
838 
839  config->fdConfig.nominalBaudrate = 500000;
840  config->fdConfig.nominalSynchJumpWidth = 8000;
841  config->fdConfig.nominalSamplePoint = 2000;
842  config->fdConfig.fastBaudrate = 1000000;
843  config->fdConfig.fastSynchJumpWidth = 8000;
844  config->fdConfig.fastSamplePoint = 2000;
845  config->fdConfig.loopDelayOffset = 0;
846 
847  config->rxPin = NULL_PTR;
849  config->txPin = NULL_PTR;
851 
852  config->transferInterrupt.enabled = FALSE;
853  config->transferInterrupt.srcId = 0;
854 
856  config->lastErrorCodeInterrupt.srcId = 0;
857 
858  config->alertInterrupt.enabled = FALSE;
859  config->alertInterrupt.srcId = 0;
860 
862  config->frameCounterInterrupt.srcId = 0;
863 
864  config->timerInterrupt.enabled = FALSE;
865  config->timerInterrupt.srcId = 0;
866 
867  config->errorWarningLevel = 96;
868 }
869 
870 
872 {
873  uint32 i, counter;
874 
875  for (counter = 1; counter < 256; counter = counter * 2)
876  {
877  node->node->ECNT.B.TEC = counter;
878  }
879 
880  for (i = 0; i < 10; ++i)
881  {
882  node->node->ECNT.B.TEC = ++counter;
883  }
884 }
885 
886 
888 {
889  config->clockSelect = IfxMultican_getInputClock(mcan->mcan);
890 
892  {
894 
895  uint16 dividerMode = IfxMultican_getFractionalDividerMode(mcan->mcan);
897 
898  if (dividerMode == 1)
899  {
900  config->moduleFreq = fsys / (1024 - stepValue);
901  }
902  else if (dividerMode == 2)
903  {
904  config->moduleFreq = (fsys * stepValue) / 1024;
905  }
906  else
907  {
908  config->moduleFreq = 0;
909  }
910  }
911  else if (config->clockSelect == IfxMultican_ClockSelect_fosc0)
912  {
914  }
915  else if (config->clockSelect == IfxMultican_ClockSelect_fErayPll)
916  {
918  }
919  else
920  {
921  config->moduleFreq = 0.0;
922  }
923 }
924 
925 
927 {
928  IfxMultican_Can_Config config;
929 
930  IfxMultican_Can_getConfig(mcan, &config);
931 
932  return config.moduleFreq;
933 }
934 
935 
937 {
938  Ifx_CAN *mcanSFR = config->module;
939 
940  mcan->mcan = mcanSFR;
941 
942  uint16 stepValue, dividerMode, i;
943 
945  {
946  {
947  uint32 stepN, stepF;
948  boolean normalDiv;
949  float32 freqN, freqF;
950 
952 
953  /* Normal divider mode */
954  stepN = (uint32)__minf(__maxf(0, 1024.0 - (fsys / config->moduleFreq)), 1023);
955  freqN = fsys / (1024 - stepN);
956 
957  /* Fractional divider mode */
958  stepF = (uint32)__minf(((config->moduleFreq * 1024) / fsys), 1023);
959  freqF = (fsys * stepF) / 1024;
960 
961  normalDiv = (__absf(config->moduleFreq - freqN) <= __absf(config->moduleFreq - freqF));
962 
963  stepValue = (normalDiv != 0) ? stepN : stepF;
964  dividerMode = (normalDiv != 0) ? 1 : 2;
965  }
966 
969 
970  /* Enable module, disregard Sleep Mode request */
971  IfxMultican_enableModule(mcanSFR);
973 
974  /* Wait until module is enabled */
975  while (IfxMultican_isModuleEnabled(mcanSFR) == FALSE)
976  {}
977 
978  /* Select the clock input, two writes to the CLKSEL are always necessary */
980  IfxMultican_setInputClock(mcanSFR, IfxMultican_ClockSelect_fclc); /* Selects Fclc = Fspb */
981 
982  IfxMultican_setFractionalDividerStepValue(mcanSFR, stepValue);
983  IfxMultican_setFractionalDividerMode(mcanSFR, dividerMode);
984  IfxScuWdt_setCpuEndinit(passwd);
985  }
986  else
987  {}
988 
990 
991 #if 0
992  // TODO
993 
994  /* deinitialise all nodes */
995  {
996  for (i = 0; i < IFXMULTICAN_NODE_COUNT; i++)
997  {
999  }
1000  }
1001 
1002  /* deinitialise all message objects */
1003  for (i = 0; i < IFXMULTICAN_MO_COUNT; i++)
1004  {
1005  IfxMultican_MsgObj_deinit(mcan, i);
1006  }
1007 
1008 #endif
1009 
1010  /* deinitialise all pending bits */
1011  for (i = 0; i < 8; i++)
1012  {
1014  }
1015 
1016  /* The position is simply given by the message pending number MPN */
1018 
1019  /* All MO contribute to the calculation of the Message index */
1020  IfxMultican_setMessageIndexMask(mcanSFR, 0xFFFFFFFF);
1021 
1022  /* Configure interrupt node pointers */
1023  IfxMultican_SrcId srcId;
1024 
1025  for (srcId = 0; srcId < IFXMULTICAN_SRC_COUNT; srcId++)
1026  {
1027  volatile Ifx_SRC_SRCR *srcPointer = IfxMultican_getSrcPointer(mcanSFR, srcId);
1028  IfxSrc_init(srcPointer, config->nodePointer[srcId].typeOfService, config->nodePointer[srcId].priority);
1029 
1030  if (config->nodePointer[srcId].priority)
1031  {
1032  IfxSrc_enable(srcPointer);
1033  }
1034  else
1035  {
1036  IfxSrc_disable(srcPointer);
1037  }
1038  }
1039 
1041 }
1042 
1043 
1045 {
1046  IfxMultican_SrcId srcId;
1047  /** - take over module pointer */
1048  config->module = mcan;
1049 
1050  /** - Selected input clock is from CLC */
1052 
1053  /** - Module frequency is fSPB */
1055 
1056  for (srcId = 0; srcId < IFXMULTICAN_SRC_COUNT; srcId++)
1057  {
1058  config->nodePointer[srcId].priority = 0;
1059  config->nodePointer[srcId].typeOfService = IfxSrc_Tos_cpu0;
1060  }
1061 }