Re: [U-Boot] [PATCH] add u-boot sja1000/can support

Do we have boards that use this code?

Matthias

On Saturday 24 October 2009 06:17, miaofng wrote:

...

From 1f6aaba856fbf484c442eb33cf220774d57fba8d Mon Sep 17 00:00:00 2001

From: miaofng miaofng@gmail.com Date: Fri, 23 Oct 2009 17:06:50 +0800 Subject: [PATCH] [can] add u-boot sja1000/can support

Signed-off-by: miaofng miaofng@gmail.com

Makefile | 1 + drivers/can/Makefile | 46 ++++ drivers/can/can_core.c | 266 ++++++++++++++++++++++ drivers/can/sja1000.c | 584 ++++++++++++++++++++++++++++++++++++++++++++++++ drivers/can/sja1000.h | 160 +++++++++++++ include/can.h | 216 ++++++++++++++++++ include/can_error.h | 93 ++++++++ include/candev.h | 46 ++++ lib_arm/board.c | 2 + 9 files changed, 1414 insertions(+), 0 deletions(-) create mode 100755 drivers/can/Makefile create mode 100755 drivers/can/can_core.c create mode 100755 drivers/can/sja1000.c create mode 100755 drivers/can/sja1000.h create mode 100755 include/can.h create mode 100755 include/can_error.h create mode 100755 include/candev.h mode change 100644 => 100755 lib_arm/board.c

diff --git a/Makefile b/Makefile index d6d6368..1ba59f8 100755 --- a/Makefile +++ b/Makefile @@ -203,6 +203,7 @@ LIBS += net/libnet.a LIBS += disk/libdisk.a LIBS += drivers/bios_emulator/libatibiosemu.a LIBS += drivers/block/libblock.a +LIBS += drivers/can/libcan.a LIBS += drivers/dma/libdma.a LIBS += drivers/fpga/libfpga.a LIBS += drivers/gpio/libgpio.a diff --git a/drivers/can/Makefile b/drivers/can/Makefile new file mode 100755 index 0000000..d3d47bb --- /dev/null +++ b/drivers/can/Makefile @@ -0,0 +1,46 @@ +# +# Copyright (C) 2009 miaofngmiaofng@126.com +# +# See file CREDITS for list of people who contributed to this +# project. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +#

+include $(TOPDIR)/config.mk

+LIB := $(obj)libcan.a

+COBJS-y += can_core.o +COBJS-$(CONFIG_DRIVER_SJA1000) += sja1000.o

+COBJS := $(sort $(COBJS-y)) +SRCS := $(COBJS:.o=.c) +OBJS := $(addprefix $(obj),$(COBJS))

+all: $(LIB)

+$(LIB): $(obj).depend $(OBJS)

• $(AR) $(ARFLAGS) $@ $(OBJS)

+#########################################################################

+# defines $(obj).depend target +include $(SRCTREE)/rules.mk

+sinclude $(obj).depend

+######################################################################### diff --git a/drivers/can/can_core.c b/drivers/can/can_core.c new file mode 100755 index 0000000..a723e8a --- /dev/null +++ b/drivers/can/can_core.c @@ -0,0 +1,266 @@ +/*

• • Copyright (C) 2009 miaofngmiaofng@gmail.com
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the version 2 of the GNU General Public License
• • as published by the Free Software Foundation
• • 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 General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
• */

+#include <common.h> +#include <can.h> +#include <malloc.h>

+#define can_debug printf +#define can_error printf

+#ifdef CONFIG_CMD_CAN +#ifndef CONFIG_CAN_DEV_MAX +#define CONFIG_CAN_DEV_MAX 8 +#endif

+static struct can_device *can_devs[CONFIG_CAN_DEV_MAX]; +#endif

+static inline struct can_device* index_to_cdev(int index) +{

• return (index<CONFIG_CAN_DEV_MAX)? can_devs[index]:0;

+}

+static inline int cdev_to_index(struct can_device *dev) +{

• return (dev)?dev->index:-1;

+}

+static void canif_tx(struct can_device *dev) +{

• struct can_frame *cf;
• int len;
• len = buf_pop(&dev->tbuf, (char*)&cf, sizeof(cf));
• if(len == sizeof(cf)) {

• dev->start_xmit(cf, dev);
  

• free(cf);
  

• }

+}

+void canif_rx(struct can_frame *cf, struct can_device *dev) +{

• int len;
• //error frame?
• if(cf->can_id&CAN_ERR_FLAG)
• {

• //error frame, drop it
  

• free(cf);
  

• return;
  

• }
• //soft id filter?
• //store to cirbuf
• if(dev->rbuf.size == dev->rbuf.totalsize) {

• can_debug("CAN: rx buffer is full\n");
  

• dev->stats.rx_dropped ++;
  

• free(cf);
  

• return;
  

• }
• buf_push(&dev->rbuf, (char*)&cf, sizeof(cf));

+}

+void canif_wake_queue(struct can_device *dev) +{

• canif_start_queue(dev);
• canif_tx(dev);

+}

+int can_init(void) +{ +#ifdef CONFIG_CMD_CAN

• int index;
• for(index = 0; index < CONFIG_CAN_DEV_MAX; index ++) can_devs[index] = 0;
• board_can_init();

+#endif

• return 0;

+}

+/*

• • Register the CAN network device
• */
• #ifndef CONFIG_CAN_BUF_TX_SZ
• #define CONFIG_CAN_BUF_TX_SZ (8*sizeof(void*))
• #endif
• #ifndef CONFIG_CAN_BUF_RX_SZ
• #define CONFIG_CAN_BUF_RX_SZ (8*sizeof(void*))
• #endif

+int register_candev(struct can_device *dev) +{

• int ret;
• int index;
• //insert into the list
• dev->index = -1;
• for(index =0; index < CONFIG_CAN_DEV_MAX; index ++)
• {

• if(!can_devs[index]) {
  

• 	can_devs[index] = dev;
  

• 	dev->index = index;
  

• 	break;
  

• }
  

• }
• if( dev->index < 0)

• can_debug("CAN: too many can devices\n");
  

• //allocate circbuf for tx and rx
• ret = buf_init(&dev->tbuf, CONFIG_CAN_BUF_TX_SZ);
• if(ret != 1) {

• can_debug("CAN: cann't init cirbuf of tx\n");
  

• can_devs[index] = 0;
  

• return -1;
  

• }
• ret = buf_init(&dev->rbuf, CONFIG_CAN_BUF_RX_SZ);
• if(ret != 1) {

• can_debug("CAN: cann't init cirbuf of rx\n");
  

• can_devs[index] = 0;
  

• buf_free(&dev->tbuf);
  

• return -1;
  

• }
• dev->qstatus = CAN_QUEUE_INIT;
• //success
• printf("CAN: %s @index %d\n", dev->name, dev->index);
• return 0;

+}

