xilinx 的socket CAN驱动介绍

 

linux的socket CAN驱动介绍

网址：http://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设备信息：

[html]  view plain  copy

 

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

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

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

[html]  view plain  copy

 

1. /* Match table for OF platform binding */  
2. static struct of_device_id xcan_of_match[] = {  
3.     { .compatible = "xlnx,ps7-can", },  
4.     { .compatible = "xlnx,axi-can-1.00.a", },  
5.     { /* end of list */ },  
6. };  
7. MODULE_DEVICE_TABLE(of, xcan_of_match);  
8.   
9. static struct platform_driver xcan_driver = {  
10.     .probe = xcan_probe,  
11.     .remove = xcan_remove,  
12.     .driver = {  
13.         .owner = THIS_MODULE,  
14.         .name = DRIVER_NAME,  
15.         .pm = &xcan_dev_pm_ops,  
16.         .of_match_table = xcan_of_match,  
17.     },  
18. };  

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

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

    接着看xcan_probe函数：

[cpp]  view plain  copy

 

1. /** 
2.  * xcan_probe - Platform registration call 
3.  * @pdev:   Handle to the platform device structure 
4.  * 
5.  * This function does all the memory allocation and registration for the CAN 
6.  * device. 
7.  * 
8.  * Return: 0 on success and failure value on error 
9.  */  
10. static int xcan_probe(struct platform_device *pdev)  
11. {  
12.     struct resource *res; /* IO mem resources */  
13.     struct net_device *ndev;  
14.     struct xcan_priv *priv;  
15.     struct device *dev = &pdev->dev;  
16.     int ret, irq;  
17.   
18.     /* Create a CAN device instance */  
19.     ndev = alloc_candev(sizeof(struct xcan_priv), XCAN_ECHO_SKB_MAX);  
20.     if (!ndev)  
21.         return -ENOMEM;  
22.   
23.     priv = netdev_priv(ndev);  
24.     priv->dev = ndev;  
25.     priv->can.bittiming_const = &xcan_bittiming_const;  
26.     priv->can.do_set_bittiming = xcan_set_bittiming;  
27.     priv->can.do_set_mode = xcan_do_set_mode;  
28.     priv->can.do_get_berr_counter = xcan_get_berr_counter;  
29.     priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK;  
30.     priv->waiting_ech_skb_index = 0;  
31.     priv->ech_skb_next = 0;  
32.     priv->waiting_ech_skb_num = 0;  
33.     priv->xcan_echo_skb_max = XCAN_ECHO_SKB_MAX;  
34.   
35.     /* Get IRQ for the device */  
36.     ndev->irq = platform_get_irq(pdev, 0);  
37.     irq = devm_request_irq(&pdev->dev, ndev->irq, &xcan_interrupt,  
38.                 priv->irq_flags, dev_name(&pdev->dev),  
39.                 (void *)ndev);  
40.     if (irq < 0) {  
41.         ret = irq;  
42.         dev_err(&pdev->dev, "Irq allocation for CAN failed\n");  
43.         goto err_free;  
44.     }  
45.   
46.     spin_lock_init(&priv->ech_skb_lock);  
47.     ndev->flags |= IFF_ECHO; /* We support local echo */  
48.   
49.     platform_set_drvdata(pdev, ndev);  
50.     SET_NETDEV_DEV(ndev, &pdev->dev);  
51.     ndev->netdev_ops = &xcan_netdev_ops;  
52.   
53.     /* Get the virtual base address for the device */  
54.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
55.     priv->reg_base = devm_ioremap_resource(&pdev->dev, res);  
56.     if (IS_ERR(priv->reg_base)) {  
57.         ret = PTR_ERR(priv->reg_base);  
58.         goto err_free;  
59.     }  
60.     ndev->mem_start = res->start;  
61.     ndev->mem_end = res->end;  
62.   
63.     priv->write_reg  = xcan_write_reg;  
64.     priv->read_reg = xcan_read_reg;  
65.   
66.     /* Getting the CAN devclk info */  
67.     priv->devclk = devm_clk_get(&pdev->dev, "ref_clk");  
68.     if (IS_ERR(priv->devclk)) {  
69.         dev_err(&pdev->dev, "Device clock not found.\n");  
70.         ret = PTR_ERR(priv->devclk);  
71.         goto err_free;  
72.     }  
73.   
74.     /* Check for type of CAN device */  
75.     if (of_device_is_compatible(pdev->dev.of_node, "xlnx,ps7-can")) {  
76.         priv->aperclk = devm_clk_get(&pdev->dev, "aper_clk");  
77.         if (IS_ERR(priv->aperclk)) {  
78.             dev_err(&pdev->dev, "aper clock not found\n");  
79.             ret = PTR_ERR(priv->aperclk);  
80.             goto err_free;  
81.         }  
82.     } else {  
83.         priv->aperclk = priv->devclk;  
84.     }  
85.   
86.     ret = clk_prepare_enable(priv->devclk);  
87.     if (ret) {  
88.         dev_err(&pdev->dev, "unable to enable device clock\n");  
89.         goto err_free;  
90.     }  
91.   
92.     ret = clk_prepare_enable(priv->aperclk);  
93.     if (ret) {  
94.         dev_err(&pdev->dev, "unable to enable aper clock\n");  
95.         goto err_unprepar_disabledev;  
96.     }  
97.   
98.     priv->can.clock.freq = clk_get_rate(priv->devclk);  
99.   
100.     ret = register_candev(ndev);  
101.     if (ret) {  
102.         dev_err(&pdev->dev, "fail to register failed (err=%d)\n", ret);  
103.         goto err_unprepar_disableaper;  
104.     }  
105.   
106.     dev_info(&pdev->dev,  
107.             "reg_base=0x%p irq=%d clock=%d, tx fifo depth:%d\n",  
108.             priv->reg_base, ndev->irq, priv->can.clock.freq,  
109.             priv->xcan_echo_skb_max);  
110.   
111.     return 0;  
112.   
113. err_unprepar_disableaper:  
114.     clk_disable_unprepare(priv->aperclk);  
115. err_unprepar_disabledev:  
116.     clk_disable_unprepare(priv->devclk);  
117. err_free:  
118.     free_candev(ndev);  
119.   
120.     return ret;  
121. }  

     当一个设备驱动通过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。

