//!/////////////////////////////////////////////////////////////////////////
/// can_io.c                                                              //
///                                                                       //
/// Version:     0.2                                                      //
/// Date:        11/01/2009                                               //
/// Author:      Michael Skutek (michael@skutek.de)                       //
///                                                                       //
/// Description: CAN I/O routines for SJA1000                             //
///                                                                       //
/// Platform:    AVR ATmega (tested on ATmega16)                          //
///                                                                       //
/// Include Files:                                                        //
///              avr/io.h:             port accessing (part of avr-gcc)   //
///              util/delay.h:         time delays (part of avr-gcc)      //
///              port_definitions.h:   definition of input/output ports   //
///              can_io.h.h:           defintions (e.g. return values)    //
///                                                                       //
///                                                                       //
/// This program 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 3 of the    //
/// License, or (at your option) any later version.                       //
///                                                                       //
/// This program 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 program. If not, see                          //
/// <http://www.gnu.org/licenses/>.                                       //
//!/////////////////////////////////////////////////////////////////////////




#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>

#include "port_definitions.h"
#include "can_io.h"



//!///////////////////////////////////////////////////////////////////////
/// can_io_send_data                                                    //
///                                                                     //
/// Description:                                                        //
///         Sends a data byte to SJA1000.                               //
///                                                                     //
/// input:                                                              //
///         address:    address byte                                    //
///            data:    data byte                                       //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void can_io_send_data(unsigned char address, unsigned char data) {

  //set control signals
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_CS) | (1 << CAN_CTRL_RDE) | (1 << CAN_CTRL_WR);
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_ALE);

  //switch Address Port to output port and set address
  CAN_ADDR_DDR = 0xff;             //CAN_Address Port -> output port
  CAN_ADDR_PORT = address;         //Address Byte

  //raise ALE
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_ALE);
  _delay_us(CAN_TIMING_AL_US);

  //set ALE to Low
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_ALE);
  _delay_us(CAN_TIMING_ALH_US);

  //set data
  CAN_ADDR_PORT = data;         //Data Byte

  //set WR and CS to Low
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_WR) & ~(1 << CAN_CTRL_CS);
  _delay_us(CAN_TIMING_WR_US);

  //set WR and CS to High
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_WR) | (1 << CAN_CTRL_CS);
  _delay_us(CAN_TIMING_WRH_US);


}



//!///////////////////////////////////////////////////////////////////////
/// can_io_read_data                                                    //
///                                                                     //
/// Description:                                                        //
///         Reads a data byte from SJA1000.                             //
///                                                                     //
/// input:                                                              //
///         address:    address byte                                    //
/// return:                                                             //
///            data:    data byte                                       //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

unsigned char can_io_read_data(unsigned char address) {

  unsigned char data = 0xff;

  //set control signals
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_CS) | (1 << CAN_CTRL_RDE) | (1 << CAN_CTRL_WR);
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_ALE);

  //switch Address Port to output port and set address
  CAN_ADDR_DDR = 0xff;             //CAN_Address Port -> output port
  CAN_ADDR_PORT = address;         //Address Byte

  //raise ALE
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_ALE);
  _delay_us(CAN_TIMING_AL_US);

  //set ALE to Low
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_ALE);
  _delay_us(CAN_TIMING_ALH_US);


  //switch Address Port to input port
  CAN_ADDR_PORT = 0xff;         //enable pull-up resistors
  CAN_ADDR_DDR = 0x00;          //CAN_Address Port -> input port


  //set RD and CS to Low
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_RDE) & ~(1 << CAN_CTRL_CS);
  _delay_us(CAN_TIMING_RD_US);

  //read data and set RD and CS to High
  data = CAN_ADDR_PIN;
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_RDE) | (1 << CAN_CTRL_CS);
  _delay_us(CAN_TIMING_RDH_US);


  return data;

}



//!///////////////////////////////////////////////////////////////////////
/// can_io_receive_message                                              //
///                                                                     //
/// Description:                                                        //
///         Receives CAN Message from SJA1000.                          //
///                                                                     //
/// input:                                                              //
///         can_message:    can message (see "can_io.h")                //
///                mode:      CAN Mode (Basic CAN:   CAN_MODE_BASIC,    //
///                                     PELICAN: CAN_MODE_PELICAN)      //
///                                                                     //
/// return:                                                             //
///          CAN_RCV_ERR:    some error occured                         //
/// CAN_RCV_OVERRUN_WARN:    overrun warning detected                   //
///           CAN_RCV_OK:    no error occured                           //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

