sja1000.c

can总线c语言 canopen 源程序

*
* ERRNO:   N/A
*
*/
static void SJA1000_DisableInt(struct WNCAN_Device *pDev)
{
    int    oldLevel;

    oldLevel = intLock();
    pDev->pBrd->canOutByte(pDev, SJA1000_IER, 0);
    intUnlock(oldLevel);

    return;
}

/************************************************************************
*
* SJA1000_GetBusError - get the bus error
*
* This function returns an ORed bit mask of all the bus errors that have
* occured during the last bus activity.
* Bus errors returned by this function can have the following values:
* WNCAN_ERR_NONE: No errors detected
* WNCAN_ERR_BIT: Bit error. 
* WNCAN_ERR_ACK: Acknowledgement error. 
* WNCAN_ERR_CRC: CRC error
* WNCAN_ERR_FORM: Form error
* WNCAN_ERR_STUFF: Stuff error
* WNCAN_ERR_UNKNOWN: this condition should not occur
* The five errors are not mutually exclusive. 
* The occurence of an error will be indicated by an interrupt. Typically, 
* this function will be called from the error interrupt handling case in the
* user's ISR callback function, to find out the kind of error that occured
* on the bus.
*
* RETURNS: the bus error
*
* ERRNO: N/A
*
*/
static WNCAN_BusError SJA1000_GetBusError(struct WNCAN_Device *pDev)
{
    UCHAR value;
    WNCAN_BusError error=0;

    /* read the error code capture register */
    value = pDev->pBrd->canInByte(pDev, SJA1000_ECC);

    switch(value >> 6)
    {
        case 0:
            error |= WNCAN_ERR_BIT;
            break;
        case 1:
            error |= WNCAN_ERR_FORM;
            break;
        case 2:
            error |= WNCAN_ERR_STUFF;
            break;
        case 3:
            switch(value & 0x1F)
            {
                case 8:
                    error |= WNCAN_ERR_CRC;
                    break;
                case 24:
                    error |= WNCAN_ERR_CRC;
                    break;
                case 25:
                    error |= WNCAN_ERR_ACK;
                    break;
                case 27:
                    error |= WNCAN_ERR_ACK;
                    break;
                default:
                    error |= WNCAN_ERR_NONE;
                    break;
            }
            break;
    }
    return error;
}

/************************************************************************
*
* SJA1000_GetIntStatus - get the interrupt status on the controller
*
* This function returns the interrupt status on the controller: 
*
*    WNCAN_INT_NONE     = no interrupt occurred
*    WNCAN_INT_ERROR    = bus error
*    WNCAN_INT_TX       = interrupt resuting from a CAN transmission
*    WNCAN_INT_RX       = interrupt resulting form message reception
*    WNCAN_INT_BUS_OFF  = interrupt resulting from bus off condition
*    WNCAN_INT_WAKE_UP  = interrupt resulting from controller waking up
*                         after being put in sleep mode
*    WNCAN_INT_SPURIOUS = unknown interrupt
*
* NOTE: If the interrupt was caused by the transmission or reception of a 
* message, the channel number that generated the interrupt is set; otherwise,
* this value is undefined.
*
* ERRNO: N/A
*
*/
static WNCAN_IntType SJA1000_GetIntStatus
      (
	  struct WNCAN_Device *pDev,
	  UCHAR *channelNum
	  )
{
    UCHAR       regInt;
    WNCAN_IntType   intStatus=WNCAN_INT_NONE;
	UCHAR regStatus;

    /* read the interrupt register */
    regInt = pDev->pBrd->canInByte(pDev, SJA1000_IR);

	if(regInt & IR_RI) {
		/*receive interrupt*/
        intStatus = WNCAN_INT_RX;
        *channelNum = 0;
	}
	
	if( regInt & IR_TI) {
		/*transmit interrupt*/
        intStatus = WNCAN_INT_TX;
        *channelNum = 1;
	}

	if(regInt & IR_WUI)
	{
		intStatus = WNCAN_INT_WAKE_UP;
	}

	/*flag WNCAN_INT_ERROR, if data overrun error int, or
	  bus error int is detected */
	if(regInt & IR_BEI) {
		/*error interrupt*/
        intStatus = WNCAN_INT_ERROR;
	}

	if(regInt & IR_EI) {
		/*bus off interrupt*/
		/* read the status register */
        regStatus = pDev->pBrd->canInByte(pDev, SJA1000_SR);

		if(regStatus & SR_BS)
			intStatus = WNCAN_INT_BUS_OFF;
	}
	
    return intStatus;
}