[cpp]  view plain  copy

 

1. /** 
2.  * struct xcan_priv - This definition define CAN driver instance 
3.  * @can:            CAN private data structure. 
4.  * @open_time:          For holding timeout values 
5.  * @waiting_ech_skb_index:  Pointer for skb 
6.  * @ech_skb_next:       This tell the next packet in the queue 
7.  * @waiting_ech_skb_num:    Gives the number of packets waiting 
8.  * @xcan_echo_skb_max:      Maximum number packets the driver CAN send 
9.  * @ech_skb_lock:       For spinlock purpose 
10.  * @read_reg:           For reading data from CAN registers 
11.  * @write_reg:          For writing data to CAN registers 
12.  * @dev:            Network device data structure 
13.  * @reg_base:           Ioremapped address to registers 
14.  * @irq_flags:          For request_irq() 
15.  * @aperclk:            Pointer to struct clk 
16.  * @devclk:         Pointer to struct clk 
17.  */  
18. struct xcan_priv {  
19.     struct can_priv can;  
20.     int open_time;  
21.     int waiting_ech_skb_index;  
22.     int ech_skb_next;  
23.     int waiting_ech_skb_num;  
24.     int xcan_echo_skb_max;  
25.     spinlock_t ech_skb_lock;  
26.     u32 (*read_reg)(const struct xcan_priv *priv, int reg);  
27.     void (*write_reg)(const struct xcan_priv *priv, int reg, u32 val);  
28.     struct net_device *dev;  
29.     void __iomem *reg_base;  
30.     unsigned long irq_flags;  
31.     struct clk *aperclk;  
32.     struct clk *devclk;  
33. };  

    调用alloc_candev()函数获取一个net_device变量，设置socket buffer大小为XCAN_ECHO_SKB_MAX=64个字节。

    接着是对struct xcan_priv *priv指针的初始化。

[cpp]  view plain  copy

 

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

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

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

[cpp]  view plain  copy

 

1. static const struct net_device_ops xcan_netdev_ops = {  
2.     .ndo_open   = xcan_open,  
3.     .ndo_stop   = xcan_close,  
4.     .ndo_start_xmit = xcan_start_xmit,  
5. };  

[cpp]  view plain  copy

 

1. <span style="font-size:12px;">ndev->netdev_ops = &xcan_netdev_ops;</span>  

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

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

[cpp]  view plain  copy

 

1. static void xcan_write_reg(const struct xcan_priv *priv, int reg, u32 val)  
2. {  
3.     writel(val, priv->reg_base + reg);  
4. }  
5. static u32 xcan_read_reg(const struct xcan_priv *priv, int reg)  
6. {  
7.     return readl(priv->reg_base + reg);  
8. }  
9. .............  
10.   
11.         priv->write_reg = xcan_write_reg;  
12.     priv->read_reg = xcan_read_reg;  

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

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

[cpp]  view plain  copy

 