uint8_t can_io_receive_message(volatile can_message_struct *can_message, uint8_t mode) {

  uint8_t return_value;
  uint32_t return_value32;


  ///check IR if Receive Interrupt Bit is set
  return_value = can_io_read_data(CAN_IR_ADDR);

  if ((return_value & CAN_RCVINTERRUPT_VAL) != CAN_RCVINTERRUPT_VAL) {
    return CAN_RCV_ERR;
  }

  ///check SR if Receive Buffer contains Data
  return_value = can_io_read_data(CAN_STAT_ADDR);

  if ((return_value & CAN_RCVBUFFER_FILLED_VALUE) != CAN_RCVBUFFER_FILLED_VALUE) {
    return CAN_RCV_ERR;
  }


  ///read receive buffer of SJA1000
  if (mode == CAN_MODE_PELICAN) {

    return_value = can_io_read_data(CAN_RXPELI_ADDR);            //get TX Frame Information

    //check for Frame Format
    if (((return_value >> 7) & CAN_EFF_MESSAGE) == CAN_EFF_MESSAGE) {        //EFF

      can_message->dlc = (return_value & 0x0f);
      return_value32 = can_io_read_data(CAN_RXPELI_ADDR + 1);          //get part of identifier
      can_message->id = (return_value32 << 21);
      return_value32 = can_io_read_data(CAN_RXPELI_ADDR + 2);          //get part of identifier
      can_message->id = can_message->id | (return_value32 << 13);
      return_value32 = can_io_read_data(CAN_RXPELI_ADDR + 3);          //get part of identifier
      can_message->id = can_message->id | (return_value32 << 5);
      return_value32 = can_io_read_data(CAN_RXPELI_ADDR + 4);          //get part of identifier
      can_message->id = can_message->id | ((return_value32 >> 3) & 0x1f);
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 5);        //get data byte
      can_message->data0 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 6);        //get data byte
      can_message->data1 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 7);        //get data byte
      can_message->data2 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 8);        //get data byte
      can_message->data3 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 9);        //get data byte
      can_message->data4 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 10);        //get data byte
      can_message->data5 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 11);        //get data byte
      can_message->data6 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 12);        //get data byte
      can_message->data7 = return_value;


    } else {                                                                 //SFF

      can_message->dlc = (return_value & 0x0f);
      return_value32 = can_io_read_data(CAN_RXPELI_ADDR + 1);          //get part of identifier
      can_message->id = (return_value32 << 3);
      return_value32 = can_io_read_data(CAN_RXPELI_ADDR + 2);          //get part of identifier
      can_message->id = can_message->id | ((return_value32 >> 5) & 0x07);
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 3);        //get data byte
      can_message->data0 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 4);        //get data byte
      can_message->data1 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 5);        //get data byte
      can_message->data2 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 6);        //get data byte
      can_message->data3 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 7);        //get data byte
      can_message->data4 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 8);        //get data byte
      can_message->data5 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 9);        //get data byte
      can_message->data6 = return_value;
      return_value = can_io_read_data(CAN_RXPELI_ADDR + 10);       //get data byte
      can_message->data7 = return_value;


    }

  } else if (mode == CAN_MODE_BASIC) {

    return_value = can_io_read_data(CAN_RXBAS_ADDR);            //get first part of identifier
    can_message->id = (return_value << 3);
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 1);        //get second part of identifier, RTR and DLC
    can_message->id = can_message->id | ((return_value >> 5) & 0x07);
    can_message->dlc = (return_value & 0x0f);
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 2);        //get data byte
    can_message->data0 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 3);        //get data byte
    can_message->data1 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 4);        //get data byte
    can_message->data2 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 5);        //get data byte
    can_message->data3 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 6);        //get data byte
    can_message->data4 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 7);        //get data byte
    can_message->data5 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 8);        //get data byte
    can_message->data6 = return_value;
    return_value = can_io_read_data(CAN_RXBAS_ADDR + 9);       //get data byte
    can_message->data7 = return_value;

  } else {
    return CAN_RCV_ERR;
  }


  ///release the receive buffer
  can_io_send_data(CAN_CMR_ADDR, CAN_RELEASERCVFIFO_VALUE);


  ///check STAT if Data Overrun Bit is set
  return_value = can_io_read_data(CAN_STAT_ADDR);

  if ((return_value & CAN_STAT_RCVOVERRUN_VALUE) != CAN_STAT_RCVOVERRUN_VALUE) {
    can_io_send_data(CAN_CMR_ADDR, CAN_CMR_CLEAROVERRUN_VALUE);
    return CAN_RCV_OVERRUN_WARN;
  }


  return CAN_RCV_OK;

}

