自己对spi内核驱动的理解

最新推荐文章于 2025-08-15 15:43:37 发布
原创 最新推荐文章于 2025-08-15 15:43:37 发布 · 1.5k 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详述了作者在学习SPI内核驱动时的心得，重点介绍了SPI设备驱动的三层结构、关键结构体和流程。通过分析配置、驱动过程和SPI控制器的操作，解释了如何在px30 kernel上编写SPI读写接口驱动。文章还涵盖了SPI设备驱动的注册、读写函数实现以及在字符设备上的应用。

自己对spi内核驱动的理解

这篇文章主要是我学习韦东山老师的的spi驱动，基于px30 kernel上编写一个spi 读写接口驱动代码的一个记录，总结了spi的大致流程，大家看的时候最好结合内核spi代码一起看，讲的可能不够详细，不够清楚，如果有错误请谅解，欢迎指正~~

首先我们来认识一下有关spi驱动有关的几个结构体：
结构体位置: include/linux/spi.spi.h
spi_device为一个spi的物理设备，包含着一些board信息，模式，频率等在dts中定义。
在这里插入图片描述
spi_master为spi控制器，bus_num由dts中的id来决定，其驱动代码一般都由厂家提供，不需要自己手动去编写。
在这里插入图片描述
spi_transfer主要用于数据的发送，将要发送和接收的数据地址，长度传入一般即可，bits_per_word默认为8字节传输。
在这里插入图片描述
spi_message包含多个spi_stransfer。
ALT

spi框架分为三层：spi设备驱动层，spi核心层，spi控制器驱动层。
spi控制器驱动层：实现spi0，spi1等控制器的注册(spi-具体芯片.c)
spi核心层：驱动的整个框架（spi.c）
spi设备驱动层：实现自己的驱动
在这里插入图片描述

配置make menuconfig

选择自己对应板子的选项

		Device Drivers ---->
				[*]SPI support ---->
						<*>Rockchip SPI controller driver

驱动过程的分析

总体大致流程：
在dts文件中打开对应的spi控制器状态为okay，则会根据compatible来匹配对应驱动文件，则module_platform_driver会创建该spi的平台设备，pdev->dev(即spi_device，包含的内容见上述结构体)会成功被申请，然后会将pdev->dev地址赋值给spi_device dev，则得到spi _device；然后执行驱动文件中的probe函数，填充spi master结构体，注册spi_master控制器；接下来实现自己的spi 设备驱动，可以注册成为字符设备，也可以注册成为misc设备，即为spi driver。在spi.c中为一些接口函数，spi_read,spi_write等接口函数在spi.h的头文件中，其中用到了spi transfer和spi message，spi message中有一个或者多个的spi transfer，也可以在自己的spi设备驱动中实现。这样，四个结构体都已经用上。

spi控制器流程
在创建master结构体的时候，需要将spi控制器的物理地址转成虚拟地址保存下来，所以我们要新建一个自己的结构体来保存该虚拟地址，方便设置spi的寄存器，需要其他自己的变量也可以在此结构体中声明。
一、从probe函数开始分析
1）spi_alloc_master出一个master结构体，第二个参数为自己定义的结构体，该函数会将自定义的结构体添加到master结构体申请的空间之后，即为master[1]；
2）通过spi_master_get_devdata,将master[1]获取出来，通过映射函数将物理地址转化为虚拟地址，并保存在自定义结构体的变量中；
3）填充master的一些参数和一些接口函数，主要bus_num，num_chipselect, mode_bits,setup, transfer等。参数具体作用见结构体图。
4）设置完参数后，开始注册spi驱动，通过spi_register_master注册，内核驱动中可能还会在spi_register_master上在封装一层；在该函数中，

spi_register_master
|___	1.判断num_chipselect是否等于0；
|___	2.判断bus_num，dev.of_node;dev.of_node会关联到设备树节点中。
|___	3.通过调用spi_match_master_to_boardinfo()函数在board_list中通过bus_num匹配对应的设备。
	|___如果master->bus_num 与board中的bus_num相同，则创建一个新的spi_master
	|___spi_new_device()
		|___spi_add_device()
			|___device_add()

二、实现steup函数，在setup函数中主要实现设置传输模式和传输频率的的设置， spi_mode由CPOL和CPHA来设定，在px30的kernel中，有spi_setup函数已经实现，若要自己重新写个驱动则需实现；

