Chinaunix首页 | 论坛 | 博客

river0830的ChinaUnix博客

首页　| 　博文目录　| 　关于我

river0830

  • 博客访问： 32552
  • 博文数量： 6
  • 博客积分： 100
  • 博客等级： 民兵
  • 技术积分： 70
  • 用 户 组： 普通用户
  • 注册时间： 2011-03-31 22:59
文章分类

全部博文（6）

文章存档

2012年（5）

2011年（1）

我的朋友
最近访客
推荐博文
相关博文
linux驱动初步学习—globalfifo

分类： 系统运维

2012-03-24 00:15:50

/* 
 * 驱动学习 globalfifo.c 
 * 内核版本2.6.27之前的创建设备节点的函数是struct class_device class_device_create 
 * class_device_destory
 */
  1. #include <linux/module.h>
  2. #include <linux/slab.h>
  3. #include <linux/types.h>
  4. #include <linux/fs.h>
  5. #include <linux/errno.h>
  6. #include <linux/mm.h>
  7. #include <linux/sched.h>
  8. #include <linux/moduleparam.h>
  9. #include <linux/init.h>
  10. #include <linux/cdev.h>
  11. #include <linux/wait.h>
  12. #include <linux/poll.h>
  13. #include <linux/device.h>

  15. #include <asm/io.h>
  16. #include <asm/system.h>
  17. #include <asm/uaccess.h>

  19. #define GLOBALMEM_SIZE 0x1000
  20. #define MEM_CLEAN 0x01
  21. #define GLOBALMEM_MAJOR 0

  23. struct globalfifo_dev
  24. {
  25.     unsigned int leng;
  26.     struct cdev cdev;
  27.      struct semaphore sem;
  28.     unsigned char mem[GLOBALMEM_SIZE];
  29.     wait_queue_head_t r_wait;
  30.     wait_queue_head_t w_wait;
  31.     struct fasync_struct *async_queue;
  32. };

  34. static struct globalfifo_dev *globalfifo_devp;
  35. static struct class *global_class;
  36. static struct device *global_device;
  37. static int globalfifo_major = GLOBALMEM_MAJOR;

  39. MODULE_AUTHOR("RIVER");
  40. MODULE_LICENSE("Dual BSD/GPL");

  42. static ssize_t globalfifo_read(struct file *filp, char __user *buf,size_t size, loff_t *f_ops)
  43. {
  44.     struct globalfifo_dev *dev = filp->private_data;
  45.     int ret;
  46.     DECLARE_WAITQUEUE(rwait, current);

  48.     down(&dev->sem);
  49.     add_wait_queue(&dev->r_wait, &rwait);

  51.     if(dev->leng == 0)
  52.     {
  53.         if(filp->f_flags & O_NONBLOCK)
  54.         {
  55.             ret = -EAGAIN;
  56.             goto out;
  57.         }
  58.         set_current_state(TASK_INTERRUPTIBLE);
  59.         up(&dev->sem);

  61.         schedule();
  62.         if(signal_pending(current)) //awake by signal
  63.         {
  64.             ret = -ERESTARTSYS;
  65.             goto out1;
  66.         }
  67.         down(&dev->sem);
  68.     }

  70.     if(size > dev->leng)
  71.         size = dev->leng;
  72.             
  73.     if(copy_to_user(buf,(void *)dev->mem, size))
  74.     {
  75.         ret = -EFAULT;
  76.         goto out;
  77.     }
  78.     else
  79.     {
  80.         memcpy(dev->mem, dev->mem + size, dev->leng - size);
  81.         dev->leng -= size;
  82.         printk(KERN_INFO "read %d bytes current leng=%d \n", size, dev->leng);
  83.         wake_up_interruptible(&dev->w_wait);
  84.         ret = size;
  85.     }
  86. out:
  87.     up(&dev->sem);
  88. out1:
  89.     remove_wait_queue(&dev->r_wait, &rwait);
  90.     set_current_state(TASK_RUNNING);
  91.     return ret;
  92. }

  94. static ssize_t globalfifo_write(struct file *filp,const char __user *buf, size_t size, loff_t *f_ops)
  95. {
  96.     struct globalfifo_dev *dev = filp->private_data;
  97.     int ret;
  98.     DECLARE_WAITQUEUE(wwait, current);

  100.     down(&dev->sem);
  101.     add_wait_queue(&dev->w_wait, &wwait);

  103.     if(dev->leng == GLOBALMEM_SIZE)
  104.     {
  105.         if(filp->f_flags & O_NONBLOCK)
  106.         {
  107.             ret = -EAGAIN;
  108.             goto out;
  109.         }
  110.     
  111.      __set_current_state(TASK_INTERRUPTIBLE);
  112.      up(&dev->sem); //avoid deadlock
  113.      schedule();
  114. // interruptible_sleep_on(&dev->w_wait);
  115.      if(signal_pending(current))
  116.      {
  117.      ret = -ERESTARTSYS;
  118.      goto out1;
  119.      }

  121.      down(&dev->sem);
  122.     }

  124.     if(size > GLOBALMEM_SIZE - dev->leng)
  125.         size = GLOBALMEM_SIZE- dev->leng;

  127.     if(copy_from_user(dev->mem,buf,size))
  128.     {
  129.         ret = - EFAULT;
  130.         goto out;
  131.     }
  132.     else
  133.     {
  134.         ret = size;
  135.         dev->leng += size;
  136.         printk(KERN_INFO "written %d bytes leng=%d\n", size, dev->leng);
  137.         wake_up_interruptible(&dev->r_wait);

  139.         if(dev->async_queue) //async read signal
  140.          kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
  141.     }

  143. out:    
  144.     up(&dev->sem);
  145. out1:
  146.     remove_wait_queue(&dev->w_wait, &wwait);
  147.     set_current_state(TASK_RUNNING);

  149.     return ret;
  150. }

  152. static int globalfifo_ioctl(struct inode *inode,struct file *filp,unsigned int cmd, unsigned long arg)
  153. {
  154.     struct globalfifo_dev *dev = filp->private_data;

  156.     switch(cmd)
  157.     {
  158.         case MEM_CLEAN:
  159.             if(down_interruptible(&dev->sem))
  160.             {
  161.                 return -ERESTARTSYS;
  162.             }
  163.             
  164.             memset(dev->mem,0,GLOBALMEM_SIZE);
  165.             printk(KERN_INFO "globalfifo is set to zero %d\n",MEM_CLEAN);
  166.             up(&dev->sem);
  167.             
  168.             break;

  170.         default:
  171.             return - EINVAL;
  172.     }
  173.     return 0;
  174. }

  176. static unsigned int globalfifo_poll(struct file *filp, struct poll_table_struct *wait)
  177. {
  178.     unsigned int mask = 0;
  179.     struct globalfifo_dev *dev = filp->private_data;

  181.     down(&dev->sem);
  182.     poll_wait(filp, &dev->r_wait, wait);
  183.     poll_wait(filp, &dev->w_wait, wait);

  185.     if(dev->leng != 0)
  186.         mask |= POLLIN | POLLRDNORM;

  188.     if(dev->leng != GLOBALMEM_SIZE)
  189.         mask |= POLLOUT | POLLWRBAND;

  191.     up(&dev->sem);
  192.     return mask;
  193. }

  195. static int globalfifo_fasync(int fd, struct file *filp, int mode)
  196. {
  197.     struct globalfifo_dev *dev = filp->private_data;

  199.     return fasync_helper(fd, filp, mode, &dev->async_queue);
  200. }
  201.     
  202. static int globalfifo_open(struct inode *inode, struct file *filp)
  203. {
  204.     struct globalfifo_dev *dev;

  206.     dev = container_of(inode->i_cdev,struct globalfifo_dev,cdev);
  207.     filp->private_data = dev;

  209.     return 0;
  210. }

  212. static int globalfifo_release(struct inode *inode, struct file *filp)
  213. {
  214.     globalfifo_fasync(-1, filp, 0);

  216.     return 0;
  217. }


  220.     
  221. static struct file_operations globalfifo_fops =
  222. {
  223.     .owner = THIS_MODULE,
  224.     .read = globalfifo_read,
  225.     .write = globalfifo_write,
  226.     .ioctl = globalfifo_ioctl,
  227.     .poll = globalfifo_poll,
  228.     .open = globalfifo_open,
  229.     .release = globalfifo_release,
  230.     .fasync = globalfifo_fasync,
  231. };

  233. static void globalfifo_setup_cdev(struct globalfifo_dev *dev,int index)
  234. {
  235.     int err;
  236.     dev_t devno = MKDEV(globalfifo_major,index);

  238.     cdev_init(&dev->cdev,&globalfifo_fops);
  239.     dev->cdev.owner = THIS_MODULE;
  240.     dev->cdev.ops = &globalfifo_fops;
  241.     err = cdev_add(&dev->cdev,devno,1);
  242.     if(err)
  243.         printk(KERN_NOTICE "Error %d adding globalfifo %d",err,index);
  244.     init_MUTEX(&dev->sem);
  245.     init_waitqueue_head(&dev->r_wait);
  246.     init_waitqueue_head(&dev->w_wait);
  247. }

  249. static int __init globalfifo_init(void)
  250. {
  251.     int result;
  252.     dev_t devno;

  254.     if(globalfifo_major)
  255.     {
  256.         devno = MKDEV(globalfifo_major,0);
  257.         result = register_chrdev_region(devno,1,"globalfifo");
  258.     }
  259.     else
  260.     {
  261.         result = alloc_chrdev_region(&devno,0,1,"globalfifo");
  262.         globalfifo_major = MAJOR(devno);
  263.     }

  265.     if(result < 0)
  266.         return result;

  268.     globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev),GFP_KERNEL);
  269.     if(!globalfifo_devp)
  270.     {
  271.         result = - ENOMEM;
  272.         goto fail_malloc;
  273.     }

  275.     memset(globalfifo_devp,0,sizeof(struct globalfifo_dev));
  276.     globalfifo_setup_cdev(globalfifo_devp,0);
  277.     global_class = class_create(THIS_MODULE, "globalfifo");
  278.     if(IS_ERR(global_class))
  279.     {
  280.         result = -EFAULT;
  281.         goto fail_malloc;
  282.     }
  283.     global_device = device_create(global_class, NULL, MKDEV(globalfifo_major,0), NULL, "globalfifo");

  285.     return 0;

  287. fail_malloc:
  288.     unregister_chrdev_region(devno,1);
  289.     return result;
  290. }

  292. static void __exit globalfifo_exit(void)
  293. {
  294.     cdev_del(&globalfifo_devp->cdev);
  295.     kfree(globalfifo_devp);
  296.     device_destroy(global_class, MKDEV(globalfifo_major, 0));
  297.     class_destroy(global_class);
  298.     unregister_chrdev_region(MKDEV(globalfifo_major,0),1);
  299. }

  301. module_param(globalfifo_major,int,S_IRUGO);

  303. module_init(globalfifo_init);
  304. module_exit(globalfifo_exit);
