Linux驱动开发:SPI子系统

这篇具有很好参考价值的文章主要介绍了Linux驱动开发:SPI子系统。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1、SPI简介

1.1 四根线

MISO:主设备数据输入,从设备数据输出。
MOSI:主设备数据输出,从设备数据输入。
SCLK:时钟信号,由主设备产生。
CS:    从设备片选信号,由主设备控制。

1.2 四种模式

CPOL(时钟极性) :   0:时钟起始位低电平      1:时钟起始为高电平  
CPHA(时钟相位) :0:第一个时钟周期采样   1:第二个时钟周期采样

1、CPOL=0,CPHA=0:此时空闲态时,SCLK处于低电平,数据采样是在第1个边沿,也就是 SCLK由低电平到高电平的跳变,所以数据采样是在上升沿,数据发送是在下降沿

2、CPOL=0,CPHA=1:此时空闲态时,SCLK处于低电平,数据发送是在第1个边沿,也就是 SCLK由低电平到高电平的跳变,所以数据采样是在下降沿,数据发送是在上升沿

3、CPOL=1,CPHA=0:此时空闲态时,SCLK处于高电平,数据采集是在第1个边沿,也就是 SCLK由高电平到低电平的跳变,所以数据采集是在下降沿,数据发送是在上升沿

4、CPOL=1,CPHA=1:此时空闲态时,SCLK处于高电平,数据发送是在第1个边沿,也就是 SCLK由高电平到低电平的跳变,所以数据采集是在上升沿,数据发送是在下降沿

1.3 SPI数据传输

Linux驱动开发:SPI子系统        

        从图中可以看出,主机和从机都有一个串行移位寄存器,主机通过向它的SPI串行寄存器写入一个字节来发起一次传输。寄存器通过MOSI信号线将字节传送给从机,从机也将自己的移位寄存器中的内容通过MISO信号线返回给主机。这样,两个移位寄存器中的内容就被交换。外设的写操作和读操作是同步完成的。如果只进行写操作,主机只需忽略接收到的字节;反之,若主机要读取从机的一个字节,就必须发送一个空字节来引发从机的传输。

1.4 SPI驱动框架简介

        SPI 驱动框架和 I2C 很类似,都分为主机控制器驱动和设备驱动,主机控制器也就是 SOC 的 SPI 控制器接口。样。和 I2C适配器驱动一样,SPI主机驱动一般都是 SOC 厂商去编写的,所以我们作为 SOC的使用者,这一部分的驱动就不用操心了。

2、SPI设备驱动

2.1 SPI相关API

2.1.1 spi_driver

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

struct device_driver {
	const char	*name;
	const struct of_device_id	*of_match_table;
}

2.1.2 注册:spi_register_driver

#define spi_register_driver(driver) 
	__spi_register_driver(THIS_MODULE, driver)

2.1.3 注销:spi_unregister_driver

static inline void spi_unregister_driver(struct spi_driver *sdrv)

2.1.4 module_spi_driver:一键注册,不需要以上注册注销的过程

#define module_spi_driver(__spi_driver) 
	module_driver(__spi_driver, spi_register_driver, 
			spi_unregister_driver)

#define module_driver(__driver, __register, __unregister, ...) 
static int __init __driver##_init(void) 
{ 
	return __register(&(__driver) , ##__VA_ARGS__); 
} 
module_init(__driver##_init); 
static void __exit __driver##_exit(void) 
{ 
	__unregister(&(__driver) , ##__VA_ARGS__); 
} 
module_exit(__driver##_exit);
module_spi_driver(myspi);

#define module_spi_driver(myspi) 
	module_driver(myspi, spi_register_driver, 
			spi_unregister_driver)

#define module_driver(myspi, spi_register_driver, spi_unregister_driver) 
static int __init myspi_init(void) 
{ 
	return spi_register_driver(&myspi); 
} 

static void __exit myspi_exit(void) 
{ 
	spi_unregister_driver(&myspi); 
} 
module_init(myspi_init); 
module_exit(myspi_exit);

2.1.5 spi_write

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);
}

2.1.6 spi_read

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);
}

