linux的socket CAN驅動介紹(code)_good

轉載於:　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設備信息：

 

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

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

主要是指定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