[米联客-XILINX-H3_CZ08_7100] LINUX驱动篇连载-13 AXI-IIC

软件版本：vitis2021.1(vivado2021.1)

操作系统：WIN10 64bit

硬件平台：适用XILINX Z7/ZU系列FPGA

登录“米联客”FPGA社区-www.uisrc.com视频课程、答疑解惑！

---

1 概述

在第十四章我们学习了I2C EEPROM的使用，在该章将会学习通过AXI-I2C来处理PL端eeprom的读写。

        实验目的：

• 掌握PL端的设备树的编写。
• 掌握vivado工程部分，axi-iic相关的总线搭建。
• 了解AXI-I2C IP的概念。
  

2 系统框图

3 介绍

3.1 AXI-IIC IP介绍

AXI-IIC控制器的功能构架图如下：

3.2 特性

-符合行业标准I2C协议

-通过axis4 - lite接口访问

-支持I2C主或从模式

-支持多主机操作

-软件可选择ACK位

-仲裁丢失中断并自动从主模式切换从模式

-寻址地址识别中断并自动从主模式到从模式

-起始位和停止位的产生和侦测

-重复起始位的产生

-ACK的产生和侦测

-总线忙检测

-支持1MHZ 、400KHZ 、100KHZ 工作时钟

-7位或10位寻址

-寻址使能和禁止

- 16字节深度的FIFO

-节流功能

-动态生成启动和停止

3.3 寄存器概述

3.4 硬件电路分析

本实验只测试EEPROM

4 工程搭建

该部分生成的文件已经分别保存在“BOOT”文件夹内，可以直接使用。如果想要自己生成，按照下面步骤。

4.1 vivado工程搭建

详细的vivado工程搭建参考第一章，本章的vivado工程并非默认的vivado工程，请选择在该章目录中的vivado工程。

打开“soc_prj”文件夹。

进入vivado工程打开IP，查看IP是否连接正确。

4.2 设备树文件

打开vitis，导入之前生成的xsa文件，生成设备树。详细过程参考第一章vivado工程搭建部分。

将pl.dsti部分的设备树文件拷贝进“附件”文件夹“soc_dts”中的dts文件中。或者可以直接使用“22.axi_iic”文件夹中有已经完成了的设备树文件。

4.3 设置内核配置

由于我们自己写的驱动程序会和已有驱动冲突，因此我们需要先将kernel内的驱动去掉。

首先，使用source mz7xcfg.sh添加环境变量，然后使用make_kernel_menuconfig.sh来设置内核。

如上图所示，依次找到Device Drivers - Misc devices - EEPROM support，取消如图所示的选项，保存并退出。运行save_kernel_defconfig.sh保存内核配置文件。

依次执行make_kernel.sh编译内核，create_image.sh打包uboot文件。

使用/uisrc-lab-xlnx/boards/mzux/ubuntu/images/boot下的三个文件，替换sd卡BOOT分区中的三个文件。

4.4 制作系统文件

详细的制作系统文件参考第一章环境搭建部分，将从vivado和vitis中生成的文件复制进开发环境，使用脚本生成系统文件。也可以直接使用本章示例文件夹“3.boot”中的文件，按照第一章的步骤复制进开发环境进行系统制作，这里只做简单的介绍。（“4.BOOT”文件夹中有已经生成好的系统文件镜像文件，可以直接拷贝至系统SD卡的BOOT文件夹内）

5 程序分析

程序分析部分，主要研究下设备树文件，驱动程序和应用程序与第十四章的程序并无不同，相关具体函数可以参考之前的解释。

5.1 设备树分析

1. /dts-v1/;
   
2. /include/ "zynq-7000.dtsi"
   
3. 
   