三、实现transfer函数，在px30的kernel中已经弃用，不用自己定义的transfer，通过使用spi_master_initialize_queue中来指定transfer函数，若要自己重新写个驱动则需实现；若自己实现：

		|___发送第一个spi_trabsfer之前先setup
		|___从spi_message中逐个取出spi_trabsfer,执行它
		|___唤醒等待线程

在内核代码中，发送数据有两种方式，1. 中断传输（适合小于32字节的数据发送）；2 dma方式（小于32字节的数据不适合使用），在px30内核代码中，通过控制use_dma来控制使用哪种方式；

spi_read() spi_write(), spi_write_then_read(),为内核实现的读写数据的接口函数，我觉得还可以加一个spi_write_and_read()，分析px30内核中的spi_read为例：

spi_read(struct spi_device *spi, void *buf, size_t len)
|___定义一个struct spi_transfer t与struct spi_message m,将参数buf，len，填入t中；
|___spi_message_init(&m)  初始化spi message m，将m结构体清0，初始化链表头；
|___spi_message_add_tail(&t, &m) 将t添加到m->transfer中
|___ spi_sync(spi, &m)
	|___ __spi_sync（）
		|___ __spi_pump_message()
			|___master->transfer_one_message()即spi_transfer_one_message
				|___master -> transfer_on即调用probe中的transfer_one

这样一次读操作的过程就玩成了。

SPI设备驱动:实现一个简单的读写驱动的接口
1.注册spi_register_driver(), 我将其注册为一个字符设备，采用cdev方法注册；
2.实现probe函数

|___动态分配一个主设备号
|___注册一个file_operation
|___初始化spi_my_data_t一个自己的结构体,包含spi_device *spi等，这个结构体成员根据自己需要来添加，可以设定自己想要的值,spi_my_data_t -> spi = spi,
     与之前dts注册出来的spi_devcie关联起来；
|___初始化mode, max_speed_HZ, bits_per_word;

3.接着自己实现了一些spi_my_read, spi_my_write, spi_my_write_then_read, spi_my_write_then_read等接口函数，其他和接口函数根据自己驱动需要来实现 如实现spi flash,spi OLED等操作函数都在这实现，我这里只是做了一个简单的读写驱动的接口而已， 若要将接口函数提供给上层，可以用ioctl等函数来实现；

自己的spi设备驱动代码

#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/fs.h>
#include <linux/dma-mapping.h>
#include <linux/dmaengine.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/spi/spi.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/miscdevice.h>
#include <linux/hrtimer.h>
#include <linux/platform_data/spi-rockchip.h>
#include <asm/uaccess.h>
#include <linux/syscalls.h>
#include <linux/cdev.h>

int spi_major;
struct cdev spi_cdev;
struct class *spi_class;
#define MAX_MY_SPI_NUM 	3

struct spi_my_data {
	int id; 
	struct spi_device *spi;
	struct device *dev;
	
};

/*保存每个挂在在spi bus上的设备的数据*/
struct spi_my_data *spi_my_data_group[MAX_MY_SPI_NUM];

int spi_my_read(int id, void *rx_buf, size_t len)
{
	struct spi_device *spi = NULL;

	if ( NULL == rx_buf)
	{
		printk("Error: rx_buff is NULL!\n");
		return -1;
	}
	if (id >= MAX_MY_SPI_NUM)
	{
		printk("Error: NOt have is id!\n");
		return -1;
	}
	if (NULL == spi_my_data_group[id])
	{
		printk("Error: spi_my_data_group[%d] is NULL!\n", id);
		return -1;
	}
		
	spi = spi_my_data_group[id] -> spi;
	spi_read(spi, rx_buf, len);

	return 0;
}
//EXPORT_SYMBOL(spi_my_read);


int spi_my_write(int id, void *tx_buf, size_t len)
{
	struct spi_device *spi = NULL;

	if ( NULL == tx_buf)
	{
		printk("Error: tx_buff is NULL!\n");
		return -1;
	}
	if (id >= MAX_MY_SPI_NUM)
	{
		printk("Error: NOt have is id!\n");
		return -1;
	}
	if (NULL == spi_my_data_group[id])
	{
		printk("Error: spi_my_data_group[%d] is NULL!\n", id);
		return -1;
	}
		
	spi = spi_my_data_group[id] -> spi;
	spi_write(spi, tx_buf, len);
	return 0;
}
//EXPORT_SYMBOL(spi_my_write);


