--- /dev/null
+/* -------------------------------- Arctic Core ------------------------------\r
+ * Arctic Core - the open source AUTOSAR platform http://arccore.com\r
+ *\r
+ * Copyright (C) 2009 ArcCore AB <contact@arccore.com>\r
+ *\r
+ * This source code is free software; you can redistribute it and/or modify it\r
+ * under the terms of the GNU General Public License version 2 as published by the\r
+ * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.\r
+ *\r
+ * This program is distributed in the hope that it will be useful, but\r
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\r
+ * for more details.\r
+ * -------------------------------- Arctic Core ------------------------------*/\r
+\r
+#include "Lin.h"\r
+#include "LinIf_Cbk.h"\r
+#include "mpc55xx.h"\r
+#include "Det.h"\r
+#include "Mcu.h"\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include "LinIf_Cbk.h"\r
+#include "Os.h"\r
+#include "isr.h"\r
+#include "irq.h"\r
+#include "arc.h"\r
+\r
+#define LIN_MAX_MSG_LENGTH 8\r
+\r
+#define LINFLEX(exp) (volatile struct LINFLEX_tag *)(0xFFE40000 + (0x4000 * exp))\r
+\r
+/* LIN145: Reset -> LIN_UNINIT: After reset, the Lin module shall set its state to LIN_UNINIT. */\r
+static Lin_DriverStatusType LinDriverStatus = LIN_UNINIT;\r
+\r
+static Lin_StatusType LinChannelStatus[LIN_CONTROLLER_CNT];\r
+static Lin_StatusType LinChannelOrderedStatus[LIN_CONTROLLER_CNT];\r
+\r
+/* static buffers, holds one frame at a time */\r
+static uint8 LinBufTx[LIN_CONTROLLER_CNT][LIN_MAX_MSG_LENGTH];\r
+static uint8 LinBufRx[LIN_CONTROLLER_CNT][LIN_MAX_MSG_LENGTH];\r
+\r
+typedef volatile union {\r
+ vuint16_t R;\r
+ struct {\r
+ vuint16_t LINS:4;\r
+ vuint16_t:2;\r
+ vuint16_t RMB:1;\r
+ vuint16_t:1;\r
+ vuint16_t RBSY:1; // LCH vuint16_t RXBUSY:1;\r
+ vuint16_t RPS:1; // LCH vuint16_t RDI:1;\r
+ vuint16_t WUF:1;\r
+ vuint16_t DBFF:1;\r
+ vuint16_t DBEF:1;\r
+ vuint16_t DRF:1;\r
+ vuint16_t DTF:1;\r
+ vuint16_t HRF:1;\r
+ } B;\r
+} LinSRtype; /* LINFLEX LIN Status Register */\r
+\r
+typedef volatile union {\r
+ vuint16_t R;\r
+ struct {\r
+ vuint16_t SZF:1;\r
+ vuint16_t OCF:1;\r
+ vuint16_t BEF:1;\r
+ vuint16_t CEF:1;\r
+ vuint16_t SFEF:1;\r
+ vuint16_t SDEF:1;\r
+ vuint16_t IDPEF:1;\r
+ vuint16_t FEF:1;\r
+ vuint16_t BOF:1;\r
+ vuint16_t:6;\r
+ vuint16_t NF:1;\r
+ } B;\r
+} LinESRType; /* LINFLEX LIN Error Status Register */\r
+\r
+\r
+/* Development error macros. */\r
+#if ( LIN_DEV_ERROR_DETECT == STD_ON )\r
+#define VALIDATE(_exp,_api,_err ) \\r
+ if( !(_exp) ) { \\r
+ Det_ReportError(MODULE_ID_LIN,0,_api,_err); \\r
+ return; \\r
+ }\r
+\r
+#define VALIDATE_W_RV(_exp,_api,_err,_rv ) \\r
+ if( !(_exp) ) { \\r
+ Det_ReportError(MODULE_ID_LIN,0,_api,_err); \\r
+ return (_rv); \\r
+ }\r
+#else\r
+#define VALIDATE(_exp,_api,_err )\r
+#define VALIDATE_W_RV(_exp,_api,_err,_rv )\r
+#endif\r
+\r
+static void ResyncDriver(uint8 Channel)\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+\r
+ /* Disable tx irq */\r
+ /* Disable Rx Interrupt */\r
+ /* Disable Rx Interrupt */\r
+\r
+ /* Disable transmitter and receiver. */\r
+\r
+ /* Clear flags */\r
+\r
+ /* Prepare module for resynchronization. */\r
+ /* LIN Resynchronize. First set then cleared. */\r
+ /* Resynchronize module. */\r
+ /* LIN Resynchronize. First set then cleared. */\r
+\r
+ /* Enable transmitter and receiver. */\r
+\r
+ /* Clear set flags again */\r
+}\r
+\r
+\r
+void LinInterruptRx(uint8 Channel)\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+\r
+ if (LinChannelStatus[Channel]==LIN_RX_BUSY) {\r
+ if (1 == LINFLEXHw->LINSR.B.DRF) {\r
+ /* Clear flags */\r
+ LINFLEXHw->LINSR.B.DRF = 1;\r
+\r
+ /* receive complete */\r
+ LinChannelStatus[Channel] = LIN_RX_OK;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* error */\r
+ }\r
+}\r
+\r
+void LinInterruptTx(uint8 Channel)\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+\r
+ if (LinChannelStatus[Channel]==LIN_TX_BUSY) {\r
+ if (1 == LINFLEXHw->LINSR.B.DTF) {\r
+ /* Clear flags */\r
+ LINFLEXHw->LINSR.B.DTF = 1;\r
+\r
+ /* receive complete */\r
+ LinChannelStatus[Channel] = LIN_TX_OK;\r
+ }\r
+ }\r
+ else{\r
+ /* error */\r
+ }\r
+\r
+}\r
+\r
+void LinInterruptErr(uint8 Channel)\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+\r
+ /* Error handling */\r
+ static uint32 errCnt=0;\r
+ errCnt++;\r
+ if(LinChannelStatus[Channel]==LIN_RX_BUSY){\r
+ LinChannelStatus[Channel] = LIN_RX_ERROR;\r
+ }else if (LinChannelStatus[Channel]==LIN_TX_BUSY){\r
+ LinChannelStatus[Channel] = LIN_TX_ERROR;\r
+ }\r
+\r
+ /* Clear flags */\r
+ LINFLEXHw->LINESR.R=0xffffffff;\r
+}\r
+\r
+static void LinInterruptRxA(){LinInterruptRx(LIN_CTRL_A);}\r
+static void LinInterruptTxA(){LinInterruptTx(LIN_CTRL_A);}\r
+static void LinInterruptErrA(){LinInterruptErr(LIN_CTRL_A);}\r
+\r
+static void LinInterruptRxB(){LinInterruptRx(LIN_CTRL_B);}\r
+static void LinInterruptTxB(){LinInterruptTx(LIN_CTRL_B);}\r
+static void LinInterruptErrB(){LinInterruptErr(LIN_CTRL_B);}\r
+\r
+void Lin_Init( const Lin_ConfigType* Config )\r
+{\r
+ (void)Config;\r
+ uint8 i;\r
+\r
+ VALIDATE( (LinDriverStatus == LIN_UNINIT), LIN_INIT_SERVICE_ID, LIN_E_STATE_TRANSITION );\r
+ /* VALIDATE( (Config!=0), LIN_INIT_SERVICE_ID, LIN_E_INVALID_POINTER ); */\r
+\r
+ for (i=0;i<LIN_CONTROLLER_CNT;i++)\r
+ {\r
+ /* LIN171: On entering the state LIN_INIT, the Lin module shall set each channel into\r
+ * state LIN_CH_UNINIT. */\r
+ LinChannelStatus[i] = LIN_CH_UNINIT;\r
+ LinChannelOrderedStatus[i]=LIN_CH_OPERATIONAL;\r
+ }\r
+\r
+ /* LIN146: LIN_UNINIT -> LIN_INIT: The Lin module shall transition from LIN_UNINIT\r
+ * to LIN_INIT when the function Lin_Init is called. */\r
+ LinDriverStatus = LIN_INIT;\r
+}\r
+\r
+void Lin_DeInit()\r
+{\r
+ LinDriverStatus = LIN_UNINIT;\r
+}\r
+\r
+void Lin_WakeupValidation( void )\r
+{\r
+\r
+}\r
+\r
+void Lin_InitChannel( uint8 Channel, const Lin_ChannelConfigType* Config )\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+ enum\r
+ {\r
+ LIN_PRIO = 3\r
+ };\r
+\r
+ VALIDATE( (Config!=0), LIN_INIT_CHANNEL_SERVICE_ID, LIN_E_INVALID_POINTER );\r
+ VALIDATE( (LinDriverStatus != LIN_UNINIT), LIN_INIT_CHANNEL_SERVICE_ID, LIN_E_UNINIT );\r
+ VALIDATE( (Channel < LIN_CONTROLLER_CNT), LIN_INIT_CHANNEL_SERVICE_ID, LIN_E_INVALID_CHANNEL );\r
+\r
+ /* Install the interrupt */\r
+ switch(Channel){\r
+ case 0:\r
+ ISR_INSTALL_ISR2("LinIsrRxA", LinInterruptRxA, (IrqType)(LINFLEX_0_RXI),LIN_PRIO, 0);\r
+ ISR_INSTALL_ISR2("LinIsrTxA", LinInterruptTxA, (IrqType)(LINFLEX_0_TXI),LIN_PRIO, 0);\r
+ ISR_INSTALL_ISR2("LinIsrErrA", LinInterruptErrA, (IrqType)(LINFLEX_0_ERR),LIN_PRIO, 0);\r
+ break;\r
+ case 1:\r
+ ISR_INSTALL_ISR2("LinIsrRxB", LinInterruptRxB, (IrqType)(LINFLEX_1_RXI),LIN_PRIO, 0);\r
+ ISR_INSTALL_ISR2("LinIsrTxB", LinInterruptTxB, (IrqType)(LINFLEX_1_TXI),LIN_PRIO, 0);\r
+ ISR_INSTALL_ISR2("LinIsrErrB", LinInterruptErrB, (IrqType)(LINFLEX_1_ERR),LIN_PRIO, 0);\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+\r
+ /* configure and enable channel */\r
+ LINFLEXHw->LINCR1.R = 0; /* Reset all bits */\r
+ LINFLEXHw->LINCR1.B.INIT = 1; /* Go to init mode */\r
+ LINFLEXHw->LINCR1.B.MBL = 3; /* 13 bit synch */\r
+ LINFLEXHw->LINCR1.B.MME = 3; /* Master mode */\r
+\r
+ LINFLEXHw->LINIER.R = 0; /* Reset all bits */\r
+ LINFLEXHw->LINIER.B.BEIE = 1; /* Bit error */\r
+ LINFLEXHw->LINIER.B.CEIE = 1; /* Checksum error */\r
+ LINFLEXHw->LINIER.B.HEIE = 1; /* Header error */\r
+ LINFLEXHw->LINIER.B.BOIE = 1; /* Buffer overrun error */\r
+ LINFLEXHw->LINIER.B.FEIE = 1; /* Framing error */\r
+\r
+ LINFLEXHw->LINIER.B.DRIE = 1; /* Data Reception Complete */\r
+ LINFLEXHw->LINIER.B.DTIE = 1; /* Data Transmitted */\r
+\r
+ /*\r
+ * Tx/ Rx baud = fperiph_set_1_clk / (16 × LFDIV)\r
+ *\r
+ * To program LFDIV = 25.62d,\r
+ * LINFBRR = 16 × 0.62 = 9.92, nearest real number 10d = 0xA\r
+ * LINIBRR = mantissa (25.620d) = 25d = 0x19\r
+ */\r
+ float lfdiv = (float)McuE_GetPeripheralClock( PERIPHERAL_CLOCK_LIN_A) / (float)((16*Config->LinChannelBaudRate));\r
+\r
+ LINFLEXHw->LINFBRR.B.DIV_F = (uint8)((lfdiv - (uint32)lfdiv) * 16); /* Fraction bits */\r
+ LINFLEXHw->LINIBRR.B.DIV_M = (uint16)lfdiv; /* Integer bits */\r
+\r
+ LINFLEXHw->LINCR2.R = 0; /* Reset all bits */\r
+ LINFLEXHw->LINCR2.B.IOBE = 1; /* Idle on bit error */\r
+ LINFLEXHw->LINCR2.B.IOPE = 1; /* Idle on parity error */\r
+\r
+ /* Status regs */\r
+ LINFLEXHw->LINSR.R = 0xffffffff; /* Reset all bits */\r
+ LINFLEXHw->LINESR.R = 0xffffffff; /* Reset all bits */\r
+\r
+ LINFLEXHw->LINCR1.B.INIT = 0; /* Go to normal mode */\r
+\r
+ LinChannelStatus[Channel]=LIN_CH_OPERATIONAL;\r
+}\r
+\r
+void Lin_DeInitChannel( uint8 Channel )\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+ VALIDATE( (Channel < LIN_CONTROLLER_CNT), LIN_DEINIT_CHANNEL_SERVICE_ID, LIN_E_INVALID_CHANNEL );\r
+\r
+ /* LIN178: The function Lin_DeInitChannel shall only be executable when the LIN\r
+ * channel state-machine is in state LIN_CH_OPERATIONAL. */\r
+ if(LinChannelStatus[Channel] != LIN_CH_UNINIT){\r
+ /* Disable */\r
+ LINFLEXHw->LINCR1.R = 0; /* Reset all bits */\r
+ LINFLEXHw->LINIER.R = 0; /* Reset all bits */\r
+ LINFLEXHw->LINSR.R = 0xffffffff; /* Reset all bits */\r
+ LINFLEXHw->LINESR.R = 0xffffffff; /* Reset all bits */\r
+\r
+ LinChannelStatus[Channel]=LIN_CH_UNINIT;\r
+ }\r
+}\r
+\r
+Std_ReturnType Lin_SendHeader( uint8 Channel, Lin_PduType* PduInfoPtr )\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+ imask_t state;\r
+\r
+ /* LIN021 */\r
+ Irq_Save(state);\r
+ if(LinChannelStatus[Channel] == LIN_TX_BUSY || LinChannelStatus[Channel] == LIN_TX_ERROR ||\r
+ LinChannelStatus[Channel] == LIN_RX_BUSY || LinChannelStatus[Channel] == LIN_RX_ERROR)\r
+ {\r
+ ResyncDriver(Channel);\r
+ LinChannelStatus[Channel]=LIN_CH_OPERATIONAL;\r
+ }\r
+ Irq_Restore(state);\r
+\r
+\r
+ VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_SEND_HEADER_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_SEND_HEADER_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_SEND_HEADER_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK);\r
+ /* Send header is used to wake the net in this implementation(no actual header is sent */\r
+ /* VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_SEND_HEADER_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK); */\r
+ VALIDATE_W_RV( (PduInfoPtr != NULL), LIN_SEND_HEADER_SERVICE_ID, LIN_E_INVALID_POINTER, E_NOT_OK);\r
+\r
+ /* Calculate the time out value for the frame.(10 × NDATA + 45) × 1.4 according to LIN1.3 */\r
+ uint16 timeOutValue = (uint16)( ( ( 10 * PduInfoPtr->DI + 45 ) * 14 ) / 10);\r
+\r
+ LINFLEXHw->BIDR.R = 0; /* Clear reg */\r
+\r
+ /* Checksum */\r
+ if (PduInfoPtr->Cs != LIN_ENHANCED_CS){ /*Frame identifiers 60 (0x3C) to 61 (0x3D) shall always use classic checksum */\r
+ LINFLEXHw->BIDR.B.CCS = 1;\r
+ }\r
+ /* Length */\r
+ LINFLEXHw->BIDR.B.DFL = PduInfoPtr->DI - 1;\r
+\r
+ /* Id */\r
+ LINFLEXHw->BIDR.B.ID = PduInfoPtr->Pid & 0x7f; /* Without parity bit */\r
+\r
+ /* Direction */\r
+ if (PduInfoPtr->Drc == LIN_MASTER_RESPONSE)\r
+ {\r
+ LINFLEXHw->BIDR.B.DIR = 1;\r
+\r
+ /* write to buffer reg */\r
+ for(int i = 0; i < PduInfoPtr->DI;i++)\r
+ {\r
+ /* convenient with freescale reg file */\r
+ switch(i)\r
+ {\r
+ case 0:\r
+ LINFLEXHw->BDRL.B.DATA0 = PduInfoPtr->SduPtr[0];\r
+ break;\r
+ case 1:\r
+ LINFLEXHw->BDRL.B.DATA1 = PduInfoPtr->SduPtr[1];\r
+ break;\r
+ case 2:\r
+ LINFLEXHw->BDRL.B.DATA2 = PduInfoPtr->SduPtr[2];\r
+ break;\r
+ case 3:\r
+ LINFLEXHw->BDRL.B.DATA3 = PduInfoPtr->SduPtr[3];\r
+ break;\r
+ case 4:\r
+ LINFLEXHw->BDRM.B.DATA4 = PduInfoPtr->SduPtr[4];\r
+ break;\r
+ case 5:\r
+ LINFLEXHw->BDRM.B.DATA5 = PduInfoPtr->SduPtr[5];\r
+ break;\r
+ case 6:\r
+ LINFLEXHw->BDRM.B.DATA6 = PduInfoPtr->SduPtr[6];\r
+ break;\r
+ case 7:\r
+ LINFLEXHw->BDRM.B.DATA7 = PduInfoPtr->SduPtr[7];\r
+ break;\r
+ }\r
+ }\r
+\r
+ LinChannelStatus[Channel]=LIN_TX_BUSY;\r
+ }\r
+ else\r
+ {\r
+ LinChannelStatus[Channel]=LIN_RX_BUSY;\r
+ }\r
+\r
+ /* Request transmission of header */\r
+ LINFLEXHw->LINCR2.B.HTRQ = 1;\r
+\r
+ return E_OK;\r
+}\r
+\r
+Std_ReturnType Lin_SendResponse( uint8 Channel, Lin_PduType* PduInfoPtr )\r
+{\r
+ VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK);\r
+ VALIDATE_W_RV( (PduInfoPtr != NULL), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_INVALID_POINTER, E_NOT_OK);\r
+\r
+ /* The response is sent from within the header in this implementation since this is a master only implementation */\r
+ return E_OK;\r
+}\r
+\r
+Std_ReturnType Lin_GoToSleep( uint8 Channel )\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+\r
+ VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK);\r
+\r
+ if (LinChannelOrderedStatus[Channel]!=LIN_CH_SLEEP){\r
+ LinChannelOrderedStatus[Channel]=LIN_CH_SLEEP;\r
+\r
+ LINFLEXHw->LINCR1.B.SLEEP = 1;\r
+\r
+ LINFLEXHw->LINIER.B.WUIE = 1; /* enable wake-up irq */\r
+ }\r
+ return E_OK;\r
+}\r
+\r
+Std_ReturnType Lin_GoToSleepInternal( uint8 Channel )\r
+{\r
+ VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK);\r
+ Lin_GoToSleep(Channel);\r
+ return E_OK;\r
+}\r
+\r
+Std_ReturnType Lin_WakeUp( uint8 Channel )\r
+{\r
+ volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel);\r
+\r
+ VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_WAKE_UP_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_WAKE_UP_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK);\r
+ VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_WAKE_UP_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] == LIN_CH_SLEEP), LIN_WAKE_UP_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK);\r
+\r
+ /* Disable wake interrupt */\r
+ LINFLEXHw->LINIER.B.WUIE = 0;\r
+ /* Clear sleep bit */\r
+ LINFLEXHw->LINCR1.B.SLEEP = 0;\r
+\r
+ LinChannelStatus[Channel]=LIN_CH_OPERATIONAL;\r
+ return E_OK;\r
+}\r
+\r
+Lin_StatusType Lin_GetStatus( uint8 Channel, uint8** Lin_SduPtr )\r
+{\r
+ VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GETSTATUS_SERVICE_ID, LIN_E_UNINIT, LIN_NOT_OK);\r
+ VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GETSTATUS_SERVICE_ID, LIN_E_CHANNEL_UNINIT, LIN_NOT_OK);\r
+ VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GETSTATUS_SERVICE_ID, LIN_E_INVALID_CHANNEL, LIN_NOT_OK);\r
+ VALIDATE_W_RV( (Lin_SduPtr!=NULL), LIN_GETSTATUS_SERVICE_ID, LIN_E_INVALID_POINTER, LIN_NOT_OK);\r
+\r
+ imask_t state;\r
+ Irq_Save(state);\r
+ Lin_StatusType res = LinChannelStatus[Channel];\r
+ /* We can only check for valid sdu ptr when LIN_RX_OK */\r
+ if(LinChannelStatus[Channel] == LIN_RX_OK || LinChannelStatus[Channel] == LIN_RX_ERROR){\r
+ *Lin_SduPtr = LinBufRx[Channel];\r
+ if(LinChannelStatus[Channel] == LIN_RX_ERROR){\r
+ ResyncDriver(Channel);\r
+ }\r
+ LinChannelStatus[Channel]=LIN_CH_OPERATIONAL;\r
+ } else if(LinChannelStatus[Channel] == LIN_TX_OK || LinChannelStatus[Channel] == LIN_TX_ERROR){\r
+ if(LinChannelStatus[Channel] == LIN_TX_ERROR){\r
+ ResyncDriver(Channel);\r
+ }\r
+ LinChannelStatus[Channel]=LIN_CH_OPERATIONAL;\r
+ }\r
+ Irq_Restore(state);\r
+ return res;\r
+}\r
+\r
+\r
+\r
+\r
+\r
projects / arc.git / commitdiff