devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

rk3399下spi驱动_3399 spi

作者：我家自动化 | 2024-06-13 11:35:46

赞

踩

3399 spi

SPI 使用

Note：本文从firefly wiki截取

SPI是一种高速的，全双工，同步串行通信接口，用于连接微控制器、传感器、存储设备等。 Firefly-RK3399 开发板提供了 SPI1 （单片选）接口，具体位置如下图： _images/spi2.jpg

SPI工作方式

SPI以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，分别是：

CS		片选信号
SCLK		时钟信号
MOSI		主设备数据输出、从设备数据输入
MISO		主设备数据输入，从设备数据输出

Linux内核用CPOL和CPHA的组合来表示当前SPI的四种工作模式：

  1. CPOL＝0，CPHA＝0		SPI_MODE_0
  2. CPOL＝0，CPHA＝1		SPI_MODE_1
  3. CPOL＝1，CPHA＝0		SPI_MODE_2
  4. CPOL＝1，CPHA＝1		SPI_MODE_3

CPOL：表示时钟信号的初始电平的状态，０为低电平，１为高电平。CPHA：表示在哪个时钟沿采样，０为第一个时钟沿采样，１为第二个时钟沿采样。SPI的四种工作模式波形图如下：

_images/spi1.jpg

驱动编写

下面以 W25Q128FV Flash模块为例简单介绍SPI驱动的编写。

硬件连接

Firefly-RK3399 与 W25Q128FV 硬件连接如下表：

_images/spi3.png

编写Makefile/Kconfig

在kernel/drivers/spi/Kconfig中添加对应的驱动文件配置：

  1. config SPI_FIREFLY
  2.        tristate "Firefly SPI demo support "
  3.        default y
  4.         help
  5.           Select this option if your Firefly board needs to run SPI demo.

在kernel/drivers/spi/Makefile中添加对应的驱动文件名：

obj-$(CONFIG_SPI_FIREFLY)              += spi-firefly-demo.o

config中选中所添加的驱动文件，如：

  1.   │ Symbol: SPI_FIREFLY [=y] 
  2.   │ Type  : tristate
  3.   │ Prompt: Firefly SPI demo support
  4.   │   Location:
  5.   │     -> Device Drivers
  6.   │       -> SPI support (SPI [=y])
  7.   │   Defined at drivers/spi/Kconfig:704
  8.   │   Depends on: SPI [=y] && SPI_MASTER [=y]

配置DTS节点

在kernel/arch/arm64/boot/dts/rockchip/rk3399-firefly-demo.dtsi中添加SPI驱动结点描述，如下所示：

  1. /* Firefly SPI demo */
  2. &spi1 {
  3. 	spi_demo: spi-demo@00{
  4. 		status = "okay";
  5. 		compatible = "firefly,rk3399-spi";
  6. 		reg = <0x00>;
  7. 		spi-max-frequency = <48000000>;
  8. 		/* rk3399 driver support SPI_CPOL | SPI_CPHA | SPI_CS_HIGH */
  9. 		//spi-cpha;		/* SPI mode: CPHA=1 */
  10. 		//spi-cpol;   	/* SPI mode: CPOL=1 */
  11. 		//spi-cs-high;
  12. 	};
  13. };
  14.  
  15. &spidev0 {
  16. 	status = "disabled";
  17. };
  • status:如果要启用SPI，则设为okay，如不启用，设为disable。
  • spi-demo@00:由于本例子使用CS0，故此处设为00，如果使用CS1，则设为01。
  • compatible:这里的属性必须与驱动中的结构体：of_device_id 中的成员compatible 保持一致。
  • reg:此处与spi-demo@00保持一致，本例设为：0x00。
  • spi-max-frequency：此处设置spi使用的最高频率。Firefly-RK3399最高支持48000000。
  • spi-cpha，spi-cpol：SPI的工作模式在此设置，本例所用的模块SPI工作模式为SPI_MODE_0或者SPI_MODE_3，这里我们选用SPI_MODE_0，如果使用SPI_MODE_3，spi_demo中打开spi-cpha和spi-cpol即可。
  • spidev0: 由于spi_demo与spidev0使用一样的硬件资源，需要把spidev0关掉才能打开spi_demo

