/* File: CAN.C */

/****************************************************************************
* 
* CAN.101
* ========
*
* CAN bus routines for CPU 167CR, C167CS, C164 
*
* TQ-Systems GmbH
* ----------------                                                         
* Costumer: TQC
* Project : STK16X, STK16XU 
* Module  : CAN
* Hardware: TQM167C, TQM164
* Tools   : uVision 2.10 with Keil C166 Compiler V4.10
*
* Used modules:
* -------------
* 
* Rev: Date:     Name:            Modification:
* ----+---------+----------------+------------------------------------------
* 101  03.07.01  F. Hattenhauer   extension for C167CS (dual CAN)
* 100  13.10.98  F. Hattenhauer   initial version
*****************************************************************************/

/*==========================================================================*
* include files (#INCLUDE):
*===========================================================================*/

/*--------------------------------------------------------------------------*
* standard include files: 
*---------------------------------------------------------------------------*/
#include <stdio.h>              /* standard I/O functions       */
#include <ctype.h>              /* typecast functions           */
#include <string.h>             /* string functions             */
#include <setjmp.h>             /* global jump functions        */
#include <absacc.h>             /* absolute access              */
#include <intrins.h>            /* intrinsic functions          */
#include <reg167.h>             /* special function register    */

/*--------------------------------------------------------------------------*
* project specific include files:
*---------------------------------------------------------------------------*/
#include "can.h"
#include "can164.h"

/*==========================================================================*
* module internal definitions (#DEFINE):
*===========================================================================*/

/*==========================================================================*
* module internal type declarations (TYPEDEF):
*===========================================================================*/

/*==========================================================================*
* module internal constants (CONST):
*===========================================================================*/

/*--------------------------------------------------------------------------*
* CMS initialization parameter (depends on project):
*---------------------------------------------------------------------------*/
const CAN_CMS_T can_cms[CAN_CMS_MAX] = {{ NMT      , READ , EVENT},  /*  0 */
                                       //{{ NMT      , WRITE, EVENT},  /*  0 */
					{ PDO1_tx  , WRITE, EVENT},  /*  1 */
					{ PDO1_rx  , READ , EVENT},  /*  2 */
					{ PDO2_tx  , WRITE, EVENT},  /*  3 */
					{ PDO2_rx  , READ , EVENT},  /*  4 */
					{ SDO_tx   , WRITE, EVENT},  /*  5 */
					{ SDO_rx   , READ , EVENT},  /*  6 */
					{ EMERGENCY, WRITE, EVENT},  /*  7 */
					{ NU       , READ , EVENT},  /*  8 */
					{ NU       , READ , EVENT},  /*  9 */
					{ NU       , READ , EVENT},  /* 10 */
					{ NU       , READ , EVENT},  /* 11 */
					{ NU       , READ , EVENT},  /* 12 */
					{ NU       , READ , EVENT}   /* 13 */
				       };

/*==========================================================================*
* extern available constants (CONST):
*===========================================================================*/

/*==========================================================================*
* modul internal variables:
*===========================================================================*/

/*--------------------------------------------------------------------------*
* CAN message variables:
* (internal buffer to keep the data until the application will read them):
*---------------------------------------------------------------------------*/
CAN_DATA_T can_cms_buf[CAN_CMS_MAX];

/*--------------------------------------------------------------------------*
* CAN register (access to the CAN controller)
*---------------------------------------------------------------------------*/
unsigned char *canreg = (unsigned char *) CANBASIS;

/*==========================================================================*
* globale external available variables (EXTERN):
*===========================================================================*/

/*==========================================================================*
* modul internal functions:
*===========================================================================*/

/*--------------------------------------------------------------------------*
* function prototypes:
*---------------------------------------------------------------------------*/
int    can_chk_cmsbuf(int cmsnr);
int    can_cms_init(int cmsnr, BYTE kn);
USHORT can_calc_id(unsigned int cmsnr, BYTE kn);

/*--------------------------------------------------------------------------*
* int can_chk_cmsbuf(int cmsnr)
*---------------------------------------------------------------------------*
* FT: test if CAN message number is valid and if CAN message buffer is aktiv
* EP: cmsnr = can_cms position (0..CAN_CMS_MAX-1)
* RV: TRUE = CAN message number is valid; FALSE = unvalid
* GP: can_cms
*---------------------------------------------------------------------------*/
int can_chk_cmsbuf(int cmsnr)
{
  /* check CAN message number: */
  if ((cmsnr >= CAN_CMS_MAX) || (cmsnr < 0 ))
    return (FALSE);

  /* check if CAN message is aktiv: */
  if (can_cms[cmsnr].msgtyp == NU)
    return (FALSE);

  return (TRUE);
}

