Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1064360
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
内核调试之寄存器编辑器

分类： LINUX

2015-12-07 14:35:29

makefile文件

点击(此处)折叠或打开

  1. # File: Makefile
  2. # wangxiancai

  4. MODEXT = ko
  5. INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.13/wxc/driver/chardriver/ko
  6. # INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.30/wxc/driver/chardriver/ko
  7. CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-
  8. # CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-
  9. KERNELDIR=/home/wangxc/linux/kernel/kernel-2.6.13
  10. # KERNELDIR=/home/wangxc/linux/kernel/kerner-2.6.30

  12. CC= $(CROSS)gcc
  13. LD= $(CROSS)ld

  15. #############################################################################
  16. # Compiler Flags
  17. #############################################################################
  18. EXTRA_CFLAGS += -I$(KERNELDIR)/include
  19. #############################################################################
  20. # Make Targets
  21. #############################################################################
  22. obj-m := regeditor.o
  23. default:
  24.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
  25. # Otherwise we were called directly from the command line; invoke the kernel build system.

  27. install: default
  28.     rm -rf $(INSTALLDIR)/regeditor.$(MODEXT)
  29.     cp -rf $(PWD)/regeditor.$(MODEXT) $(INSTALLDIR)

  31. clean:
  32.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.bak modules.order Module.symvers