+/*

• • Unregister the CAN network device
• */

+void unregister_candev(struct can_device *dev) +{

• int index = cdev_to_index(dev);
• if(index < 0) {

• can_debug("CAN: invalid para\n");
  

• return;
  

• }
• //close the dev first
• can_close((int)dev);
• //release tx/rx buffer
• buf_free(&dev->tbuf);
• buf_free(&dev->rbuf);
• //remove from the list
• can_devs[index] = 0;

+}

+//api +int can_setbrg(int brg, int index) +{

• struct can_device *dev = index_to_cdev(index);
• if(!dev) {

• can_debug("CAN: invalid para\n");
  

• return -1;
  

• }
• if( dev->state != CAN_STATE_STOPPED) {

• can_debug("CAN: invalid dev status<%d>\n", dev->state);
  

• return -1;
  

• }
• if(dev->setbrg)

• return dev->setbrg(brg, dev);
  

• can_debug("CAN: op not supported by the dev\n");
• return -1;

+}

+int can_open(int index) +{

• struct can_device *dev = index_to_cdev(index);
• if(!dev) {

• can_debug("CAN: invalid para\n");
  

• return 0;
  

• }
• if(dev->state != CAN_STATE_STOPPED) {

• can_debug("CAN: invalid dev status<%d>\n", dev->state);
  

• return 0;
  

• }
• if(dev && dev->open) dev->open(dev);
• return (int)dev;

+}

+void can_close(int dev_id) +{

• struct can_device *dev = (struct can_device*) dev_id;
• struct can_frame *cf;
• if(!dev) {

• can_debug("CAN: invalid para\n");
  

• return;
  

• }
• //can device close
• if(dev->close) dev->close(dev);
• //tbuf,rbuf dump
• while(buf_pop(&dev->tbuf, (char*)&cf, sizeof(cf)) ) free(cf);
• while(buf_pop(&dev->rbuf, (char*)&cf, sizeof(cf)) ) free(cf);

+}

+//non block write +int can_send(struct can_frame *cf, int dev_id) +{

• struct can_device *dev = (struct can_device*) dev_id;
• if(!cf || !dev ) {

• can_debug("CAN: invalid para\n");
  

• return -1;
  

• }
• if(dev->tbuf.size == dev->tbuf.totalsize){ //tbuf overflow

• can_debug("CAN: tx buffer is full\n");
  

• return -1;
  

• }
• buf_push(&dev->tbuf, (char*)&cf, sizeof(cf));
• //start queue?
• if( dev->qstatus == CAN_QUEUE_READY )

• canif_tx(dev);
  

• return 0;

+}

+//non block read +struct can_frame* can_recv(int dev_id) +{

• struct can_device *dev = (struct can_device*) dev_id;
• struct can_frame *cf;
• int len;
• if(!dev ) {

• can_debug("CAN: invalid para\n");
  

• return 0;
  

• }
• len = buf_pop(&dev->rbuf, (char*)&cf, sizeof(cf));
• if(len != sizeof(cf)) return (struct can_frame*)0;
• else return cf;

+} diff --git a/drivers/can/sja1000.c b/drivers/can/sja1000.c new file mode 100755 index 0000000..07560bd --- /dev/null +++ b/drivers/can/sja1000.c @@ -0,0 +1,584 @@ +/*

• • sja1000.c - Philips SJA1000 network device driver
• • Copyright (c) 2009 miaofngmiaofng@gmail.com
• • Copyright (c) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33,
• • 38106 Braunschweig, GERMANY
• • Copyright (c) 2002-2007 Volkswagen Group Electronic Research
• • All rights reserved.
• • Redistribution and use in source and binary forms, with or without
• • modification, are permitted provided that the following conditions
• • are met:
• • 1. Redistributions of source code must retain the above copyright
• • notice, this list of conditions and the following disclaimer.
• • 2. Redistributions in binary form must reproduce the above copyright
• • notice, this list of conditions and the following disclaimer in the
• • documentation and/or other materials provided with the distribution.
• • 3. Neither the name of Volkswagen nor the names of its contributors
• • may be used to endorse or promote products derived from this software
• • without specific prior written permission.
• • Alternatively, provided that this notice is retained in full, this
• • software may be distributed under the terms of the GNU General
• • Public License ("GPL") version 2, in which case the provisions of the
• • GPL apply INSTEAD OF those given above.
• • The provided data structures and external interfaces from this code
• • are not restricted to be used by modules with a GPL compatible license.
• • THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
• • "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
• • LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
• • A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
• • OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
• • SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
• • LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
• • DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
• • THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
• • (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
• • OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
• • DAMAGE.
• • Send feedback to socketcan-users@lists.berlios.de
• */

+#include <common.h> +#include <asm/io.h> +#include <can.h> +#include <malloc.h> +#include <linux/string.h>

+#include "sja1000.h"

+#define DRV_NAME "sja1000"

+//MODULE_AUTHOR("Oliver Hartkopp oliver.hartkopp@volkswagen.de"); +//MODULE_LICENSE("Dual BSD/GPL"); +//MODULE_DESCRIPTION(DRV_NAME "CAN netdevice driver");

+#define sja_debug printf

+/*

• • Flags for sja1000priv.flags
• */

+#define SJA1000_CUSTOM_IRQ_HANDLER 0x1

+/*

• • SJA1000 private data structure
• */

+struct sja1000_priv {

• struct can_device can; /* must be the first member */
• /* the lower-layer is responsible for appropriate locking */
• void* reg_base; /* ioremap'ed address to registers */
• u8 (*read_reg) (const struct sja1000_priv *priv, u8 reg);
• void (*write_reg) (const struct sja1000_priv *priv, u8 reg, u8 val);

+};

