[X]关闭
搜索

[米联客-XILINX-H3_CZ08_7100] LINUX驱动篇连载-19 PL 自定义AXI-Lite-PWM

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

软件版本：vitis2021.1(vivado2021.1)
操作系统：WIN10 64bit
硬件平台：适用XILINX Z7/ZU系列FPGA
登录“米联客”FPGA社区-www.uisrc.com视频课程、答疑解惑！
1 概述
本课就以AXI-Lite总线实现PWM(Pulse Width Modulation，脉冲宽度调制)自定义IP作为验证AXI-Lite总线应用的方案，实现2路PWM，通过点亮LED观察效果，带领大家快速进入实战状态。
本文实验目的：
  • 设计一个简单的PWM发生器，并且通过AXI-LITE-SLAVE寄存器实现频率调整、占空比调整
  • 通过VITIS-SDK实现对自定义IP中寄存器的读写访问
2 系统框图
image.jpg
3 创建IP
3.1 利用模板创建AXI-Lite IP
1:打开VIVADO软件，新建一个工程
2:单击ToolsàCreate and Package NEW IP，单击Next。
3:由于需要挂在到总线上，因此创建一个带AXI总线的用户IP，选择Create a new AXI4 peripheral，单击Next。
image.jpg
4:输入要创建的IP名字，此处命名为PWM_LITE_ML，选择保存路径,单击Next。
image.jpg
5:NameàS00_AXI；
Interface Type(接口类型)àLite；
Data Width(Bits)(数据位宽)à32位；
Number of  Registers(寄存器数量)à8 ；单击next。
image.jpg
设置总线形式为Lite总线，Lite总线是简化的AXI总线，消耗的资源少，当然性能比完整版的AXI总线差一点。因为频率要求不高，因此采用Lite总线就够了。设置寄存器数量为8，因为后面我们需要用到8个寄存器。
6:选择Edit IP，单击Finish完成
image.jpg
3.2 修改IP源码
IP创建后，需要对其进行修改，建立我们能够实际使用的IP。
1:打开PWM_LITE_ML_v1_0.v文件。
image.jpg
修改如下：
1、添加PWM_o端口
image.jpg           修改为                image.jpg
2、添加端口
   image.jpg                       修改为                image.jpg
2:打开PWM_LITE_ML_v1_0_S00_AXI.v文件。
image.jpg
修改如下：
1、添加PWM_o端口(注意录制的视频教程接口PWM_o名字改为了PWM)
   image.jpg 修改为       image.jpg