//!///////////////////////////////////////////////////////////////////////
/// can_io_send_message                                                 //
///                                                                     //
/// Description:                                                        //
///         Sends a CAN Message to SJA1000 (Standard Frame).            //
///                                                                     //
/// input:                                                              //
///     can_message:    can message (see "can_io.h")                    //
///    frame_format:    Frame Format (SFF: CAN_SFF_MESSAGE,             //
///                                   EFF: CAN_EFF_MESSAGE)             //
///    message_type:    Message Type (Data: CAN_DATA_TRANS,             //
///                                   RTR: CAN_RTR_TRANS)               //
///            mode:      CAN Mode (Basic CAN:   CAN_MODE_BASIC,        //
///                                 PELICAN: CAN_MODE_PELICAN)          //
///                                                                     //
/// return:                                                             //
///   CAN_TRANS_ERR:    error during transmitting message occured       //
///    CAN_TRANS_OK:    no error occured                                //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

unsigned char can_io_send_message(can_message_struct *can_message, uint8_t frame_format,
                                  uint8_t message_type, uint8_t mode) {

  unsigned char return_value;
  uint8_t timeout_counter = 0;


  ///check transmit buffer status
  return_value = can_io_read_data(CAN_STAT_ADDR);

  timeout_counter = 0;
  while (((return_value & CAN_TRSTATUS_RELEASED_VALUE) != CAN_TRSTATUS_RELEASED_VALUE) && (timeout_counter < CAN_TRANSMISSION_TIMEOUT)) {
    return_value = can_io_read_data(CAN_STAT_ADDR);
    timeout_counter++;
  }

  //timeout occured - return an error
  if (timeout_counter >= CAN_TRANSMISSION_TIMEOUT) {
    return CAN_TRANS_ERR;
  }

  ///if transmit buffer is released - send message bytes and set transmission request bit in CMR

  //send TX Frame Information, Identifier and Data Bytes

  //PELICAN Mode
  if (mode == CAN_MODE_PELICAN) {
    can_io_send_data(CAN_TXPELI_ADDR, (frame_format << 7) | (message_type << 6) | (can_message->dlc & 0x0f));

    if (frame_format == CAN_EFF_MESSAGE) {
      can_io_send_data(CAN_TXPELI_ADDR + 1, ((can_message->id >> 21) & 0xff));
      can_io_send_data(CAN_TXPELI_ADDR + 2, ((can_message->id >> 13) & 0xff));
      can_io_send_data(CAN_TXPELI_ADDR + 3, ((can_message->id >> 5) & 0xff));
      can_io_send_data(CAN_TXPELI_ADDR + 4, ((can_message->id << 3) & 0xf8));
      can_io_send_data(CAN_TXPELI_ADDR + 5, can_message->data0);
      can_io_send_data(CAN_TXPELI_ADDR + 6, can_message->data1);
      can_io_send_data(CAN_TXPELI_ADDR + 7, can_message->data2);
      can_io_send_data(CAN_TXPELI_ADDR + 8, can_message->data3);
      can_io_send_data(CAN_TXPELI_ADDR + 9, can_message->data4);
      can_io_send_data(CAN_TXPELI_ADDR + 10, can_message->data5);
      can_io_send_data(CAN_TXPELI_ADDR + 11, can_message->data6);
      can_io_send_data(CAN_TXPELI_ADDR + 12, can_message->data7);
    } else {
      can_io_send_data(CAN_TXPELI_ADDR + 1, ((can_message->id >> 3) & 0xff));
      can_io_send_data(CAN_TXPELI_ADDR + 2, ((can_message->id << 5) & 0xe0));
      can_io_send_data(CAN_TXPELI_ADDR + 3, can_message->data0);
      can_io_send_data(CAN_TXPELI_ADDR + 4, can_message->data1);
      can_io_send_data(CAN_TXPELI_ADDR + 5, can_message->data2);
      can_io_send_data(CAN_TXPELI_ADDR + 6, can_message->data3);
      can_io_send_data(CAN_TXPELI_ADDR + 7, can_message->data4);
      can_io_send_data(CAN_TXPELI_ADDR + 8, can_message->data5);
      can_io_send_data(CAN_TXPELI_ADDR + 9, can_message->data6);
      can_io_send_data(CAN_TXPELI_ADDR + 10, can_message->data7);
    }

    //send CAN Transmission Request
    can_io_send_data(CAN_CMR_ADDR, CAN_CMR_TRREQ_VALUE);


    //BASIC CAN Mode
  } else if (mode == CAN_MODE_BASIC) {
    can_io_send_data(CAN_TXBAS_ADDR, ((can_message->id >> 3) & 0xff));
    can_io_send_data(CAN_TXBAS_ADDR + 1, (can_message->id << 5) | (message_type << 4) | (can_message->dlc & 0x0f));
    can_io_send_data(CAN_TXBAS_ADDR + 2, can_message->data0);
    can_io_send_data(CAN_TXBAS_ADDR + 3, can_message->data1);
    can_io_send_data(CAN_TXBAS_ADDR + 4, can_message->data2);
    can_io_send_data(CAN_TXBAS_ADDR + 5, can_message->data3);
    can_io_send_data(CAN_TXBAS_ADDR + 6, can_message->data4);
    can_io_send_data(CAN_TXBAS_ADDR + 7, can_message->data5);
    can_io_send_data(CAN_TXBAS_ADDR + 8, can_message->data6);
    can_io_send_data(CAN_TXBAS_ADDR + 9, can_message->data7);

    //send CAN Transmission Request
    can_io_send_data(CAN_CMR_ADDR, CAN_CMR_TRREQ_VALUE);

  } else {
    return CAN_TRANS_ERR;
  }



  return CAN_TRANS_OK;

}