2.1.7 spi_write_then_read 

extern int spi_write_then_read(struct spi_device *spi,
		const void *txbuf, unsigned n_tx,
		void *rxbuf, unsigned n_rx);

2.1.8 以上三种spi传输函数解析,实际接收发送只需spi_write、spi_read

struct spi_transfer {
	const void	*tx_buf;  //用于保存发送的数据
	void		*rx_buf;  //用于保存接收到的数据
	unsigned	len;      //是要进行传输的数据长度, SPI是全双工通信,
                          //因此在一次通信中发送和接收的字节数都是一样的,
                          //所以 spi_transfer中也就没有发送长度和接收长度之分。
};

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

	spi_message_init_with_transfers(&msg, xfers, num_xfers);

	return spi_sync(spi, &msg);
}

struct spi_message {
	struct list_head	transfers;
	struct spi_device	*spi;
};

spi_message_init_with_transfers(struct spi_message *m,
struct spi_transfer *xfers, unsigned int num_xfers)
{    
	unsigned int i;
	spi_message_init(m);
	for (i = 0; i < num_xfers; ++i)
		spi_message_add_tail(&xfers[i], m);
}

总体流程:

①、申请并初 始化 spi_transfer,设置 spi_transfer的 tx_buf成员变量, tx_buf为要发送的数
据。然后设置 rx_buf成员变量, rx_buf保存着接收到的数据。最后设置 len成员变量,也就是要进行数据通信的长度。
②、使用 spi_message_init函数初始化 spi_message。
③、使用 spi_message_add_tail函数将前面设置好的 spi_transfer添加到 spi_message队列中。
④、使用 spi_sync函数完成 SPI数据同步传输。文章来源地址https://www.toymoban.com/news/detail-461604.html

 2.1.9 spi_message_init

int spi_sync(struct spi_device *spi, struct spi_message *message) 
/*
功能:初始化spi_message
参数:
    @spi    :要进行数据传输的 spi_device
    @message:要传输的 spi_message
返回值:无
*/

2.1.10 spi_message_add_tail

void spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
/*
功能:初始化完成以后需要将 spi_transfer添加到 spi_message队列中
参数:
    @t:要添加到队列中的 spi_transfer
    @m:spi_transfer要加入的 spi_message
返回值: 无
*/

2.1.11 spi_sync:同步传输

int spi_sync(struct spi_device *spi, struct spi_message *message)
/*
功能:同步传输,会阻塞的等待 SPI 数据传输完成
参数:
    @spi:要进行数据传输的 spi_device
    @message:要传输的 spi_message
返回值:成功返回0,失败返回错误码
*/

2.1.12 spi_async:异步传输

int spi_async(struct spi_device *spi, struct spi_message *message)
/*
功能:异步传输不会阻塞的等到 SPI数据传输完成,异步传输需要设置 spi_message中的 complete成员变量,
      complete是一个回调函数,当 SPI异步传输完成以后此函数就会被调用。
参数:        
    @spi:要进行数据传输的 spi_device
    @message:要传输的 spi_message
返回值:成功返回0,失败返回错误码
*/

3、驱动程序

3.1 修改设备树

&spi4{
    pinctrl-names = "default", "sleep";
    pinctrl-0 = <&spi4_pins_b>;
    pinctrl-1 = <&spi4_sleep_pins_b>;
    cs-gpios = <&gpioe 11 0>;
    status = "okay";
    
    m74hc595@0{
        compatible = "aaa,m74hc595";
        reg = <0>;
        spi-max-frequency = <10000000>; //10Mhz
    };
};

3.2 驱动程序编写

#ifndef __M74HC595_H__
#define __M74HC595_H__

