linux内核动态调试信息的打开pr-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

for my cute boy

凯发app官方网站首页　| 　博文目录　| 　关于我

formycuteboy

  • 博客访问： 1125414
  • 博文数量： 146
  • 博客积分： 190
  • 博客等级： 入伍新兵
  • 技术积分： 5225
  • 用 户 组： 普通用户
  • 注册时间： 2012-06-06 08:24
个人简介

慢行者

文章分类

全部博文（146）

文章存档

2013年（145）

2012年（1）

我的朋友
最近访客
推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
linux内核动态调试信息的打开pr_debug（基于按键驱动，全过程记录）

分类： linux

2013-05-24 15:56:49

原文地址： 作者：


所用到源码： 

【1】配置kconfig，添加要调试驱动模块的debug选项
如在driver/char目录下的kconfig中添加如下代码：
  1. config my_key//该部分配置驱动是否编译进内核/编译为内核模块/不编译
  2.     tristate "key driver for friendlyarm tiny6410 development boards"
  3.     depends on cpu_s3c6410
  4.     default m
  5.     help
  6.       this is buttons driver, add by jason

  8. config my_key_debug//该部分是调试时添加，配置是否打印调试信息，如果不需要可不添加
  9.     bool "support my_key debug"
  10.     help
  11.       this is debug function, add by jason
  12. depends on my_key

【2】配置makefile，添加编译支持驱动模块 extra_cflags = -ddebug
如在driver/char目录下的makefile中添加如下代码：
  1. obj-$(config_my_key)        = my_key.o
  2. ifeq ($(config_my_key_debug), y)            //判断是否调试驱动
  3.     extra_cflags = -ddebug
  4. endif

【3】配置内核，使支持动态调试
kernel hacking  --->
[*] tracers  --->
[*] trace max stack
kernel hacking  --->
[*] enable dynamic printk() support


【4】如果驱动选择的是动态加载，则重新编译模块（make modules）；否则，重新编译内核（make uimage -j4）。

【5】如果驱动选择的是动态加载，则传*.ko文件到板子的文件系统；否则，重烧内核。然后改变控制台debug消息显示级别7-->8，可以打印printk(debug ...)信息。