/* 驱动Makefile */

KERNELDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

install:
insmod globalmem.ko
uninstall:
rmmod globalmem.ko

clean:
$(MAKE) -C $(KERNELDIR) M=$(PWD) clean
endif

/* 
 * 驱动验证  global.c
 */

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <fcntl.h>
  5. #include <sys/types.h>
  6. #include <sys/time.h>
  7. #include <sys/stat.h>

  9. #define MAX 512

  11. int main(void)
  12. {
  13.     int fd, fd1;
  14.     char str[MAX] = {0}, buf[25] = {0};
  15.     int i = 0;
  16.     pid_t pid;
  17.     struct timeval to;
  18.     fd_set rfds;
  19.     
  20.     pid = fork();
  21.     while(1)
  22.     {
  23.         if(pid < 0)
  24.         {
  25.             printf("ERR in fork\n");
  26.         }
  27.         else if(pid != 0)
  28.         {
  29.             fd1 = open("/dev/globalfifo",O_RDWR);

  31.             if(fd1 < 0)
  32.             {
  33.                  printf("the globalfifo can't be open\n");
  34.                 continue;
  35.             }
  36.         
  37.             sleep(1);
  38.             snprintf(buf, 10, "hello %d", i++);
  39.             if( i > 3 )
  40.             {
  41.                 i = 0;
  42.                 sleep(3);
  43.                 close(fd1);
  44.                 continue;
  45.             }
  46.             write(fd1, buf, strlen(buf));
  47.             memset(buf, 0, 25);
  48.             close(fd1);
  49.         }
  50.         else
  51.         {
  52.             fd = open("/dev/globalfifo", 0);
  53.             if(fd < 0)
  54.             {
  55.                 printf("the globalfifo can't open\n");
  56.                 continue;
  57.             }
  58.             FD_ZERO(&rfds);
  59.             FD_SET(fd, &rfds);
  60.             to.tv_sec = 3; //timeout 3s
  61.             to.tv_usec = 0;

  63.             select(fd+1, &rfds, NULL, NULL, &to);
  64.             {
  65.                 if(FD_ISSET(fd, &rfds))
  66.                 {
  67.                     read(fd, str, 10);
  68.                     str[10] = 0;
  69.                     printf("%s\n", str);
  70.                     memset(str, 0, 10);
  71.                 }
  72.                 else
  73.                 {
  74.                     printf("time out\n");
  75.                 }
  76.             }
  77.             close(fd);
  78.         }
  79.     }
  80.     return 0;
  81. }