+static int set_reset_mode(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• unsigned char status = priv->read_reg(priv, REG_MOD);
• int i;
• /* disable interrupts */
• priv->write_reg(priv, REG_IER, IRQ_OFF);
• for (i = 0; i < 100; i++) {

• /* check reset bit */
  

• if (status & MOD_RM) {
  

• 	priv->can.state = CAN_STATE_STOPPED;
  

• 	return 0;
  

• }
  

• priv->write_reg(priv, REG_MOD, MOD_RM);	/* reset chip */
  

• udelay(10);
  

• status = priv->read_reg(priv, REG_MOD);
  

• }
• //sja_debug("SJA1000: setting into reset mode failed!\n");
• return -1;

+}

+static void set_normal_mode(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• unsigned char status = priv->read_reg(priv, REG_MOD);
• int i;
• for (i = 0; i < 100; i++) {

• /* check reset bit */
  

• if ((status & MOD_RM) == 0) {
  

• 	priv->can.state = CAN_STATE_ERROR_ACTIVE;
  

• 	/* enable all interrupts */
  

• 	priv->write_reg(priv, REG_IER, IRQ_ALL);
  

• 	return;
  

• }
  

• /* set chip to normal mode */
  

• priv->write_reg(priv, REG_MOD, 0x00);
  

• udelay(10);
  

• status = priv->read_reg(priv, REG_MOD);
  

• }
• sja_debug("SJA1000@%d: setting into normal mode failed!\n", dev->index);

+}

+static void sja1000_start(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• /* leave reset mode */
• if (priv->can.state != CAN_STATE_STOPPED)

• set_reset_mode(dev);
  

• /* Clear error counters and error code capture */
• priv->write_reg(priv, REG_TXERR, 0x0);
• priv->write_reg(priv, REG_RXERR, 0x0);
• priv->read_reg(priv, REG_ECC);
• /* leave reset mode */
• set_normal_mode(dev);

+}

+#ifndef CONFIG_SJA1000_CLK_HZ +#define CONFIG_SJA1000_CLK_HZ 24000000 +#endif

+static int sja1000_setbrg(int brg, struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• int fosc = CONFIG_SJA1000_CLK_HZ;
• int fscl, btr0, btr1;
• u8 sjw = 1; // 0~3 +1
• u8 brp; // 0~63 +1
• u8 sam = 1; // 0~1
• u8 tseg2 = 5; // 0~7 +1
• u8 tseg1 = 6; // 0~15 +1
• //calculation
• fscl = (1+tseg1+tseg2)*brg;
• brp = (fosc>>1)/fscl;
• if(brg > 250000) sam = 0;
• //set register
• btr0 = ((sjw - 1) << 6) | (brp - 1);
• btr1 = (sam << 7) | ((tseg2 -1) << 4) | (tseg1 -1);
• sja_debug("SJA1000@%d: setting BTR0=0x%02x BTR1=0x%02x\n", dev->index, btr0, btr1);
• priv->write_reg(priv, REG_BTR0, btr0);
• priv->write_reg(priv, REG_BTR1, btr1);
• return 0;

+}

+/*

• • initialize SJA1000 chip:
• • • reset chip
• • • set output mode
• • • set baudrate
• • • enable interrupts
• • • start operating mode
• */

+static void chipset_init(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• /* set clock divider and output control register */
• priv->write_reg(priv, REG_CDR, CDR_PELICAN|CDR_CBP|CDR_CLK_OFF);
• /* set acceptance filter (accept all) */
• priv->write_reg(priv, REG_ACCC0, 0x00);
• priv->write_reg(priv, REG_ACCC1, 0x00);
• priv->write_reg(priv, REG_ACCC2, 0x00);
• priv->write_reg(priv, REG_ACCC3, 0x00);
• priv->write_reg(priv, REG_ACCM0, 0xFF);
• priv->write_reg(priv, REG_ACCM1, 0xFF);
• priv->write_reg(priv, REG_ACCM2, 0xFF);
• priv->write_reg(priv, REG_ACCM3, 0xFF);
• priv->write_reg(priv, REG_OCR, OCR_TX0_PUSHPULL|OCR_TX1_PUSHPULL| OCR_MODE_NORMAL);

+}

+/*

• • transmit a CAN message
• */

+static int sja1000_start_xmit(struct can_frame *cf, struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• struct can_device_stats *stats = &dev->stats;
• uint8_t fi;
• uint8_t dlc;
• canid_t id;
• uint8_t dreg;
• int i;
• canif_stop_queue(dev);
• fi = dlc = cf->can_dlc;
• id = cf->can_id;
• if (id & CAN_RTR_FLAG)

• fi |= FI_RTR;
  

• if (id & CAN_EFF_FLAG) {

• fi |= FI_FF;
  

• dreg = EFF_BUF;
  

• priv->write_reg(priv, REG_FI, fi);
  

• priv->write_reg(priv, REG_ID1, (id & 0x1fe00000) >> (5 + 16));
  

• priv->write_reg(priv, REG_ID2, (id & 0x001fe000) >> (5 + 8));
  

• priv->write_reg(priv, REG_ID3, (id & 0x00001fe0) >> 5);
  

• priv->write_reg(priv, REG_ID4, (id & 0x0000001f) << 3);
  

• } else {

• dreg = SFF_BUF;
  

• priv->write_reg(priv, REG_FI, fi);
  

• priv->write_reg(priv, REG_ID1, (id & 0x000007f8) >> 3);
  

• priv->write_reg(priv, REG_ID2, (id & 0x00000007) << 5);
  

• }
• for (i = 0; i < dlc; i++)

• priv->write_reg(priv, dreg++, cf->data[i]);
  

• priv->write_reg(priv, REG_CMR, CMD_TR);
• stats->tx_bytes += dlc;
• return 0;

+}

