1

/*

     2

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

     3

     4

Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

AT91 Port: Peter CHRISTEN

     6

     7

See COPYING file for copyrights details.

     8

     9

This library is free software; you can redistribute it and/or

    10

modify it under the terms of the GNU Lesser General Public

    11

License as published by the Free Software Foundation; either

    12

version 2.1 of the License, or (at your option) any later version.

    13

    14

This library is distributed in the hope that it will be useful,

    15

but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17

Lesser General Public License for more details.

    18

    19

You should have received a copy of the GNU Lesser General Public

    20

License along with this library; if not, write to the Free Software

    21

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    22

*/

    23

    24

//#define DEBUG_WAR_CONSOLE_ON

    25

//#define DEBUG_ERR_CONSOLE_ON

    26

    27

#include "can_AT91.h"

    28

#include "canfestival.h"

    29

    30

void can_irq_handler(void);

    31

    32

unsigned char canInit(unsigned int bitrate)

    33

/******************************************************************************

    34

Initialize the hardware to receive CAN messages and start the timer for the

    35

CANopen stack.

    36

INPUT	

    37

OUTPUT	

    38

******************************************************************************/

    39

{

    40

  unsigned char i;

    41

  AT91S_CAN_MB *mb_ptr = AT91C_BASE_CAN_MB0;

    42

    43

  // Enable CAN PIOs

    44

  AT91F_CAN_CfgPIO();

    45

  // Enable CAN Clock

    46

  AT91F_CAN_CfgPMC();

    47

    48

  // Enable CAN Transceiver

    49

  AT91F_PIOA_CfgPMC();

    50

    51

  // Init CAN Interrupt Source Level

    52

  AT91F_AIC_ConfigureIt(AT91C_BASE_AIC,				// CAN base address

    53

                        AT91C_ID_CAN,				// CAN ID

    54

                        AT91C_AIC_PRIOR_HIGHEST,		// Max priority

    55

                        AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL,	// Level sensitive

    56

                        can_irq_handler);			// C Handler

    57

    58

  AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_CAN);

    59

    60

  if (bitrate <= 500)

    61

  {

    62

    // CANopen 10..500 kbit with 16 tq, sample point is at 14 tq

    63

    // all values are added to 1 by hardware

    64

    // Resynchronisation jump width (SJW)	= 1 tq

    65

    // Propagation Time Segment (PRS)		= 5 tq

    66

    // Phase Segment 1 (PHS1)			= 8 tq

    67

    // Phase Segment 2 (PHS2)			= 2 tq

    68

    // Total					= 16 tq

    69

    AT91F_CAN_CfgBaudrateReg(AT91C_BASE_CAN,

    70

                             (AT91C_MASTER_CLOCK/16/1000/bitrate - 1) << 16 | 0x0471);

    71

  }

    72

  else

    73

    return 0;

    74

    75

  // Enable CAN and Wait for WakeUp Interrupt

    76

//  AT91F_CAN_EnableIt(AT91C_BASE_CAN, AT91C_CAN_WAKEUP);

    77

  AT91F_CAN_CfgModeReg(AT91C_BASE_CAN, AT91C_CAN_CANEN);

    78

    79

  // Reset all mailsboxes (MBs), filters are zero (accept all) by clear all MB

    80

  // Set the lower MBs as rx buffer

    81

  for (i = 0; i < NB_RX_MB; i++, mb_ptr++)

    82

  // Configure receive MBs as receive buffer, last as receive overwrite

    83

    AT91F_InitMailboxRegisters(mb_ptr,

    84

				((i < (NB_RX_MB - 1)) ? AT91C_CAN_MOT_RX : AT91C_CAN_MOT_RXOVERWRITE)

    85

				| AT91C_CAN_PRIOR,	// Mailbox Mode Reg

    86

				0x00000000,		// Mailbox Acceptance Mask Reg

    87

				0x00000000,		// Mailbox ID Reg

    88

				0x00000000,		// Mailbox Data Low Reg

    89

				0x00000000,		// Mailbox Data High Reg

    90

				0x00000000);		// Mailbox Control Reg

    91

  for (   ; i < NB_MB; i++, mb_ptr++)

    92

  // Configure transmit MBs

    93

    AT91F_InitMailboxRegisters(mb_ptr,

    94

				AT91C_CAN_MOT_TX

    95

				| AT91C_CAN_PRIOR,	// Mailbox Mode Reg

    96

				0x00000000,		// Mailbox Acceptance Mask Reg

    97

				0x00000000,		// Mailbox ID Reg

    98

				0x00000000,		// Mailbox Data Low Reg

    99

				0x00000000,		// Mailbox Data High Reg

   100

				0x00000000);		// Mailbox Control Reg

   101

  // Enable Reception on all receive Mailboxes

   102

  AT91F_CAN_InitTransferRequest(AT91C_BASE_CAN, RX_INT_MSK);

   103

  // Enable all receive interrupts

   104

  AT91F_CAN_EnableIt(AT91C_BASE_CAN, RX_INT_MSK);

   105

  return 1;

   106

}

   107

   108

