[PATCH] [can] add u-boot sja1000/can support

miaofng miaofng at gmail.com
Fri Oct 23 11:06:50 CEST 2009


Signed-off-by: miaofng <miaofng at 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 miaofng<miaofng at 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 miaofng<miaofng at 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 miaofng<miaofng at 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 at 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 at 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 miaofng<miaofng at 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 at 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 miaofng<miaofng at gmail.com>
+ *
+ * Authors: Oliver Hartkopp <oliver.hartkopp at volkswagen.de>
+ *          Urs Thuermann   <urs.thuermann at volkswagen.de>
+ * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
+ * All rights reserved.
+ *
+ * Send feedback to <socketcan-users at 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 at volkswagen.de>
+ * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
+ * All rights reserved.
+ *
+ * Send feedback to <socketcan-users at 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 miaofng<miaofng at 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");
 
-- 
1.6.2.5




More information about the U-Boot mailing list