4. / {
   
5. model = "Zynq MZ7X Development Board";
   
6. compatible = "xlnx,zynq-MZ7X", "xlnx,zynq-7000";
   
7. 
   
8. aliases {
   
9.   ethernet0 = &gem0;
   
10.   serial0 = &uart1;
    
11.   spi0 = &qspi;
    
12.   i2c0 = &axi_iic_0;
    
13.   mmc0 = &sdhci0;
    
14.   mmc1 = &sdhci1;
    
15. };
    
16. 
    
17. memory@0 {
    
18.   device_type = "memory";
    
19.   reg = <0x0 0x40000000>;
    
20. };
    
21. 
    
22. chosen {
    
23.   bootargs = "";
    
24.   stdout-path = "serial0:115200n8";
    
25. };
    
26. 
    
27. usb_phy0: phy0@e0002000 {
    
28.   compatible = "ulpi-phy";
    
29.   #phy-cells = <0>;
    
30.   reg = <0xe0002000 0x1000>;
    
31.   view-port = <0x0170>;
    
32.   drv-vbus;
    
33. };
    
34. };
    
35. 
    
36. / {
    
37. amba_pl: amba_pl {
    
38.   #address-cells = <1>;
    
39.   #size-cells = <1>;
    
40.   compatible = "simple-bus";
    
41.   ranges ;
    
42.   axi_iic_0: i2c@41600000 {
    
43.    #address-cells = <1>;
    
44.    #size-cells = <0>;
    
45.    clock-names = "s_axi_aclk";
    
46.    clocks = <&clkc 15>;
    
47.    compatible = "xlnx,axi-iic-2.1", "xlnx,xps-iic-2.00.a";
    
48.    interrupt-names = "iic2intc_irpt";
    
49.    interrupt-parent = <&intc>;
    
50.    interrupts = <0 29 4>;
    
51.    reg = <0x41600000 0x10000>;
    
52.   };
    
53. };
    
54. };
    
55. 
    
56. &axi_iic_0 {
    
57. status = "okay";
    
58. clock-frequency = <400000>;
    
59. // scl-gpios = <&gpio 38 GPIO_ACTIVE_HIGH>;
    
60. // sda-gpios = <&gpio 39 GPIO_ACTIVE_HIGH>;
    
61. 
    
62. // rtc@68 {
    
63. //  compatible = "dallas,ds1337";
    
64. //  reg = <0x68>;
    
65. // };
    
66. 
    
67. eeprom@50 {
    
68.   compatible = "atmel,24c02";
    
69.   /* compatible = "at24,24c02"; */
    
70.   reg = <0x50>;
    
71. };
    
72. };
    
73. 
    
74. &gem0 {
    
75. status = "okay";
    
76. phy-mode = "rgmii-id";
    
77. xlnx,ptp-enet-clock = <0x69f6bcb>;
    
78. phy-handle = <&ethernet_phy>;
    
79. 
    
80. ethernet_phy: ethernet-phy@0 {
    
81.   reg = <0>;
    
82.   device_type = "ethernet-phy";
    
83. };
    
84. };
    
85. 
    
86. &gpio0 {
    
87. emio-gpio-width = <64>;
    
88. gpio-mask-high = <0x0>;
    
89. gpio-mask-low = <0x5600>;
    
90. };
    
91. 
    
92. &intc {
    
93. num_cpus = <2>;
    
94. num_interrupts = <96>;
    
95. };
    
96. 
    
97. &qspi {
    
98. u-boot,dm-pre-reloc;
    
99. status = "okay";
    
100. is-dual = <0>;
     
101. num-cs = <1>;
     
102. flash@0 {
     
103.   compatible = "n25q128a11";
     
104.   reg = <0x0>;
     
105.   spi-tx-bus-width = <4>;
     
106.   spi-rx-bus-width = <4>;
     
107.   spi-max-frequency = <125000000>;
     
108. };
     
109. };
     
110. 
     
111. &sdhci0 {
     
112. u-boot,dm-pre-reloc;
     
113. status = "okay";
     
114. xlnx,has-cd = <0x1>;
     
115. xlnx,has-power = <0x0>;
     
116. xlnx,has-wp = <0x0>;
     
117. };
     
118. 
     
119. &sdhci1 {
     
120. status = "okay";
     
121. xlnx,has-cd = <0x1>;
     
122. xlnx,has-power = <0x0>;
     
123. xlnx,has-wp = <0x1>;
     
124. };
     
125. 
     
126. &uart1 {
     
127. u-boot,dm-pre-reloc;
     
128. status = "okay";
     
129. };
     