定义SPI驱动

在内核源码目录kernel/drivers/spi/中创建新的驱动文件，如：spi-firefly-demo.c 在定义 SPI 驱动之前，用户首先要定义变量 of_device_id 。 of_device_id 用于在驱动中调用dts文件中定义的设备信息，其定义如下所示：

static struct of_device_id firefly_match_table[] = {{ .compatible = "firefly,rk3399-spi",},{},};

此处的compatible与DTS文件中的保持一致。

spi_driver定义如下所示：

  1. static struct spi_driver firefly_spi_driver = {
  2. 	.driver = {
  3. 		.name = "firefly-spi",
  4. 		.owner = THIS_MODULE,
  5. 		.of_match_table = firefly_match_table,},
  6. 	.probe = firefly_spi_probe,};

注册SPI设备

在初始化函数static int __init spidev_init(void)中向内核注册SPI驱动： spi_register_driver(&firefly_spi_driver);

如果内核启动时匹配成功，则SPI核心会配置SPI的参数（mode、speed等），并调用firefly_spi_probe。

读写 SPI 数据

Note：程序在文末

firefly_spi_probe中使用了两种接口操作读取W25Q128FV的ID: firefly_spi_read_w25x_id_0接口直接使用了spi_transfer和spi_message来传送数据。 firefly_spi_read_w25x_id_1接口则使用SPI接口spi_write_then_read来读写数据。

成功后会打印：

  1. root@rk3399_firefly_box:/ # dmesg | grep firefly-spi                                                                                   
  2. [    1.006235] firefly-spi spi0.0: Firefly SPI demo program                                                                            
  3. [    1.006246] firefly-spi spi0.0: firefly_spi_probe: setup mode 0, 8 bits/w, 48000000 Hz max                                          
  4. [    1.006298] firefly-spi spi0.0: firefly_spi_read_w25x_id_0: ID = ef 40 18 00 00                                                     
  5. [    1.006361] firefly-spi spi0.0: firefly_spi_read_w25x_id_1: ID = ef 40 18 00 00

打开SPI demo