+static void sja1000_rx(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• struct can_device_stats *stats = &dev->stats;
• struct can_frame *cf;
• uint8_t fi;
• uint8_t dreg;
• canid_t id;
• uint8_t dlc;
• int i;
• cf = malloc(sizeof(struct can_frame));
• if (cf == NULL) {

• sja_debug("SJA1000%d: out of mem!\n",dev->index);
  

• return;
  

• }
• fi = priv->read_reg(priv, REG_FI);
• dlc = fi & 0x0F;
• if (fi & FI_FF) {

• /* extended frame format (EFF) */
  

• dreg = EFF_BUF;
  

• id = (priv->read_reg(priv, REG_ID1) << (5 + 16))
  

•     | (priv->read_reg(priv, REG_ID2) << (5 + 8))
  

•     | (priv->read_reg(priv, REG_ID3) << 5)
  

•     | (priv->read_reg(priv, REG_ID4) >> 3);
  

• id |= CAN_EFF_FLAG;
  

• } else {

• /* standard frame format (SFF) */
  

• dreg = SFF_BUF;
  

• id = (priv->read_reg(priv, REG_ID1) << 3)
  

•     | (priv->read_reg(priv, REG_ID2) >> 5);
  

• }
• if (fi & FI_RTR)

• id |= CAN_RTR_FLAG;
  

• memset(cf, 0, sizeof(struct can_frame));
• cf->can_id = id;
• cf->can_dlc = dlc;
• for (i = 0; i < dlc; i++)

• cf->data[i] = priv->read_reg(priv, dreg++);
  

• while (i < 8)

• cf->data[i++] = 0;
  

• /* release receive buffer */
• priv->write_reg(priv, REG_CMR, CMD_RRB);
• canif_rx(cf, dev);
• //dev->last_rx = jiffies;
• stats->rx_packets++;
• stats->rx_bytes += dlc;

+}

+static int sja1000_err(struct can_device *dev, uint8_t isrc, uint8_t status) +{

• struct sja1000_priv *priv = candev_priv(dev);
• struct can_device_stats *stats = &dev->stats;
• struct can_frame *cf;
• enum can_state state = priv->can.state;
• uint8_t ecc, alc;
• cf = malloc(sizeof(struct can_frame));
• if (cf == NULL)
• {

• sja_debug("SJA1000@%d: out of mem!\n", dev->index);
  

• return -1;
  

• }
• memset(cf, 0, sizeof(struct can_frame));
• cf->can_id = CAN_ERR_FLAG;
• cf->can_dlc = CAN_ERR_DLC;
• if (isrc & IRQ_DOI) {

• /* data overrun interrupt */
  

• sja_debug("SJA1000@%d: data overrun interrupt\n", dev->index);
  

• cf->can_id |= CAN_ERR_CRTL;
  

• cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
  

• //stats->rx_over_errors++;
  

• stats->rx_errors++;
  

• priv->write_reg(priv, REG_CMR, CMD_CDO);	/* clear bit */
  

• }
• if (isrc & IRQ_EI) {

• /* error warning interrupt */
  

• sja_debug("SJA1000@%d: error warning interrupt\n", dev->index);
  

• if (status & SR_BS) {
  

• 	state = CAN_STATE_BUS_OFF;
  

• 	cf->can_id |= CAN_ERR_BUSOFF;
  

• 	//can_bus_off(dev);
  

• } else if (status & SR_ES) {
  

• 	state = CAN_STATE_ERROR_WARNING;
  

• } else
  

• 	state = CAN_STATE_ERROR_ACTIVE;
  

• }
• if (isrc & IRQ_BEI) {

• /* bus error interrupt */
  

• priv->can.stats.bus_error++;
  

• stats->rx_errors++;
  

• ecc = priv->read_reg(priv, REG_ECC);
  

• cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
  

• switch (ecc & ECC_MASK) {
  

• case ECC_BIT:
  

• 	cf->data[2] |= CAN_ERR_PROT_BIT;
  

• 	break;
  

• case ECC_FORM:
  

• 	cf->data[2] |= CAN_ERR_PROT_FORM;
  

• 	break;
  

• case ECC_STUFF:
  

• 	cf->data[2] |= CAN_ERR_PROT_STUFF;
  

• 	break;
  

• default:
  

• 	cf->data[2] |= CAN_ERR_PROT_UNSPEC;
  

• 	cf->data[3] = ecc & ECC_SEG;
  

• 	break;
  

• }
  

• /* error occured during transmission? */
  

• if ((ecc & ECC_DIR) == 0)
  

• 	cf->data[2] |= CAN_ERR_PROT_TX;
  

• }
• if (isrc & IRQ_EPI) {

• /* error passive interrupt */
  

• sja_debug("SJA1000@%d: error passive interrupt\n", dev->index);
  

• if (status & SR_ES)
  

• 	state = CAN_STATE_ERROR_PASSIVE;
  

• else
  

• 	state = CAN_STATE_ERROR_ACTIVE;
  

• }
• if (isrc & IRQ_ALI) {

• /* arbitration lost interrupt */
  

• sja_debug("SJA1000@%d: arbitration lost interrupt\n", dev->index);
  

• alc = priv->read_reg(priv, REG_ALC);
  

• priv->can.stats.arbitration_lost++;
  

• stats->rx_errors++;
  

• cf->can_id |= CAN_ERR_LOSTARB;
  

• cf->data[0] = alc & 0x1f;
  

• }
• if (state != priv->can.state && (state == CAN_STATE_ERROR_WARNING ||

• 			 state == CAN_STATE_ERROR_PASSIVE)) {
  

• uint8_t rxerr = priv->read_reg(priv, REG_RXERR);
  

• uint8_t txerr = priv->read_reg(priv, REG_TXERR);
  

• cf->can_id |= CAN_ERR_CRTL;
  

• if (state == CAN_STATE_ERROR_WARNING) {
  

• 	priv->can.stats.error_warning++;
  

• 	cf->data[1] = (txerr > rxerr) ?
  

• 		CAN_ERR_CRTL_TX_WARNING :
  

• 		CAN_ERR_CRTL_RX_WARNING;
  

• } else {
  

• 	priv->can.stats.error_passive++;
  

• 	cf->data[1] = (txerr > rxerr) ?
  

• 		CAN_ERR_CRTL_TX_PASSIVE :
  

• 		CAN_ERR_CRTL_RX_PASSIVE;
  

• }
  

• }
• priv->can.state = state;
• canif_rx(cf,dev);
• return 0;

+}

+#define SJA1000_MAX_IRQ 20 /* max. number of interrupts handled in ISR */

