字符设备驱动以及杂项设备驱动

　　先复习一下设备的分类，前面博客有提过的：

　　　　字符设备指那些必须以串行顺序依次进行访问的设备。

　　　　块设备可以用任意顺序进行访问，为什么？经过了系统的快速缓冲。

　　　　网络设备面向数据包的接收和发送设计，没有对应的文件系统节点。

　　不管怎么样，先看一下字符设备这个结构体吧：

struct cdev {
    　　struct kobject kobj;   //内嵌的kobject对象
    　　struct module *owner;　　//所属模块
    　　const struct file_operations *ops;　　//文件操作结构体
    　　struct list_head list;　　//队列
    　　dev_t dev;　　//设备号
    　　unsigned int count;
　};

　　好吧，我来分析一下，不知道对不对，请指导：

　　　　kobj--作为设备存在于文件系统中的一个纽带，比如它的上层目录，同级设备，下级目录等。

　　　　owner--所属模块，通常都是指向THIS_MODULE。

　　　　ops--这是一个很重要的结构，驱动的工作，基本都是为了实现这个结构体里面的函数。

　　　　list--队列，一般用于添加同种设备，查询，遍历作用？？？

　　　　dev--设备号，包括主设备号和次设备号。

　　　　count--记录设备被打开的次数？？？

　　设备号的三个函数：

　　　　MAJOR(dev_t dev)　　　　　　通过设备号dev获取主设备号

　　　　MINOR(dev_t dev)　　　　　　通过设备号dev获取次设备号

　　　　MKDEV(int major, int minor)　　通过主设备号和次设备号生成设备号

　　好吧，这些没什么用，讲下字符设备的注册流程吧：

　　　　1，定义一个结构体，里面包含cdev；其实可以直接定义一个cdev结构体就可以了，但是这样做的目的是实现了很好的封装性。

　　　　struct my_cdev {

　　　　　　struct cdev cdev；

　　　　　　int flag；

　　　　　　、、、、

　　　　}

　　　　定义一个struct class *my_class; 这个主要是为了自动创建设备节点；如果你想手动的mknod 那么这个便可以不用。

　　　　2，定义一个file_operations 结构体，并完成其中的一些函数的实现，比如：

/* File operations on mytime,*/
struct file_operations mytime_fops = {
    .owner     =     THIS_MODULE,
    .read     =     mytime_read,
    .write     =     mytime_write,
    .unlocked_ioctl     =     mytime_ioctl,
    .open     =     mytime_open,
    .release =     mytime_release,
};

 

　　　　3，init函数要完成的工作：　　　

　　　　　　分配设备号；
　　　　　　　　无主设备号的时候使用：动态（alloc_chrdev_region)

　　　　　　　　确定主设备号的时候使用：静态（register_chrdev_region）

　　　　　　cdev设备初始化
 　　　　　　　　静态内存定义初始化：
　　　　　　　　cdev_init(&my_cdev.cdev, &fops);
　　　　　　　　my_cdev.owner = THIS_MODULE;
　　　　　　　　动态内存定义初始化：
　　　　　　　　struct cdev *my_cdev = cdev_alloc();
　　　　　　　　my_cdev->ops = &fops;
　　　　　　　　my_cdev->owner = THIS_MODULE;

 　　　　　　注册cdev设备　　　cdev_add(struct cdev *p, dev_t dev,unsigned count)

 　　　　　　自动创建设备节点：在驱动初始化的代码里调用class_create为该设备创建一个class，再为每个设备调用 class_device_create创建对应的设备。
　　　　　　　　struct class *myclass = class_create(THIS_MODULE, “my_device_driver”);
　　　　　　　　class_device_create(myclass, NULL, MKDEV(major_num, 0), NULL, “my_device”);

 　　　　　　当然刚才说了，如果你不需要自动创建设备节点，这个可以免去。

　　　　驱动卸载的流程，根据注册的先后顺序，反过来。

　　　　删除字符设备：cdev_del( struct cdev *p);

　　　　释放设备号：void unregister_chrdev_region(dev_t first, unsigned int count);　　　　
　　　　删除设备文件：device_destroy (struct class * class, dev_t devt);
　　　　删除/sys/class下的类：class_destroy(struct class *cls);

　　　　流程大概就是这样，看例子吧，自己写的一个时钟，感觉写得还可以，照顾的方面蛮多的。可以拿来作为参考：

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>