regeditor.c文件

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/errno.h>
  4. #include <linux/string.h>
  5. #include <linux/mm.h>
  6. #include <linux/tty.h>
  7. #include <linux/slab.h>
  8. #include <linux/delay.h>
  9. #include <linux/fb.h>
  10. #include <linux/init.h>
  11. #include <linux/dma-mapping.h>
  12. #include <linux/string.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/workqueue.h>
  15. #include <linux/wait.h>
  16. #include <linux/fs.h>
  17. #include <linux/irq.h>
  18. #include <asm/hardware.h>
  19. #include <linux/poll.h>
  20. #include <linux/device.h>

  22. #include <asm/io.h>
  23. #include <asm/irq.h>
  24. #include <asm/uaccess.h>
  25. #include <asm/div64.h>

  27. #include <asm/mach/map.h>
  28. #include <asm/arch/regs-lcd.h>
  29. #include <asm/arch/regs-gpio.h>
  30. #include <asm/arch/fb.h>
  31. #include <asm/hardware/clock.h>

  33. #include <asm/arch/tq2440-map.h> // HJ MMU setting

  35. /*注意 :每个地址值，其实只对应8位
  36. *例如 : 地址 0x56000054 其实只有 8位
  37.                 地址 0x56000055 其实只有 8位
  38.                 地址 0x56000056 其实只有 8位
  39.                 地址 0x56000057 其实只有 8位
  40. */
  41. #define REG_R8 0        /*读取 指定地址的8位的数据*/
  42. #define REG_R16 1        /*读取 指定地址的8位+后8位的数据*/
  43. #define REG_R32 2        /*读取 指定地址的8位+后24位的数据*/

  45. #define REG_W8     3        /*写 8位数据 到 指定地址的8位*/
  46. #define REG_W16 4        /*写 16位数据 到 指定地址的连续16位*/
  47. #define REG_W32 5        /*写 32位数据 到 指定地址的连续32位*/

  49. #define DEVICE_NAME    "regeditor"
  50. static int MYDRIVER_Major = 0;

  52. static struct class * mydriver_class;
  53. static struct class_device    * mydriver_class_dev;

  55. /*
  56. *应用层 ioctl函数的原型 : int ioctl(int filedes, int request, ...); //参数个数是可变个数。
  57. *读取的时候，地址存放在 arg变量，应用程序传递进来的arg是指定的地址。
  58. *写的时候，地址和值都存放在 arg变量，应用程序传递进来的arg是个数组的地址(是int型数组，2个元素)。
  59. */
  60. static int regeditor_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  61. {
  62.     volatile unsigned char * p8;
  63.     volatile unsigned short * p16;
  64.     volatile unsigned int * p32;
  65.     
  66.     unsigned int buf[2]; /*2个int，共8个字节*/
  67.     unsigned int addr; //用来指示寄存器的地址
  68.     unsigned int val; //用来指示寄存器的值
  69.     
  70.     //printk("DEVICE:regeditor_ioctl Called!\n");
  71.     //printk("DEVICE:cmd=[%d], arg=[0x%x]\n", cmd, (unsigned int)arg);

  73.     /*功能 : 从用户空间指定的地址里面取得8个字节的数据。
  74.     *arg : 表示用户空间的int型数组buf的地址,该数组2个元素，刚好8个字节长度。
  75.     *注意 : 和应用程序约定好的 :
  76.     *                写入命令时 : buf[0]是写入的地址,做输入参数; buf[1]是欲写入的值,做输入参数。
  77.     *                读取命令时 : buf[0]是读取的地址,做输入参数; buf[1]是将要存放的值,做输出参数。
  78.     */
  79.     if(copy_from_user(buf, (const char __user *)arg, 8))
  80.     {
  81.             return - EFAULT;
  82.     }
  83.     addr = buf[0];
  84.     
  85.     /*读取时 : val=buf[1]初始值是0; 写入时 : val=buf[1]值是欲写入的值;*/
  86.     val = buf[1];

  88.     //printk("DEVICE:cmd=[%d], buf[0]=[0x%x], buf[1]=[%d]\n", cmd, buf[0], buf[1]);

  90.     p8 = (volatile unsigned char *)ioremap(addr, 4); /*映射4个字节*/
  91.     p16 = (volatile unsigned short * )p8;
  92.     p32 = (volatile unsigned int *)p8;
  93.     /*注意 : 上面3行处理之后，*p8只表示8位数据了，*p16只表示16位数据了，*p32只表示32位数据了，*/

  95.     switch(cmd)
  96.     {
  97.         case REG_R8: /*读取 指定地址的8位的数据*/
  98.         {
  99.             val = *p8; /*指定地址的8位数据 赋值 给 val*/
  100.             /* 拷贝数据到用户空间 */
  101.             /* arg+4 指向buf[1]了，即将val中的值，写入到用户空间的buf[1]中*/
  102.             if(copy_to_user((void __user *)arg+4, &val, 4))
  103.             {
  104.                     return - EFAULT;
  105.             }
  106.             break;
  107.         }
  108.         case REG_R16: /*读取 指定地址的8位+后8位的数据*/
  109.         {
  110.             val = *p16; /*指定地址的16位数据 赋值 给 val*/
  111.             /* 拷贝数据到用户空间 */
  112.             /* arg+4 指向buf[1]了，即将val中的值，写入到用户空间的buf[1]中*/
  113.             if(copy_to_user((void __user *)arg+4, &val, 4))
  114.             {
  115.                     return - EFAULT;
  116.             }
  117.             break;
  118.         }
  119.         case REG_R32: /*读取 指定地址的8位+后24位的数据*/
  120.         {
  121.             val = *p32; /*指定地址的32位数据 赋值 给 val*/
  122.             /* 拷贝数据到用户空间 */
  123.             /* arg+4 指向buf[1]了，即将val中的值，写入到用户空间的buf[1]中*/
  124.             if(copy_to_user((void __user *)arg+4, &val, 4))
  125.             {
  126.                     return - EFAULT;
  127.             }
  128.             break;
  129.         }
  130.         case REG_W8: /*写 8位数据 到 指定地址的8位*/
  131.         {
  132.             *p8 = (unsigned char)val; /*val截取底8位 赋值 给 指定的8位地址*/
  133.             break;
  134.         }
  135.         case REG_W16: /*写 16位数据 到 指定地址的连续16位*/
  136.         {
  137.             *p16 = (unsigned short)val; /*val截取底16位 赋值 给 指定的16位地址*/
  138.             break;
  139.         }
  140.         case REG_W32: /*写 16位数据 到 指定地址的连续24位*/
  141.         {
  142.             *p32 = (unsigned int)val; /*val的32位 赋值 给 指定的32位地址*/
  143.             break;
  144.         }
  145.     }
  146.     iounmap((void *)p8);
  147.     return 0;
  148. }

  150. static struct file_operations kernel_rw_fops =
  151. {
  152.     .owner =        THIS_MODULE,
  153.     .ioctl = regeditor_ioctl,
  154. };

  156. static int __init regeditor_init(void)
  157. {
  158.     //printk("DEVICE : regeditor_init\n");

  160.     MYDRIVER_Major = register_chrdev(0, DEVICE_NAME, &kernel_rw_fops);
  161.     if (MYDRIVER_Major < 0)
  162.     {
  163.         printk(DEVICE_NAME " can't register major number\n");
  164.         return MYDRIVER_Major;
  165.     }
  166.     printk("DEVICE : register regeditor OK! Major = [%d]\n", MYDRIVER_Major);

  168.     /*注册一个类，使mdev可以自动在"/dev/"目录下面建立设备节点
  169.     静态编译进内核的，可以依赖mdev来建立设备节点，
  170.     编译成模块的，也只使用insmod 即可建立设备节点
  171.     */
  172.     mydriver_class = class_create(THIS_MODULE, DEVICE_NAME);
  173.     if(IS_ERR(mydriver_class))
  174.     {
  175.         printk("DEVICE:class_create err!\n");
  176.         return -1;
  177.     }
  178.     //创建一个设备节点，节点名为DEVICE_NAME
  179.     //device_create(mydriver_class, NULL, MKDEV(MYDRIVER_Major, 0), NULL, DEVICE_NAME);
  180.     mydriver_class_dev = class_device_create(mydriver_class, MKDEV(MYDRIVER_Major, 0), NULL, DEVICE_NAME); // dev/mydriver

  182.     //printk("DEVICE:initialized\n");

  184.     return 0;
  185. }

  187. static void __exit regeditor_exit(void)
  188. {
  189.     //printk("DEVICE : regeditor_exit####################\n");
  190.     unregister_chrdev(MYDRIVER_Major, DEVICE_NAME);
  191.     class_device_destroy(mydriver_class, MKDEV(MYDRIVER_Major, 0));
  192.     class_destroy(mydriver_class);
  193.     
  194.     return;
  195. }

  197. module_init(regeditor_init);
  198. module_exit(regeditor_exit);

  200. MODULE_AUTHOR("wangxiancai");
  201. MODULE_DESCRIPTION("DEVICE : regeditor");
  202. MODULE_LICENSE("GPL");


  205. /*
  206. 测试 :
  207. 1, # insmod regeditor.ko
  208. DEVICE : register regeditor Major = [253]

  210. 2, # mknod /dev/regeditor c 253 0
  211.      # ls -lrt /dev/reg*
  212. crw-r--r-- 1 root root 253, 0 Jan 1 01:15 /dev/regeditor

  214. 3, 点亮LED灯
  215. GPBCON = 0x56000010
  216. GPBDAT = 0x56000014
  217. GPBUP = 0x56000018

  219. # ./regeditor w32 0x56000010 0x55555555 //全部配置成输出引脚
  220. # ./regeditor r32 0x56000010
  221.     [00.] [0x56000010] = [0x00155555]
  222. # ./regeditor r8 0x56000010 4
  223.     [00.] [0x56000010] = [0x55]
  224.     [01.] [0x56000011] = [0x55]
  225.     [02.] [0x56000012] = [0x15]
  226.     [03.] [0x56000013] = [0x00]

  228. # ./regeditor w32 0x56000018 0x00000000
  229. # ./regeditor r32 0x56000018
  230.     [00.] [0x56000018] = [0x00000000]
  231. # ./regeditor r8 0x56000018 4
  232.     [00.] [0x56000018] = [0x00]
  233.     [01.] [0x56000019] = [0x00]
  234.     [02.] [0x5600001a] = [0x00]
  235.     [03.] [0x5600001b] = [0x00]

  237. # ./regeditor w32 0x56000014 0xffffffff //灯全灭，蜂鸣器响了。最后1位，1:蜂鸣器响,0:蜂鸣器不响
  238. # ./regeditor w32 0x56000014 0xfffffffe //灯全灭，蜂鸣器不响。
  239. # ./regeditor r32 0x56000014
  240.     [00.] [0x56000014] = [0x000007fe]
  241. # ./regeditor r8 0x56000014 4
  242.     [00.] [0x56000014] = [0xfe]
  243.     [01.] [0x56000015] = [0x07]
  244.     [02.] [0x56000016] = [0x00]
  245.     [03.] [0x56000017] = [0x00]
  246. # ./regeditor w32 0x56000014 0x00000000 //灯全亮，蜂鸣器不响。

  248. # ./regeditor r8 0x56000010 8 //读取8个字节时，读取到 地址 0x56000017 的值。
  249.     [00.] [0x56000010] = [0x55]
  250.     [01.] [0x56000011] = [0x55]
  251.     [02.] [0x56000012] = [0x15]
  252.     [03.] [0x56000013] = [0x00]
  253.     [04.] [0x56000014] = [0xfe]
  254.     [05.] [0x56000015] = [0x07]
  255.     [06.] [0x56000016] = [0x00]
  256.     [07.] [0x56000017] = [0x00]
  257. # ./regeditor r32 0x56000010 3 //一次读取3个寄存器(GPBCON,GPBDAT,GPBUP)的值
  258.     [00.] [0x56000010] = [0x00155555]
  259.     [01.] [0x56000014] = [0x000007fe]
  260.     [02.] [0x56000018] = [0x00000000]
  261.     
  262. # ./regeditor r32 0x48000000 12 //一次读取存储控制器相关的12个寄存器的值。
  263. [00.] [0x48000000] = [0x220dd112]
  264. [01.] [0x48000004] = [0x00000700]
  265. [02.] [0x48000008] = [0x00001c10]
  266. [03.] [0x4800000c] = [0x00001c10]
  267. [04.] [0x48000010] = [0x00001f4c]
  268. [05.] [0x48000014] = [0x00000700]
  269. [06.] [0x48000018] = [0x00000700]
  270. [07.] [0x4800001c] = [0x00018005]
  271. [08.] [0x48000020] = [0x00018005]
  272. [09.] [0x48000024] = [0x008e04f4]
  273. [10.] [0x48000028] = [0x00000032]
  274. [11.] [0x4800002c] = [0x00000030]
  275. */
