Linux SPI 驱动分析

参考文章： Linux下spi驱动开发        作者：刘洪涛

    SPI驱动和前面的I2C类似，采用了主机、外设驱动分离的思想，通过SPI核心（文件位置/derivers/spi/spi.c，类似于i2c-core.c）调动SPI控制器驱动和外设驱动。SPI总线、控制器和设备的注册过程与上一篇的I2C的整个注册过程是一样的，想了解注册过程可参考上一篇linux i2c驱动分析 s3c6410(一)（转载）。

    SPI总线、控制器和设备的各个驱动注册完成后，sys目录下spi子系统结构如下:

1. s3c64xx的spi控制器platform驱动
1.1 Platform bus
   Platform bus对应的结构是platform_bus_type，这个内核开始就定义好的。我们不需要定义。
1.2 Platform_device
    SPI控制器对应platform_device的定义方式，同样以S3c6410中的SPI控制器为例，参看arch/arm/mach-s3c64xx/dev-spi.c文件

struct platform_device s3c64xx_device_spi1 = {
    .name         = "s3c64xx-spi",            /* 名称，要和Platform_driver匹配 */
    .id         = 1,                          /* 第1个控制器，S3c6410中有2个控制器 */
    .num_resources     = ARRAY_SIZE(s3c64xx_spi1_resource),
    .resource     = s3c64xx_spi1_resource,    /* 指向资源结构数组的指针 */
    .dev = {
        .dma_mask        = &spi_dmamask,      /* dma寻址范围 */
        .coherent_dma_mask    = DMA_BIT_MASK(32),     /* 可以通过关闭cache等措施保证一致性的dma寻址范围 */
        .platform_data = &s3c64xx_spi1_pdata, /* 特殊的平台数据，参看后文 */
    },
};

static struct s3c64xx_spi_info s3c64xx_spi1_pdata = {
    .cfg_gpio = s3c64xx_spi_cfg_gpio,        /* 用于控制器管脚的IO配置 */
    .fifo_lvl_mask = 0x7f,
    .rx_lvl_offset = 13,
    .tx_st_done = 21,
};

