Linux SPI 子系统详解

MODE 0 (CPOL=0, CPHA=0):
SCLK  ─┐ ┌─┐ ┌─┐ ┌─
        └─┘ └─┘ └─┘
MOSI  ═══X═══X═══X══  在时钟上升沿被 Slave 采样
              ↑采样

┌──────────────────────────────────────────┐
│              用户空间                     │
│  spidev(/dev/spidevX.Y) 或 内核驱动      │
└──────────────────┬───────────────────────┘
                   │
┌──────────────────▼───────────────────────┐
│           SPI 核心层（spi.c）             │
│  spi_register_driver / spi_sync          │
│  设备-驱动匹配（of_match / id_table）     │
└──────────────────┬───────────────────────┘
                   │
┌──────────────────▼───────────────────────┐
│         SPI 控制器驱动（spi-imx.c）       │
│  struct spi_master / spi_controller      │
│  DMA / PIO 传输实现                       │
└──────────────────┬───────────────────────┘
                   │ 寄存器操作
┌──────────────────▼───────────────────────┐
│            硬件 SPI 控制器               │
│  iMX6ULL ECSPI1~4                        │
└──────────────────────────────────────────┘

struct spi_device {
    struct device      dev;
    struct spi_master *master;      /* 所属控制器 */
    u32                max_speed_hz; /* 最大时钟频率 */
    u8                 chip_select;  /* CS 编号 */
    u8                 bits_per_word;/* 字长，通常 8 */
    u16                mode;         /* SPI_MODE_0~3 等 */
    int                irq;          /* 中断号（DTS 配置后自动填充）*/
    /* ... */
};

struct spi_transfer {
    const void  *tx_buf;    /* 发送缓冲区（NULL = 发全0）*/
    void        *rx_buf;    /* 接收缓冲区（NULL = 丢弃）*/
    unsigned     len;       /* 字节数 */
    u32          speed_hz;  /* 本次传输的时钟（0=用设备默认）*/
    u8           bits_per_word;
    u16          delay_usecs; /* 传输后延迟 */
    unsigned     cs_change:1; /* 传输后是否切换 CS */
    struct list_head transfer_list;
};

struct spi_message {
    struct list_head transfers;  /* spi_transfer 链表 */
    struct spi_device *spi;
    int status;                  /* 完成后的错误码 */
    /* ... */
};

/* 使用示例 */
struct spi_message  msg;
struct spi_transfer xfer[2];

spi_message_init(&msg);

xfer[0].tx_buf = cmd_buf;
xfer[0].len    = 1;
spi_message_add_tail(&xfer[0], &msg);

xfer[1].rx_buf = rx_buf;
xfer[1].len    = 14;
spi_message_add_tail(&xfer[1], &msg);

ret = spi_sync(spi, &msg);  /* 同步等待完成 */

struct spi_driver {
    const struct spi_device_id *id_table;
    int  (*probe)(struct spi_device *spi);
    int  (*remove)(struct spi_device *spi);
    struct device_driver driver;
};

/* 只写 N 字节 */
int spi_write(struct spi_device *spi, const void *buf, size_t len);

/* 只读 N 字节 */
int spi_read(struct spi_device *spi, void *buf, size_t len);

/*
 * 先写 n_tx 字节，再读 n_rx 字节，同一 CS 事务内完成。
 * 最适合"写寄存器地址 + 读数据"的读操作模式。
 */
int spi_write_then_read(struct spi_device *spi,
                        const void *txbuf, unsigned n_tx,
                        void       *rxbuf, unsigned n_rx);

int spi_sync(struct spi_device *spi, struct spi_message *message);
int spi_async(struct spi_device *spi, struct spi_message *message);
/* spi_async 不阻塞，完成后调用 message->complete 回调 */

spi->bits_per_word = 8;
spi->mode          = SPI_MODE_0;
ret = spi_setup(spi);   /* 将配置写入控制器硬件 */

/* probe 中：把 iio_dev 绑定到 spi_device */
spi_set_drvdata(spi, indio_dev);

/* remove 中：取回 */
struct iio_dev *indio_dev = spi_get_drvdata(spi);

/* 1. 定义私有数据 */
struct mydev_data {
    struct spi_device *spi;
    struct mutex       lock;
};

/* 2. 寄存器读写 */
static int mydev_read(struct spi_device *spi, u8 reg, u8 *val)
{
    u8 cmd = reg | BIT(7);  /* 读标志（视芯片协议而定）*/
    return spi_write_then_read(spi, &cmd, 1, val, 1);
}

static int mydev_write(struct spi_device *spi, u8 reg, u8 val)
{
    u8 buf[2] = { reg, val };
    return spi_write(spi, buf, 2);
}

/* 3. probe */
static int mydev_probe(struct spi_device *spi)
{
    struct mydev_data *data;
    int ret;

    /* 配置 SPI 参数 */
    spi->bits_per_word = 8;
    spi->mode          = SPI_MODE_0;
    ret = spi_setup(spi);
    if (ret) return ret;

    data = devm_kzalloc(&spi->dev, sizeof(*data), GFP_KERNEL);
    if (!data) return -ENOMEM;

    data->spi = spi;
    mutex_init(&data->lock);
    spi_set_drvdata(spi, data);

    /* 硬件初始化 ... */
    return 0;
}

static int mydev_remove(struct spi_device *spi)
{
    /* devm_ 资源自动释放，这里只需关闭硬件 */
    return 0;
}

/* 4. 驱动注册 */
static const struct of_device_id mydev_of_match[] = {
    { .compatible = "vendor,mydev" },
    { }
};
MODULE_DEVICE_TABLE(of, mydev_of_match);

static struct spi_driver mydev_driver = {
    .driver = {
        .name           = "mydev",
        .of_match_table = mydev_of_match,
    },
    .probe  = mydev_probe,
    .remove = mydev_remove,
};
module_spi_driver(mydev_driver);

/* iomuxc 中定义引脚复用 */
&iomuxc {
    pinctrl_ecspi3: ecspi3grp {
        fsl,pins = <
            MX6UL_PAD_UART2_TX_DATA__GPIO1_IO20   0x10b0  /* CS (GPIO) */
            MX6UL_PAD_UART2_RX_DATA__ECSPI3_SCLK  0x10b1
            MX6UL_PAD_UART2_CTS_B__ECSPI3_MOSI    0x10b1
            MX6UL_PAD_UART2_RTS_B__ECSPI3_MISO    0x10b1
        >;
    };
};

/* ECSPI3 控制器节点 */
&ecspi3 {
    fsl,spi-num-chipselects = <1>;
    cs-gpios = <&gpio1 20 GPIO_ACTIVE_LOW>;  /* 软件 GPIO 片选 */
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_ecspi3>;
    status = "okay";

    mydev@0 {
        compatible = "vendor,mydev";
        reg = <0>;                           /* CS 编号 */
        spi-max-frequency = <8000000>;       /* 8 MHz */
    };
};

mydev@0 {
    compatible = "vendor,mydev";
    reg = <0>;
    spi-max-frequency = <8000000>;
    interrupt-parent = <&gpio4>;
    interrupts = <16 IRQ_TYPE_EDGE_RISING>; /* INT 引脚 → GPIO4_IO16 */
};

      CS ──┐                              ┌──
           └──────────────────────────────┘
     SCLK    ┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐ ┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐
     MOSI  ══╪══ reg|0x80 ══╪══╪══ dummy ═╪═
     MISO  ══╪══  (忽略)   ══╪══╪══ data  ═╪═
              ←── n_tx=1B ──→  ←── n_rx=NB ──→
              └──────────── 同一 CS 事务 ───────┘