use broken-out patches for the coldfire to make it easier to follow differences against the bsp

SVN-Revision: 16547

1 files changed, 1376 insertions, 0 deletions

diff --git a/target/linux/coldfire/patches/077-mcfv4e_flexcan.patch b/target/linux/coldfire/patches/077-mcfv4e_flexcan.patch
new file mode 100644
index 0000000000..ae7aefd649
--- /dev/null
+++ b/target/linux/coldfire/patches/077-mcfv4e_flexcan.patch
@@ -0,0 +1,1376 @@
+From c44de58d0972d05851512ba8cbd928b7adef5187 Mon Sep 17 00:00:00 2001
+From: Kurt Mahan <kmahan@freescale.com>
+Date: Tue, 8 Jul 2008 17:11:33 -0600
+Subject: [PATCH] Add FlexCAN support.
+
+LTIBName: mcfv4e-flexcan
+Signed-off-by: Kurt Mahan <kmahan@freescale.com>
+Signed-off-by: Huan Wang <b18965@freescale.com>
+---
+ drivers/net/can/Kconfig               |   13 ++
+ drivers/net/can/Makefile              |    1 +
+ drivers/net/can/flexcan/Makefile      |    5 +
+ drivers/net/can/flexcan/flexcan.c     |  378 +++++++++++++++++++++++++++++++++
+ drivers/net/can/flexcan/flexcan.h     |  148 +++++++++++++
+ drivers/net/can/flexcan/mcf548x_can.c |  213 ++++++++++++++++++
+ include/asm-m68k/m5485sim.h           |    2 +
+ include/linux/can/dev.h               |   62 ++++++
+ include/linux/can/ioctl.h             |  152 +++++++++++++
+ include/linux/can/version.h           |   22 ++
+ net/can/Makefile                      |    3 +
+ net/can/dev.c                         |  292 +++++++++++++++++++++++++
+ 12 files changed, 1291 insertions(+), 0 deletions(-)
+ create mode 100644 drivers/net/can/flexcan/Makefile
+ create mode 100644 drivers/net/can/flexcan/flexcan.c
+ create mode 100644 drivers/net/can/flexcan/flexcan.h
+ create mode 100644 drivers/net/can/flexcan/mcf548x_can.c
+ create mode 100644 include/linux/can/dev.h
+ create mode 100644 include/linux/can/ioctl.h
+ create mode 100644 include/linux/can/version.h
+ create mode 100644 net/can/dev.c
+
+--- a/drivers/net/can/Kconfig
++++ b/drivers/net/can/Kconfig
+@@ -12,6 +12,19 @@ config CAN_VCAN
+ 	  This driver can also be built as a module.  If so, the module
+ 	  will be called vcan.
+ 
++config CAN_FLEXCAN
++	tristate "Support for Freescale FLEXCAN based chips"
++	depends on CAN && (PPC || M68K || M68KNOMMU)
++	---help---
++	  Say Y here if you want to support for Freescale FlexCAN.
++
++config CAN_MCF547X_8X
++	tristate "Freescale MCF547X/MCF548X onboard CAN controller"
++	depends on CAN_FLEXCAN && (M547X || M548X)
++	---help---
++	  Say Y here if you want to support for Freescale MCF547x/MCF548x
++	  onboard dualCAN controller.
++
+ config CAN_DEBUG_DEVICES
+ 	bool "CAN devices debugging messages"
+ 	depends on CAN
+--- a/drivers/net/can/Makefile
++++ b/drivers/net/can/Makefile
+@@ -3,3 +3,4 @@
+ #
+ 
+ obj-$(CONFIG_CAN_VCAN)		+= vcan.o
++obj-$(CONFIG_CAN_FLEXCAN)	+= flexcan/
+--- /dev/null
++++ b/drivers/net/can/flexcan/Makefile
+@@ -0,0 +1,5 @@
++
++obj-$(CONFIG_CAN_MCF547X_8X)	+= flexcan-mcf548x.o
++
++flexcan-mcf548x-objs	:= flexcan.o mcf548x_can.o
++
+--- /dev/null
++++ b/drivers/net/can/flexcan/flexcan.c
+@@ -0,0 +1,378 @@
++/*
++ * flexcan.c
++ *
++ * DESCRIPTION:
++ *  CAN bus driver for the alone generic (as possible as) FLEXCAN controller.
++ *
++ * AUTHOR:
++ *  Andrey Volkov <avolkov@varma-el.com>
++ *
++ * COPYRIGHT:
++ *  2005-2006, Varma Electronics Oy
++ *
++ * LICENCE:
++ *  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
++ *
++ *  HISTORY:
++ *  	2008-06-23 Support for MCF548x's FlexCAN
++ * 			Huan, Wang <b18965@freescale.com>
++ */
++
++
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/interrupt.h>
++#include <linux/delay.h>
++#include <linux/netdevice.h>
++#include <linux/if_arp.h>
++#include <linux/if_ether.h>
++#include <linux/can.h>
++#include <linux/list.h>
++#include <linux/io.h>
++
++#include <linux/can/dev.h>
++#include <linux/can/error.h>
++#include "flexcan.h"
++#include <asm/coldfire.h>
++#include <asm/m5485sim.h>
++#include <linux/can/version.h>	/* for RCSID. Removed by mkpatch script */
++RCSID("$Id$");
++
++struct flexcan_priv {
++	struct can_priv can;
++	volatile unsigned long flags;
++	u8 shadow_statflg;
++	u8 shadow_canrier;
++	u8 cur_pri;
++	u8 tx_active;
++
++	struct list_head tx_head;
++	struct napi_struct napi;
++	struct net_device *dev;
++};
++
++
++static int flexcan_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
++{
++	struct can_frame *frame = (struct can_frame *)skb->data;
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++	int i, len;
++	int txbuf = 0;
++	u32 can_id, can_ext, tmp, tmp1;
++
++	/* Transmission inactive */
++	regs->cantxfg[txbuf].can_dlc = MB_CNT_CODE(0x08);
++
++	can_ext = frame->can_id;
++	if (can_ext & CAN_EFF_FLAG) {
++		/* Frame format is extended */
++		regs->cantxfg[txbuf].can_dlc |= (1 << 21);
++		regs->cantxfg[txbuf].can_dlc |= (1 << 22);
++		can_id = frame->can_id & MB_ID_EXT;
++		if (frame->can_id & CAN_RTR_FLAG)
++			regs->cantxfg[txbuf].can_dlc |= (1 << 20);
++
++		tmp = (can_id & CAN_SFF_MASK) << 18;
++		tmp1 = can_id >> 11;
++		can_id = tmp | tmp1;
++		regs->cantxfg[txbuf].can_id = can_id;
++	} else {
++		/* Frame format is standard */
++		can_id = frame->can_id & MB_ID_EXT;
++		if (frame->can_id & CAN_RTR_FLAG)
++			regs->cantxfg[txbuf].can_dlc |= (1 << 20);
++
++		regs->cantxfg[txbuf].can_id = can_id << 18;
++	}
++
++	len = 8;
++	for (i = 0; i < len; i++)
++		regs->cantxfg[txbuf].data[i] = frame->data[i];
++
++	regs->cantxfg[txbuf].can_dlc |= len << 16;
++	/* Transmission active */
++	regs->cantxfg[txbuf].can_dlc |= MB_CNT_CODE(0x0c);
++	kfree_skb(skb);
++	return NETDEV_TX_OK;
++}
++
++static void flexcan_tx_timeout(struct net_device *dev)
++{
++	struct sk_buff *skb;
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++	struct can_frame *frame;
++	int length = 8;
++
++	/* Diable the interrupts */
++	regs->imask = IMASK_BUFF_DISABLE_ALL;
++
++	skb = dev_alloc_skb(sizeof(struct can_frame));
++	if (!skb) {
++		if (printk_ratelimit())
++			dev_notice(ND2D(dev), "TIMEOUT packet dropped.\n");
++		return;
++	}
++	frame = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
++
++	frame->can_dlc = length;
++
++	skb->dev = dev;
++	skb->protocol = __constant_htons(ETH_P_CAN);
++	skb->pkt_type = PACKET_BROADCAST;
++	skb->ip_summed = CHECKSUM_UNNECESSARY;
++
++	netif_rx(skb);
++}
++
++static irqreturn_t flexcan_isr(int irq, void *dev_id)
++{
++	struct net_device *dev = (struct net_device *)dev_id;
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++	struct net_device_stats *stats = dev->get_stats(dev);
++	struct sk_buff *skb;
++	struct can_frame *frame;
++	u32 iflags, oflags;
++	int i, k;
++	int retval = 1;
++
++	iflags = regs->iflag;
++	oflags = iflags;
++	for (i = 0; i < 16; i++) {
++		if (iflags & (0x01 << i)) {
++			struct flexcan_mb *mb = &regs->cantxfg[i];
++			int ctrl = mb->can_dlc;
++			int code = (ctrl >> 24) & 0x0f;
++			int length = (ctrl >> 16) & 0x0f;
++			u32 tmp, tmp1;
++
++			if (code < 8 && (length > 0)) {
++				/* receive frame */
++				skb = dev_alloc_skb(sizeof(struct can_frame));
++				if (!skb)
++					dev_notice(ND2D(dev),
++							"Packets dropped.\n");
++				skb->dev = dev;
++				frame = (struct can_frame *)skb_put(skb,
++						sizeof(struct can_frame));
++
++				frame->can_id &= 0x0;
++				frame->can_dlc = length;
++				tmp1 = mb->can_id & MB_ID_EXT;
++				if (ctrl & MB_CNT_IDE) {
++					tmp = tmp1;
++					tmp = (tmp >> 18) & CAN_SFF_MASK;
++					frame->can_id = (tmp1 << 11) | tmp;
++					frame->can_id &= CAN_EFF_MASK;
++					frame->can_id |= CAN_EFF_FLAG;
++					if (ctrl & MB_CNT_RTR)
++						frame->can_id |= CAN_RTR_FLAG;
++				} else {
++					frame->can_id  = tmp1 >> 18;
++					if (ctrl & MB_CNT_RTR)
++						frame->can_id |= CAN_RTR_FLAG;
++				}
++
++				for (k = 0; k < 8; k++)
++					frame->data[k] = mb->data[k];
++
++				mb->can_dlc &= MB_CODE_MASK;
++				mb->can_dlc |= MB_CNT_CODE(0x04);
++
++				stats->rx_packets++;
++				stats->rx_bytes += frame->can_dlc;
++				skb->dev = dev;
++				skb->protocol = __constant_htons(ETH_P_CAN);
++				skb->ip_summed = CHECKSUM_UNNECESSARY;
++
++				retval = netif_rx(skb);
++				if (retval == NET_RX_DROP)
++					dev_notice(ND2D(dev),
++							"Packets dropped.\n");
++			} else {
++				/* transmit frame */
++				mb->can_dlc = MB_CNT_CODE(0x04);
++			}
++		}
++	}
++	regs->iflag = oflags;
++
++	return IRQ_HANDLED;
++}
++
++static int flexcan_do_set_bit_time(struct net_device *dev,
++				 struct can_bittime *bt)
++{
++	struct flexcan_priv *priv = netdev_priv(dev);
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++	int ret = 0;
++	u32 reg;
++
++	if (bt->type != CAN_BITTIME_STD)
++		return -EINVAL;
++
++	spin_lock_irq(&priv->can.irq_lock);
++
++	reg = CANCTRL_PRESDIV(bt->std.brp) | CANCTRL_PSEG1(bt->std.phase_seg1
++			- 1) | CANCTRL_PSEG2(bt->std.phase_seg2 - 1);
++	regs->canctrl &= CANCTRL_BITTIME;
++	regs->canctrl |= (reg | CANCTRL_SAMP(bt->std.sam) |
++		CANCTRL_PROPSEG(bt->std.prop_seg - 1));
++
++	spin_unlock_irq(&priv->can.irq_lock);
++	return ret;
++}
++
++
++static int flexcan_open(struct net_device *dev)
++{
++	int ret, i, j;
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++
++#if defined(CONFIG_M547X_8X)
++	MCF_PAR_TIMER = MCF_PAR_TIMER | 0x28;
++	MCF_PAR_TIMER = MCF_PAR_TIMER & 0xf8;
++	MCF_PAR_DSPI = MCF_PAR_DSPI | 0x0a00;
++	MCF_PAR_FECI2CIRQ = MCF_PAR_FECI2CIRQ | 0x0283;
++	MCF_PAR_PSCn(2) = MCF_PAR_PSCn(2) & 0x0f;
++	MCF_PAR_PSCn(2) = MCF_PAR_PSCn(2) | 0x50;
++#endif
++
++	regs->canmcr |= CANMCR_SOFTRST;
++	regs->canmcr |= CANMCR_MDIS;
++	udelay(10);
++
++	if ((regs->canmcr & CANMCR_SOFTRST) != 0x0) {
++		dev_err(ND2D(dev), "Failed to softreset can module.\n");
++		return -1;
++	}
++
++	/* Enable error and bus off interrupt */
++	regs->canctrl |= (CANCTRL_RJW(3) | CANCTRL_ERRMSK |
++			CANCTRL_BOFFMSK);
++
++	/* Set lowest buffer transmitted first */
++	regs->canctrl |= CANCTRL_LBUF;
++
++	for (i = 0; i < 16; i++) {
++		regs->cantxfg[i].can_dlc = 0;
++		regs->cantxfg[i].can_id = 0;
++		for (j = 0; j < 8; j++)
++			regs->cantxfg[i].data[j] = 0;
++
++		/* Put MB into rx queue */
++		regs->cantxfg[i].can_dlc = MB_CNT_CODE(0x04);
++	}
++
++	/* acceptance mask/acceptance code (accept everything) */
++	regs->rxgmask = 0x00000000;
++	regs->rx14mask = 0x00000000;
++	regs->rx15mask = 0x00000000;
++	/* extended frame */
++	regs->cantxfg[14].can_dlc |= 0x600000;
++	/* Enable flexcan module */
++	regs->canmcr &= ~CANMCR_MDIS;
++	/* Synchronize with the can bus */
++	regs->canmcr &= ~CANMCR_HALT;
++
++#if defined(CONFIG_M547X_8X)
++	for (i = 0; i < 2; i++) {
++		MCF_ICR(ISC_CANn_MBOR(i)) = 0x33;
++		MCF_ICR(ISC_CANn_ERR(i)) = 0x33;
++		MCF_ICR(ISC_CANn_BUSOFF(i)) = 0x33;
++	}
++
++	ret = request_irq(dev->irq + 64, flexcan_isr, IRQF_DISABLED,
++			dev->name, dev);
++	ret = request_irq(dev->irq + 1 + 64, flexcan_isr, IRQF_DISABLED,
++			dev->name, dev);
++	ret = request_irq(dev->irq + 2 + 64, flexcan_isr, IRQF_DISABLED,
++			dev->name, dev);
++	if (ret < 0) {
++		printk(KERN_ERR "%s - failed to attach interrupt.\n",
++		       dev->name);
++		return ret;
++	}
++#endif
++
++	/* Enable all interrupts */
++	regs->imask = IMASK_BUFF_ENABLE_ALL;
++	netif_start_queue(dev);
++	return 0;
++}
++
++static int flexcan_close(struct net_device *dev)
++{
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++
++	netif_stop_queue(dev);
++
++	/* Disable all interrupts */
++	regs->imask = IMASK_BUFF_DISABLE_ALL;
++	free_irq(dev->irq + 64, dev);
++	free_irq(dev->irq + 1 + 64, dev);
++	free_irq(dev->irq + 2 + 64, dev);
++
++	/* Disable module */
++	regs->canmcr |= CANMCR_MDIS;
++	return 0;
++}
++
++int register_flexcandev(struct net_device *dev, int clock_src)
++{
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++
++	regs->canmcr &= ~CANMCR_MDIS;
++	udelay(100);
++	regs->canmcr |= (CANMCR_FRZ | CANMCR_HALT);
++	return register_netdev(dev);
++}
++EXPORT_SYMBOL(register_flexcandev);
++
++void unregister_flexcandev(struct net_device *dev)
++{
++	struct flexcan_regs *regs = (struct flexcan_regs *)dev->base_addr;
++
++	regs->canmcr |= (CANMCR_FRZ | CANMCR_HALT);
++	regs->canmcr |= CANMCR_MDIS;
++
++	unregister_netdev(dev);
++}
++EXPORT_SYMBOL(unregister_flexcandev);
++
++struct net_device *alloc_flexcandev(void)
++{
++	struct net_device *dev;
++	struct flexcan_priv *priv;
++
++	dev = alloc_candev(sizeof(struct flexcan_priv));
++	if (!dev)
++		return NULL;
++
++	priv = netdev_priv(dev);
++	priv->dev = dev;
++	dev->open = flexcan_open;
++	dev->stop = flexcan_close;
++	dev->hard_start_xmit = flexcan_hard_start_xmit;
++	dev->tx_timeout = flexcan_tx_timeout;
++	dev->flags |= IFF_NOARP;
++	priv->can.do_set_bit_time = flexcan_do_set_bit_time;
++	return dev;
++}
++EXPORT_SYMBOL(alloc_flexcandev);
++
++MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
++MODULE_LICENSE("GPL v2");
++MODULE_DESCRIPTION("CAN port driver for flexcan based chip");
+--- /dev/null
++++ b/drivers/net/can/flexcan/flexcan.h
+@@ -0,0 +1,148 @@
++/*
++ * flexcan.h
++ *
++ * DESCRIPTION:
++ *  Definitions of consts/structs to drive the Freescale FLEXCAN.
++ *
++ */
++
++#ifndef __FLEXCAN_H__
++#define __FLEXCAN_H__
++
++#include <linux/autoconf.h>
++#include <linux/types.h>
++
++/* FLEXCAN module configuration register (CANMCR) bits */
++#define CANMCR_MDIS				0x80000000
++#define CANMCR_FRZ				0x40000000
++#define CANMCR_HALT				0x10000000
++#define CANMCR_SOFTRST				0x02000000
++#define CANMCR_FRZACK				0x01000000
++#define CANMCR_SUPV				0x00800000
++#define CANMCR_MAXMB(x)				((x)&0x0f)
++
++/* FLEXCAN control register (CANCTRL) bits */
++#define CANCTRL_PRESDIV(x)			(((x)&0xff)<<24)
++#define CANCTRL_RJW(x)				(((x)&0x03)<<22)
++#define CANCTRL_PSEG1(x)			(((x)&0x07)<<19)
++#define CANCTRL_PSEG2(x)			(((x)&0x07)<<16)
++#define CANCTRL_BOFFMSK				0x00008000
++#define CANCTRL_ERRMSK				0x00004000
++#define CANCTRL_LPB				0x00001000
++#define CANCTRL_SAMP(x)				(((x)&0x1)<<7)
++#define CANCTRL_BOFFREC				0x00000040
++#define CANCTRL_TSYNC				0x00000020
++#define CANCTRL_LBUF				0x00000010
++#define CANCTRL_LOM				0x00000008
++#define CANCTRL_PROPSEG(x)			((x)&0x07)
++#define CANCTRL_BITTIME				0x00c0d078
++
++/* FLEXCAN error counter register (ERRCNT) bits */
++#define ERRCNT_REXECTR(x)			(((x)&0xff)<<8)
++#define ERRCNT_TXECTR(x)			((x)&0xff)
++
++/* FLEXCAN error and status register (ERRSTAT) bits */
++#define ERRSTAT_BITERR(x)			(((x)&0x03)<<14)
++#define ERRSTAT_ACKERR				0x00002000
++#define ERRSTAT_CRCERR				0x00001000
++#define ERRSTAT_FRMERR				0x00000800
++#define ERRSTAT_STFERR				0x00000400
++#define ERRSTAT_TXWRN				0x00000200
++#define ERRSTAT_RXWRN				0x00000100
++#define ERRSTAT_IDLE 				0x00000080
++#define ERRSTAT_TXRX				0x00000040
++#define ERRSTAT_FLTCONF(x)			(((x)&0x03)<<4)
++#define ERRSTAT_BOFFINT				0x00000004
++#define ERRSTAT_ERRINT          		0x00000002
++
++/* FLEXCAN interrupt mask register (IMASK) bits */
++#define IMASK_BUF15M				0x8000
++#define IMASK_BUF14M				0x4000
++#define IMASK_BUF13M				0x2000
++#define IMASK_BUF12M				0x1000
++#define IMASK_BUF11M				0x0800
++#define IMASK_BUF10M				0x0400
++#define IMASK_BUF9M				0x0200
++#define IMASK_BUF8M				0x0100
++#define IMASK_BUF7M				0x0080
++#define IMASK_BUF6M				0x0040
++#define IMASK_BUF5M				0x0020
++#define IMASK_BUF4M				0x0010
++#define IMASK_BUF3M				0x0008
++#define IMASK_BUF2M				0x0004
++#define IMASK_BUF1M				0x0002
++#define IMASK_BUF0M				0x0001
++#define IMASK_BUFnM(x)				(0x1<<(x))
++#define IMASK_BUFF_ENABLE_ALL			0xffff
++#define IMASK_BUFF_DISABLE_ALL 			0x0000
++
++/* FLEXCAN interrupt flag register (IFLAG) bits */
++#define IFLAG_BUF15M				0x8000
++#define IFLAG_BUF14M				0x4000
++#define IFLAG_BUF13M				0x2000
++#define IFLAG_BUF12M				0x1000
++#define IFLAG_BUF11M				0x0800
++#define IFLAG_BUF10M				0x0400
++#define IFLAG_BUF9M				0x0200
++#define IFLAG_BUF8M				0x0100
++#define IFLAG_BUF7M				0x0080
++#define IFLAG_BUF6M				0x0040
++#define IFLAG_BUF5M				0x0020
++#define IFLAG_BUF4M				0x0010
++#define IFLAG_BUF3M				0x0008
++#define IFLAG_BUF2M				0x0004
++#define IFLAG_BUF1M				0x0002
++#define IFLAG_BUF0M				0x0001
++#define IFLAG_BUFnM(x)				(0x1<<(x))
++#define IFLAG_BUFF_SET_ALL			0xffff
++#define IFLAG_BUFF_DISABLE_ALL 			0x0000
++
++/* FLEXCAN message buffers */
++#define MB_CNT_CODE(x)				(((x)&0x0f)<<24)
++#define MB_CNT_SRR				0x00400000
++#define MB_CNT_IDE				0x00200000
++#define MB_CNT_RTR				0x00100000
++#define MB_CNT_LENGTH(x)			(((x)&0x0f)<<16)
++#define MB_CNT_TIMESTAMP(x)			((x)&0xffff)
++
++#define MB_ID_STD				((0x7ff)<<18)
++#define MB_ID_EXT				0x1fffffff
++#define MB_CODE_MASK				0xf0ffffff
++
++/* Structure of the message buffer */
++struct flexcan_mb {
++	u32	can_dlc;
++	u32	can_id;
++	u8	data[8];
++};
++
++/* Structure of the hardware registers */
++struct flexcan_regs {
++	u32	canmcr;
++	u32	canctrl;
++	u32	timer;
++	u32	reserved1;
++	u32 	rxgmask;
++	u32 	rx14mask;
++	u32 	rx15mask;
++	u32	errcnt;
++	u32 	errstat;
++	u32	reserved2;
++	u32	imask;
++	u32	reserved3;
++	u32 	iflag;
++	u32	reserved4[19];
++	struct	flexcan_mb cantxfg[16];
++};
++
++struct flexcan_platform_data {
++	u8 clock_src;		/* FLEXCAN clock source CRIN or SYSCLK */
++	u32 clock_frq;		/* can ref. clock, in Hz */
++};
++
++struct net_device *alloc_flexcandev(void);
++
++extern int register_flexcandev(struct net_device *dev, int clock_src);
++extern void unregister_flexcandev(struct net_device *dev);
++
++#endif				/* __FLEXCAN_H__ */
+--- /dev/null
++++ b/drivers/net/can/flexcan/mcf548x_can.c
+@@ -0,0 +1,213 @@
++/*
++ * DESCRIPTION:
++ *  CAN bus driver for the Freescale MCF548x embedded CPU.
++ *
++ * AUTHOR:
++ *  Andrey Volkov <avolkov@varma-el.com>
++ *
++ * COPYRIGHT:
++ *  2004-2005, Varma Electronics Oy
++ *
++ * LICENCE:
++ *  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
++ *
++ * HISTORY:
++ * 	2008-06-23 support for MCF548x's FlexCAN
++ * 		Huan, Wang  <b18965@freescale.com>
++ * 	2005-02-03 created
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/interrupt.h>
++#include <linux/platform_device.h>
++#include <linux/netdevice.h>
++#include <linux/can.h>
++#include <linux/can/dev.h>
++#include <linux/io.h>
++
++#include "flexcan.h"
++#include <asm/coldfire.h>
++#include <asm/m5485sim.h>
++#include <linux/can/version.h>	/* for RCSID. Removed by mkpatch script */
++
++RCSID("$Id$");
++
++#define PDEV_MAX 2
++
++struct platform_device *pdev[PDEV_MAX];
++
++static int __devinit mcf548x_can_probe(struct platform_device *pdev)
++{
++	struct resource *mem;
++	struct net_device *dev;
++	struct flexcan_platform_data *pdata = pdev->dev.platform_data;
++	struct can_priv *can;
++	u32 mem_size;
++	int ret = -ENODEV;
++
++	if (!pdata)
++		return ret;
++
++	dev = alloc_flexcandev();
++	if (!dev)
++		return -ENOMEM;
++	can = netdev_priv(dev);
++
++	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++
++	dev->irq = platform_get_irq(pdev, 0);
++	if (!mem || !dev->irq)
++		goto req_error;
++
++	mem_size = mem->end - mem->start + 1;
++	if (!request_mem_region(mem->start, mem_size, pdev->dev.driver->name)) {
++		dev_err(&pdev->dev, "resource unavailable\n");
++		goto req_error;
++	}
++	SET_NETDEV_DEV(dev, &pdev->dev);
++
++	dev->base_addr = (unsigned long)ioremap_nocache(mem->start, mem_size);
++	if (!dev->base_addr) {
++		dev_err(&pdev->dev, "failed to map can port\n");
++		ret = -ENOMEM;
++		goto fail_map;
++	}
++	can->can_sys_clock = pdata->clock_frq;
++	platform_set_drvdata(pdev, dev);
++	ret = register_flexcandev(dev, pdata->clock_src);
++	if (ret >= 0) {
++		dev_info(&pdev->dev, "probe for port 0x%lX done\n",
++			 dev->base_addr);
++		return ret;
++	}
++
++	iounmap((unsigned long *)dev->base_addr);
++fail_map:
++	release_mem_region(mem->start, mem_size);
++req_error:
++	free_candev(dev);
++	dev_err(&pdev->dev, "probe failed\n");
++	return ret;
++}
++
++static int __devexit mcf548x_can_remove(struct platform_device *pdev)
++{
++	struct net_device *dev = platform_get_drvdata(pdev);
++	struct resource *mem;
++
++	platform_set_drvdata(pdev, NULL);
++	unregister_flexcandev(dev);
++	iounmap((unsigned long *)dev->base_addr);
++
++	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++	release_mem_region(mem->start, mem->end - mem->start + 1);
++	free_candev(dev);
++	return 0;
++}
++
++static struct platform_driver mcf548x_can_driver = {
++	.driver = {
++		   .name = "mcf548x-flexcan",
++		   },
++	.probe = mcf548x_can_probe,
++	.remove = __devexit_p(mcf548x_can_remove),
++};
++
++static struct resource mcf548x_can0_resources[] = {
++	[0] = {
++		.start 		= MCF_MBAR + 0x0000A000,
++		.end		= MCF_MBAR + 0x0000A7FF,
++		.flags		= IORESOURCE_MEM,
++	},
++	[1] = {
++		.start		= 49,
++		.end		= 49,
++		.flags		= IORESOURCE_IRQ,
++	},
++};
++
++static struct resource mcf548x_can1_resources[] = {
++	[0] = {
++		.start 		= MCF_MBAR + 0x0000A800,
++		.end		= MCF_MBAR + 0x0000AFFF,
++		.flags		= IORESOURCE_MEM,
++	},
++	[1] = {
++		.start		= 55,
++		.end		= 55,
++		.flags		= IORESOURCE_IRQ,
++	},
++};
++
++
++static int __init mcf548x_of_to_pdev(void)
++{
++	unsigned int i;
++	int err = -ENODEV;
++	struct flexcan_platform_data pdata;
++
++	pdev[0] = platform_device_register_simple("mcf548x-flexcan", 0,
++			mcf548x_can0_resources, 2);
++	if (IS_ERR(pdev[0])) {
++		err = PTR_ERR(pdev[0]);
++		return err;
++	}
++	pdev[1] = platform_device_register_simple("mcf548x-flexcan", 1,
++			mcf548x_can1_resources, 2);
++	if (IS_ERR(pdev[1])) {
++		err = PTR_ERR(pdev[1]);
++		return err;
++	}
++
++	/* FlexCAN clock */
++	pdata.clock_frq = 100000000;
++
++	for (i = 0; i < PDEV_MAX; i++) {
++		err = platform_device_add_data(pdev[i], &pdata, sizeof(pdata));
++		if (err)
++			return err;
++	}
++	return err;
++}
++
++int __init mcf548x_can_init(void)
++{
++	int err = mcf548x_of_to_pdev();
++
++	if (err) {
++		printk(KERN_ERR "%s init failed with err=%d\n",
++			mcf548x_can_driver.driver.name, err);
++		return err;
++	}
++
++	return platform_driver_register(&mcf548x_can_driver);
++}
++
++void __exit mcf548x_can_exit(void)
++{
++	int i;
++	platform_driver_unregister(&mcf548x_can_driver);
++	for (i = 0; i < PDEV_MAX; i++)
++		platform_device_unregister(pdev[i]);
++}
++
++module_init(mcf548x_can_init);
++module_exit(mcf548x_can_exit);
++
++MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
++MODULE_DESCRIPTION("Freescale MCF548x CAN driver");
++MODULE_LICENSE("GPL v2");
+--- a/include/asm-m68k/m5485sim.h
++++ b/include/asm-m68k/m5485sim.h
+@@ -186,6 +186,8 @@
+ #define MCF_PAR_PCIBR   	   MCF_REG16(0x000A4A)
+ #define MCF_PAR_PSCn(x)            MCF_REG08(0x000A4F-((x)&0x3))
+ #define MCF_PAR_FECI2CIRQ   	   MCF_REG16(0x000A44)
++#define MCF_PAR_DSPI               MCF_REG16(0x000A50)
++#define MCF_PAR_TIMER              MCF_REG08(0X000A52)
+ #define MCF_EPPAR       	   MCF_REG16(0x000F00)
+ #define MCF_EPIER       	   MCF_REG08(0x000F05)
+ #define MCF_EPFR       	   	   MCF_REG08(0x000F0C)
+--- /dev/null
++++ b/include/linux/can/dev.h
+@@ -0,0 +1,62 @@
++/*
++ * linux/can/dev.h
++ *
++ * Definitions for CAN controller network devices lib (work in progress)
++ *
++ * * * $Id$
++ *
++ * Author: Andrey Volkov <avolkov@varma-el.com>
++ * Copyright (c) 2006 Varma Electronics Oy
++ *
++ */
++
++#ifndef CAN_DEVICE_H
++#define CAN_DEVICE_H
++
++#include <linux/version.h>
++#include <linux/can/error.h>
++#include <linux/can/ioctl.h>
++
++struct can_priv {
++	struct can_device_stats can_stats;
++
++	/* can-bus oscillator frequency, in Hz,
++	   BE CAREFUL! SOME CONTROLLERS (LIKE SJA1000)
++	   FOOLISH ABOUT THIS FRQ (for sja1000 as ex. this
++	   clock must be xtal clock divided by 2). */
++	u32	can_sys_clock;
++
++	/* by default max_brp is equal 64,
++	   but for a Freescale TouCAN, as ex., it can be 255*/
++	u32	max_brp;
++	/* For the mostly all controllers, max_sjw is equal 4, but
++	   some, hmm, CAN implementations hardwared it to 1 */
++	u8	max_sjw;
++
++	u32	baudrate;	/* in bauds */
++	struct can_bittime	bit_time;
++
++	spinlock_t irq_lock;
++	/* Please hold this lock when touching net_stats/can_stats*/
++	spinlock_t stats_lock;
++
++	can_state_t state;
++	can_mode_t  mode;
++	can_ctrlmode_t ctrlmode;
++
++	int (*do_set_bit_time)(struct net_device *dev, struct can_bittime *br);
++	int (*do_get_state)   (struct net_device *dev, can_state_t *state);
++	int (*do_set_mode)    (struct net_device *dev, can_mode_t mode);
++	int (*do_set_ctrlmode)(struct net_device *dev, can_ctrlmode_t ctrlmode);
++	int (*do_get_ctrlmode)(struct net_device *dev, can_ctrlmode_t *ctrlmode);
++};
++
++#define ND2D(_ndev)		(_ndev->dev.parent)
++
++struct net_device *alloc_candev(int sizeof_priv);
++void free_candev(struct net_device *dev);
++
++int can_calc_bit_time(struct can_priv *can, u32 baudrate,
++		      struct can_bittime_std *bit_time);
++
++#endif /* CAN_DEVICE_H */
+--- /dev/null
++++ b/include/linux/can/ioctl.h
+@@ -0,0 +1,152 @@
++/*
++ * linux/can/ioctl.h
++ *
++ * Definitions for CAN controller setup (work in progress)
++ *
++ * $Id$
++ *
++ * Send feedback to <socketcan-users@lists.berlios.de>
++ *
++ */
++
++#ifndef CAN_IOCTL_H
++#define CAN_IOCTL_H
++
++#include <linux/sockios.h>
++
++
++/* max. 16 private ioctls */
++
++#define SIOCSCANBAUDRATE	(SIOCDEVPRIVATE+0)
++#define SIOCGCANBAUDRATE	(SIOCDEVPRIVATE+1)
++
++#define SIOCSCANCUSTOMBITTIME   (SIOCDEVPRIVATE+2)
++#define SIOCGCANCUSTOMBITTIME   (SIOCDEVPRIVATE+3)
++
++#define SIOCSCANMODE		(SIOCDEVPRIVATE+4)
++#define SIOCGCANMODE		(SIOCDEVPRIVATE+5)
++
++#define SIOCSCANCTRLMODE	(SIOCDEVPRIVATE+6)
++#define SIOCGCANCTRLMODE	(SIOCDEVPRIVATE+7)
++
++#define SIOCSCANFILTER		(SIOCDEVPRIVATE+8)
++#define SIOCGCANFILTER		(SIOCDEVPRIVATE+9)
++
++#define SIOCGCANSTATE		(SIOCDEVPRIVATE+10)
++#define SIOCGCANSTATS		(SIOCDEVPRIVATE+11)
++
++#define SIOCSCANERRORCONFIG	(SIOCDEVPRIVATE+12)
++#define SIOCGCANERRORCONFIG	(SIOCDEVPRIVATE+13)
++
++/* parameters for ioctls */
++
++/* SIOC[SG]CANBAUDRATE */
++/* baudrate for CAN-controller in bits per second. */
++/* 0 = Scan for baudrate (Autobaud) */
++
++typedef __u32 can_baudrate_t;
++
++
++/* SIOC[SG]CANCUSTOMBITTIME */
++
++typedef enum CAN_BITTIME_TYPE {
++	CAN_BITTIME_STD,
++	CAN_BITTIME_BTR
++} can_bittime_type_t;
++
++/* TSEG1 of controllers usually is a sum of synch_seg (always 1),
++ * prop_seg and phase_seg1, TSEG2 = phase_seg2 */
++
++struct can_bittime_std {
++	__u32 brp;        /* baud rate prescaler */
++	__u8  prop_seg;   /* from 1 to 8 */
++	__u8  phase_seg1; /* from 1 to 8 */
++	__u8  phase_seg2; /* from 1 to 8 */
++	__u8  sjw:7;      /* from 1 to 4 */
++	__u8  sam:1;      /* 1 - enable triple sampling */
++};
++
++struct can_bittime_btr {
++	__u8  btr0;
++	__u8  btr1;
++};
++
++struct can_bittime {
++	can_bittime_type_t type;
++	union {
++		struct can_bittime_std std;
++		struct can_bittime_btr btr;
++	};
++};
++
++#define CAN_BAUDRATE_UNCONFIGURED	((__u32) 0xFFFFFFFFU)
++#define CAN_BAUDRATE_UNKNOWN		0
++
++/* SIOC[SG]CANMODE */
++
++typedef __u32 can_mode_t;
++
++#define CAN_MODE_STOP	0
++#define CAN_MODE_START	1
++#define CAN_MODE_SLEEP	2
++
++
++/* SIOC[SG]CANCTRLMODE */
++
++typedef __u32 can_ctrlmode_t;
++
++#define CAN_CTRLMODE_LOOPBACK   0x1
++#define CAN_CTRLMODE_LISTENONLY 0x2
++
++
++/* SIOCGCANFILTER */
++
++typedef __u32 can_filter_t;
++
++/* filter modes (may vary due to controller specific capabilities) */
++#define CAN_FILTER_CAPAB       0  /* get filter type capabilities
++				     (32 Bit value) */
++#define CAN_FILTER_MASK_VALUE  1  /* easy bit filter (see struct can_filter) */
++#define CAN_FILTER_SFF_BITMASK 2  /* bitfield with 2048 bit SFF filter */
++				  /* filters 3 - 31 currently undefined */
++
++#define CAN_FILTER_MAX         31 /* max. filter type value */
++
++
++/* SIOCGCANSTATE */
++
++typedef __u32 can_state_t;
++
++#define CAN_STATE_ACTIVE		0
++#define CAN_STATE_BUS_WARNING		1
++#define CAN_STATE_BUS_PASSIVE		2
++#define CAN_STATE_BUS_OFF		3
++#define CAN_STATE_SCANNING_BAUDRATE	4
++#define CAN_STATE_STOPPED		5
++#define CAN_STATE_SLEEPING		6
++
++
++/* SIOCGCANSTATS */
++
++struct can_device_stats {
++	int error_warning;
++	int data_overrun;
++	int wakeup;
++	int bus_error;
++	int error_passive;
++	int arbitration_lost;
++	int restarts;
++	int bus_error_at_init;
++};
++
++/* SIOC[SG]CANERRORCONFIG */
++
++typedef enum CAN_ERRCFG_TYPE {
++	CAN_ERRCFG_MASK,
++	CAN_ERRCFG_BUSERR,
++	CAN_ERRCFG_BUSOFF
++} can_errcfg_type_t;
++
++/* tbd */
++
++#endif /* CAN_IOCTL_H */
+--- /dev/null
++++ b/include/linux/can/version.h
+@@ -0,0 +1,22 @@
++/*
++ * linux/can/version.h
++ *
++ * Version information for the CAN network layer implementation
++
++ * Author: 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_VERSION_H
++#define CAN_VERSION_H
++
++#define RCSID(s) asm(".section .rodata.str1.1,\"aMS\",@progbits,1\n\t" \
++		     ".string \"" s "\"\n\t.previous\n")
++
++RCSID("$Id$");
++
++#endif /* CAN_VERSION_H */
+--- a/net/can/Makefile
++++ b/net/can/Makefile
+@@ -10,3 +10,6 @@ can-raw-objs		:= raw.o
+ 
+ obj-$(CONFIG_CAN_BCM)	+= can-bcm.o
+ can-bcm-objs		:= bcm.o
++
++obj-$(CONFIG_CAN)       += candev.o
++candev-objs             := dev.o
+--- /dev/null
++++ b/net/can/dev.c
+@@ -0,0 +1,292 @@
++/*
++ * $Id$
++ *
++ * Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
++ * Copyright (C) 2006 Andrey Volkov, Varma Electronics
++ *
++ * 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 <linux/module.h>
++#include <linux/netdevice.h>
++#include <linux/if_arp.h>
++#include <linux/can.h>
++#include <linux/can/dev.h>
++
++MODULE_DESCRIPTION("CAN netdevice library");
++MODULE_LICENSE("GPL v2");
++MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>, "
++	      "Andrey Volkov <avolkov@varma-el.com>");
++
++/*
++ Abstract:
++	Baud rate calculated with next formula:
++	baud = frq/(brp*(1 + prop_seg+ phase_seg1 + phase_seg2))
++
++	This calc function based on work of Florian Hartwich and Armin Bassemi
++	"The Configuration of the CAN Bit Timing"
++	(http://www.semiconductors.bosch.de/pdf/CiA99Paper.pdf)
++
++ Parameters:
++  [in]
++    bit_time_nsec - expected bit time in nanosecs
++
++  [out]
++	bit_time	- calculated time segments, for meaning of
++			  each field read CAN standard.
++*/
++
++#define DEFAULT_MAX_BRP			64U
++#define DEFAULT_MAX_SJW			4U
++
++/* All below values in tq units */
++#define MAX_BIT_TIME	25U
++#define MIN_BIT_TIME	8U
++#define MAX_PROP_SEG	8U
++#define MAX_PHASE_SEG1	8U
++#define MAX_PHASE_SEG2	8U
++
++int can_calc_bit_time(struct can_priv *can, u32 baudrate,
++		      struct can_bittime_std *bit_time)
++{
++	int best_error  = -1; /* Ariphmetic error */
++	int df, best_df = -1; /* oscillator's tolerance range */
++	u32 quanta;	      /*in tq units*/
++	u32 brp, phase_seg1, phase_seg2, sjw, prop_seg;
++	u32 brp_min, brp_max, brp_expected;
++	u64 tmp;
++
++	/* baudrate range [1baud,1Mbaud] */
++	if (baudrate == 0 || baudrate > 1000000UL)
++		return -EINVAL;
++
++	tmp = (u64)can->can_sys_clock*1000;
++	do_div(tmp, baudrate);
++	brp_expected = (u32)tmp;
++
++	brp_min = brp_expected / (1000 * MAX_BIT_TIME);
++	if (brp_min == 0)
++		brp_min = 1;
++	if (brp_min > can->max_brp)
++		return -ERANGE;
++
++	brp_max = (brp_expected + 500 * MIN_BIT_TIME) / (1000 * MIN_BIT_TIME);
++	if (brp_max == 0)
++		brp_max = 1;
++	if (brp_max > can->max_brp)
++		brp_max = can->max_brp;
++
++	for (brp = brp_min; brp <= brp_max; brp++) {
++		quanta = brp_expected / (brp * 1000);
++		if (quanta < MAX_BIT_TIME && quanta * brp * 1000 !=
++				brp_expected)
++			quanta++;
++		if (quanta < MIN_BIT_TIME || quanta > MAX_BIT_TIME)
++			continue;
++
++		phase_seg2 = min((quanta - 3) / 2, MAX_PHASE_SEG2);
++		for (sjw = can->max_sjw; sjw > 0; sjw--) {
++			for (; phase_seg2 > sjw; phase_seg2--) {
++				u32 err1, err2;
++				phase_seg1 = phase_seg2 % 2 ?
++					phase_seg2-1 : phase_seg2;
++				prop_seg = quanta-1 - phase_seg2 - phase_seg1;
++				/*
++				 * FIXME: support of longer lines
++				 * (i.e. bigger prop_seg) is more prefered
++				 * than support of cheap oscillators
++				 * (i.e. bigger df/phase_seg1/phase_seg2)
++				 * */
++
++				if (prop_seg < phase_seg1)
++						continue;
++				if (prop_seg > MAX_PROP_SEG)
++						goto next_brp;
++
++				err1 = phase_seg1 * brp * 500 * 1000 /
++					(13 * brp_expected - phase_seg2 *
++					 brp * 1000);
++				err2 = sjw * brp * 50 * 1000 / brp_expected;
++
++				df = min(err1, err2);
++				if (df >= best_df) {
++					unsigned error = abs(brp_expected * 10 /
++							(brp * (1 + prop_seg +
++								phase_seg1 +
++								phase_seg2)) - 10000);
++
++					if (error > 10 || error > best_error)
++						continue;
++
++					if (error == best_error && prop_seg <
++							bit_time->prop_seg)
++						continue;
++
++					best_error = error;
++					best_df = df;
++					bit_time->brp = brp;
++					bit_time->prop_seg = prop_seg;
++					bit_time->phase_seg1 = phase_seg1;
++					bit_time->phase_seg2 = phase_seg2;
++					bit_time->sjw = sjw;
++					bit_time->sam =
++						(bit_time->phase_seg1 > 3);
++				}
++			}
++		}
++next_brp:	;
++	}
++
++	if (best_error < 0)
++		return -EDOM;
++	return 0;
++}
++EXPORT_SYMBOL(can_calc_bit_time);
++
++static int can_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
++{
++	struct can_priv *can = netdev_priv(dev);
++	struct can_bittime *bt = (struct can_bittime *)&ifr->ifr_ifru;
++	ulong *baudrate = (ulong *)&ifr->ifr_ifru;
++	int ret = -EOPNOTSUPP;
++
++	dev_dbg(ND2D(dev), "(%s) 0x%08x %p\n", __func__, cmd, &ifr->ifr_ifru);
++
++	switch (cmd) {
++	case SIOCSCANBAUDRATE:
++		if (can->do_set_bit_time) {
++			struct can_bittime bit_time;
++			ret = can_calc_bit_time(can, *baudrate, &bit_time.std);
++			if (ret != 0)
++				break;
++			bit_time.type = CAN_BITTIME_STD;
++			ret = can->do_set_bit_time(dev, &bit_time);
++			if (!ret) {
++				can->baudrate = *baudrate;
++				can->bit_time = bit_time;
++			}
++		}
++		break;
++	case SIOCGCANBAUDRATE:
++		*baudrate = can->baudrate;
++		ret = 0;
++		break;
++	case SIOCSCANCUSTOMBITTIME:
++		if (can->do_set_bit_time) {
++			ret = can->do_set_bit_time(dev, bt);
++			if (!ret) {
++				can->bit_time = *bt;
++				if (bt->type == CAN_BITTIME_STD && bt->std.brp) {
++					can->baudrate = can->can_sys_clock /
++						(bt->std.brp * (1 + bt->std.prop_seg +
++								bt->std.phase_seg1 +
++								bt->std.phase_seg2));
++				} else
++					can->baudrate = CAN_BAUDRATE_UNKNOWN;
++			}
++		}
++		break;
++	case SIOCGCANCUSTOMBITTIME:
++		*bt = can->bit_time;
++		ret = 0;
++		break;
++	case SIOCSCANMODE:
++		if (can->do_set_mode) {
++			can_mode_t mode =
++				*((can_mode_t *)(&ifr->ifr_ifru));
++			if (mode == CAN_MODE_START &&
++			    can->baudrate == CAN_BAUDRATE_UNCONFIGURED) {
++				dev_info(ND2D(dev), "Impossible to start \
++						on UNKNOWN speed\n");
++				ret = EINVAL;
++			} else
++				return can->do_set_mode(dev, mode);
++		}
++		break;
++	case SIOCGCANMODE:
++		*((can_mode_t *)(&ifr->ifr_ifru)) = can->mode;
++		ret = 0;
++		break;
++	case SIOCSCANCTRLMODE:
++		if (can->do_set_ctrlmode) {
++			can_ctrlmode_t ctrlmode =
++				*((can_ctrlmode_t *)(&ifr->ifr_ifru));
++			return can->do_set_ctrlmode(dev, ctrlmode);
++		}
++		break;
++	case SIOCGCANCTRLMODE:
++		*((can_ctrlmode_t *)(&ifr->ifr_ifru)) = can->ctrlmode;
++		ret = 0;
++		break;
++	case SIOCSCANFILTER:
++		break;
++	case SIOCGCANFILTER:
++		break;
++	case SIOCGCANSTATE:
++		if (can->do_get_state)
++			return can->do_get_state(dev,
++					(can_state_t *)(&ifr->ifr_ifru));
++		break;
++	case SIOCGCANSTATS:
++		*((struct can_device_stats *)(&ifr->ifr_ifru)) = can->can_stats;
++		ret = 0;
++		break;
++	}
++
++	return ret;
++}
++
++static void can_setup(struct net_device *dev)
++{
++	dev->type            = ARPHRD_CAN;
++	dev->mtu             = sizeof(struct can_frame);
++	dev->do_ioctl        = can_ioctl;
++	dev->hard_header_len = 0;
++	dev->addr_len        = 0;
++	dev->tx_queue_len    = 10;
++
++	/* New-style flags. */
++	dev->flags           = IFF_NOARP;
++	dev->features        = NETIF_F_NO_CSUM;
++}
++
++/*
++ * Function  alloc_candev
++ * 	Allocates and sets up an CAN device
++ */
++struct net_device *alloc_candev(int sizeof_priv)
++{
++	struct net_device *dev;
++	struct can_priv *priv;
++
++	dev = alloc_netdev(sizeof_priv, "can%d", can_setup);
++	if (!dev)
++		return NULL;
++
++	priv = netdev_priv(dev);
++
++	priv->baudrate = CAN_BAUDRATE_UNCONFIGURED;
++	priv->max_brp  = DEFAULT_MAX_BRP;
++	priv->max_sjw  = DEFAULT_MAX_SJW;
++	spin_lock_init(&priv->irq_lock);
++
++	return dev;
++}
++EXPORT_SYMBOL(alloc_candev);
++
++void free_candev(struct net_device *dev)
++{
++	free_netdev(dev);
++}
++EXPORT_SYMBOL(free_candev);