Chinaunix首页 | 论坛 | 博客

路漫漫vincent.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

vincent-cws

  • 博客访问： 959040
  • 博文数量： 116
  • 博客积分： 3923
  • 博客等级： 中校
  • 技术积分： 1337
  • 用 户 组： 普通用户
  • 注册时间： 2009-04-23 01:22
文章分类

全部博文（116）

文章存档

2013年（1）

2012年（17）

2011年（69）

2009年（29）

我的朋友
最近访客
推荐博文
相关博文
实践Linux设备驱动开发

分类： LINUX

2011-12-25 13:42:08

刚看了华清远见的《Linux设备驱动开发详解》，突然就想动手慢慢的实践一番，就当作笔记吧，先来个简单的驱动，其实就是里面的例子，不过感觉写的还是很不错，自己也动手尝试一下：

  1. /*
  2.  * file: gmemd.c
  3.  * history:
  4.  * 20111205: initial
  5.  * 20111205: support async event to app level
  6.  */
  7. #include <linux/init.h>
  8. #include <linux/module.h>
  9. #include <linux/cdev.h>
  10. #include <linux/fs.h>
  11. #include <linux/signal.h>

  13. #include <asm/uaccess.h>

  15. #define GMEMD_MAJOR 221

  17. #define MEM_CLEAR 0x01

  19. #define DEMO_NAME "demo_dev"
  20. #define MEM_SIZE 1024

  22. static int gmemd_major = GMEMD_MAJOR;


  25. typedef struct demo_dev_st
  26. {
  27.     struct cdev cdev;
  28.     unsigned char mem[MEM_SIZE];
  29.     struct fasync_struct *async_queue;
  30. }demo_dev_t;

  32. static struct demo_dev_st* __demo_devp=0;


  35. static int __demo_open (struct inode *inode, struct file *filp)
  36. {
  37.     filp->private_data = __demo_devp;
  38.     printk("==>trace: %s\n", __func__);
  39.     return 0;
  40. }



  44. static ssize_t __demo_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
  45. {
  46.     int ret = 0;
  47.     unsigned long pos = *ppos;
  48.     unsigned long count = size;
  49.     
  50.     struct demo_dev_st* devp = filp->private_data;
  51.     
  52.     printk("==>trace: %s, size=%d, pos=%d\n", __func__, size, pos);
  53.     
  54. #if 0
  55.     if (pos >= MEM_SIZE)
  56.         return count ? -ENXIO : 0;
  57.     if (count > MEM_SIZE - pos)
  58.         count = MEM_SIZE - pos;
  59. #else
  60.     {
  61.         int i=0;
  62.         while (i<MEM_SIZE-1 && devp->mem[i]) i++;
  63.         if (i==MEM_SIZE-1)
  64.         {
  65.             devp->mem[i]=0;
  66.         }
  67.         count = i;
  68.     }
  69. #endif
  70.     
  71.     if (copy_to_user(buf, (void*)(devp->mem+pos), count))
  72.     {
  73.         ret = -EFAULT;
  74.     }
  75.     else
  76.     {
  77. #if 0
  78.         *ppos += count;
  79. #else
  80.         *ppos = 0;
  81. #endif
  82.         ret = count;
  83.     }
  84.     return ret;
  85. }

  87. static ssize_t __demo_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
  88. {
  89.     int ret = 0;
  90.     unsigned long pos = *ppos;
  91.     unsigned long count = size;
  92.     
  93.     struct demo_dev_st* devp = filp->private_data;
  94.     
  95.     printk("==>trace: %s, size=%d, pos=%d\n", __func__, size, pos);
  96.     
  97.     if (pos >= MEM_SIZE)
  98.         return count ? -ENXIO : 0;
  99.     if (count > MEM_SIZE - pos)
  100.         count = MEM_SIZE - pos;
  101.     
  102.     if (copy_from_user(devp->mem+pos,buf,count))
  103.     {
  104.         ret = -EFAULT;
  105.     }
  106.     else
  107.     {
  108. #if 0
  109.         *ppos= count;
  110. #else
  111.         *ppos= 0;
  112. #endif
  113.         ret = count;
  114.         if (devp->async_queue)
  115.             kill_fasync(&devp->async_queue, SIGIO, POLL_IN);
  116.     }
  117.     return ret;
  118. }

  120. static int __demo_fasync(int fd, struct file *filp, int mode)
  121. {
  122.     struct demo_dev_st* devp = filp->private_data;
  123.     printk("==>trace: %s\n", __func__);
  124.     
  125.     return fasync_helper(fd, filp, mode, &devp->async_queue);
  126. }

  128. static loff_t __demo_llseek(struct file *filp, loff_t offset, int orig)
  129. {
  130.     loff_t ret = 0;
  131.     
  132.     struct demo_dev_st* devp = filp->private_data;
  133.     
  134.     printk("==>trace: %s, orig=%d, offset=%d\n", __func__, orig, offset);
  135.     
  136.     switch(orig)
  137.     {
  138.     case 0: /* offset from the 0 position of the file */
  139.         if (offset < 0 || (unsigned int)offset > MEM_SIZE)
  140.         {
  141.             ret = -EINVAL;
  142.             break;
  143.         }
  144.         ret = filp->f_pos = (unsigned int)offset;
  145.         break;
  146.     case 1: /* offset from the current position */
  147.         if ((filp->f_pos+offset)<0||(filp->f_pos+offset)>MEM_SIZE)
  148.         {
  149.             ret = -EINVAL;
  150.             break;
  151.         }
  152.         filp->f_pos += offset;
  153.         ret = filp->f_pos;
  154.         break;
  155.     default:
  156.         ret = -EINVAL;
  157.         break;
  158.     }
  159.     
  160.     return ret;
  161. }


  164. static long __demo_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  165. {
  166.     long ret = 0;
  167.     
  168.     struct demo_dev_st* devp = filp->private_data;
  169.     switch(cmd)
  170.     {
  171.     case MEM_CLEAR:
  172.         memset(devp->mem, 0, MEM_SIZE);
  173.         break;
  174.     default:
  175.         ret = -EINVAL;
  176.         break;
  177.     }
  178.     return ret;
  179. }

  181. static int __demo_release(struct inode *inode, struct file *filp)
  182. {
  183.     struct demo_dev_st* devp = filp->private_data;
  184.     printk("==>trace: %s\n", __func__);
  185.     __demo_fasync(-1, filp, 0);
  186.     return 0;
  187. }


  190. static struct file_operations gmemd_fops =
  191. {
  192.     .owner = THIS_MODULE,
  193.         .read = __demo_read,
  194.         .write = __demo_write,
  195.         .open = __demo_open,
  196.         .release = __demo_release,
  197.         .fasync = __demo_fasync,
  198.         .llseek = __demo_llseek,
  199.         .ioctl = __demo_ioctl,
  200. };

  202. static int __gmemd_init()
  203. {
  204.     int ret = 0;
  205.     dev_t devno = MKDEV(gmemd_major, 0);
  206.     
  207.     printk("==>trace: %s\n", __func__);
  208.     
  209.     if (gmemd_major)
  210.     {
  211.         ret = register_chrdev_region(devno,1,DEMO_NAME);
  212.     }
  213.     else
  214.     {
  215.         ret = alloc_chrdev_region(&devno, 0, 1, DEMO_NAME);
  216.         gmemd_major = MAJOR(devno);
  217.     }
  218.     if (ret < 0)
  219.         return ret;
  220.     
  221.     __demo_devp=kmalloc(sizeof(demo_dev_t),GFP_KERNEL); /* __get_free_pages */
  222.     
  223.     if (!__demo_devp)
  224.     {
  225.         ret = -ENOMEM;
  226.         goto __err_exit;
  227.     }
  228.     memset(__demo_devp, 0, sizeof(demo_dev_t));
  229.     
  230.     cdev_init(&__demo_devp->cdev , &gmemd_fops);
  231.     __demo_devp->cdev.owner = THIS_MODULE;
  232.     ret = cdev_add(&__demo_devp->cdev, devno, 1);
  233.     if (ret)
  234.         printk(KERN_INFO "error to cdev_add() ... \n");
  235.     
  236.     return ret;
  237.     
  238. __err_exit:
  239.     unregister_chrdev_region(devno, 1);
  240.     
  241.     return ret;
  242. }

  244. static void __gmemd_exit()
  245. {
  246.     printk("==>trace: %s\n", __func__);
  247.     cdev_del(&__demo_devp->cdev);
  248.     kfree(__demo_devp);
  249.     __demo_devp=0;
  250.     unregister_chrdev_region(MKDEV(gmemd_major,0), 1);
  251. }

  253. module_init(__gmemd_init);
  254. module_exit(__gmemd_exit);

  256. MODULE_AUTHOR("vincent");
  257. MODULE_DESCRIPTION("nothing to say...");
  258. MODULE_LICENSE("GPL");
  259. MODULE_ALIAS("test");

