{        errnoSet(S_can_illegal_config);    }    else    {        value = pDev->pBrd->canInByte(pDev, SJA1000_SR);        if (value & SR_DOS)                            retCode = 1;                else            retCode = 0;    }    return retCode;}/************************************************************************** SJA1000_ClearMessageLost - Clear message lost indication ** This function clears data overrun flag for a particular channel* Valid only for channels with mode = WNCAN_CHN_RECEIVE** RETURNS:        OK or ERROR** ERRNO:          S_can_illegal_channel_no,*                 S_can_illegal_config**/static STATUS SJA1000_ClearMessageLost      (	  struct WNCAN_Device *pDev,	  UCHAR channelNum	  ){	STATUS retCode = ERROR;	    if (channelNum >= SJA1000_MAX_MSG_OBJ)    {        errnoSet(S_can_illegal_channel_no);    }    else if(pDev->pCtrl->chnMode[channelNum] != WNCAN_CHN_RECEIVE)    {        errnoSet(S_can_illegal_config);    }    else    {        /* clear data overrun */         pDev->pBrd->canOutByte(pDev, SJA1000_CMR, CMR_CDO);		 retCode = OK;    }    return retCode;}/************************************************************************* SJA1000_IsRTR - test if the RTR bit is set** This function tests if the message has the RTR bit set. The mode of the * channel must be WNCAN_CHN_TRANSMIT or WNCAN_CHN_RECEIVE* This function can be used on simple controllers such as the SJA1000 only** RETURNS:        0 if FALSE, 1 if TRUE, or -1 if ERROR*   * ERRNO:          S_can_illegal_channel_no,*                 S_can_illegal_channel_mode,**/static int SJA1000_IsRTR      (	  struct WNCAN_Device *pDev,	  UCHAR channelNum	  ){    int retCode = -1; /* pessimistic */    struct TxMsg *pTxMsg;	UCHAR value;    if (channelNum >= SJA1000_MAX_MSG_OBJ)    {        errnoSet(S_can_illegal_channel_no);    }    else if((pDev->pCtrl->chnMode[channelNum] != WNCAN_CHN_TRANSMIT) &&		    (pDev->pCtrl->chnMode[channelNum] != WNCAN_CHN_RECEIVE))    {        errnoSet(S_can_illegal_channel_mode);    }    else    {		if(pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_TRANSMIT)		{			pTxMsg = (struct TxMsg *)pDev->pCtrl->csData;			if(pTxMsg->rtr)				retCode = 1;			else				retCode = 0;		}		else		{			/* Read RTR field in the received channel hardware */			value = pDev->pBrd->canInByte(pDev,SJA1000_RXID+2);			if(value & 0x10)				retCode = 1;			else				retCode = 0;		}    }    return retCode;}/************************************************************************** SJA1000_SetRTR - set the RTR bit** This routine sets the RTR bit in the CAN message. The mode of the channel* must be WNCAN_CHN_TRANSMIT.** RETURNS:        OK, or ERROR*   * ERRNO:          S_can_illegal_channel_no,*                 S_can_illegal_channel_mode**/static STATUS SJA1000_SetRTR      (	  struct WNCAN_Device *pDev,	  UCHAR channelNum,	  BOOL rtr	  ){    STATUS retCode = ERROR; /* pessimistic */    struct TxMsg *pTxMsg;        if (channelNum >= SJA1000_MAX_MSG_OBJ)    {        errnoSet(S_can_illegal_channel_no);    }    else if(pDev->pCtrl->chnType[channelNum] != WNCAN_CHN_TRANSMIT)    {        errnoSet(S_can_illegal_channel_mode);            }    else    {        pTxMsg = (struct TxMsg *)pDev->pCtrl->csData;        pTxMsg->rtr = rtr;        retCode = OK;    }    return retCode;}/************************************************************************** SJA1000_TxAbort - abort the current CAN transmission** This routine aborts any current CAN transmissions on the controller.** RETURNS:        N/A** ERRNO:          N/A**/static void SJA1000_TxAbort      (	  struct WNCAN_Device *pDev	  ){    UCHAR value;    value = pDev->pBrd->canInByte(pDev, SJA1000_CMR);    pDev->pBrd->canOutByte(pDev, SJA1000_CMR, value | CMR_AT);    return;}/************************************************************************** SJA1000_Sleep - put the CAN controller to sleep.** This routine puts the CAN controller of the device into sleep mode* if the hardware supports this functionality; otherwise, this function* is a no-op.aborts any current CAN transmissions on the controller** RETURNS:        Ok or ERROR** ERRNO:          S_can_cannot_sleep_in_reset_mode**/static STATUS SJA1000_Sleep      (	  struct WNCAN_Device *pDev	  ){    UCHAR value;	STATUS retCode = ERROR;	/*Setting of the Sleep bit is not possible in reset mode	  Check if controller is in reset mode, if yes set error no and	  return error	 */	value = pDev->pBrd->canInByte(pDev, SJA1000_MOD);	if(value & MOD_RM)	{		errnoSet(S_can_cannot_sleep_in_reset_mode);		return retCode;		}	/*Set Sleep bit */    pDev->pBrd->canOutByte(pDev, SJA1000_MOD, value | MOD_SM);	retCode = OK;    return retCode;}/************************************************************************** SJA1000_WakeUp - brings CAN controller out of sleep mode** Auto awake feature is always enabled** RETURNS:        OK always*   * ERRNO:          N/A*/static STATUS SJA1000_WakeUp( struct WNCAN_Device *pDev ){        volatile UCHAR value;        /*Reset Sleep bit */    value = pDev->pBrd->canInByte(pDev, SJA1000_MOD);    /*MOD.4 is sleep bit*/    value &= ~(MOD_SM);    pDev->pBrd->canOutByte(pDev, SJA1000_MOD, value);        return OK;    }/************************************************************************** SJA1000_EnableChannel -  enable channel and set interrupts*                           * This function marks the channel valid. It also sets the type of channel* interrupt requested. If the channel type does not match the type of* interrupt requested it returns an error.** RETURNS: OK if successful, ERROR otherwise*   * ERRNO: S_can_illegal_channel_no*        S_can_illegal_config*        S_can_invalid_parameter*        S_can_incompatible_int_type**/static STATUS SJA1000_EnableChannel(    struct WNCAN_Device *pDev,    UCHAR                channelNum,    WNCAN_IntType        intSetting){    UCHAR  regVal;    STATUS retCode = ERROR; /* pessimistic */    if (channelNum >= SJA1000_MAX_MSG_OBJ)    {        errnoSet(S_can_illegal_channel_no);		return retCode;    }	regVal = pDev->pBrd->canInByte(pDev,SJA1000_IER);	switch(pDev->pCtrl->chnMode[channelNum]) {	case WNCAN_CHN_TRANSMIT:				if(intSetting == WNCAN_INT_RX)		{			errnoSet(S_can_incompatible_int_type);			return retCode;		}		if(intSetting == WNCAN_INT_TX)			regVal |= IER_TIE;		else			regVal &= ~(IER_TIE);							pDev->pBrd->canOutByte(pDev, SJA1000_IER, regVal);		retCode = OK;		break;	case WNCAN_CHN_RECEIVE:		if(intSetting == WNCAN_INT_TX)		{			errnoSet(S_can_incompatible_int_type);			return retCode;		}		if(intSetting == WNCAN_INT_RX)			regVal |= IER_RIE;		else			regVal &= ~(IER_RIE);				pDev->pBrd->canOutByte(pDev, SJA1000_IER, regVal);		retCode = OK;		break;    default:		 errnoSet(S_can_illegal_config);         break;	}    return retCode;}/************************************************************************** SJA1000_DisableChannel -  reset channel interrupts and mark channel*                           invalid** RETURNS: OK if successful, ERROR otherwise** ERRNO: S_can_illegal_channel_no*        S_can_illegal_config **/static STATUS SJA1000_DisableChannel(    struct WNCAN_Device *pDev,    UCHAR channelNum){    UCHAR  regVal;    STATUS retCode = ERROR; /* pessimistic */    if (channelNum >= SJA1000_MAX_MSG_OBJ)    {        errnoSet(S_can_illegal_channel_no);    }    else    {        regVal = pDev->pBrd->canInByte(pDev,SJA1000_IER);        switch(pDev->pCtrl->chnMode[channelNum])        {            case WNCAN_CHN_TRANSMIT:                regVal &= ~(IER_TIE);                retCode = OK;                break;            case WNCAN_CHN_RECEIVE:                regVal &= ~(IER_RIE);                pDev->pBrd->canOutByte(pDev, SJA1000_IER, regVal);                retCode = OK;                break;				            default:                errnoSet(S_can_illegal_config);                break;        }		pDev->pBrd->canOutByte(pDev, SJA1000_IER, regVal);    }    return retCode;}/******************************************************************************** SJA1000_WriteReg -  Access hardware register and write data** This function accesses the CAN controller memory at the offset specified. * A list of valid offsets are defined as macros in a CAN controller specific* header file, named as controllerOffsets.h (e.g. toucanOffsets.h or sja1000Offsets.h)* A pointer to the data buffer holding the data to be written is passed to the* function in UBYTE *data. The number of data bytes to be copied from the data* buffer to the CAN controller's memory area is specified by the length parameter.** RETURNS: OK or ERROR** ERRNO: S_can_illegal_offset**/static STATUS SJA1000_WriteReg      (	  struct WNCAN_Device *pDev,	  UINT offset,	  UCHAR * data,	  UINT length	  ){	STATUS retCode = ERROR;	UINT i;	if((offset + length) > SJA1000_MAX_OFFSET)		{		errnoSet(S_can_illegal_offset);				return retCode;	}	for(i=0;i<length;i++)	{		pDev->pBrd->canOutByte(pDev, (offset + i),data[i]);	}	retCode = OK;	return retCode;}/******************************************************************************** SJA1000_ReadReg -  Access hardware register and reads data** This function accesses the CAN controller memory at the offset specified. A list* of valid offsets are defined as macros in a CAN controller specific header file,* named as controllerOffsets.h (e.g. toucanOffsets.h or sja1000Offsets.h)* A pointer to the data buffer to hold the data to be read, is passed through * UINT *data. The length of the data to be copied is specified through the * length parameter.*** RETURNS: N/A** ERRNO: S_can_illegal_offset**/static STATUS SJA1000_ReadReg      (	  struct WNCAN_Device *pDev,	  UINT offset,	  UCHAR *data,	  UINT  length	  ){	UINT  i;	STATUS retCode = ERROR;		if(data == NULL) 	{		errnoSet(S_can_null_input_buffer);							return retCode;	}	if(offset > SJA1000_MAX_OFFSET)		{		errnoSet(S_can_illegal_offset);							return retCode;	}			for(i=0;i<length;i++)	{				data[i] = (UCHAR)pDev->pBrd->canInByte(pDev, (offset + i));								}	retCode = OK;	return retCode;}/************************************************************************** SJA1000_establishLinks -  set up function pointers in CAN_Device*** RETURNS: N/A** ERRNO: N/A**/void  SJA1000_establishLinks(struct WNCAN_Device *pDev){    /* it is assumed that the calling routine has checked       that pDev is not null */    pDev->Init              = SJA1000_Init;	pDev->Start             = SJA1000_Start;	pDev->Stop              = SJA1000_Stop;    pDev->SetBitTiming      = SJA1000_SetBitTiming;	pDev->GetBaudRate       = SJA1000_GetBaudRate;	pDev->SetIntMask        = SJA1000_SetIntMask;    pDev->EnableInt         = SJA1000_EnableInt;    pDev->DisableInt        = SJA1000_DisableInt;	pDev->GetBusStatus      = SJA1000_GetBusStatus;    pDev->GetBusError       = SJA1000_GetBusError;    pDev->ReadID            = SJA1000_ReadID;    pDev->WriteID           = SJA1000_WriteID;    pDev->ReadData          = SJA1000_ReadData;    pDev->GetMessageLength  = SJA1000_GetMessageLength;    pDev->WriteData         = SJA1000_WriteData;    pDev->Tx                = SJA1000_Tx;    pDev->TxMsg             = SJA1000_TxMsg;    pDev->SetGlobalRxFilter = SJA1000_SetGlobalRxFilter;    pDev->GetGlobalRxFilter = SJA1000_GetGlobalRxFilter;    pDev->SetLocalMsgFilter = SJA1000_SetLocalMsgFilter;    pDev->GetLocalMsgFilter = SJA1000_GetLocalMsgFilter;    pDev->GetIntStatus      = SJA1000_GetIntStatus;    pDev->IsMessageLost     = SJA1000_IsMessageLost;    pDev->ClearMessageLost  = SJA1000_ClearMessageLost;    pDev->IsRTR             = SJA1000_IsRTR;    pDev->SetRTR            = SJA1000_SetRTR;    pDev->TxAbort           = SJA1000_TxAbort;    pDev->Sleep             = SJA1000_Sleep;    pDev->WakeUp            = SJA1000_WakeUp;    pDev->EnableChannel     = SJA1000_EnableChannel;    pDev->DisableChannel    = SJA1000_DisableChannel;	pDev->WriteReg          = SJA1000_WriteReg;	pDev->ReadReg           = SJA1000_ReadReg;    return;}#endif