LInux驱动开发笔记（十）SPI子系统及其驱动

文章目录

前言
一、SPI驱动框架
二、总线驱动
- 2.1 SPI总线的运行机制
- 2.2 重要数据结构
- - 2.2.1 spi_controller
  - 2.2.2 spi_driver
  - 2.2.3 spi_device
  - 2.2.4 spi_transfer
  - 2.2.5 spi_message
三、设备驱动的编写
- 3.1 设备树的修改
- 3.2 相关API函数
- - 3.2.1 spi_setup( )
  - 3.2.2 spi_message_init( )
  - 3.2.3 spi_message_add_tail( )
  - 3.2.4 spi_transfer_init( )
  - 3.2.5 spi_sync( )和spi_async( )
  - 3.2.6 spi_register_driver( )
  - 3.2.7 spi_unregister_driver( )
- 3.3 SPI驱动的信息传递
- 3.4 SPI驱动的设计框架
- 3.5 具体功能的实现
- - 3.5.1 _init函数和_exit函数
  - 3.5.2 .probe函数
  - 3.5.3 .remove函数
  - 3.5.4 数据传输函数

前言

前章我们已经学习了iic子系统驱动，这部分我们继续spi子系统驱动的学习。

一、SPI驱动框架

SPI同样可分为spi总线驱动和spi设备驱动，我们也只需要进行spi设备驱动的编写。SPI设备驱动涉及到SPI设备驱动、SPI核心层、SPI主机驱动，具体功能如下：
SPI核心层：SPI核心层是SPI子系统的中间层，提供了一个通用的接口以便设备驱动可以与SPI主机驱动交互。核心层负责管理SPI总线上的所有设备，并提供基本的数据传输功能。提供SPI控制器驱动和设备驱动的注册方法、注销方法，SPI Core提供操作接口函数，允许一个spi master，spi driver 和spi device初始化。
SPI主机驱动：SPI主机驱动与具体的硬件SPI控制器直接交互，负责实际的数据传输和控制操作，它实现了SPI核心层定义的接口，并提供对硬件的抽象。其主要包含SPI硬件体系结构中适配器(spi控制器)的控制，实现spi总线的硬件访问操作。
SPI设备驱动：SPI设备驱动是针对特定SPI从设备的驱动程序，负责与特定的硬件设备交互，主要职责包括设备的初始化、配置以及数据传输。设备驱动通常会调用SPI核心层提供的接口来完成这些任务。
在这里插入图片描述

二、总线驱动

2.1 SPI总线的运行机制

linux系统在开机的时候就会自动执行spi_init函数，进行spi总线注册。当总线注册成功之后，会在sys/bus下面生成一个spi总线，然后在系统中新增一个设备类，sys/class/目录下会可以找到spi_master类。

//注册SPI总线
static int __init spi_init(void)
{
    int     status;
    ...
    status = bus_register(&spi_bus_type);
    ...
    status = class_register(&spi_master_class);
    ...
}

struct bus_type spi_bus_type = {
    .name           = "spi",
    .dev_groups     = spi_dev_groups,
    .match          = spi_match_device,
    .uevent         = spi_uevent,
};


//匹配规则，同IIC子系统，常用设备树匹配的方法
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;

    /* Then try ACPI */
    if (acpi_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;
}

使用的rk3568芯片有4个spi控制器，对应的设备树存在4个节点，利用平台总线module_platform_driver(rockchip_spi_driver)，间接调用platform_driver_register 和 platform_driver_unregister，实现平台驱动函数的注册和注销。
当匹配到对应驱动时时，调用rockchip_spi_probe函数，进行初始化，获取设备树节点信息，初始化spi时钟、dma、中断等。

2.2 重要数据结构

2.2.1 spi_controller

spi_controller 结构体用于表示一个SPI控制器，它包含了控制器的属性和方法。在Linux中，该结构体定义在 <linux/spi/spi.h> 头文件中。