/************************************************************************
*
* sja1000ISR - interrupt service routine
*
* RETURNS: N/A
*
* ERRNO: N/A
*
*/
void sja1000ISR(ULONG context)
{
    WNCAN_DEVICE     *pDev;
    WNCAN_IntType  intStatus=WNCAN_INT_NONE;
    UCHAR          chnNum;	


    pDev = (WNCAN_DEVICE *)context;

    /* notify board that we're entering isr */
    if(pDev->pBrd->onEnterISR)
        pDev->pBrd->onEnterISR(pDev);

    /* Get the interrupt status */
    intStatus = SJA1000_GetIntStatus((void*)context, &chnNum);

	 if (intStatus != WNCAN_INT_NONE)
	 {
		 
		 pDev->pISRCallback(pDev, intStatus, chnNum);
		 
		 if (intStatus == WNCAN_INT_RX)
		 {
			 /* release the receive buffer */
			 /* this will temporarily cleat RI bit */
			 pDev->pBrd->canOutByte(pDev, SJA1000_CMR, CMR_RRB);
		 }
		 else if (intStatus == WNCAN_INT_ERROR)
		 {
			 /* clear bei interrupt flag */
			 pDev->pBrd->canInByte(pDev, SJA1000_ECC);
		 }
	 }
	
	
    /* notify board that we're leaving isr */
    if(pDev->pBrd->onLeaveISR)
        pDev->pBrd->onLeaveISR(pDev);

   return;
}


/************************************************************************
*
* SJA1000_ReadID - read the CAN Id
*
* This function reads the CAN Id corresponding to the channel number on
* the controller. The standard or extended flag is set by the function.
* The mode of the channel cannot be WNCAN_CHN_INACTIVE or WNCAN_CHN_INVALID
*
* RETURNS:        LONG: the CAN Id; on error return -1
*
* ERRNO:          S_can_illegal_channel_no,
*                 S_can_illegal_config
*
*/
static long SJA1000_ReadID(struct WNCAN_Device *pDev, UCHAR channelNum, 
                           BOOL* ext)
{
    UCHAR           value;
    struct TxMsg    *pTxMsg;
    ULONG           msgID=0xffffffff;

    if (channelNum >= SJA1000_MAX_MSG_OBJ)
    {
        errnoSet(S_can_illegal_channel_no);
    }
    else if((pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INACTIVE) ||
            (pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INVALID))
    {
        errnoSet(S_can_illegal_config);
    }
    else
    {
        /* Set up frame and ID registers based on channel mode */
        if(pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_RECEIVE)
        {
            /* get the frame format */
            value = pDev->pBrd->canInByte(pDev, SJA1000_SFF);

            /* test if message ID is extended or standard */
            if (value & 0x80)
            {
                *ext = 1;
                value = pDev->pBrd->canInByte(pDev,SJA1000_RXID);
                msgID = (value << (24-3));

                value = pDev->pBrd->canInByte(pDev,SJA1000_RXID+1);
                msgID |= (value << (16-3));

                value = pDev->pBrd->canInByte(pDev,SJA1000_RXID+2);
                msgID |= (value << (8-3));

                value = pDev->pBrd->canInByte(pDev,SJA1000_RXID+3);
                msgID |= (value >> 3);
            }
            else
            {
                *ext = 0;
                value = pDev->pBrd->canInByte(pDev,SJA1000_RXID);
                msgID = (value << (8-5));
                value = pDev->pBrd->canInByte(pDev,SJA1000_RXID+1);
                msgID |= (value >> 5);
            }
        }
        else
        {
            pTxMsg = (struct TxMsg *)pDev->pCtrl->csData;
            *ext = pTxMsg->ext;
            msgID = pTxMsg->id;
        }
    }
    return ((long) msgID);
}