#include <linux/kernel.h>        /* printk() */
#include <linux/slab.h>                /* kmalloc() */
#include <linux/fs.h>                /* everything... */
#include <linux/errno.h>        /* error codes */
#include <linux/types.h>        /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h>        /* O_ACCMODE */
#include <linux/seq_file.h>
#include <linux/cdev.h>

#include <asm/system.h>                /* cli(), *_flags */
#include <asm/uaccess.h>        /* copy_*_user */


#include <linux/sched.h>
#include <linux/mm.h>
#include <asm/io.h>
#include <linux/kd.h>
#include <linux/kbd_kern.h>
#include <linux/ioctl.h>
#include <linux/poll.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/completion.h>

#define MYTIME_DEBUG 1;

struct mytime_dev{  /* need to supplement,*/
    struct cdev cdev;
    struct timer_list timer;
    int timer_count;
    struct completion com;
};

static struct class *mytime_class;
static struct mytime_dev  *mytime_device;

static dev_t dev_no;

/* open method, */
static int mytime_open(struct inode *inode, struct file *file)
{
    struct mytime_dev *dev;
#ifdef    MYTIME_DEBUG
    printk(KERN_INFO "%s:I am here!\n",__func__);
#endif
    dev = container_of(inode->i_cdev, struct mytime_dev, cdev);
    file->private_data = dev; /* for other methods */

    return 0; /* success */
}

/* release method,  */
static int mytime_release(struct inode *inode, struct file *file)
{
#ifdef    MYTIME_DEBUG
    printk(KERN_INFO "%s:I am here!\n",__func__);
#endif
    return 0;
}

/* read method,  */
static ssize_t mytime_read(struct file *file, char __user *buf, 
            size_t count, loff_t *pos)
{
    struct mytime_dev *dev = file->private_data;
    int seconds, minutes, hours;
    char time_buf[10] = {'0'};
#ifdef    MYTIME_DEBUG
    printk(KERN_INFO "%s:I am here!\n",__func__);
#endif
    /* wait for completion */
    wait_for_completion_interruptible(&dev->com);

    seconds = (dev->timer_count)%60;
    minutes = (dev->timer_count)/60%60;
    hours     = (dev->timer_count)/60/60%24;

    /* this is a foolish way */
/*    time_buf[7] = seconds%10 + '0';
    time_buf[6] = seconds/10 + '0';
    time_buf[4] = minutes%10 + '0';
    time_buf[3] = minutes/10 + '0';
    time_buf[1] = hours%10 + '0';
    time_buf[0] = hours/10 + '0';*/

    /* this is a smart way */
    snprintf(time_buf, 10, "%02d:%02d:%02d\n",hours, minutes, seconds);    
    if(copy_to_user(buf, time_buf, 10))
        return -EFAULT;

    return 10;     /* be care of the return value is the count */
}

/* write method, */
static ssize_t mytime_write(struct file *file, const char __user *buf, 
            size_t count, loff_t *pos)
{
    struct mytime_dev *dev = file->private_data;
    ssize_t retval = -ENOMEM;
    char settime[9] = {'0'};
    copy_from_user(settime, buf, count);

    /* can we use this function? */
    //time_int = atoi(settime);

    retval = count;
    if(settime[0] == 'r') 
    {
        /* awaken the completion */
        complete(&dev->com);    
    }
    else 
    {
    dev->timer_count = (settime[7]-'0')+((settime[6]-'0')*10)+((settime[4]-'0')*60)+((settime[3]-'0')*10*60)+\
                ((settime[1]-'0')*3600)+((settime[0]-'0')*10*3600);
    //dev->timer_count = time_int%100 + ((time_int/100)%100)*60 + (time_int/10000)*3600;
    }
    //printk("%s",settime);
    return retval;
}

 /*ioctr method, */
static long mytime_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct mytime_dev *dev = file->private_data;

    /* wait for adding code */    
    switch (cmd) {
        case 0:
            dev->timer_count = 0;
        default:
            return -EINVAL;
    }    
    return 0;
}

/* mytime_timer function */
static void mytime_timer(unsigned long _data)
{
    struct mytime_dev *device = (struct mytime_dev *)_data; 
    device->timer_count++;    
    mod_timer(&device->timer, jiffies+HZ);
}

/* File operations on mytime,*/
struct file_operations mytime_fops = {
    .owner     =     THIS_MODULE,
    .read     =     mytime_read,
    .write     =     mytime_write,
    .unlocked_ioctl     =     mytime_ioctl,
    .open     =     mytime_open,
    .release =     mytime_release,
};