struct spi_controller {
    struct device   		 dev;
    ...
    struct list_head 		 list;
    s16                      bus_num;
    u16                      num_chipselect;
    ...
    struct spi_message       *cur_msg;
    ...
    int     (*setup)(struct spi_device *spi);
    int     (*transfer)(struct spi_device *spi,struct spi_message *mesg);
    void    (*cleanup)(struct spi_device *spi);
    struct kthread_worker    kworker;
    struct task_struct       *kworker_task;
    struct kthread_work      pump_messages;
    struct list_head         queue;
    struct spi_message       *cur_msg;
    ...
    int (*transfer_one)(struct spi_controller *ctlr, struct spi_device *spi,struct spi_transfer *transfer);
    int (*prepare_transfer_hardware)(struct spi_controller *ctlr);
    int (*transfer_one_message)(struct spi_controller *ctlr,struct spi_message *mesg);
    void (*set_cs)(struct spi_device *spi, bool enable);
    ...
    int                     *cs_gpios;
}

成员说明：

dev：该字段表示该SPI控制器对应的设备对象，继承自Linux内核中的设备模型。
list：这是一个链表节点，用于将SPI控制器连接到全局的SPI控制器链表中。
bus_num： spi控制器编号。
num_chipselect：支持的芯片选择线数量。
cur_msg：指向当前正在处理的SPI消息的指针。
setup：函数指针，用于执行SPI设备的初始化和配置操作。
transfer：指向数据传输函数的指针，用于把数据加入控制器的消息队列中,实现SPI数据的传输。
cleanup：函数指针，用于执行SPI设备的清理和释放操作。
kworker：内核线程工人，spi可以使用异步传输方式发送数据。
pump_messages：具体传输工作。
queue：所有等待传输的消息队列挂在该链表下。
transfer_one_message：发送一个spi消息，类似IIC适配器里的algo->master_xfer，产生spi通信时序。
cs_gpios：记录spi上具体的片选信号。

2.2.2 spi_driver

spi_driver 结构体用于表示一个SPI设备的驱动程序，在Linux中，该结构体定义在 <linux/spi/spi.h> 头文件中。

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

成员说明：

id_table：匹配表
driver：设备驱动的基本信息，如驱动名字、所属的模块等。
probe：指向探测函数的指针，用于初始化并注册SPI设备。
shutdown：指向关闭函数的函数指针，用于关闭SPI设备。当系统关闭或卸载设备驱动时，会调用该函数。
remove：指向移除函数的指针，用于卸载SPI设备。

2.2.3 spi_device

spi_device 结构体用于表示一个具体的SPI设备，它与硬件设备相对应。在Linux中，该结构体定义在 <linux/spi/spi.h> 头文件中。

struct spi_device {
    struct device           dev;
    struct spi_controller   *controller;
    struct spi_controller   *master;        /* compatibility layer */
    u32                     max_speed_hz;
    u8                      chip_select;
    u8                      bits_per_word;
    u16                     mode;
   #define  SPI_CPHA        0x01                    /* clock phase */
   #define  SPI_CPOL        0x02                    /* clock polarity */
   #define  SPI_MODE_0      (0|0)                   /* (original MicroWire) */
   #define  SPI_MODE_1      (0|SPI_CPHA)
   #define  SPI_MODE_2      (SPI_CPOL|0)
   #define  SPI_MODE_3      (SPI_CPOL|SPI_CPHA)
   #define  SPI_CS_HIGH     0x04                    /* chipselect active high? */
   #define  SPI_LSB_FIRST   0x08                    /* per-word bits-on-wire */
   #define  SPI_3WIRE       0x10                    /* SI/SO signals shared */
   #define  SPI_LOOP        0x20                    /* loopback mode */
   #define  SPI_NO_CS       0x40                    /* 1 dev/bus, no chipselect */
   #define  SPI_READY       0x80                    /* slave pulls low to pause */
   #define  SPI_TX_DUAL     0x100                   /* transmit with 2 wires */
   #define  SPI_TX_QUAD     0x200                   /* transmit with 4 wires */
   #define  SPI_RX_DUAL     0x400                   /* receive with 2 wires */
   #define  SPI_RX_QUAD     0x800                   /* receive with 4 wires */
    int                     irq;
    void                    *controller_state;
    void                    *controller_data;
    char                    modalias[SPI_NAME_SIZE];
    int                     cs_gpio;        /* chip select gpio */