应用层测试用的APP:

  1. /*
  2.  * file: client.c
  3.  * history:
  4.  * 20111205: initial, for test async event in the app level
  5.  */

  7. #include <unistd.h>
  8. #include <fcntl.h>
  9. #include <signal.h>
  10. #include <stdio.h>
  11. #include <sys/stat.h>

  13. #define DEMO_DEV "/dev/gmemd"

  15. static int s_fd=-1;


  18. static void __sig_handler(int signum)
  19. {
  20. #define MAX_BUF 1023
  21.     int count = 0;
  22.     char buf[MAX_BUF+1]= {0};
  23.     
  24.     printf("==>signum:%d\n", signum);
  25.     
  26.     if (s_fd!=-1)
  27.     {
  28.         while ((count=read(s_fd, buf, MAX_BUF))>=MAX_BUF)
  29.         {
  30.             printf("count:%d=>%s\n", count,(buf[MAX_BUF]=0,buf));
  31.         }
  32.         printf("count:%d=>%s\n", count,(buf[count]=0,buf));
  33.     }
  34. }

  36. int main(void)
  37. {
  38.     int fd, oflags;
  39.     printf("wellcome to startup the client program!\n");
  40.     s_fd = fd = open (DEMO_DEV, O_RDWR, S_IRUSR|S_IWUSR);
  41.     if (fd==-1)
  42.     {
  43.         printf("open %s failed!\n", DEMO_DEV);
  44.         return -1;
  45.     }
  46.     else
  47.     {
  48.         printf("open %s successful!\n", DEMO_DEV);
  49.         signal(SIGIO, __sig_handler);
  50.         fcntl(fd, F_SETOWN, getpid());
  51.         oflags = fcntl(fd, F_GETFL);
  52.         fcntl(fd, F_SETFL, oflags|FASYNC);
  53.         while(1);
  54.     }
  55. }