static int s3c64xx_spi_cfg_gpio(struct platform_device *pdev)
{
    unsigned int base;

    switch (pdev->id) {
    case 0:
        base = S3C64XX_GPC(0);
        break;

    case 1:
        base = S3C64XX_GPC(4);
        break;

    default:
        dev_err(&pdev->dev, "Invalid SPI Controller number!");
        return -EINVAL;
    }

    s3c_gpio_cfgall_range(base, 3,
                  S3C_GPIO_SFN(2), S3C_GPIO_PULL_UP);

    return 0;

1.3 Platform_driver
    再看platform_driver，参看drivers/spi/spi_s3c64xx.c文件

static struct platform_driver s3c64xx_spi_driver = {
    .driver = {
        .name    = "s3c64xx-spi",        /* 名称，和platform_device对应 */
        .owner = THIS_MODULE,
    },
    .remove = s3c64xx_spi_remove,
    .suspend = s3c64xx_spi_suspend,
    .resume = s3c64xx_spi_resume,
};

    platform_driver_probe(&s3c64xx_spi_driver, s3c64xx_spi_probe);    /* 注册s3c64xx_spi_driver */
    和平台中注册的platform_device匹配后，调用s3c64xx_spi_probe。然后根据传入的platform_device参数，构建一个用于描述SPI控制器的结构体spi_master，并注册: spi_register_master(master)。后续注册的spi_device需要选定自己的spi_master，并利用spi_master提供的传输功能传输spi数据。
    和I2C类似，SPI也有一个描述控制器的对象叫spi_master。其主要成员是主机控制器的序号（系统中可能存在多个SPI主机控制器）、片选数量、SPI模式和时钟设置用到的函数、数据传输用到的函数等。

struct spi_master {
    struct device   dev;
    struct list_head list;
    s16 bus_num;                  /* 表示是SPI主机控制器的编号。由平台代码决定 */
    u16 num_chipselect;           /* 控制器支持的片选数量，即能支持多少个spi设备 */
    u16 dma_alignment;            /* dma对齐 */
    u16 mode_bits;                /* 模式位 */
    u16 flags;                    /* 传输类型标志 */
    spinlock_t  bus_lock_spinlock;          /* spi总线自旋锁 */
    struct mutex    bus_lock_mutex;         /* spi总线互斥锁 */
    bool    bus_lock_flag;                  /* 上锁标志 */
    int (*setup)(structspi_device *spi);    /* 针对设备设置SPI的工作时钟及数据传输模式等。在spi_add_device函数中调用 */
    int (*transfer)(structspi_device *spi,
    struct spi_message *mesg);    /* 实现数据的双向传输，可能会睡眠 */
    void (*cleanup)(structspi_device *spi); /* 注销时调用 */
};

1.4 Spi bus
    Spi总线对应的总线类型为spi_bus_type，在内核的drivers/spi/spi.c中定义

struct bus_type spi_bus_type = {
    .name        = "spi",
    .dev_attrs    = spi_dev_attrs,
    .match        = spi_match_device,
    .uevent        = spi_uevent,
    .pm        = &spi_pm,
};

    对应的匹配规则是（高版本中的匹配规则会稍有变化，引入了id_table，可以匹配多个spi设备名称）：

static int spi_match_device(struct device *dev, struct device_driver *drv)
{
    const struct spi_device    *spi = to_spi_device(dev);
    const struct spi_driver    *sdrv = to_spi_driver(drv);

    /* Attempt an OF style match */
    if (of_driver_match_device(dev, drv))
        return 1;

    if (sdrv->id_table)
        return !!spi_match_id(sdrv->id_table, spi);

    return strcmp(spi->modalias, drv->name) == 0;
}

2. SPI设备驱动
2.1 spi_device
    下面该讲到spi_device的构建与注册了。spi_device对应的含义是挂接在spi总线上的一个设备，所以描述它的时候应该明确它自身的设备特性、传输要求、及挂接在哪个总线上。

static struct spi_board_info ok6410_spi_info[] __initdata = {
    {   .modalias = "mcp2515",
        .platform_data = &mcp251x_info,
        .controller_data = &s3c64xx_spi1_csinfo,
        .irq = IRQ_EINT(16),
        .max_speed_hz = 10*1000*1000,    /* 最大的spi时钟频率 */
        .bus_num = 1,                    /* 设备连接在spi控制器1上 */
        .chip_select = 0,                /* 片选线号，在S5PC100的控制器驱动中没有使用它作为片选的依据，而是选择了下文controller_data里的方法 */
        .mode = SPI_MODE_0,              /* CPOL=0, CPHA=0 此处选择具体数据传输模式 */
    },
};

static struct s3c64xx_spi_csinfo s3c64xx_spi1_csinfo = {
      .fb_delay = 0x3,
      .line = S3C64XX_GPC(7),
      .set_level = cs_set_level,
};

static void  cs_set_level(unsigned line_id, int lvl) {    /*  spi控制器会用这个方法设置cs*/
    gpio_direction_output(line_id, lvl);
};

    spi_register_board_info(ok6410_spi_info,ARRAY_SIZE(ok6410_spi_info)) 这个代码会把spi_board_info注册要链表board_list上。
    事实上上文提到的spi_master的注册会在spi_register_board_info之后，spi_master注册的过程中会扫描board_list并调用spi_match_master_to_boardinfo(master, &bi->board_info)，找到挂接在它上面的spi设备，然后创建并注册spi_device。

static void spi_match_master_to_boardinfo(struct spi_master *master,
                struct spi_board_info *bi)
{
    struct spi_device *dev;

    if (master->bus_num != bi->bus_num)      /* 对应spi_master的设备 */
        return;

    dev = spi_new_device(master, bi);        /*创建并注册了spi_device  */
    if (!dev)
        dev_err(master->dev.parent, "can't create new device for %s\n",
            bi->modalias);
}

2.2 spi_driver
    本文以linux内核中的/driver/net/can/mcp251x.c驱动为参考

static struct spi_driver mcp251x_can_driver = {    /*spi_driver的构建  */
    .driver = {
        .name = DEVICE_NAME,
        .bus = &spi_bus_type,
        .owner = THIS_MODULE,
    },

    .id_table = mcp251x_id_table,
    .probe = mcp251x_can_probe,
    .remove = __devexit_p(mcp251x_can_remove),
    .suspend = mcp251x_can_suspend,
    .resume = mcp251x_can_resume,
};

    spi_register_driver(&mcp251x_can_driver);    /* 注册该驱动 */
    在有匹配的spi device时，会调用mcp251x_can_probe

static int __devinit mcp251x_can_probe(struct spi_device *spi)
{
    ...
}

    根据传入的spi_device参数，可以找到对应的spi_master。接下来就可以利用spi子系统为我们完成数据交互了。可以参看mcp251x_spi_trans(struct spi_device *spi, int len)函数。要完成传输，先理解下面几个结构的含义：（这两个结构的定义及详细注释参见include/linux/spi/spi.h）
    spi_message：描述一次完整的传输，即cs信号从高-->底-->高的传输
    spi_transfer：多个spi_transfer够成一个spi_message

static int mcp251x_spi_trans(struct spi_device *spi, int len)
{
    struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
    struct spi_transfer t = {        /* 初始化其transfers链表 */
        .tx_buf = priv->spi_tx_buf,
        .rx_buf = priv->spi_rx_buf,
        .len = len,
        .cs_change = 0,
    };
    struct spi_message m;            /* 定义了一个spi_message */
    int ret;

    spi_message_init(&m);            /* 添加到spi_message */

    if (mcp251x_enable_dma) {
        t.tx_dma = priv->spi_tx_dma;
        t.rx_dma = priv->spi_rx_dma;
        m.is_dma_mapped = 1;
    }

    spi_message_add_tail(&t, &m);

    ret = spi_sync(spi, &m);         /*  调用spi_master发送spi_message*/
    if (ret)
        dev_err(&spi->dev, "spi transfer failed: ret = %d\n", ret);
    return ret;
}

    spi_sync为同步方式发送，还可以用spi_async异步方式，那样的话，需要设置回调完成函数。
    另外你也可以选择一些封装好的更容易使用的函数，这些函数可以在include/linux/spi/spi.h文件中找到，如：extern int spi_write_then_read(struct spi_device*spi, const u8 *txbuf, unsigned n_tx, u8 *rxbuf, unsigned n_rx);