    /* the statistics */
    struct spi_statistics   statistics;
};

成员说明：

controller：指向控制器的指针，表示该设备所属的SPI控制器。
master：指向主机的指针，表示该设备所属的SPI主机。
chip_select：芯片选择线的编号。
max_speed_hz：设备支持的最大时钟频率。
mode：设备的SPI模式（CPOL、CPHA）。
bits_per_word：每个数据字的位数。
mode： SPI工作模式，工作模式如以上代码中的宏定义。
irq：如果使用了中断，它用于指定中断号

2.2.4 spi_transfer

spi_transfer 结构体用于表示SPI数据传输的信息，包括要发送和接收的数据、数据长度等。在Linux中，该结构体定义在 <linux/spi/spi.h> 头文件中。

struct spi_transfer {
    const void      *tx_buf;
    void            *rx_buf;
    unsigned        len;

    dma_addr_t      tx_dma;
    dma_addr_t      rx_dma;
    struct sg_table tx_sg;
    struct sg_table rx_sg;

    unsigned        cs_change:1;
    unsigned        tx_nbits:3;
    unsigned        rx_nbits:3;
#define     SPI_NBITS_SINGLE        0x01 /* 1bit transfer */
#define     SPI_NBITS_DUAL          0x02 /* 2bits transfer */
#define     SPI_NBITS_QUAD          0x04 /* 4bits transfer */
    u8              bits_per_word;
    u16             delay_usecs;
    u32             speed_hz;

    struct list_head transfer_list;
};

成员说明：

tx_buf：指向要发送数据的缓冲区。
rx_buf：指向接收数据的缓冲区。
len：数据长度。
tx_dma、rx_dma：如果使用了DAM，用于指定tx或rx DMA地址。
speed_hz：数据传输的时钟频率。
bits_per_word：每个数据字的位数。
delay_usecs：传输完成后的延迟时间。

2.2.5 spi_message

spi_message 结构体用于表示一个SPI数据传输的完整消息，包含了一个或多个 spi_transfer 结构体。在Linux中，该结构体定义在 <linux/spi/spi.h> 头文件中。

struct spi_message {
      ...
    struct list_head        transfers;
    struct spi_device       *spi;
    unsigned                is_dma_mapped:1;
    struct list_head        queue;
    void 					*state;
      ...
};

成员说明：

spi：指向SPI设备的指针。
is_dma_mapped：表示数据是否已经进行DMA映射。
transfers：一个链表，包含了多个 spi_transfer 结构体，表示要进行的多个数据传输。
queue：用于在 SPI 控制器内部排队等待处理的消息队列，通常由 SPI 主控制器驱动程序使用。
state：当前驱动程序的状态指针，用于在传输过程中保存和恢复状态。

三、设备驱动的编写

3.1 设备树的修改

相关瑞芯微官方给出的ic3控制器的设备树代码这里就不再赘述了，如下所示：

spi3 {
    spi3m1_pins: spi3m1-pins {
        rockchip,pins =
            /* spi3_clkm1 */
            <4 RK_PC2 2 &pcfg_pull_none>,
            /* spi3_misom1 */
            <4 RK_PC5 2 &pcfg_pull_none>,
            /* spi3_mosim1 */
            <4 RK_PC3 2 &pcfg_pull_none>;
    };

    spi3m1_cs0: spi3m1-cs0 {
        rockchip,pins =
            /* spi3_cs0m1 */
            <4 RK_PC6 2 &pcfg_pull_none>;
    };

    spi3m1_cs1: spi3m1-cs1 {
        rockchip,pins =
            /* spi3_cs1m1 */
            <4 RK_PD1 2 &pcfg_pull_none>;
    };
};