int spi_my_write_then_read(int id, void *tx_buf, size_t len1, void *rx_buf, size_t len2)
{
	struct spi_device *spi = NULL;
	struct spi_message m;
	struct spi_transfer t[] = {
		{
			.tx_buf = tx_buf,
			.len = len1,
		},
		{
			.rx_buf = rx_buf,
			.len = len2,
		},
	};

	if ( NULL == tx_buf || NULL == rx_buf)
	{
		printk("Error: tx_buff is NULL!\n");
		return -1;
	}
	if (id >= MAX_MY_SPI_NUM)
	{
		printk("Error: NOt have is id!\n");
		return -1;
	}
	if (NULL == spi_my_data_group[id])
	{
		printk("Error: spi_my_data_group[%d] is NULL!\n", id);
		return -1;
	}

	spi = spi_my_data_group[id] -> spi;


	spi_message_init(&m);
	spi_message_add_tail(&t[0], &m);
	spi_message_add_tail(&t[1], &m);
	return spi_sync(spi, &m);		
}
//EXPORT_SYMBOL(spi_my_write_then_read);


int spi_my_write_and_read(int id, void *tx_buf, void *rx_buf, size_t len)
{
	struct spi_device *spi = NULL;
	struct spi_transfer     t = {
			.tx_buf         = tx_buf,
			.rx_buf         = rx_buf,
			.len            = len,
		};
	struct spi_message      m;


	if ( NULL == tx_buf || NULL == rx_buf)
	{
		printk("Error: tx_buff is NULL!\n");
		return -1;
	}
	if (id >= MAX_MY_SPI_NUM)
	{
		printk("Error: NOt have is id!\n");
		return -1;
	}
	if (NULL == spi_my_data_group[id])
	{
		printk("Error: spi_my_data_group[%d] is NULL!\n", id);
		return -1;
	}

	spi = spi_my_data_group[id] -> spi;

	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	return spi_sync(spi, &m);
}
//EXPORT_SYMBOL(spi_my_write_and_read);