运行
#gcc -o fifo global.c
#./fifo
 hello0
 hello1
 hello2
 timeout
 ....

/*
 * 异步通知程序
 */

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <signal.h>

  9. #define MAX_LEN 30

  11. int fd = -1;

  13. void input_handle(int sig)
  14. {
  15.     char buf[MAX_LEN] = {0};
  16.     int len;

  18.     printf("receive buf from globalfifo, signal = %d\n", sig);
  19.     if(fd > 0)
  20.     {
  21.         len = read(fd, &buf, MAX_LEN);
  22.         buf[len] = 0;
  23.         printf("%s\n", buf);
  24.         close(fd);
  25. fd = -1;
  26.     }
  27. }

  29. int main(void)
  30. {
  31.     int flag;

  33.     fd = open("/dev/globalfifo", 0);
  34.     if(fd > 0)
  35.     {
  36.         signal(SIGIO, input_handle);
  37.         fcntl(fd, F_SETOWN, getpid());
  38.         flag = fcntl(fd, F_GETFL);
  39.         fcntl(fd, F_SETFL, flag | FASYNC);
  40.         sleep(5);
  41.     }
  42.     else
  43.     {
  44.         perror("open /dev/globalfifo");
  45.     }

  47.     return 0;
  48. }
运行#./fifo,  再开一个终端#echo 'hello' > /dev/globalfifo
receive buf from globalfifo, signal = 29
hello

阅读(2343) | 评论(1) | 转发(1) |
0

上一篇：构建基本的嵌入式Linux根文件系统

下一篇：Linux IIO子系统分析-1-概述

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

桔子T恤2012-03-27 22:32:27

内核版本2.6.27之前的创建设备节点的函数是struct class_device class_device_create

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6