/*
This file is part of CanFestival, a library implementing CanOpen Stack.

Copyright (C): Edouard TISSERANT and Francis DUPIN
AVR Port: Andreas GLAUSER and Peter CHRISTEN

See COPYING file for copyrights details.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

//#define DEBUG_WAR_CONSOLE_ON
//#define DEBUG_ERR_CONSOLE_ON

#include "can_AVR.h"
#include "canfestival.h"

volatile unsigned char msg_received = 0;

unsigned char canInit(unsigned int bitrate)
/******************************************************************************
Initialize the hardware to receive CAN messages and start the timer for the
CANopen stack.
INPUT	bitrate		bitrate in kilobit
OUTPUT	1 if successful	
******************************************************************************/
{
  unsigned char i,k;
    //- Pull-up on TxCAN & RxCAN one by one to use bit-addressing
  CAN_PORT_DIR &= ~(1<<CAN_INPUT_PIN );
  CAN_PORT_DIR &= ~(1<<CAN_OUTPUT_PIN);
  CAN_PORT_OUT |=  (1<<CAN_INPUT_PIN );
  CAN_PORT_OUT |=  (1<<CAN_OUTPUT_PIN);

  Can_reset();				// Reset the CAN controller

  if (bitrate <= 500)
  {
    // CANopen 10..500 kbit with 16 tq, sample point is at 14 tq
    // all values are added to 1 by hardware
    // Resynchronisation jump width (SJW)	= 1 tq 
    // Propagation Time Segment (PRS)		= 5 tq
    // Phase Segment 1 (PHS1)			= 8 tq 
    // Phase Segment 2 (PHS2)			= 2 tq
    // Total					= 16 tq
    CANBT1 = ((F_CPU/16/1000/bitrate-1) << BRP);	// set bitrate
    CANBT2 = ((1-1) << SJW) |((5-1) << PRS);	// set SJW, PRS
    CANBT3 = (((2-1) << PHS2) | ((8-1) << PHS1) | (1<<SMP)); // set PHS1, PHS2, 3 sample points
  }
  else 
    return 0;

  // Reset all mailsboxes (MObs), filters are zero (accept all) by clear all MOb
  // Set the lower MObs as rx buffer
  for (i = 0; i < NB_MOB; i++)
  {
    Can_set_mob(i);		// Change to MOb with the received message
    Can_clear_mob();		// All MOb Registers=0
    for (k = 0; k < NB_DATA_MAX; k++)
      CANMSG = 0;		// MOb data FIFO
    if (i < NB_RX_MOB)		// Is receive MOb
      Can_config_rx_buffer();	// configure as receive buffer
  }
  // The tx MOb is still disabled, it will be set to tx mode when the first message will be sent
  // Enable the general CAN interrupts
  CANGIE = (1 << ENIT) | (1 << ENRX) | (1 << ENTX) | (0 << ENERR) | (0 << ENERG) | (0 << ENOVRT);
  CANIE1 = 0x7F;	// Enable the interrupts of all MObs (0..14)
  CANIE2 = 0xFF;   
  Can_enable();                                 // Enable the CAN bus controller
  return 1;
}

unsigned char canSend(CAN_PORT notused, Message *m)
/******************************************************************************
The driver send a CAN message passed from the CANopen stack
INPUT	CAN_PORT is not used (only 1 avaiable)
	Message *m pointer to message to send
OUTPUT	1 if  hardware -> CAN frame
******************************************************************************/
{
  unsigned char i;

  for (i = START_TX_MOB; i < NB_MOB; i++)	// Search the first free MOb
  {
    Can_set_mob(i);			// Change to MOb
    if ((CANCDMOB & CONMOB_MSK) == 0)	// MOb disabled = free
    {
      break;
    }
  }
  if (i < NB_MOB)			// free MOb found
  {
    Can_set_mob(i);			// Switch to the sending messagebox
    Can_set_std_id(m->cob_id);		// Set cob id
    if (m->rtr)				// Set remote transmission request
      Can_set_rtr();
    Can_set_dlc(m->len);		// Set data lenght code

    for (i= 0; i < (m->len); i++)	// Add data bytes to the MOb
      CANMSG = m->data[i];
  // Start sending by writing the MB configuration register to transmit
    Can_config_tx();		// Set the last MOb to transmit mode
    return 1;	// succesful
  }
  else
    return 0;	// not succesful
}