static ssize_t spi_rockchip_my_read(struct file *filp, char __user *buf, size_t count, loff_t *f_ops)
{
	return 0;
}
static ssize_t spi_rockchip_my_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_ops)
{
	
		int argc = 0, i;
		char tmp[64];
		char *argv[16];
		char *cmd, *data;
		unsigned int id = 0, times = 0, size = 0;
		unsigned long us = 0, bytes = 0;
		char *txbuf = NULL, *rxbuf = NULL;
		ktime_t start_time;
		ktime_t end_time;
		ktime_t cost_time;
	
		memset(tmp, 0, sizeof(tmp));
		if (copy_from_user(tmp, buf, count))
			return -EFAULT;
		cmd = tmp;
		data = tmp;
	
		while (data < (tmp + count)) {
			data = strstr(data, " ");
			if (!data)
				break;
			*data = 0;
			argv[argc] = ++data;
			argc++;
			if (argc >= 16)
				break;
		}
	
		tmp[count - 1] = 0;
	
		if (!strcmp(cmd, "setspeed")) {
			int id = 0, val;
			struct spi_device *spi = NULL;
	
			sscanf(argv[0], "%d", &id);
			sscanf(argv[1], "%d", &val);
	
			if (id >= MAX_MY_SPI_NUM)
				return count;
			if (!spi_my_data_group[id]) {
				pr_err("g_spi.%d is NULL\n", id);
				return count ;
			} else {
				spi = spi_my_data_group[id]->spi;
			}
			spi->max_speed_hz = val;
		} else if (!strcmp(cmd, "write")) {
			char name[64];
			int fd;
			mm_segment_t old_fs = get_fs();
	
			sscanf(argv[0], "%d", &id);
			sscanf(argv[1], "%d", &times);
			sscanf(argv[2], "%d", &size);
			if (argc > 3) {
				sscanf(argv[3], "%s", name);
				set_fs(KERNEL_DS);
			}
	
			txbuf = kzalloc(size, GFP_KERNEL);
			if (!txbuf) {
				printk("spi write alloc buf size %d fail\n", size);
				return count;
			}
	
			if (argc > 3) {
				fd = sys_open(name, O_RDONLY, 0);
				if (fd < 0) {
					printk("open %s fail\n", name);
				} else {
					sys_read(fd, (char __user *)txbuf, size);
					sys_close(fd);
				}
				set_fs(old_fs);
			} else {
				for (i = 0; i < size; i++)
					txbuf[i] = i % 256;
			}
	
			start_time = ktime_get();
			for (i = 0; i < times; i++)
				spi_my_write(id, txbuf, size);
			end_time = ktime_get();
			cost_time = ktime_sub(end_time, start_time);
			us = ktime_to_us(cost_time);
	
			bytes = size * times * 1;
			bytes = bytes * 1000 / us;
			printk("spi write %d*%d cost %ldus speed:%ldKB/S\n", size, times, us, bytes);
	
			kfree(txbuf);
		} else if (!strcmp(cmd, "read")) {
			sscanf(argv[0], "%d", &id);
			sscanf(argv[1], "%d", &times);
			sscanf(argv[2], "%d", &size);
	
			rxbuf = kzalloc(size, GFP_KERNEL);
			if (!rxbuf) {
				printk("spi read alloc buf size %d fail\n", size);
				return count;
			}
	
			start_time = ktime_get();
			for (i = 0; i < times; i++)
				spi_my_read(id, rxbuf, size);
			end_time = ktime_get();
			cost_time = ktime_sub(end_time, start_time);
			us = ktime_to_us(cost_time);
	
			bytes = size * times * 1;
			bytes = bytes * 1000 / us;
			printk("spi read %d*%d cost %ldus speed:%ldKB/S\n", size, times, us, bytes);
	
			kfree(rxbuf);
		} else if (!strcmp(cmd, "loop")) {
			sscanf(argv[0], "%d", &id);
			sscanf(argv[1], "%d", &times);
			sscanf(argv[2], "%d", &size);
	
			txbuf = kzalloc(size, GFP_KERNEL);
			if (!txbuf) {
				printk("spi tx alloc buf size %d fail\n", size);
				return count;
			}
	
			rxbuf = kzalloc(size, GFP_KERNEL);
			if (!rxbuf) {
				kfree(txbuf);
				printk("spi rx alloc buf size %d fail\n", size);
				return count;
			}
	
			for (i = 0; i < size; i++)
				txbuf[i] = i % 256;
	
			start_time = ktime_get();
			for (i = 0; i < times; i++)
				spi_my_write_and_read(id, txbuf, rxbuf, size);
			//	spi_my_write_then_read(id, txbuf, size, rxbuf, size);
	
			end_time = ktime_get();
			cost_time = ktime_sub(end_time, start_time);
			us = ktime_to_us(cost_time);
	
			if (memcmp(txbuf, rxbuf, size))
				printk("spi loop test fail\n");
	
			bytes = size * times;
			bytes = bytes * 1000 / us;
			printk("spi loop %d*%d cost %ldus speed:%ldKB/S\n", size, times, us, bytes);
	
			kfree(txbuf);
			kfree(rxbuf);
		} else {
			printk("echo id number size > /dev/spi_misc_test\n");
			printk("echo write 0 10 255 > /dev/spi_misc_test\n");
			printk("echo write 0 10 255 init.rc > /dev/spi_misc_test\n");
			printk("echo read 0 10 255 > /dev/spi_misc_test\n");
			printk("echo loop 0 10 255 > /dev/spi_misc_test\n");
			printk("echo setspeed 0 1000000 > /dev/spi_misc_test\n");
		}
	return 0;
}
static long spi_rockchip_my_ioctl (struct file *file, unsigned int cmd, unsigned long arg)
{
	return 0;
}


struct file_operations spi_rockchip_my_ops = {

	.owner = THIS_MODULE,
 	//.read = spi_rockchip_my_read,
	//.write = spi_rockchip_my_write,
	//.unlocked_ioctl = spi_rockchip_my_ioctl,
};

static void set_spi_cdev(void)
{
	int err, devno;
	devno = MKDEV(spi_major, 0);
	cdev_init(&spi_cdev, &spi_rockchip_my_ops);
	spi_cdev.owner = THIS_MODULE;
	spi_cdev.ops = &spi_rockchip_my_ops;
	err = cdev_add(&spi_cdev, devno, 1);
	if (err)
		printk("add %d spi device error\n", devno);
}