spi3-hs {
            spi3m1_pins_hs: spi3m1-pins {
                    rockchip,pins =
                            /* spi3_clkm1 */
                            <4 RK_PC2 2 &pcfg_pull_up_drv_level_1>,
                            /* spi3_misom1 */
                            <4 RK_PC5 2 &pcfg_pull_up_drv_level_1>,
                            /* spi3_mosim1 */
                            <4 RK_PC3 2 &pcfg_pull_up_drv_level_1>;
            };

            spi3m1_cs0_hs: spi3m1-cs0 {
                    rockchip,pins =
                            /* spi3_cs0m1 */
                            <4 RK_PC6 2 &pcfg_pull_up_drv_level_1>;
            };

            spi3m1_cs1_hs: spi3m1-cs1 {
                    rockchip,pins =
                            /* spi3_cs1m1 */
                            <4 RK_PD1 2 &pcfg_pull_up_drv_level_1>;
            };
    };

以下是我们需要修改的部分：

&spi3{
    status = "okay";
    
    //定义引脚控制的状态名称，用于选择引脚配置
    pinctrl-names = "default", "high_speed";
    
    //引脚控制的默认状态，引用了 spi3m1_cs0 和 spi3m1_pins 引脚配置
    pinctrl-0 = <&spi3m1_cs0 &spi3m1_pins>;
    
    //高速模式下的引脚控制状态，引用了 spi3m1_cs0 和 spi3m1_pins_hs 引脚配置
    pinctrl-1 = <&spi3m1_cs0 &spi3m1_pins_hs>;
    
    //定义芯片选择（CS）引脚的GPIO配置。这里使用了GPIO4的PC6引脚，并且是低电平有效（GPIO_ACTIVE_LOW）
    cs-gpios = <&gpio4 RK_PC6 GPIO_ACTIVE_LOW>;

    spi_oled@0 {
        status = "okay";
        compatible = "company,myspi";
        
        //SPI设备的地址，即芯片选择（CS）编号,这里是CS0
        reg = <0>;
        
        //SPI设备的最大时钟频率，单位为赫兹（Hz）                        
        spi-max-frequency = <24000000>;   
        
        //定义一个数据/命令控制引脚，使用GPIO3的PA7引脚，并且是高电平有效（GPIO_ACTIVE_HIGH）
        dc_control_pin = <&gpio3 RK_PA7 GPIO_ACTIVE_HIGH>;
        
        //定义引脚控制的状态名称，用于选择引脚配置
        pinctrl-names = "default";
        
        //引脚控制的默认状态，引用了 spi_oled_pin 引脚配置
        pinctrl-0 = <&myspi>;
    };
};

&pinctrl {
    myspi {
        myspi: myspi {
            rockchip,pins = <3 RK_PA7 RK_FUNC_GPIO &pcfg_pull_none>;
        };
    };
};

3.2 相关API函数

3.2.1 spi_setup( )

函数设置spi设备的片选信号、传输单位、最大传输速率等，函数中调用spi控制器的成员controller->setup()，也就是master->setup,在前面的函数rockchip_spi_probe()中初始化了“ctlr->setup = rockchip_spi_setup;”。

int spi_setup(struct spi_device *spi)

参数：
- spi spi_device spi设备结构体
返回值：
- 成功： 0
- 失败：其他任何值都为错误码

3.2.2 spi_message_init( )

//初始化spi_message
static inline void spi_message_init(struct spi_message *m)
{
    memset(m, 0, sizeof *m);
    spi_message_init_no_memset(m);
}

参数：
- m：spi_message 结构体指针，spi_message结构体定义和介绍可在前面关键数据结构中找到。
返回值：无。

3.2.3 spi_message_add_tail( )

这个函数很简单就是将将spi_transfer结构体添加到spi_message队列的末尾。

//
static inline void spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
{
    list_add_tail(&t->transfer_list, &m->transfers);
}

参数：
- t：指向要添加的SPI传输结构体的指针。
- m：指向SPI消息结构体的指针。

3.2.4 spi_transfer_init( )

//初始化SPI传输结构体
void spi_transfer_init(struct spi_transfer *t);

参数：
- t：指向要添加的SPI传输结构体的指针。

3.2.5 spi_sync( )和spi_async( )

