linux 设备驱动概述

 本系列文章我们将一步步、深入浅出的介绍linux设备驱动编程中设计的一些问题及学习方法，希望对大家学习linux设备驱动有所帮助。

在任何一个计算机系统中，大至服务器、PC机、小至手机、mp3/mp4播放器，无论是复杂的大型服务器系统还是一个简单的流水灯单片机系统，都离不开驱动程序的身影，没有硬件的软件是空中楼阁，没有软件的硬件只是一堆废铁，硬件是底层的基础，是所有软件得以运行的平台，代码最终会落实到硬件上的逻辑组合。

    但是硬件与软件之间存在一个驳论：为了快速、优质的完成软件功能设计，应用程序工程师不想也不愿关心硬件，而硬件工程师也很难有功夫去处理软件开发中的一些应用。例如软件工程师在调用printf的时候，不许也不用关心信息到底是通过什么样的处理，走过哪些通路显示在该显示的地方，硬件工程师在写完了一个4*4键盘驱动后，无需也不必管应用程序在获得键值后做哪些处理及操作。

    也就是说软件工程师需要看到一个没有硬件的纯软件世界，硬件必须透明的提供给他，谁来实现这一任务？答案是驱动程序，驱动程序从字面解释就是：“驱使硬件设备行动”。驱动程序直接与硬件打交道，按照硬件设备的具体形式，驱动设备的寄存器，完成设备的轮询、中断处理、DMA通信，最终让通信设备可以收发数据，让显示设备能够显示文字和画面，让音频设备可以完成声音的存储和播放。

    可见，设备驱动程序充当了硬件和软件之间的枢纽，因此驱动程序的表现形式可能就是一些标准的、事先协定好的API函数，驱动工程师只需要去完成相应函数的填充，应用工程师只需要调用相应的接口完成相应的功能。无论有没有操作系统，驱动程序都有其存在价值，只是在裸机情况下，工作环境比较简单、完成的工作较单一，驱动程序完成的功能也就比较简单，同时接口只要在小范围内符合统一的标准即可。但是在有操作系统的情况下，此问题就会被放大：硬件来自不同的公司、千变万化，全世界每天都会有大量的新芯片被生产，大量的电路板被设计出来，如果没有一个很好的统一标准去规范这一程序，操作系统就会被设计的非常冗余，效率会非常低。

所以无论任何操作系统都会制定一套标准的架构去管理这些驱动程序：linux作为嵌入式操作系统的典范，其驱动架构具有很高的规范性与聚合性，不但把不同的硬件设备分门别类、综合管理，并且针对不同硬件的共性进行了统一抽象，将其硬件相关性降到最低，大大简化了驱动程序的编写，形成了具有其特色的驱动组织架构。

下图反映了应用程序、linux内核、驱动程序、硬件的关系。

1. #include <linux/init.h>         /* printk() */
2. #include <linux/module.h>       /* __init __exit */
3. static int  __init  hello_init(void)      /*模块加载函数，通过insmod命令加载模块时，被自动执行*/
4. {
5. printk(KERN_INFO " Hello World enter\n");
6. return 0;
7. }
8. static void  __exit  hello_exit(void)    /*模块卸载函数，当通过rmmod命令卸载时，会被自动执行*/
9. {
10. printk(KERN_INFO " Hello World exit\n ");
11. }
12. module_init(hello_init);
13. module_exit(hello_exit);
14. MODULE_AUTHOR("dengwei");           /*模块作者，可选*/
15. MODULE_LICENSE("Dual BSD/GPL");     /*模块许可证明，描述内核模块的许可权限，必须*/
16. MODULE_DESCRIPTION("A simple Hello World Module"); /*模块说明，可选*/
17. MODULE_ALIAS("a simplest module");                  /*模块说明，可选*/<span style="font-family:SimSun;font-size:18px;color:#FF0000;"><strong>
18. </strong></span>

1. obj-m :=hello.o                     //目标文件
2. #module-objs := file1.o file.o      //当模块有多个文件组成时，添加本句
3. KDIR :=/usr/src/linux               //内核路径，根据实际情况换成自己的内核路径，嵌入式的换成嵌入式，PC机的指定PC机路径
4. PWD := $(shell pwd)                 //模块源文件路径
5. all:
6. $(MAKE)  -C  $(KDIR)  SUBDIRS=$(PWD)  modules
7. @rm -rf *.mod.*
8. @rm -rf .*.cmd
9. @rm -rf *.o
10. @rm -rf Module.*
11. clean:
12. rm -rf *.ko

1. static int __init myModule_init(void)
2. {
3. /* Module init code */
4. PRINTK("myModule_init\n");
5. return 0;
6. }
7. module_init(myModule_init);

1. static void __exit myModule_exit(void)
2. {
3. /* Module exit code */
4. PRINTK("myModule_exit\n");
5. return;
6. }
7. module_exit(myModule_exit);

1. MODULE_AUTHOR("dengwei");
2. MODULE_LICENSE("Dual BSD/GPL");
3. MODULE_DESCRIPTION("A simple Hello World Module");
4. MODULE_ALIAS("a simplest module");

1. static char *string_test = “this is a test”;
2. static num_test = 1000;
3. module_param (num_test,int,S_IRUGO);
4. module_param (steing_test,charp,S_ITUGO);

1. #include <linux/module.h>    /*module_init()*/
2. #include <linux/kernel.h> /* printk() */
3. #include <linux/init.h>       /* __init __exit */
4. #define DEBUG   //open debug message
5. #ifdef DEBUG
6. #define PRINTK(fmt, arg...)     printk(KERN_WARNING fmt, ##arg)
7. #else
8. #define PRINTK(fmt, arg...)     printk(KERN_DEBUG fmt, ##arg)
9. #endif
10. static char *string_test="default paramater";
11. static int num_test=1000;
12. static int __init hello_init(void)
13. {
14. PRINTK("\nthe  string_test is : %s\n",string_test);
15. PRINTK("the  num_test is : %d\n",num_test);
16. return 0;
17. }
18. static void __exit hello_exit(void)
19. {
20. PRINTK(" input paramater module exit\n ");
21. }
22. module_init(hello_init);
23. module_exit(hello_exit);
24. module_param(num_test,int,S_IRUGO);
25. module_param(string_test,charp,S_IRUGO);
26. MODULE_AUTHOR("dengwei");
27. MODULE_LICENSE("GPL");

1. Hello World enter
2. the test string is： this is a test
3. the test num is ：1000

1. Hello World enter
2. the test string is： edit by dengwei
3. the test num is ：2000

1. #include <linux/module.h>    /*module_init()*/
2. #include <linux/kernel.h> /* printk() */
3. #include <linux/init.h>       /* __init __exit */
4. int add_test(int a ,int b)
5. {
6. return a + b;
7. }
8. int sub_test(int a,int b)
9. {
10. return a - b;
11. }
12. EXPORT_SYMBOL(add_test);
13. EXPORT_SYMBOL(sub_test);
14. MODULE_AUTHOR("dengwei");
15. MODULE_LICENSE("GPL");

1. f88c9008 r __ksymtab_sub_integar        [export_symb]
2. f88c9020 r __kstrtab_sub_integar         [export_symb]
3. f88c9018 r __kcrctab_sub_integar         [export_symb]
4. f88c9010 r __ksymtab_add_integar        [export_symb]
5. f88c902c r __kstrtab_add_integar          [export_symb]
6. f88c901c r __kcrctab_add_integar         [export_symb]
7. f88c9000 T add_tes                [export_symb]
8. f88c9004 T sub_tes                [export_symb]
9. 13db98c9 a __crc_sub_integar           [export_symb]
10. e1626dee a __crc_add_integar           [export_symb]

1. #include <linux/module.h>    /*module_init()*/
2. #include <linux/kernel.h> /* printk() */
3. #include <linux/init.h>       /* __init __exit */
4. #define DEBUG   //open debug message
5. #ifdef DEBUG
6. #define PRINTK(fmt, arg...)     printk(KERN_WARNING fmt, ##arg)
7. #else
8. #define PRINTK(fmt, arg...)     printk(KERN_DEBUG fmt, ##arg)
9. #endif
10. extern int add_test(int a ,int b);
11. extern int sub_test(int a,int b);
12. static int __init hello_init(void)
13. {
14. int a,b;
15. a = add_test(10,20);
16. b = sub_test(30,20);
17. PRINTK("the add test result is %d",a);
18. PRINTK("the sub test result is %d\n",b);
19. return 0;
20. }
21. static void __exit hello_exit(void)
22. {
23. PRINTK(" Hello World exit\n ");
24. }
25. module_init(hello_init);
26. module_exit(hello_exit);
27. MODULE_AUTHOR("dengwei");
28. MODULE_LICENSE("GPL");

1. #include <linux/module.h>       /*module_init()*/
2. #include <linux/kernel.h> /* printk() */
3. #include <linux/init.h>       /* __init __exit */
4. #define DEBUG   //open debug message
5. #ifdef DEBUG
6. #define PRINTK(fmt, arg...)     printk(KERN_WARNING fmt, ##arg)
7. #else
8. #define PRINTK(fmt, arg...)     printk(KERN_DEBUG fmt, ##arg)
9. #endif
10. /* Module Init & Exit function */
11. static int __init myModule_init(void)
12. {
13. /* Module init code */
14. PRINTK("myModule_init\n");
15. return 0;
16. }
17. static void __exit myModule_exit(void)
18. {
19. /* Module exit code */
20. PRINTK("myModule_exit\n");
21. return;
22. }
23. module_init(myModule_init);
24. module_exit(myModule_exit);
25. MODULE_AUTHOR("dengwei");                          /*模块作者，可选*/
26. MODULE_LICENSE("GPL");                             /*模块许可证明，描述内核模块的许可权限，必须*/
27. MODULE_DESCRIPTION("A simple Hello World Module"); /*模块说明，可选*/

platform_driver在具体的硬件设备驱动编写中完成：
同plartform_device相似，需要定义并实现以下结构体

/*申请Watchdog中断服务，这里使用的是快速中断:IRQF_DISABLED。中断服务程序为:wdt_irq，将Watchdog平台设备pdev做参数传递过去了*/
    ret = request_irq(wdt_irqno, wdt_irq, IRQF_DISABLED, pdev->name, pdev);

/*获取watchdog平台设备所使用的IO端口资源，注意这个IORESOURCE_MEM标志和watchdog平台设备定义中的一致*/
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

/*申请watchdog的IO端口资源所占用的IO空间(要注意理解IO空间和内存空间的区别),request_mem_region定义在ioport.h中*/
    wdt_mem = request_mem_region(res->start, res->end - res->start + 1, pdev->name);

/*将watchdog的IO端口占用的这段IO空间映射到内存的虚拟地址，ioremap定义在io.h中。
     注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作，*/
    wdt_base = ioremap(res->start, res->end - res->start + 1);

return ret;
}

/*Watchdog平台驱动的设备移除接口函数的实现*/
static int __devexit wdt_remove(struct platform_device *dev)
{
  /*释放获取的Watchdog平台设备的IO资源*/
    release_resource(wdt_mem);
    kfree(wdt_mem);
    wdt_mem = NULL;

/*同watchdog_probe中中断的申请相对应，在那里申请中断，这里就释放中断*/
    free_irq(wdt_irqno, dev);
    wdt_irq = NULL;

/*释放获取的Watchdog平台设备的时钟*/
    clk_disable(wdt_clock);
    clk_put(wdt_clock);
    wdt_clock = NULL;

/*释放Watchdog设备虚拟地址映射空间*/
    iounmap(wdt_base);
    return 0;
}

#ifdef CONFIG_PM

在Linux 2.6内核中，devfs被认为是过时的方法，并最终被抛弃，udev取代了它。Devfs的一个很重要的特点就是可以动态创建设备结点。那我们现在如何通过udev和sys文件系统动态创建设备结点呢？
用udev在/dev/下动态生成设备文件，这样用户就不用手工调用mknod了。

利用的kernel API：    
    class_create        :    创建class 
    class_destroy        :    销毁class 
    class_device_create    :    创建device 
    class_device_destroy    :    销毁device

注意，这些API是2.6.13开始有的，在2.6.13之前，应当使用 
class_simple_create 
class_simple_destroy 
class_simple_device_add 
class_simple_device_remove 
这一系列，也就是ldd3第14章描述的。 详见: 
    
