LInux驱动开发笔记(十)SPI子系统及其驱动


前言

  前章我们已经学习了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);
}
  1. 参数:
    • t:指向要添加的SPI传输结构体的指针。
    • m:指向SPI消息结构体的指针。

3.2.4 spi_transfer_init( )

//初始化SPI传输结构体
void spi_transfer_init(struct spi_transfer *t);
  1. 参数:
    • 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;
}
  1. 参数:
    • spi:指向SPI设备的指针。
    • message:包含要传输的数据的SPI消息结构体。
      返回值:成功时返回0,失败时返回负错误代码。
//进行异步SPI数据传输
int spi_async(struct spi_device *spi, struct spi_message *message)
{
    ...
    ret = __spi_async(spi, message);
    ...
}
  1. 参数:
    • spi:指向SPI设备的指针。
    • message:包含要传输的数据的SPI消息结构体。
  2. 返回值:
    • 0:成功
    • 负数:错误码

3.2.6 spi_register_driver( )

//注册一个SPI设备驱动程序
int spi_register_driver(struct spi_driver *sdrv);
  1. 参数:
    • sdrv:指向要注册的SPI设备驱动程序的指针。
  2. 返回值:
    • 0:成功
    • 负数:错误码

3.2.7 spi_unregister_driver( )

//从系统中注销一个SPI设备驱动程序
void spi_unregister_driver(struct spi_driver *sdrv);
  1. 参数:
  2. 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 操作。
数据传输流程
流程示例

  1. 创建一个 spi_message 结构体,并添加多个 spi_transfer 到这个 spi_message 中。
  2. 将 spi_message 提交给 SPI 子系统。
  3. SPI 子系统找到合适的 spi_controller,并调用其transfer 函数来处理 spi_message。
  4. spi_controller 按顺序处理 spi_message 中的每个spi_transfer,并进行实际的数据传输。
  5. 当所有 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驱动和字符设备,这里着重讲一下这部分的设计思路:

  1. 本实验采用设备树匹配的方式进行匹配,故而需要设置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),
    },
};
  1. 出入口函数的编写,这里我们采用字符设备的写法,需要编写module_init和module_exti,并且在其中分别使用spi_register_driver( )函数和spi_unregister_driver( )函数进行spi总线的注册和注销。
  2. 字符设备相关内容的编写,即在module_init进行alloc_chrdev_region(内存申请)、cdev_init(字符设备的申请),cdev_add(字符设备的添加)、class_create(类的创建)、device_create(设备的创建);在module_exti中进行device_destroy(设备删除)、class_destroy(清除类)、cdev_del(清除设备号)、unregister_chrdev_region(注销字符设备);及各种资源的释放。
  3. probe函数的编写,这部分主要是利用of_get_named_gpio( )进行申请gpio、gpio_request( )和gpio_direction_output( )进行函数控制D/C引脚、以及通过spi_setup( )初始化spi。
  4. remove函数的编写,这部分与probe函数对应即可,利用gpio_free( )释放gpio资源。
  5. 编写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;
}

免责声明:本内容部分参考野火科技及其他相关公开资料,若有侵权或者勘误请联系作者。

  • 30
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值