这两个函数都用于阻塞当前线程进行数据传输，spi_sync()内部调用__spi_sync()/__spi_async函数，mutex_lock()和mutex_unlock()为互斥锁的加锁和解锁，互斥锁这部分内容在之前应用层TCP/UDP协议中提及到过。

//进行同步SPI数据传输
int spi_sync(struct spi_device *spi, struct spi_message *message)
{
    int ret;
	//上锁
    mutex_lock(&spi->controller->bus_lock_mutex);
    //
    ret = __spi_sync(spi, message);
    //解锁
    mutex_unlock(&spi->controller->bus_lock_mutex);

    return ret;
}

参数：
- spi：指向SPI设备的指针。
- message：包含要传输的数据的SPI消息结构体。
  返回值：成功时返回0，失败时返回负错误代码。

//进行异步SPI数据传输
int spi_async(struct spi_device *spi, struct spi_message *message)
{
    ...
    ret = __spi_async(spi, message);
    ...
}

参数：
- spi：指向SPI设备的指针。
- message：包含要传输的数据的SPI消息结构体。
返回值：
- 0：成功
- 负数：错误码

3.2.6 spi_register_driver( )

//注册一个SPI设备驱动程序
int spi_register_driver(struct spi_driver *sdrv);

参数：
- sdrv：指向要注册的SPI设备驱动程序的指针。
返回值：
- 0：成功
- 负数：错误码

3.2.7 spi_unregister_driver( )

//从系统中注销一个SPI设备驱动程序
void spi_unregister_driver(struct spi_driver *sdrv);

参数：
sdrv：指向要注销的SPI设备驱动程序的指针

3.3 SPI驱动的信息传递

spi_message通过成员变量queue将一系列的spi_message串联起来，第一个spi_message挂在spi_controller结构体的queue下面。除此之外， spi_message中的transfers_list成员变量也可以在不同的spi_transfer之间相互串联。
在这里插入图片描述
结构体之间的关系
spi_transfer 和 spi_message：一个 spi_message 结构体包含多个 spi_transfer 结构体，通过 transfers_list将它们串联起来。这表示一个 SPI 事务中可以包含多个数据传输操作。
spi_message 和 spi_controller：一个 spi_message 通过 SPI 控制器（spi_controller）进行处理。spi_controller 的 transfer 函数会接收一个 spi_message，并按照 spi_message 中定义的顺序执行所有 spi_transfer 操作。
数据传输流程
流程示例

创建一个 spi_message 结构体，并添加多个 spi_transfer 到这个 spi_message 中。
将 spi_message 提交给 SPI 子系统。
SPI 子系统找到合适的 spi_controller，并调用其transfer 函数来处理 spi_message。
spi_controller 按顺序处理 spi_message 中的每个spi_transfer，并进行实际的数据传输。
当所有 spi_transfer 完成后，调用 spi_message 的complete 回调函数（如果有的话）。
数据结构体切换的问题
在 SPI 子系统中，通过 spi_sync/spi_async函数进行消息传输时，每次调用 spi_sync/spi_async都会处理一个完整的 spi_message 结构体，包含多个 spi_transfer 结构体。这意味着如果你需要在传输过程中切换不同的 spi_message传输操作，需要通过多个spi_sync/spi_async来实现，而不能像 spi_transfer 那样提前多次利用spi_message_add_tail来制定顺序，然后使用spi_sync/spi_async统一进行数据输出。