unsigned char canReceive(Message *m)
/******************************************************************************
The driver pass a received CAN message to the stack
INPUT	Message *m pointer to received CAN message
OUTPUT	1 if a message received
******************************************************************************/
{
  unsigned char i;

  if (msg_received == 0)
    return 0;		// Nothing received

  for (i = 0; i < NB_RX_MOB; i++)	// Search the first MOb received
  {
    Can_set_mob(i);			// Change to MOb
    if ((CANCDMOB & CONMOB_MSK) == 0)	// MOb disabled = received
    {
      msg_received--;
      break;
    }
  }
  if (i < NB_RX_MOB)			// message found
  {
    Can_get_std_id(m->cob_id);		// Get cob id
    m->rtr = Can_get_rtr();		// Get remote transmission request
    m->len = Can_get_dlc();		// Get data lenght code
    for (i= 0; i < (m->len); i++)	// get data bytes from the MOb
      m->data[i] = CANMSG;
    Can_config_rx_buffer();		// reset the MOb for receive
    return 1;                  		// message received
  }
  else					// no message found
  {
    msg_received = 0;			// reset counter
    return 0;                  		// no message received
  }
}

/***************************************************************************/
unsigned char canChangeBaudRate_driver( CAN_HANDLE fd, char* baud)
{

	return 0;
}

#ifdef  __IAR_SYSTEMS_ICC__
#pragma type_attribute = __interrupt
#pragma vector=CANIT_vect
void CANIT_interrupt(void)
#else	// GCC
ISR(CANIT_vect)
#endif	// GCC
/******************************************************************************
CAN Interrupt
******************************************************************************/
{
  unsigned char i;

  if (CANGIT & (1 << CANIT))	// is a messagebox interrupt
  {
    if ((CANSIT1 & TX_INT_MSK) == 0)	// is a Rx interrupt
    {
      for (i = 0; (i < NB_RX_MOB) && (CANGIT & (1 << CANIT)); i++)	// Search the first MOb received
      {
        Can_set_mob(i);			// Change to MOb
        if (CANSTMOB & MOB_RX_COMPLETED)	// receive ok
        {
          Can_clear_status_mob();	// Clear status register
	  Can_mob_abort();		// disable the MOb = received
	  msg_received++;
        }
        else if (CANSTMOB & ~MOB_RX_COMPLETED)	// error
        {
          Can_clear_status_mob();	// Clear status register
	  Can_config_rx_buffer();	// reconfigure as receive buffer
        }
      }
    }
    else				// is a Tx interrupt	 
    {
      for (i = NB_RX_MOB; i < NB_MOB; i++)	// Search the first MOb transmitted
      {
        Can_set_mob(i);			// change to MOb
        if (CANSTMOB)			// transmission ok or error
        {
          Can_clear_status_mob();	// clear status register
	  CANCDMOB = 0;			// disable the MOb
	  break;
        }
      }
    }
  }

  // Bus Off Interrupt Flag
  if (CANGIT & (1 << BOFFIT))    // Finaly clear the interrupt status register
  {
    CANGIT |= (1 << BOFFIT);                    // Clear the interrupt flag
  }
  else
    CANGIT |= (1 << BXOK) | (1 << SERG) | (1 << CERG) | (1 << FERG) | (1 << AERG);// Finaly clear other interrupts
}

#ifdef  __IAR_SYSTEMS_ICC__
#pragma type_attribute = __interrupt
#pragma vector=OVRIT_vect
void OVRIT_interrupt(void)
#else	// GCC
ISR(OVRIT_vect)
#endif	// GCC
/******************************************************************************
CAN Timer Interrupt
******************************************************************************/
{
  CANGIT |= (1 << OVRTIM);
}