【6】驱动源码：蓝绿色部分是pr_debug，有了这个，就可以在配置内核时通过选择或取消debug选项，控制调试信息的开和关；绿色部分是在代码里通过修改driver_debug的值，控制调试信息的开和关，相比较，很显然是pr_debug比较方便。
  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  4. #include <linux/fs.h>
  5. #include <linux/errno.h>
  6. #include <linux/cdev.h>
  7. #include <linux/types.h>
  8. #include <linux/device.h>
  9. #include <linux/mm.h>
  10. #include <linux/slab.h>
  11. #include <linux/sched.h>
  12. #include <linux/poll.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/irq.h>
  15. #include <asm/uaccess.h>
  16. #include <asm/irq.h>
  17. #include <asm/io.h>
  18. #include <asm/system.h>
  19. #include <mach/map.h>
  20. #include <mach/regs-clock.h>
  21. #include <mach/regs-gpio.h>
  22. #include <mach/irqs.h>
  23. #include <mach/gpio-bank-n.h>
  24. #include <plat/gpio-cfg.h>

  26. #define driver_debug   1
  27. #define device_name        "mykey"

  29. /* parameters */

  31. static int major;
  32. static int minor = 0;
  33. static int nr_devs = 1;            /* number of devices */

  35. static declare_wait_queue_head(button_waitq);

  37. static struct fasync_struct *button_async;

  39. /* 中断事件标志, 中断服务程序将它置1，third_drv_read将它清0 */
  40. static volatile int ev_press = 0;

  42. /* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
  43. /* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
  44. struct pin_desc{
  45.     unsigned int pin_num;
  46.     unsigned int key_val;
  47. };

  49. struct pin_desc pins_desc[4] = {
  50.     {0x00, 0x01},
  51.     {0x01, 0x02},
  52.     {0x02, 0x03},
  53.     {0x03, 0x04},
  54. };

  56. static unsigned char key_val;

  58. struct class *mykey_class;

  60. struct mykey_dev {
  61.     struct cdev cdev;        /* char device structure */
  62. }*mykey_devp;            /* device structure pointer */

  64. /*
  65. * 确定按键值
  66. */
  67. static irqreturn_t buttons_irq(int irq, void *dev_id, struct pt_regs *regs)
  68. {
  69.     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
  70.     unsigned int pinval;

  72.     pr_debug("in the %s function!\n", __function__);

  74.     pinval = (~readl(s3c64xx_gpndat)) & (1 << pindesc->pin_num);

  76.     if (pinval)    //one of the key is pressed
  77.         key_val = pindesc->key_val;
  78.     else
  79.         key_val = 0x80 | pindesc->key_val;

  81.     ev_press = 1;                          /* 表示中断发生了 */

  83.     wake_up_interruptible(&button_waitq);/* 唤醒休眠的进程 */

  85.     kill_fasync (&button_async, sigio, poll_in);

  87.     return irq_retval(irq_handled);
  88. }


  91. /*
  92. * the fasync function of device driver.
  93. */
  94. static int mykey_fasync (int fd, struct file *filp, int on)
  95. {
  96.     pr_debug("driver: mykey_fasync!\n");

  98.     return fasync_helper (fd, filp, on, &button_async);
  99. }


  102. /*
  103. * the open function of device driver.
  104. */

  106. static int mykey_open(struct inode *inode, struct file *filp)
  107. {
  108.     pr_debug("in the %s function!\n", __function__);

  110.     request_irq(irq_eint(0), buttons_irq, irq_type_edge_both, "s1", &pins_desc[0]);
  111.     request_irq(irq_eint(1), buttons_irq, irq_type_edge_both, "s2", &pins_desc[1]);
  112.     request_irq(irq_eint(2), buttons_irq, irq_type_edge_both, "s3", &pins_desc[2]);
  113.     request_irq(irq_eint(3), buttons_irq, irq_type_edge_both, "s4", &pins_desc[3]);

  115.     return 0;
  116. }


  119. /*
  120. * the release function of device driver.
  121. */
  122. static int mykey_release(struct inode *inode, struct file *filp)
  123. {
  124.     pr_debug("in the %s function!\n", __function__);

  126.     free_irq(irq_eint(0), &pins_desc[0]);
  127.     free_irq(irq_eint(1), &pins_desc[1]);
  128.     free_irq(irq_eint(2), &pins_desc[2]);
  129.     free_irq(irq_eint(3), &pins_desc[3]);

  131.     return 0;
  132. }


  135. /*
  136. * the read function of device driver.
  137. */
  138. static int mykey_read(struct file *filp, char __user *buff,
  139.         size_t count, loff_t *offp)
  140. {
  141.     pr_debug("in the %s function!\n", __function__);

  143.     /* 如果没有按键动作, 休眠 */
  144.     wait_event_interruptible(button_waitq, ev_press);

  146.     pr_debug("starting to read data in the %s function!\n", __function__);

  148.     /* 如果有按键动作, 返回键值 */
  149.     copy_to_user(buff, &key_val, 1);

  151.     ev_press = 0;

  153.     return 1;
  154. }


  157. /*
  158. * the file operations for the device
  159. */
  160. static struct file_operations mykey_fops = {
  161. .owner =this_module,
  162. .open =mykey_open,
  163. .release=mykey_release,
  164. .read =mykey_read,
  165. .fasync=mykey_fasync,
  166. };


  169. /*
  170. * set up a cdev entry.
  171. */
  172. static void mykey_setup_cdev(struct mykey_dev *dev, int index)
  173. {
  174.     int err, devno;

  176.     devno= mkdev(major, minor index);
  177.     cdev_init(&dev->cdev, &mykey_fops);
  178.     dev->cdev.owner = this_module;
  179.     err = cdev_add (&dev->cdev, devno, 1);
  180.     if (err)
  181.         printk(kern_notice "error %d adding mykey%d", err, index);
  182. }


  185. /*
  186. * initialize the pipe devs; return how many we did.
  187. */
  188. static int __init mykey_init_module(void)
  189. {
  190.     int ret;

  192.     dev_t devno = mkdev(major, minor);
  193.     
  194.    pr_debug("in the %s function!\n", __function__);

  196.     if (major)
  197.         ret = register_chrdev_region(devno, nr_devs, device_name);
  198.     else {
  199.         ret = alloc_chrdev_region(&devno, minor, nr_devs, device_name);
  200.         major = major(devno);
  201.     }
  202.     if (ret < 0) {
  203.         printk(kern_warning "%s: can't get major %d\n", \
  204.             device_name, major);
  205.         return ret;
  206.     }

  208.     pr_debug("after \"alloc_chrdev_region()\"\n");

  210.     mykey_devp = kzalloc(sizeof(struct mykey_dev), gfp_kernel);
  211.     if (!mykey_devp) {
  212.         ret =- enomem;
  213.         goto fail_malloc;
  214.     }

  216.     pr_debug("after \"kzalloc()\"\n");

  218.     /*  the following step must after kmalloc() and memset() */
  219.     mykey_setup_cdev(mykey_devp, 0);

  221.     pr_debug("after \"mykey_setup_cdev()\"\n");

  223.      /* 1. create your own class under /sys
  224.     *  2. register your own device in sys
  225.     *     this will cause udev to create corresponding device node
  226.     */
  227.     mykey_class = class_create(this_module, "mykey_class");
  228.     if (is_err(mykey_class)) {
  229.         printk(device_name " failed in creating class./n");
  230.         return -1;
  231.     }
  232.     device_create(mykey_class, null, devno, null, "mykey""%d", 0);

  234.     pr_debug("after \"class_create()\" and \"device_create\"\n");

#ifdef driver_debug
  1. printk(device_name "\tinitialized, major = %d, minor = %d.\n",
  2.         major, minor);
  3. #endif
  1.     return 0;

  3. fail_malloc:
  4.     unregister_chrdev_region(devno, 1);

  6.     return ret;
  7. }


  10. /*
  11. * this is called by cleanup_module or on failure.
  12. */

  14. static void __exit mykey_exit_module(void)
  15. {
  16.     pr_debug("in the %s function!\n", __function__);

  18.     device_destroy(mykey_class, mkdev(major, minor));
  19.     class_destroy(mykey_class);
  20.     cdev_del(&mykey_devp->cdev);
  21.     kfree(mykey_devp);
  22.     unregister_chrdev_region(mkdev(major, minor), 1);   

  #ifdef driver_debug
  1.     printk(device_name "\texited!\n");
  2. #endif
  3. }

  5. module_init(mykey_init_module);
  6. module_exit(mykey_exit_module);

  8. module_author("jason lu");
  9. module_version("0.1.0");
  10. module_description("jason's blog: http://blog.chinaunix.net/space.php?\
  11.         uid=20746260");
  12. module_license("dual mpl/gpl");