//示例
static int spi_example_transfer(struct spi_device *spi)
{
    int ret;

    // 第一个 spi_message
    struct spi_message msg1;
    u8 tx_buf1[] = {0x01, 0x02, 0x03, 0x04};
    struct spi_transfer tx_transfer1 = {
        .tx_buf = tx_buf1,
        .rx_buf = NULL,
        .len = sizeof(tx_buf1),
        .cs_change = 1,    // 在传输完成后改变 CS 线
        .delay_usecs = 10, // 传输完成后延迟 10 微秒
        .speed_hz = spi->max_speed_hz,
        .bits_per_word = 8,
    };

    spi_message_init(&msg1);
    spi_message_add_tail(&tx_transfer1, &msg1);

    // 提交第一个 spi_message
    ret = spi_sync(spi, &msg1);
    if (ret) {
        dev_err(&spi->dev, "SPI transfer 1 failed: %d\n", ret);
        return ret;
    }

    // 第二个 spi_message
    struct spi_message msg2;
    u8 tx_buf2[] = {0x05, 0x06, 0x07, 0x08};
    u8 rx_buf2[4];
    struct spi_transfer tx_transfer2 = {
        .tx_buf = tx_buf2,
        .rx_buf = NULL,
        .len = sizeof(tx_buf2),
        .cs_change = 0,
        .delay_usecs = 0,
        .speed_hz = spi->max_speed_hz,
        .bits_per_word = 8,
    };
    struct spi_transfer rx_transfer2 = {
        .tx_buf = NULL,
        .rx_buf = rx_buf2,
        .len = sizeof(rx_buf2),
        .cs_change = 0,
        .delay_usecs = 0,
        .speed_hz = spi->max_speed_hz,
        .bits_per_word = 8,
    };

    spi_message_init(&msg2);
    spi_message_add_tail(&tx_transfer2, &msg2);
    spi_message_add_tail(&rx_transfer2, &msg2);

    // 提交第二个 spi_message
    ret = spi_sync(spi, &msg2);
    if (ret) {
        dev_err(&spi->dev, "SPI transfer 2 failed: %d\n", ret);
        return ret;
    }

    // 处理接收到的数据
    for (int i = 0; i < sizeof(rx_buf2); i++) {
        pr_info("Received byte %d: %02x\n", i, rx_buf2[i]);
    }

    return 0;
}

3.4 SPI驱动的设计框架

本次实验大致采用SPI驱动和字符设备，这里着重讲一下这部分的设计思路：

本实验采用设备树匹配的方式进行匹配，故而需要设置spi_driver结构体。

//指定ID匹配表
static const struct spi_device_id oled_device_id[] = {
    {"fire,spi_oled", 0},
    {}
};

//指定设备树匹配表
static const struct of_device_id oled_of_match_table[] = {
    {.compatible = "fire,spi_oled"},
    {}
};

//spi总线设备结构体
struct spi_driver oled_driver = {
    .probe = oled_probe,
    .remove = oled_remove,
    .id_table = oled_device_id,
    .driver = {
            .name = "myspi",
            .owner = THIS_MODULE,
            .of_match_table = of_match_ptr(oled_of_match_table),
    },
};

出入口函数的编写，这里我们采用字符设备的写法，需要编写module_init和module_exti，并且在其中分别使用spi_register_driver( )函数和spi_unregister_driver( )函数进行spi总线的注册和注销。
字符设备相关内容的编写，即在module_init进行alloc_chrdev_region(内存申请)、cdev_init(字符设备的申请)，cdev_add(字符设备的添加)、class_create(类的创建)、device_create(设备的创建)；在module_exti中进行device_destroy(设备删除)、class_destroy(清除类)、cdev_del(清除设备号)、unregister_chrdev_region(注销字符设备)；及各种资源的释放。
probe函数的编写，这部分主要是利用of_get_named_gpio( )进行申请gpio、gpio_request( )和gpio_direction_output( )进行函数控制D/C引脚、以及通过spi_setup( )初始化spi。
remove函数的编写，这部分与probe函数对应即可，利用gpio_free( )释放gpio资源。
编写operations结构体相关函数，包括open、write、read、release。

3.5 具体功能的实现

3.5.1 _init函数和_exit函数