130. 
     
131. &usb0 {
     
132. status = "okay";
     
133. dr_mode = "host";
     
134. usb-phy = <&usb_phy0>;
     
135. usb-reset = <&gpio0 46 0>;
     
136. };
     
137. 
     
138. &clkc {
     
139. fclk-enable = <0x7>;
     
140. ps-clk-frequency = <33333333>;
     
141. };

复制代码

具体的设备树如何查看，请参考第六章基于设备树的平台驱动。

第22行，将“axi_iic_0”设置一个别名“i2c1”。

第48行，vitis生成的关于PL端子卡的相关i2c配置。

和68行，为“axi_iic_0”添加“eeprom”设备，方便自己编写的驱动获取相关设置。

第174行，将“i2c0”中的“eeprom”设备注释掉，避免与子卡的eeprom冲突。

5.2 驱动程序分析

1. //添加头文件
   
2. #include <linux/init.h>
   
3. #include <linux/module.h>
   
4. #include <linux/input.h>
   
5. #include <linux/interrupt.h>
   
6. #include <linux/slab.h>
   
7. #include <linux/of.h>
   
8. #include <linux/of_irq.h>
   
9. #include <linux/of_gpio.h>
   
10. #include <linux/i2c.h>
    
11. #include <linux/io.h>
    
12. #include <linux/uaccess.h>
    
13. #include <linux/cdev.h>
    
14. 
    
15. #define EEPROM_MAJOR 400
    
16. #define EEPROM_MINOR 0
    
17. 
    
18. static struct class *EEPROM_cls;
    
19. 
    
20. //设计一个全局数据对象
    
21. struct eeprom_24c02r_device
    
22. {
    
23. struct cdev cdev;
    
24. struct i2c_client *client; //记录匹配成功后的i2c client
    
25. };
    
26. 
    
27. struct eeprom_24c02r_device *eeprom_dev;
    
28. 
    
29. int eeprom_i2c_send(struct i2c_client *client, char *buf, int count)
    
30. {
    
31. int ret = 0;
    
32. struct i2c_adapter *adapter = client->adapter;
    
33. struct i2c_msg msg;
    
34. 
    
35. msg.addr = client->addr; //消息包是发送给哪个从设备
    
36. msg.buf = buf;    //传送的数据
    
37. msg.flags = 0;    //是发送数据还是接收数据
    
38. msg.len = count;   //数据的个数
    
39. 
    
40. //参数1---i2c控制器对象---来自于client
    
41. //参数2---统一的数据包
    
42. //参数3---数据包的个数
    
43. //返回值已经正确传输数据的个数
    
44. ret = i2c_transfer(adapter, &msg, 1);
    
45. return 0;
    
46. }
    
47. 
    
48. int eeprom_i2c_recv(struct i2c_client *client, char *buf, int count)
    
49. {
    
50. int ret = 0;
    
51. struct i2c_adapter *adapter = client->adapter;
    
52. struct i2c_msg msg;
    
53. 
    
54. msg.addr = client->addr; //消息包是发送给哪个从设备
    
55. msg.buf = buf;    //传送的数据
    
56. msg.flags = 1;    //是发送数据还是接收数据
    
57. msg.len = count;   //数据的个数
    
58. 
    
59. //参数1---i2c控制器对象---来自于client
    
60. //参数2---统一的数据包
    
61. //参数3---数据包的个数
    
62. //返回值已经正确传输数据的个数
    
63. ret = i2c_transfer(adapter, &msg, 1);
    
64. return 0;
    
65. }
    
66. 
    
67. ssize_t eeprom_24c02r_read(struct file *filp, char __user *buf, size_t count, loff_t *fops)
    
68. {
    
69. int ret = 0;
    
70. char *temp_buf = kzalloc(count, GFP_KERNEL);
    
71. 
    
72. //先从从设备读取数据
    
73. ret = eeprom_i2c_recv(eeprom_dev->client, temp_buf, count);
    
74. printk("Successful packet acquisition ret = %d\n", ret);
    
75. if (ret < 0)
    
76. {
    
77.   printk("eeprom i2c recv error!\n");
    
78.   return -1;
    
79. }
    
80. 
    
81. //将数据传输到应用层
    
82. ret = copy_to_user(buf, temp_buf, count);
    
83. if (ret > 0)
    
84. {
    
85.   printk("copy to user error!\n");
    
86.   return -EFAULT;
    
87. }
    
88. 
    
89. kfree(temp_buf);
    
90. 
    
91. return count;
    
92. }
    