【7】以下是【3】里support my_key debug未选中时的运行情况。

【8】keytest.c源码
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>
  5. #include <poll.h>
  6. #include <signal.h>
  7. #include <sys/types.h>
  8. #include <unistd.h>
  9. #include <fcntl.h>

  11. int fd;

  13. void my_signal_fun(int signum)
  14. {
  15.     unsigned char key_val;
  16.     read(fd, &key_val, 1);
  17.     printf("key_val: 0x%x\n", key_val);
  18. }

  20. int main(int argc, char **argv)
  21. {
  22.     int oflags;

  24.     signal(sigio, my_signal_fun);
  25.    
  26.     fd = open("/dev/mykey0", o_rdwr);
  27.     if (fd < 0)
  28.     {
  29.         printf("can't open!\n");
  30.     }

  32.     fcntl(fd, f_setown, getpid());   
  33.     oflags = fcntl(fd, f_getfl);    
  34.     fcntl(fd, f_setfl, oflags | fasync);

  36.     while (1)
  37.     {
  38.         sleep(1000);
  39.     }
  40.    
  41.     return 0;
  42. }
阅读(2864) | 评论(0) | 转发(0) |
0

上一篇：嵌入式linux之我行——按键驱动在2440上的实例开发（带去抖动）

下一篇：c语言终极面试宝典_c语言面试必备

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图