static int __init oled_driver_init(void)
{
    int ret = 0;
    printk("\t driver has entered! \n");

    ret = alloc_chrdev_region(&oled_devno, 0, DEV_CNT, DEV_NAME);
    if (ret < 0) {
        printk("\t alloc_chrdev_region err! \n");
        goto alloc_err;
    }

    oled_chr_dev.owner = THIS_MODULE;
    cdev_init(&oled_chr_dev, &oled_chr_dev_fops);

    ret = cdev_add(&oled_chr_dev, oled_devno, DEV_CNT);
    if (ret < 0) {
        printk("\t cdev_add err! \n");
        goto add_err;
    }

    class_oled = class_create(THIS_MODULE, DEV_NAME);
    if (IS_ERR(class_oled)) {
        ret = PTR_ERR(class_oled);
        printk("\t class_create err! \n");
        goto class_err;
    }

    device_oled = device_create(class_oled, NULL, oled_devno, NULL, DEV_NAME);
    if (IS_ERR(device_oled)) {
        ret = PTR_ERR(device_oled);
        printk("\t device_create err! \n");
        goto device_err;
    }

    ret = spi_register_driver(&oled_driver);
    if (ret < 0) {
        printk("\t spi_register_driver err! \n");
        goto spi_err;
    }

    return 0;

spi_err:
    device_destroy(class_oled, oled_devno);
device_err:
    class_destroy(class_oled);
class_err:
    cdev_del(&oled_chr_dev);
add_err:
    unregister_chrdev_region(oled_devno, DEV_CNT);
alloc_err:
    return ret;
}
module_init(oled_driver_init);

static void __exit oled_driver_exit(void)
{
    spi_unregister_driver(&oled_driver);
    device_destroy(class_oled, oled_devno);         //清除设备
    class_destroy(class_oled);                      //清除类
    cdev_del(&oled_chr_dev);                        //清除设备号
    unregister_chrdev_region(oled_devno, DEV_CNT);  //取消注册字符设备
    printk("\t driver has exited! \n");
}
module_exit(oled_driver_exit);

3.5.2 .probe函数

static int oled_probe(struct spi_device *spi_device)
{
    int ret;
    struct device_node *node = spi_device->dev.of_node;
    printk("\t device has matched! \n");

    spi_cs = of_get_named_gpio(node, "dc_control_pin", 0); //进行申请gpio
    printk("\t spi_cs is %d \n", spi_cs);

    ret = gpio_request(spi_cs, "spi_cs");
    if (ret < 0) {
        printk("\t gpio_request err! \n");
        return ret;
    }

    gpio_direction_output(spi_cs, 1);

    /*初始化spi*/
    spi_bus_device = spi_device;
    spi_bus_device->mode = SPI_MODE_0;
    spi_bus_device->max_speed_hz = 2000000;
    ret = spi_setup(spi_bus_device);
    if (ret < 0) {
        printk("\t spi_setup err! \n");
        goto spi_err;
    }

    printk("spibus has init successfully\n");
    printk("max_speed_hz = %d\n", spi_bus_device->max_speed_hz);
    printk("chip_select = %d\n", (int)spi_bus_device->chip_select);
    printk("bits_per_word = %d\n", (int)spi_bus_device->bits_per_word);
    printk("mode = %02X\n", spi_bus_device->mode);
    printk("cs_gpio = %02X\n", spi_bus_device->cs_gpio);
    return 0;

spi_err:
    gpio_free(spi_cs);
    return ret;
}

3.5.3 .remove函数

static int oled_remove(struct spi_device *spi_device)
{
    printk("device has removed!\n");
    gpio_free(spi_cs);
    return 0;
}

3.5.4 数据传输函数

//向 oled 发送一个字节
static int oled_send_one_u8(struct spi_device *spi_device, u8 data)
{
    int error = 0;
    u8 tx_data = data;
    struct spi_message message;   //定义发送的消息
    struct spi_transfer *transfer; //定义传输结构体

    //设置 D/C引脚为高电平
    gpio_direction_output(spi_cs, 1);

    //申请空间
    transfer = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);
    if (!transfer) {
        printk("kzalloc error!\n");
        return -ENOMEM;
    }

    //填充message和transfer结构体
    transfer->tx_buf = &tx_data;
    transfer->len = 1;
    spi_message_init(&message);
    spi_message_add_tail(transfer, &message);
	
	//同步发送 SPI 消息
    error = spi_sync(spi_device, &message);
    kfree(transfer);
    if (error != 0)
    {
        printk("spi_sync error! \n");
        return -1;
    }
    return 0;
}