/* Driver Exit */
static void  mytime_exit(void)
{
#ifdef     MYTIME_DEBUG
    printk("%s:Good Bye!\n",__func__);
#endif
    /* delete timer */
    del_timer(&mytime_device->timer);

    /* remove the cdev */
    cdev_del(&mytime_device->cdev);
    
    /* free memory block */
    kfree(mytime_device);
    
    /* release the char device number */
    unregister_chrdev_region(dev_no,1);

    /* it will destroy the device node under /dev, */
    device_destroy(mytime_class, dev_no);

    /* Destroy class */
    class_destroy(mytime_class);    
}

/* Driver Initialization,*/
static int  mytime_init(void)
{
    int result;
#ifdef     MYTIME_DEBUG
    printk("%s:I am here!\n",__func__);
#endif
    /* asking for a dynamic major*/
    result = alloc_chrdev_region(&dev_no, 0, 1, "mytime_dev");
    if(result < 0) {
        printk(KERN_WARNING "mytime_dev:can't get device number!\n");
        return result;
    }
    else {
        printk("the device number is %d !\n",dev_no);
    }
    
    /* allocate the devices*/
    mytime_device = kzalloc(sizeof(struct mytime_dev),GFP_KERNEL);
    if(!mytime_device) {
        result = -ENOMEM;
        goto fail;
    }
//    memset(mytime_device, 0, sizeof(struct mytime_dev));

    /* set up the char_dev structure for this device.*/

    /* when declare cdev as pointer, use cdev_alloc()*/
//    (mytime_device->cdev) = cdev_alloc();
    /* if declare cdev as structure, use cdev_init */
    cdev_init(&mytime_device->cdev, &mytime_fops);
    mytime_device->cdev.owner = THIS_MODULE;
//    mytime_device->cdev.ops = &mytime_fops;    //for cdev_alloc()
    
    if(cdev_add(&mytime_device->cdev, dev_no,1)) {
        printk("%s:add cdev failde!",__func__);
        return 1;
    }
    /* initialize competion */
    init_completion(&mytime_device->com);

    /* setup a timer */
    setup_timer(&mytime_device->timer, mytime_timer, (unsigned long)mytime_device);
    mytime_device->timer.expires = jiffies + HZ;

    /* add this timer to timer queue */
    add_timer(&mytime_device->timer);

    /* create sysfs entries */
    mytime_class = class_create(THIS_MODULE, "mytime_class");

    /* Send uevents to udev, so it'll create /dev nodes */
    device_create(mytime_class, NULL, dev_no, NULL, "mytime_dev");
    
    return 0;     /*succeed*/
    
    fail:
        mytime_exit();
        return result;
}

module_init(mytime_init);
module_exit(mytime_exit);

MODULE_AUTHOR("Chen Yucai, ksime");
MODULE_DESCRIPTION("Time Char Driver");
MODULE_LICENSE("GPL");

 

 　　对于字符设备是不是觉得还是麻烦，对！确实麻烦，注册这，注册那的，好在我们还有一个选择，杂项设备驱动，这个它的主设备号规定为10，它帮我们省掉了很多注册或者初始化的操作，只需要调用它的API就可以了。下面我们来看看:

　　1，定义一个struct miscdevice misc;

　　2，init注册：ret = misc_register(&misc);

　　3，exit卸载：misc_deregister(&misc);

 　　真的就这么简单么？真的！所以，一般的字符设备驱动，我们都使用杂项驱动！！！看例子吧，根据上面那个改的：

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/init.h>
#include <asm/io.h>
#include <asm/uaccess.h>
//#include <asm/arch/hardware.h>
#include <linux/kd.h>
#include <linux/fs.h>
#include <linux/kbd_kern.h>
#include <linux/ioctl.h>
#include <linux/poll.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/input.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/completion.h>

#define MISC_TIME_DEBUG 1;

struct misc_time {
    struct miscdevice misc;
    struct completion com;
    struct timer_list timer;
    int timer_count;
};

static struct misc_time time_device;

static int misc_time_open(struct inode *inode, struct file *file)
{
    struct misc_time *time;
#ifdef MISC_TIME_DEBUG
    printk(KERN_INFO "MISC_TIME open.\n");
#endif
    time = &time_device;
    if(!time)
        return -ENODEV;
    file->private_data = time;
    
    return 0;
}

