[X]关闭
搜索

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

文档创建者：LINUX课程
浏览次数：246
最后更新：2024-09-10
文档课程分类-AMD-ZYNQ
AMD-ZYNQ: ZYNQ-SOC » 2_LINUX应用开发
本帖最后由 LINUX课程 于 2024-9-11 10:38 编辑

软件版本：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.jpg
3 介绍
3.1 AXI-IIC IP介绍
AXI-IIC控制器的功能构架图如下：
image.jpg
3.2 特性
-符合行业标准I2C协议
-通过axis4 - lite接口访问
-支持I2C主或从模式
-支持多主机操作
-软件可选择ACK位
-仲裁丢失中断并自动从主模式切换从模式
-寻址地址识别中断并自动从主模式到从模式
-起始位和停止位的产生和侦测
-重复起始位的产生
-ACK的产生和侦测
-总线忙检测
-支持1MHZ 、400KHZ 、100KHZ 工作时钟
-7位或10位寻址
-寻址使能和禁止
- 16字节深度的FIFO
-节流功能
-动态生成启动和停止
3.3 寄存器概述
image.jpg
3.4 硬件电路分析
本实验只测试EEPROM
image.jpg
4 工程搭建
该部分生成的文件已经分别保存在“BOOT”文件夹内，可以直接使用。如果想要自己生成，按照下面步骤。
4.1 vivado工程搭建
详细的vivado工程搭建参考第一章，本章的vivado工程并非默认的vivado工程，请选择在该章目录中的vivado工程。
打开“soc_prj”文件夹。
image.jpg
进入vivado工程打开IP，查看IP是否连接正确。
image.jpg
4.2 设备树文件
打开vitis，导入之前生成的xsa文件，生成设备树。详细过程参考第一章vivado工程搭建部分。
image.jpg
将pl.dsti部分的设备树文件拷贝进“附件”文件夹“soc_dts”中的dts文件中。或者可以直接使用“22.axi_iic”文件夹中有已经完成了的设备树文件。
4.3 设置内核配置
由于我们自己写的驱动程序会和已有驱动冲突，因此我们需要先将kernel内的驱动去掉。
image.jpg
首先，使用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"

  4. / {
  5. model = "Zynq MZ7X Development Board";
  6. compatible = "xlnx,zynq-MZ7X", "xlnx,zynq-7000";

  8. aliases {
  9.   ethernet0 = &gem0;
  10.   serial0 = &uart1;
  11.   spi0 = &qspi;
  12.   i2c0 = &axi_iic_0;
  13.   mmc0 = &sdhci0;
  14.   mmc1 = &sdhci1;
  15. };

  17. memory@0 {
  18.   device_type = "memory";
  19.   reg = <0x0 0x40000000>;
  20. };

  22. chosen {
  23.   bootargs = "";
  24.   stdout-path = "serial0:115200n8";
  25. };

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

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

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

  62. // rtc@68 {
  63. //  compatible = "dallas,ds1337";
  64. //  reg = <0x68>;
  65. // };

  67. eeprom@50 {
  68.   compatible = "atmel,24c02";
  69.   /* compatible = "at24,24c02"; */
  70.   reg = <0x50>;
  71. };
  72. };

  74. &gem0 {
  75. status = "okay";
  76. phy-mode = "rgmii-id";
  77. xlnx,ptp-enet-clock = <0x69f6bcb>;
  78. phy-handle = <&ethernet_phy>;

  80. ethernet_phy: ethernet-phy@0 {
  81.   reg = <0>;
  82.   device_type = "ethernet-phy";
  83. };
  84. };

  86. &gpio0 {
  87. emio-gpio-width = <64>;
  88. gpio-mask-high = <0x0>;
  89. gpio-mask-low = <0x5600>;
  90. };

  92. &intc {
  93. num_cpus = <2>;
  94. num_interrupts = <96>;
  95. };

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

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

  119. &sdhci1 {
  120. status = "okay";
  121. xlnx,has-cd = <0x1>;
  122. xlnx,has-power = <0x0>;
  123. xlnx,has-wp = <0x1>;
  124. };

  126. &uart1 {
  127. u-boot,dm-pre-reloc;
  128. status = "okay";
  129. };

  131. &usb0 {
  132. status = "okay";
  133. dr_mode = "host";
  134. usb-phy = <&usb_phy0>;
  135. usb-reset = <&gpio0 46 0>;
  136. };

  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>

  15. #define EEPROM_MAJOR 400
  16. #define EEPROM_MINOR 0

  18. static struct class *EEPROM_cls;

  20. //设计一个全局数据对象
  21. struct eeprom_24c02r_device
  22. {
  23. struct cdev cdev;
  24. struct i2c_client *client; //记录匹配成功后的i2c client
  25. };

  27. struct eeprom_24c02r_device *eeprom_dev;

  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;

  35. msg.addr = client->addr; //消息包是发送给哪个从设备
  36. msg.buf = buf;    //传送的数据
  37. msg.flags = 0;    //是发送数据还是接收数据
  38. msg.len = count;   //数据的个数

  40. //参数1---i2c控制器对象---来自于client
  41. //参数2---统一的数据包
  42. //参数3---数据包的个数
  43. //返回值已经正确传输数据的个数
  44. ret = i2c_transfer(adapter, &msg, 1);
  45. return 0;
  46. }

  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;

  54. msg.addr = client->addr; //消息包是发送给哪个从设备
  55. msg.buf = buf;    //传送的数据
  56. msg.flags = 1;    //是发送数据还是接收数据
  57. msg.len = count;   //数据的个数

  59. //参数1---i2c控制器对象---来自于client
  60. //参数2---统一的数据包
  61. //参数3---数据包的个数
  62. //返回值已经正确传输数据的个数
  63. ret = i2c_transfer(adapter, &msg, 1);
  64. return 0;
  65. }

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

  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. }

  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. }

  89. kfree(temp_buf);

  91. return count;
  92. }

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

  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. }

  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. }

  116. kfree(temp_buf);

  118. return count;
  119. }

  121. const struct file_operations eeprom_fops = {
  122. .owner = THIS_MODULE,
  123. .read = eeprom_24c02r_read,
  124. .write = eeprom_24c02r_write,
  125. };

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

  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. }

  142. //记录i2c匹配成功的client
  143. eeprom_dev->client = client;

  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. }

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

  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. }

  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. }

  188. //用于驱动从设备树中匹配相应的硬件
  189. const struct of_device_id of_eeprom_24c02r[] = {
  190. {.compatible = "atmel,24c02"},
  191. };

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

  204. //实现装载入口函数
  205. static __init int eeprom_24c02r_drv_init(void)
  206. {
  207. //构建i2c设备，并注册到i2c总线上
  208. return i2c_add_driver(&eeprom_24c02r_drv);
  209. }

  211. //实现卸载入口函数
  212. static __exit void eeprom_24c02r_drv_exit(void)
  213. {
  214. i2c_del_driver(&eeprom_24c02r_drv);
  215. }

  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>

  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. }

  20. int main(int argc, char *argv[])
  21. {
  22. int i;
  23. int fd;
  24. unsigned char val; //字节

  26. unsigned int register_addr = 0x100; //片内地址

  28. //存储读写数据的数组
  29. char wbuf[9] = {0};
  30. char rbuf[8] = {0};

  32. //判读执行文件时是否带有一个以上的参数，没有则提示
  33. if (argc < 2)
  34. {
  35.   print_usage(argv[0]);
  36.   exit(1);
  37. }

  39. /*打开设备文件*/
  40. fd = open("/dev/EEPROM_device0", O_RDWR);
  41. if (fd < 0)
  42. {
  43.   perror("open failed");
  44.   exit(1);
  45. }

  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.   }

  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];

  86.   //先写片内地址
  87.   wbuf[0] = register_addr; // 片内地址0x08
  88.   wbuf[1] = val;
  89.   printf("val=%d\n", wbuf[1]);

  91.   for (i = 2; i < 9; i++)
  92.    wbuf[i] = '9';

  94.   //连续向fd文件中写入8个8字符
  95.   if (write(fd, wbuf, 9) < 0)
  96.   {
  97.    perror("write failed");
  98.    close(fd);
  99.    exit(1);
  100.   }

  102.   printf("write data ok!\n");
  103. }

  105. close(fd);
  106. return 0;
  107. }