/************************************************************************
*
* SJA1000_WriteID - write the CAN Id to the channel number
*
* This function writes the CAN Id to the channel. The type of Id 
* (standard or extended) is specified. the behaviour of the function for
* every channel mode is specified as follows:
* WNCAN_CHN_INVALID: not allowed. ERROR is returned.
* WNCAN_CHN_INACTIVE: not allowed. ERROR is returned.
* WNCAN_CHN_RECEIVE: CAN messages with this Id will be received.
* WNCAN_CHN_TRANSMIT: CAN meesage with the specified ID will be transmitted
* when CAN_Tx is called
*
* If this function is called while the controller is online, receive errors
* may occur while the receive buffer id is being changed. 
*
*
* RETURNS:        OK, or ERROR
*
* ERRNO:          S_can_illegal_channel_no,
*                 S_can_illegal_config
*
*/

static STATUS SJA1000_WriteID(struct WNCAN_Device *pDev, UCHAR channelNum,
                             unsigned long canId, BOOL ext)
{
	struct TxMsg    *pTxMsg;
    UCHAR           value, regVal, rxIEOff;     	
    STATUS          retCode = ERROR; /* pessimistic */	
	
    if (channelNum >= SJA1000_MAX_MSG_OBJ)
    {
        errnoSet(S_can_illegal_channel_no);
    }
    else if((pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INACTIVE) ||
		(pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INVALID))
    {
        errnoSet(S_can_illegal_config);
    }
    else
    {
        if(pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_RECEIVE)
        {
			/*check if receive interrupts are turned on. If yes, disable
			interrupts */
			regVal = pDev->pBrd->canInByte(pDev,SJA1000_IER);
			if(regVal & IER_RIE)
			{
				rxIEOff = regVal & ~(IER_RIE);
				pDev->pBrd->canOutByte(pDev, SJA1000_IER, rxIEOff);
				
			}
			
            if (ext == TRUE)
            {
                value = canId >> (24-3);
                pDev->pBrd->canOutByte(pDev, SJA1000_ACR0, value);
                value = canId >> (16-3);
                pDev->pBrd->canOutByte(pDev, SJA1000_ACR1, value);
                value = canId >> (8-3);
                pDev->pBrd->canOutByte(pDev, SJA1000_ACR2, value);
                value = canId << 3;
                pDev->pBrd->canOutByte(pDev, SJA1000_ACR3, value);
				
            }
            else
            {
                value = canId >> 3;
                pDev->pBrd->canOutByte(pDev, SJA1000_ACR0, value);
                value = canId << 5;
                pDev->pBrd->canOutByte(pDev, SJA1000_ACR1, value);
				
			}
			
            /* restore receive interrupts if previously set*/
			if(regVal & IER_RIE)
			{
				pDev->pBrd->canOutByte(pDev, SJA1000_IER, regVal);
			}
			
            
        }
        else
        {
            pTxMsg = (struct TxMsg *)pDev->pCtrl->csData;
            pTxMsg->id = canId;
            pTxMsg->ext = ext;
        }
		
        retCode = OK;
    }
	
    return retCode;
}