93. 
    
94. ssize_t eeprom_24c02r_write(struct file *filp, const char __user *buf, size_t count, loff_t *fops)
    
95. {
    
96. int ret = 0;
    
97. char *temp_buf = kzalloc(count, GFP_KERNEL);
    
98. 
    
99. //先从应用层获取数据
    
100. ret = copy_from_user(temp_buf, buf, count);
     
101. if (ret > 0)
     
102. {
     
103.   printk("copy from user error!\n");
     
104.   return -EFAULT;
     
105. }
     
106. 
     
107. //将数据发送到底层
     
108. ret = eeprom_i2c_send(eeprom_dev->client, temp_buf, count);
     
109. printk("Successful packet acquisition ret = %d\n", ret);
     
110. if (ret < 0)
     
111. {
     
112.   printk("eeprom i2c send error!\n");
     
113.   return -1;
     
114. }
     
115. 
     
116. kfree(temp_buf);
     
117. 
     
118. return count;
     
119. }
     
120. 
     
121. const struct file_operations eeprom_fops = {
     
122. .owner = THIS_MODULE,
     
123. .read = eeprom_24c02r_read,
     
124. .write = eeprom_24c02r_write,
     
125. };
     
126. 
     
127. //驱动匹配到硬件后自动进入probe函数
     
128. int eeprom_24c02r_probe(struct i2c_client *client, const struct i2c_device_id *id)
     
129. {
     
130. int ret = 0;
     
131. //通过手动分配，组合主次设备号
     
132. dev_t devno = MKDEV(EEPROM_MAJOR, EEPROM_MINOR);
     
133. 
     
134. //给全局数据分配空间
     
135. eeprom_dev = kzalloc(sizeof(*eeprom_dev), GFP_KERNEL);
     
136. if (eeprom_dev == NULL)
     
137. {
     
138.   printk("error,Failed to allocate eeprom_dev space!\n");
     
139.   return -1;
     
140. }
     
141. 
     
142. //记录i2c匹配成功的client
     
143. eeprom_dev->client = client;
     
144. 
     
145. //注册字符设备
     
146. //参数一：注册的主设备
     
147. //参数二：注册的设备共有多少次设备号
     
148. //参数三：设备名字，在/proc/devices显示
     
149. ret = register_chrdev_region(devno, 1, "eeprom_24c02r");
     
150. if (ret < 0)
     
151. {
     
152.   printk("register chrdev region error!\n");
     
153.   return 0;
     
154. }
     
155. 
     
156. //初始化字符设备
     
157. cdev_init(&eeprom_dev->cdev, &eeprom_fops);
     
158. eeprom_dev->cdev.owner = THIS_MODULE;
     
159. //创建类
     
160. EEPROM_cls = class_create(THIS_MODULE, "EEPROM_class");
     
161. //创建设备
     
162. device_create(EEPROM_cls, NULL, devno, NULL, "EEPROM_device%d", 0);
     
163. 
     
164. //向系统注册一个设备
     
165. cdev_add(&eeprom_dev->cdev, devno, 1);
     
166. if (ret < 0)
     
167. {
     
168.   printk("cdev add faile!\n");
     
169.   return -1;
     
170. }
     
171. printk("Test Success!\n");
     
172. return 0;
     
173. }
     
174. 
     
175. int eeprom_24c02r_remove(struct i2c_client *clinet)
     
176. {
     
177. dev_t devno = MKDEV(EEPROM_MAJOR, EEPROM_MINOR);
     
178. cdev_del(&eeprom_dev->cdev);
     
179. //删除设备
     
180. device_destroy(EEPROM_cls, devno);
     
181. //删除类
     
182. class_destroy(EEPROM_cls);
     
183. unregister_chrdev_region(devno, 1);
     
184. kfree(eeprom_dev);
     
185. return 0;
     
186. }
     
