• ZYNQ7020--动态加载CPU1程序＜1＞

    配合食用“ZYNQ7020--AMP下裸机程序开发 ＜2＞”

    1.实验目标

            CPU0运行petalinux，CPU1运行裸机程序。CPU0启动后，可动态加载CPU1程序。

            测试：通过分别加载两个程序来验证是否成功。

            CPU1共有两个程序：一个控制两路LED灯闪烁，另一个控制两路LED按照0-1-2-3二进制显示。

    2.硬件配置

    • 串口0
    • 网口
    • SD0
    • AXI-GPIO

    详细配置过程参照《Z7-Lite 系列教程 之 Linux 系统篇》第5章和第9章。

    工程文件编译后，导出硬件描述文件至SDK。

    3.PetaLinux端配置

    创建工程

    petalinux-create --type project --template zynq --name ampgpio

     指定工作目录

    petalinux-config --get-hw-description=.

    3.1 工程配置

    主菜单 ---> DTG Settings ---> Kernel Bootargs，取消 generate boot args automatically，手动填入如下信息：

    console=ttyPS0,115200 earlyprintk maxcpus=1

     保存退出

    3.2 内核配置

    主要用于自动初始化下axi-gpio相关内容，配置内核。

    petalinux-config -c kernel

    等待弹窗，此处无需修改配置，直接保存，退出即可。

     3.3 修改设备树

    路径：工程目录 ---> project-spec ---> meta-user ---> recipes-bsp ---> device-tree ---> files ---> system-user.dtsi 添加如下内容：

    1. /include/ "system-conf.dtsi"
    2. / {    
    3.     reserved-memory {
    4.         #address-cells = <1>;
    5.         #size-cells = <1>;
    6.         ranges;
    7.  
    8.         reserved: buffer@0x18000000 {       //512-384 = 128M, 长度 120M
    9.             no-map;
    10.             reg = <0x18000000 0x07800000>;
    11.         };
    12.     };
    13.   
    14.     reserved-driver@0 {
    15.         compatible = "xlnx,reserved-memory";
    16.         memory-region = <&reserved>;
    17.     };
    18.    
    19.     dbox_ipc_dev_instance: dbox_ipc_dev@0 { //112M
    20.         compatible = "dbox,dbox-ipc-dev";
    21.         reg = <0x18000000 0x07000000>;
    22.         ipi12 = <12>;
    23.         ipi13 = <13>;   
    24.     };
    25.  
    26.     usb_phy0:usb_phy0{
    27.         compatible = "ulpi-phy";
    28.         #phy-cells = <0>;
    29.         reg = <0xe0002000 0x1000>;
    30.         view-port = <0x170>;
    31.         drv-vbus;
    32.     };
    33. };
    34.  
    35. &axi_ethernet_0{
    36.     local-mac-address = [B4 A9 FC 80 0A 54];
    37.     phy-handle = <&phy1>;
    38.     xlnx,has-mdio = <0x1>;
    39.     phy-mode = "mii";
    40.  
    41.     mdio{
    42.         #address-cells = <1>;
    43.         #size-cells = <0>;
    44.         phy1:phy@1{
    45.             compatible = "realtek,rtl8201","ethernet-phy-id001c.c816";
    46.             device_type = "ethernet-phy";
    47.             reg = <0>;
    48.         };
    49.     };
    50. };
    51.  
    52. &usb0{
    53.     dr_mode = "host";
    54.     usb-phy = <&usb_phy0>;
    55. };

    reserved-memory 和 reserved-driver： 用于为CPU1保留内存，

    dbox_ipcb_dev_instance：是基于xilinx官方remotporc AMP程序，网上的一个简化版，网址如下：

    zynq7000 AMP双核IPC+SharedMem通信_Donce Jiang的博客-CSDN博客_zynq7000 双核通信

    需要注意：

    dbox_ipcb_dev_instance 里边的地址要和 reserved 地址保持一致，也可能要大于reserved。dbox_ipc_dev_instance中reg后边一个参数，应该是长度，这个值不能超过reserved中reg的第二个参数。

    3.4 添加驱动

    参考教程：使用petalinux写驱动_沐唐的博客-CSDN博客_petalinux编译驱动

    3.4.1 创建驱动工程

    petalinux-create -t modules --name dbox-ipc-dev

    使用如下指令时 无需3.4.3

    petalinux-create -t modules --name dbox-ipc-dev --enable

    3.4.2 修改.c文件

    路径：执行上边指令后，INFO会显示路径

     工程目录 ---> project-spec ---> meta-user ---> recipes-modules ---> dbox-ipc-dev ---> files ---> dbox-ipc-dev.c ，内容如下：

    1. /*  dbox-ipc-dev.c - The simplest kernel module.
    2.  
    3. * Copyright (C) 2013 - 2016 Xilinx, Inc
    4. *
    5. *   This program is free software; you can redistribute it and/or modify
    6. *   it under the terms of the GNU General Public License as published by
    7. *   the Free Software Foundation; either version 2 of the License, or
    8. *   (at your option) any later version.
    9.  
    10. *   This program is distributed in the hope that it will be useful,
    11. *   but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13. *   GNU General Public License for more details.
    14. *
    15. *   You should have received a copy of the GNU General Public License along
    16. *   with this program. If not, see .
    17.  
    18. */
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include  
    26. #include 
    27. #include 
    28. #include 
    29. #include 
    30.  
    31. #include 
    32. #include 
    33. #include  
    34. #include <../../arch/arm/mach-zynq/common.h>
    35. #include  
    36.  
    37. //extern int zynq_cpun_stop(int cpu);
    38.  
    39. /* Standard module information, edit as appropriate */
    40. MODULE_LICENSE("GPL");
    41. MODULE_AUTHOR
    42.     ("Xilinx Inc.");
    43. MODULE_DESCRIPTION
    44.     ("dbox-ipc-dev - loadable module template generated by petalinux-create -t modules");
    45.  
    46. #define DRIVER_NAME "dbox-ipc-dev"
    47. #define DRIVER_NUM 1
    48.  
    49. /* Simple example of how to receive command line parameters to your module.
    50.    Delete if you don't need them */
    51. unsigned myint = 0xdeadbeef;
    52. char *mystr = "default";
    54. module_param(myint, int, S_IRUGO);
    55. module_param(mystr, charp, S_IRUGO);
    57. #define StarCpu1            0x10000000
    58. #define StopCpu1            0x20000000
    59. #define KickCpu1            0x30000000
    61. struct dbox_ipc_dev_local {
    62.     int irq;
    63.     int cpu0_to_cpu1_ipi;
    64.     int cpu1_to_cpu0_ipi;
    65.     unsigned long mem_start;
    66.     unsigned long mem_end;
    67.     void __iomem *base_addr;
    68. };
    70. struct dbox_ipc_dev 
    71. { 
    72.     dev_t devid;                   /*  设备号  */ 
    73.     struct cdev chdev;              /* cdev 结构体  */ 
    74.     struct class *class;            /*  类  */ 
    75.     struct device *device;          /*  设备  */ 
    76.     struct dbox_ipc_dev_local *param;
    77.     struct fasync_struct *async_queue; 
    78. };
    80. static struct dbox_ipc_dev dbox_ipc_dev_;
    82. static int dbox_ipc_dev_open(struct inode *inode, struct file *filp) 
    83. { 
    84.     //cpu_up(1);
    85.     //printk("dbox_ipc_dev Dev: open success  \r\n"); 
    86.                     
    87.     return 0; 
    88. } 
    90. static ssize_t dbox_ipc_dev_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt) 
    91. {
    92.     int ret; 
    93.     
    94.     ret = copy_from_user((unsigned char*)(dbox_ipc_dev_.param->base_addr + (*offt)), buf, cnt);  
    95.     
    96.     if(0 > ret)
    97.     {
    98.         printk(KERN_ERR "dbox_ipc_dev_ Dev: Failed to copy data from user space \r\n"); 
    99.         return -EFAULT;             
    100.     }
    101.     
    102.     //printk("dbox_ipc_dev_ Dev: write add: %08X  cnt: %d\r\n",(unsigned int)(dbox_ipc_dev_.param->base_addr + (*offt)),cnt); 
    103.     
    104.     *offt = *offt + cnt;
    105.     
    106.     return cnt;
    107. }
    109. static ssize_t dbox_ipc_dev_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 
    110. { 
    111.     int ret = 0; 
    112.     
    113.     ret = copy_to_user(buf, (unsigned char*)(dbox_ipc_dev_.param->base_addr + (*offt)) , cnt); 
    114.     
    115.     if(ret < 0)
    116.     { 
    117.         printk(KERN_ERR "dbox_ipc_dev_ Dev: Failed to copy data to user space \r\n"); 
    118.     } 
    119.     
    120.     *offt = *offt + cnt;
    121.     
    122.     return cnt;  
    123. }
    125. static long dbox_ipc_dev_ioctl(struct file *filp,unsigned int cmd, unsigned long arg) 
    126. {
    127.     int ret = 0; 
    128.     //printk("cmd %d \n" ,cmd);
    129.     switch(cmd)
    130.     {
    131.     case StarCpu1:
    132.         ret = cpu_down(1);
    133.         if (ret && (ret != -EBUSY)) 
    134.         {
    135.             printk("!! Can't release cpu1 %d\n",ret);
    136.             return ret;
    137.         }
    138.         //zynq_cpun_stop(1);
    139.         zynq_cpun_start((u32)dbox_ipc_dev_.param->mem_start, 1);
    140.         //printk("StarCpu1\n");
    141.         break;      
    142.     case StopCpu1:  
    143.         ret = cpu_up(1);
    144.         if (ret)
    145.         {
    146.             printk("!! Can't power on cpu1 %d\n", ret);
    147.         }
    148.         //printk("StopCpu1\n");
    149.         break;
    150.     case KickCpu1:
    151.         gic_raise_softirq(cpumask_of(1), dbox_ipc_dev_.param->cpu0_to_cpu1_ipi);
    152.         //printk("KickCpu %d  %d \n",1,dbox_ipc_dev_.param->cpu0_to_cpu1_ipi);
    153.         break;      
    154.     }
    155.     return 0;
    156. }
    157. /*********************************************************************
    158. *
    159. *
    160. *
    161. **********************************************************************/
    162. loff_t dbox_ipc_dev_llseek(struct file *filp, loff_t off, int whence)
    163. {
    164.     loff_t newpos;
    165.     switch(whence)
    166.     {
    167.     case 0: /* SEEK_SET */
    168.         newpos = off;    
    169.         break;
    170.     case 1: /* SEEK_CUR */
    171.         newpos = filp->f_pos + off;
    172.         break;
    173.     case 2: /* SEEK_END */
    174.         if(whence>0)
    175.             newpos = (dbox_ipc_dev_.param->mem_end - dbox_ipc_dev_.param->mem_start);
    176.         else
    177.             newpos = (dbox_ipc_dev_.param->mem_end - dbox_ipc_dev_.param->mem_start)+ whence;       
    178.         break;
    179.     default: /* can't happen */
    180.         return -EINVAL;
    181.     }
    182.  
    183.     if (newpos < 0)
    184.         return -EINVAL;
    185.     
    186.     filp->f_pos = newpos;
    187.  
    188.     return newpos;
    189. }
    190. /*********************************************************************
    191. *
    192. *
    193. *
    194. **********************************************************************/
    195. static int dbox_ipc_dev_fasync(int fd, struct file *filp, int on) 
    196. {
    197.     return fasync_helper(fd, filp, on, &dbox_ipc_dev_.async_queue); 
    198. }
    199. /*********************************************************************
    200. *
    201. *
    202. *
    203. **********************************************************************/
    204. static int dbox_ipc_dev_fasync_release(struct inode *inode, struct file *filp) 
    205. {
    206.     return dbox_ipc_dev_fasync(-1, filp, 0); 
    207. }
    208. /*********************************************************************
    209. *
    210. *
    211. *
    212. **********************************************************************/
    213. static struct file_operations dbox_ipc_dev_fops = 
    214. { 
    215.     .owner = THIS_MODULE, 
    216.     .open = dbox_ipc_dev_open, 
    217.     .write = dbox_ipc_dev_write, 
    218.     .read = dbox_ipc_dev_read, 
    219.     .unlocked_ioctl = dbox_ipc_dev_ioctl, 
    220.     .llseek = dbox_ipc_dev_llseek, 
    221.     .fasync = dbox_ipc_dev_fasync, 
    222.     .release = dbox_ipc_dev_fasync_release, 
    223.  }; 
    224. /*********************************************************************
    225. *
    226. *
    227. *
    228. **********************************************************************/
    229. static int dbox_ipc_dev_param_init(struct dbox_ipc_dev_local *nd) 
    230. { 
    231.     dbox_ipc_dev_.param = nd;   
    232.     cpu_down(1);
    233.     return 0;
    234. }
    235. /*********************************************************************
    236. *
    237. *IPI 中断通知Linux CPU0 有信息要处理
    238. *
    239. **********************************************************************/
    240. static void cpu1_to_cpu0_ipi_kick(void)
    241. {
    242.     //printk("[dbox]-->>ipi %d \n",dbox_ipc_dev_.param->cpu1_to_cpu0_ipi);
    243.     if(dbox_ipc_dev_.async_queue) 
    244.     {
    245.         //printk("ipi %d  kick SIGIO \n",dbox_ipc_dev_.param->cpu1_to_cpu0_ipi);
    246.         kill_fasync(&dbox_ipc_dev_.async_queue, SIGIO, POLL_IN); 
    247.     }
    248.     else
    249.     {
    250.         //printk("ipi %d kick but async_queue is null \n",dbox_ipc_dev_.param->cpu1_to_cpu0_ipi);
    251.     }
    252. }
    253.  
    254. static irqreturn_t dbox_ipc_dev_irq(int irq, void *lp)
    255. {
    256.     printk("dbox-ipc-dev interrupt\n");
    257.     return IRQ_HANDLED;
    258. }
    259.  
    260. static int dbox_ipc_dev_probe(struct platform_device *pdev)
    261. {
    262.     struct resource *r_irq; /* Interrupt resources */
    263.     struct resource *r_mem; /* IO mem resources */
    264.     struct device *dev = &pdev->dev;
    265.     struct dbox_ipc_dev_local *lp = NULL;
    266.  
    267.     int rc = 0;
    268.     dev_info(dev, "Device Tree Probing\n");
    269.     printk("---->>>>>dbox ipc dev Device Tree Probing\n");
    270.     /* Get iospace for the device */
    271.     r_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    272.     if (!r_mem) {
    273.         dev_err(dev, "invalid address\n");
    274.         return -ENODEV;
    275.     }
    276.     lp = (struct dbox_ipc_dev_local *) kmalloc(sizeof(struct dbox_ipc_dev_local), GFP_KERNEL);
    277.     if (!lp) {
    278.         dev_err(dev, "Cound not allocate dbox-ipc-dev device\n");
    279.         return -ENOMEM;
    280.     }
    281.     dev_set_drvdata(dev, lp);
    282.     lp->mem_start = r_mem->start;
    283.     lp->mem_end = r_mem->end;
    284.  
    285.     if (!request_mem_region(lp->mem_start,
    286.                 lp->mem_end - lp->mem_start + 1,
    287.                 DRIVER_NAME)) {
    288.         dev_err(dev, "Couldn't lock memory region at %p\n",
    289.             (void *)lp->mem_start);
    290.         rc = -EBUSY;
    291.         goto error1;
    292.     }
    293.  
    294.     lp->base_addr = ioremap(lp->mem_start, lp->mem_end - lp->mem_start + 1);
    295.     if (!lp->base_addr) {
    296.         dev_err(dev, "dbox-ipc-dev: Could not allocate iomem\n");
    297.         rc = -EIO;
    298.         goto error2;
    299.     }
    300.  
    301.     lp->cpu0_to_cpu1_ipi = 12;
    302.     lp->cpu1_to_cpu0_ipi = 13;//默认值
    303.  
    304.     /* Read ipi12 ipi number 用于 ucos 通知 linux */
    305.     rc = of_property_read_u32(pdev->dev.of_node, "ipi12",&lp->cpu1_to_cpu0_ipi);
    306.     if (rc < 0) 
    307.     {
    308.         dev_err(&pdev->dev, "unable to read property ipi 12");
    309.         goto error3;
    310.     }
    311.     rc = set_ipi_handler(lp->cpu1_to_cpu0_ipi, cpu1_to_cpu0_ipi_kick,"cpu 1 kick cpu0");
    312.     if (rc) 
    313.     {
    314.         dev_err(&pdev->dev, "IPI 12 handler already registered\n");
    315.         goto error3;
    316.     }
    317.     /* Read ipi13 ipi number 用于 linux 通知 ucos */
    318.     rc = of_property_read_u32(pdev->dev.of_node, "ipi13",&lp->cpu0_to_cpu1_ipi);
    319.     if (rc < 0) 
    320.     {
    321.         dev_err(&pdev->dev, "unable to read property ipi 13");
    322.         goto error3;
    323.     }
    324.     printk("dbox_ipc_dev_device at 0x%08x mapped to 0x%08x len= %08X , ipi= %d\n",
    325.         (unsigned int __force)lp->mem_start,
    326.         (unsigned int __force)lp->base_addr,
    327.         (unsigned int __force)(lp->mem_end - lp->mem_start+1),
    328.         lp->cpu0_to_cpu1_ipi);
    329.     
    330.     dbox_ipc_dev_param_init(lp); 
    331.     
    332.     rc = alloc_chrdev_region(&dbox_ipc_dev_.devid, 0, DRIVER_NUM, DRIVER_NAME); 
    333.     if(rc)
    334.     {
    335.         dev_err(&pdev->dev, "unable to alloc_chrdev_region ");
    336.     }
    337.     
    338.     dbox_ipc_dev_.chdev.owner = THIS_MODULE; 
    339.     cdev_init(&dbox_ipc_dev_.chdev, &dbox_ipc_dev_fops); 
    340.     
    341.     rc = cdev_add(&dbox_ipc_dev_.chdev, dbox_ipc_dev_.devid, 1); 
    342.     if(rc)
    343.     {
    344.         dev_err(&pdev->dev, "unable to cdev_add ");
    345.     }   
    346.     
    347.     dbox_ipc_dev_.class = class_create(THIS_MODULE, DRIVER_NAME); 
    348.     if (IS_ERR(dbox_ipc_dev_.class)) 
    349.     { 
    350.         dev_err(&pdev->dev, "unable to class_create ");
    351.     }   
    352.     
    353.     dbox_ipc_dev_.device = device_create(dbox_ipc_dev_.class, &pdev->dev,dbox_ipc_dev_.devid, NULL, DRIVER_NAME); 
    354.     if (IS_ERR(dbox_ipc_dev_.device)) 
    355.     { 
    356.         dev_err(&pdev->dev, "unable to device_create ");
    357.     }
    358.     
    359.     return 0;
    360. error3:
    361.     clear_ipi_handler(lp->cpu0_to_cpu1_ipi);
    362. error2:
    363.     release_mem_region(lp->mem_start, lp->mem_end - lp->mem_start + 1);
    364. error1:
    365.     kfree(lp);
    366.     dev_set_drvdata(dev, NULL);
    367.     return rc;
    368. }
    369.  
    370. static int dbox_ipc_dev_remove(struct platform_device *pdev)
    371. {
    372.     struct device *dev = &pdev->dev;
    373.     struct dbox_ipc_dev_local *lp = dev_get_drvdata(dev);
    374.     
    375.     device_destroy(dbox_ipc_dev_.class, dbox_ipc_dev_.devid); 
    376.     class_destroy(dbox_ipc_dev_.class);     
    377.     cdev_del(&dbox_ipc_dev_.chdev);     
    378.     unregister_chrdev_region(dbox_ipc_dev_.devid, DRIVER_NUM);  
    379.     clear_ipi_handler(lp->cpu0_to_cpu1_ipi);
    380.     iounmap(lp->base_addr);
    381.     release_mem_region(lp->mem_start, lp->mem_end - lp->mem_start + 1);
    382.     kfree(lp);
    383.     dev_set_drvdata(dev, NULL);
    384.     return 0;
    385. }
    386.  
    387. static struct of_device_id dbox_ipc_dev_of_match[] = {
    388.     { .compatible = "dbox,dbox-ipc-dev", },
    389.     { /* end of list */ },
    390. };
    391. MODULE_DEVICE_TABLE(of, dbox_ipc_dev_of_match);
    392.  
    393. static struct platform_driver dbox_ipc_dev_driver = {
    394.     .driver = {
    395.         .name = DRIVER_NAME,
    396.         .owner = THIS_MODULE,
    397.         .of_match_table = dbox_ipc_dev_of_match,
    398.     },
    399.     .probe      = dbox_ipc_dev_probe,
    400.     .remove     = dbox_ipc_dev_remove,
    401. };
    402.  
    403. static int __init dbox_ipc_dev_init(void)
    404. {
    405.     printk("<1>Hello module world.\n");
    406.     printk("<1>Module parameters were (0x%08x) and \"%s\"\n", myint,
    407.            mystr);
    408.  
    409.     return platform_driver_register(&dbox_ipc_dev_driver);
    410. }
    411.  
    412. static void __exit dbox_ipc_dev_exit(void)
    413. {
    414.     platform_driver_unregister(&dbox_ipc_dev_driver);
    415.     printk(KERN_ALERT "Goodbye module world.\n");
    416. }
    417.  
    418. module_init(dbox_ipc_dev_init);
    419. module_exit(dbox_ipc_dev_exit);

    3.4.3 将驱动添加到内核

    petalinux-config -c rootfs

    界面选择 modules ---> ，使能 dbox-ipc-dev，保存。

     3.4.4 编译

    petalinux-build

    3.4.5 打包

    petalinux-package --boot --fsbl ./images/linux/zynq_fsbl.elf --fpga ./images/linux/system.bit --uboot --force

    将 images/linux 下的，BOOT.bin 和 image.ub 拷贝至SD卡。

     3.4.6 驱动验证

    登录系统，找到 ”/dev/dbox-ipc-dev“ 则表明驱动运行正常

    1. ls /dev/db*				 //看到 dbox-ipc-dev 则表明成功
    2. cat /proc/cpuinfo		 //看到一个cpu则 表明运行成功

  • 相关阅读:
    C语言300行代码实现扫雷（可展开+可标记+可更改困难级别+内附图形界面版本）
    认识京东联盟API,获取APPkey和APPsecret|直接调用KEY方式
    java基于Android studio的家政服务系统
    idea热部署Jrebel插件和自动手动三种方式实现
    JVM-虚拟机的故障处理与调优案例分析
    Flink 写入Apache Arrow
    韩国程序员面试考什么？
    Redis变慢怎么办？
    [原创]dotnet 命令行工具解决方案 PomeloCli
    Vue2 | Vant uploader实现上传文件和图片
  • 原文地址：https://blog.csdn.net/mengqingbin5219/article/details/126480517