1. ret = register_candev(ndev);  
2. ............  
3. int register_candev(struct net_device *dev)  
4. {  
5.     dev->rtnl_link_ops = &can_link_ops;  
6.     return register_netdev(dev);  
7. }  
8. .......  
9. static struct rtnl_link_ops can_link_ops __read_mostly = {  
10.     .kind       = "can",  
11.     .maxtype    = IFLA_CAN_MAX,  
12.     .policy     = can_policy,  
13.     .setup      = can_setup,  
14.     .newlink    = can_newlink,  
15.     .changelink = can_changelink,  
16.     .get_size   = can_get_size,  
17.     .fill_info  = can_fill_info,  
18.     .get_xstats_size = can_get_xstats_size,  
19.     .fill_xstats    = can_fill_xstats,  
20. };  

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

[cpp]  view plain  copy

 

1. static int xcan_remove(struct platform_device *pdev)  
2. {  
3.     struct net_device *ndev = platform_get_drvdata(pdev);  
4.     struct xcan_priv *priv = netdev_priv(ndev);  
5.   
6.     if (set_reset_mode(ndev) < 0)  
7.         netdev_err(ndev, "mode resetting failed!\n");  
8.   
9.     unregister_candev(ndev);  
10.     clk_disable_unprepare(priv->aperclk);  
11.     clk_disable_unprepare(priv->devclk);  
12.   
13.     free_candev(ndev);  
14.   
15.     return 0;  
16. }  

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

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

[cpp]  view plain  copy

 

1. static int xcan_open(struct net_device *ndev)  
2. {  
3.     struct xcan_priv *priv = netdev_priv(ndev);  
4.     int err;  
5.   
6.     /* Set chip into reset mode */  
7.     err = set_reset_mode(ndev);  
8.     if (err < 0)  
9.         netdev_err(ndev, "mode resetting failed failed!\n");  
10.   
11.     /* Common open */  
12.     err = open_candev(ndev);  
13.     if (err)  
14.         return err;  
15.   
16.     err = xcan_start(ndev);  
17.     if (err < 0)  
18.         netdev_err(ndev, "xcan_start failed!\n");  
19.   
20.     priv->open_time = jiffies;  
21.   
22.     can_led_event(ndev, CAN_LED_EVENT_OPEN);  
23.     netif_start_queue(ndev);  
24.   
25.     return 0;  
26. }  

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

[cpp]  view plain  copy

 

1. static int set_normal_mode(struct net_device *ndev)  
2. {  
3.     struct xcan_priv *priv = netdev_priv(ndev);  
4.   
5.     /* Enable interrupts */  
6.     priv->write_reg(priv, XCAN_IER_OFFSET, XCAN_IXR_TXOK_MASK |  
7.             XCAN_IXR_BSOFF_MASK | XCAN_IXR_WKUP_MASK |  
8.             XCAN_IXR_SLP_MASK | XCAN_IXR_RXNEMP_MASK |  
9.             XCAN_IXR_ERROR_MASK | XCAN_IXR_ARBLST_MASK);  
10.   
11.     /* Check whether it is loopback mode or normal mode  */  
12.     if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)  
13.         /* Put device into loopback mode */  
14.         priv->write_reg(priv, XCAN_MSR_OFFSET, XCAN_MSR_LBACK_MASK);  
15.     else  
16.         /* The device is in normal mode */  
17.         priv->write_reg(priv, XCAN_MSR_OFFSET, 0);  
18.   
19.     if (priv->can.state == CAN_STATE_STOPPED) {  
20.         /* Enable Xilinx CAN */  
21.         priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_CEN_MASK);  
22.         priv->can.state = CAN_STATE_ERROR_ACTIVE;  
23.         if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {  
24.             while ((priv->read_reg(priv, XCAN_SR_OFFSET) &  
25.                     XCAN_SR_LBACK_MASK) == 0)  
26.                     ;  
27.         } else {  
28.             while ((priv->read_reg(priv, XCAN_SR_OFFSET)  
29.                     & XCAN_SR_NORMAL_MASK) == 0)  
30.                     ;  
31.         }  
32.         netdev_dbg(ndev, "status:#x%08x\n",  
33.                 priv->read_reg(priv, XCAN_SR_OFFSET));  
34.     }  
35.   
36.     return 0;  
37. }  

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

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

[cpp]  view plain  copy

 

1. static int xcan_close(struct net_device *ndev)  
2. {  
3.     struct xcan_priv *priv = netdev_priv(ndev);  
4.   
5.     netif_stop_queue(ndev);  
6.     if (set_reset_mode(ndev) < 0)  
7.         netdev_err(ndev, "mode resetting failed failed!\n");  
8.   
9.     close_candev(ndev);  
10.   
11.     priv->open_time = 0;  
12.   
13.     can_led_event(ndev, CAN_LED_EVENT_STOP);  
14.   
15.     return 0;  
16. }  

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

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

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

    NAPI函数的调用过程如下：

netif_napi_add

...

napi_enable

...

关中断

napi_schedule

...

netif_receive_skb

napi_complete