187. 
     
188. //用于驱动从设备树中匹配相应的硬件
     
189. const struct of_device_id of_eeprom_24c02r[] = {
     
190. {.compatible = "atmel,24c02"},
     
191. };
     
192. 
     
193. //构建i2c driver
     
194. struct i2c_driver eeprom_24c02r_drv = {
     
195. .driver = {
     
196.   .owner = THIS_MODULE,
     
197.   .name = "eeprom_24c02r",       //体现在/sys/bus/i2c/driver/eeprom_24c02r_drv
     
198.   .of_match_table = of_match_ptr(of_eeprom_24c02r) //从设备树中根据compatible获取相应的硬件信息
     
199. },
     
200. .probe = eeprom_24c02r_probe,
     
201. .remove = eeprom_24c02r_remove,
     
202. };
     
203. 
     
204. //实现装载入口函数
     
205. static __init int eeprom_24c02r_drv_init(void)
     
206. {
     
207. //构建i2c设备，并注册到i2c总线上
     
208. return i2c_add_driver(&eeprom_24c02r_drv);
     
209. }
     
210. 
     
211. //实现卸载入口函数
     
212. static __exit void eeprom_24c02r_drv_exit(void)
     
213. {
     
214. i2c_del_driver(&eeprom_24c02r_drv);
     
215. }
     
216. 
     
217. //声明装载入口函数和卸载入口函数
     
218. module_init(eeprom_24c02r_drv_init);
     
219. module_exit(eeprom_24c02r_drv_exit);
     
220. //添加GPL协议
     
221. MODULE_LICENSE("GPL");
     
222. MODULE_AUTHOR("msxbo");

复制代码

5.3 应用程序分析

1. #include <linux/i2c-dev.h>
   
2. #include <sys/types.h>
   
3. #include <sys/stat.h>
   
4. #include <fcntl.h>
   
5. #include <stdlib.h>
   
6. #include <stdio.h>
   
7. #include <sys/ioctl.h>
   
8. #include <fcntl.h>
   
9. #include <string.h>
   
10. #include <stdlib.h>
    
11. #include <unistd.h>
    
12. 
    
13. //当执行app文件时没有带参数产生提示
    
14. void print_usage(char *str)
    
15. {
    
16. printf("%s r     : read at24c02 addresss 0x100\n", str);
    
17. printf("%s w val : write at24c02 addresss 0x100\n", str);
    
18. }
    
19. 
    
20. int main(int argc, char *argv[])
    
