RK3568驱动指南｜第十六篇 SPI-第188章 mcp2515驱动编写：复位函数

瑞芯微RK3568芯片是一款定位中高端的通用型SOC，采用22nm制程工艺，搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码，支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU，可用于轻量级人工智能应用。RK3568 支持安卓 11 和 linux 系统，主要面向物联网网关、NVR 存储、工控平板、工业检测、工控盒、卡拉 OK、云终端、车载中控等行业。

​
【公众号】迅为电子

【粉丝群】258811263（加群获取驱动文档+例程）

【视频观看】嵌入式学习之Linux驱动（第十六篇 SPI_全新升级）_基于RK3568

【购买链接】迅为RK3568开发板瑞芯微Linux安卓鸿蒙ARM核心板人工智能AI主板

---

1. 第188章 mcp2515驱动编写：复位函数

在上一章中填充了mcp2515字符设备注册相关的内容，有了mcp2515对应的设备节点，而实际上仍旧属于编写通用SPI外设驱动的范畴，如果要编写其他外设的SPI驱动程序，同样要完成上一章编写的驱动内容，而从本章节开始才真正进入到mcp2515特性相关驱动的编写，在本章节将填充mcp2515的复位函数。

188.1 理论分析

MCP2515具有五种模式，分别为配置模式、正常模式、休眠模式、仅监听模式和环回模式，只有在配置模式下，才能对关键寄存器进行初始化和配置，当MCP2515上电或者复位时，器件会自动进入配置模式，而MCP2515提供了一系列的SPI指令，SPI指令表如下图所示：

通过向MCP2515发送上述SPI指令就能实现复位、读、写等操作，复位操作对应的指令格式为11000000，在Linux驱动中可以使用spi_write函数来实现向SPI从设备发送数据，spi_write函数定义在include/linux/spi/spi.h文件中，具体内容如下所示：

static inline int
spi_write(struct spi_device *spi, const void *buf, size_t len)
{
	struct spi_transfer	t = {
			.tx_buf		= buf,
			.len		= len,
		};

	return spi_sync_transfer(spi, &t, 1);
}

该函数首先会对要传输的数据以及传输的数据大小进行封装，然后调用spi_sync_transfer函数进行输入传输，spi_write函数传入的第一个参数为spi_device类型的结构体变量，struct spi_device是Linux内核中用于描述SPI从设备的结构体。它包含了与 SPI 设备相关的各种信息和配置选项，该结构体的具体内容如下所示：

struct spi_device {
    struct device dev; // 通用设备模型的设备结构体
    struct spi_controller *controller; // 指向控制器的指针
    struct spi_controller *master; // 兼容层，指向控制器的指针（与controller相同）
    u32 max_speed_hz; // 设备支持的最大速度（以赫兹为单位）
    u8 chip_select; // 片选编号
    u8 bits_per_word; // 每个字的位数
    u16 mode; // SPI 模式配置（包括时钟相位和极性等）
    int irq; // 中断号
    void *controller_state; // 控制器状态的私有数据
    void *controller_data; // 控制器数据的私有数据
    char modalias[SPI_NAME_SIZE]; // 设备别名
    const char *driver_override; // 驱动程序覆盖
    int cs_gpio; // 片选 GPIO 引脚
    struct spi_statistics statistics; // 统计数据

    /* mode flags */
    #define SPI_CPHA 0x01 // 时钟相位
    #define SPI_CPOL 0x02 // 时钟极性
    #define SPI_MODE_0 (0|0) // 模式0
    #define SPI_MODE_1 (0|SPI_CPHA) // 模式1
    #define SPI_MODE_2 (SPI_CPOL|0) // 模式2
    #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA) // 模式3
    #define SPI_CS_HIGH 0x04 // 片选高电平有效
    #define SPI_LSB_FIRST 0x08 // 最低有效位先传输
    #define SPI_3WIRE 0x10 // 三线模式
    #define SPI_LOOP 0x20 // 环回模式
    #define SPI_NO_CS 0x40 // 无片选信号
    #define SPI_READY 0x80 // 从设备拉低以暂停
    #define SPI_TX_DUAL 0x100 // 双线发送
    #define SPI_TX_QUAD 0x200 // 四线发送
    #define SPI_RX_DUAL 0x400 // 双线接收
    #define SPI_RX_QUAD 0x800 // 四线接收
    #define SPI_CS_WORD 0x1000 // 每个字后切换片选
};