//!///////////////////////////////////////////////////////////////////////
///can_io_init                                                          //
///                                                                     //
/// Description:                                                        //
///         Initializes the SJA1000 after Reset.                        //
///                                                                     //
/// input:                                                              //
///             mode:      CAN Mode (Basic CAN:   CAN_MODE_BASIC,       //
///                                  PELICAN: CAN_MODE_PELICAN)         //
///         baudrate:      Baudrate (100 kBit/s:  CAN_100_KBIT,         //
///                                  250 kBit/s:  CAN_250_KBIT,         //
///                                  500 kBit/s:  CAN_500_KBIT,         //
///                                    1 MBit/s:  CAN_1_MBIT            //
///  acceptance_code:      Acceptance Code (ACR3,ACR2,ACR1,ACR0 <-LSB)  //
///  acceptance_mask:      Acceptance Mask (AMR3,AMR2,AMR1,AMR0 <-LSB)  //
///                                                                     //
/// return:                                                             //
///     return_value:      CAN_INIT_ERR: error occured during init      //
///                         CAN_INIT_OK: no error occured               //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

unsigned char can_io_init(uint8_t mode, uint8_t baudrate,
                            uint32_t acceptance_code, uint32_t acceptance_mask) {

  unsigned char return_value = CAN_INIT_ERR;         //preset of return value
  uint8_t timeout_counter = 0;


  ///wait for power up of CAN Controller
  _delay_ms(CAN_TIMING_POWERON_MS);


  ///RESET
  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_RST);
  _delay_ms(CAN_TIMING_RESET_MS);
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_RST);


  ///PELICAN Mode
  if (mode == CAN_MODE_PELICAN) {

    //after RESET SJA1000 is in Basic CAN Mode --> Check for Reset Flag in CR
    return_value = can_io_read_data(CAN_CR_ADDR);

    //if RESET mode Flag is not set, try to set it (only for CAN_MODESET_TIMEOUT cycles)
    timeout_counter = 0;
    while (((return_value & CAN_CR_RESET_VAL) != CAN_CR_RESET_VAL) && (timeout_counter < CAN_MODESET_TIMEOUT)) {
      can_io_send_data(CAN_CR_ADDR, (return_value | CAN_CR_RESET_VAL));    //don't change other bits...
      return_value = can_io_read_data(CAN_CR_ADDR);
      timeout_counter++;
    }

    //timeout occured - return an error
    if (timeout_counter >= CAN_MODESET_TIMEOUT) {
      return CAN_INIT_ERR;
    }

    //setup Clock Register and change to PELICAN Mode
    can_io_send_data(CAN_CDR_ADDR, CAN_CDR_PELICAN_VAL);

    //setup ACR and AMR register
    can_io_send_data(CAN_ACRPEL_ADDR, (acceptance_code & 0xff));
    can_io_send_data(CAN_ACRPEL_ADDR + 1, ((acceptance_code >> 8) & 0xff));
    can_io_send_data(CAN_ACRPEL_ADDR + 2, ((acceptance_code >> 16) & 0xff));
    can_io_send_data(CAN_ACRPEL_ADDR + 3, ((acceptance_code >> 24) & 0xff));
    can_io_send_data(CAN_AMRPEL_ADDR, (acceptance_mask & 0xff));
    can_io_send_data(CAN_AMRPEL_ADDR + 1, ((acceptance_mask >> 8) & 0xff));
    can_io_send_data(CAN_AMRPEL_ADDR + 2, ((acceptance_mask >> 16) & 0xff));
    can_io_send_data(CAN_AMRPEL_ADDR + 3, ((acceptance_mask >> 24) & 0xff));

    //setup BTR register depending on requested Baudrate
    if (baudrate == CAN_100_KBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_100K_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_100K_VAL);
    } else if (baudrate == CAN_250_KBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_250K_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_250K_VAL);
    } else if (baudrate == CAN_500_KBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_500K_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_500K_VAL);
    } else if (baudrate == CAN_1_MBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_1M_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_1M_VAL);
    } else {
      return CAN_INIT_ERR;
    }

    //setup OCR register
    can_io_send_data(CAN_OCR_ADDR, CAN_OCR_VAL);

    //setup IER register -> enable external interrupt to uC (message received and buffer overflow)
    can_io_send_data(CAN_IERPELI_ADDR, CAN_IER_VAL);

    //setup mode register --> end of RESET Mode
    can_io_send_data(CAN_MOD_ADDR, 0x00);
    return_value = can_io_read_data(CAN_MOD_ADDR);

    //if RESET mode Flag is not cleared, try to clear it
    timeout_counter = 0;
    while ((return_value != CAN_MOD_RUN_VAL) && (timeout_counter < CAN_MODESET_TIMEOUT)) {
      can_io_send_data(CAN_MOD_ADDR, CAN_MOD_RUN_VAL);    //don't change other bits...
      return_value = can_io_read_data(CAN_MOD_ADDR);
      timeout_counter++;
    }

    //timeout occured - return an error
    if (timeout_counter >= CAN_MODESET_TIMEOUT) {
      return CAN_INIT_ERR;
    }


    ///BASIC CAN Mode
  } else if (mode == CAN_MODE_BASIC) {

    //after RESET SJA1000 is in Basic CAN Mode --> Check for Reset Flag in CR
    return_value = can_io_read_data(CAN_CR_ADDR);

    //if RESET mode Flag is not set, try to set it (only for CAN_MODESET_TIMEOUT cycles)
    timeout_counter = 0;
    while (((return_value & CAN_CR_RESET_VAL) != CAN_CR_RESET_VAL) && (timeout_counter < CAN_MODESET_TIMEOUT)) {
      can_io_send_data(CAN_CR_ADDR, (return_value | CAN_CR_RESET_VAL));    //don't change other bits...
      return_value = can_io_read_data(CAN_CR_ADDR);
      timeout_counter++;
    }

    //timeout occured - return an error
    if (timeout_counter >= CAN_MODESET_TIMEOUT) {
      return CAN_INIT_ERR;
    }

    //setup Clock Register and change to BASIC CAN Mode
    can_io_send_data(CAN_CDR_ADDR, CAN_CDR_BASICCAN_VAL);

    //setup ACR and AMR register
    can_io_send_data(CAN_ACRBAS_ADDR, (acceptance_code & 0xff));
    can_io_send_data(CAN_AMRBAS_ADDR, (acceptance_mask & 0xff));

    //setup BTR register depending on requested Baudrate
    if (baudrate == CAN_100_KBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_100K_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_100K_VAL);
    } else if (baudrate == CAN_250_KBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_250K_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_250K_VAL);
    } else if (baudrate == CAN_500_KBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_500K_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_500K_VAL);
    } else if (baudrate == CAN_1_MBIT) {
      can_io_send_data(CAN_BTR0_ADDR, CAN_BTR0_1M_VAL);
      can_io_send_data(CAN_BTR1_ADDR, CAN_BTR1_1M_VAL);
    } else {
      return CAN_INIT_ERR;
    }

    //setup OCR register
    can_io_send_data(CAN_OCR_ADDR, CAN_OCR_VAL);

    //setup CR register  -> enable external interrupt to uC (message received and buffer overflow)
    //                   -> set end of reset mode
    can_io_send_data(CAN_CR_ADDR, CAN_CR_BASICCAN_RUN_VAL);
    return_value = can_io_read_data(CAN_CR_ADDR);

    //if RESET Flag is not cleared, try to clear it
    timeout_counter = 0;
    while ((return_value != CAN_CR_BASICCAN_RUN_VAL) && (timeout_counter < CAN_MODESET_TIMEOUT)) {
      can_io_send_data(CAN_CR_ADDR, CAN_CR_BASICCAN_RUN_VAL);    //don't change other bits...
      return_value = can_io_read_data(CAN_CR_ADDR);
      timeout_counter++;
    }

    //timeout occured - return an error
    if (timeout_counter >= CAN_MODESET_TIMEOUT) {
      return CAN_INIT_ERR;
    }


  }


  ///read Clock Divider Register = return_value
  return_value = can_io_read_data(CAN_CDR_ADDR);



  ///some tests... to be removed
  /* for (timeout_counter = 0; timeout_counter < 50; timeout_counter++) {
     can_io_send_data(CAN_CMR_ADDR, 0x10);
     _delay_ms(CAN_TIMING_POWERON_MS);
     _delay_ms(CAN_TIMING_POWERON_MS);
     _delay_ms(CAN_TIMING_POWERON_MS);
     can_io_send_data(CAN_CMR_ADDR, 0x12);
     _delay_ms(CAN_TIMING_POWERON_MS);
     _delay_ms(CAN_TIMING_POWERON_MS);
     _delay_ms(CAN_TIMING_POWERON_MS);
   }`*/

  return CAN_INIT_OK;

}