+int sja1000_interrupt(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• struct can_device_stats *stats = &dev->stats;
• uint8_t isrc, status;
• int n = 0;
• /* Shared interrupts and IRQ off? */
• if (priv->read_reg(priv, REG_IER) == IRQ_OFF)

• return -1;
  

• while ((isrc = priv->read_reg(priv, REG_IR)) && (n < SJA1000_MAX_IRQ)) {

• n++;
  

• status = priv->read_reg(priv, REG_SR);
  

• if (isrc & IRQ_WUI)
  

• 	sja_debug("SJA1000@%d: wakeup interrupt\n", dev->index);
  

• if (isrc & IRQ_TI) {
  

• 	/* transmission complete interrupt */
  

• 	stats->tx_packets++;
  

• 	//can_get_echo_skb(dev, 0);
  

• 	canif_wake_queue(dev);
  

• }
  

• if (isrc & IRQ_RI) {
  

• 	/* receive interrupt */
  

• 	while (status & SR_RBS) {
  

• 		sja1000_rx(dev);
  

• 		status = priv->read_reg(priv, REG_SR);
  

• 	}
  

• }
  

• if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) {
  

• 	/* error interrupt */
  

• 	if (sja1000_err(dev, isrc, status))
  

• 		break;
  

• }
  

• }
• if (n >= SJA1000_MAX_IRQ)

• sja_debug("SJA1000@%d: %d messages handled in ISR", dev->index, n);
  

• return (n) ? 0 : -1;

+}

+static int sja1000_open(struct can_device *dev) +{

• /* set chip into reset mode */
• set_reset_mode(dev);
• /* register interrupt handler, if not done by the device driver */

+#ifdef CONFIG_USBCAN

• extern int request_irq_usbcan(int (*isr)(struct can_device*), struct can_device*);
• int err = request_irq_usbcan(&sja1000_interrupt, dev);
• if (err) {

• sja_debug("SJA1000@%d: unable to request the irq\n", dev->index);
  

• return -1;
  

• }

+#endif

• /* init and start chi */
• sja1000_start(dev);
• //priv->open_time = jiffies;
• canif_start_queue(dev);
• return 0;

+}

+static int sja1000_close(struct can_device *dev) +{

• canif_stop_queue(dev);
• set_reset_mode(dev);
• //can_free_irq(dev->irq, (void *)dev);
• return 0;

+}

+static int sja1000_probe_chip(struct can_device *dev) +{

• struct sja1000_priv *priv = candev_priv(dev);
• int ret;
• ret = set_reset_mode(dev);
• if(ret) {

• sja_debug("%s: probing @0x%x failed\n", DRV_NAME, (u32)(priv->reg_base));
  

• return -1;
  

• }
• return 0;

+}

+int register_sja1000dev(struct can_device *dev) +{

• if (sja1000_probe_chip(dev))

• return -1;
  

• strcpy(dev->name, DRV_NAME);
• dev->setbrg = sja1000_setbrg;
• dev->open = sja1000_open;
• dev->start_xmit = sja1000_start_xmit;
• dev->close = sja1000_close;
• set_reset_mode(dev);
• chipset_init(dev);
• return register_candev(dev);

+}

+void unregister_sja1000dev(struct can_device *dev) +{

• set_reset_mode(dev);
• unregister_candev(dev);

+}

