linux的socket CAN驱动介绍

https://blog.csdn.net/linyangspring/article/details/27186911

在linux中，CAN总线的驱动有两种实现方式：字符设备以及socket can驱动。Socket CAN使用伯克利的Socket接口和Linux网络协议栈，这种方法使得CAN设备驱动可以通过网络接口来调用。Socket CAN的接口被设计的尽量接近TCP/IP的协议，让那些熟悉网络编程的程序员能够比较容易的学习和使用。

本文以赛灵思的Zynq-7000为硬件背景，详细介绍开发板上的socket can驱动。主要的驱动文件为dev.c以及xilinx_can.c，可以从https://github.com/Xilinx/linux-xlnx获取。

首先看一下传递给内核的dts文件中的can设备信息：

ps7_can_0: ps7-can@e0008000 {
	clock-names = "ref_clk", "aper_clk";
	clocks = <&clkc 19>, <&clkc 36>;
	compatible = "xlnx,ps7-can-1.00.a", "xlnx,ps7-can";
	interrupt-parent = <&ps7_scugic_0>;
	interrupts = <0 28 4>;
	reg = <0xe0008000 0x1000>;
} ;

指定了寄存器地址范围，中断号，驱动适配版本以及参考时钟源。

再来看xilinx_can.c文件中的代码：

/* Match table for OF platform binding */
static struct of_device_id xcan_of_match[] = {
	{ .compatible = "xlnx,ps7-can", },
	{ .compatible = "xlnx,axi-can-1.00.a", },
	{ /* end of list */ },
};
MODULE_DEVICE_TABLE(of, xcan_of_match);
 
static struct platform_driver xcan_driver = {
	.probe = xcan_probe,
	.remove	= xcan_remove,
	.driver	= {
		.owner = THIS_MODULE,
		.name = DRIVER_NAME,
		.pm = &xcan_dev_pm_ops,
		.of_match_table	= xcan_of_match,
	},
};

可见对于PS的CAN接口以及PL的基于axi总线的CAN接口，均可以使用该platform_driver驱动。

ARM上电之后，linux初始化函数会依据dts信息将CAN硬件信息加入到系统的硬件链表中，当驱动程序装载时，会去遍历该链表获取硬件信息，比如寄存器地址、中断号等，然后调用ioremap、request_irq等，进一步初始化硬件。

接着看xcan_probe函数：

/**
 * xcan_probe - Platform registration call
 * @pdev:	Handle to the platform device structure
 *
 * This function does all the memory allocation and registration for the CAN
 * device.
 *
 * Return: 0 on success and failure value on error
 */
static int xcan_probe(struct platform_device *pdev)
{
	struct resource *res; /* IO mem resources */
	struct net_device *ndev;
	struct xcan_priv *priv;
	struct device *dev = &pdev->dev;
	int ret, irq;
 
	/* Create a CAN device instance */
	ndev = alloc_candev(sizeof(struct xcan_priv), XCAN_ECHO_SKB_MAX);
	if (!ndev)
		return -ENOMEM;
 
	priv = netdev_priv(ndev);
	priv->dev = ndev;
	priv->can.bittiming_const = &xcan_bittiming_const;
	priv->can.do_set_bittiming = xcan_set_bittiming;
	priv->can.do_set_mode = xcan_do_set_mode;
	priv->can.do_get_berr_counter = xcan_get_berr_counter;
	priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK;
	priv->waiting_ech_skb_index = 0;
	priv->ech_skb_next = 0;
	priv->waiting_ech_skb_num = 0;
	priv->xcan_echo_skb_max = XCAN_ECHO_SKB_MAX;
 
	/* Get IRQ for the device */
	ndev->irq = platform_get_irq(pdev, 0);
	irq = devm_request_irq(&pdev->dev, ndev->irq, &xcan_interrupt,
				priv->irq_flags, dev_name(&pdev->dev),
				(void *)ndev);
	if (irq < 0) {
		ret = irq;
		dev_err(&pdev->dev, "Irq allocation for CAN failed\n");
		goto err_free;
	}
 
	spin_lock_init(&priv->ech_skb_lock);
	ndev->flags |= IFF_ECHO;	/* We support local echo */
 
	platform_set_drvdata(pdev, ndev);
	SET_NETDEV_DEV(ndev, &pdev->dev);
	ndev->netdev_ops = &xcan_netdev_ops;
 
	/* Get the virtual base address for the device */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	priv->reg_base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(priv->reg_base)) {
		ret = PTR_ERR(priv->reg_base);
		goto err_free;
	}
	ndev->mem_start = res->start;
	ndev->mem_end = res->end;
 
	priv->write_reg	= xcan_write_reg;
	priv->read_reg = xcan_read_reg;
 
	/* Getting the CAN devclk info */
	priv->devclk = devm_clk_get(&pdev->dev, "ref_clk");
	if (IS_ERR(priv->devclk)) {
		dev_err(&pdev->dev, "Device clock not found.\n");
		ret = PTR_ERR(priv->devclk);
		goto err_free;
	}
 
	/* Check for type of CAN device */
	if (of_device_is_compatible(pdev->dev.of_node, "xlnx,ps7-can")) {
		priv->aperclk = devm_clk_get(&pdev->dev, "aper_clk");
		if (IS_ERR(priv->aperclk)) {
			dev_err(&pdev->dev, "aper clock not found\n");
			ret = PTR_ERR(priv->aperclk);
			goto err_free;
		}
	} else {
		priv->aperclk = priv->devclk;
	}
 
	ret = clk_prepare_enable(priv->devclk);
	if (ret) {
		dev_err(&pdev->dev, "unable to enable device clock\n");
		goto err_free;
	}
 
	ret = clk_prepare_enable(priv->aperclk);
	if (ret) {
		dev_err(&pdev->dev, "unable to enable aper clock\n");
		goto err_unprepar_disabledev;
	}
 
	priv->can.clock.freq = clk_get_rate(priv->devclk);
 
	ret = register_candev(ndev);
	if (ret) {
		dev_err(&pdev->dev, "fail to register failed (err=%d)\n", ret);
		goto err_unprepar_disableaper;
	}
 
	dev_info(&pdev->dev,
			"reg_base=0x%p irq=%d clock=%d, tx fifo depth:%d\n",
			priv->reg_base, ndev->irq, priv->can.clock.freq,
			priv->xcan_echo_skb_max);
 
	return 0;
 
