在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设备信息:

 





 

 ​
​​

  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文件中的代码:

 



 

 ​
​​

  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函数:

 




 

 ​
​​

  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。




  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指针的初始化。

 




  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接口的具体操作函数代码如下:

 




  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. };  




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


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

 

 

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

 




  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特定的操作函数。

 




  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()函数不再详述。

 




  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()函数:




  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寄存器进入对应的模式。




  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()函数不再分析。



  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