应用程序：
makefile文件

点击(此处)折叠或打开

  1. CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-gcc
  2. all: regeditor
  3. regeditor:regeditor.c
  4.     $(CROSS) -o regeditor regeditor.c
  5. clean:
  6.     @rm -vf regeditor.o regeditor
regeditor.c文件

点击(此处)折叠或打开

  1. /*
  2. 本程序的功能 : 可以读取指定寄存器的值，也可以直接修改指定寄存器的值。
  3. 自己制作的驱动调试的工具 : 可以作为一个很强大的调试驱动程序工具
  4. 工作中会遇到各种各样的驱动程序，需要根据实际要求来写各种各样的驱动调试工具。
  5. 用法示例 :
  6.         程序名称 读取命令 读取的地址 顺序读取地址的值的个数
  7.    ./regeditor r16 addr [num]

  9. 1, ./regeditor r8 0x56000054 4 //表示读取 0x56000054+0x56000055+0x56000056+0x56000057 4个地址的值 每个读取8位 共32位。
  10. 2, ./regeditor r8 0x56000054
  11. 3, ./regeditor r16 0x56000054 4
  12. 4, ./regeditor r16 0x56000054
  13. 5, ./regeditor r32 0x56000054 2
  14. 6, ./regeditor r32 0x56000054

  16.         程序名称 写入命令 写入的地址 写入的值
  17.    ./regeditor w8 addr val
  18. 1, ./regeditor w32 0x56000054 0x7f
  19. */

  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #include <fcntl.h>
  24. #include <stdio.h>
  25. #include <poll.h>
  26. #include <signal.h>
  27. #include <sys/types.h>
  28. #include <unistd.h>
  29. #include <fcntl.h>
  30. #include <stdlib.h>
  31. #include <string.h>

  33. /*注意 :每个地址值，其实只对应8位
  34. *例如 : 地址 0x56000054 其实只有 8位
  35.                 地址 0x56000055 其实只有 8位
  36.                 地址 0x56000056 其实只有 8位
  37.                 地址 0x56000057 其实只有 8位
  38. */
  39. #define REG_R8 0        /*读取 指定地址的8位的数据*/
  40. #define REG_R16 1        /*读取 指定地址的8位+后8位的数据*/
  41. #define REG_R32 2        /*读取 指定地址的8位+后24位的数据*/

  43. #define REG_W8     3        /*写 8位数据 到 指定地址的8位*/
  44. #define REG_W16 4        /*写 16位数据 到 指定地址的连续16位*/
  45. #define REG_W32 5        /*写 32位数据 到 指定地址的连续32位*/

  47. /*函数功能 : 打印本程序的用法
  48. */
  49. void print_usage(char * cmd)
  50. {
  51.     printf("Usage:\n");
  52.     printf("%s [num]\n", cmd);
  53.     printf("%s \n", cmd);
  54. }

  56. int main(int argc, char **argv)
  57. {
  58.     int fd;
  59.     
  60.     /*
  61.     写入命令时 : buf[0]是写入的地址,做输入参数; buf[1]是欲写入的值,做输入参数
  62.     读取命令时 : buf[0]是读取的地址,做输入参数; buf[1]是将要存放的值,做输出参数
  63.     */
  64.     unsigned int buf[2];
  65.     unsigned int i;
  66.     unsigned int num; /*连续读取的次数*/
  67.     
  68.     memset(buf, 0, sizeof(buf));
  69.     
  70.     if((argc != 3) && (argc != 4))
  71.     {
  72.         /* argv[0]:是程序名称 */
  73.         print_usage(argv[0]);
  74.         return -1;
  75.     }

  77.     fd = open("/dev/regeditor", O_RDWR);
  78.     if(fd < 0)
  79.     {
  80.         printf("can't open /dev/regeditor\n");
  81.         return -2;
  82.     }

  84.     /* argv[2]:是地址 */
  85.     buf[0] = strtoul(argv[2], NULL, 0);
  86.     
  87.     //printf("&buf=[%p]\n", buf);

  89.     if(argc == 4) /*如果有4个参数(argv[3])*/
  90.     {
  91.         /*则第4个参数是 写入命令 : 写入的值; 读取命令 : 顺序读取地址的值的个数*/
  92.         buf[1] = strtoul(argv[3], NULL, 0); /* argv[3]:是将写入的值 */
  93.         num = buf[1];                                        /* argv[3]:顺序读取地址的值的个数 */
  94.     }
  95.     else /*如果只有3个参数*/
  96.     {
  97.         num = 1; /* 肯定是读取命令:则默认只读取1个地址的值,buf[1]是空，准备接受数据*/
  98.     }

  100.     /* r8 R8,r16 R16,r32 R32 表示argv[1]:是读取命令 */
  101.     if((strcmp(argv[1], "r8") == 0) || (strcmp(argv[1], "R8") == 0)) /*读取 指定地址的8位的数据*/
  102.     {
  103.         for(i = 0; i < num; i++)
  104.         {
  105.             ioctl(fd, REG_R8, buf); /* buf[0]是读取的地址，buf[1]是存放读取的值 */
  106.             printf("[%02d.] [0x%08x] = [0x%02x]\n", i, buf[0], (unsigned char)buf[1]);
  107.             buf[0] += 1; /*int型的地址值+1*/
  108.         }
  109.     }
  110.     else if((strcmp(argv[1], "r16") == 0) || (strcmp(argv[1], "R16") == 0)) /*读取 指定地址的8位+后8位的数据*/
  111.     {
  112.         for (i = 0; i < num; i++)
  113.         {
  114.             ioctl(fd, REG_R16, buf); /* buf[0]是读取的地址，buf[1]是存放读取的值 */
  115.             printf("[%02d.] [0x%08x] = [0x%04x]\n", i, buf[0], (unsigned short)buf[1]);
  116.             buf[0] += 2;
  117.         }
  118.     }
  119.     else if((strcmp(argv[1], "r32") == 0) || (strcmp(argv[1], "R32") == 0)) /*读取 指定地址的8位+后24位的数据*/
  120.     {
  121.         for (i = 0; i < num; i++)
  122.         {
  123.             ioctl(fd, REG_R32, buf); /* buf[0]是读取的地址，buf[1]是存放读取的值 */
  124.             printf("[%02d.] [0x%08x] = [0x%08x]\n", i, buf[0], (unsigned int)buf[1]);
  125.             buf[0] += 4;
  126.         }
  127.     }
  128.     /* w8 W8,w16 W16,w32 W32 表示argv[1]:是写入命令 */
  129.     else if((strcmp(argv[1], "w8") == 0) || (strcmp(argv[1], "W8") == 0)) /*写 8位数据 到 指定地址的8位*/
  130.     {
  131.         ioctl(fd, REG_W8, buf); /* buf[0]是写入的地址，buf[1]是写入的值 */
  132.     }
  133.     else if((strcmp(argv[1], "w16") == 0) || (strcmp(argv[1], "W16") == 0)) /*写 16位数据 到 指定地址的连续16位*/
  134.     {
  135.         ioctl(fd, REG_W16, buf); /* buf[0]是写入的地址，buf[1]是写入的值 */
  136.     }
  137.     else if((strcmp(argv[1], "w32") == 0) || (strcmp(argv[1], "W32") == 0)) /*写 32位数据 到 指定地址的连续32位*/
  138.     {
  139.         ioctl(fd, REG_W32, buf); /* buf[0]是写入的地址，buf[1]是写入的值 */
  140.     }
  141.     else
  142.     {
  143.         printf("[%s] err!!!", argv[1]);
  144.         return -1;
  145.     }

  147.     return 0;

  149. }


  152. /*
  153. 测试 :
  154. 1, # insmod regeditor.ko
  155. DEVICE : register regeditor Major = [253]

  157. 2, # mknod /dev/regeditor c 253 0
  158.      # ls -lrt /dev/reg*
  159. crw-r--r-- 1 root root 253, 0 Jan 1 01:15 /dev/regeditor

  161. 3, 点亮LED灯
  162. GPBCON = 0x56000010
  163. GPBDAT = 0x56000014
  164. GPBUP = 0x56000018

  166. # ./regeditor w32 0x56000010 0x55555555 //全部配置成输出引脚
  167. # ./regeditor r32 0x56000010
  168.     [00.] [0x56000010] = [0x00155555]
  169. # ./regeditor r8 0x56000010 4
  170.     [00.] [0x56000010] = [0x55]
  171.     [01.] [0x56000011] = [0x55]
  172.     [02.] [0x56000012] = [0x15]
  173.     [03.] [0x56000013] = [0x00]

  175. # ./regeditor w32 0x56000018 0x00000000
  176. # ./regeditor r32 0x56000018
  177.     [00.] [0x56000018] = [0x00000000]
  178. # ./regeditor r8 0x56000018 4
  179.     [00.] [0x56000018] = [0x00]
  180.     [01.] [0x56000019] = [0x00]
  181.     [02.] [0x5600001a] = [0x00]
  182.     [03.] [0x5600001b] = [0x00]

  184. # ./regeditor w32 0x56000014 0xffffffff //灯全灭，蜂鸣器响了。最后1位，1:蜂鸣器响,0:蜂鸣器不响
  185. # ./regeditor w32 0x56000014 0xfffffffe //灯全灭，蜂鸣器不响。
  186. # ./regeditor r32 0x56000014
  187.     [00.] [0x56000014] = [0x000007fe]
  188. # ./regeditor r8 0x56000014 4
  189.     [00.] [0x56000014] = [0xfe]
  190.     [01.] [0x56000015] = [0x07]
  191.     [02.] [0x56000016] = [0x00]
  192.     [03.] [0x56000017] = [0x00]
  193. # ./regeditor w32 0x56000014 0x00000000 //灯全亮，蜂鸣器不响。

  195. # ./regeditor r8 0x56000010 8 //读取8个字节时，读取到 地址 0x56000017 的值。
  196.     [00.] [0x56000010] = [0x55]
  197.     [01.] [0x56000011] = [0x55]
  198.     [02.] [0x56000012] = [0x15]
  199.     [03.] [0x56000013] = [0x00]
  200.     [04.] [0x56000014] = [0xfe]
  201.     [05.] [0x56000015] = [0x07]
  202.     [06.] [0x56000016] = [0x00]
  203.     [07.] [0x56000017] = [0x00]
  204. # ./regeditor r32 0x56000010 3 //一次读取3个寄存器(GPBCON,GPBDAT,GPBUP)的值
  205.     [00.] [0x56000010] = [0x00155555]
  206.     [01.] [0x56000014] = [0x000007fe]
  207.     [02.] [0x56000018] = [0x00000000]
  208.     
  209. # ./regeditor r32 0x48000000 12 //一次读取存储控制器相关的12个寄存器的值。
  210. [00.] [0x48000000] = [0x220dd112]
  211. [01.] [0x48000004] = [0x00000700]
  212. [02.] [0x48000008] = [0x00001c10]
  213. [03.] [0x4800000c] = [0x00001c10]
  214. [04.] [0x48000010] = [0x00001f4c]
  215. [05.] [0x48000014] = [0x00000700]
  216. [06.] [0x48000018] = [0x00000700]
  217. [07.] [0x4800001c] = [0x00018005]
  218. [08.] [0x48000020] = [0x00018005]
  219. [09.] [0x48000024] = [0x008e04f4]
  220. [10.] [0x48000028] = [0x00000032]
  221. [11.] [0x4800002c] = [0x00000030]
  222. */


阅读(686) | 评论(0) | 转发(0) |
0

上一篇：内核线程

下一篇：自己编写一个printk函数

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6