err_unprepar_disableaper:
	clk_disable_unprepare(priv->aperclk);
err_unprepar_disabledev:
	clk_disable_unprepare(priv->devclk);
err_free:
	free_candev(ndev);
 
	return ret;
}

当一个设备驱动通过driver_register加入对应的驱动总线下时，会去遍历对应总线下的设备双向链表，当驱动和设备匹配时，会触发驱动的probe函数，probe函数的传入参数pdev即为遍历得到的设备信息。

struct xcan_priv为CAN私有数据结构，包含struct can_priv、struct net_device等数据成员，注意can_priv结构成员一定要放在第一位，具体原因参考http://blog.sina.com.cn/s/blog_636a55070101mc2d.html。

/**
 * struct xcan_priv - This definition define CAN driver instance
 * @can:			CAN private data structure.
 * @open_time:			For holding timeout values
 * @waiting_ech_skb_index:	Pointer for skb
 * @ech_skb_next:		This tell the next packet in the queue
 * @waiting_ech_skb_num:	Gives the number of packets waiting
 * @xcan_echo_skb_max:		Maximum number packets the driver CAN send
 * @ech_skb_lock:		For spinlock purpose
 * @read_reg:			For reading data from CAN registers
 * @write_reg:			For writing data to CAN registers
 * @dev:			Network device data structure
 * @reg_base:			Ioremapped address to registers
 * @irq_flags:			For request_irq()
 * @aperclk:			Pointer to struct clk
 * @devclk:			Pointer to struct clk
 */
struct xcan_priv {
	struct can_priv can;
	int open_time;
	int waiting_ech_skb_index;
	int ech_skb_next;
	int waiting_ech_skb_num;
	int xcan_echo_skb_max;
	spinlock_t ech_skb_lock;
	u32 (*read_reg)(const struct xcan_priv *priv, int reg);
	void (*write_reg)(const struct xcan_priv *priv, int reg, u32 val);
	struct net_device *dev;
	void __iomem *reg_base;
	unsigned long irq_flags;
	struct clk *aperclk;
	struct clk *devclk;
};

调用alloc_candev()函数获取一个net_device变量，设置socket buffer大小为XCAN_ECHO_SKB_MAX=64个字节。接着是对struct xcan_priv *priv指针的初始化。

	priv->can.do_set_bittiming = xcan_set_bittiming;
	priv->can.do_set_mode = xcan_do_set_mode;
	priv->can.do_get_berr_counter = xcan_get_berr_counter;

CAN接口的位速率设置函数，模式设置函数，数据传输错误计数函数。

牵涉到CAN接口的具体操作函数代码如下：

static const struct net_device_ops xcan_netdev_ops = {
	.ndo_open	= xcan_open,
	.ndo_stop	= xcan_close,
	.ndo_start_xmit	= xcan_start_xmit,
};

ndev->netdev_ops = &xcan_netdev_ops；

主要是指定struct net_device *ndev指针的打开关闭以及数据发送函数。

然后指定struct xcan_priv *priv指针的读写寄存器函数。

static void xcan_write_reg(const struct xcan_priv *priv, int reg, u32 val)
{
	writel(val, priv->reg_base + reg);
}
static u32 xcan_read_reg(const struct xcan_priv *priv, int reg)
{
	return readl(priv->reg_base + reg);
}
.............
 
        priv->write_reg = xcan_write_reg;
	priv->read_reg = xcan_read_reg;

接着获取设备时钟源并使能，注意Zynq-7000要求每个设备有两个时钟源。

然后注册CAN设备，其实是注册net设备，只不过指定net设备的操作函数为CAN特定的操作函数。