#define SEG_WHICH _IOW('k',0,int)
#define SEG_DAT  _IOW('k',1,int)
#endif
#define NAME "m74hc595"
int major = 0;
struct class *cls;
struct device *dev;
struct spi_device *gspi;
u8 code[] = {
	0x3f, 0x06, 0x5b, 0x4f, 0x6d, 0x7d, 0x07, 0x7f, 
	0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71, 
};

u8 which[] = {
	0x1, 0x2, 0x4, 0x8, 
};

int m74hc595_open(struct inode *inode, struct file *file)
{
	return 0;
}
long m74hc595_ioctl(struct file *file, 
	unsigned int cmd, unsigned long args)
{	
	switch(cmd){
		case SEG_WHICH:
			spi_write(gspi,&which[args],1);
			break;
		case SEG_DAT:
			spi_write(gspi,&code[args],1);
			break;
		default: printk("ioctl error\n");break;
	}
	
	return 0;
}

int m74hc595_close(struct inode *inode, struct file *file)
{
	return 0;
}
struct file_operations fops = {
	.open = m74hc595_open,
	.unlocked_ioctl = m74hc595_ioctl,
	.release = m74hc595_close,
};

int	m74hc595_probe(struct spi_device *spi)
{
	u8 buf[2] = {0xf,0x0};
	gspi = spi;
	spi_write(gspi,buf,ARRAY_SIZE(buf));
	
	major = register_chrdev(0,NAME,&fops);
	cls = class_create(THIS_MODULE,NAME);
	dev = device_create(cls,NULL,MKDEV(major,0),NULL,NAME);

	return 0;
}

int	m74hc595_remove(struct spi_device *spi)
{
	device_destroy(cls,MKDEV(major,0));
	class_destroy(cls);
	unregister_chrdev(major,NAME);
	return 0;
}

const struct of_device_id of_match[] = {
	{.compatible = "aaa,m74hc595",},
	{},
};

struct spi_driver m74hc595 = {
	.probe = m74hc595_probe,
	.remove = m74hc595_remove,
	.driver = {
		.name = "bbb",
		.of_match_table = of_match,
	},	
};
module_spi_driver(m74hc595);

4、应用程序  

int main(int argc, const char *argv[])
{
	int which=0;
	int data=0;
	int fd;
	fd = open("/dev/m74hc595",O_RDWR);
	if(fd < 0){
		perror("open error");
		return -1;
	}

	while(1){
		ioctl(fd,SEG_WHICH,which++);
		ioctl(fd,SEG_DAT,data++);
		if(which >= 4)which=0;
		if(data >= 16)data = 0;
		sleep(1);
	}

	close(fd);
	return 0;
}