unsigned char canSend(CAN_PORT notused, Message *m)

   109

/******************************************************************************

   110

The driver send a CAN message passed from the CANopen stack

   111

INPUT	CAN_PORT is not used (only 1 avaiable)

   112

	Message *m pointer to message to send

   113

OUTPUT	1 if  hardware -> CAN frame

   114

******************************************************************************/

   115

{

   116

  unsigned int mask;

   117

  AT91S_CAN_MB *mb_ptr = AT91C_BASE_CAN_MB0 + START_TX_MB;

   118

   119

  if ((AT91F_CAN_GetStatus(AT91C_BASE_CAN) & TX_INT_MSK) == 0)

   120

    return 0;			// No free MB for sending

   121

   122

  for (mask = 1 << START_TX_MB;

   123

       (mask & TX_INT_MSK) && !(AT91F_CAN_GetStatus(AT91C_BASE_CAN) & mask);

   124

	mask <<= 1, mb_ptr++)	// Search the first free MB

   125

  {

   126

  }

   127

  AT91F_CAN_CfgMessageIDReg(mb_ptr, m->cob_id, 0);	// Set cob id

   128

  // Mailbox Control Register, set remote transmission request and data lenght code

   129

  AT91F_CAN_CfgMessageCtrlReg(mb_ptr, m->rtr ? AT91C_CAN_MRTR : 0 | (m->len << 16));	

   130

  AT91F_CAN_CfgMessageDataLow(mb_ptr, *(UNS32*)(&m->data[0]));// Mailbox Data Low Reg

   131

  AT91F_CAN_CfgMessageDataHigh(mb_ptr, *(UNS32*)(&m->data[4]));// Mailbox Data High Reg

   132

  // Start sending by writing the MB configuration register to transmit

   133

  AT91F_CAN_InitTransferRequest(AT91C_BASE_CAN, mask);

   134

  return 1;	// successful

   135

}

   136

   137

unsigned char canReceive(Message *m)

   138

/******************************************************************************

   139

The driver passes a received CAN message to the stack

   140

INPUT	Message *m pointer to received CAN message

   141

OUTPUT	1 if a message received

   142

******************************************************************************/

   143

{

   144

  unsigned int mask;

   145

  AT91S_CAN_MB *mb_ptr = AT91C_BASE_CAN_MB0;

   146

   147

  if ((AT91F_CAN_GetStatus(AT91C_BASE_CAN) & RX_INT_MSK) == 0)

   148

    return 0;		// Nothing received

   149

   150

  for (mask = 1;

   151

       (mask & RX_INT_MSK) && !(AT91F_CAN_GetStatus(AT91C_BASE_CAN) & mask);

   152

	mask <<= 1, mb_ptr++)	// Search the first MB received

   153

  {

   154

  }

   155

  m->cob_id = AT91F_CAN_GetFamilyID(mb_ptr);

   156

  m->len = (AT91F_CAN_GetMessageStatus(mb_ptr) & AT91C_CAN_MDLC) >> 16;

   157

  m->rtr = (AT91F_CAN_GetMessageStatus(mb_ptr) & AT91C_CAN_MRTR) ? 1 : 0;

   158

  *(UNS32*)(&m->data[0]) = AT91F_CAN_GetMessageDataLow(mb_ptr);

   159

  *(UNS32*)(&m->data[4]) = AT91F_CAN_GetMessageDataHigh(mb_ptr);

   160

  // Enable Reception on Mailbox

   161

  AT91F_CAN_CfgMessageModeReg(mb_ptr, AT91C_CAN_MOT_RX | AT91C_CAN_PRIOR);

   162

  AT91F_CAN_InitTransferRequest(AT91C_BASE_CAN, mask);

   163

  return 1;		// message received

   164

}

   165

   166

/******************************************************************************

   167

   168

 ******************************* CAN INTERRUPT  *******************************/

   169

   170

void can_irq_handler(void)

   171

/******************************************************************************

   172

CAN Interrupt

   173

******************************************************************************/

   174

{

   175

  volatile unsigned int status;

   176

  static Message m = Message_Initializer;		// contain a CAN message

   177

   178

  status = AT91F_CAN_GetStatus(AT91C_BASE_CAN) & AT91F_CAN_GetInterruptMaskStatus(AT91C_BASE_CAN);

   179

   180

  if(status & RX_INT_MSK)

   181

  {	// Rx Interrupt

   182

    if (canReceive(&m))			// a message received

   183

      canDispatch(&ObjDict_Data, &m);         // process it

   184

  }

   185

}