ret = register_candev(ndev);
............
int register_candev(struct net_device *dev)
{
	dev->rtnl_link_ops = &can_link_ops;
	return register_netdev(dev);
}
.......
static struct rtnl_link_ops can_link_ops __read_mostly = {
	.kind		= "can",
	.maxtype	= IFLA_CAN_MAX,
	.policy		= can_policy,
	.setup		= can_setup,
	.newlink	= can_newlink,
	.changelink	= can_changelink,
	.get_size	= can_get_size,
	.fill_info	= can_fill_info,
	.get_xstats_size = can_get_xstats_size,
	.fill_xstats	= can_fill_xstats,
};

至于xcan_remove()函数不再详述。

static int xcan_remove(struct platform_device *pdev)
{
	struct net_device *ndev = platform_get_drvdata(pdev);
	struct xcan_priv *priv = netdev_priv(ndev);
 
	if (set_reset_mode(ndev) < 0)
		netdev_err(ndev, "mode resetting failed!\n");
 
	unregister_candev(ndev);
	clk_disable_unprepare(priv->aperclk);
	clk_disable_unprepare(priv->devclk);
 
	free_candev(ndev);
 
	return 0;
}

有关socket can应用层程序的编写可以参考Documentation\networking\can.txt。

当使用socket打开can接口时，会调用到xcan_open()函数：

static int xcan_open(struct net_device *ndev)
{
	struct xcan_priv *priv = netdev_priv(ndev);
	int err;
 
	/* Set chip into reset mode */
	err = set_reset_mode(ndev);
	if (err < 0)
		netdev_err(ndev, "mode resetting failed failed!\n");
 
	/* Common open */
	err = open_candev(ndev);
	if (err)
		return err;
 
	err = xcan_start(ndev);
	if (err < 0)
		netdev_err(ndev, "xcan_start failed!\n");
 
	priv->open_time = jiffies;
 
	can_led_event(ndev, CAN_LED_EVENT_OPEN);
	netif_start_queue(ndev);
 
	return 0;
}

首先reset CAN，进入config mode；然后调用dev.c中的open_candev()函数打开CAN接口；调用xcan_start()函数，进入Normal mode，主要是使能中断，依据应用层传入的mode参数设置loopback mode或者normal mode；然后使能CAN接口，并等待XCAN_SR_OFFSET寄存器进入对应的模式。

static int set_normal_mode(struct net_device *ndev)
{
	struct xcan_priv *priv = netdev_priv(ndev);
 
	/* Enable interrupts */
	priv->write_reg(priv, XCAN_IER_OFFSET, XCAN_IXR_TXOK_MASK |
			XCAN_IXR_BSOFF_MASK | XCAN_IXR_WKUP_MASK |
			XCAN_IXR_SLP_MASK | XCAN_IXR_RXNEMP_MASK |
			XCAN_IXR_ERROR_MASK | XCAN_IXR_ARBLST_MASK);
 
	/* Check whether it is loopback mode or normal mode  */
	if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
		/* Put device into loopback mode */
		priv->write_reg(priv, XCAN_MSR_OFFSET, XCAN_MSR_LBACK_MASK);
	else
		/* The device is in normal mode */
		priv->write_reg(priv, XCAN_MSR_OFFSET, 0);
 
	if (priv->can.state == CAN_STATE_STOPPED) {
		/* Enable Xilinx CAN */
		priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_CEN_MASK);
		priv->can.state = CAN_STATE_ERROR_ACTIVE;
		if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
			while ((priv->read_reg(priv, XCAN_SR_OFFSET) &
					XCAN_SR_LBACK_MASK) == 0)
					;
		} else {
			while ((priv->read_reg(priv, XCAN_SR_OFFSET)
					& XCAN_SR_NORMAL_MASK) == 0)
					;
		}
		netdev_dbg(ndev, "status:#x%08x\n",
				priv->read_reg(priv, XCAN_SR_OFFSET));
	}
 
	return 0;
}

最后调用netif_start_queue()函数使能发送队列。

对应的xcan_close()函数不再分析。

static int xcan_close(struct net_device *ndev)
{
	struct xcan_priv *priv = netdev_priv(ndev);
 
	netif_stop_queue(ndev);
	if (set_reset_mode(ndev) < 0)
		netdev_err(ndev, "mode resetting failed failed!\n");
 
	close_candev(ndev);
 
	priv->open_time = 0;
 
	can_led_event(ndev, CAN_LED_EVENT_STOP);
 
	return 0;
}

带NAPI的中断轮询数据接收模式

中断接收数据模式在数据频繁情况下，中断触发负载过大，系统性能受到影响，为此基于轮询的接收模式被开发，称为New API，即NAPI。

NAPI仍然需要首次数据包接收中断来触发poll过程，第一次接收中断发生后，中断处理程序禁止设备的接收中断，通过poll方式读取设备的接收缓冲区后，再次使能中断。

NAPI函数的调用过程如下：

netif_napi_add

…

napi_enable

…

关中断

napi_schedule

…

netif_receive_skb

napi_complete