+static u8 sja1000_read_reg(const struct sja1000_priv *priv, u8 reg) +{ +#if (CONFIG_USBCAN == 1)

• writeb(reg, priv->reg_base+4); //addr latch
• return readb(priv->reg_base);

+#else

• return writeb(priv->reg_base + reg);

+#endif +}

+static void sja1000_write_reg(const struct sja1000_priv *priv, u8 reg, u8 val) +{ +#if (CONFIG_USBCAN == 1)

• writeb(reg, priv->reg_base+4); //addr latch
• writeb(val, priv->reg_base);

+#else

• return readb(val, priv->reg_base + reg);

+#endif +}

+int sja1000_init(u32 reg_base) +{

• struct sja1000_priv * priv = malloc(sizeof(struct sja1000_priv));
• if(priv == NULL) {

• sja_debug("SJA1000:  out of mem!!!\n");
  

• return -1;
  

• }
• memset(priv, 0, sizeof(priv));
• priv->reg_base = (void*)reg_base;
• priv->read_reg = sja1000_read_reg;
• priv->write_reg = sja1000_write_reg;
• if( register_sja1000dev(&priv->can) )
• {

• free(priv);
  

• //sja_debug("SJA1000: register device fail!!!\n");
  

• return -1;
  

• }
• return 0;

+} diff --git a/drivers/can/sja1000.h b/drivers/can/sja1000.h new file mode 100755 index 0000000..6311f75 --- /dev/null +++ b/drivers/can/sja1000.h @@ -0,0 +1,160 @@ +/*

• • sja1000.h - Philips SJA1000 network device driver
• • Copyright (C) 2009 miaofngmiaofng@126.com
• • Copyright (c) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33,
• • 38106 Braunschweig, GERMANY
• • Copyright (c) 2002-2007 Volkswagen Group Electronic Research
• • All rights reserved.
• • Redistribution and use in source and binary forms, with or without
• • modification, are permitted provided that the following conditions
• • are met:
• • 1. Redistributions of source code must retain the above copyright
• • notice, this list of conditions and the following disclaimer.
• • 2. Redistributions in binary form must reproduce the above copyright
• • notice, this list of conditions and the following disclaimer in the
• • documentation and/or other materials provided with the distribution.
• • 3. Neither the name of Volkswagen nor the names of its contributors
• • may be used to endorse or promote products derived from this software
• • without specific prior written permission.
• • Alternatively, provided that this notice is retained in full, this
• • software may be distributed under the terms of the GNU General
• • Public License ("GPL") version 2, in which case the provisions of the
• • GPL apply INSTEAD OF those given above.
• • The provided data structures and external interfaces from this code
• • are not restricted to be used by modules with a GPL compatible license.
• • THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
• • "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
• • LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
• • A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
• • OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
• • SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
• • LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
• • DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
• • THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
• • (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
• • OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
• • DAMAGE.
• • Send feedback to socketcan-users@lists.berlios.de
• */

+#ifndef SJA1000_DEV_H +#define SJA1000_DEV_H

+/* SJA1000 registers - manual section 6.4 (Pelican Mode) */ +#define REG_MOD 0x00 +#define REG_CMR 0x01 +#define REG_SR 0x02 +#define REG_IR 0x03 +#define REG_IER 0x04 +#define REG_ALC 0x0B +#define REG_ECC 0x0C +#define REG_EWL 0x0D +#define REG_RXERR 0x0E +#define REG_TXERR 0x0F +#define REG_ACCC0 0x10 +#define REG_ACCC1 0x11 +#define REG_ACCC2 0x12 +#define REG_ACCC3 0x13 +#define REG_ACCM0 0x14 +#define REG_ACCM1 0x15 +#define REG_ACCM2 0x16 +#define REG_ACCM3 0x17 +#define REG_RMC 0x1D +#define REG_RBSA 0x1E

+/* Common registers - manual section 6.5 */ +#define REG_BTR0 0x06 +#define REG_BTR1 0x07 +#define REG_OCR 0x08 +#define REG_CDR 0x1F

+#define REG_FI 0x10 +#define SFF_BUF 0x13 +#define EFF_BUF 0x15

+#define FI_FF 0x80 +#define FI_RTR 0x40

+#define REG_ID1 0x11 +#define REG_ID2 0x12 +#define REG_ID3 0x13 +#define REG_ID4 0x14

+#define CAN_RAM 0x20

+/* mode register */ +#define MOD_RM 0x01 +#define MOD_LOM 0x02 +#define MOD_STM 0x04 +#define MOD_AFM 0x08 +#define MOD_SM 0x10

+/* commands */ +#define CMD_SRR 0x10 +#define CMD_CDO 0x08 +#define CMD_RRB 0x04 +#define CMD_AT 0x02 +#define CMD_TR 0x01

+/* interrupt sources */ +#define IRQ_BEI 0x80 +#define IRQ_ALI 0x40 +#define IRQ_EPI 0x20 +#define IRQ_WUI 0x10 +#define IRQ_DOI 0x08 +#define IRQ_EI 0x04 +#define IRQ_TI 0x02 +#define IRQ_RI 0x01 +#define IRQ_ALL 0xFF +#define IRQ_OFF 0x00

+/* status register content */ +#define SR_BS 0x80 +#define SR_ES 0x40 +#define SR_TS 0x20 +#define SR_RS 0x10 +#define SR_TCS 0x08 +#define SR_TBS 0x04 +#define SR_DOS 0x02 +#define SR_RBS 0x01

+#define SR_CRIT (SR_BS|SR_ES)

+/* ECC register */ +#define ECC_SEG 0x1F +#define ECC_DIR 0x20 +#define ECC_ERR 6 +#define ECC_BIT 0x00 +#define ECC_FORM 0x40 +#define ECC_STUFF 0x80 +#define ECC_MASK 0xc0

+/* clock divider register */ +#define CDR_CLKOUT_MASK 0x07 +#define CDR_CLK_OFF 0x08 /* Clock off (CLKOUT pin) */ +#define CDR_RXINPEN 0x20 /* TX1 output is RX irq output */ +#define CDR_CBP 0x40 /* CAN input comparator bypass */ +#define CDR_PELICAN 0x80 /* PeliCAN mode */

+/* output control register */ +#define OCR_MODE_BIPHASE 0x00 +#define OCR_MODE_TEST 0x01 +#define OCR_MODE_NORMAL 0x02 +#define OCR_MODE_CLOCK 0x03 +#define OCR_TX0_INVERT 0x04 +#define OCR_TX0_PULLDOWN 0x08 +#define OCR_TX0_PULLUP 0x10 +#define OCR_TX0_PUSHPULL 0x18 +#define OCR_TX1_INVERT 0x20 +#define OCR_TX1_PULLDOWN 0x40 +#define OCR_TX1_PULLUP 0x80 +#define OCR_TX1_PUSHPULL 0xc0 +#endif /* SJA1000_DEV_H */ diff --git a/include/can.h b/include/can.h new file mode 100755 index 0000000..55e6643 --- /dev/null +++ b/include/can.h @@ -0,0 +1,216 @@ +/*

• • linux/can.h
• • Definitions for CAN network layer (socket addr / CAN frame / CAN filter)
• • Copyright (C) 2009 miaofngmiaofng@gmail.com
• • Authors: Oliver Hartkopp oliver.hartkopp@volkswagen.de

• •      Urs Thuermann   <urs.thuermann@volkswagen.de>
    

• • Copyright (c) 2002-2007 Volkswagen Group Electronic Research
• • All rights reserved.
• • Send feedback to socketcan-users@lists.berlios.de
• */

+#ifndef CAN_H +#define CAN_H

+#include <linux/types.h> +#include <can_error.h> +#include <circbuf.h> +#include <candev.h>

+/* controller area network (CAN) kernel definitions */

+/* special address description flags for the CAN_ID */ +#define CAN_EFF_FLAG 0x80000000U /* EFF/SFF is set in the MSB */ +#define CAN_RTR_FLAG 0x40000000U /* remote transmission request */ +#define CAN_ERR_FLAG 0x20000000U /* error frame */

+/* valid bits in CAN ID for frame formats */ +#define CAN_SFF_MASK 0x000007FFU /* standard frame format (SFF) */ +#define CAN_EFF_MASK 0x1FFFFFFFU /* extended frame format (EFF) */ +#define CAN_ERR_MASK 0x1FFFFFFFU /* omit EFF, RTR, ERR flags */

+/*

• • Controller Area Network Identifier structure
• • bit 0-28 : CAN identifier (11/29 bit)
• • bit 29 : error frame flag (0 = data frame, 1 = error frame)
• • bit 30 : remote transmission request flag (1 = rtr frame)
• • bit 31 : frame format flag (0 = standard 11 bit, 1 = extended 29 bit)
• */

+typedef __u32 canid_t;

+/**

• • struct can_frame - basic CAN frame structure
• • @can_id: the CAN ID of the frame and CAN_*_FLAG flags, see above.
• • @can_dlc: the data length field of the CAN frame
• • @data: the CAN frame payload.
• */

+struct can_frame {

• canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */
• __u8 can_dlc; /* data length code: 0 .. 8 */
• __u8 data[8] __attribute__((aligned(8)));

+};

+/**

• • struct can_filter - CAN ID based filter in can_register().
• • @can_id: relevant bits of CAN ID which are not masked out.
• • @can_mask: CAN mask (see description)
• • Description:
• • A filter matches, when

• •      <received_can_id> & mask == can_id & mask
    

• • The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
• • filter for error frames (CAN_ERR_FLAG bit set in mask).
• */

+struct can_filter {

• canid_t can_id;
• canid_t can_mask;
• struct can_filter* next;

+};

+#define CAN_INV_FILTER 0x20000000U /* to be set in can_filter.can_id */

+//can_device.state +enum can_state {

• CAN_STATE_ERROR_ACTIVE = 0, /* RX/TX error count < 96 */
• CAN_STATE_ERROR_WARNING, /* RX/TX error count < 128 */
• CAN_STATE_ERROR_PASSIVE, /* RX/TX error count < 256 */
• CAN_STATE_BUS_OFF, /* RX/TX error count >= 256 */
• CAN_STATE_STOPPED, /* Device is stopped */
• CAN_STATE_SLEEPING, /* Device is sleeping */
• CAN_STATE_MAX

+};

+//can_device.stats, refer to net_device_stats +struct can_device_stats +{

• unsigned long rx_packets; /* total packets received */
• unsigned long tx_packets; /* total packets transmitted */
• unsigned long rx_bytes; /* total bytes received */
• unsigned long tx_bytes; /* total bytes transmitted */
• unsigned long rx_errors; /* bad packets received */
• unsigned long tx_errors; /* packet transmit problems */
• unsigned long rx_dropped; /* no space in linux buffers */
• unsigned long tx_dropped; /* no space available in linux */
• unsigned long multicast; /* multicast packets received */
• unsigned long collisions;
• //can stats
• unsigned long error_passive;
• unsigned long error_warning;
• unsigned long arbitration_lost;
• unsigned long bus_error;

+};