https:/ n.net/Articles/128644/ 
Output: 
=========================================== 
[root@localhost dynamic_dev_node]# insmod ./dummy_dev.ko 
[root@localhost dynamic_dev_node]# file /dev/dummy_dev0 
/dev/dummy_dev0: character special (250/0) 
[root@localhost dynamic_dev_node]# rmmod dummy_dev.ko 
[root@localhost dynamic_dev_node]# file /dev/dummy_dev0 
/dev/dummy_dev0: ERROR: cannot open `/dev/dummy_dev0' (No such file or directory)

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux pes.h>
#include <linux/delay.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/ioctl.h>
#include <linux ev.h>
#include <linux/string.h>
#include <linux st.h>
#include <linux/pci.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <asm/unistd.h>

#define THIS_DESCRIPTION "\
This module is a dummy device driver, it register\n\
\t\ta char device, and utilize udev to create/destroy \n\
\t\tdevice node under /dev/ dynamicallly."

MODULE_LICENSE("GPL");
MODULE_AUTHOR("albcamus <albcamus@gmail.com>");
MODULE_DESCRIPTION(THIS_DESCRIPTION);

#define DUMMY_MAJOR 250
#define DUMMY_MINOR 0
#define DUMMY_NAME "dummy_dev"

/**
* the open routine of 'dummy_dev'
*/
static int dummy_open(struct inode *inode, struct file *file)
{
    printk("Open OK\n");
    return 0;
}
/**
* the write routine of 'dummy_dev'
*/
static ssize_t dummy_write(struct file *filp, const char *bp, size_t count, loff_t *ppos)
{
    printk("Don't Write!\n");
    return 0;
}
/**
* the read routine of 'dummy_dev'
*/
static ssize_t dummy_read(struct file *filp, char *bp, size_t count, loff_t *ppos)
{
    return 0;
}
/**
* the ioctl routine of 'dummy_dev'
*/
static int dummy_ioctl(struct inode *inode, struct file *filep,
            unsigned int cmd, unsigned long arg)
{
    return 0;
}

/**
* file_operations of 'dummy_dev'
*/
static struct file_operations dummy_dev_ops = {
    .owner = THIS_MODULE,
    .open = dummy_open,
    .read = dummy_read,
    .write = dummy_write,
    .ioctl = dummy_ioctl,
};

/**
* struct cdev of 'dummy_dev'
*/
struct cdev *my_cdev;
struct class *my_class;

static int __init my_init(void)
{
    int err, devno = MKDEV(DUMMY_MAJOR, DUMMY_MINOR);

/* register the 'dummy_dev' char device */
    my_cdev = cdev_alloc();
    cdev_init(my_cdev, &dummy_dev_ops);
    my_cdev->owner = THIS_MODULE;
    err = cdev_add(my_cdev, devno, 1);
    if (err != 0)
        printk("dummy pci device register failed!\n");
    /* creating your own class */
    my_class = class_create(THIS_MODULE, "dummy_class");
    if(IS_ERR(my_class)) {
        printk("Err: failed in creating class.\n");
        return -1;
    }
    /* register your own device in sysfs, and this will cause udevd to create corresponding device node */
    class_device_create(my_class, NULL, MKDEV(DUMMY_MAJOR, DUMMY_MINOR), NULL, DUMMY_NAME "%d", DUMMY_MINOR );

return 0;
}
static void __exit my_fini(void)
{
    printk("bye\n");
    cdev_del(my_cdev);
    / ree(my_cdev); no use. because that cdev_del() will call kfree if neccessary.

class_device_destroy(my_class, MKDEV(DUMMY_MAJOR, DUMMY_MINOR));
    class_destroy(my_class);
}

module_init(my_init);
module_exit(my_fini);

原来2.6.15中的函数： 
class_device_create（）； 
class_device_destroy（）； 
在2.6.27中变为： 
device_create（） 
device_destroy（）
第一、什么是udev？ 
这篇文章UDEV Primer给我们娓娓道来，花点时间预习一下是值得的。当然，不知道udev是什么也没关系， 
把它当个助记符好了，有了下面的上路指南，可以节省很多时间。我们只需要树立一个信念：udev很简单！ 
嵌入式的udev应用尤其简单。 
第二、为什么udev要取代devfs？ 
这是生产关系适应生产力的需要，udev好，devfs坏，用好的不用坏的。 
udev是硬件平台无关的，属于user space的进程，它脱离驱动层的关联而建立在操作系统之上，基于这种设
计实现，我们可以随时修改及删除/dev下的设备文件名称和指向，随心所欲地按照我们的愿望安排和管理设 
备文件系统，而完成如此灵活的功能只需要简单地修改udev的配置文件即可，无需重新启动操作系统。udev 
已经使得我们对设备的管理如探囊取物般轻松自如。 
第三、如何得到udev？ 
udev的主页在这里：http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html 
我们按照下面的步骤来生成udev的工具程序，以arm-linux为例： 
1、wget http://www.us.kernel.org/pub/linux/utils/kernel/hotplug/udev-100.tar.bz2 
2、tar xjf udev-100.tar.bz2 
3、cd udev-100 编辑Makefile，查找CROSS_COMPILE，修改CROSS_COMPILE ?= arm-linux- 
4、make 
没有什么意外的话当前目录下生成udev,udevcontrol,udevd,udevinfo,udevmonitor,udevsettle,udevstart, 
udevtest,udevtrigger九个工具程序，在嵌入式系统里，我们只需要udevd和udevstart就能使udev工作得很好， 
其他工具则帮助我们完成udev的信息察看、事件捕捉或者更高级的操作。 
另外一个方法是直接使用debian提供的已编译好的二进制包，美中不足的是版本老了一些。 
1、wget http://ftp.us.debian.org/debian/pool/main/u/udev/udev_0.056-3_arm.deb 
2、ar -xf udev_0.056-3_arm.deb 
3、tar xzf data.tar.gz 
在sbin目录里就有我们需要的udevd和udevstart工具程序。 
建议大家采用第一种方式生成的udevd和udevstart。为什么要用最新udev呢？新的强，旧的弱，用强的不用弱的。 
第四、如何配置udev？ 
首先，udev需要内核sysfs和tmpfs的支持，sysfs为udev提供设备入口和uevent通道，tmpfs为udev设备文件提供存放空间，也就是说，在上电之前系统上是没有足够的设备文件可用的，我们需要一些技巧让kernel先引导起来。 
由于在kernel启动未完成以前我们的设备文件不可用，如果使用mtd设备作为rootfs的挂载点，这个时候/dev/mtdblock这个设备目录是不存在的，我们无法让kernel通过/dev/mtdblock/X这样的设备找到rootfs，kernel只好停在那里惊慌。这个问题我们可以通过给kernel传递设备号的方式来解决，在linux系统中，mtdblock的主设备号是31，part号从0开始，那么以前的/dev/mtdblock/3就等同于31:03，以次类推，所以我们只需要修改bootloader传给kernel的cmd
line参数，使root=31:03，就可以让kernel在udevd未起来之前成功的找到rootfs。 
另外一种方法就是给kernel传递未经归类的设备文件名，在udev未创建之前，所有的设备实际上已经通过sysfs建立，mtdblockX的位置相对于/sys/block/mtdblockX/dev，这个文件里存放着mtdblockX的设备号，形式与上一种方式相同。这时由于没有相应的udev规则，所有的设备都被隐含地映射到/dev目录下，mtdblockX对应于/dev/mtdbockX，这样我们给kernel传递root=/dev/mtdblock3，kernel发现/dev没有被建立，就自动从映射表里查找对应关系，最后取出/sys/block/mtdblockX/dev里的设备号，完成rootfs的挂载。

其次，需要做的工作就是重新生成rootfs，把udevd和udevstart复制到/sbin目录。然后我们需要在/etc/下为udev建立设备规则，这可以说是udev最为复杂的一步。这篇文章提供了最完整的指导：Writing
udev
rules文中描述的复杂规则我们可以暂时不用去理会，上路指南将带领我们轻松穿过这片迷雾。这里提供一个由简入繁的方法，对于嵌入式系统，这样做可以一劳永逸。 
1、在前面用到的udev-100目录里，有一个etc目录，里面放着的udev目录包含了udev设备规则的详细样例文本。为了简单而又简洁，我们只需要用到etc/udev/udev.conf这个文件，在我们的rootfs/etc下建立一个udev目录，把它复制过去，这个文件很简单，除了注释只有一行，是用来配置日志信息的，嵌入式系统也许用不上日志，但是udevd需要检查这个文件。 
2、在rootfs/etc/udev下建立一个rules.d目录，生成一个空的配置文件touch etc/udev/rules.d/udev.conf。然后 
我们来编辑这个文件并向它写入以下配置项： 
############################################### 
# vc devices 
KERNEL=="tty[0-9]*", NAME="vc/%n" 
# block devices 
KERNEL=="loop[0-9]*", NAME="loop/%n" 
# mtd devices 
KERNEL=="mtd[0-9]*", NAME="mtd/%n" 
KERNEL=="mtdblock*", NAME="mtdblock/%n" 
# input devices 
KERNEL=="mice" NAME="input/%k" 
KERNEL=="mouse[0-9]*", NAME="input/%k" 
KERNEL=="ts[0-9]*", NAME="input/%k" 
KERNEL=="event[0-9]*", NAME="input/%k" 
# misc devices 
KERNEL=="apm_bios", NAME="misc/%k" 
KERNEL=="rtc", NAME="misc/%k" 
################################################ 
保存它，我们的设备文件系统基本上就可以了，udevd和udevstart会自动分析这个文件。 
3、为了使udevd在kernel起来后能够自动运行，我们在rootfs/etc/init.d/rcS中增加以下几行： 
################################## 
/bin/mount -t tmpfs tmpfs /dev 
echo "Starting udevd..." 
/sbin/udevd --daemon 
/sbin/udevstart 
################################## 
4、重新生成rootfs，烧写到flash指定的rootfs part中。 
5、如果需要动态改变设备规则，可以把etc/udev放到jffs或yaffs part，以备修改，根据需求而定，可以随时扩充udev.conf中的配置项。

1. <include/linux/cdev.h>
2. struct cdev {
3. struct kobject kobj;                  //内嵌的内核对象.
4. struct module *owner;                 //该字符设备所在的内核模块的对象指针.
5. const struct file_operations *ops;    //该结构描述了字符设备所能实现的方法，是极为关键的一个结构体.
6. struct list_head list;                //用来将已经向内核注册的所有字符设备形成链表.
7. dev_t dev;                            //字符设备的设备号，由主设备号和次设备号构成.
8. unsigned int count;                   //隶属于同一主设备号的次设备号的个数.
9. };

1. void cdev_init(struct cdev *cdev, const struct file_operations *fops)
2. {
3. memset(cdev, 0, sizeof *cdev);
4. INIT_LIST_HEAD(&cdev->list);
5. kobject_init(&cdev->kobj, &ktype_cdev_default);
6. cdev->ops = fops;
7. }

1. struct cdev *cdev_alloc(void)
2. {
3. struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
4. if (p) {
5. INIT_LIST_HEAD(&p->list);
6. kobject_init(&p->kobj, &ktype_cdev_dynamic);
7. }
8. return p;
9. }

1. //宏定义：
2. #define MINORBITS    20
3. #define MINORMASK    ((1U << MINORBITS) - 1)
4. #define MAJOR(dev)    ((unsigned int) ((dev) >> MINORBITS))
5. #define MINOR(dev)    ((unsigned int) ((dev) & MINORMASK))
6. #define MKDEV(ma,mi)    (((ma) << MINORBITS) | (mi))</span>

1. int register_chrdev_region(dev_t from, unsigned count, const char *name)
2. {
3. struct char_device_struct *cd;
4. dev_t to = from + count;
5. dev_t n, next;
6. for (n = from; n < to; n = next) {
7. next = MKDEV(MAJOR(n)+1, 0);
8. if (next > to)
9. next = to;
10. cd = __register_chrdev_region(MAJOR(n), MINOR(n),
11. next - n, name);
12. if (IS_ERR(cd))
13. goto fail;
14. }
15. return 0;
16. fail:
17. to = n;
18. for (n = from; n < to; n = next) {
19. next = MKDEV(MAJOR(n)+1, 0);
20. kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
21. }
22. return PTR_ERR(cd);
23. }

1. int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
2. const char *name)
3. {
4. struct char_device_struct *cd;
5. cd = __register_chrdev_region(0, baseminor, count, name);
6. if (IS_ERR(cd))
7. return PTR_ERR(cd);
8. *dev = MKDEV(cd->major, cd->baseminor);
9. return 0;
10. }

1. static struct char_device_struct *
2. __register_chrdev_region(unsigned int major, unsigned int baseminor,
3. int minorct, const char *name)
4. {
5. struct char_device_struct *cd, **cp;
6. int ret = 0;
7. int i;
8. cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
9. if (cd == NULL)
10. return ERR_PTR(-ENOMEM);
11. mutex_lock(&chrdevs_lock);
12. /* temporary */
13. if (major == 0) {
14. for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
15. if (chrdevs[i] == NULL)
16. break;
17. }
18. if (i == 0) {
19. ret = -EBUSY;
20. goto out;
21. }
22. major = i;
23. ret = major;
24. }
25. cd->major = major;
26. cd->baseminor = baseminor;
27. cd->minorct = minorct;
28. strlcpy(cd->name, name, sizeof(cd->name));
29. i = major_to_index(major);
30. for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
31. if ((*cp)->major > major ||
32. ((*cp)->major == major &&
33. (((*cp)->baseminor >= baseminor) ||
34. ((*cp)->baseminor + (*cp)->minorct > baseminor))))
35. break;
36. /* Check for overlapping minor ranges.  */
37. if (*cp && (*cp)->major == major) {
38. int old_min = (*cp)->baseminor;
39. int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
40. int new_min = baseminor;
41. int new_max = baseminor + minorct - 1;
42. /* New driver overlaps from the left.  */
43. if (new_max >= old_min && new_max <= old_max) {
44. ret = -EBUSY;
45. goto out;
46. }
47. /* New driver overlaps from the right.  */
48. if (new_min <= old_max && new_min >= old_min) {
49. ret = -EBUSY;
50. goto out;
51. }
52. }
53. cd->next = *cp;
54. *cp = cd;
55. mutex_unlock(&chrdevs_lock);
56. return cd;
57. out:
58. mutex_unlock(&chrdevs_lock);
59. kfree(cd);
60. return ERR_PTR(ret);
61. }

1. static inline int register_chrdev(unsigned int major, const char *name,
2. const struct file_operations *fops)
3. {
4. return __register_chrdev(major, 0, 256, name, fops);
5. }

1. int __register_chrdev(unsigned int major, unsigned int baseminor,
2. unsigned int count, const char *name,
3. const struct file_operations *fops)
4. {
5. struct char_device_struct *cd;
6. struct cdev *cdev;
7. int err = -ENOMEM;
8. cd = __register_chrdev_region(major, baseminor, count, name);
9. if (IS_ERR(cd))
10. return PTR_ERR(cd);
11. cdev = cdev_alloc();
12. if (!cdev)
13. goto out2;
14. cdev->owner = fops->owner;
15. cdev->ops = fops;
16. kobject_set_name(&cdev->kobj, "%s", name);
17. err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
18. if (err)
19. goto out;
20. cd->cdev = cdev;
21. return major ? 0 : cd->major;
22. out:
23. kobject_put(&cdev->kobj);
24. out2:
25. kfree(__unregister_chrdev_region(cd->major, baseminor, count));
26. return err;
27. }

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/cdev.h>
4. static int major = 250;
5. static int minor = 0;
6. static dev_t devno;
7. static struct cdev cdev;
8. static int hello_open (struct inode *inode, struct file *filep)
9. {
10. printk("hello_open \n");
11. return 0;
12. }
13. static struct file_operations hello_ops=
14. {
15. .open = hello_open,
16. };
17. static int hello_init(void)
18. {
19. int ret;
20. printk("hello_init");
21. devno = MKDEV(major,minor);
22. ret = register_chrdev_region(devno, 1, "hello");
23. if(ret < 0)
24. {
25. printk("register_chrdev_region fail \n");
26. return ret;
27. }
28. cdev_init(&cdev,&hello_ops);
29. ret = cdev_add(&cdev,devno,1);
30. if(ret < 0)
31. {
32. printk("cdev_add fail \n");
33. return ret;
34. }
35. return 0;
36. }
37. static void hello_exit(void)
38. {
39. cdev_del(&cdev);
40. unregister_chrdev_region(devno,1);
41. printk("hello_exit \n");
42. }
43. MODULE_LICENSE("GPL");
44. module_init(hello_init);
45. module_exit(hello_exit);

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. main()
6. {
7. int fd;
8. fd = open("/dev/hello",O_RDWR);
9. if(fd<0)
10. {
11. perror("open fail \n");
12. return ;
13. }
14. close(fd);
15. }

1. ifneq  ($(KERNELRELEASE),)
2. obj-m:=hello.o
3. $(info "2nd")
4. else
5. KDIR := /lib/modules/$(shell uname -r)/build
6. PWD:=$(shell pwd)
7. all:
8. $(info "1st")
9. make -C $(KDIR) M=$(PWD) modules
10. clean:
11. rm -f *.ko *.o *.symvers *.mod.c *.mod.o *.order
12. endif

1. #define class_create(owner, name)       \
2. ({                      \
3. static struct lock_class_key __key; \
4. __class_create(owner, name, &__key);    \
5. })

1. struct class *__class_create(struct module *owner, const char *name,
2. struct lock_class_key *key)
3. {
4. struct class *cls;
5. int retval;
6. cls = kzalloc(sizeof(*cls), GFP_KERNEL);
7. if (!cls) {
8. retval = -ENOMEM;
9. goto error;
10. }
11. cls->name = name;
12. cls->owner = owner;
13. cls->class_release = class_create_release;
14. retval = __class_register(cls, key);
15. if (retval)
16. goto error;
17. return cls;
18. error:
19. kfree(cls);
20. return ERR_PTR(retval);
21. }
22. EXPORT_SYMBOL_GPL(__class_create);

1. void class_destroy(struct class *cls)
2. {
3. if ((cls == NULL) || (IS_ERR(cls)))
4. return;
5. class_unregister(cls);
6. }

1. struct device *device_create(struct class *class, struct device *parent,
2. dev_t devt, void *drvdata, const char *fmt, ...)
3. {
4. va_list vargs;
5. struct device *dev;
6. va_start(vargs, fmt);
7. dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
8. va_end(vargs);
9. return dev;
10. }

1. struct device *device_create_vargs(struct class *class, struct device *parent,
2. dev_t devt, void *drvdata, const char *fmt,
3. va_list args)
4. {
5. return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
6. fmt, args);
7. }

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/cdev.h>
4. #include <linux/device.h>
5. static int major = 250;
6. static int minor=0;
7. static dev_t devno;
8. static struct class *cls;
9. static struct device *test_device;
10. static int hello_open (struct inode *inode, struct file *filep)
11. {
12. printk("hello_open \n");
13. return 0;
14. }
15. static struct file_operations hello_ops=
16. {
17. .open = hello_open,
18. };
19. static int hello_init(void)
20. {
21. int ret;
22. printk("hello_init \n");
23. devno = MKDEV(major,minor);
24. ret = register_chrdev(major,"hello",&hello_ops);
25. cls = class_create(THIS_MODULE, "myclass");
26. if(IS_ERR(cls))
27. {
28. unregister_chrdev(major,"hello");
29. return -EBUSY;
30. }
31. test_device = device_create(cls,NULL,devno,NULL,"hello");//mknod /dev/hello
32. if(IS_ERR(test_device))
33. {
34. class_destroy(cls);
35. unregister_chrdev(major,"hello");
36. return -EBUSY;
37. }
38. return 0;
39. }
40. static void hello_exit(void)
41. {
42. device_destroy(cls,devno);
43. class_destroy(cls);
44. unregister_chrdev(major,"hello");
45. printk("hello_exit \n");
46. }
47. MODULE_LICENSE("GPL");
48. module_init(hello_init);
49. module_exit(hello_exit);

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. main()
6. {
7. int fd;
8. fd = open("/dev/hello",O_RDWR);
9. if(fd<0)
10. {
11. perror("open fail \n");
12. return ;
13. }
14. close(fd);
15. }

1. ifneq  ($(KERNELRELEASE),)
2. obj-m:=hello.o
3. $(info "2nd")
4. else
5. KDIR := /lib/modules/$(shell uname -r)/build
6. PWD:=$(shell pwd)
7. all:
8. $(info "1st")
9. make -C $(KDIR) M=$(PWD) modules
10. clean:
11. rm -f *.ko *.o *.symvers *.mod.c *.mod.o *.order
12. endif

1. struct inode {
2. struct hlist_node i_hash;
3. struct list_head i_list;
4. struct list_head i_sb_list;
5. struct list_head i_dentry;
6. unsigned long  i_ino;
7. atomic_t  i_count;
8. unsigned int  i_nlink;
9. uid_t   i_uid;//inode拥有者id
10. gid_t   i_gid;//inode所属群组id
11. dev_t   i_rdev;//若是设备文件，表示记录设备的设备号
12. u64   i_version;
13. loff_t   i_size;//inode所代表大少
14. #ifdef __NEED_I_SIZE_ORDERED
15. seqcount_t  i_size_seqcount;
16. #endif
17. struct timespec  i_atime;//inode最近一次的存取时间
18. struct timespec  i_mtime;//inode最近一次修改时间
19. struct timespec  i_ctime;//inode的生成时间
20. unsigned int  i_blkbits;
21. blkcnt_t  i_blocks;
22. unsigned short          i_bytes;
23. umode_t   i_mode;
24. spinlock_t  i_lock;
25. struct mutex  i_mutex;
26. struct rw_semaphore i_alloc_sem;
27. const struct inode_operations *i_op;
28. const struct file_operations *i_fop;
29. struct super_block *i_sb;
30. struct file_lock *i_flock;
31. struct address_space *i_mapping;
32. struct address_space i_data;
33. #ifdef CONFIG_QUOTA
34. struct dquot  *i_dquot[MAXQUOTAS];
35. #endif
36. struct list_head i_devices;
37. union {
38. struct pipe_inode_info *i_pipe;
39. struct block_device *i_bdev;
40. struct cdev  *i_cdev;//若是字符设备，对应的为cdev结构体
41. };

1. #define CHRDEV_MAJOR_HASH_SIZE 255
2. static DEFINE_MUTEX(chrdevs_lock);
3. static struct char_device_struct {
4. struct char_device_struct *next; // 结构体指针
5. unsigned int major;              // 主设备号
6. unsigned int baseminor;          // 次设备起始号
7. int minorct;                     // 次备号个数
8. char name[64];
9. struct cdev *cdev; /* will die */
10. } *chrdevs[CHRDEV_MAJOR_HASH_SIZE];      // 只能挂255个字符主设备<span style="font-family: Arial, Helvetica, sans-serif; rgb(255, 255, 255);">  </span>

1. struct file_operations {
2. struct module *owner;//拥有该结构的模块的指针，一般为THIS_MODULES
3. loff_t (*llseek) (struct file *, loff_t, int);//用来修改文件当前的读写位置
4. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);//从设备中同步读取数据
5. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);//向设备发送数据
6. ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);//初始化一个异步的读取操作
7. ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);//初始化一个异步的写入操作
8. int (*readdir) (struct file *, void *, filldir_t);//仅用于读取目录，对于设备文件，该字段为NULL
9. unsigned int (*poll) (struct file *, struct poll_table_struct *); //轮询函数，判断目前是否可以进行非阻塞的读写或写入
10. int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); //执行设备I/O控制命令
11. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); //不使用BLK文件系统，将使用此种函数指针代替ioctl
12. long (*compat_ioctl) (struct file *, unsigned int, unsigned long); //在64位系统上，32位的ioctl调用将使用此函数指针代替
13. int (*mmap) (struct file *, struct vm_area_struct *); //用于请求将设备内存映射到进程地址空间
14. int (*open) (struct inode *, struct file *); //打开
15. int (*flush) (struct file *, fl_owner_t id);
16. int (*release) (struct inode *, struct file *); //关闭
17. int (*fsync) (struct file *, struct dentry *, int datasync); //刷新待处理的数据
18. int (*aio_fsync) (struct kiocb *, int datasync); //异步刷新待处理的数据
19. int (*fasync) (int, struct file *, int); //通知设备FASYNC标志发生变化
20. int (*lock) (struct file *, int, struct file_lock *);
21. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
22. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
23. int (*check_flags)(int);
24. int (*flock) (struct file *, int, struct file_lock *);
25. ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
26. ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
27. int (*setlease)(struct file *, long, struct file_lock **);
28. };

1. static int ***_fasync(int fd,struct file *filp,int mode)
2. {
3. struct ***_dev * dev=filp->private_data;
4. return fasync_helper(fd,filp,mode,&dev->async_queue);//第四个参数为 fasync_struct结构体指针的指针。
5. //这个函数是用来处理FASYNC标志的函数。（FASYNC：表示兼容BSD的fcntl同步操作）当这个标志改变时，驱动程序中的fasync（）函数将得到执行。  （注：感觉这个‘标志'词用的并不恰当）
6. }

1. int *pgpx2con  ;
2. int *pgpx2dat;
3. pgpx2con = ioremap( GPX2CON, 4);
4. pgpx2dat = ioremap(GPX2DAT,4);
5. readl(pgpx2con);
6. writel(0x01, pgpx2dat );

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/cdev.h>
4. #include <linux/device.h>
5. #include <asm/io.h>
6. #include <asm/uaccess.h>
7. static int major = 250;
8. static int minor=0;
9. static dev_t devno;
10. static struct class *cls;
11. static struct device *test_device;
12. #define  GPX2CON    0x11000c40
13. #define  GPX2DAT    0x11000c44
14. #define  GPX1CON    0x11000c20
15. #define  GPX1DAT    0x11000c24
16. #define  GPF3CON    0x114001e0
17. #define  GPF3DAT    0x114001e4
18. static int *pgpx2con  ;
19. static int *pgpx2dat;
20. static int *pgpx1con  ;
21. static int *pgpx1dat;
22. static int *pgpf3con  ;
23. static int *pgpf3dat;
24. void fs4412_led_off(int num);
25. void fs4412_led_on(int num)
26. {
27. switch(num)
28. {
29. case 1:
30. writel(readl(pgpx2dat) |(0x1<<7), pgpx2dat);
31. break;
32. case 2:
33. writel(readl(pgpx1dat) |(0x1<<0), pgpx1dat);
34. break;
35. case 3:
36. writel(readl(pgpf3dat) |(0x1<<4), pgpf3dat);
37. break;
38. case 4:
39. writel(readl(pgpf3dat) |(0x1<<5), pgpf3dat);
40. break;
41. default:
42. fs4412_led_off(1);
43. fs4412_led_off(2);
44. fs4412_led_off(3);
45. fs4412_led_off(4);
46. break;
47. }
48. }
49. void fs4412_led_off(int num)
50. {
51. switch(num)
52. {
53. case 1:
54. writel(readl(pgpx2dat) &(~(0x1<<7)), pgpx2dat);
55. break;
56. case 2:
57. writel(readl(pgpx1dat)&(~(0x1<<0)), pgpx1dat);
58. break;
59. case 3:
60. writel(readl(pgpf3dat) &(~(0x1<<4)), pgpf3dat);
61. break;
62. case 4:
63. writel(readl(pgpf3dat) &(~(0x1<<5)), pgpf3dat);
64. break;
65. }
66. }
67. static int led_open (struct inode *inode, struct file *filep)
68. {//open
69. fs4412_led_off(1);
70. fs4412_led_off(2);
71. fs4412_led_off(3);
72. fs4412_led_off(4);
73. return 0;
74. }
75. static int led_release(struct inode *inode, struct file *filep)
76. {//close
77. fs4412_led_off(1);
78. fs4412_led_off(2);
79. fs4412_led_off(3);
80. fs4412_led_off(4);
81. return 0;
82. }
83. static ssize_t led_read(struct file *filep, char __user *buf, size_t len, loff_t *pos)
84. {
85. return 0;
86. }
87. static ssize_t led_write(struct file *filep, const char __user *buf, size_t len, loff_t *pos)
88. {
89. int led_num;
90. if(len !=4)
91. {
92. return -EINVAL;
93. }
94. if(copy_from_user(&led_num,buf,len))
95. {
96. return -EFAULT;
97. }
98. fs4412_led_on(led_num);
99. printk("led_num =%d \n",led_num);
100. return 0;
101. }
102. static struct file_operations hello_ops=
103. {
104. .open     = led_open,
105. .release = led_release,
106. .read     = led_read,
107. .write    = led_write,
108. };
109. static void fs4412_led_init(void)
110. {
111. pgpx2con = ioremap(GPX2CON,4);
112. pgpx2dat = ioremap(GPX2DAT,4);
113. pgpx1con = ioremap(GPX1CON,4);
114. pgpx1dat =ioremap(GPX1DAT,4);
115. pgpf3con  = ioremap(GPF3CON,4);
116. pgpf3dat =ioremap(GPF3DAT,4);
117. writel((readl(pgpx2con)& ~(0xf<<28)) |(0x1<<28),pgpx2con) ;
118. writel((readl(pgpx1con)& ~(0xf<<0)) |(0x1<<0),pgpx1con) ;
119. writel((readl(pgpf3con)& ~(0xff<<16)) |(0x11<<16),pgpf3con) ;
120. }
121. static int led_init(void)
122. {
123. int ret;
124. devno = MKDEV(major,minor);
125. ret = register_chrdev(major,"led",&hello_ops);
126. cls = class_create(THIS_MODULE, "myclass");
127. if(IS_ERR(cls))
128. {
129. unregister_chrdev(major,"led");
130. return -EBUSY;
131. }
132. test_device = device_create(cls,NULL,devno,NULL,"led");//mknod /dev/hello
133. if(IS_ERR(test_device))
134. {
135. class_destroy(cls);
136. unregister_chrdev(major,"led");
137. return -EBUSY;
138. }
139. fs4412_led_init();
140. return 0;
141. }
142. void fs4412_led_unmap(void)
143. {
144. iounmap(pgpx2con);
145. iounmap(pgpx2dat );
146. iounmap(pgpx1con);
147. iounmap(pgpx1dat );
148. iounmap(pgpf3con );
149. iounmap(pgpf3dat );
150. }
151. static void led_exit(void)
152. {
153. fs4412_led_unmap();
154. device_destroy(cls,devno);
155. class_destroy(cls);
156. unregister_chrdev(major,"led");
157. printk("led_exit \n");
158. }
159. MODULE_LICENSE("GPL");
160. module_init(led_init);
161. module_exit(led_exit);

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. main()
6. {
7. int fd,i,lednum;
8. fd = open("/dev/led",O_RDWR);
9. if(fd<0)
10. {
11. perror("open fail \n");
12. return ;
13. }
14. for(i=0;i<100;i++)
15. {
16. lednum=0;
17. write(fd,&lednum,sizeof(int));
18. lednum = i%4+1;
19. write(fd,&lednum,sizeof(int));
20. sleep(1);
21. }
22. close(fd);
23. }

1. ifneq  ($(KERNELRELEASE),)
2. obj-m:=hello.o
3. $(info "2nd")
4. else
5. #KDIR := /lib/modules/$(shell uname -r)/build
6. KDIR := /home/xiaoming/linux-3.14-fs4412
7. PWD:=$(shell pwd)
8. all:
9. $(info "1st")
10. make -C $(KDIR) M=$(PWD) modules
11. arm-none-linux-gnueabi-gcc test.c
12. sudo cp hello.ko a.out /rootfs/test/
13. clean:
14. rm -f *.ko *.o *.symvers *.mod.c *.mod.o *.order
15. endif

1. unsigned int   *gpd0con;
2. void *timer_base;<span style="white-space:pre">   </span>//之所以是void类型，偏移量为4时，只是移动4个字节，方便理解
3. gpd0con = ioremap(GPD0CON,4);
4. timer_base = ioremap(TIMER_BASE , 0x14);

1. writel((readl(gpd0con)&~(0xf<<0)) | (0x2<<0),gpd0con);
2. writel ((readl(timer_base +TCFG0  )&~(0xff<<0)) | (0xff <<0),timer_base +TCFG0);
3. writel ((readl(timer_base +TCFG1 )&~(0xf<<0)) | (0x2 <<0),timer_base +TCFG1 );

1. writel(500, timer_base +TCNTB0  );
2. writel(250, timer_base +TCMPB0 );
3. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x2 <<0),timer_base +TCON );

1. void beep_on(void)
2. {
3. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x9 <<0),timer_base +TCON );
4. }
5. void beep_off(void)
6. {
7. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x0 <<0),timer_base +TCON );
8. }

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/cdev.h>
4. #include <linux/device.h>
5. #include <asm/io.h>
6. #include <asm/uaccess.h>
7. static int major = 250;
8. static int minor=0;
9. static dev_t devno;
10. static struct class *cls;
11. static struct device *test_device;
12. #define GPD0CON       0x114000a0
13. #define TIMER_BASE    0x139D0000
14. #define TCFG0         0x0000
15. #define TCFG1         0x0004
16. #define TCON          0x0008
17. #define TCNTB0        0x000C
18. #define TCMPB0        0x0010
19. static unsigned int *gpd0con;
20. static void *timer_base;
21. #define  MAGIC_NUMBER    'k'
22. #define  BEEP_ON    _IO(MAGIC_NUMBER    ,0)
23. #define  BEEP_OFF   _IO(MAGIC_NUMBER    ,1)
24. #define  BEEP_FREQ   _IO(MAGIC_NUMBER   ,2)
25. static void fs4412_beep_init(void)
26. {
27. gpd0con = ioremap(GPD0CON,4);
28. timer_base = ioremap(TIMER_BASE,0x14);
29. writel ((readl(gpd0con)&~(0xf<<0)) | (0x2<<0),gpd0con);
30. writel ((readl(timer_base +TCFG0  )&~(0xff<<0)) | (0xff <<0),timer_base +TCFG0);
31. writel ((readl(timer_base +TCFG1 )&~(0xf<<0)) | (0x2 <<0),timer_base +TCFG1 );
32. writel (500, timer_base +TCNTB0  );
33. writel (250, timer_base +TCMPB0 );
34. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x2 <<0),timer_base +TCON );
35. }
36. void fs4412_beep_on(void)
37. {
38. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x9 <<0),timer_base +TCON );
39. }
40. void fs4412_beep_off(void)
41. {
42. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x0 <<0),timer_base +TCON );
43. }
44. static int beep_open (struct inode *inode, struct file *filep)
45. {
46. // fs4412_beep_on();
47. return 0;
48. }
49. static int beep_release(struct inode *inode, struct file *filep)
50. {
51. fs4412_beep_off();
52. return 0;
53. }
54. #define BEPP_IN_FREQ 100000
55. static void beep_freq(unsigned long arg)
56. {
57. writel(BEPP_IN_FREQ/arg, timer_base +TCNTB0  );
58. writel(BEPP_IN_FREQ/(2*arg), timer_base +TCMPB0 );
59. }
60. static long beep_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
61. {
62. switch(cmd)
63. {
64. case BEEP_ON:
65. fs4412_beep_on();
66. break;
67. case BEEP_OFF:
68. fs4412_beep_off();
69. break;
70. case BEEP_FREQ:
71. beep_freq( arg );
72. break;
73. default :
74. return -EINVAL;
75. }
76. }
77. static struct file_operations beep_ops=
78. {
79. .open     = beep_open,
80. .release = beep_release,
81. .unlocked_ioctl      = beep_ioctl,
82. };
83. static int beep_init(void)
84. {
85. int ret;
86. devno = MKDEV(major,minor);
87. ret = register_chrdev(major,"beep",&beep_ops);
88. cls = class_create(THIS_MODULE, "myclass");
89. if(IS_ERR(cls))
90. {
91. unregister_chrdev(major,"beep");
92. return -EBUSY;
93. }
94. test_device = device_create(cls,NULL,devno,NULL,"beep");//mknod /dev/hello
95. if(IS_ERR(test_device))
96. {
97. class_destroy(cls);
98. unregister_chrdev(major,"beep");
99. return -EBUSY;
100. }
101. fs4412_beep_init();
102. return 0;
103. }
104. void fs4412_beep_unmap(void)
105. {
106. iounmap(gpd0con);
107. iounmap(timer_base);
108. }
109. static void beep_exit(void)
110. {
111. fs4412_beep_unmap();
112. device_destroy(cls,devno);
113. class_destroy(cls);
114. unregister_chrdev(major,"beep");
115. printk("beep_exit \n");
116. }
117. MODULE_LICENSE("GPL");
118. module_init(beep_init);
119. module_exit(beep_exit);

1. ifneq  ($(KERNELRELEASE),)
2. obj-m:=beep.o
3. $(info "2nd")
4. else
5. #KDIR := /lib/modules/$(shell uname -r)/build
6. KDIR := /home/fs/linux/linux-3.14-fs4412
7. PWD:=$(shell pwd)
8. all:
9. $(info "1st")
10. make -C $(KDIR) M=$(PWD) modules
11. arm-none-linux-gnueabi-gcc test.c -o beeptest
12. sudo cp beep.ko beeptest /tftpboot
13. clean:
14. rm -f *.ko *.o *.symvers *.mod.c *.mod.o *.order
15. endif

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. #include <sys/ioctl.h>
6. #define  MAGIC_NUMBER    'k'
7. #define   BEEP_ON    _IO(MAGIC_NUMBER    ,0)
8. #define   BEEP_OFF   _IO(MAGIC_NUMBER    ,1)
9. #define   BEEP_FREQ   _IO(MAGIC_NUMBER    ,2)
10. main()
11. {
12. int fd;
13. fd = open("/dev/beep",O_RDWR);
14. if(fd<0)
15. {
16. perror("open fail \n");
17. return ;
18. }
19. ioctl(fd,BEEP_ON);
20. sleep(6);
21. ioctl(fd,BEEP_OFF);
22. close(fd);
23. }

1. /*
2. * main.c : test demo driver
3. */
4. #include <stdio.h>
5. #include <stdlib.h>
6. #include <unistd.h>
7. #include <fcntl.h>
8. #include <string.h>
9. #include <sys/types.h>
10. #include <sys/stat.h>
11. #include <sys/ioctl.h>
12. #include "pwm_music.h"
13. /*ioctl 鍛戒护*/
14. #define magic_number 'k'
15. #define BEEP_ON _IO(magic_number,0)
16. #define BEEP_OFF _IO(magic_number,1)
17. #define SET_FRE _IO(magic_number,2)
18. int main(void)
19. {
20. int i = 0;
21. int n = 2;
22. int dev_fd;
23. int div;
24. dev_fd = open("/dev/beep",O_RDWR | O_NONBLOCK);
25. if ( dev_fd == -1 ) {
26. perror("open");
27. exit(1);
28. }
29. for(i = 0;i<sizeof(GreatlyLongNow)/sizeof(Note);i++ )
30. {
31. div = (GreatlyLongNow[i].pitch);
32. ioctl(dev_fd, SET_FRE, div);
33. ioctl(dev_fd, BEEP_ON);
34. usleep(GreatlyLongNow[i].dimation * 100);
35. ioctl(dev_fd, BEEP_OFF);
36. }
37. for(i = 0;i<sizeof(MumIsTheBestInTheWorld)/sizeof(Note);i++ )
38. {
39. div = (MumIsTheBestInTheWorld[i].pitch);
40. ioctl(dev_fd, SET_FRE, div);
41. ioctl(dev_fd, BEEP_ON);
42. usleep(MumIsTheBestInTheWorld[i].dimation * 100);
43. ioctl(dev_fd, BEEP_OFF);
44. }
45. for(i = 0;i<sizeof(FishBoat)/sizeof(Note);i++ )
46. {
47. div = (FishBoat[i].pitch);
48. ioctl(dev_fd, SET_FRE, div);
49. ioctl(dev_fd, BEEP_ON);
50. usleep(FishBoat[i].dimation * 100);
51. ioctl(dev_fd, BEEP_OFF);
52. }
53. return 0;
54. }

1. #ifndef __PWM_MUSIC_H
2. #define __PWM_MUSIC_H
3. #define BIG_D
4. #define PCLK (202800000/4)
5. typedef struct
6. {
7. int pitch;
8. int dimation;
9. }Note;
10. // 1            2       3        4          5           6       7
11. // C            D       E        F          G           A       B
12. //261.6256  293.6648   329.6276 349.2282   391.9954     440     493.8833
13. //C澶ц皟
14. #ifdef BIG_C
15. #define DO 262
16. #define RE 294
17. #define MI 330
18. #define FA 349
19. #define SOL 392
20. #define LA  440
21. #define SI  494
22. #define TIME 6000
23. #endif
24. //D澶ц皟
25. #ifdef BIG_D
26. #define DO 293
27. #define RE 330
28. #define MI 370
29. #define FA 349
30. #define SOL 440
31. #define LA  494
32. #define SI  554
33. #define TIME 6000
34. #endif
35. Note MumIsTheBestInTheWorld[]={
36. //6.              //_5       //3         //5
37. {LA,TIME+TIME/2}, {SOL,TIME/2},{MI,TIME},{SOL,TIME},
38. //1^           //6_       //_5      //6-
39. {DO*2,TIME},{LA,TIME/2},{SOL,TIME/2} ,{LA,2*TIME},
40. // 3      //5_      //_6           //5
41. {MI,TIME},{SOL,TIME/2},{LA,TIME/2},{SOL,TIME},
42. // 3        //1_        //_6,
43. {MI,TIME},{DO,TIME/2},{LA/2,TIME/2},
44. //5_        //_3        //2-           //2.
45. {SOL,TIME/2},{MI,TIME/2},{RE,TIME*2},{RE,TIME+TIME/2},
46. //_3    //5         //5_            //_6
47. {MI,TIME/2},{SOL,TIME},{SOL,TIME/2},{LA,TIME/2},
48. // 3        //2         //1-            //5.
49. {MI,TIME},{RE,TIME},{DO,TIME*2},{SOL,TIME+TIME/2},
50. //_3        //2_        //_1        //6,_
51. {MI,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME/2},
52. //_1        //5,--
53. {DO,TIME/2},{SOL/2,TIME*3}
54. };
55. Note GreatlyLongNow[]={
56. // 2        3           3       3.              _2              1
57. {RE,TIME}, {MI,TIME},{MI,TIME},{MI,TIME+TIME/2},{RE,TIME/2},{DO,TIME},
58. //6,        1           2       1--             2           3           3
59. {LA/2,TIME},{DO,TIME},{RE,TIME},{DO,TIME*3},{RE,TIME},{MI,TIME},{MI,TIME},
60. //3.                _5          3           3           2           3
61. {MI,TIME+TIME/2},{SOL,TIME/2},{MI,TIME},{MI,TIME},{RE,TIME},{MI,TIME},
62. //3--       5           6           6         6.                _5
63. {MI,TIME*3},{SOL,TIME},{LA,TIME},{LA,TIME},{LA,TIME+TIME/2},{SOL,TIME/2},
64. // 3        3       5               6       5---            2           3
65. {MI,TIME},{MI,TIME},{SOL,TIME},{LA,TIME},{SOL,TIME*3},{RE,TIME},{MI,TIME},
66. // 3        2.              _3              3         2         3
67. {MI,TIME},{RE,TIME+TIME/2},{MI,TIME/2},{MI,TIME},{RE,TIME},{MI,TIME},
68. //6,        1_            _6,             6,-
69. {LA/2,TIME},{DO,TIME/2},{LA/2,TIME/2},{LA/2,TIME*2},
70. //2_        _2          2_              _1          6,
71. {RE,TIME/2},{RE,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME},
72. //2_        _2          2_              _1          6,
73. {RE,TIME/2},{RE,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME},
74. // 2        3       1           2.                  _3          5
75. {RE,TIME},{MI,TIME},{DO,TIME},{RE,TIME+TIME/2},{MI,TIME/2},{SOL,TIME},
76. //6_        _6              6_          _5          3
77. {LA,TIME/2},{LA,TIME/2},{LA,TIME/2},{SOL,TIME/2},{MI,TIME},
78. //2_        _2          2_              _1          6,
79. {RE,TIME/2},{RE,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME},
80. //6,        5,.                   _6,            6,--
81. {LA/2,TIME},{SOL/2,TIME+TIME/2},{LA/2,TIME/2},{LA/2,TIME*3},
82. //2_        _2          2_              _1          6,
83. {RE,TIME/2},{RE,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME},
84. //2_        _2          2_              _1          6,
85. {RE,TIME/2},{RE,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME},
86. // 2        3       1           2.                  _3          5
87. {RE,TIME},{MI,TIME},{DO,TIME},{RE,TIME+TIME/2},{MI,TIME/2},{SOL,TIME},
88. //6_        _6              6_          _5          3
89. {LA,TIME/2},{LA,TIME/2},{LA,TIME/2},{SOL,TIME/2},{MI,TIME},
90. //2_        _2          2_              _1          6,
91. {RE,TIME/2},{RE,TIME/2},{RE,TIME/2},{DO,TIME/2},{LA/2,TIME},
92. //6,        5,.                   _6,            6,--
93. {LA/2,TIME},{SOL/2,TIME+TIME/2},{LA/2,TIME/2},{LA/2,TIME*3}
94. };
95. Note FishBoat[]={ //3.              _5          6._                 =1^          6_
96. {MI,TIME+TIME/2},{SOL,TIME/2},{LA,TIME/2+TIME/4},{DO*2,TIME/4},{LA,TIME/2},
97. //_5            3 -.        2         1.             _3          2._
98. {SOL,TIME/2},{MI,TIME*3},{RE,TIME},{DO,TIME+TIME/2},{MI,TIME/2},{RE,TIME/2+TIME/4},
99. //=3            2_          _1       2--            3.              _5
100. {MI,TIME/4},{RE,TIME/2},{DO,TIME/2},{RE,TIME*4},{MI,TIME+TIME/2},{SOL,TIME/2},
101. // 2        1       6._                 =1^             6_          _5
102. {RE,TIME},{DO,TIME},{LA,TIME/2+TIME/4},{DO*2,TIME/4},{LA,TIME/2},{SOL,TIME/2},
103. //6-         5,.                    _6,         1._                 =3
104. {LA,TIME*2},{SOL/2,TIME+TIME/2},{LA/2,TIME/2},{DO,TIME/2+TIME/4},{MI,TIME/4},
105. //2_            _1       5,--
106. {RE,TIME/2},{DO,TIME/2},{SOL/2,TIME*4},
107. //3.                _5          6._                 =1^         6_
108. {MI,TIME+TIME/2},{SOL,TIME/2},{LA,TIME/2+TIME/4},{DO*2,TIME/4},{LA,TIME/2},
109. //_5            3-.         5_          _6          1^_                _6
110. {SOL,TIME/2},{MI,TIME*3},{SOL,TIME/2},{LA,TIME/2},{DO*2,TIME+TIME/2},{LA,TIME/2},
111. //5._                   =6          5_        _3            2--
112. {SOL,TIME/2+TIME/4},{LA,TIME/4},{SOL,TIME/2},{MI,TIME/2},{RE,TIME*4},
113. //3.                _5          2._                 =3          2_          _1
114. {MI,TIME+TIME/2},{SOL,TIME/2},{RE,TIME/2+TIME/4},{MI,TIME/4},{RE,TIME/2},{DO,TIME/2},
115. //6._               =1^             6_          _5          6-          1.
116. {LA,TIME/2+TIME/4},{DO*2,TIME/4},{LA,TIME/2},{SOL,TIME/2},{LA,TIME*2},{DO,TIME+TIME/2},
117. //_2         3_         _5              2_          _3          1--
118. {RE,TIME/2},{MI,TIME/2},{SOL,TIME/2},{RE,TIME/2},{MI,TIME/2},{DO,TIME*4}
119. };
120. #endif

1. static inline int copy_from_user(void *to, const void __user volatile *from,
2. unsigned long n)
3. {
4. __chk_user_ptr(from, n);
5. volatile_memcpy(to, from, n);
6. return 0;
7. }
8. static inline int copy_to_user(void __user volatile *to, const void *from,
9. unsigned long n)
10. {
11. __chk_user_ptr(to, n);
12. volatile_memcpy(to, from, n);
13. return 0;
14. }

1. static void volatile_memcpy(volatile char *to, const volatile char *from,
2. unsigned long n)
3. {
4. while (n--)
5. *(to++) = *(from++);
6. }

1. static inline unsigned long __must_check copy_to_user(void __user *to, const void *from, unsigned long n)
2. static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n)

1. static ssize_t hello_read(struct file *filep, char __user *buf, size_t len, loff_t *pos)
2. {
3. if(len>64)
4. {
5. len =64;
6. }
7. if(copy_to_user(buf,temp,len))
8. {
9. return -EFAULT;
10. }
11. return len;
12. }
13. static ssize_t hello_write(struct file *filep, const char __user *buf, size_t len, loff_t *pos)
14. {
15. if(len>64)
16. {
17. len = 64;
18. }
19. if(copy_from_user(temp,buf,len))
20. {
21. return -EFAULT;
22. }
23. printk("write %s\n",temp);
24. return len;
25. }

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. char buf[]="111232342342342";
6. char temp[64]={0};
7. main()
8. {
9. int fd,len;
10. fd = open("/dev/hello",O_RDWR);
11. if(fd<0)
12. {
13. perror("open fail \n");
14. return ;
15. }
16. write(fd,buf,strlen(buf));
17. len=read(fd,temp,sizeof(temp));
18. printf("len=%d,%s \n",len,temp);
19. close(fd);
20. }

1. #define   _IOC_NRBITS        8                               //序数（number）字段的字位宽度，8bits
2. #define   _IOC_TYPEBITS      8                               //幻数（type）字段的字位宽度，8bits
3. #define   _IOC_SIZEBITS      14                              //大小（size）字段的字位宽度，14bits
4. #define   _IOC_DIRBITS       2                               //方向（direction）字段的字位宽度，2bits
5. #define   _IOC_NRMASK       ((1 << _IOC_NRBITS)-1)    //序数字段的掩码，0x000000FF
6. #define   _IOC_TYPEMASK     ((1 << _IOC_TYPEBITS)-1)  //幻数字段的掩码，0x000000FF
7. #define   _IOC_SIZEMASK     ((1 << _IOC_SIZEBITS)-1)   //大小字段的掩码，0x00003FFF
8. #define   _IOC_DIRMASK      ((1 << _IOC_DIRBITS)-1)    //方向字段的掩码，0x00000003
9. #define   _IOC_NRSHIFT     0                                //序数字段在整个字段中的位移，0
10. #define   _IOC_TYPESHIFT   (_IOC_NRSHIFT+_IOC_NRBITS)       //幻数字段的位移，8
11. #define   _IOC_SIZESHIFT   (_IOC_TYPESHIFT+_IOC_TYPEBITS)   //大小字段的位移，16
12. #define   _IOC_DIRSHIFT    (_IOC_SIZESHIFT+_IOC_SIZEBITS)   //方向字段的位移，30
13. #define _IOC_NONE    0U     //没有数据传输
14. #define _IOC_WRITE   1U     //向设备写入数据，驱动程序必须从用户空间读入数据
15. #define _IOC_READ    2U     //从设备中读取数据，驱动程序必须向用户空间写入数据
16. #define _IOC(dir,type,nr,size) \
17. (((dir)  << _IOC_DIRSHIFT) | \
18. ((type) << _IOC_TYPESHIFT) | \
19. ((nr)   << _IOC_NRSHIFT) | \
20. ((size) << _IOC_SIZESHIFT))
21. //构造无参数的命令编号
22. #define _IO(type,nr)             _IOC(_IOC_NONE,(type),(nr),0)
23. //构造从驱动程序中读取数据的命令编号
24. #define _IOR(type,nr,size)     _IOC(_IOC_READ,(type),(nr),sizeof(size))
25. //用于向驱动程序写入数据命令
26. #define _IOW(type,nr,size)    _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
27. //用于双向传输
28. #define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
29. //从命令参数中解析出数据方向，即写进还是读出
30. #define _IOC_DIR(nr)          (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
31. //从命令参数中解析出幻数type
32. #define _IOC_TYPE(nr)              (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
33. //从命令参数中解析出序数number
34. #define _IOC_NR(nr)           (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
35. //从命令参数中解析出用户数据大小
36. #define _IOC_SIZE(nr)         (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
37. #define IOC_IN            (_IOC_WRITE << _IOC_DIRSHIFT)
38. #define IOC_OUT           (_IOC_READ << _IOC_DIRSHIFT)
39. #define IOC_INOUT         ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
40. #define IOCSIZE_MASK      (_IOC_SIZEMASK << _IOC_SIZESHIFT)
41. #define IOCSIZE_SHIFT     (_IOC_SIZESHIFT)

1. //构造无参数的命令编号
2. #define _IO(type,nr)             _IOC(_IOC_NONE,(type),(nr),0)
3. //构造从驱动程序中读取数据的命令编号
4. #define _IOR(type,nr,size)     _IOC(_IOC_READ,(type),(nr),sizeof(size))
5. //用于向驱动程序写入数据命令
6. #define _IOW(type,nr,size)    _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
7. //用于双向传输
8. #define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))

1. #define   MAGIC_NUMBER    'k'
2. #define   BEEP_ON    _IO(MAGIC_NUMBER    ,0)
3. #define   BEEP_OFF   _IO(MAGIC_NUMBER    ,1)
4. #define   BEEP_FREQ  _IO(MAGIC_NUMBER    ,2)

1. #define  MAGIC_NUMBER    'k'
2. #define  BEEP_ON    _IO(MAGIC_NUMBER    ,0)
3. #define  BEEP_OFF   _IO(MAGIC_NUMBER    ,1)
4. #define  BEEP_FREQ  _IO(MAGIC_NUMBER    ,2)
5. #define  BEPP_IN_FREQ 100000
6. static void beep_freq(unsigned long arg)
7. {
8. writel(BEPP_IN_FREQ/arg, timer_base +TCNTB0  );
9. writel(BEPP_IN_FREQ/(2*arg), timer_base +TCMPB0 );
10. }
11. static long beep_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
12. {
13. switch(cmd)
14. {
15. case BEEP_ON:
16. fs4412_beep_on();
17. break;
18. case BEEP_OFF:
19. fs4412_beep_off();
20. break;
21. case BEEP_FREQ:
22. beep_freq( arg );
23. break;
24. default :
25. return -EINVAL;
26. }
27. }

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. #include <sys/ioctl.h>
6. #define  MAGIC_NUMBER    'k'
7. #define   BEEP_ON    _IO(MAGIC_NUMBER    ,0)
8. #define   BEEP_OFF   _IO(MAGIC_NUMBER    ,1)
9. #define   BEEP_FREQ   _IO(MAGIC_NUMBER    ,2)
10. main()
11. {
12. int fd;
13. fd = open("/dev/beep",O_RDWR);
14. if(fd<0)
15. {
16. perror("open fail \n");
17. return ;
18. }
19. ioctl(fd,BEEP_ON);
20. sleep(6);
21. ioctl(fd,BEEP_OFF);
22. close(fd);
23. }

1. #define readb __raw_readb
2. #define readw(addr) __le16_to_cpu(__raw_readw(addr))
3. #define readl(addr) __le32_to_cpu(__raw_readl(addr))
4. #ifndef __raw_readb
5. static inline u8 __raw_readb(const volatile void __iomem *addr)
6. {
7. return *(const volatile u8 __force *) addr;
8. }
9. #endif
10. #ifndef __raw_readw
11. static inline u16 __raw_readw(const volatile void __iomem *addr)
12. {
13. return *(const volatile u16 __force *) addr;
14. }
15. #endif
16. #ifndef __raw_readl
17. static inline u32 __raw_readl(const volatile void __iomem *addr)
18. {
19. return *(const volatile u32 __force *) addr;
20. }
21. #endif
22. #define writeb __raw_writeb
23. #define writew(b,addr) __raw_writew(__cpu_to_le16(b),addr)
24. #define writel(b,addr) __raw_writel(__cpu_to_le32(b),addr)

1. #define GPD0CON       0x114000a0
2. #define TIMER_BASE    0x139D0000
3. #define TCFG0         0x0000
4. #define TCFG1         0x0004
5. #define TCON          0x0008
6. #define TCNTB0        0x000C
7. #define TCMPB0        0x0010

1. static unsigned int *gpd0con;
2. static void *timer_base;

1. gpd0con = ioremap(GPD0CON,4);
2. timer_base = ioremap(TIMER_BASE,0x14);

1. writel ((readl(gpd0con)&~(0xf<<0)) | (0x2<<0),gpd0con);
2. writel ((readl(timer_base +TCFG0  )&~(0xff<<0)) | (0xff <<0),timer_base +TCFG0);
3. writel ((readl(timer_base +TCFG1 )&~(0xf<<0)) | (0x2 <<0),timer_base +TCFG1 );
4. writel (500, timer_base +TCNTB0  );
5. writel (250, timer_base +TCMPB0 );
6. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x2 <<0),timer_base +TCON );

1. /*
2. * 超级块结构中定义的字段非常多，
3. * 这里只介绍一些重要的属性
4. */
5. struct super_block {
6. struct list_head    s_list;               /* 指向所有超级块的链表 */
7. const struct super_operations    *s_op; /* 超级块方法 */
8. struct dentry        *s_root;           /* 目录挂载点 */
9. struct mutex        s_lock;            /* 超级块信号量 */
10. int            s_count;                   /* 超级块引用计数 */
11. struct list_head    s_inodes;           /* inode链表 */
12. struct mtd_info        *s_mtd;            /* 存储磁盘信息 */
13. fmode_t            s_mode;                /* 安装权限 */
14. };
15. /*
16. * 其中的 s_op 中定义了超级块的操作方法
17. * 这里只介绍一些相对重要的函数
18. */
19. struct super_operations {
20. struct inode *(*alloc_inode)(struct super_block *sb); /* 创建和初始化一个索引节点对象 */
21. void (*destroy_inode)(struct inode *);                /* 释放给定的索引节点 */
22. void (*dirty_inode) (struct inode *);                 /* VFS在索引节点被修改时会调用这个函数 */
23. int (*write_inode) (struct inode *, int);             /* 将索引节点写入磁盘，wait表示写操作是否需要同步 */
24. void (*drop_inode) (struct inode *);                  /* 最后一个指向索引节点的引用被删除后，VFS会调用这个函数 */
25. void (*delete_inode) (struct inode *);                /* 从磁盘上删除指定的索引节点 */
26. void (*put_super) (struct super_block *);             /* 卸载文件系统时由VFS调用，用来释放超级块 */
27. void (*write_super) (struct super_block *);           /* 用给定的超级块更新磁盘上的超级块 */
28. int (*sync_fs)(struct super_block *sb, int wait);     /* 使文件系统中的数据与磁盘上的数据同步 */
29. int (*statfs) (struct dentry *, struct kstatfs *);    /* VFS调用该函数获取文件系统状态 */
30. int (*remount_fs) (struct super_block *, int *, char *); /* 指定新的安装选项重新安装文件系统时，VFS会调用该函数 */
31. void (*clear_inode) (struct inode *);                 /* VFS调用该函数释放索引节点，并清空包含相关数据的所有页面 */
32. void (*umount_begin) (struct super_block *);          /* VFS调用该函数中断安装操作 */
33. };

1. /*
2. * 索引节点结构中定义的字段非常多，
3. * 这里只介绍一些重要的属性
4. */
5. struct inode {
6. struct hlist_node    i_hash;     /* 散列表，用于快速查找inode */
7. struct list_head    i_list;        /* 索引节点链表 */
8. struct list_head    i_sb_list;  /* 超级块链表超级块  */
9. struct list_head    i_dentry;   /* 目录项链表 */
10. unsigned long        i_ino;      /* 节点号 */
11. atomic_t        i_count;        /* 引用计数 */
12. unsigned int        i_nlink;    /* 硬链接数 */
13. uid_t            i_uid;          /* 使用者id */
14. gid_t            i_gid;          /* 使用组id */
15. struct timespec        i_atime;    /* 最后访问时间 */
16. struct timespec        i_mtime;    /* 最后修改时间 */
17. struct timespec        i_ctime;    /* 最后改变时间 */
18. const struct inode_operations    *i_op;  /* 索引节点操作函数 */
19. const struct file_operations    *i_fop;    /* 缺省的索引节点操作 */
20. struct super_block    *i_sb;              /* 相关的超级块 */
21. struct address_space    *i_mapping;     /* 相关的地址映射 */
22. struct address_space    i_data;         /* 设备地址映射 */
23. unsigned int        i_flags;            /* 文件系统标志 */
24. void            *i_private;             /* fs 私有指针 */
25. };
26. /*
27. * 其中的 i_op 中定义了索引节点的操作方法
28. * 这里只介绍一些相对重要的函数
29. */
30. struct inode_operations {
31. /* 为dentry对象创造一个新的索引节点 */
32. int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
33. /* 在特定文件夹中寻找索引节点，该索引节点要对应于dentry中给出的文件名 */
34. struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
35. /* 创建硬链接 */
36. int (*link) (struct dentry *,struct inode *,struct dentry *);
37. /* 从一个符号链接查找它指向的索引节点 */
38. void * (*follow_link) (struct dentry *, struct nameidata *);
39. /* 在 follow_link调用之后，该函数由VFS调用进行清除工作 */
40. void (*put_link) (struct dentry *, struct nameidata *, void *);
41. /* 该函数由VFS调用，用于修改文件的大小 */
42. void (*truncate) (struct inode *);
43. };

1. /* 目录项对象结构 */
2. struct dentry {
3. atomic_t d_count;       /* 使用计数 */
4. unsigned int d_flags;   /* 目录项标识 */
5. spinlock_t d_lock;        /* 单目录项锁 */
6. int d_mounted;          /* 是否登录点的目录项 */
7. struct inode *d_inode;    /* 相关联的索引节点 */
8. struct hlist_node d_hash;    /* 散列表 */
9. struct dentry *d_parent;    /* 父目录的目录项对象 */
10. struct qstr d_name;         /* 目录项名称 */
11. struct list_head d_lru;        /* 未使用的链表 */
12. /*
13. * d_child and d_rcu can share memory
14. */
15. union {
16. struct list_head d_child;    /* child of parent list */
17. struct rcu_head d_rcu;
18. } d_u;
19. struct list_head d_subdirs;    /* 子目录链表 */
20. struct list_head d_alias;    /* 索引节点别名链表 */
21. unsigned long d_time;        /* 重置时间 */
22. const struct dentry_operations *d_op; /* 目录项操作相关函数 */
23. struct super_block *d_sb;    /* 文件的超级块 */
24. void *d_fsdata;            /* 文件系统特有数据 */
25. unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* 短文件名 */
26. };
27. /* 目录项相关操作函数 */
28. struct dentry_operations {
29. /* 该函数判断目录项对象是否有效。VFS准备从dcache中使用一个目录项时会调用这个函数 */
30. int (*d_revalidate)(struct dentry *, struct nameidata *);
31. /* 为目录项对象生成hash值 */
32. int (*d_hash) (struct dentry *, struct qstr *);
33. /* 比较 qstr 类型的2个文件名 */
34. int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
35. /* 当目录项对象的 d_count 为0时，VFS调用这个函数 */
36. int (*d_delete)(struct dentry *);
37. /* 当目录项对象将要被释放时，VFS调用该函数 */
38. void (*d_release)(struct dentry *);
39. /* 当目录项对象丢失其索引节点时（也就是磁盘索引节点被删除了），VFS会调用该函数 */
40. void (*d_iput)(struct dentry *, struct inode *);
41. char *(*d_dname)(struct dentry *, char *, int);
42. };

1. /*
2. * 文件对象结构中定义的字段非常多，
3. * 这里只介绍一些重要的属性
4. */
5. struct file {
6. union {
7. struct list_head    fu_list;    /* 文件对象链表 */
8. struct rcu_head     fu_rcuhead; /* 释放之后的RCU链表 */
9. } f_u;
10. struct path        f_path;             /* 包含的目录项 */
11. const struct file_operations    *f_op; /* 文件操作函数 */
12. atomic_long_t        f_count;        /* 文件对象引用计数 */
13. };
14. /*
15. * 其中的 f_op 中定义了文件对象的操作方法
16. * 这里只介绍一些相对重要的函数
17. */
18. struct file_operations {
19. /* 用于更新偏移量指针,由系统调用lleek()调用它 */
20. loff_t (*llseek) (struct file *, loff_t, int);
21. /* 由系统调用read()调用它 */
22. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
23. /* 由系统调用write()调用它 */
24. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
25. /* 由系统调用 aio_read() 调用它 */
26. ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
27. /* 由系统调用 aio_write() 调用它 */
28. ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
29. /* 将给定文件映射到指定的地址空间上,由系统调用 mmap 调用它 */
30. int (*mmap) (struct file *, struct vm_area_struct *);
31. /* 创建一个新的文件对象,并将它和相应的索引节点对象关联起来 */
32. int (*open) (struct inode *, struct file *);
33. /* 当已打开文件的引用计数减少时,VFS调用该函数 */
34. int (*flush) (struct file *, fl_owner_t id);
35. };

1. void ext3_read_inode(struct inode * inode)
2. {
3. ……
4. //是普通文件
5. if (S_ISREG(inode->i_mode)) {
6. inode->i_op = &ext3_file_inode_operations;
7. inode->i_fop = &ext3_file_operations;
8. ext3_set_aops(inode);
9. } else if (S_ISDIR(inode->i_mode)) {
10. //是目录文件
11. inode->i_op = &ext3_dir_inode_operations;
12. inode->i_fop = &ext3_dir_operations;
13. } else if (S_ISLNK(inode->i_mode)) {
14. // 是连接文件
15. ……
16. } else {
17. // 如果以上三种情况都排除了，则是设备驱动
18. //这里的设备还包括套结字、FIFO等伪设备
19. ……

1. static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
2. int flags, struct file *f,
3. int (*open)(struct inode *, struct file *))
4. {
5. struct inode *inode;
6. ……
7. //整个函数的工作在于填充一个file对象
8. ……
9. f->f_mapping = inode->i_mapping;
10. f->f_dentry = dentry;
11. f->f_vfsmnt = mnt;
12. f->f_pos = 0;
13. //将对应的索引节点的文件操作函数集赋予文件对象的操作列表
14. f->f_op = fops_get(inode->i_fop);
15. ……
16. //若文件自己定义了open操作，则执行这个特定的open操作。
17. if (!open && f->f_op)
18. open = f->f_op->open;
19. if (open) {
20. error = open(inode, f);
21. if (error)
22. goto cleanup_all;
23. ……
24. return f;
25. }

1. #include <linux/device.h> //设备类用到的头文件
2. staticint device_major = DEVICE_MAJOR; //用于保存系统动态生成的主设备号
3. staticstruct class *button_class; //定义一个类
4. static int __init button_init(void)
5. {
6. //注册字符设备，这里定义DEVICE_MAJOR=0，让系统去分配，注册成功后将返回动态分配的主设备号
7. device_major = register_chrdev(DEVICE_MAJOR, DEVICE_NAME,&buttons_fops);
8. if(device_major< 0)
9. {
10. printk(DEVICE_NAME " register faild!/n");
11. return device_major;
12. }
13. //注册一个设备类，使mdev可以在/dev/目录下建立设备节点
14. button_class =class_create(THIS_MODULE, DEVICE_NAME);
15. if(IS_ERR(button_class))
16. {
17. printk(DEVICE_NAME" create class faild!/n");
18. return-1;
19. }
20. //创建一个设备节点，取名为DEVICE_NAME(即my2440_buttons)
21. //注意2.6内核较早版本的函数名是class_device_create，现该为device_create
22. device_create(button_class,NULL,MKDEV(device_major,0),NULL,DEVICE_NAME);
23. return 0;
24. }
25. static void __exit button_exit(void)
26. {
27. //注销字符设备
28. unregister_chrdev(device_major, DEVICE_NAME);
29. //删除设备节点，注意2.6内核较早版本的函数名是class_device_destroy，现该为device_destroy
30. device_destroy(button_class,MKDEV(device_major,0));
31. //注销类
32. class_destroy(button_class);
33. }

1. struct sysfs_dirent {
2. atomic_t                s_count;
3. atomic_t                s_active;
4. struct sysfs_dirent  *s_parent;  /* 指向父节点 */
5. struct sysfs_dirent  *s_sibling;  /* 指向兄弟节点，兄弟节点是按照inode索引s_ino的大小顺序链接在一起的。*/
6. const char             *s_name;    /* 节点名称 */
7. union {
8. struct sysfs_elem_dir            s_dir;      /* 文件夹，s_dir->kobj指向sysfs对象 */
9. struct sysfs_elem_symlink    s_symlink;  /* 链接 */
10. struct sysfs_elem_attr           s_attr;     /* 普通文件 */
11. struct sysfs_elem_bin_attr     s_bin_attr;  /* 二进制文件 */
12. };
13. unsigned int           s_flags;
14. ino_t          s_ino;     /* inode索引，创建节点时被动态申请，通过此值和sysfs_dirent地址可以到inode散列表中获取inode结构 */
15. umode_t                s_mode;
16. struct iattr             *s_iattr;
17. };

1. struct inode {
2. struct hlist_node     i_hash;    /* 散列表链节 */
3. struct list_head       i_list;
4. struct list_head       i_sb_list;
5. struct list_head       i_dentry;  /* dentry链节 */
6. unsigned long         i_ino;   /* inode索引 */
7. atomic_t             i_count;
8. unsigned int           i_nlink;
9. uid_t                     i_uid;
10. gid_t                     i_gid;
11. dev_t                    i_rdev; /* 主从设备号 */
12. const struct inode_operations *i_op; /* 一组inode操作函数，可用其中lookup查找目录下的inode，对应sysfs为sysfs_lookup函数 */
13. const struct file_operations  *i_fop;    /* 一组文件操作函数，对于sysfs为sysfs的open/read/write等函数 */
14. struct super_block  *i_sb;
15. struct list_head       i_devices;
16. union {
17. struct pipe_inode_info    *i_pipe;
18. struct block_device       *i_bdev;
19. struct cdev            *i_cdev;
20. };
21. };

1. struct dentry {
2. atomic_t d_count;         /* 目录项对象使用的计数器 */
3. unsigned int d_flags;             /* 目录项标志 */
4. spinlock_t d_lock;              /* 目录项自旋锁 */
5. int d_mounted;                     /* 对于安装点而言，表示被安装文件系统根项 */
6. struct inode *d_inode;           /* 文件索引节点(inode) */
7. /*
8. * The next three fields are touched by __d_lookup.  Place them here
9. * so they all fit in a cache line.
10. */
11. struct hlist_node d_hash;       /* lookup hash list */
12. struct dentry *d_parent; /* parent directory */
13. struct qstr d_name;              /* 文件名 */
14. /*
15. * d_child and d_rcu can share memory
16. */
17. union {
18. struct list_head d_child; /* child of parent list */
19. struct rcu_head d_rcu;
20. } d_u;
21. void *d_fsdata;                    /* 与文件系统相关的数据，在sysfs中指向sysfs_dirent */
22. unsigned char d_iname[DNAME_INLINE_LEN_MIN];      /* 存放短文件名 */
23. };

1. static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
2. {
3. struct dentry *ret = NULL;
4. struct sysfs_dirent *parent_sd = dentry->d_parent->d_fsdata; //获取父sysfs_direct
5. struct sysfs_dirent *sd;
6. struct inode *inode;
7. mutex_lock(&sysfs_mutex);
8. /* 在父sysfs_direct查找名为dentry->d_name.name的节点 */
9. sd = sysfs_find_dirent(parent_sd, dentry->d_name.name);
10. /* no such entry */
11. if (!sd) {
12. ret = ERR_PTR(-ENOENT);
13. goto out_unlock;
14. }
15. /* 这儿就是通过sysfs_direct获取对应的inode，sysfs_get_inode实现原理上面已经介绍过了 */
16. /* attach dentry and inode */
17. inode = sysfs_get_inode(sd);
18. if (!inode) {
19. ret = ERR_PTR(-ENOMEM);
20. goto out_unlock;
21. }
22. /* 填充目录项，至此一个目录项创建完毕 */
23. /* instantiate and hash dentry */
24. dentry->d_op = &sysfs_dentry_ops;   /* 填充目录项的操作方法，该方法只提供一释放inode函数sysfs_d_iput */
25. dentry->d_fsdata = sysfs_get(sd);        //填充sysfs_direct
26. d_instantiate(dentry, inode);                 //填充inode
27. d_rehash(dentry);                               //将dentry加入hash表
28. out_unlock:
29. mutex_unlock(&sysfs_mutex);
30. return ret;
31. }

1. struct platform_device {
2. const char * name;/* 设备名 */
3. u32 id;//设备id，用于给插入给该总线并且具有相同name的设备编号，如果只有一个设备的话填-1。
4. struct device dev;//结构体中内嵌的device结构体。
5. u32 num_resources;/* 设备所使用各类资源数量 */
6. struct resource * resource;/* //定义平台设备的资源*/
7. };

1. struct platform_driver {
2. int (*probe)(struct platform_device *);
3. int (*remove)(struct platform_device *);
4. void (*shutdown)(struct platform_device *);
5. int (*suspend)(struct platform_device *, pm_message_t state);
6. int (*suspend_late)(struct platform_device *, pm_message_t state);
7. int (*resume_early)(struct platform_device *);
8. int (*resume)(struct platform_device *);
9. struct pm_ext_ops *pm;
10. struct device_driver driver;
11. };

1. struct bus_type platform_bus_type = {
2. .name = “platform”,
3. .dev_attrs = platform_dev_attrs,
4. .match = platform_match,
5. .uevent = platform_uevent,
6. .pm = PLATFORM_PM_OPS_PTR,
7. };
8. EXPORT_SYMBOL_GPL(platform_bus_type);

1. static int platform_match(struct device *dev, struct device_driver *drv)
2. {
3. struct platform_device *pdev;
4. pdev = container_of(dev, struct platform_device, dev);
5. return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
6. }

1. int platform_add_devices(struct platform_device **devs, int num);

1. int __init platform_bus_init(void)
2. {
3. int error;
4. early_platform_cleanup(); //清除platform设备链表
5. //该函数把设备名为platform 的设备platform_bus注册到系统中，其他的platform的设备都会以它为parent。它在sysfs中目录下.即 /sys/devices/platform。
6. //platform_bus总线也是设备，所以也要进行设备的注册
7. //struct device platform_bus = {
8. //.init_name = "platform",
9. //};
10. error = device_register(&platform_bus);//将平台bus作为一个设备注册，出现在sys文件系统的device目录
11. if (error)
12. return error;
13. //接着bus_register(&platform_bus_type)注册了platform_bus_type总线.
14. /*
15. struct bus_type platform_bus_type = {
16. .name = “platform”,
17. .dev_attrs = platform_dev_attrs,
18. .match = platform_match,
19. .uevent = platform_uevent,
20. .pm = PLATFORM_PM_OPS_PTR,
21. };
22. */
23. //默认platform_bus_type中没有定义probe函数。
24. error = bus_register(&platform_bus_type);//注册平台类型的bus，将出现sys文件系统在bus目录下，创建一个platform的目录，以及相关属性文件
25. if (error)
26. device_unregister(&platform_bus);
27. return error;
28. }

1. static int platform_match(struct device *dev, struct device_driver *drv)
2. {
3. struct platform_device *pdev = to_platform_device(dev);
4. struct platform_driver *pdrv = to_platform_driver(drv);
5. /* match against the id table first */
6. if (pdrv->id_table)
7. return platform_match_id(pdrv->id_table, pdev) != NULL;
8. /* fall-back to driver name match */
9. return (strcmp(pdev->name, drv->name) == 0);//比较设备和驱动的名称是否一样
10. }
11. static const struct platform_device_id *platform_match_id(struct platform_device_id *id,struct platform_device *pdev)
12. {
13. while (id->name[0]) {
14. if (strcmp(pdev->name, id->name) == 0) {
15. pdev->id_entry = id;
16. return id;
17. }
18. id++;
19. }
20. return NULL;
21. }

1. static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
2. {
3. struct platform_device *pdev = to_platform_device(dev);
4. add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
5. return 0;
6. }

1. static struct kset_uevent_ops device_uevent_ops = {
2. .filter = dev_uevent_filter,
3. .name = dev_uevent_name,
4. .uevent = dev_uevent,
5. };

1. int platform_device_register(struct platform_device *pdev)
2. {
3. device_initialize(&pdev->dev);//初始化platform_device内嵌的device
4. return platform_device_add(pdev);//把它注册到platform_bus_type上
5. }
6. int platform_device_add(struct platform_device *pdev)
7. {
8. int i, ret = 0;
9. if (!pdev)
10. return -EINVAL;
11. if (!pdev->dev.parent)
12. pdev->dev.parent = &platform_bus;//设置父节点，即platform_bus作为总线设备的父节点，其余的platform设备都是它的子设备
13. //platform_bus是一个设备，platform_bus_type才是真正的总线
14. pdev->dev.bus = &platform_bus_type;//设置platform总线,指定bus类型为platform_bus_type
15. //设置pdev->dev内嵌的kobj的name字段,将platform下的名字传到内部device，最终会传到kobj
16. if (pdev->id != -1)
17. dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
18. else
19. dev_set_name(&pdev->dev, "%s", pdev->name);
20. //初始化资源并将资源分配给它，每个资源的它的parent不存在则根据flags域设置parent，flags为IORESOURCE_MEM，
21. //则所表示的资源为I/O映射内存，flags为IORESOURCE_IO，则所表示的资源为I/O端口。
22. for (i = 0; i < pdev->num_resources; i++) {
23. struct resource *p, *r = &pdev->resource[i];
24. if (r->name == NULL)//资源名称为NULL则把设备名称设置给它
25. r->name = dev_name(&pdev->dev);
26. p = r->parent;//取得资源的父节点，资源在内核中也是层次安排的
27. if (!p) {
28. if (resource_type(r) == IORESOURCE_MEM) //如果父节点为NULL，并且资源类型为IORESOURCE_MEM，则把父节点设置为iomem_resource
29. p = &iomem_resource;
30. else if (resource_type(r) == IORESOURCE_IO)//否则如果类型为IORESOURCE_IO，则把父节点设置为ioport_resource
31. p = &ioport_resource;
32. }
33. //从父节点申请资源，也就是出现在父节点目录层次下
34. if (p && insert_resource(p, r)) {
35. printk(KERN_ERR "%s: failed to claim resource %d\n",dev_name(&pdev->dev), i);ret = -EBUSY;
36. goto failed;
37. }
38. }
39. pr_debug("Registering platform device '%s'. Parent at %s\n",dev_name(&pdev->dev), dev_name(pdev->dev.parent));
40. //device_creat() 创建一个设备并注册到内核驱动架构...
41. //device_add() 注册一个设备到内核，少了一个创建设备..
42. ret = device_add(&pdev->dev);//就在这里把设备注册到总线设备上,标准设备注册，即在sys文件系统中添加目录和各种属性文件
43. if (ret == 0)
44. return ret;
45. failed:
46. while (--i >= 0) {
47. struct resource *r = &pdev->resource[i];
48. unsigned long type = resource_type(r);
49. if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
50. release_resource(r);
51. }
52. return ret;
53. }

1. struct platform_device * platform_device_alloc(const char *name, int id)
2. {
3. struct platform_object *pa;
4. /*
5. struct platform_object {
6. struct platform_device pdev;
7. char name[1];
8. };
9. */
10. pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);//该函数首先为platform设备分配内存空间
11. if (pa) {
12. strcpy(pa->name, name);
13. pa->pdev.name = pa->name;//初始化platform_device设备的名称
14. pa->pdev.id = id;//初始化platform_device设备的id
15. device_initialize(&pa->pdev.dev);//初始化platform_device内嵌的device
16. pa->pdev.dev.release = platform_device_release;
17. }
18. return pa ? &pa->pdev : NULL;
19. }

1. struct platform_device *platform_device_register_simple(const char *name,int id,struct resource *res,unsigned int num)
2. {
3. struct platform_device *pdev;
4. int retval;
5. pdev = platform_device_alloc(name, id);
6. if (!pdev) {
7. retval = -ENOMEM;
8. goto error;
9. }
10. if (num) {
11. retval = platform_device_add_resources(pdev, res, num);
12. if (retval)
13. goto error;
14. }
15. retval = platform_device_add(pdev);
16. if (retval)
17. goto error;
18. return pdev;
19. error:
20. platform_device_put(pdev);
21. return ERR_PTR(retval);
22. }

1. int platform_device_add_resources(struct platform_device *pdev,struct resource *res, unsigned int num)
2. {
3. struct resource *r;
4. r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);//为资源分配内存空间
5. if (r) {
6. memcpy(r, res, sizeof(struct resource) * num);
7. pdev->resource = r; //并拷贝参数res中的内容，链接到device并设置其num_resources
8. pdev-> num_resources = num;
9. }
10. return r ? 0 : -ENOMEM;
11. }

1. int platform_driver_register(struct platform_driver *drv)
2. {
3. drv->driver.bus = &platform_bus_type;//它将要注册到的总线
4. /*设置成platform_bus_type这个很重要，因为driver和device是通过bus联系在一起的，
5. 具体在本例中是通过 platform_bus_type中注册的回调例程和属性来是实现的,
6. driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。
7. */
8. if (drv->probe)
9. drv-> driver.probe = platform_drv_probe;
10. if (drv->remove)
11. drv->driver.remove = platform_drv_remove;
12. if (drv->shutdown)
13. drv->driver.shutdown = platform_drv_shutdown;
14. return driver_register(&drv->driver);//注册驱动
15. }

1. static int platform_drv_probe(struct device *_dev)
2. {
3. struct platform_driver *drv = to_platform_driver(_dev->driver);
4. struct platform_device *dev = to_platform_device(_dev);
5. return drv->probe(dev);//调用platform_driver的probe()函数，这个函数一般由用户自己实现
6. //例如下边结构，回调的是serial8250_probe()函数
7. /*
8. static struct platform_driver serial8250_isa_driver = {
9. .probe        = serial8250_probe,
10. .remove        = __devexit_p(serial8250_remove),
11. .suspend    = serial8250_suspend,
12. .resume        = serial8250_resume,
13. .driver        = {
14. .name    = "serial8250",
15. .owner    = THIS_MODULE,
16. },
17. };
18. */
19. }
20. static int platform_drv_remove(struct device *_dev)
21. {
22. struct platform_driver *drv = to_platform_driver(_dev->driver);
23. struct platform_device *dev = to_platform_device(_dev);
24. return drv->remove(dev);
25. }
26. static void platform_drv_shutdown(struct device *_dev)
27. {
28. struct platform_driver *drv = to_platform_driver(_dev->driver);
29. struct platform_device *dev = to_platform_device(_dev);
30. drv->shutdown(dev);
31. }

1. struct resource {
2. resource_size_t start;  资源起始地址
3. resource_size_t end;   资源结束地址
4. const char *name;
5. unsigned long flags;   区分是资源什么类型的
6. struct resource *parent, *sibling, *child;
7. };
8. #define IORESOURCE_MEM        0x00000200
9. #define IORESOURCE_IRQ        0x00000400

1. static struct  resource beep_resource[] =
2. {
3. [0] = {
4. .start = 0x114000a0,
5. .end = 0x114000a0+0x4,
6. .flags = IORESOURCE_MEM,
7. },
8. [1] = {
9. .start = 0x139D0000,
10. .end = 0x139D0000+0x14,
11. .flags = IORESOURCE_MEM,
12. },
13. };

a -- 为什么要用 platform 驱动？不用platform驱动可以吗？

b -- 设备驱动中引入platform 概念有什么好处？

      引入platform模型符合Linux 设备模型 —— 总线、设备、驱动，设备模型中配套的sysfs节点都可以用，方便我们的开发；当然你也可以选择不用，不过就失去了一些platform带来的便利；

      设备驱动中引入platform 概念，隔离BSP和驱动。在BSP中定义platform设备和设备使用的资源、设备的具体匹配信息，而在驱动中，只需要通过API去获取资源和数据，做到了板相关代码和驱动代码的分离，使得驱动具有更好的可扩展性和跨平台性。

三、实例

        这是一个蜂鸣器的驱动，其实前面已经有解析 Linux 字符设备驱动开发基础（二）—— 编写简单 PWM 设备驱动， 下面来看一下，套上platform 外壳后的程序：

1、device.c

2、driver.c

3、makefile

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. main()
6. {
7. int fd,i,lednum;
8. fd = open("/dev/beep",O_RDWR);
9. if(fd<0)
10. {
11. perror("open fail \n");
12. return ;
13. }
14. sleep(10);
15. close(fd);
16. }

1. / {
2. node1 {
3. a-string-property = "A string";
4. a-string-list-property = "first string", "second string";
5. a-byte-data-property = [0x01 0x23 0x34 0x56];
6. child-node1 {
7. first-child-property;
8. second-child-property = <1>;
9. a-string-property = "Hello, world";
10. };
11. child-node2 {
12. };
13. };
14. node2 {
15. an-empty-property;
16. a-cell-property = <1 2 3 4>; /* each number (cell) is a uint32 */
17. child-node1 {
18. };
19. };
20. };

1. / {
2. compatible = "acme,coyotes-revenge";
3. cpus {
4. cpu@0 {
5. compatible = "arm,cortex-a9";
6. };
7. cpu@1 {
8. compatible = "arm,cortex-a9";
9. };
10. };
11. serial@101F0000 {
12. compatible = "arm,pl011";
13. };
14. serial@101F2000 {
15. compatible = "arm,pl011";
16. };
17. gpio@101F3000 {
18. compatible = "arm,pl061";
19. };
20. interrupt-controller@10140000 {
21. compatible = "arm,pl190";
22. };
23. spi@10115000 {
24. compatible = "arm,pl022";
25. };
26. external-bus {
27. ethernet@0,0 {
28. compatible = "smc,smc91c111";
29. };
30. i2c@1,0 {
31. compatible = "acme,a1234-i2c-bus";
32. rtc@58 {
33. compatible = "maxim,ds1338";
34. };
35. };
36. flash@2,0 {
37. compatible = "samsung,k8f1315ebm", "cfi-flash";
38. };
39. };
40. };

1. serial@101f2000 {
2. compatible = "arm,pl011";
3. reg = <0x101f2000 0x1000 >;
4. };
5. gpio@101f3000 {
6. compatible = "arm,pl061";
7. reg = <0x101f3000 0x1000
8. 0x101f4000 0x0010>;
9. };
10. interrupt-controller@10140000 {
11. compatible = "arm,pl190";
12. reg = <0x10140000 0x1000 >;
13. };

1. static int platform_match(struct device *dev, struct device_driver *drv)
2. {
3. struct platform_device *pdev = to_platform_device(dev);
4. struct platform_driver *pdrv = to_platform_driver(drv);
5. /* Attempt an OF style match first */
6. if (of_driver_match_device(dev, drv))
7. return 1;
8. /* Then try ACPI style match */
9. if (acpi_driver_match_device(dev, drv))
10. return 1;
11. /* Then try to match against the id table */
12. if (pdrv->id_table)
13. return platform_match_id(pdrv->id_table, pdev) != NULL;
14. /* fall-back to driver name match */
15. return (strcmp(pdev->name, drv->name) == 0);
16. }

1. static inline int of_driver_match_device(struct device *dev,
2. const struct device_driver *drv)
3. {
4. return of_match_device(drv->of_match_table, dev) != NULL;
5. }

1. const struct of_device_id *of_match_device(const struct of_device_id *matches,
2. const struct device *dev)
3. {
4. if ((!matches) || (!dev->of_node))
5. return NULL;
6. return of_match_node(matches, dev->of_node);
7. }
8. EXPORT_SYMBOL(of_match_device);

1. /**
2. * of_match_node - Tell if an device_node has a matching of_match structure
3. *  @matches:   array of of device match structures to search in
4. *  @node:      the of device structure to match against
5. *
6. *  Low level utility function used by device matching.
7. */
8. const struct of_device_id *of_match_node(const struct of_device_id *matches,
9. const struct device_node *node)
10. {
11. const struct of_device_id *match;
12. unsigned long flags;
13. raw_spin_lock_irqsave(&devtree_lock, flags);
14. match = __of_match_node(matches, node);
15. raw_spin_unlock_irqrestore(&devtree_lock, flags);
16. return match;
17. }
18. EXPORT_SYMBOL(of_match_node);

1. const struct of_device_id *__of_match_node(const struct of_device_id *matches,
2. const struct device_node *node)
3. {
4. const struct of_device_id *best_match = NULL;
5. int score, best_score = 0;
6. if (!matches)
7. return NULL;
8. for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
9. score = __of_device_is_compatible(node, matches->compatible,
10. matches->type, matches->name);
11. if (score > best_score) {
12. best_match = matches;
13. best_score = score;
14. }
15. }
16. return best_match;
17. }

1. static int __of_device_is_compatible(const struct device_node *device,
2. const char *compat, const char *type, const char *name)
3. {
4. struct property *prop;
5. const char *cp;
6. int index = 0, score = 0;
7. /* Compatible match has highest priority */
8. if (compat && compat[0]) {
9. prop = __of_find_property(device, "compatible", NULL);
10. for (cp = of_prop_next_string(prop, NULL); cp;
11. cp = of_prop_next_string(prop, cp), index++) {
12. if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
13. score = INT_MAX/2 - (index << 2);
14. break;
15. }
16. }
17. if (!score)
18. return 0;
19. }
20. /* Matching type is better than matching name */
21. if (type && type[0]) {
22. if (!device->type || of_node_cmp(type, device->type))
23. return 0;
24. score += 2;
25. }
26. /* Matching name is a bit better than not */
27. if (name && name[0]) {
28. if (!device->name || of_node_cmp(name, device->name))
29. return 0;
30. score++;
31. }
32. return score;
33. }

成员中有const struct of_device_id*of_match_table; 是struct of_device_id 类型，定义如下：

可以看到其作用就是为了匹配一个设备。我们所要做的就是对 char compatible[128] 的填充；设备树加载之后，内核会自动把设备树节点转换成 platform_device这种格式，同时把名字放到of_node这个地方。

1. static struct of_device_id beep_table[] = {
2. {.compatible = "fs4412,beep"},
3. };
4. static struct platform_driver beep_driver=
5. {
6. .probe = beep_probe,
7. .remove = beep_remove,
8. .driver={
9. .name = "bigbang",
10. .of_match_table = beep_table,
11. },
12. };

1. static struct platform_driver beep_driver=
2. {
3. .driver.name = "bigbang",
4. .probe = beep_probe,
5. .remove = beep_remove,
6. };

1. fs4412-beep{
2. compatible = "fs4412,beep";
3. reg = <0x114000a0 0x4 0x139D0000 0x14>;
4. };

1. local_irq_disable()
2. local_irq_enable()
3. 只能禁止和使能本地CPU的中断，所以不能解决多CPU引发的竞态
4. local_irq_save(flags)
5. local_irq_restore(flags)
6. 除了能禁止和使能中断外，还保存和还原目前的CPU中断位信息
7. local_bh_disable()
8. local_bh_disable()
9. 如果只是想禁止中断的底半部，这是个不错的选择。

typedef struct {
volatile int counter;
} atomic_t;

#define ATOMIC_INIT(i) ( (atomic_t) { (i) } )

#define atomic_set(v,i) ((v)->counter = (i))
void atomic_set(atomic_t *v, int i);//设置原子变量的值为i

#define atomic_read(v) ((v)->counter + 0)
atomic_read(atomic_t *v);//返回原子变量的值

static __inline__ void atomic_add(int i, atomic_t * v)； //原子变量增加i
static __inline__ void atomic_sub(int i, atomic_t * v)； //原子变量减少i

#define atomic_inc(v) atomic_add(1, v)； //原子变量加1
#define atomic_dec(v) atomic_sub(1, v); //原子变量减1

//这些操作对原子变量执行自增,自减,减操作后测试是否为0,是返回true,否则返回false
#define atomic_inc_and_test(v) (atomic_add_return(1, (v)) == 0)
static inline int atomic_add_return(int i, atomic_t *v)

1. static atomic_t v=ATOMIC_INIT(1);
2. static int hello_open (struct inode *inode, struct file *filep)
3. {
4. if(!atomic_dec_and_test(&v))
5. {
6. atomic_inc(&v);
7. return -EBUSY;
8. }
9. return 0;
10. }
11. static int hello_release (struct inode *inode, struct file *filep)
12. {
13. atomic_inc(&v);
14. return 0;
15. }

spinlock_t spin; //定义自旋锁
spin_lock_init(lock); //初始化自旋锁
spin_lock(lock); //成功获得自旋锁立即返回，否则自旋在那里直到该自旋锁的保持者释放
spin_trylock(lock); //成功获得自旋锁立即返回真，否则返回假，而不是像上一个那样"在原地打转"
spin_unlock(lock);//释放自旋锁

1. static spinlock_t lock;
2. static int flag = 1;
3. static int hello_open (struct inode *inode, struct file *filep)
4. {
5. spin_lock(&lock);
6. if(flag !=1)
7. {
8. spin_unlock(&lock);
9. return -EBUSY;
10. }
11. flag = 0;
12. spin_unlock(&lock);
13. return 0;
14. }
15. static int hello_release (struct inode *inode, struct file *filep)
16. {
17. flag = 1;
18. return 0;
19. }

struct semaphore {
spinlock_t lock; //用来对count变量起保护作用。
unsigned int count; // 大于0，资源空闲；等于0，资源忙，但没有进程等待这个保护的资源；小于0，资源不可用，并至少有一个进程等待资源。
struct list_head wait_list; //存放等待队列链表的地址，当前等待资源的所有睡眠进程都会放在这个链表中。
};

static inline void sema_init(struct semaphore *sem, int val); //设置sem为val
#define init_MUTEX(sem) sema_init(sem, 1) //初始化一个用户互斥的信号量sem设置为1
#define init_MUTEX_LOCKED(sem) sema_init(sem, 0) //初始化一个用户互斥的信号量sem设置为0

DECLARE_MUTEX(name); //该宏定义信号量name并初始化1
DECLARE_MUTEX_LOCKED(name); //该宏定义信号量name并初始化0

void down(struct semaphore *sem)；

int down_interruptible(struct semaphore *sem)；

int down_killable(struct semaphore *sem)；

void up(struct semaphore *sem)；

1. //定义和初始化
2. static  struct semaphore sem;
3. sema_init(&sem,1);
4. static int hello_open (struct inode *inode, struct file *filep)
5. {
6. // p操作，获得信号量，保护临界区
7. if(down_interruptible(&sem))
8. {
9. //没有获得信号量
10. return -ERESTART;
11. }
12. return 0;
13. }
14. static int hello_release (struct inode *inode, struct file *filep)
15. {
16. //v操作，释放信号量
17. up(&sem);
18. return 0;
19. }

struct __wait_queue_head 
{
spinlock_t lock;                    /* 保护等待队列的原子锁 */
struct list_head task_list;         /* 等待队列 */
};

typedef struct __wait_queue_head wait_queue_head_t;

struct __wait_queue 
{
unsigned int flags;
void *private;                       /* 通常指向当前任务控制块 *//* 任务唤醒操作方法，该方法在内核中提供，通常为autoremove_wake_function */
wait_queue_func_t func;             
struct list_head task_list;              /* 挂入wait_queue_head的挂载点 */
};

/* 定义“等待队列头” */

wait_queue_head_t my_queue;

/* 初始化“等待队列头”*/
init_waitqueue_head(&my_queue);

DECLARE_WAITQUEUE(name,tsk);

/* add_wait_queue()函数,设置等待的进程为非互斥进程，并将其添加进等待队列头(q)的队头中*/
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
/* 该函数也和add_wait_queue()函数功能基本一样，只不过它是将等待的进程(wait)设置为互斥进程。*/
void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait);

1. /**
2. * wait_event - sleep until a condition gets true
3. * @wq: the waitqueue to wait on
4. * @condition: a C expression for the event to wait for
5. *
6. * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
7. * @condition evaluates to true. The @condition is checked each time
8. * the waitqueue @wq is woken up.
9. *
10. * wake_up() has to be called after changing any variable that could
11. * change the result of the wait condition.
12. */
13. #define wait_event(wq, condition)                   \
14. do {                                    \
15. if (condition)                          \
16. break;                          \
17. __wait_event(wq, condition);                    \
18. } while (0)

1. #define wake_up(x)          __wake_up(x, TASK_NORMAL, 1, NULL)
2. /**
3. * __wake_up - wake up threads blocked on a waitqueue.
4. * @q: the waitqueue
5. * @mode: which threads
6. * @nr_exclusive: how many wake-one or wake-many threads to wake up
7. * @key: is directly passed to the wakeup function
8. */
9. void __wake_up(wait_queue_head_t *q, unsigned int mode,
10. int nr_exclusive, void *key)
11. {
12. unsigned long flags;
13. spin_lock_irqsave(&q->lock, flags);
14. __wake_up_common(q, mode, nr_exclusive, 0, key);
15. spin_unlock_irqrestore(&q->lock, flags);
16. }
17. EXPORT_SYMBOL(__wake_up);

#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)

1. static ssize_t hello_read(struct file *filep, char __user *buf, size_t len, loff_t *pos)
2. {
3. /*
4. 实现应用进程read的时候，如果没有数据就阻塞
5. */
6. if(len>64)
7. {
8. len =64;
9. }
10. wait_event_interruptible(wq, have_data == 1);
11. if(copy_to_user(buf,temp,len))
12. {
13. return -EFAULT;
14. }
15. have_data = 0;
16. return len;
17. }
18. static ssize_t hello_write(struct file *filep, const char __user *buf, size_t len, loff_t *pos)
19. {
20. if(len > 64)
21. {
22. len = 64;
23. }
24. if(copy_from_user(temp,buf,len))
25. {
26. return -EFAULT;
27. }
28. printk("write %s\n",temp);
29. have_data = 1;
30. wake_up_interruptible(&wq);
31. return len;
32. }

int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptionfds, struct timeval *timeout);

struct timeval

{
    int tv_sec;   //秒
    int tv_usec;   //微秒
}

unsigned int(*poll)(struct file *filp, struct poll_table * wait);

 void poll_wait(struct file *filp, wait_queue_head_t *queue,poll_table *wait)  

1. static unsigned int XXX_poll(struct file *filp, poll_table *wait)
2. {
3. unsigned int mask = 0;
4. struct XXX_dev *dev = filp->private_data;     //获得设备结构指针
5. ...
6. poll_wait(filp, &dev->r_wait, wait);    //加读等待对列头
7. poll_wait(filp ,&dev->w_wait, wait);    //加写等待队列头
8. if(...)//可读
9. ｛
10. mask |= POLLIN | POLLRDNORM;    //标识数据可获得
11. ｝
12. if(...)//可写
13. ｛
14. mask |= POLLOUT | POLLWRNORM;    //标识数据可写入
15. ｝
16. ..
17. return mask;
18. }

poll_wait(filp,&wait_q,wait) // 此处将当前进程加入到等待队列中，但并不阻塞

/*mem设备描述结构体*/
struct mem_dev
{
char *data;
unsigned long size;
wait_queue_head_t inq;
};#endif /* _MEMDEV_H_ */

1. #include <linux/module.h>
2. #include <linux/types.h>
3. #include <linux/fs.h>
4. #include <linux/errno.h>
5. #include <linux/mm.h>
6. #include <linux/sched.h>
7. #include <linux/init.h>
8. #include <linux/cdev.h>
9. #include <asm/io.h>
10. #include <asm/system.h>
11. #include <asm/uaccess.h>
12. #include <linux/poll.h>
13. #include "memdev.h"
14. static mem_major = MEMDEV_MAJOR;
15. bool have_data = false; /*表明设备有足够数据可供读*/
16. module_param(mem_major, int, S_IRUGO);
17. struct mem_dev *mem_devp; /*设备结构体指针*/
18. struct cdev cdev;
19. /*文件打开函数*/
20. int mem_open(struct inode *inode, struct file *filp)
21. {
22. struct mem_dev *dev;
23. /*获取次设备号*/
24. int num = MINOR(inode->i_rdev);
25. if (num >= MEMDEV_NR_DEVS)
26. return -ENODEV;
27. dev = &mem_devp[num];
28. /*将设备描述结构指针赋值给文件私有数据指针*/
29. filp->private_data = dev;
30. return 0;
31. }
32. /*文件释放函数*/
33. int mem_release(struct inode *inode, struct file *filp)
34. {
35. return 0;
36. }
37. /*读函数*/
38. static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
39. {
40. unsigned long p =  *ppos;
41. unsigned int count = size;
42. int ret = 0;
43. struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
44. /*判断读位置是否有效*/
45. if (p >= MEMDEV_SIZE)
46. return 0;
47. if (count > MEMDEV_SIZE - p)
48. count = MEMDEV_SIZE - p;
49. while (!have_data) /* 没有数据可读，考虑为什么不用if，而用while */
50. {
51. if (filp->f_flags & O_NONBLOCK)
52. return -EAGAIN;
53. wait_event_interruptible(dev->inq,have_data);
54. }
55. /*读数据到用户空间*/
56. if (copy_to_user(buf, (void*)(dev->data + p), count))
57. {
58. ret =  - EFAULT;
59. }
60. else
61. {
62. *ppos += count;
63. ret = count;
64. printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
65. }
66. have_data = false; /* 表明不再有数据可读 */
67. /* 唤醒写进程 */
68. return ret;
69. }
70. /*写函数*/
71. static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
72. {
73. unsigned long p =  *ppos;
74. unsigned int count = size;
75. int ret = 0;
76. struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
77. /*分析和获取有效的写长度*/
78. if (p >= MEMDEV_SIZE)
79. return 0;
80. if (count > MEMDEV_SIZE - p)
81. count = MEMDEV_SIZE - p;
82. /*从用户空间写入数据*/
83. if (copy_from_user(dev->data + p, buf, count))
84. ret =  - EFAULT;
85. else
86. {
87. *ppos += count;
88. ret = count;
89. printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
90. }
91. have_data = true; /* 有新的数据可读 */
92. /* 唤醒读进程 */
93. wake_up(&(dev->inq));
94. return ret;
95. }
96. /* seek文件定位函数 */
97. static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
98. {
99. loff_t newpos;
100. switch(whence) {
101. case 0: /* SEEK_SET */
102. newpos = offset;
103. break;
104. case 1: /* SEEK_CUR */
105. newpos = filp->f_pos + offset;
106. break;
107. case 2: /* SEEK_END */
108. newpos = MEMDEV_SIZE -1 + offset;
109. break;
110. default: /* can't happen */
111. return -EINVAL;
112. }
113. if ((newpos<0) || (newpos>MEMDEV_SIZE))
114. return -EINVAL;
115. filp->f_pos = newpos;
116. return newpos;
117. }
118. unsigned int mem_poll(struct file *filp, poll_table *wait)
119. {
120. struct mem_dev  *dev = filp->private_data;
121. unsigned int mask = 0;
122. /*将等待队列添加到poll_table */
123. poll_wait(filp, &dev->inq,  wait);
124. if (have_data)         mask |= POLLIN | POLLRDNORM;  /* readable */
125. return mask;
126. }
127. /*文件操作结构体*/
128. static const struct file_operations mem_fops =
129. {
130. .owner = THIS_MODULE,
131. .llseek = mem_llseek,
132. .read = mem_read,
133. .write = mem_write,
134. .open = mem_open,
135. .release = mem_release,
136. .poll = mem_poll,
137. };
138. /*设备驱动模块加载函数*/
139. static int memdev_init(void)
140. {
141. int result;
142. int i;
143. dev_t devno = MKDEV(mem_major, 0);
144. /* 静态申请设备号*/
145. if (mem_major)
146. result = register_chrdev_region(devno, 2, "memdev");
147. else  /* 动态分配设备号 */
148. {
149. result = alloc_chrdev_region(&devno, 0, 2, "memdev");
150. mem_major = MAJOR(devno);
151. }
152. if (result < 0)
153. return result;
154. /*初始化cdev结构*/
155. cdev_init(&cdev, &mem_fops);
156. cdev.owner = THIS_MODULE;
157. cdev.ops = &mem_fops;
158. /* 注册字符设备 */
159. cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
160. /* 为设备描述结构分配内存*/
161. mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
162. if (!mem_devp)    /*申请失败*/
163. {
164. result =  - ENOMEM;
165. goto fail_malloc;
166. }
167. memset(mem_devp, 0, sizeof(struct mem_dev));
168. /*为设备分配内存*/
169. for (i=0; i < MEMDEV_NR_DEVS; i++)
170. {
171. mem_devp[i].size = MEMDEV_SIZE;
172. mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
173. memset(mem_devp[i].data, 0, MEMDEV_SIZE);
174. /*初始化等待队列*/
175. init_waitqueue_head(&(mem_devp[i].inq));
176. //init_waitqueue_head(&(mem_devp[i].outq));
177. }
178. return 0;
179. fail_malloc:
180. unregister_chrdev_region(devno, 1);
181. return result;
182. }
183. /*模块卸载函数*/
184. static void memdev_exit(void)
185. {
186. cdev_del(&cdev);   /*注销设备*/
187. kfree(mem_devp);     /*释放设备结构体内存*/
188. unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
189. }
190. MODULE_AUTHOR("David Xie");
191. MODULE_LICENSE("GPL");
192. module_init(memdev_init);
193. module_exit(memdev_exit);

1. #include <stdio.h>
2. int main()
3. {
4. FILE *fp = NULL;
5. char Buf[128];
6. /*打开设备文件*/
7. fp = fopen("/dev/memdev0","r+");
8. if (fp == NULL)
9. {
10. printf("Open Dev memdev Error!\n");
11. return -1;
12. }
13. /*写入设备*/
14. strcpy(Buf,"memdev is char dev!");
15. printf("Write BUF: %s\n",Buf);
16. fwrite(Buf, sizeof(Buf), 1, fp);
17. sleep(5);
18. fclose(fp);
19. return 0;
20. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/ioctl.h>
5. #include <sys/types.h>
6. #include <sys/stat.h>
7. #include <fcntl.h>
8. #include <sys/select.h>
9. #include <sys/time.h>
10. #include <errno.h>
11. int main()
12. {
13. int fd;
14. fd_set rds;
15. int ret;
16. char Buf[128];
17. /*初始化Buf*/
18. strcpy(Buf,"memdev is char dev!");
19. printf("BUF: %s\n",Buf);
20. /*打开设备文件*/
21. fd = open("/dev/memdev0",O_RDWR);
22. FD_ZERO(&rds);
23. FD_SET(fd, &rds);
24. /*清除Buf*/
25. strcpy(Buf,"Buf is NULL!");
26. printf("Read BUF1: %s\n",Buf);
27. ret = select(fd + 1, &rds, NULL, NULL, NULL);
28. if (ret < 0)
29. {
30. printf("select error!\n");
31. exit(1);
32. }
33. if (FD_ISSET(fd, &rds))
34. read(fd, Buf, sizeof(Buf));
35. /*检测结果*/
36. printf("Read BUF2: %s\n",Buf);
37. close(fd);
38. return 0;
39. }

void (*signal(int signum,void (*handler))(int)))(int)

typedef void(*sighandler_t)(int);
 
sighandler_t signal(int signum,sighandler_t handler);

1. //启动信号机制
2. void sigterm_handler(int sigo)
3. {
4. char data[MAX_LEN];
5. int len;
6. len = read(STDIN_FILENO,&data,MAX_LEN);
7. data[len] = 0;
8. printf("Input available:%s\n",data);
9. exit(0);
10. }
11. int main(void)
12. {
13. int oflags;
14. //启动信号驱动机制
15. signal(SIGIO,sigterm_handler);
16. fcntl(STDIN_FILENO,F_SETOWN,getpid());
17. oflags = fcntl(STDIN_FILENO,F_GETFL);
18. fctcl(STDIN_FILENO,F_SETFL,oflags | FASYNC);
19. //建立一个死循环，防止程序结束
20. whlie(1);
21. return 0;
22. }

int fasync_helper(int fd,struct file *filp,int mode,struct fasync_struct **fa);

void kill_fasync(struct fasync_struct **fa,int sig,int band);

1. struct xxx_dev{
2. struct cdev cdev;
3. ...
4. struct fasync_struct *async_queue;
5. //异步结构体指针
6. };

1. static int xxx_fasync(int fd,struct file *filp, int mode)
2. {
3. struct xxx_dev *dev = filp->private_data;
4. return fasync_helper(fd, filp, mode, &dev->async_queue);
5. }

1. static ssize_t xxx_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
2. {
3. struct xxx_dev *dev = filp->private_data;
4. ...
5. if(dev->async_queue)
6. kill_fasync(&dev->async_queue,GIGIO,POLL_IN);
7. ...
8. }

1. int xxx_release(struct inode *inode,struct file *filp)
2. {
3. xxx_fasync(-1,filp,0);
4. ...
5. return 0;
6. }

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/cdev.h>
4. #include <linux/device.h>
5. #include <asm/uaccess.h>
6. #include <linux/fcntl.h>
7. static int major = 250;
8. static int minor=0;
9. static dev_t devno;
10. static struct class *cls;
11. static struct device *test_device;
12. static char temp[64]={0};
13. static struct fasync_struct *fasync;
14. static int hello_open (struct inode *inode, struct file *filep)
15. {
16. return 0;
17. }
18. static int hello_release(struct inode *inode, struct file *filep)
19. {
20. return 0;
21. }
22. static ssize_t hello_read(struct file *filep, char __user *buf, size_t len, loff_t *pos)
23. {
24. if(len>64)
25. {
26. len =64;
27. }
28. if(copy_to_user(buf,temp,len))
29. {
30. return -EFAULT;
31. }
32. return len;
33. }
34. static ssize_t hello_write(struct file *filep, const char __user *buf, size_t len, loff_t *pos)
35. {
36. if(len>64)
37. {
38. len = 64;
39. }
40. if(copy_from_user(temp,buf,len))
41. {
42. return -EFAULT;
43. }
44. printk("write %s\n",temp);
45. kill_fasync(&fasync, SIGIO, POLL_IN);
46. return len;
47. }
48. static int hello_fasync (int fd, struct file * file, int on)
49. {
50. return fasync_helper(fd, file, on, &fasync);
51. }
52. static struct file_operations hello_ops=
53. {
54. .open = hello_open,
55. .release = hello_release,
56. .read =hello_read,
57. .write=hello_write,
58. };
59. static int hello_init(void)
60. {
61. int ret;
62. devno = MKDEV(major,minor);
63. ret = register_chrdev(major,"hello",&hello_ops);
64. cls = class_create(THIS_MODULE, "myclass");
65. if(IS_ERR(cls))
66. {
67. unregister_chrdev(major,"hello");
68. return -EBUSY;
69. }
70. test_device = device_create(cls,NULL,devno,NULL,"hello");//mknod /dev/hello
71. if(IS_ERR(test_device))
72. {
73. class_destroy(cls);
74. unregister_chrdev(major,"hello");
75. return -EBUSY;
76. }
77. return 0;
78. }
79. static void hello_exit(void)
80. {
81. device_destroy(cls,devno);
82. class_destroy(cls);
83. unregister_chrdev(major,"hello");
84. printk("hello_exit \n");
85. }
86. MODULE_LICENSE("GPL");
87. module_init(hello_init);
88. module_exit(hello_exit);

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. #include <signal.h>
6. static int fd,len;
7. static char buf[64]={0};
8. void func(int signo)
9. {
10. printf("signo %d \n",signo);
11. read(fd,buf,64);
12. printf("buf=%s \n",buf);
13. }
14. main()
15. {
16. int flage,i=0;
17. fd = open("/dev/hello",O_RDWR);
18. if(fd<0)
19. {
20. perror("open fail \n");
21. return ;
22. }
23. fcntl(fd,F_SETOWN,getpid());
24. flage = fcntl(fd,F_GETFL);
25. fcntl(fd,F_SETFL,flage|FASYNC);
26. signal(SIGIO,func);
27. while(1)
28. {
29. sleep(1);
30. printf("%d\n",i++);
31. }
32. close(fd);
33. }

1. 一、概述
2. （1）udev是构建在linux的sysfs之上的是一个一个用户程序，它能够根据系统中的硬件设备的状态动态更新设备文件，包括设备文件的创建，删除等，设备文件通常放在/dev目录下。使用udev后，在/dev目录下就只包含系统中真正存在的设备。udev的的工作过程大致是这样的：
3. 1. 当内核检测到在系统中出现了新设备后，内核会在sysfs文件系统中为该新设备生成一项新的记录，新记录是以文件或目录的方式来表示，每个文件都包含有特定的信息。
4. 2. udev在系统中是以守护进程的方式运行，它通过某种途径检测到新设备的出现，通过查找设备对应的sysfs中的记录得到设备的信息。
5. 3. udev会根据/etc/udev/udev.conf文件中的udev_rules指定的目录，逐个检查该目录下的文件，这个目录下的文件都是针对某类或某个设备应该施行什么措施的规则文件。udev读取文件是按照文件名的ASCII字母顺序来读取的，如果udev一旦找到了与新加入的设备匹配的规则，udev就会根据规则定义的措施对新设备进行配置。同时不再读后续的规则文件。
6. （2）udev的工作可以简单的概括为：监控系统中设备状态的变化，当有设备的状态发生变化时，根据用户的配置对设备文件执行相应的操作。
7. （3）udev的配置规则
8. udev的全局的配置文件是/etc/udev/udev.conf，该文件一般缺省有这样几项：
9. udev_root="/dev" #udev产生的设备文件的根目录是/dev
10. udev_rules="/etc/udev/rules.d" #用于指导udev工作的规则所在目录。
11. udev_log="err" #当出现错误时，用syslog记录错误信息。
12. 其中最关键的就是规则文件，即/etc/udev/rules.d/目录下的文件，udev是按照文件名的ASCII字母顺序来读取的，一旦找到与设备匹配的规则，就运用该规则，并不再读后续的规则文件了。下面简单看下udev定义了那些规则，以及它是如何进行配置的，怎样去编写这种规则文件。
13. udev的规则文件以行为单位，以"#"开头的行代表注释行。其余的每一行代表一个规则。每个规则分成一个或多个“匹配”和“赋值”部分。“匹配”部分用“匹配“专用的关键字来表示，相应的“赋值”部分用“赋值”专用的关键字来表示。“匹配”关键字包括：ACTION，KERNEL，BUS，

    SYSFS等等，“赋值”关键字包括：NAME，SYMLINK，OWNER等等。具体详细的描述可以阅读udev的man文档。下面通过一个具体的例子来说明，看如下的规则:

14. # PCI device 0x8086:0x1096 (e1000e)
15. SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:19:21:ff:cc:7c", ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"
16. 这个规则中的“匹配”部分有四项，分别是SUBSYSTEM，ACTION，DRIVERS，KERNEL。而"赋值"部分有一项，是NAME。这个规则就是说，当系统中出现的新硬件属于net子系统范畴，系统对该硬件采取的动作是加入这个硬件，且这个硬件在DRIVERS信息中的address="00:19:21:ff:cc:7c"，dev_id="0x0"，内核的命名为eth*时，udev会在建立新的网络设备，并命名为eth0。udev规则文件的编写可以参考man手册。
17. 二、udev自动生成设备节点
18. 生成设备文件节点的方法有三个：1.手动mknod 2.利用devfs 3.利用udev
19. udev是硬件平台无关的，属于user space的进程，它脱离驱动层的关联而建立在操作系统之上，基于这种设计实现，我们可以随时修改及删除/dev下的设备文件名称和指向，随心所欲地按照我们的愿望安排和管理设备文件系统，而完成如此灵活的功能只需要简单地修改udev的配置文件即可，无需重新启动操作系统。udev已经使得我们对设备的管理如探囊取物般轻松自如。
20. 内核中定义了struct class 结构体，顾名思义，一个struct class 结构体类型变量对应一个类，内核同时提供了class_create() 函数，可以用它来创建一个类，这个类存放于sysfs 下面，一旦创建好了这个类，再调用device_create() 函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create() 函数，去/sysfs 下寻找对应的类从而创建设备节点。
21. struct class {
22. const char * name;
23. struct module * owner;
24. nbsp; struct kset subsys;
25. struct list_head devices;
26. struct list_head interfaces;
27. struct kset class_dirs;
28. struct semaphore sem; /* locks children, devices, interfaces */
29. struct class_attribute * class_attrs;
30. struct device_attribute * dev_attrs;
31. int ( * dev_uevent) ( struct device * dev, struct kobj_uevent_env * env) ;
32. void ( * class_release) ( struct class * class ) ;
33. void ( * dev_release) ( struct device * dev) ;
34. int ( * suspend) ( struct device * dev, pm_message_t state) ;
35. int ( * resume) ( struct device * dev) ;
36. } ;
37. //第一个参数指定类的所有者是哪个模块，第二个参数指定类名。
38. struct class * class_create( struct module * owner, const char * name)
39. {
40. struct class * cls;
41. int retval;
42. cls = kzalloc( sizeof ( * cls) , GFP_KERNEL) ;//分配一个类结构
43. if ( ! cls) {
44. retval = - ENOMEM;
45. goto error ;
46. }
47. cls- > name = name;
48. cls- > owner = owner;
49. cls- > class_release = class_create_release;
50. retval = class_register( cls) ;//注册这个类，即在/sys/class目录下添加目录
51. if ( retval)
52. goto error ;
53. return cls;
54. error :
55. kfree( cls) ;
56. return ERR_PTR( retval) ;
57. }
58. //第一个参数指定所要创建的设备所从属的类，第二个参数是这个设备的父设备，如果没有就指定为NULL，第三个参数是设备号，第四个参数是设备名称，第五个参数是从设备号。
59. struct device * device_create( struct class * class , struct device * parent,dev_t devt, const char * fmt, . . . )
60. {
61. va_list vargs;
62. struct device * dev;
63. va_start ( vargs, fmt);
64. //device_create_vargs函数流程：
65. //device_create-->device_create_vargs-->device_register-->device_add-->kobject_uevent(&dev->kobj, KOBJ_ADD);-->
66. //kobject_uevent_env(kobj, action, NULL);-->call_usermodehelper(argv[0], argv,env->envp, UMH_WAIT_EXEC);}
67. dev = device_create_vargs( class , parent, devt, NULL , fmt, vargs) ;
68. va_end ( vargs) ;
69. return dev;
70. }
71. 三、事件通知
72. 在device_add()例程，其用于将一个device注册到device model，其中调用了kobject_uevent(&dev->kobj, KOBJ_ADD)例程向用户空间发出KOBJ_ADD 事件并输出环境变量，以表明一个device被添加了。在《Linux设备模型浅析之设备篇》中介绍过rtc_device_register()例程 ，其最终调用device_add()例程添加了一个rtc0的device，我们就以它为例子来完成uevent的分析。让我们看看kobject_uevent()这个例程的代码，如下：
73. int kobject_uevent(struct kobject *kobj, enum kobject_action action)
74. {
75. return kobject_uevent_env(kobj, action, NULL);
76. }
77. 它又调用了kobject_uevent_env()例程，部分代码如下：
78. int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,char *envp_ext[])
79. {
80. struct kobj_uevent_env *env;
81. const char *action_string = kobject_actions[action]; // 本例是“add”命令
82. const char *devpath = NULL;
83. const char *subsystem;
84. struct kobject *top_kobj;
85. struct kset *kset;
86. struct kset_uevent_ops *uevent_ops;
87. u64 seq;
88. int i = 0;
89. int retval = 0;
90. pr_debug("kobject: '%s' (%p): %s\n",kobject_name(kobj), kobj, __func__);
91. top_kobj = kobj;
92. /* 找到其所属的 kset容器，如果没找到就从其父kobj找，一直持续下去，直到父kobj不存在 */
93. while (!top_kobj->kset && top_kobj->parent)
94. top_kobj = top_kobj->parent;
95. if (!top_kobj->kset) {
96. pr_debug("kobject: '%s' (%p): %s: attempted to send uevent ""without kset!\n", kobject_name(kobj), kobj,__func__);
97. return -EINVAL;
98. }
99. /* 在本例中是devices_kset容器 */
100. kset = top_kobj->kset;
101. uevent_ops = kset->uevent_ops; // 本例中uevent_ops = ＆device_uevent_ops
102. /* 回调 uevent_ops->filter ()例程，本例中是dev_uevent_filter()例程，主要是检查是否uevent suppress*/
103. /* skip the event, if the filter returns zero. */
104. if (uevent_ops && uevent_ops->filter)
105. if (!uevent_ops->filter(kset, kobj)) { // 如果不成功，即uevent suppress，则直接返回
106. pr_debug("kobject: '%s' (%p): %s: filter function ""caused the event to drop!\n",kobject_name(kobj), kobj, __func__);
107. return 0;
108. }
109. /* 回调 uevent_ops-> name ()，本例中是dev_uevent_name()例程，获取bus或class的名字，本例中rtc0不存在bus，所以是class的名字“rtc”，后面分析 */
110. if (uevent_ops && uevent_ops->name)
111. subsystem = uevent_ops->name(kset, kobj);
112. else
113. subsystem = kobject_name(&kset->kobj);
114. if (!subsystem) {
115. pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the ""event to drop!\n", kobject_name(kobj), kobj,__func__);
116. return 0;
117. }
118. // 获得用于存放环境变量的buffer
119. env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
120. if (!env)
121. return -ENOMEM;
122. /* 获取该kobj在sysfs的路径，通过遍历其父kobj来获得，本例是/sys/devices/platform/s3c2410-rtc/rtc/rtc0 */
123. devpath = kobject_get_path(kobj, GFP_KERNEL);
124. if (!devpath) {
125. retval = -ENOENT;
126. goto exit;
127. }
128. // 添加 ACTION环境变量，本例是“add”命令
129. retval = add_uevent_var(env, "ACTION=%s", action_string);
130. if (retval)
131. goto exit;
132. // 添加 DEVPATH环境变量，本例是/sys/devices/platform/s3c2410-rtc/rtc/rtc0
133. retval = add_uevent_var(env, "DEVPATH=%s", devpath);
134. if (retval)
135. goto exit;
136. // 添加 SUBSYSTEM 环境变量，本例中是“rtc”
137. retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
138. if (retval)
139. goto exit;
140. /* keys passed in from the caller */
141. if (envp_ext) { // 为NULL，不执行
142. for (i = 0; envp_ext[i]; i++) {
143. retval = add_uevent_var(env, "%s", envp_ext[i]);
144. if (retval)
145. goto exit;
146. }
147. }
148. // 回调 uevent_ops->uevent()，本例中是dev_uevent()例程，输出一些环境变量，后面分析
149. if (uevent_ops && uevent_ops->uevent) {
150. retval = uevent_ops->uevent(kset, kobj, env);
151. if (retval) {
152. pr_debug("kobject: '%s' (%p): %s: uevent() returned ""%d\n", kobject_name(kobj), kobj,__func__, retval);
153. goto exit;
154. }
155. }
156. if (action == KOBJ_ADD)
157. kobj->state_add_uevent_sent = 1;
158. else if (action == KOBJ_REMOVE)
159. kobj->state_remove_uevent_sent = 1;
160. /* 增加event序列号的值，并输出到环境变量的buffer。该系列号可以从/sys/kernel/uevent_seqnum属性文件读取，至于uevent_seqnum属性文件及/sys/kernel/目录是怎样产生的，后面会分析 */
161. spin_lock(&sequence_lock);
162. seq = ++uevent_seqnum;
163. spin_unlock(&sequence_lock);
164. retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)seq);
165. if (retval)
166. goto exit;
167. /* 如果配置了网络，那么就会通过netlink socket 向用户空间发送环境标量，而用户空间则通过netlink socket 接收，然后采取一些列的动作。这种机制目前用在udev中，也就是pc机系统中，后面会分析*/
168. #if defined(CONFIG_NET)
169. /* 如果配置了net，则会在kobject_uevent_init()例程中将全局比昂俩uevent_sock 初试化为NETLINK_KOBJECT_UEVENT 类型的socket。*/
170. if (uevent_sock) {
171. struct sk_buff *skb;
172. size_t len;
173. /* allocate message with the maximum possible size */
174. len = strlen(action_string) + strlen(devpath) + 2;
175. skb = alloc_skb(len + env->buflen, GFP_KERNEL);
176. if (skb) {
177. char *scratch;
178. /* add header */
179. scratch = skb_put(skb, len);
180. sprintf(scratch, "%s@%s", action_string, devpath);
181. /* copy keys to our continuous event payload buffer */
182. for (i = 0; i < env->envp_idx; i++) {
183. len = strlen(env->envp[i]) + 1;
184. scratch = skb_put(skb, len);
185. strcpy(scratch, env->envp[i]);
186. }
187. NETLINK_CB(skb).dst_group = 1;
188. retval = netlink_broadcast(uevent_sock, skb, 0, 1,GFP_KERNEL); // 广播
189. } else
190. retval = -ENOMEM;
191. }
192. #endif
193. /* 对于嵌入式系统来说，busybox采用的是mdev，在系统启动脚本rcS 中会使用echo /sbin/mdev > /proc/sys/kernel/hotplug命令，而这个 hotplug文件通过一定的方法映射到了uevent_helper[]数组，所以uevent_helper[] = “/sbin/mdev” 。所以对于采用busybox的嵌入式系统来说会执行里面的代码，而pc机不会。也就是说内核会call用户空间的/sbin/mdev这个应用程序来做动作，后面分析 */
194. if (uevent_helper[0]) {
195. char *argv [3];
196. // 加入到环境变量buffer
197. argv [0] = uevent_helper;
198. argv [1] = (char *)subsystem;
199. argv [2] = NULL;
200. //添加HOME目录环境变量
201. retval = add_uevent_var(env, "HOME=/");
202. if (retval)
203. goto exit;
204. //添加PATH环境变量
205. retval = add_uevent_var(env,"PATH=/sbin:/bin:/usr/sbin:/usr/bin");
206. if (retval)
207. goto exit;
208. // 呼叫应用程序来处理， UMH_WAIT_EXEC表明等待应用程序处理完，dev会根据先前设置的环境变量进行处理
209. retval = call_usermodehelper(argv[0], argv,env->envp, UMH_WAIT_EXEC);
210. }
211. exit:
212. kfree(devpath);
213. kfree(env);
214. return retval;
215. }
216. kobject_uevent_env函数最后调用了mdev，mdev的入口函数在busybox的mdev_main
217. mdev_main
218. {
219. if (argv[1] && !strcmp(argv[1], "-s"))//先判断参数1是否为-s，如果为-s则表明mdev为开机执行的情况（mdev -s位于/etc/init.d/rcS中）
220. else
221. getenv //提取各个环境变量
222. make_device //根据action创建设备
223. /*对于设备，当我们创建其节点时，我们可以通过配置文件进行配置，该配置文件位于/etc/mdev.conf
224. *设备名称正则表达式用户id 组id 节点属性 创建的设备节点路径 shell命令
225. *配置方式为<device regex> <uid>:<gid> <octal permissions> [=path] [@|$|*<command>]
226. */
227. parser = config_open2("/etc/mdev.conf", fopen_for_read); //打开/etc/mdev.conf文件
228. while (config_read(parser, tokens, 4, 3, "# \t", PARSE_NORMAL)) //分析mdev.conf文件内容，并执行相关操作command
229. {...}
230. mknod(device_name, mode | type, makedev(major, minor)) //调用mknod进行节点创建
231. }
232. 四、示例
233. Udev获取和设置设备节点的信息是通过建立一个本地套接口来实现：socket(AF_LOCAL, SOCK_SEQPACKET|SOCK_NONBLOCK|SOCK_CLOEXEC, 0)。其中SOCK_SEQPACKET提供连续可信赖的数据包连接。然后通过sendmsg和recvmsg去发送和获取相应的信息。当获取到设备的相应信息后再根据用户设置的规则调用mknod函数去创建相应的设备节点。
234. Udev创建的所有设备节点的设备号都可以在/sys/dev/{block,char}目录中找到。如果驱动程序要让udev自动创建设备节点，那么你就必须保存在这个目录下有这个设备号。下面例举一个简单的例子：
235. #include <linux/module.h>
236. #include <linux/fs.h>
237. #include <linux/init.h>
238. #include <linux/cdev.h>
239. #include <linux/device.h>
240. static int mem_major = 240;
241. static struct class *test_class;
242. struct cdev cdev;
243. /*文件操作结构体*/
244. static const struct file_operations mem_fops =
245. {
246. .owner = THIS_MODULE,
247. };
248. /*设备驱动模块加载函数*/
249. static int memdev_init(void)
250. {
251. dev_t devno = MKDEV(mem_major, 0);
252. int result = register_chrdev_region(devno, 2, "memdev");
253. if (result < 0)
254. return result;
255. cdev_add(&cdev, MKDEV(mem_major, 0), 1);
256. test_class = class_create(THIS_MODULE, "juvi_test_class");//创建一个类，用来表示该设备文件是哪一种类型，创建成功会在/sys/class中出现。
257. device_create(test_class, NULL, devno, NULL, "test_udev");//创建设备文件，它会在/sys/dev/char中出现相应的设备接点号。然后dev目录下面会自动创建设备文件。
258. return result;
259. }
260. /*模块卸载函数*/
261. static void memdev_exit(void)
262. {
263. cdev_del(&cdev); /*注销设备*/
264. unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
265. class_destroy(test_class);//删除这个类型的设备。
266. }
267. MODULE_LICENSE("GPL");
268. module_init(memdev_init);
269. module_exit(memdev_exit);
270. 五、分析mdev
271. a、执行mdev -s命令时，mdev扫描/sys/block(块设备保存在/sys/block目录下,内核2.6.25版本以后，块设备也保存在/sys/class/block目录下。mdev扫描/sys/block是为了实现向后兼容)和/sys/class两个目录下的dev属性文件，从该dev属性文件中获取到设备编号(dev属性文件以"major:minor\n"形式保存设备编号)，并以包含该dev属性文件的目录名称作为设备名device_name(即包含dev属性文件的目录称为device_name，而/sys/class和device_name之间的那部分目录称为subsystem。也就是每个dev属性文件所在的路径都可表示为/sys/class/subsystem/device_name/dev)，在/dev目录下创建相应的设备文件。例如，cat /sys/class/tty/tty0/dev会得到4:0，subsystem为tty,device_name为tty0。
272. b、当mdev因uevnet事件(以前叫hotplug事件)被调用时，mdev通过由uevent事件传递给它的环境变量获取到：引起该uevent事件的设备action及该设备所在的路径device

     path。然后判断引起该uevent事件的action是什么。若该action是add，即有新设备加入到系统中，不管该设备是虚拟设备还是实际物理设备，mdev都会通过device
     path路径下的dev属性文件获取到设备编号，然后以device path路径最后一个目录(即包含该dev属性文件的目录)作为设备名，在/dev目录下创建相应的设备文件。若该action是remote，即设备已从系统中移除，则删除/dev目录下以device path路径最后一个目录名称作为文件名的设备文件。如果该action既不是add也不是remove，mdev则什么都不做。

273. 由上面可知，如果我们想在设备加入到系统中或从系统中移除时，由mdev自动地创建和删除设备文件，那么就必须做到以下三点：1、在/sys/class的某一subsystem目录下，2、创建一个以设备名device_name作为名称的目录，3、并且在该device_name目录下还必须包含一个dev属性文件，该dev属性文件以"major:minor\n"形式输出设备编号。
274. int mdev_main(int argc UNUSED_PARAM, char **argv)
275. {
276. //#define RESERVE_CONFIG_BUFFER(buffer,len) char buffer[len]
277. //声明一个数组
278. RESERVE_CONFIG_BUFFER(temp, PATH_MAX + SCRATCH_SIZE);
279. /*
280. struct globals {
281. int root_major, root_minor;
282. char *subsystem;
283. #if ENABLE_FEATURE_MDEV_CONF
284. const char *filename;
285. parser_t *parser;
286. struct rule **rule_vec;
287. unsigned rule_idx;
288. #endif
289. struct rule cur_rule;
290. } FIX_ALIASING;
291. #define G (*(struct globals*)&bb_common_bufsiz1)
292. enum { COMMON_BUFSIZE = (BUFSIZ >= 256*sizeof(void*) ? BUFSIZ+1 : 256*sizeof(void*)) };
293. extern char bb_common_bufsiz1[COMMON_BUFSIZE];
294. #define INIT_G() do { \
295. IF_NOT_FEATURE_MDEV_CONF(G.cur_rule.maj = -1;) \
296. IF_NOT_FEATURE_MDEV_CONF(G.cur_rule.mode = 0660;) \
297. } while (0)
298. */
299. //初始化结构体
300. INIT_G();
301. #if ENABLE_FEATURE_MDEV_CONF
302. G.filename = "/etc/mdev.conf";
303. #endif
304. /* We can be called as hotplug helper */
305. //阅读这个函数的源代码后，发现这里其实就是判断了/dev/null是否存在。如果打不开，那么就进入die状态。
306. bb_sanitize_stdio();
307. /* Force the configuration file settings exactly */
308. umask(0);//配置屏蔽位
309. xchdir("/dev");//切换到/dev目录
310. if (argv[1] && strcmp(argv[1], "-s") == 0) {//如果执行的是mdev -s，这是在shell里调用的。在系统启动时调用。创建所有设备驱动的节点。
311. struct stat st;
312. #if ENABLE_FEATURE_MDEV_CONF
313. /* Same as xrealloc_vector(NULL, 4, 0): */
314. G.rule_vec = xzalloc((1 << 4) * sizeof(*G.rule_vec));//给rule结构体分配空间
315. #endif
316. xstat("/", &st);//返回根目录文件状态信息
317. G.root_major = major(st.st_dev);//保存文件的设备号
318. G.root_minor = minor(st.st_dev);
319. if (access("/sys/class/block", F_OK) != 0) {//判断/sys/class/block这个文件或者目录是否存在。存在返回0，否则返回-1
320. //这个函数是递归函数，它会把/sys/block目录下的所有文件文件夹都去查看一遍，如果发现dev文件，那么将按照/etc/mdev.conf文件进行相应的配置。如果没有配置文件，那么直接创建设备节点。
321. recursive_action("/sys/block",ACTION_RECURSE | ACTION_FOLLOWLINKS | ACTION_QUIET,fileAction, dirAction, temp, 0);
322. }
323. //这个函数是递归函数，它会把/sys/class目录下的所有文件文件夹都去查看一遍，如果发现dev文件，那么将按照/etc/mdev.conf文件进行相应的配置。如果没有配置文件，那么直接创建设备节点。
324. recursive_action("/sys/class",ACTION_RECURSE | ACTION_FOLLOWLINKS,fileAction, dirAction, temp, 0);
325. } else {//通过hotplug通知mdev创建设备节点
326. char *fw;
327. char *seq;
328. char *action;
329. char *env_path;
330. static const char keywords[] ALIGN1 = "remove\0add\0";
331. enum { OP_remove = 0, OP_add };
332. smalluint op;
333. /* Hotplug:
334. * env ACTION=... DEVPATH=... SUBSYSTEM=... [SEQNUM=...] mdev
335. * ACTION can be "add" or "remove"
336. * DEVPATH is like "/block/sda" or "/class/input/mice"
337. 经过驱动层分析，所得的环境变量为，这里是以spidev，0.0设备为例：
338. ACTION=add: kobject_actions[KOBJ_ADD]
339. DEVPATH=/class/spidev/spidev0.0/: kobject_get_path(kobj, GFP_KERNEL) /sys不存在，这里只统计到/sys目录下
340. SUBSYSTEM=spidev: dev->bus->name，dev->class->name，如果dev->bus不存在的情况下，那么才使用dev->class->name
341. MAJOR=MAJOR(dev->devt)
342. MINOR=MINOR(dev->devt)
343. PHYSDEVPATH=/devices/platform/atmel_spi.0/spi0.0/: kobject_get_path(&dev->parent->kobj, GFP_KERNEL) /sys不存在，这里只统计到/sys目录下
344. PHYSDEVBUS=/bus/spi/: dev->parent->bus->name /sys不存在，这里只统计到/sys目录下
345. PHYSDEVDRIVER=spidev: dev->parent->driver->name
346. SEQNUM=++uevent_seqnum
347. HOME=/
348. PATH=/sbin:/bin:/usr/sbin:/usr/bin
349. */
350. //获得环境变量
351. action = getenv("ACTION");
352. env_path = getenv("DEVPATH");
353. G.subsystem = getenv("SUBSYSTEM");
354. if (!action || !env_path)
355. bb_show_usage();
356. fw = getenv("FIRMWARE");
357. op = index_in_strings(keywords, action);//比较keywords数组中和action，若是remove则返回0，若是add则返回1
358. seq = getenv("SEQNUM");
359. /*
360. 内核不序列化热插拔事件，而是为每一个成功的热插拔调用增加了 SEQNUM
     这个环境变量。通常情况下，mdev不在乎这个。这样也许可以重新对热插拔事件进行重调用，典型的症状就是有时某些设备节点不能像期待的那样被创建出来。不管怎么说，如果
     /dev/mdev.seq 文件存在，mdev将比较它和SEQNUM的内容，它将重试直到有两个第二，等待他们匹配。如果他们精确的匹配（甚至连"\n"都不被允许），或者两个第二出现，mdev依旧运行，然后它用SEQNUM+1重写/dev/mdev.seq。
361. */
362. if (seq) {
363. int timeout = 2000 / 32; /* 2000 msec */
364. do {
365. int seqlen;
366. char seqbuf[sizeof(int)*3 + 2];
367. //从mdev.seq文件中读出seq
368. seqlen = open_read_close("mdev.seq", seqbuf, sizeof(seqbuf) - 1);
369. if (seqlen < 0) {
370. seq = NULL;
371. break;
372. }
373. seqbuf[seqlen] = '\0';
374. if (seqbuf[0] == '\n' /* seed file? */|| strcmp(seq, seqbuf) == 0) { /* correct idx? */
375. break;
376. }
377. usleep(32*1000);
378. } while (--timeout);
379. }
380. //创建的设备路径名赋值给temp，例如/sys/class/spidev/spidev0.0/
381. snprintf(temp, PATH_MAX, "/sys%s", env_path);
382. if (op == OP_remove) {//删除节点
383. if (!fw)
384. make_device(temp, /*delete:*/ 1);
385. }
386. else if (op == OP_add) {//添加节点
387. make_device(temp, /*delete:*/ 0);
388. if (ENABLE_FEATURE_MDEV_LOAD_FIRMWARE) {
389. if (fw)
390. load_firmware(fw, temp);
391. }
392. }
393. if (seq) {//重写mdev.seq文件
394. xopen_xwrite_close("mdev.seq", utoa(xatou(seq) + 1));
395. }
396. }
397. if (ENABLE_FEATURE_CLEAN_UP)
398. RELEASE_CONFIG_BUFFER(temp);
399. return EXIT_SUCCESS;
400. }
401. //recursive_action("/sys/block",ACTION_RECURSE | ACTION_FOLLOWLINKS | ACTION_QUIET,fileAction, dirAction, temp, 0);
402. int FAST_FUNC recursive_action(const char *fileName,unsigned flags,int FAST_FUNC (*fileAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),
403. int FAST_FUNC (*dirAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),void* userData,unsigned depth)
404. {
405. struct stat statbuf;
406. unsigned follow;
407. int status;
408. DIR *dir;
409. struct dirent *next;
410. if (!fileAction)
411. fileAction = true_action;
412. if (!dirAction)
413. dirAction = true_action;
414. follow = ACTION_FOLLOWLINKS;
415. if (depth == 0)//第一次调用时传入depth参数为0
416. follow = ACTION_FOLLOWLINKS | ACTION_FOLLOWLINKS_L0;
417. follow &= flags;//也设置了ACTION_FOLLOWLINKS标志
418. //stat和lstat的区别：当文件是一个符号链接时，lstat返回的是该符号链接本身的信息；而stat返回的是该链接指向的文件的信息。
419. status = (follow ? stat : lstat)(fileName, &statbuf);//这里用stat读取目录或文件属性
420. if (status < 0) {
421. if ((flags & ACTION_DANGLING_OK)&& errno == ENOENT&& lstat(fileName, &statbuf) == 0) {/* Dangling link */
422. return fileAction(fileName, &statbuf, userData, depth);
423. }
424. goto done_nak_warn;
425. }
426. if (!S_ISDIR(statbuf.st_mode)) {//如果不是目录，则调用下边函数进行创建设备节点
427. return fileAction(fileName, &statbuf, userData, depth);
428. }
429. //ACTION_RECURSE标志设置过，不进行以下操作
430. if (!(flags & ACTION_RECURSE)) {
431. return dirAction(fileName, &statbuf, userData, depth);
432. }
433. //没有设置过ACTION_DEPTHFIRST
434. if (!(flags & ACTION_DEPTHFIRST)) {
435. status = dirAction(fileName, &statbuf, userData, depth);//返回TRUE=1
436. if (!status)
437. goto done_nak_warn;
438. if (status == SKIP)
439. return TRUE;
440. }
441. //执行到这里表明传入的参数是目录
442. dir = opendir(fileName);//打开目录
443. if (!dir) {
444. goto done_nak_warn;
445. }
446. status = TRUE;
447. while ((next = readdir(dir)) != NULL) {//读目录
448. char *nextFile;
449. nextFile = concat_subpath_file(fileName, next->d_name);//读目录下的文件
450. if (nextFile == NULL)
451. continue;
452. /* process every file (NB: ACTION_RECURSE is set in flags) */
453. if (!recursive_action(nextFile, flags, fileAction, dirAction,userData, depth + 1))//递归调用
454. status = FALSE;
455. free(nextFile);
456. }
457. closedir(dir);
458. //没有设置过ACTION_DEPTHFIRST,不会进去执行
459. if (flags & ACTION_DEPTHFIRST) {
460. if (!dirAction(fileName, &statbuf, userData, depth))
461. goto done_nak_warn;
462. }
463. return status;
464. done_nak_warn:
465. if (!(flags & ACTION_QUIET))
466. bb_simple_perror_msg(fileName);
467. return FALSE;
468. }
469. static int FAST_FUNC fileAction(const char *fileName,struct stat *statbuf UNUSED_PARAM,void *userData,int depth UNUSED_PARAM)
470. {
471. size_t len = strlen(fileName) - 4; /* can't underflow */
472. char *scratch = userData;
473. //检查传入进来的路径名的最后4个字符是否为“/dev”，即只有根据dev文件来创建设备节点
474. if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX)
475. return FALSE;
476. strcpy(scratch, fileName);//复制文件名
477. scratch[len] = '\0';//将最后的"/dev"去掉
478. make_device(scratch, /*delete:*/ 0);//进行创建设备节点
479. return TRUE;
480. }
481. static void make_device(char *path, int delete)
482. {
483. char *device_name, *subsystem_slash_devname;
484. int major, minor, type, len;
485. dbg("%s('%s', delete:%d)", __func__, path, delete);
486. major = -1;
487. if (!delete) {
488. char *dev_maj_min = path + strlen(path);//将dev_maj_min指针指向路径名的最后
489. //传入的路径名是最后dev文件的父目录，例如/sys/block/mtdblock0
490. strcpy(dev_maj_min, "/dev");//即将路径名添加“/dev”，即/sys/block/mtdblock0/dev确保读的文件时dev文件
491. len = open_read_close(path, dev_maj_min + 1, 64);//从dev文件中读出主设备号和次设备号存到dev_maj_min + 1地址处
492. *dev_maj_min = '\0';
493. if (len < 1) {
494. if (!ENABLE_FEATURE_MDEV_EXEC)
495. return;
496. } else if (sscanf(++dev_maj_min, "%u:%u", &major, &minor) != 2) {//主设备号和次设备号复制给major和minor
497. major = -1;
498. }
499. }
500. //调用strrchr() 函数查找字符在指定字符串中从后面开始的第一次出现的位置，即找到设备名
501. //例如：/sys/block/mtdblock0,返回的设备名就是mtdblock0
502. device_name = (char*) bb_basename(path);
503. type = S_IFCHR;
504. //判断是否为block设备
505. if (strstr(path, "/block/") || (G.subsystem && strncmp(G.subsystem, "block", 5) == 0))
506. type = S_IFBLK;
507. /* Make path point to "subsystem/device_name" */
508. subsystem_slash_devname = NULL;
509. //path路径名前移
510. if (strncmp(path, "/sys/block/", 11) == 0) /* legacy case */
511. path += sizeof("/sys/") - 1;
512. else if (strncmp(path, "/sys/class/", 11) == 0)
513. path += sizeof("/sys/class/") - 1;
514. else {
515. /* Example of a hotplug invocation:
516. * SUBSYSTEM="block"
517. * DEVPATH="/sys" + "/devices/virtual/mtd/mtd3/mtdblock3"
518. * ("/sys" is added by mdev_main)
519. * - path does not contain subsystem
520. */
521. subsystem_slash_devname = concat_path_file(G.subsystem, device_name);
522. path = subsystem_slash_devname;
523. }
524. #if ENABLE_FEATURE_MDEV_CONF
525. G.rule_idx = 0; /* restart from the beginning (think mdev -s) */
526. #endif
527. for (;;) {
528. const char *str_to_match;
529. regmatch_t off[1 + 9 * ENABLE_FEATURE_MDEV_RENAME_REGEXP];
530. char *command;
531. char *alias;
532. char aliaslink = aliaslink; /* for compiler */
533. const char *node_name;
534. const struct rule *rule;
535. str_to_match = "";
536. //# define next_rule() (&G.cur_rule)
537. rule = next_rule();
538. //检查rule
539. #if ENABLE_FEATURE_MDEV_CONF
540. if (rule->maj >= 0) { /* @maj,min rule */
541. if (major != rule->maj)
542. continue;
543. if (minor < rule->min0 || minor > rule->min1)
544. continue;
545. memset(off, 0, sizeof(off));
546. goto rule_matches;
547. }
548. if (rule->envvar) { /* $envvar=regex rule */
549. str_to_match = getenv(rule->envvar);
550. dbg("getenv('%s'):'%s'", rule->envvar, str_to_match);
551. if (!str_to_match)
552. continue;
553. } else {
554. /* regex to match [subsystem/]device_name */
555. str_to_match = (rule->regex_has_slash ? path : device_name);
556. }
557. if (rule->regex_compiled) {
558. int regex_match = regexec(&rule->match, str_to_match, ARRAY_SIZE(off), off, 0);
559. dbg("regex_match for '%s':%d", str_to_match, regex_match);
560. if (regex_match != 0
561. /* regexec returns whole pattern as "range" 0 */
562. || off[0].rm_so != 0
563. || (int)off[0].rm_eo != (int)strlen(str_to_match)
564. ) {
565. continue; /* this rule doesn't match */
566. }
567. }
568. /* else: it's final implicit "match-all" rule */
569. rule_matches:
570. #endif
571. dbg("rule matched");
572. /* Build alias name */
573. alias = NULL;
574. if (ENABLE_FEATURE_MDEV_RENAME && rule->ren_mov) {
575. aliaslink = rule->ren_mov[0];
576. if (aliaslink == '!') {
577. /* "!": suppress node creation/deletion */
578. major = -2;
579. }
580. else if (aliaslink == '>' || aliaslink == '=') {
581. if (ENABLE_FEATURE_MDEV_RENAME_REGEXP) {
582. char *s;
583. char *p;
584. unsigned n;
585. /* substitute %1..9 with off[1..9], if any */
586. n = 0;
587. s = rule->ren_mov;
588. while (*s)
589. if (*s++ == '%')
590. n++;
591. p = alias = xzalloc(strlen(rule->ren_mov) + n * strlen(str_to_match));
592. s = rule->ren_mov + 1;
593. while (*s) {
594. *p = *s;
595. if ('%' == *s) {
596. unsigned i = (s[1] - '0');
597. if (i <= 9 && off[i].rm_so >= 0) {
598. n = off[i].rm_eo - off[i].rm_so;
599. strncpy(p, str_to_match + off[i].rm_so, n);
600. p += n - 1;
601. s++;
602. }
603. }
604. p++;
605. s++;
606. }
607. } else {
608. alias = xstrdup(rule->ren_mov + 1);
609. }
610. }
611. }
612. dbg("alias:'%s'", alias);
613. command = NULL;
614. IF_FEATURE_MDEV_EXEC(command = rule->r_cmd;)
615. if (command) {
616. const char *s = "$@*";
617. const char *s2 = strchr(s, command[0]);
618. /* Are we running this command now?
619. * Run $cmd on delete, @cmd on create, *cmd on both
620. */
621. if (s2 - s != delete) {
622. /* We are here if: '*',
623. * or: '@' and delete = 0,
624. * or: '$' and delete = 1
625. */
626. command++;
627. } else {
628. command = NULL;
629. }
630. }
631. dbg("command:'%s'", command);
632. /* "Execute" the line we found */
633. node_name = device_name;
634. if (ENABLE_FEATURE_MDEV_RENAME && alias) {
635. node_name = alias = build_alias(alias, device_name);
636. dbg("alias2:'%s'", alias);
637. }
638. if (!delete && major >= 0) {//创建设备节点
639. dbg("mknod('%s',%o,(%d,%d))", node_name, rule->mode | type, major, minor);
640. if (mknod(node_name, rule->mode | type, makedev(major, minor)) && errno != EEXIST)//创建设备节点
641. bb_perror_msg("can't create '%s'", node_name);
642. if (major == G.root_major && minor == G.root_minor)
643. symlink(node_name, "root");
644. if (ENABLE_FEATURE_MDEV_CONF) {
645. chmod(node_name, rule->mode);
646. chown(node_name, rule->ugid.uid, rule->ugid.gid);
647. }
648. if (ENABLE_FEATURE_MDEV_RENAME && alias) {
649. if (aliaslink == '>') {
650. //TODO: on devtmpfs, device_name already exists and symlink() fails.
651. //End result is that instead of symlink, we have two nodes.
652. //What should be done?
653. symlink(node_name, device_name);
654. }
655. }
656. }
657. if (ENABLE_FEATURE_MDEV_EXEC && command) {
658. /* setenv will leak memory, use putenv/unsetenv/free */
659. char *s = xasprintf("%s=%s", "MDEV", node_name);
660. char *s1 = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem);
661. putenv(s);
662. putenv(s1);
663. if (system(command) == -1)
664. bb_perror_msg("can't run '%s'", command);
665. bb_unsetenv_and_free(s1);
666. bb_unsetenv_and_free(s);
667. }
668. if (delete && major >= -1) {//删除节点
669. if (ENABLE_FEATURE_MDEV_RENAME && alias) {
670. if (aliaslink == '>')
671. unlink(device_name);
672. }
673. unlink(node_name);
674. }
675. if (ENABLE_FEATURE_MDEV_RENAME)
676. free(alias);
677. /* We found matching line.
678. * Stop unless it was prefixed with '-'
679. */
680. if (!ENABLE_FEATURE_MDEV_CONF || !rule->keep_matching)
681. break;
682. } /* for (;;) */
683. free(subsystem_slash_devname);
684. }