复制代码
6 程序编译
详细的程序编译部分可以参考第一章程序编译部分。将编译好的文件上传至开发板。
6.1 Makefile文件分析
  1. #已经编译过的内核源码路径
  2. KERNEL_DIR = /home/uisrc/uisrc-lab-xlnx/sources/kernel

  4. export ARCH=arm
  5. export CROSS_COMPILE=arm-linux-gnueabihf-

  7. #当前路径
  8. CURRENT_DIR = $(shell pwd)

  10. MODULE =  eeprom_24c02r_drv
  11. APP = eeprom_24c02r_app

  13. all :
  14. #进入并调用内核源码目录中Makefile的规则, 将当前的目录中的源码编译成模块
  15. make -C $(KERNEL_DIR) M=$(CURRENT_DIR) modules
  16. rm -rf *.mod.c *.mod.o *.o *.symvers *.order

  18. ifneq ($(APP), )
  19. $(CROSS_COMPILE)gcc $(APP).c -o $(APP)
  20. endif

  22. clean :
  23. make -C $(KERNEL_DIR) M=$(CURRENT_DIR) clean
  24. rm -rf $(APP) *.tmp

  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实现二次开发”）
2f5038eb9880afd532753935815b079.jpg
将 PS 端串口线连接电脑，如果要使用 ssh 登录，将网口线同样连接至电脑，最后给开发板通电。每次重新上电，需要重新插拔 PS 串口，否则会登录失败。
image.jpg
接入12V直流电源开机。
7.2 程序准备
将驱动与程序上传至开发板，查看文件是否传输成功。
在终端输入“ls”命令。确认当前所需文件，已经被上传到当前的文件夹内了。
image.jpg
在管理员权限下，终端输入“chmod +x eeprom_24c02r”，改变应用程序的权限。
image.jpg
然后在root 状态下 insmod 安装驱动。“lsmod”查看当前安装的驱动。
image.jpg
通过以上操作可以确定应用程序，与驱动均已准备完成。
7.3 实验结果
在终端输入“./eeprom_24c02r_app r”，输出如下。可以看到，该应用程序读取了eeprom中前8个字节的内容。
image.jpg
再在终端输入“./eeprom_24c02r_app w 0xA”，输出如下。可以看到，读取的第一个字节的位置的0x1，已经被写入的修改了，变为了0xA。
image.jpg
测试成功。
回复

使用道具 举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

XILINX 官网| 站点统计| Archiver| 手机版| 米联客品牌主页|
版权所有 UISRC.COM Copyright © 2023-2026, 常州一二三电子科技有限公司. ( 苏ICP备19046771号-2 ) 站点内容版权归常州一二三电子科技有限公司所有，如侵犯您的权益，请联系客服处理