/*--------------------------------------------------------------------------*
* USHORT can_calc_id(unsigned int cmsnr, BYTE kn)
*---------------------------------------------------------------------------*
* FT: calculate CAN message identifier
* EP: cmsnr = can_cms position (0..CAN_CMS_MAX-1)
*     kn    = node (0..NODEMAX)
* RV: ID number (0xFFFF if any error occurred)
* GP: can_cms
*---------------------------------------------------------------------------*/
USHORT can_calc_id(unsigned int cmsnr, BYTE kn)
{ unsigned int idf;

  /* check the cms objekt: */
  if (!can_chk_cmsbuf(cmsnr))
    return (0xFFFF);

  if (kn > NODEMAX)
    return (0xFFFF);

  /* calculate CAN ID: */
  switch( can_cms[cmsnr].msgtyp )
  {
    case NMT      : idf = 0x00; break;
    case EMERGENCY: idf = 0x80 + kn; break;
    case PDO1_tx  : idf = 0x180 + kn; break;
    case PDO1_rx  : idf = 0x200 + kn; break;
    case PDO2_tx  : idf = 0x280 + kn; break;
    case PDO2_rx  : idf = 0x300 + kn; break;
    case SDO_tx   : idf = 0x580 + kn; break;
    case SDO_rx   : idf = 0x600 + kn; break;
    default       : idf = 0xFFFF;
  }
  return (idf);
}

/*--------------------------------------------------------------------------*
* int can_cms_init(int cmsnr, BYTE kn)
*---------------------------------------------------------------------------*
* FT: init CAN message register
* EP: cmsnr = CMS-Nummer (0..CAN_CMS_MAX-1)
*     kn    = node (0..NODEMAX)
* RV: TRUE = function succesfully; FALSE = function failed
* GP: can_cms, can_cms_buf, canreg
*---------------------------------------------------------------------------*/
int can_cms_init(int cmsnr, BYTE kn)
{ int loop;
  int msgbuf;
  unsigned int id;

  if (cmsnr >= CAN_CMS_MAX)
	return (FALSE);

  msgbuf = cmsnr + 1;

  /* message control register: reset all flags */
  canreg[msgbuf * MSGOFF + CAN_MSG_CTR0]  = 0x55;
  canreg[msgbuf * MSGOFF + CAN_MSG_CTR1]  = 0x55;

  /* if message is not valid, return: */
  if (can_cms[cmsnr].msgtyp == NU)
	return (FALSE);

  /* calulate identifier (11 bit): */
  id = can_calc_id(cmsnr, kn);

  /* check identifier length (11 bit = 00x07FF): */
  if (id > 0x07FF)
    return (FALSE);

  /* set ID of CAN controller's address field: */
  canreg[msgbuf * MSGOFF + CAN_MSG_AR0 ] = (id >> 3) & 0xff;
  canreg[msgbuf * MSGOFF + CAN_MSG_AR1 ] = (id << 5) & 0xff;
  canreg[msgbuf * MSGOFF + CAN_MSG_AR2 ] = 0;
  canreg[msgbuf * MSGOFF + CAN_MSG_AR3 ] = 0;

  /* clear controller data register and CMS data memory: */
  for (loop=0; loop<8; loop++)
  {
    canreg [msgbuf * MSGOFF + CAN_MSG_DATA1 + loop ] = 0;
    can_cms_buf[cmsnr].data[loop] = 0;
  }     

  /* init message buffer: */
  switch (can_cms[cmsnr].access_type)
  {
    case WRITE: canreg[msgbuf * MSGOFF + CAN_MSG_CFR]  = IW_CAN_MSG_CFR;
		can_cms_buf[cmsnr].status = INITIALIZED;
		break;
    case READ : canreg[msgbuf * MSGOFF + CAN_MSG_CFR]  = IR_CAN_MSG_CFR;
		canreg[msgbuf * MSGOFF + CAN_MSG_CTR0]  = IR_CAN_MSG_CTR0; 
		canreg[msgbuf * MSGOFF + CAN_MSG_CTR1]  = IR_CAN_MSG_CTR1; 
		can_cms_buf[cmsnr].status = INITIALIZED;
		break;
    default   : return (FALSE);
  }