所以在调用spi_write函数之前需要先定义一个struct spi_device类型的用于描述SPI设备的结构体，然后来编写MCP2515的复位函数，编写完成如下所示：

struct spi_device *spi_dev; // SPI设备指针

// MCP2515芯片复位函数
void mcp2515_reset(void){
    int ret;
    char write_buf[] = {0xc0}; // 复位指令0x11000000即0xc0
    ret = spi_write(spi_dev, write_buf, sizeof(write_buf)); // 发送复位命令
    if(ret < 0){
        printk("spi_write is error\n"); // 打印错误信息
    }
}

由于这里只编写了MCP2515的复位函数，无法进行验证，所以本章节并不能进行相应的实验，在下个小节中将会对SPI通信流程进行讲解。

188.2 SPI通信流程

在上个小节中讲解的spi_write函数可以向SPI从设备发送数据，而spi_read函数可以接收从设备发送的数据，spi_read函数具体内容如下所示：

static inline int
spi_read(struct spi_device *spi, void *buf, size_t len)
{
	struct spi_transfer	t = {
			.rx_buf		= buf,
			.len		= len,
		};

	return spi_sync_transfer(spi, &t, 1);
}

跟spi_write函数相同，spi_read函数也会对数据进行封包的操作，将数据buf以及数据大小len封包成spi_transfer类型的结构体，struct spi_transfer是一个描述SPI数据传输的结构体，用于配置一次SPI数据传输的各种参数，该结构体的具体内容如下所示：

struct spi_transfer {
    const void *tx_buf;    // 发送缓冲区
    void *rx_buf;          // 接收缓冲区
    unsigned len;          // 传输数据的长度

    dma_addr_t tx_dma;     // 发送缓冲区的 DMA 地址
    dma_addr_t rx_dma;     // 接收缓冲区的 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 // 1 位传输
    #define SPI_NBITS_DUAL   0x02 // 2 位传输
    #define SPI_NBITS_QUAD   0x04 // 4 位传输

    u8 bits_per_word;     // 每个字的位数
    u16 delay_usecs;      // 传输之间的延迟（微秒）
    u32 speed_hz;         // 传输速度（赫兹）
    u16 word_delay;       // 每个字之间的延迟

    struct list_head transfer_list; // 传输链表，用于将多个传输串联起来
};

而spi_write函数和spi_read函数只差在struct spi_transfer结构体参数的不同，而封装为struct spi_transfer之后还需要再一次进行封装，spi_write函数和spi_read函数最后都会调用 spi_sync_transfer函数，该函数的具体内容如下所示：

static inline int
spi_sync_transfer(struct spi_device *spi, struct spi_transfer *xfers,
	unsigned int num_xfers)
{
	struct spi_message msg;

	// 使用给定的传输初始化 SPI 消息
	spi_message_init_with_transfers(&msg, xfers, num_xfers);

	// 同步方式发送 SPI 消息
	return spi_sync(spi, &msg);
}

这个函数主要用于封装 SPI 同步传输操作，简化了调用过程。在第8行调用了spi_message_init_with_transfers函数进行SPI传输数据的初始化，最后在第11行调用spi_sync函数采用同步的方式发送SPI数据，spi_sync函数的具体内容如下所示：

int spi_sync(struct spi_device *spi, struct spi_message *message)
{
	int ret;

	// 锁定 SPI 控制器的总线锁互斥体
	mutex_lock(&spi->controller->bus_lock_mutex);
	// 执行同步 SPI 传输
	ret = __spi_sync(spi, message);
	// 解锁 SPI 控制器的总线锁互斥体
	mutex_unlock(&spi->controller->bus_lock_mutex);

	return ret;
}

该函数的主要作用是确保SPI数据传输操作在一个互斥锁的保护下进行，以避免并发传输导致的冲突和数据错误。通过调用内部的 __spi_sync 函数来执行实际的数据传输。__spi_sync函数如下所示：