+/*queue status definition*/ +#define CAN_QUEUE_INIT 0 +#define CAN_QUEUE_READY 1 +#define CAN_QUEUE_BUSY 2

+#define NAMESIZE_CAN 8

+struct can_device {

• //can core readonly
• char name[NAMESIZE_CAN];
• enum can_state state;
• struct can_device_stats stats;
• //can dev methods
• int (*setbrg)(int, struct can_device*);
• int (*setfilter)(struct can_filter*, struct can_device*);
• int (*open) (struct can_device*);
• int (*start_xmit) (struct can_frame*, struct can_device*);
• int (*close)(struct can_device*);
• //can_core private
• int qstatus; //queue status
• circbuf_t tbuf; //tx buffer
• circbuf_t rbuf; //rx buffer
• //struct can_device *next;
• int index;

+};

+//help routines +static inline void *candev_priv(const struct can_device *dev) { return (void *) dev; } +int register_candev(struct can_device*); +void unregister_candev(struct can_device*); +void canif_rx(struct can_frame*, struct can_device*);

+/* *

• • these 3 functions are used to set the queue status
• */

+static inline void canif_stop_queue(struct can_device *dev) {dev->qstatus = CAN_QUEUE_BUSY;} +static inline void canif_start_queue(struct can_device *dev) {dev->qstatus = CAN_QUEUE_READY;} +void canif_wake_queue(struct can_device*);

+//note: these functions must be called before can_open() +int can_init(void);

+/**

• • function can_setbrg - set the bus speed of can device
• • @brg bus speed to set, unit bps, such as: 250000,1000000 and etc
• • @index device to set the speed, should be 0,1,2,....
• • @return success->0, or fail->-1
• • description:
• • please set the speed when the device in reset mode.
• */

+int can_setbrg(int brg, int index);

+/**

• • function can_setfilter - set the can id filter
• • @filter filter list to be set
• • @index device to do the operation, such as 0,1,2 ...
• • @return success->0, or fail->-1
• • description:
• • please set the filter when the device in reset mode.
• */

+int can_setfilter(struct can_filter *filter, int index);

+/**

• • function can_open - open a specified can device(or channel) for read/write
• • @index index of the can channel to open, value as 0,1,2 ...
• • @return device id, for can_send/can_recv ... , in case of fail, return 0
• • description:
• • can device will leave the reset mode by this operation.
• */

+int can_open(int index);

+/**

• • function can_send - send a can frame
• • @cf frame to be sent
• • @dev_id device to do 'send' operation
• • @return success->0, or fail->-1
• • description:
• • this is non block operation. can_core will store the frame pointer to the tx cirbuf.
• */

+int can_send(struct can_frame *cf, int dev_id);

+/**

• • function can_recv - get a can frame from the specified can device(or channel)
• • @dev_id can device to read
• • @return success-> the pointer to a can frame, fail->0
• • description:
• • this is non block operation. can_core will get a frame pointer from the rx cirbuf of the device.
• • the memory of the frame should be released by caller.
• */

+struct can_frame* can_recv(int dev_id);

+/**

• • function can_close - close a specified can device(or channel)
• • @dev_id can device to close
• • description:
• • can_close will do following operation:
• • 1. dump the device's tx/rx buffer
• • 2. set device into reset mode
• */

+void can_close(int dev_id); +#endif /* CAN_H */ diff --git a/include/can_error.h b/include/can_error.h new file mode 100755 index 0000000..d4127fd --- /dev/null +++ b/include/can_error.h @@ -0,0 +1,93 @@ +/*

• • linux/can/error.h
• • Definitions of the CAN error frame to be filtered and passed to the user.
• • Author: Oliver Hartkopp oliver.hartkopp@volkswagen.de
• • Copyright (c) 2002-2007 Volkswagen Group Electronic Research
• • All rights reserved.
• • Send feedback to socketcan-users@lists.berlios.de
• */

+#ifndef CAN_ERROR_H +#define CAN_ERROR_H

+#define CAN_ERR_DLC 8 /* dlc for error frames */

+/* error class (mask) in can_id */ +#define CAN_ERR_TX_TIMEOUT 0x00000001U /* TX timeout (by netdevice driver) */ +#define CAN_ERR_LOSTARB 0x00000002U /* lost arbitration / data[0] */ +#define CAN_ERR_CRTL 0x00000004U /* controller problems / data[1] */ +#define CAN_ERR_PROT 0x00000008U /* protocol violations / data[2..3] */ +#define CAN_ERR_TRX 0x00000010U /* transceiver status / data[4] */ +#define CAN_ERR_ACK 0x00000020U /* received no ACK on transmission */ +#define CAN_ERR_BUSOFF 0x00000040U /* bus off */ +#define CAN_ERR_BUSERROR 0x00000080U /* bus error (may flood!) */ +#define CAN_ERR_RESTARTED 0x00000100U /* controller restarted */

+/* arbitration lost in bit ... / data[0] */ +#define CAN_ERR_LOSTARB_UNSPEC 0x00 /* unspecified */

• 		      /* else bit number in bitstream */
  

