设为首页 收藏本站
问答 店铺
热搜: ZYNQ FPGA discuz

QQ登录

只需一步，快速开始

微信登录

微信扫码，快速开始

FPGA+AI数字世界»FPGA|AI社区 › 教程-FPGA › FPGA教程-AMD ›
微信扫一扫 分享朋友圈

已有 1143 人浏览分享

开启左侧

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

[复制链接]
1143 0
AMD-FPGA课程
AMD课程: 08-KU实验 »
软件版本：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"

  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实现二次开发”）
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
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

LINUX课程
新手上路

0

关注

0

粉丝

43

主题
精彩推荐
热门资讯
    网友晒图
      图文推荐
        

        • 微信公众平台

        • 扫描访问手机版