static int misc_time_release(struct inode *inode, struct file *file)
{
#ifdef MISC_TIME_DEBUG
    printk(KERN_INFO "MISC_TIME release.\n");
#endif
    return 0;
}

static ssize_t misc_time_read(struct file *file, char __user *buf, size_t count,loff_t *pos)
{
    struct misc_time *time = file->private_data;
        int seconds, minutes, hours;
    char time_buf[10] = {'0'};
#ifdef    MISC_TIME_DEBUG
    printk(KERN_INFO "%s:I am here!\n",__func__);
#endif
    /* wait for completion */
    wait_for_completion_interruptible(&time->com);

    seconds = (time->timer_count)%60;
    minutes = (time->timer_count)/60%60;
    hours     = (time->timer_count)/60/60%24;

    /* this is a foolish way */
/*    time_buf[7] = seconds%10 + '0';
    time_buf[6] = seconds/10 + '0';
    time_buf[4] = minutes%10 + '0';
    time_buf[3] = minutes/10 + '0';
    time_buf[1] = hours%10 + '0';
    time_buf[0] = hours/10 + '0';*/

    /* this is a smart way */
    snprintf(time_buf, 10, "%02d:%02d:%02d\n",hours, minutes, seconds);    
    if(copy_to_user(buf, time_buf, 10))
        return -EFAULT;

    return 10;     /* be care of the return value is the count */
}

static ssize_t misc_time_write(struct file *file, const char __user *buf, 
            size_t count, loff_t *pos)
{
    struct misc_time *time = file->private_data;
    ssize_t retval = -ENOMEM;
    char settime[9] = {'0'};
    copy_from_user(settime, buf, count);

    /* can we use this function? */
    //time_int = atoi(settime);

    retval = count;
    if(settime[0] == 'r') 
    {
        /* awaken the completion */
        complete(&time->com);    
    }
    else 
    {
    time->timer_count = (settime[7]-'0')+((settime[6]-'0')*10)+((settime[4]-'0')*60)+((settime[3]-'0')*10*60)+\
                ((settime[1]-'0')*3600)+((settime[0]-'0')*10*3600);
    //time->timer_count = time_int%100 + ((time_int/100)%100)*60 + (time_int/10000)*3600;
    }
    //printk("%s",settime);
    return retval;
}

static long misc_time_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct misc_time *time = file->private_data;

    /* wait for adding code */    
    switch (cmd) {
        case 0:
            time->timer_count = 0;
        default:
            return -EINVAL;
    }    
    return 0;
}

static void misc_timer(unsigned long _data)
{
    struct misc_time *time = (struct misc_time *)_data; 
    time->timer_count++;    
    mod_timer(&time->timer, jiffies+HZ);
}


struct file_operations misc_time_fops = {
    .owner     =     THIS_MODULE,
    .read     =     misc_time_read,
    .write     =     misc_time_write,
    .unlocked_ioctl     =     misc_time_ioctl,
    .open     =     misc_time_open,
    .release =     misc_time_release,
};

static struct misc_time time_device = {
    .misc = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = "misc_time",
        .fops = &misc_time_fops,
    },
};

static int __init misc_time_init(void)
{
    int ret;

    //allocate for time data
    //register the misc driver
    ret = misc_register(&time_device.misc);
    if(unlikely(ret)) {
        printk(KERN_ERR "misc time driver failed to registe "
            "the misc drivers.\n");
        return ret;
    }
    init_completion(&(time_device.com));
    setup_timer(&time_device.timer, misc_timer, (unsigned long)&time_device);
    time_device.timer.expires = jiffies + HZ;

    /* add this timer to timer queue */
    add_timer(&time_device.timer);
    
    return 0;
}

static void __exit misc_time_exit(void)
{
    printk(KERN_INFO "MISC_TIME exit\n");
    del_timer(&time_device.timer);
    misc_deregister(&time_device.misc);
}


module_init(misc_time_init);
module_exit(misc_time_exit);

MODULE_AUTHOR("Chen Yucai, ksime");
MODULE_DESCRIPTION("Time Misc Driver");
MODULE_LICENSE("GPL");

 

 　　字符驱动是基础！要理解一个驱动的架构！驱动的工作就是完成struct file_operation 的回调函数！

　　上面这两个例子，是很久之前写的，现在回头看看，也有更多的体会！努力加油！

　　今天下雨，微冷！热点的时候，是否就更好的迁徙了呢？