2、添加PWM.v的端口
image.jpg
修改为
image.jpg
说明：slv_reg0-slv_reg7为PS部分写入PL的寄存器。通过这8个寄存器的值，我们可以控制PWM的占空比。
下面这段代码就是PS写PL部分的寄存器，一共有8个寄存器。
        always @( posedge S_AXI_ACLK )
        begin
          if ( S_AXI_ARESETN == 1'b0 )
            begin
              slv_reg0 <= 0;
              slv_reg1 <= 0;
              slv_reg2 <= 0;
              slv_reg3 <= 0;
              slv_reg4 <= 0;
              slv_reg5 <= 0;
              slv_reg6 <= 0;
              slv_reg7 <= 0;
            end
          else begin
            if (slv_reg_wren)
              begin
                case ( axi_awaddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )
                  3'h0:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 0
                        slv_reg0[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h1:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 1
                        slv_reg1[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h2:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 2
                        slv_reg2[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h3:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 3
                        slv_reg3[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h4:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 4
                        slv_reg4[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h5:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 5
                        slv_reg5[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h6:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 6
                        slv_reg6[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  3'h7:
                    for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
                      if ( S_AXI_WSTRB[byte_index] == 1 ) begin
                        // Respective byte enables are asserted as per write strobes
                        // Slave register 7
                        slv_reg7[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
                      end  
                  default : begin
                              slv_reg0 <= slv_reg0;
                              slv_reg1 <= slv_reg1;
                              slv_reg2 <= slv_reg2;
                              slv_reg3 <= slv_reg3;
                              slv_reg4 <= slv_reg4;
                              slv_reg5 <= slv_reg5;
                              slv_reg6 <= slv_reg6;
                              slv_reg7 <= slv_reg7;
                            end
                endcase
              end
          end
        end     
3:新建一个PWM.v 文件实现PWM输出。
module PWM(
input clk,
input rst_n,
input [31:0]fre_set,
input [31:0]wav_set,
output  PWM_o
);
reg [31:0]fre_cnt;
always @(posedge clk)begin
        if(rst_n==1'b0)begin
                fre_cnt <=32'd0;
        end
        else begin
                if(fre_cnt<fre_set) begin
                        fre_cnt <= fre_cnt+1'b1;
                end
                else begin
                        fre_cnt<=32'd0;
                end
        end
end
assign PWM_o = (wav_set>fre_cnt);
endmodule
4:进一步修改。去掉“_v1_0”。
1、PWM_LITE_ML_v1_0_S00_AXI.v中：
module PWM_LITE_ML_v1_0_S00_AXI #修改为àmodule PWM_LITE_ML_S00_AXI #
image.jpg     修改为            image.jpg
2、PWM_LITE_ML_v1_0.v中：
module PWM_LITE_ML_v1_0 #     修改为àmodule PWM_LITE_ML #
image.jpg                             修改后    image.jpg
PWM_LITE_ML_v1_0_S00_AXI #  修改为àPWM_LITE_ML_S00_AXI #
PWM_LITE_ML_v1_0_S00_AXI_inst 修改为àPWM_LITE_ML_S00_AXI_inst
image.jpg        修改后   image.jpg
5:修改后，保存。出现如下界面，选择Automatically pick new top module。
image.jpg
6:重新封装。选择ToolsCreat and Pakage New IP，单击Next。
7:选择Package your current project，单击Next。
image.jpg
image.jpg
8:选择Overwrite。
9:选择Package IPRewiew and Package Re-Package IP。完成创建自定义IP。
4 硬件电路分析
这里PWM输出的IO引出到LED上，调整PWM的占空比可以实现LED的亮度调节。
image.jpg
5 搭建SOC系统工程
详细的搭建过程这里不再重复，对于初学读者如果还不清楚如何创建SOC工程的，请学习“01Vitis Soc开发入门”这篇文章。
5.1 SOC系统工程
image.jpg
1:中断设置
本实验可以不设置中断
image.jpg
2:设置GP Master接口
image.jpg
3:设置复位输出
image.jpg
4:设置PL时钟
image.jpg
5:添加自定义IP
设置自定义IP路径，并且添加IP
image.jpg
5.2 设置AXI外设地址分配
只要添加的AXI总线外设都要正确分配地址,这一步不能遗漏
image.jpg
5.3 编译并导出平台文件
以下步骤简写，有不清楚的看Linux基础篇第四章。
1:打开soc_prj内工程。
2:生成Bit文件。
3:导出到硬件: FileàExport HardwareàInclude bitstream
4:导出完成后，对应工程路径的soc_hw路径下有硬件平台文件：system_wrapper.xsa的文件。根据硬件平台文件system_wrapper.xsa来创建需要Platform平台。
image.jpg
5：打开vitis，并添加设备树模板，不清楚请参考Linux基础篇第四章。
6：创建工程文件，选择device tree创建，创建完成后编译工程。
7：获得设备树以及启动文件，打开虚拟机将文件拷贝到开发包的指定位置。
5.4 设备树修改及驱动编译
1：设备树修改
本章vitis会生成pl端的设备树，需要手动添加。另外soc_dts内有写好的设备树，新手请不要自行修改，直接使用教程提供的设备树。设备树的修改如下：
image.jpg
这次直接使用vitis生成的设备树来写驱动，所以不对生成的设备树进行修改。
2：编译系统
拷贝上一步写好的设备树到指定路径，拷贝其他文件后，编译uboot，编译kernel，制作镜像并烧录系统。具体步骤参考Linux基础篇第四章。
3：编译驱动
将对应的demo拷贝至/home/uisrc下，同时确保/home/uisrc下有软件开发包uisrc-lab-xlnx。
1725955370490.jpg
进入demo的路径，使用make编译驱动。
image.jpg
其中.ko结尾的文件为我们编译出来的驱动。
4：拷贝程序
将对应的文件拷贝至sd卡上：
image.jpg
6 程序分析
这个驱动需要根据设备树来编写驱动，所以采用了一个比较熟悉的开发模式，即基于设备树的平台驱动开发。
  1. #include <linux/ide.h>
  2. #include <linux/module.h>
  3. #include <linux/of_platform.h>
  4. #include <linux/gpio.h>
  5. #include <linux/delay.h>

  7. #define ZYNQMP_GPIO_NR_GPIOS 118
  8. #define MIO_PIN_51 (ARCH_NR_GPIOS - ZYNQMP_GPIO_NR_GPIOS + 51)
  9. // #define MIO_PIN_42 (ARCH_NR_GPIOS - ZYNQMP_GPIO_NR_GPIOS + 42)

  11. struct AxiPWM
  12. {
  13. int addr_width;
  14. int data_width;
  15. struct device_node *dev_node;
  16. int reg_num;
  17. unsigned int *reg_value;
  18. };
  19. struct AxiPWM *AxiPWM_data;

  21. static unsigned int *pwm0_fre = NULL;
  22. static unsigned int *pwm0_wav = NULL;
  23. static unsigned int *pwm1_fre = NULL;
  24. static unsigned int *pwm1_wav = NULL;
  25. static unsigned int *pwm2_fre = NULL;
  26. static unsigned int *pwm2_wav = NULL;
  27. static unsigned int *pwm3_fre = NULL;
  28. static unsigned int *pwm3_wav = NULL;

  30. static struct of_device_id AxiPWM_of_match[] = {
  31. {.compatible = "xlnx,PWM-LITE-ML-1.0"},
  32. {},
  33. };

  35. int of_AxiPWM_data(struct AxiPWM *pdata, struct platform_device *pdev)
  36. {
  37. struct device_node *np = pdev->dev.of_node;
  38. int ret = 0;

  40. pdata->reg_num = of_property_count_elems_of_size(np, "reg", sizeof(int));
  41. if (pdata->reg_num < 0)
  42. {
  43.   dev_err(&pdev->dev, "get reg_num failed\n");
  44.   return ret;
  45. }

  47. pdata->reg_value = (unsigned int *)kmalloc(sizeof(unsigned int) * pdata->reg_num, GFP_KERNEL);
  48. if (!pdata->reg_value)
  49. {
  50.   kfree(pdata->reg_value);
  51.   dev_err(&pdev->dev, "kmalloc failed\n");
  52.   return -1;
  53. }
  54. ret = of_property_read_u32_array(np, "reg", pdata->reg_value, pdata->reg_num);
  55. if (ret != 0)
  56. {
  57.   kfree(pdata->reg_value);
  58.   dev_err(&pdev->dev, "get reg failed\n");
  59.   return ret;
  60. }

  62. ret = of_property_read_u32(np, "xlnx,s00-axi-addr-width", &pdata->addr_width);
  63. if (ret < 0)
  64. {
  65.   dev_err(&pdev->dev, "get addr_width failed\n");
  66.   return ret;
  67. }

  69. ret = of_property_read_u32(np, "xlnx,s00-axi-data-width", &pdata->data_width);
  70. if (ret < 0)
  71. {
  72.   dev_err(&pdev->dev, "get data_width failed\n");
  73.   return ret;
  74. }

  76. return 0;
  77. }

  79. static int AxiPWM_probe(struct platform_device *pdev)
  80. {
  81. int ret = 0;
  82. int i = 0;

  84. struct device *dev = &pdev->dev;
  85. struct AxiPWM *pdata = dev_get_platdata(dev);
  86. if (!pdata)
  87. {
  88.   pdata = devm_kzalloc(dev, sizeof(struct AxiPWM), GFP_KERNEL);
  89.   if (!pdata)
  90.    return -ENOMEM;

  92.   platform_set_drvdata(pdev, pdata);
  93. }
  94. ret = of_AxiPWM_data(pdata, pdev);
  95. AxiPWM_data = pdata;

  97. // 打印属性值
  98. printk("addr_width = %d\r\n", AxiPWM_data->addr_width);
  99. printk("data_width = %d\r\n", AxiPWM_data->data_width);
  100. printk("reg_num = %d\r\n", AxiPWM_data->reg_num);
  101. for (i = 0; i < AxiPWM_data->reg_num; i += 2)
  102. {
  103.   printk("reg = %#X  %#X \r\n", AxiPWM_data->reg_value[i], AxiPWM_data->reg_value[i + 1]);
  104. }

  106. pwm0_fre = ioremap(AxiPWM_data->reg_value[0] + 4 * 0, 4);
  107. pwm0_wav = ioremap(AxiPWM_data->reg_value[0] + 4 * 1, 4);
  108. pwm1_fre = ioremap(AxiPWM_data->reg_value[0] + 4 * 2, 4);
  109. pwm1_wav = ioremap(AxiPWM_data->reg_value[0] + 4 * 3, 4);
  110. pwm2_fre = ioremap(AxiPWM_data->reg_value[0] + 4 * 4, 4);
  111. pwm2_wav = ioremap(AxiPWM_data->reg_value[0] + 4 * 5, 4);
  112. pwm3_fre = ioremap(AxiPWM_data->reg_value[0] + 4 * 6, 4);
  113. pwm3_wav = ioremap(AxiPWM_data->reg_value[0] + 4 * 7, 4);
  114. printk("ioremap is done!\r\n");

  116. writel(0x63, pwm0_fre);
  117. writel(0x63, pwm1_fre);
  118. // writel(0x63, pwm2_fre);
  119. // writel(0x63, pwm3_fre);
  120. printk("writel is done!\r\n");

  122. ret = gpio_request(MIO_PIN_51, "led0");
  123. if (ret < 0)
  124. {
  125.   printk("gpio request led0 error!\n");
  126.   return ret;
  127. }
  128. // ret = gpio_request(MIO_PIN_42, "led1");
  129. // if (ret < 0)
  130. // {
  131. //  printk("gpio request led1 error!\n");
  132. //  return ret;
  133. // }
  134. ret = gpio_direction_output(MIO_PIN_51, 0);
  135. if (ret != 0)
  136. {
  137.   printk("gpio direction input MIO_PIN_51 fail!\n");
  138. }
  139. // ret = gpio_direction_output(MIO_PIN_42, 0);
  140. // if (ret != 0)
  141. // {
  142. //  printk("gpio direction input MIO_PIN_42 fail!\n");
  143. // }
  144. gpio_set_value(MIO_PIN_51, 0);
  145. // gpio_set_value(MIO_PIN_42, 0);

  147. for (i = 0; i <= 600; i++)
  148. {
  149.   writel(i % 200 < 100 ? i % 200 : 200 - i % 200, pwm0_wav);
  150.   writel(i % 200 < 100 ? i % 200 : 200 - i % 200, pwm1_wav);
  151.   // printk("%d\n",readl(pwm0_wav));
  152.   msleep(20);
  153. }

  155. return ret;
  156. }

  158. static int AxiPWM_remove(struct platform_device *pdev)
  159. {
  160. gpio_free(MIO_PIN_51);
  161. // gpio_free(MIO_PIN_42);
  162. kfree(AxiPWM_data->reg_value);
  163. iounmap(pwm0_fre);
  164. iounmap(pwm0_wav);
  165. iounmap(pwm1_fre);
  166. iounmap(pwm1_wav);
  167. iounmap(pwm2_fre);
  168. iounmap(pwm2_wav);
  169. iounmap(pwm3_fre);
  170. iounmap(pwm3_wav);
  171. return 0;
  172. }

  174. static struct platform_driver AxiPWM_device_driver = {
  175. .driver = {
  176.   .name = "AxiPWM",
  177.   .owner = THIS_MODULE,
  178.   .of_match_table = of_match_ptr(AxiPWM_of_match),
  179. },
  180. .probe = AxiPWM_probe,
  181. .remove = AxiPWM_remove,
  182. };

  184. static int __init AxiPWM_init(void)
  185. {
  186. return platform_driver_register(&AxiPWM_device_driver);
  187. }

  189. static void __exit AxiPWM_exit(void)
  190. {
  191. platform_driver_unregister(&AxiPWM_device_driver);
  192. }

  194. late_initcall(AxiPWM_init);
  195. module_exit(AxiPWM_exit);

  197. MODULE_LICENSE("GPL");
  198. MODULE_AUTHOR("uisrc");
复制代码
这里依旧使用的基于设备树的平台驱动进行开发，改动主要在probe函数部分。
行7~9，定义了ps端两个led灯的gpio标号，目的是为了后面关闭ps灯让pl的灯看起来更清楚。
行21~28，定义了四组pwm寄存器，fre为pwm的频率，wav为pwm的占空比。
行106~113，映射4组共8个寄存器。
行115~118，设置4个pwm寄存器的频率为99。
行120~143，使用GPIO子系统关闭ps端的灯，方便观察pl的led灯。
行145~150，设置了三组呼吸灯，单次2s，共计6s。
7 演示结果
SD2.0 启动 01 而模式开关为 ON OFF（7100 需要先将系统烧录进qspi，然后才能从qspi启动sd卡，参考Linux基础篇第四章）
2f5038eb9880afd532753935815b079.jpg
将 PS 端串口线连接电脑，如果要使用 ssh 登录，将网口线同样连接至电脑，最后给开发板通电。每次重新上电，需要重新插拔 PS 串口，否则会登录失败。
image.jpg
接入12V直流电源开机。
找到刚才放驱动的目录：
image.jpg
使用sudo insmod axipwm.ko命令装载驱动，密码为root：
image.jpg
可以看到板子上的pl区域灯变成了呼吸灯。
回复

使用道具 举报

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

本版积分规则

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