接下来就是Makefile:
  1. #Makefile

  3. obj-m := gmemd.o

  5. KDIR := /usr/src/linux-headers-2.6.24-16-generic

  7. CC := gcc

  9. default:
  10.     make -C $(KDIR) M=$(PWD) modules

  12. client: client.o
  13.     $(CC) -Wall client.c -o client

编译之前发现自己的gcc没下载开发包，需要执行指令：
sudo apt-get install build-essential

然后编译：
make
make client
再加载模块：
insmod gmemd.ko
再查看加载的模块：
lsmod | grep gmemd
再查看注册的设备信息：
cat /proc/devices
再在/dev/目录下创建一个设备节点信息提供给应用层的访问：
mknod /dev/gmemd c 221 0
查看设备节点信息:
ls -l /dev/gmemd
再对设备节点对其读写：
echo "test" > /dev/gmemd
cat /dev/gmemd
测试异步IO响应事件：
./client &
echo "test" > /dev/gmemd
再查看里面printk打印出来的日志信息:
cat /var/log/messages
最后删除设备节点和卸载模块:
rm /dev/gmemd
rmmod gmemd
完成

附件：

 gmemd.rar  







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

上一篇：【转】register 修饰符使用

下一篇：『转』伪终端设备之我见

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

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

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

16024965号-6