static int __spi_sync(struct spi_device *spi, struct spi_message *message)
{
	// 声明并初始化一个完成变量
	DECLARE_COMPLETION_ONSTACK(done);
	int status;
	struct spi_controller *ctlr = spi->controller;
	unsigned long flags;

	// 验证 SPI 设备和消息
	status = __spi_validate(spi, message);
	if (status != 0)
		return status;

	// 设置消息完成回调和上下文
	message->complete = spi_complete;
	message->context = &done;
	message->spi = spi;

	// 更新统计信息
	SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync);
	SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);

	/* 如果我们不使用旧的传输方法，
	 * 那么我们将在调用上下文中尝试传输以进行特殊处理。
	 * 如果我们能够删除对驱动程序实现的消息队列的支持，这段代码会更简单。
	 */
	if (ctlr->transfer == spi_queued_transfer) {
		// 锁定总线锁旋转锁并保存中断标志
		spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);

		// 记录 SPI 消息提交的跟踪信息
		trace_spi_message_submit(message);

		// 执行队列传输
		status = __spi_queued_transfer(spi, message, false);

		// 解锁总线锁旋转锁并恢复中断标志
		spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
	} else {
		// 异步锁定传输
		status = spi_async_locked(spi, message);
	}

	if (status == 0) {
		/* 如果可以，则在调用上下文中推送消息 */
		if (ctlr->transfer == spi_queued_transfer) {
			// 更新同步立即传输的统计信息
			SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync_immediate);
			SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync_immediate);
			// 推送消息
			__spi_pump_messages(ctlr, false);
		}

		// 等待完成
		wait_for_completion(&done);
		// 获取消息的状态
		status = message->status;
	}
	// 清除消息的上下文
	message->context = NULL;
	return status;
}

该函数的主要作用是在锁定的上下文中同步执行SPI消息传输。它负责初始化传输消息，验证消息和设备的有效性，处理传输，并在完成后返回传输的状态。该函数的重点在__spi_pump_messages推送消息函数，该函数的具体内容如下所示：

static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
{
	unsigned long flags;
	bool was_busy = false;
	int ret;

	/* 锁定消息队列 */
	spin_lock_irqsave(&ctlr->queue_lock, flags);

	/* 确保没有其他消息正在处理 */
	if (ctlr->cur_msg) {
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
		return;
	}

	/* 如果另一个上下文正在空闲设备，则推迟处理 */
	if (ctlr->idling) {
		kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
		return;
	}

	/* 检查队列是否空闲 */
	if (list_empty(&ctlr->queue) || !ctlr->running) {
		if (!ctlr->busy) {
			spin_unlock_irqrestore(&ctlr->queue_lock, flags);
			return;
		}

		/* 只有在线程中执行拆除操作 */
		if (!in_kthread) {
			kthread_queue_work(&ctlr->kworker,
					   &ctlr->pump_messages);
			spin_unlock_irqrestore(&ctlr->queue_lock, flags);
			return;
		}

		ctlr->busy = false;
		ctlr->idling = true;
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);

		kfree(ctlr->dummy_rx);
		ctlr->dummy_rx = NULL;
		kfree(ctlr->dummy_tx);
		ctlr->dummy_tx = NULL;
		if (ctlr->unprepare_transfer_hardware &&
		    ctlr->unprepare_transfer_hardware(ctlr))
			dev_err(&ctlr->dev,
				"failed to unprepare transfer hardware\n");
		if (ctlr->auto_runtime_pm) {
			pm_runtime_mark_last_busy(ctlr->dev.parent);
			pm_runtime_put_autosuspend(ctlr->dev.parent);
		}
		trace_spi_controller_idle(ctlr);

		spin_lock_irqsave(&ctlr->queue_lock, flags);
		ctlr->idling = false;
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
		return;
	}

	/* 从队列中获取第一个消息 */
	ctlr->cur_msg =
		list_first_entry(&ctlr->queue, struct spi_message, queue);

	list_del_init(&ctlr->cur_msg->queue);
	if (ctlr->busy)
		was_busy = true;
	else
		ctlr->busy = true;
	spin_unlock_irqrestore(&ctlr->queue_lock, flags);

	mutex_lock(&ctlr->io_mutex);

	if (!was_busy && ctlr->auto_runtime_pm) {
		ret = pm_runtime_get_sync(ctlr->dev.parent);
		if (ret < 0) {
			pm_runtime_put_noidle(ctlr->dev.parent);
			dev_err(&ctlr->dev, "Failed to power device: %d\n",
				ret);
			mutex_unlock(&ctlr->io_mutex);
			return;
		}
	}

	if (!was_busy)
		trace_spi_controller_busy(ctlr);

	if (!was_busy && ctlr->prepare_transfer_hardware) {
		ret = ctlr->prepare_transfer_hardware(ctlr);
		if (ret) {
			dev_err(&ctlr->dev,
				"failed to prepare transfer hardware\n");

			if (ctlr->auto_runtime_pm)
				pm_runtime_put(ctlr->dev.parent);
			mutex_unlock(&ctlr->io_mutex);
			return;
		}
	}

	trace_spi_message_start(ctlr->cur_msg);

	if (ctlr->prepare_message) {
		ret = ctlr->prepare_message(ctlr, ctlr->cur_msg);
		if (ret) {
			dev_err(&ctlr->dev, "failed to prepare message: %d\n",
				ret);
			ctlr->cur_msg->status = ret;
			spi_finalize_current_message(ctlr);
			goto out;
		}
		ctlr->cur_msg_prepared = true;
	}

	ret = spi_map_msg(ctlr, ctlr->cur_msg);
	if (ret) {
		ctlr->cur_msg->status = ret;
		spi_finalize_current_message(ctlr);
		goto out;
	}

	ret = ctlr->transfer_one_message(ctlr, ctlr->cur_msg);
	if (ret) {
		dev_err(&ctlr->dev,
			"failed to transfer one message from queue\n");
		goto out;
	}