/************************************************************************
*
* SJA1000_ReadData - read 0 to 8 bytes of data from channel
*
* This function reads "len" bytes of data from the channel and sets the value
* of len to the number of bytes read. The range of "len" is zero (for zero 
* length data) to a maximum of eight. The mode of the channel must not be 
* WNCAN_CHN_INVALID or WNCAN_CHN_INACTIVE; however, the newData flag is valid 
* WNCAN_CHN_RECEIVE channel mode.
* For receive channels, if no new data has been received since the last
* CAN_ReadData  function call, the newData flag is set to FALSE; 
* otherwise, the flag is TRUE. In both cases, the data and length of the
* data currently in the channel are read. 
*
* RETURNS:        OK, or ERROR
*
* ERRNO:          S_can_illegal_channel_no,
*                 S_can_illegal_config,
*                 S_can_buffer_overflow,
*                 S_can_null_input_buffer
*
*/
static STATUS SJA1000_ReadData(struct WNCAN_Device *pDev, UCHAR channelNum,
                       UCHAR *data, UCHAR *len, BOOL *newData)
{
    UCHAR           value;
    UCHAR           hwLength=0;
    UINT            i;
    UINT            offset;
    struct TxMsg    *pTxMsg;

    STATUS          retCode = ERROR; /* pessimistic */

    if (channelNum >= SJA1000_MAX_MSG_OBJ)
    {
        errnoSet(S_can_illegal_channel_no);
    }
    else if((pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INACTIVE) ||
            (pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INVALID))
    {
        errnoSet(S_can_illegal_config);
    }
    else
    {
        if(data == NULL)
        {
         errnoSet(S_can_null_input_buffer);
	     return retCode;     
        }

        if(pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_RECEIVE)
        {
            /* get the frame info and read the data */
            value = pDev->pBrd->canInByte(pDev, SJA1000_SFF);
            offset = (value & 0x80)? 2 : 0;
            hwLength = value & 0xF;

            if (hwLength > *len)
            {
             /*
              If the actual number of bytes in the message are greater than
              expected bytes by user, set error no and do not copy message
              DLC into *len
             */
             errnoSet(S_can_buffer_overflow);

            }
            else
            {
             /*If the message DLC and the expected data length is equal,
               copy message DLC into *len and continue */
               *len = hwLength;
               retCode = OK;
            }

            for (i = 0; i < *len; i++)
                data[i] = pDev->pBrd->canInByte(pDev, (SJA1000_SFDATA + i + offset));

            /* check the status register to see if the message was new */
            value = pDev->pBrd->canInByte(pDev, SJA1000_SR);
            if(value & SR_RBS)
            {
                *newData = 1;
                /* release the receive buffer */
                pDev->pBrd->canOutByte(pDev, SJA1000_CMR, CMR_RRB);
            }
            else
                *newData = FALSE;
        }
        else
        {

            pTxMsg = (struct TxMsg *)pDev->pCtrl->csData;
			
			/*transmit channel*/
			/*check for overflow*/
			if(pTxMsg->len > *len)
			{
				errnoSet(S_can_buffer_overflow);
			}
			else
			{
				*len = pTxMsg->len;
				retCode = OK;
			}
            
			for(i = 0 ; i < *len ; i++)
                data[i] = pTxMsg->data[i];
            			
        }

    }

    return retCode;
}

/************************************************************************
*
* SJA1000_GetMessageLength - get the message length
*
* This function returns the length of the message data in the channel on the 
* controller. The minimum value returned is 0, and the maximum value is 8. 
* This number is equal to the "len" argument in CAN_ReadData. If the data 
* has zero length, this function returns zero. The mode of the channel
* must not be WNCAN_CHN_INACTIVE or WNCAN_CHN_INVALID
*
* RETURNS:        length of data or -1 if error
*
* ERRNO:          S_can_illegal_channel_no, S_can_illegal_config
*
*/
static int SJA1000_GetMessageLength
      (
	  struct WNCAN_Device *pDev,
	  UCHAR channelNum
	  )
{
    struct TxMsg *pTxMsg;
    int retLen = -1; /* pessimistic */


    if (channelNum >= SJA1000_MAX_MSG_OBJ)
    {
        errnoSet(S_can_illegal_channel_no);
    }
    else if((pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INACTIVE) ||
            (pDev->pCtrl->chnMode[channelNum] == WNCAN_CHN_INVALID))
    {
        errnoSet(S_can_illegal_config);
    }
    else
    {
        if(pDev->pCtrl->chnMode[channelNum] != WNCAN_CHN_TRANSMIT)
		{
            retLen = pDev->pBrd->canInByte(pDev, SJA1000_SFF ) & 0x0f;
		}
        else
        {