spi-firefly-demo默认没有打开，如果需要的话可以使用以下补丁打开demo驱动：

  1. --- a/kernel/arch/arm64/boot/dts/rockchip/rk3399-firefly-demo.dtsi
  2. +++ b/kernel/arch/arm64/boot/dts/rockchip/rk3399-firefly-demo.dtsi
  3. @@ -64,7 +64,7 @@ /* Firefly SPI demo */
  4.  &spi1 {spi_demo: spi-demo@00{
  5.  -                status = "disabled";
  6.  +               status = "okay";
  7.                    compatible = "firefly,rk3399-spi";
  8.                    reg = <0x00>;
  9.                    spi-max-frequency = <48000000>;
  10.  @@ -76,6 +76,6 @@
  11.   }; 
  12.   
  13.    &spidev0 {
  14.    -       status = "okay";
  15.    +       status = "disabled";
  16.  };

常用SPI接口

下面是常用的 SPI API 定义：

  1. void spi_message_init(struct spi_message *m); 
  2. void spi_message_add_tail(struct spi_transfer *t, struct spi_message *m); 
  3. int spi_sync(struct spi_device *spi, struct spi_message *message) ; 
  4. int spi_write(struct spi_device *spi, const void *buf, size_t len); 
  5. int spi_read(struct spi_device *spi, void *buf, size_t len); 
  6. ssize_t spi_w8r8(struct spi_device *spi, u8 cmd); 
  7. ssize_t spi_w8r16(struct spi_device *spi, u8 cmd); 
  8. ssize_t spi_w8r16be(struct spi_device *spi, u8 cmd); 
  9. int spi_write_then_read(struct spi_device *spi, const void *txbuf, unsigned n_tx, void *rxbuf, unsigned n_rx);

接口使用

Linux提供了一个功能有限的SPI用户接口，如果不需要用到IRQ或者其他内核驱动接口，可以考虑使用接口spidev编写用户层程序控制SPI设备。 在 Firefly-RK3399 开发板中对应的路径为： /dev/spidev0.0

spidev对应的驱动代码： kernel/drivers/spi/spidev.c

内核config需要选上SPI_SPIDEV：

  1.  │ Symbol: SPI_SPIDEV [=y]
  2.  │ Type  : tristate
  3.  │ Prompt: User mode SPI device driver support 
  4.  │   Location:
  5.  │     -> Device Drivers
  6.  │       -> SPI support (SPI [=y])
  7.  │   Defined at drivers/spi/Kconfig:684
  8.  │   Depends on: SPI [=y] && SPI_MASTER [=y]

DTS配置如下：

  1. &spi1 {
  2.     status = "okay";
  3.     max-freq = <48000000>;  
  4.     spidev@00 {
  5.         compatible = "linux,spidev";
  6.         reg = <0x00>;
  7.         spi-max-frequency = <48000000>;
  8.     };
  9. };

FAQs

Q1: SPI数据传送异常

A1: 确保 SPI 4个引脚的 IOMUX 配置正确， 确认 TX 送数据时，TX 引脚有正常的波形，CLK 频率正确，CS 信号有拉低，mode 与设备匹配。

程序清单：

  1. /*
  2.  * Driver for pwm demo on Firefly board.
  3.  *
  4.  * Copyright (C) 2016, Zhongshan T-chip Intelligent Technology Co.,ltd.
  5.  * Copyright 2006  Sam Chan
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 2 as
  9.  * published by the Free Software Foundation.
  10.  */
  11. #define DEBUG
  12. #include <linux/module.h>
  13. #include <linux/kernel.h>
  14. #include <linux/init.h>
  15. #include <linux/err.h>
  16. #include <linux/io.h>
  17. #include <linux/of.h>
  18. #include <linux/interrupt.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/spi/spi.h>
  21. #include <linux/spi/spidev.h>
  22. #define FIREFLY_SPI_READ_ID_CMD 0x9F
  23. #define FIREFLY_SPI_PRINT_ID(rbuf) \
  24. 	do { \
  25. 		if (status == 0) \
  26. 			dev_dbg(&spi->dev, "%s: ID = %02x %02x %02x %02x %02x\n", __FUNCTION__, \
  27. 				rbuf[0], rbuf[1], rbuf[2], rbuf[3], rbuf[4]); \
  28. 		else \
  29. 			dev_err(&spi->dev, "%s: read ID error\n", __FUNCTION__); \
  30. 	}while(0)
  31. static int firefly_spi_read_w25x_id_0(struct spi_device *spi)
  32. {	
  33. 	int	status;
  34. 	char tbuf[]={FIREFLY_SPI_READ_ID_CMD};
  35. 	char rbuf[5];
  36. 	struct spi_transfer	t = {
  37. 		.tx_buf		= tbuf,
  38. 		.len		= sizeof(tbuf),
  39. 	};
  40. 	struct spi_transfer     r = {
  41. 		.rx_buf         = rbuf,
  42. 		.len            = sizeof(rbuf),
  43. 	};
  44. 	struct spi_message      m;
  45. 	spi_message_init(&m);
  46. 	spi_message_add_tail(&t, &m);
  47. 	spi_message_add_tail(&r, &m);
  48. 	status = spi_sync(spi, &m);
  49. 	FIREFLY_SPI_PRINT_ID(rbuf);
  50. 	return status;
  51. }
  52. static int firefly_spi_read_w25x_id_1(struct spi_device *spi)
  53. {
  54. 	int	status;
  55. 	char tbuf[] = {FIREFLY_SPI_READ_ID_CMD};
  56. 	char rbuf[5];
  57. 	status = spi_write_then_read(spi, tbuf, sizeof(tbuf), rbuf, sizeof(rbuf));
  58. 	
  59. 	FIREFLY_SPI_PRINT_ID(rbuf);
  60. 	return status;
  61. }
  62. static int firefly_spi_probe(struct spi_device *spi)
  63. {
  64.     int ret = 0;
  65.     struct device_node __maybe_unused *np = spi->dev.of_node;
  66.     dev_dbg(&spi->dev, "Firefly SPI demo program\n");
  67. 	if(!spi)	
  68. 		return -ENOMEM;
  69. 	dev_dbg(&spi->dev, "firefly_spi_probe: setup mode %d, %s%s%s%s%u bits/w, %u Hz max\n",
  70. 			(int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
  71. 			(spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
  72. 			(spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
  73. 			(spi->mode & SPI_3WIRE) ? "3wire, " : "",
  74. 			(spi->mode & SPI_LOOP) ? "loopback, " : "",
  75. 			spi->bits_per_word, spi->max_speed_hz);
  76. 	firefly_spi_read_w25x_id_0(spi);
  77. 	firefly_spi_read_w25x_id_1(spi);
  78. 	
  79.     return ret;
  80. }
  81. static struct of_device_id firefly_match_table[] = {
  82. 	{ .compatible = "firefly,rk3399-spi",},
  83. 	{},
  84. };
  85. static struct spi_driver firefly_spi_driver = {
  86. 	.driver = {
  87. 		.name = "firefly-spi",
  88. 		.owner = THIS_MODULE,
  89. 		.of_match_table = firefly_match_table,
  90. 	},
  91. 	.probe = firefly_spi_probe,
  92. };
  93. static int firefly_spi_init(void)
  94. {
  95. 	return spi_register_driver(&firefly_spi_driver);
  96. }
  97. module_init(firefly_spi_init);
  98. static void firefly_spi_exit(void)
  99. {
  100. 	spi_unregister_driver(&firefly_spi_driver);
  101. }
  102. module_exit(firefly_spi_exit);
  103. MODULE_AUTHOR("zhansb <service@t-firefly.com>");
  104. MODULE_DESCRIPTION("Firefly SPI demo driver");
  105. MODULE_ALIAS("platform:firefly-spi");
  106. MODULE_LICENSE("GPL");

看一下读写函数吧：

  1. static int firefly_spi_read_w25x_id_0(struct spi_device *spi)
  2. {	
  3. 	int	status;
  4. 	char tbuf[]={FIREFLY_SPI_READ_ID_CMD};
  5. 	char rbuf[5];
  6. 	struct spi_transfer	t = {
  7. 		.tx_buf		= tbuf,
  8. 		.len		= sizeof(tbuf),
  9. 	};
  10. 	struct spi_transfer     r = {
  11. 		.rx_buf         = rbuf,
  12. 		.len            = sizeof(rbuf),
  13. 	};
  14. 	struct spi_message      m;
  15. 	spi_message_init(&m);
  16. 	spi_message_add_tail(&t, &m);
  17. 	spi_message_add_tail(&r, &m);
  18. 	status = spi_sync(spi, &m);
  19. 	FIREFLY_SPI_PRINT_ID(rbuf);
  20. 	return status;
  21. }

是不是和IIC的很像，来做一下对比：

  1. static int read_reg(const struct i2c_client *client, unsigned int *buf , unsigned char address)
  2. {
  3. 	struct i2c_msg msg[2];
  4. 	int ret;
  5. 	unsigned char date1[2];
  6.  
  7. 	msg[0].addr  = client->addr;  
  8. 	msg[0].buf   = &address;              
  9. 	msg[0].len   = 1;                     
  10. 	msg[0].flags = 0;                   
  11.  
  12. 	msg[1].addr  = client->addr; 
  13. 	msg[1].buf   = date1;                 
  14. 	msg[1].len   = 2;                    
  15. 	msg[1].flags = I2C_M_RD;                   
  16.  
  17. 	ret = i2c_transfer(client->adapter, msg, 2);
  18. 	if (ret > 0)
  19. 	{
  20. 		printk(KERN_INFO "date1 : %d date1 :%d\n",date1[0],date1[1]);
  21. 		*buf = (date1[0] << 8) | (date1[1]); 
  22. 		return 1;
  23. 	}
  24. 	else
  25. 		return -EIO;
  26. }

spi的总体框架从大体上应该和iic差不多吧，以后分析了如果说的不对，再来修改

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号