+/* error status of CAN-controller / data[1] */ +#define CAN_ERR_CRTL_UNSPEC 0x00 /* unspecified */ +#define CAN_ERR_CRTL_RX_OVERFLOW 0x01 /* RX buffer overflow */ +#define CAN_ERR_CRTL_TX_OVERFLOW 0x02 /* TX buffer overflow */ +#define CAN_ERR_CRTL_RX_WARNING 0x04 /* reached warning level for RX errors */ +#define CAN_ERR_CRTL_TX_WARNING 0x08 /* reached warning level for TX errors */ +#define CAN_ERR_CRTL_RX_PASSIVE 0x10 /* reached error passive status RX */ +#define CAN_ERR_CRTL_TX_PASSIVE 0x20 /* reached error passive status TX */

• 		      /* (at least one error counter exceeds */
  

• 		      /* the protocol-defined level of 127)  */
  

+/* error in CAN protocol (type) / data[2] */ +#define CAN_ERR_PROT_UNSPEC 0x00 /* unspecified */ +#define CAN_ERR_PROT_BIT 0x01 /* single bit error */ +#define CAN_ERR_PROT_FORM 0x02 /* frame format error */ +#define CAN_ERR_PROT_STUFF 0x04 /* bit stuffing error */ +#define CAN_ERR_PROT_BIT0 0x08 /* unable to send dominant bit */ +#define CAN_ERR_PROT_BIT1 0x10 /* unable to send recessive bit */ +#define CAN_ERR_PROT_OVERLOAD 0x20 /* bus overload */ +#define CAN_ERR_PROT_ACTIVE 0x40 /* active error announcement */ +#define CAN_ERR_PROT_TX 0x80 /* error occured on transmission */

+/* error in CAN protocol (location) / data[3] */ +#define CAN_ERR_PROT_LOC_UNSPEC 0x00 /* unspecified */ +#define CAN_ERR_PROT_LOC_SOF 0x03 /* start of frame */ +#define CAN_ERR_PROT_LOC_ID28_21 0x02 /* ID bits 28 - 21 (SFF: 10 - 3) */ +#define CAN_ERR_PROT_LOC_ID20_18 0x06 /* ID bits 20 - 18 (SFF: 2 - 0 )*/ +#define CAN_ERR_PROT_LOC_SRTR 0x04 /* substitute RTR (SFF: RTR) */ +#define CAN_ERR_PROT_LOC_IDE 0x05 /* identifier extension */ +#define CAN_ERR_PROT_LOC_ID17_13 0x07 /* ID bits 17-13 */ +#define CAN_ERR_PROT_LOC_ID12_05 0x0F /* ID bits 12-5 */ +#define CAN_ERR_PROT_LOC_ID04_00 0x0E /* ID bits 4-0 */ +#define CAN_ERR_PROT_LOC_RTR 0x0C /* RTR */ +#define CAN_ERR_PROT_LOC_RES1 0x0D /* reserved bit 1 */ +#define CAN_ERR_PROT_LOC_RES0 0x09 /* reserved bit 0 */ +#define CAN_ERR_PROT_LOC_DLC 0x0B /* data length code */ +#define CAN_ERR_PROT_LOC_DATA 0x0A /* data section */ +#define CAN_ERR_PROT_LOC_CRC_SEQ 0x08 /* CRC sequence */ +#define CAN_ERR_PROT_LOC_CRC_DEL 0x18 /* CRC delimiter */ +#define CAN_ERR_PROT_LOC_ACK 0x19 /* ACK slot */ +#define CAN_ERR_PROT_LOC_ACK_DEL 0x1B /* ACK delimiter */ +#define CAN_ERR_PROT_LOC_EOF 0x1A /* end of frame */ +#define CAN_ERR_PROT_LOC_INTERM 0x12 /* intermission */

+/* error status of CAN-transceiver / data[4] */ +/* CANH CANL */ +#define CAN_ERR_TRX_UNSPEC 0x00 /* 0000 0000 */ +#define CAN_ERR_TRX_CANH_NO_WIRE 0x04 /* 0000 0100 */ +#define CAN_ERR_TRX_CANH_SHORT_TO_BAT 0x05 /* 0000 0101 */ +#define CAN_ERR_TRX_CANH_SHORT_TO_VCC 0x06 /* 0000 0110 */ +#define CAN_ERR_TRX_CANH_SHORT_TO_GND 0x07 /* 0000 0111 */ +#define CAN_ERR_TRX_CANL_NO_WIRE 0x40 /* 0100 0000 */ +#define CAN_ERR_TRX_CANL_SHORT_TO_BAT 0x50 /* 0101 0000 */ +#define CAN_ERR_TRX_CANL_SHORT_TO_VCC 0x60 /* 0110 0000 */ +#define CAN_ERR_TRX_CANL_SHORT_TO_GND 0x70 /* 0111 0000 */ +#define CAN_ERR_TRX_CANL_SHORT_TO_CANH 0x80 /* 1000 0000 */

+/* controller specific additional information / data[5..7] */

+#endif /* CAN_ERROR_H */ diff --git a/include/candev.h b/include/candev.h new file mode 100755 index 0000000..0e0dee7 --- /dev/null +++ b/include/candev.h @@ -0,0 +1,46 @@ +/*

• • (C) Copyright 2009 miaofngmiaofng@gmail.com
• • See file CREDITS for list of people who contributed to this
• • project.
• • This program is free software; you can redistribute it and/or
• • modify it under the terms of the GNU General Public License as
• • published by the Free Software Foundation; either version 2 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 General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 59 Temple Place, Suite 330, Boston,
• • MA 02111-1307 USA
• */

+/*

• • netdev.h - definitions an prototypes for network devices
• */

+#ifndef _CANDEV_H_ +#define _CANDEV_H_

+/*

• • Board and CPU-specific initialization functions
• • board_eth_init() has highest priority. cpu_eth_init() only
• • gets called if board_eth_init() isn't instantiated or fails.
• • Return values:

• •  0: success
    

• • -1: failure
    

• */

+int board_can_init(void); +void board_can_update(void);

+/* Driver initialization prototypes */ +int sja1000_init(u32 reg_base);

+#endif /* _CANDEV_H_ */ diff --git a/lib_arm/board.c b/lib_arm/board.c old mode 100644 new mode 100755 index 5e3d7f6..aa11dd3 --- a/lib_arm/board.c +++ b/lib_arm/board.c @@ -356,6 +356,8 @@ void start_armboot (void) serial_initialize(); #endif

• can_init();
• /* IP Address */ gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");