到了这里,关于Linux驱动开发:SPI子系统的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux驱动开发】011 gpio子系统

    前面我们编写了基于设备树的 LED 驱动,但是驱动的本质还是没变,都是配置 LED 灯所使用的 GPIO 寄存器,驱动开发方式和裸机基本没啥区别。本章我们就来学习一下如何借助 pinctrl 和 gpio 子系统来简化 GPIO 驱动开发。   Linux 内核针对 PIN 的配置推出了 pinctrl 子系统,对于

    2024年02月03日
    浏览(47)
  • <Linux开发>驱动开发 -之-基于pinctrl/gpio子系统的beep驱动

    <Linux开发>驱动开发 -之-基于pinctrl/gpio子系统的beep驱动 交叉编译环境搭建: <Linux开发> linux开发工具-之-交叉编译环境搭建 uboot移植可参考以下: <Linux开发> -之-系统移植 uboot移植过程详细记录(第一部分) <Linux开发> -之-系统移植 uboot移植过程详细记录(第二部分

    2024年02月13日
    浏览(38)
  • 【Linux驱动开发】012 gpio子系统API函数

    设置好设备树以后, 在驱动程序中就可以使用 gpio 子系统提供的 API 函数来操作指定的 GPIO, gpio 子系统向驱动开发人员屏蔽了具体的读写寄存器过程。这就是驱动分层与分离的好处,大家各司其职,做好自己的本职工作即可。 gpio 子系统提供的常用的 API 函数有下面几个:

    2023年04月18日
    浏览(40)
  • Linux驱动开发之【pinctrl和gpio子系统】

    目录 一、 pinctrl和gpio子系统 1.pinctrl子系统 1.1 pinctrl子系统简介 1.2 pinctrl子系统驱动 1.3 设备树中添加pinctrl节点模版 2. gpio子系统 2.1 gpio子系统简介 2.2 gpio子系统驱动 2.3 gpio子系统API函数 2.4 设备树中添加gpio节点模板 2.5 与gpio相关的OF函数 3. 驱动程序编写 3.1 驱动入口函数 3

    2024年02月06日
    浏览(43)
  • 【LED子系统深度剖析】一、开篇词|Linux驱动开发必读

    我的圈子: 高级工程师聚集地 我是董哥,高级嵌入式软件开发工程师,从事嵌入式Linux驱动开发和系统开发,曾就职于世界500强公司! 创作理念:专注分享高质量嵌入式文章,让大家读有所得!

    2024年02月09日
    浏览(40)
  • Linux SPI子系统(2):SPI核心层

    目录 SPI核心层  1. SPI子系统初始化 2. 重要的数据结构 2.1 struct spi_controller 2.2 struct spi_driver 2.3 struct spi_device 2.4 struct spi_transfer和struct spi_message 3. 重要的API 3.1 spi_register_controller 3.2 数据准备函数:spi_message_init和spi_message_add_tail 3.3 数据传输函数:spi_sync和spi_async 4. 参考文章

    2024年02月01日
    浏览(69)
  • 【IMX6ULL驱动开发学习】14.Linux驱动开发 - GPIO中断(设备树 + GPIO子系统)

    代码自取 【14.key_tree_pinctrl_gpios_interrupt】: https://gitee.com/chenshao777/imx6-ull_-drivers 主要接口函数: 1. of_gpio_count (获得GPIO的数量) 2. kzalloc (向内核申请空间) 3. of_get_gpio (获取GPIO子系统标号) 4. gpio_to_irq (根据GPIO子系统标号得到软件中断号) 5. request_irq (根据软件中断号

    2024年02月12日
    浏览(49)
  • 【IMX6ULL驱动开发学习】21.Linux驱动之PWM子系统(以SG90舵机为例)

    首先在 imx6ull.dtsi 文件中已经帮我们定义好了一些pwm的设备树节点,这里以pwm2为例 我们要在设备树(.dts)文件中引用和使能该节点,同时指定好pwm映射到的GPIO引脚(即pinctrl子系统,我这里映射到了GPIO1_9上) 使用pwm 只需要在设备树节点中添加两条属性信息,如下所示 pwms :属

    2024年02月12日
    浏览(129)
  • Linux Mii management/mdio子系统分析之三 mii_bus注册、注销及其驱动开发流程

    (转载)原文链接:https://blog.csdn.net/u014044624/article/details/123303174       本篇是mii management/mdio模块分析的第三篇文章,本章我们主要介绍mii-bus的注册与注销接口。在前面的介绍中也已经说过,我们可以将mii-bus理解为mdio总线的控制器的抽象,就像spi-master、i2c-adapter一样。 本

    2024年01月16日
    浏览(42)
  • Linux IIO 子系统简介

    IIO 子系统系统框架 而在IIO子系统内部,则主要包括如下四部分的内容: iio buffer用于处理需要进行连续采集的数据,当一个IIO device的各通道数据支持连续采集时,则调用iio buffer模块提供的接口,创建iio buffer用于存储连续存储的数据,同时该模块提供字符设备文件的注册,因

    2024年02月16日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包