out:
	mutex_unlock(&ctlr->io_mutex);

	/* 如果成功传输，则唤醒调度器 */
	if (!ret)
		cond_resched();
}

124行代码ctlr->transfer_one_message是一个函数指针，它指向了SPI控制器中负责执行SPI消息传输的函数。通过调用这个函数，将当前的SPI消息 ctlr->cur_msg 传递给该函数进行处理。这个函数通常会负责将消息的数据发送到SPI设备或从设备接收数据，并与硬件设备进行通信。

因此，ctlr->transfer_one_message(ctlr, ctlr->cur_msg)这一行代码的作用是将当前的SPI消息传递给SPI控制器中的传输函数进行处理，以完成消息的传输操作。

至此，SPI通信过程已经分析完毕，而除了spi_write和spi_read函数，还有第三个常用函数spi_write_then_read，该函数的作用为先写后读，在后面的章节中会用到该函数，该函数的具体内容如下所示：

int spi_write_then_read(struct spi_device *spi,
		const void *txbuf, unsigned n_tx,
		void *rxbuf, unsigned n_rx)
{
	// 定义一个静态互斥锁
	static DEFINE_MUTEX(lock);

	int			status;
	struct spi_message	message;
	struct spi_transfer	x[2];
	u8			*local_buf;

	/* 如果可以的话，使用预分配的 DMA 安全缓冲区。我们不能避免
	 * 在这里进行拷贝操作（作为一种纯粹的方便操作），但是我们可以
	 * 在缓冲区未被其他进程使用或传输不太大的情况下，
	 * 避免在热路径上分配堆内存。
	 */
	if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
		local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
				    GFP_KERNEL | GFP_DMA);
		if (!local_buf)
			return -ENOMEM; // 如果内存分配失败，返回错误码
	} else {
		local_buf = buf;
	}

	// 初始化 SPI 消息
	spi_message_init(&message);
	memset(x, 0, sizeof(x));
	if (n_tx) {
		x[0].len = n_tx;
		spi_message_add_tail(&x[0], &message);
	}
	if (n_rx) {
		x[1].len = n_rx;
		spi_message_add_tail(&x[1], &message);
	}

	// 将发送数据复制到本地缓冲区
	memcpy(local_buf, txbuf, n_tx);
	x[0].tx_buf = local_buf;
	x[1].rx_buf = local_buf + n_tx;

	/* 执行 I/O 操作 */
	status = spi_sync(spi, &message);
	if (status == 0)
		// 如果传输成功，将接收数据复制到接收缓冲区
		memcpy(rxbuf, x[1].rx_buf, n_rx);

	// 释放锁或释放内存
	if (x[0].tx_buf == buf)
		mutex_unlock(&lock);
	else
		kfree(local_buf);

	return status; // 返回传输状态
}

至此，关于常用的SPI通信函数以及SPI通信流程就讲解完成了，在下个章节中将会继续对MCP2515驱动程序进行完善。