static int rockchip_spi_my_probe(struct spi_device *spi)
{
	int t_buf[4] = {0};
	int r_buf[4] = {0};
	dev_t dev;
	int ret;	
	struct spi_my_data *spi_my_data_t = NULL;
	int id;

	if (!spi)
		return -ENOMEM;
	
	if (!spi->dev.of_node)
		return -ENOMEM;

	/*动态分配一个主设备号*/
	ret = alloc_chrdev_region(&dev, 0, 1, "spi_my_drv");
	if (ret < 0)
	{
		printk("spi rocjchip alloc_chrdev_region fail!\n");
		return -1;
	}
	spi_major = MAJOR(dev);
	/*注册一个file_operation*/
	set_spi_cdev();
	spi_class = class_create(THIS_MODULE, "spi_my_drv");
	device_create(spi_class, NULL, MKDEV(spi_major, 0), "SPI_MY_DRV", "spi_my_drv");

	/*初始化spi_device，可以设定自己想要的值*/	

	
	spi_my_data_t = (struct spi_my_data *)kzalloc(sizeof(struct spi_my_data), GFP_KERNEL);
	if (!spi_my_data_t) {
		dev_err(&spi->dev, "ERR: no memory for spi_test_data\n");
		return -ENOMEM;
	}
	spi->bits_per_word = 8;
	spi_my_data_t -> spi = spi;
	spi_my_data_t -> dev = &spi -> dev;
	if (of_property_read_u32(spi->dev.of_node, "id", &id)) {
		dev_warn(&spi->dev, "fail to get id, default set 0\n");
		id = 0;
	}
	/*初始化mode, max_speed_HZ, bits_per_word*/
	ret = spi_setup(spi);
	if (ret < 0) {
		dev_err(spi_my_data_t->dev, "ERR: fail to setup spi\n");
		return -1;
	}

	spi_my_data_group[id] = spi_my_data_t;
	printk("%s:name=%s,bus_num=%d,cs=%d,mode=%d,speed=%d\n", __func__, spi->modalias, spi->master->bus_num, spi->chip_select, spi->mode, spi->max_speed_hz);


	return 0;
}

static int rockchip_spi_my_remove(struct spi_device *spi)
{

	return 0;
}


static const struct of_device_id rockchip_spi_my_match[] = {
	{ .compatible = "rockship, spi_my_drv_cs0",   },
	{ },
};
MODULE_DEVICE_TABLE(of, rockchip_spi_my_match);

static struct spi_driver spi_rockchip_my_driver = {
	.driver = {
		.name = "spi_my_drv",
		.owner = THIS_MODULE,
		.of_match_table = of_match_ptr(rockchip_spi_my_match),
	},
	.probe = rockchip_spi_my_probe,
	.remove = rockchip_spi_my_remove,
};


static int __init spi_rockchip_my_init(void)
{
	int ret;

	ret = spi_register_driver(&spi_rockchip_my_driver);

	return ret;
}


static void __exit spi_rockchip_my_exit(void)
{
	device_destroy(spi_class, MKDEV(spi_major, 0));
	class_destroy(spi_class);
	cdev_del(&spi_cdev);
	unregister_chrdev_region(MKDEV(spi_major, 0), 1);
	spi_unregister_driver(&spi_rockchip_my_driver);
}