//!///////////////////////////////////////////////////////////////////////
///can_io_pin_init                                                      //
///                                                                     //
/// Description:                                                        //
///         Initializes the ATmegae I/O pins for interfacing the        //
///         SJA1000 CAN Controller.                                     //
///                                                                     //
/// input:                                                              //
///                -                                                    //
///                                                                     //
/// return:                                                             //
///                -                                                    //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////


void can_io_pin_init(void) {

  //set CAN I/O Ports/Pins
  CAN_ADDR_PORT = 0xff;            //CAN Address Port init value
  CAN_ADDR_DDR = 0xff;             //CAN_Address Port -> output port


  CAN_CTRL_PORT = CAN_CTRL_PORT & ~(1 << CAN_CTRL_ALE);
  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_CS) | (1 << CAN_CTRL_RST) | (1 << CAN_CTRL_RDE) | (1 << CAN_CTRL_WR);
  CAN_CTRL_DDR = CAN_CTRL_DDR | (1 << CAN_CTRL_CS) | (1 << CAN_CTRL_RST) | (1 << CAN_CTRL_RDE) | (1 << CAN_CTRL_WR) | (1 << CAN_CTRL_ALE);

  CAN_CTRL_PORT = CAN_CTRL_PORT | (1 << CAN_CTRL_INT);     //activate pull-up resisitor for INT input
  CAN_CTRL_DDR = CAN_CTRL_DDR & ~(1 << CAN_CTRL_INT);      //switch INT pin to input

}