21. {
    
22. int i;
    
23. int fd;
    
24. unsigned char val; //字节
    
25. 
    
26. unsigned int register_addr = 0x100; //片内地址
    
27. 
    
28. //存储读写数据的数组
    
29. char wbuf[9] = {0};
    
30. char rbuf[8] = {0};
    
31. 
    
32. //判读执行文件时是否带有一个以上的参数，没有则提示
    
33. if (argc < 2)
    
34. {
    
35.   print_usage(argv[0]);
    
36.   exit(1);
    
37. }
    
38. 
    
39. /*打开设备文件*/
    
40. fd = open("/dev/EEPROM_device0", O_RDWR);
    
41. if (fd < 0)
    
42. {
    
43.   perror("open failed");
    
44.   exit(1);
    
45. }
    
46. 
    
47. if (strcmp(argv[1], "r") == 0)
    
48. {
    
49.   //确定读哪个位置，读操作时先写片内地址
    
50.   if (write(fd, &register_addr, 1) < 1)
    
51.   {
    
52.    perror("write failed");
    
53.    exit(1);
    
54.   }
    
55. 
    
56.   //将EEPROM中的数据读到rbuf中
    
57.   if (read(fd, rbuf, 8) < 0)
    
58.   {
    
59.    perror("read failed");
    
60.    exit(1);
    
61.   }
    
62.   else
    
63.   {
    
64.    for (i = 0; i < 8; i++)
    
65.    {
    
66.     printf("rbuf[%d] = 0x%c ", i, rbuf[i]);
    
67.     if (i == 3)
    
68.      printf("\n");
    
69.    }
    
70.    printf("\n");
    
71.   }
    
72. }
    
73. else if ((strcmp(argv[1], "w") == 0) && (argc == 3))
    
74. {
    
75.   char num[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    
76.   int x = strtoul(argv[2], NULL, 0);
    
77.   if (x < 0 || x > 15)
    
78.   {
    
79.    perror("write overflow");
    
80.    close(fd);
    
81.    exit(1);
    
82.   }
    
83.   else
    
84.    val = num[x];
    
85. 
    
86.   //先写片内地址
    
87.   wbuf[0] = register_addr; // 片内地址0x08
    
88.   wbuf[1] = val;
    
89.   printf("val=%d\n", wbuf[1]);
    
90. 
    
91.   for (i = 2; i < 9; i++)
    
92.    wbuf[i] = '9';
    
93. 
    
94.   //连续向fd文件中写入8个8字符
    
95.   if (write(fd, wbuf, 9) < 0)
    
96.   {
    
97.    perror("write failed");
    
98.    close(fd);
    
99.    exit(1);
    
100.   }
     
101. 
     
102.   printf("write data ok!\n");
     
103. }
     
104. 
     
105. close(fd);
     
106. return 0;
     
107. }

复制代码

6 程序编译

详细的程序编译部分可以参考第一章程序编译部分。将编译好的文件上传至开发板。

6.1 Makefile文件分析

1. #已经编译过的内核源码路径
   
2. KERNEL_DIR = /home/uisrc/uisrc-lab-xlnx/sources/kernel
   
3. 
   
4. export ARCH=arm
   
5. export CROSS_COMPILE=arm-linux-gnueabihf-
   
6. 
   
7. #当前路径
   
8. CURRENT_DIR = $(shell pwd)
   
9. 
   
10. MODULE =  eeprom_24c02r_drv
    
11. APP = eeprom_24c02r_app
    
12. 
    
13. all :
    
14. #进入并调用内核源码目录中Makefile的规则, 将当前的目录中的源码编译成模块
    
15. make -C $(KERNEL_DIR) M=$(CURRENT_DIR) modules
    
16. rm -rf *.mod.c *.mod.o *.o *.symvers *.order
    
17. 
    
18. ifneq ($(APP), )
    
19. $(CROSS_COMPILE)gcc $(APP).c -o $(APP)
    
20. endif
    
21. 
    
22. clean :
    
23. make -C $(KERNEL_DIR) M=$(CURRENT_DIR) clean
    
24. rm -rf $(APP) *.tmp
    
25. 
    
26. #指定编译哪个文件
    
27. obj-m += $(MODULE).o

复制代码

第10行，和第11行需要根据自己编写的驱动文件名进行修改，其他的部分与之前的一致。

7 演示

7.1 硬件准备

SD2.0 启动 01 而模式开关为 ON OFF（7100 需要先将系统烧录进qspi，然后才能从qspi启动sd卡，“[米联客-XILINX-H3_CZ08_7100] LINUX基础篇连载-04 从vitis移植Ubuntu实现二次开发”）

将 PS 端串口线连接电脑，如果要使用 ssh 登录，将网口线同样连接至电脑，最后给开发板通电。每次重新上电，需要重新插拔 PS 串口，否则会登录失败。

接入12V直流电源开机。

7.2 程序准备

将驱动与程序上传至开发板，查看文件是否传输成功。

在终端输入“ls”命令。确认当前所需文件，已经被上传到当前的文件夹内了。

在管理员权限下，终端输入“chmod +x eeprom_24c02r”，改变应用程序的权限。

然后在root 状态下 insmod 安装驱动。“lsmod”查看当前安装的驱动。

通过以上操作可以确定应用程序，与驱动均已准备完成。

7.3 实验结果

在终端输入“./eeprom_24c02r_app r”，输出如下。可以看到，该应用程序读取了eeprom中前8个字节的内容。

再在终端输入“./eeprom_24c02r_app w 0xA”，输出如下。可以看到，读取的第一个字节的位置的0x1，已经被写入的修改了，变为了0xA。

测试成功。