module_init(spi_rockchip_my_init);
module_exit(spi_rockchip_my_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("San Huid ,Inc");

参考px30内核和韦东山老师的的spi驱动

Evilsouls
关注
三大通信协议（3）SPI——基于flash的读操作
求学者
10-29 1849
目录 一、数据手册分析 二、实例 总结 一、数据手册分析 以黑金的开发板EP4CE6F17C8为核心，外部的flash芯片为M25P16，首先给出M25P16官方手册的时序图。 首先使能信号CS_N拉低，时钟信号上升沿读取MOSI中的数据，下降沿进行数据更新，MOSI先发送一个字节的读指令，然后发送三个字节的地址信号（扇区地址、页地址、字节地址），MISO从该地址中输出存储的数据，紧接着输出下一个地址中的数据，依次输出，直到使能信号CS_N拉...
spi 驱动程序组成简要分析
chuchou7395的博客
05-31 173
注册设备info（主要有设备通信速率、模式、片选引脚等与具体设备相关信息） spi_register_board_info list_add_tail(&bi->list, &board_list);//放进board_list链表中 l...
SPI (三) -- 如何编写SPI设备驱动程序
uleemos的博客
06-14 3534
上面将函数读写的上下层调用关系简单说明，其中，有个重要的数据结构，就是 struct spi_message *message。spi_message中存放的transfer链表，是由多个spi_transfer结构体组成，链表通过上图中的spi_message_add_tail函数，将传输的buff放入链表尾部。函数，对应的是异步的SPI传输函数，简单地说就是这个函数即刻返回，它返回后SPI传输不一定已经完成。，这是一个同步、阻塞的SPI传输函数，返回要么成功，要么失败。函数最终返回时，调用了。
spi中的write和read的数据传输过程
gxlovelxx的博客
09-01 6849
从示意图中，我们可以很清除看到函数的调用过程：先调用spi设备驱动层，随后调用bitbang中间层，最后调用了master驱动层来完成数据的传输。 read方法和write方法基本差不多，关键的区别在于其发送的数据为0，而在s3c24xx_spi_txrx中断服务程序中将读取数据寄存器。下面仅仅给出函数调用示意图。
linux kernel spi write_and_read clk不间断
u013463707的专栏
04-29 3591
spi_write_and_read，一帧完成写和读，CS保持低，clk不间断
pinctrl虚拟spi的linux驱动,linux内核pinctrl驱动的理解和总结
weixin_33185844的博客
05-15 288
1. 前言本站之前的三篇文章[1][2][3]介绍了pin controller(对应的pin controllersubsystem)、gpio controller(对应的GPIO subsystem)有关的基本概念，包括pinmultiplexing、pin configuration等等。本文将基于这些文章，单纯地从pin controllerdriver的角度(屏蔽掉pinctrl co...
24、深入理解Linux内核中的SPI设备驱动开发
k0l1m2n3o的博客
08-14 60
本文深入解析了Linux内核中SPI设备驱动的开发过程，涵盖了SPI消息处理基础、访问SPI设备的方式、驱动抽象与架构实现、驱动初始化与注册、SPI设备实例化等核心内容。通过代码示例详细说明了同步与异步事务处理的区别，提供了开发流程的总结、优化建议以及常见问题的解决方案，帮助开发者全面掌握SPI设备驱动开发的关键技术。
24、深入理解 Linux 内核中的 SPI 设备驱动开发
最新发布
ik678901234的博客
08-15 52
本文深入探讨了Linux内核中SPI设备驱动的开发，涵盖了SPI消息处理基础、设备访问机制、驱动抽象与架构设计、设备信息提供方式、驱动初始化与注册流程以及SPI设备的实例化方法。同时，还分析了在用户空间实现SPI通信的方式及其优缺点。通过详细的代码示例和结构解析，帮助开发者更好地理解和应用SPI驱动开发技术。
Linux下SPI驱动分析
steven.bai的专栏
06-20 945
Linux下SPI总线驱动有通用接口，一般的SPI设备驱动使用这个驱动接口实现设备驱动。分析驱动最好是先了解核心代码，然后从具体设备分析入手，然后从下至上，了解整个框架，再从上到下分析，理解透彻。以下分析内核根目录均以"src"代替。内核代码http://lxr.linux.no/，版本2.6.37.2。SPI的核心代码即"src/drivers/spi/spi.c"——SPI 初始化
嵌入式linux SPI驱动开发,Linux下spi驱动技术分析
weixin_39541681的博客
05-06 530
SPI是“Serial Peripheral Interface” 的缩写，是一种四线制的同步串行通信接口，用来连接微控制器、传感器、存储设备，SPI设备分为主设备和从设备两种，用于通信和控制的四根线分别是：CS 片选信号SCK 时钟信号MISO 主设备的数据输入、从设备的数据输出脚MOSI 主设备的数据输出、从设备的数据输入脚因为在大多数情况下，CPU或SOC一侧通常都是工作在主设备模式，所以，...
Linux下的SPI总线驱动（二）
zhanjianshinian的专栏
05-29 1796
四．SPI内核代码分析 我们已经讲过SPI驱动的移植，SPI控制设备和SPI接口设备的注册，SPI控制设备驱动和SPI接口设备驱动的注册。在移植时候，我们配置的选项告诉我们有些文件已经编入内核，那些就是SPI驱动的比较重要的文件。其中spi.c是SPI初始化和核心代码。spi_gpio.c是IO模拟SPI接口代码。spi_s3c24xx.c是s3c24xx系列芯片的SPI控制器驱动，它向更上层的
SPI内核驱动模型-dm8127
weixin_42005898的博客
11-23 385
利用TI提供的已有SPI内核驱动模型，该方案需要我们了解内核的SPI驱动模型是如何实现的。 3.1.    SPI内核驱动模型 在2.6的linux内核中，SPI的驱动架构可以分为如下三个层次：SPI 核心层、SPI控制器驱动层和SPI设备驱动层。Linux 中SPI驱动代码位于drivers/spi目录。 3.1.1.    SPI核心层 SPI核心层是Linux的SPI核心部分，提供了核心数据...
Linux 内核 SPI驱动收发函数API
weixin_35238280的博客
09-06 2456
发送字符串 static int spi_write_bytes(struct spi_device *spi, unsigned char *txbuf, int txlen) { int ret = 0; struct spi_message msg; struct spi_transfer xfer = { .len = txlen, ...
和菜鸟一起学linux总线驱动之初识spi驱动主要结构
东月之神
08-29 7153
既然知道了协议了，那么就可以开始去瞧瞧linux kenerl中的spi的驱动代码了，代码中有很多的结构体，还是对主要的结构体先做个了解吧，那样才可以很好的理解驱动。主要是include/linux/spi.h   首先是SPI的主机和从机通信接口，也就是SPI总线， extern struct bus_type spi_bus_type;   bus_type定义在linux/de
探索SPI通信与ADXL345传感器驱动编写
weixin_31185473的博客
04-29 1058
本文详细解读了如何通过SPI总线读取ADXL345传感器的轴值，通过adxl345_position_read()函数的代码剖析，我们了解到SPI通信的实现过程及adxl345_bus_ops数据结构的作用。文章还涉及到了如何声明支持的设备列表、定义spi_device_id数组、注册spi_driver结构体，并介绍了如何构建和加载设备树。此外，作者还提供了代码清单和GitHub仓库资源，方便读者进一步学习和实验。
全志F1C200S嵌入式驱动开发（spi-nand驱动）
嵌入式-老费，一个分享专业嵌入式知识的blog
07-17 3711
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 和v3s一样，f1c200s也支持tf卡、spi-nor、spi-nand启动。前面也说过，tf卡由于机械锁扣的原因，更适合拿来学习，spi-nor和spi-nand比较适合用来进行工业部署。只是spi-nor容量较小，一般最大也就32MB，spi-nand较大一点，可以达到128MB，因此前者工业上用的多一点，后者消费类电子多一点。
SPI_Master驱动程序框架
jia_weihui的博客
03-02 599
使用SPI传输时，最小的传输单位是"spi_transfer"，对于一个设备，可以发起多个spi_transfer，这些spi_transfer，会放入一个spi_message里。spi_transfer：指定tx_buf、rx_buf、len同一个SPI设备的spi_transfer，使用spi_message来管理：从spi_master的队列里取出每一个spi_message从spi_message的队列里取出一个spi_transfer处理spi_transfer。
linux spi设备驱动中probe函数何时被调用
kyo_的博客
07-03 1601
这两天被设备文件快搞疯了，也怪自己学东西一知半解吧，弄了几天总算能把设备注册理清楚一点点了。就以spi子设备的注册为例总结一下，免得自己忘记。 首先以注册一个spidev的设备为例: ...
RK356X SPI 使用
qq_29890089的博客
11-12 3878
Rockchip SPI 功能特点 SPI （serial peripheral interface），以下是 linux 4.4 spi 驱动支持的一些特性︰ 默认采用摩托罗拉 SPI 协议 支持 8 位和 16 位 软件可编程时钟频率和传输速率高达 50MHz 支持 SPI 4 种传输模式配置 每个 SPI 控制器支持一个到两个片选 除以上支持，linux 4.19 新增以下特性： 框架支持 slave 和 master 两种模式 代码路径 内核配置 DTS 节点配置 spi1: spi@fe62
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值