2.6内核字符驱动示例程序

/*
 *
 * kf701_chardev.c
 *
 * 2006-12-06 13:22:22
 *
 * Contact me: kf701.ye AT gmail.com
 *
 * 2.6内核字符驱动示例程序，供学习。
 *
 * /dev/kf701_chardev0
 * /proc/devices
 *
 * 分配1024个字节的buffer,对/dev/kf701_chardev0的读写将
 * 作用到buffer上。目前的写操作会覆盖先前的buffer。
 *
 * 内核定时器每次向buffer里追加一个字符和一个回车。
 *
 * 测试方法：
 * $> echo "only for test" > /dev/kf701_chardev0
 * $> cat /dev/kf701_chardev0
 *
 * 2006-12-18 09:19:44 修改
 * 加入对 NONBLOCK 和 poll 的支持。
 *
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/ioctl.h>
#include <linux/poll.h>
#include <linux/wait.h>

int chardev_open(struct inode *, struct file *);
int chardev_release(struct inode *, struct file *);
ssize_t chardev_read(struct file *, char __user *, size_t, loff_t *);
ssize_t chardev_write(struct file *, const char __user *, size_t, loff_t *);
int chardev_ioctl(struct inode *,struct file *,unsigned int,unsigned long);
unsigned int chardev_poll(struct file* file, poll_table *wait);
void timer_function(unsigned long);

#define DEVICE "kf701_chardev"
#define SUCCESS 0
#define BUF_SIZE 1024
#define TIMER_INTERVAL 20 // 每20秒运行一次定时器函数



int major = 233;
int minor = 0;

// define ioctl command


#define KF701_IOC_MAGIC 'K'
#define KF701_IO_RESET _IO(KF701_IOC_MAGIC,0)
#define KF701_IO_R _IOR(KF701_IOC_MAGIC,1,int)
#define KF701_IO_W _IOW(KF701_IOC_MAGIC,2,int)
#define KF701_IO_RW _IOWR(KF701_IOC_MAGIC,3,int)
#define KF701_IOC_MAXNR 4

struct file_operations fops = {
        .owner = THIS_MODULE,
        .read = chardev_read,
        .write = chardev_write,
        .open = chardev_open,
        .release = chardev_release,
        .ioctl = chardev_ioctl,
        .poll = chardev_poll,
};

struct my_dev{
        wait_queue_head_t rq; // 读取等待队列


        uint8_t *buf;
        uint32_t size;
        uint32_t index;
        struct semaphore sem;
        struct cdev cdev;
        struct timer_list timer;
        char timer_char;
        uint32_t timer_interval;
};

struct my_dev *kf701_dev;

static int __init chardev_init(void)
{
        // 1. 分配主设备号


        dev_t devno = MKDEV( major, minor );
        int ret = register_chrdev_region( devno, 1, DEVICE );
        if( ret < 0 )
        {
          printk(KERN_DEBUG "register major number failed with %d\n", ret);
          return ret;
        }
        printk(KERN_DEBUG "%s:register major number OK\n",DEVICE);

        // 2. 注册设备


        kf701_dev = kmalloc(sizeof(struct my_dev), GFP_KERNEL);
        memset( kf701_dev, 0, sizeof(struct my_dev) );
        cdev_init( &kf701_dev->cdev, &fops );
        kf701_dev->cdev.ops = &fops;
        kf701_dev->cdev.owner = THIS_MODULE;
        ret = cdev_add( &kf701_dev->cdev, devno, 1 );
        if( ret < 0 )
        {
          printk(KERN_DEBUG "register device failed with %d\n", ret);
          return ret;
        }
        printk(KERN_DEBUG "%s:register device OK\n",DEVICE);

        // 3. 分配本驱动要使用的内存


        kf701_dev->index = 0;
        kf701_dev->size = BUF_SIZE;
        kf701_dev->buf = kmalloc( kf701_dev->size, GFP_KERNEL );
        if( NULL == kf701_dev->buf )
        {
          printk(KERN_DEBUG "kmalloc failed\n");
          return -ENOMEM;
        }
        printk(KERN_DEBUG "%s:kmalloc buffer OK\n",DEVICE);

        // 4. 初始化信号量


        init_MUTEX( &(kf701_dev->sem) );
        printk(KERN_DEBUG "%s:init semaphore OK\n",DEVICE);

        // 5. 初始化等待队列头


        init_waitqueue_head(&kf701_dev->rq);

        // 6. 初始化并启动定时器


        kf701_dev->timer_char = 'A';
        init_timer( &kf701_dev->timer );
        kf701_dev->timer_interval = HZ * TIMER_INTERVAL;
        kf701_dev->timer.function = timer_function;
        kf701_dev->timer.expires = jiffies + kf701_dev->timer_interval;
        kf701_dev->timer.data = (unsigned long)kf701_dev;
        add_timer( &kf701_dev->timer );
        printk(KERN_DEBUG "%s:init timer OK\n",DEVICE);

        return SUCCESS;
}

static void __exit chardev_exit(void)
{
        dev_t devno = MKDEV( major, minor );
        // 以相反的顺序清除


        del_timer_sync( &kf701_dev->timer );
        printk(KERN_DEBUG "%s:del timer OK\n",DEVICE);
        kfree( kf701_dev->buf );
        cdev_del( &kf701_dev->cdev );
        kfree( kf701_dev );
        printk(KERN_DEBUG "%s:kfree OK\n",DEVICE);
        unregister_chrdev_region( devno, 1 );
        printk(KERN_DEBUG "%s:unregister device OK\n",DEVICE);
}

int chardev_open(struct inode *inode, struct file *file)
{
        struct my_dev *dev = container_of(inode->i_cdev, struct my_dev, cdev);
        file->private_data = dev;

        printk(KERN_DEBUG "%s:open OK\n",DEVICE);
        return SUCCESS;
}

int chardev_release(struct inode *inode, struct file *file)
{
        printk(KERN_DEBUG "%s:release OK\n",DEVICE);
        return SUCCESS;
}

ssize_t chardev_read(struct file *file, char __user *buf, size_t count,loff_t *offset)
{
        struct my_dev *dev = file->private_data;
        ssize_t retval = 0;

        if( down_interruptible(&dev->sem) )
                return -ERESTARTSYS;

        // 增加了对NONBLOCK的支持


        while( 0 == dev->index )
        {
                up(&dev->sem);
                if( file->f_flags & O_NONBLOCK )
                        return -EAGAIN;
                // 在这里准备睡眠,等待条件为真


                if( wait_event_interruptible(dev->rq, (0 != dev->index)) )
                        return -ERESTARTSYS; // 返回非0表示被信号中断


                if( down_interruptible(&dev->sem) )
                        return -ERESTARTSYS; // 先取得锁再检查条件


        }

        if( *offset >= dev->index )
                goto out;
        if( (*offset+count) > dev->index )
                count = dev->index - *offset;
        if( copy_to_user(buf, dev->buf + *offset, count) )
        {
                retval = -EFAULT;
                goto out;
        }
        *offset += count;
        retval = count;

out:
        up(&dev->sem);
        return retval;
}

// omit offset argument for write


ssize_t chardev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
{
        struct my_dev *dev = file->private_data;
        ssize_t retval = -ENOMEM;

        if( down_interruptible(&dev->sem) )
                return -ERESTARTSYS;

        if( count > dev->size )
                count = dev->size - 1;
        if( copy_from_user(dev->buf, buf, count) )
        {
                retval = -EFAULT;
                goto out;
        }
        dev->index = count;
        retval = count;

out:
        up(&dev->sem);
        // 唤醒阻塞在 read 和 select 上的进程


        if( retval > 0 )
                wake_up_interruptible(&dev->rq);
        return retval;
}

int chardev_ioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg)
{
        struct my_dev *dev = file->private_data;
        int retval = 0, tmp = 0;

        if( _IOC_TYPE(cmd) != KF701_IOC_MAGIC )
                return -ENOTTY;
        if( _IOC_NR(cmd) > KF701_IOC_MAXNR )
                return -ENOTTY;

        switch(cmd)
        {
                case KF701_IO_RESET:
                        printk(KERN_DEBUG "%s:IO_RESET CMD\n",DEVICE);
                        break;
                case KF701_IO_R:
                        printk(KERN_DEBUG "%s:IO READ CMD\n",DEVICE);
                        retval = put_user(dev->index, (int __user *)arg);
                        break;
                case KF701_IO_W:
                        printk(KERN_DEBUG "%s:IO WRITE CMD\n",DEVICE);
                        retval = get_user(tmp, (int __user *)arg);
                        printk(KERN_DEBUG "CMD ARG = %d\n", tmp);
                        break;
                case KF701_IO_RW:
                        printk(KERN_DEBUG "%s:IO W-R CMD\n",DEVICE);
                        break;
                default:
                        return -ENOTTY;
        }
        return retval;
}

unsigned int chardev_poll(struct file * file, poll_table * wait)
{
        struct my_dev *dev = file->private_data;
        unsigned int mask = 0;
        down(&dev->sem);
        poll_wait(file,&dev->rq,wait);
        if( 0 != dev->index )
                mask |= POLLIN | POLLRDNORM;
        up(&dev->sem);
        return mask;
}

// 此函数在进程上下文之外运行，类似中断上下文，因此：


// 1. 不能访问用户空间


// 2. current指针没有意义


// 3. 不能调用可能引起体眠和调度的代码，信号量也不行。


// 4. 最好使用 spinlock


void timer_function(unsigned long arg)
{
        struct my_dev *dev = (struct my_dev*)arg;
        if( dev->index >= (dev->size - 1) )
                return;
        if( dev->timer_char > 'Z' )
                dev->timer_char = 'A';
        if( '\n' == dev->buf[dev->index-1] )
                dev->index--;
        dev->buf[dev->index++] = (dev->timer_char)++;
        dev->buf[dev->index++] = '\n';

        // 唤醒阻塞在 read 和 select 上的进程


        wake_up_interruptible(&dev->rq);

        dev->timer.expires += dev->timer_interval;
        add_timer( &dev->timer );
}

module_init(chardev_init);
module_exit(chardev_exit);

MODULE_AUTHOR("kf701.ye at gmail.com");
MODULE_DESCRIPTION("Study for kf701");
MODULE_SUPPORTED_DEVICE(DEVICE);
MODULE_LICENSE("GPL");