• (笔记)linux设备驱动--LED驱动

    linux设备驱动--LED驱动

    最近正在学习设备驱动开发，因此打算写一个系列博客，即是对自己学习的一个总结，也是对自己的一个督促，有不对，不足，需要改正的地方还望大家指出，而且希望结识志同道合的朋友一起学习技术，共同进步。

    作者：liufei_learning（转载请注明出处）

    email：flying0216@foxmail.com 

    IT学习交流群：160855096

    转至：http://blog.csdn.net/liufei_learning/article/details/7025246

    开发环境：Win7(主机) +VisualBox + ubuntu10.10(虚拟机) + TQ2440开发板(2.6.30.4内核)

    功能：实现tq2440下led控制以及自动创建设备节点

    目录：

    1.实现

    1）程序分析框图：

    2）程序流程

    3）原理图

    2.步骤

    3.分析

    1）字符设备注册问题

    2）file_operations()

    3）ioctl

    4）设备节点的自动创建

    实现：

    程序分析框图：

    函数

    fun：leds_open()

    fun：leds_ioctl()

    fun：leds_init()

    fun：leds_exit()

    结构体

    struct：led_table

    struct：led_cfg_table

    struct：led_fops

     调用

    控制程序执行open()时，会调用此函数

    控制程序执行ioctl)时，会调用此函数

    加载模块时会调用此函数

    卸载函数时会调用此函数

    功能

    控制LED的IO口

    LEDIO口的模式

    注册字符设备时，通过此结构体关联leds_open()，Leds_ioctl()

    程序流程

    首先通过入口函数module_init(leds_init)，进入leds_init()进行初始化操作，设置GPIO口，注册字符设备，通过led_fops结构体关联leds_open()，Leds_ioctl()，创建设备节点，卸载时调用leds_exit()注销设备删除设备节点

    由原理图得知LED电路是共阳极的，并分别由2440的GPB5、GPB6、GPB7、GPB8口控制

                                           

    步骤：

    （参考http://hbhuanggang.cublog.cn，添加自动加载设备节点 ）

    1.去掉内核已有的LED驱动设置，因为IO口与tq2440开发板不一致 修改arch/arm/plat-s3c24xx/common-smdk.c

    [cpp] view plaincopyprint?
     
    1. /* LED devices */  
    2. /* 
    3. static structs3c24xx_led_platdata smdk_pdata_led4 = { 
    4.     .gpio        =S3C2410_GPF4, 
    5.     .flags        =S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
    6.     .name        ="led4", 
    7.     .def_trigger    ="timer", 
    8. }; 
    9.   
    10. static structs3c24xx_led_platdata smdk_pdata_led5 = { 
    11.     .gpio        =S3C2410_GPF5, 
    12.     .flags        =S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
    13.     .name        ="led5", 
    14.     .def_trigger    ="nand-disk", 
    15. }; 
    16.   
    17. static structs3c24xx_led_platdata smdk_pdata_led6 = { 
    18.     .gpio        =S3C2410_GPF6, 
    19.     .flags        =S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
    20.     .name        ="led6", 
    21. }; 
    22.   
    23. static structs3c24xx_led_platdata smdk_pdata_led7 = { 
    24.     .gpio        =S3C2410_GPF7, 
    25.     .flags        =S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
    26.     .name        ="led7", 
    27. }; 
    28.   
    29. static structplatform_device smdk_led4 = { 
    30.     .name        ="s3c24xx_led", 
    31.     .id        =0, 
    32.     .dev        ={ 
    33.         .platform_data= &smdk_pdata_led4, 
    34.     }, 
    35. }; 
    36.   
    37. static structplatform_device smdk_led5 = { 
    38.     .name        ="s3c24xx_led", 
    39.     .id        =1, 
    40.     .dev        ={ 
    41.         .platform_data= &smdk_pdata_led5, 
    42.     }, 
    43. }; 
    44.   
    45. static structplatform_device smdk_led6 = { 
    46.     .name        ="s3c24xx_led", 
    47.     .id        =2, 
    48.     .dev        ={ 
    49.         .platform_data= &smdk_pdata_led6, 
    50.     }, 
    51. }; 
    52.   
    53. static structplatform_device smdk_led7 = { 
    54.     .name        ="s3c24xx_led", 
    55.     .id        =3, 
    56.     .dev        ={ 
    57.         .platform_data= &smdk_pdata_led7, 
    58.     }, 
    59. };*/  
    60.    
    61. static struct platform_device__initdata *smdk_devs[] = {  
    62.     &s3c_device_nand,  
    63.     /*&smdk_led4, 
    64.     &smdk_led5, 
    65.     &smdk_led6, 
    66.     &smdk_led7,*/  
    67. };  
    [cpp] view plaincopyprint?
     
    1. void __initsmdk_machine_init(void)  
    2. {  
    3.     /*Configure the LEDs (even if we have no LED support)*/  
    4.     /* 
    5.     s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP); 
    6.     s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP); 
    7.     s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP); 
    8.     s3c2410_gpio_cfgpin(S3C2410_GPF7, S3C2410_GPF7_OUTP); 
    9.   
    10.     s3c2410_gpio_setpin(S3C2410_GPF4, 1); 
    11.     s3c2410_gpio_setpin(S3C2410_GPF5, 1); 
    12.     s3c2410_gpio_setpin(S3C2410_GPF6, 1); 
    13.     s3c2410_gpio_setpin(S3C2410_GPF7, 1);*/  
    14.    
    15.     if (machine_is_smdk2443())  
    16.         smdk_nand_info.twrph0 = 50;  
    17.     s3c_device_nand.dev.platform_data = &smdk_nand_info;  
    18.     platform_add_devices(smdk_devs, ARRAY_SIZE(smdk_devs));  
    19.     s3c_pm_init();  
    20. }  



    2.编写tq2440的LED驱动，代码如下

    [cpp] view plaincopyprint?
     
    1. /* 
    2.  * tq2440_leds.c 
    3.  * 
    4.  * Created on: 2011-11-29 
    5.  *     Author: liufei_learning 
    6.  * 
    7.  */  
    8.    
    9. #include<linux/module.h>  
    10. #include<linux/init.h>  
    11. #include<linux/fs.h>  
    12. #include<mach/hardware.h>  
    13. #include<mach/regs-gpio.h>  
    14. #include<linux/device.h>  
    15.    
    16. #defineDEVICE_NAME        "tq2440_leds"    //设备名称  
    17. #defineLED_MAJOR        231                //主设备号  
    18. #defineIOCTL_LED_ON        1                 //LED亮状态  
    19. #defineIOCTL_LED_OFF        0                //LED灭状态  
    20.    
    21. //控制LED的IO口  
    22. static unsigned longled_table[] =  
    23. {  
    24. S3C2410_GPB5,  
    25. S3C2410_GPB6,  
    26. S3C2410_GPB7,  
    27. S3C2410_GPB8,  
    28. };  
    29.    
    30. //LED IO口的模式  
    31. static unsigned intled_cfg_table[] =  
    32. {  
    33. S3C2410_GPB5_OUTP,  
    34. S3C2410_GPB6_OUTP,  
    35. S3C2410_GPB7_OUTP,  
    36. S3C2410_GPB8_OUTP,  
    37. };  
    38.    
    39. static struct class*leds_class;  
    40.    
    41. static int __initleds_open(struct inode *inode, struct file *file)  
    42. {  
    43. return0;  
    44. }  
    45.    
    46. static int __initleds_ioctl(struct inode *inode, struct file *file,  
    47. unsignedint cmd, unsigned long arg)  
    48. {  
    49. //检测是第几个LED，因开发板上只有4个，索引从0开始  
    50. if(arg< 0 || arg > 3)  
    51. {  
    52. return-EINVAL;  
    53. }  
    54.    
    55. //判断LED要执行哪种状态  
    56. switch(cmd)  
    57. {  
    58. caseIOCTL_LED_ON:  
    59. {  
    60. s3c2410_gpio_setpin(led_table[arg],~(IOCTL_LED_ON));  
    61. break;  
    62. }  
    63. caseIOCTL_LED_OFF:  
    64. {  
    65. s3c2410_gpio_setpin(led_table[arg],~(IOCTL_LED_OFF));  
    66. break;  
    67. }  
    68. default:  
    69. {  
    70. return-EINVAL;  
    71. }  
    72. }  
    73.    
    74. return0;  
    75. }  
    76.    
    77. static structfile_operations led_fops =  
    78. {  
    79. .owner= THIS_MODULE,  
    80. .open= leds_open,  
    81. .ioctl= leds_ioctl,  
    82. };  
    83.    
    84. static int __initleds_init(void)  
    85. {  
    86. intret;  
    87. int i;  
    88. for(i= 0; i < 4; i++)  
    89. {  
    90. //初始化各IO口为输出模式  
    91. s3c2410_gpio_cfgpin(led_table[i],led_cfg_table[i]);  
    92. //由原理图可知LED电路是共阳极的(即各IO口输出低电平0才会点亮)  
    93. //这里初始化为1，不让LED点亮  
    94. s3c2410_gpio_setpin(led_table[i],~(IOCTL_LED_OFF));  
    95. }  
    96.    
    97. //注册LED设备为字符设备  
    98. ret =register_chrdev(LED_MAJOR, DEVICE_NAME, &led_fops);  
    99.    
    100. if(ret< 0)  
    101. {  
    102. printk(DEVICE_NAME" major number register falid! ");  
    103. returnret;  
    104. }  
    105.    
    106. //注册一个类，使mdev可以在/dev/下面建立设备节点  
    107. leds_class= class_create(THIS_MODULE, DEVICE_NAME);  
    108. if(IS_ERR(leds_class) )  
    109. {  
    110. printk("creatleds_class failed!");  
    111. return-1;  
    112. }  
    113.    
    114. //创建一个设备节点，节点名字为DEVICE_NAME  
    115. device_create(leds_class,NULL, MKDEV(LED_MAJOR, 0), NULL, DEVICE_NAME);  
    116. printk(DEVICE_NAME"initialized!");  
    117. return0;  
    118. }  
    119.    
    120. static void __initleds_exit(void)  
    121. {  
    122. //注销设备  
    123. unregister_chrdev(LED_MAJOR,DEVICE_NAME);  
    124. //删除设备节点  
    125. device_destroy(leds_class,MKDEV(LED_MAJOR, 0));  
    126. //注销类  
    127. class_destroy(leds_class);  
    128. }  
    129.    
    130. module_init( leds_init);  
    131. module_exit( leds_exit);  
    132.    
    133. MODULE_LICENSE("GPL");  
    134. MODULE_AUTHOR("liufei_learning");  
    135. MODULE_DESCRIPTION("tq2440leds driver");  



    3.编写应用程序测试LED驱动

    [cpp] view plaincopyprint?
     
    1. /* 
    2.  ============================================== 
    3.  Name           : led_test.c 
    4.  Author         : liufei_learning 
    5.  Date           : 11/27/2011 
    6.  Description    : tq2440 led driver test 
    7.  ============================================== 
    8.  */  
    9.    
    10. #include <stdio.h>  
    11. #include <stdlib.h>  
    12. #include <fcntl.h>  
    13. #include<sys/ioctl.h>  
    14.    
    15. int main(int argc, char**argv)  
    16. {  
    17.     int turn, index, fd;  
    18.    
    19.     //检测输入的参数合法性  
    20.     if(argc != 3 || sscanf(argv[2],"%d", &index) != 1 || index < 1 || index > 4)  
    21.     {  
    22.         printf("Usage: led_test on|off1|2|3|4 ");  
    23.         exit(1);  
    24.     }  
    25.    
    26.     if(strcmp(argv[1], "on") == 0)  
    27.     {  
    28.         turn = 1;  
    29.     }  
    30.     else if(strcmp(argv[1], "off") ==0)  
    31.     {  
    32.         turn = 0;  
    33.     }  
    34.     else  
    35.     {  
    36.         printf("Usage: led_test on|off1|2|3|4 ");  
    37.         exit(1);  
    38.     }  
    39.    
    40.     //打开LED设备  
    41.     fd = open("/dev/tq2440_leds", 0);  
    42.    
    43.     if(fd < 0)  
    44.     {  
    45.         printf("Open Led DeviceFaild! ");  
    46.         exit(1);  
    47.     }  
    48.    
    49.     //IO控制  
    50.     ioctl(fd, turn, index - 1);  
    51.    
    52.     //关闭LED设备  
    53.     close(fd);  
    54.    
    55.     return 0;  
    56. }  



    4. 把LED驱动代码部署到内核中去

    #cp -f tq2440_leds.c/linux-2.6.30.4/drivers/char    //把驱动源码复制到内核驱动的字符设备下

    #vim /linux-2.6.30.4/drivers/char/Kconfig    //添加LED设备配置

    [cpp] view plaincopyprint?
     
    1. config TQ2440_LEDS  
    2.    tristate "TQ2440 Leds Device"  
    3.    depends on ARCH_S3C2440  
    4.    default y  
    5.    ---help---  
    6.       TQ2440User Leds  

     

    #vim /linux-2.6.30.4/drivers/char/Makefile    //添加LED设备配置

    obj-$(CONFIG_TQ2440_LEDS) +=tq2440_leds.o

    5. 配置内核，选择LED设备选项

    #make menuconfig

    Device Drivers --->

        Character devices ---> 

            <*> TQ2440 Leds Device (NEW)

    6.编译内核make zImage

    7.编译测试程序#arm-linux-gcc -o led_test led_test.c 将生成的文件复制到开发板 /usr/sbin下

    8.开发板上测试

    查看已加载的设备：#cat/proc/devices，可以看到tq2440_leds的主设备号为231

    控制led输入led_test on 1可以看到对应led被点亮

     

    分析：

    1.字符设备注册问题

    register_chrdev()

    intregister_chrdev(unsigned int major, const char *name,

                        const structfile_operations *fops)

    register_chrdev()为字符设备注册一个主设备号

    参数：majar：主设备号若==0，则系统动态分配一个主设备号，>0系统尝试用所给的值存储主设备号

          成功返回0，失败返回错误errno:-ve

    name：设备名称

    fops：与此设备相关的文件操作

    设备号的范围为：0~255

    2.6内核以后的大量驱动代码, 有许多字符驱动不使用上面代码的方法. 那是还没有更新到 2.6 内核接口的老代码. 因为那个代码实际上能用,这个更新可能很长时间不会发生. 为完整, 我们描述老的字符设备注册接口, 但是新代码不应当使用它; 这个机制在将来内核中可能会消失(LDD3)，所以下一篇blog将讨论新的方法。不过老的方法我觉得还是有必要学习一下，了解系统实现的原理，有助于跟深入的理解字符设备驱动。

    在Linux中，字符设备是用一个叫做字符设备结构的数据结构char device struct来描述的。为了管理上的方便，系统维护了一个数组chrdevs[]，该数组的每一项都代表一个字符没备。

    在文件linux/fs/char_dev.c中定义的char_device_struct的数据结构及数组chrdevs［］代码如下：

    结构中的一个域name是指向设备驱动程序名的指针；另一个域fops是指向－个封装了文件操作函数集结构的指针。这些文件操作函数就是对这个字符设备进行具体的如打开、读、写、关闭等文件操作驱动程序。

    字符设备注册表结构如图所示。当安装一个字符设各时，须调用注册函数regesterchardev（）向注册表插入一个新的表项。函数regester_chardev（）的原型如下：

    图字符设备驱动程序的注册

    当代表－个字符设备的文件被进程打开时，系统根据设备主、次设各号，查询上述的chrdevs[]数组，并获得fops指针和为进程设置－个描述这个字符特眯文件跑数握结构file，进而通过fops指针调用指定的驱动程序。

    取消注册的函数为unregister_chrdev（）。其原型如下：

    intunregister_chrdev int major,const char*name):

    设备驱动程序的注册和取消注册应分别在模块的初始化函数和析构函数中完成。

    2.file_operations()

    [cpp] view plaincopyprint?
     
    1. struct file_operations {  
    2. 1485        struct module *owner;  
    3. 1486        loff_t (*llseek) (struct file *,loff_t, int);  
    4. 1487        ssize_t (*read) (struct file *, char__user *, size_t, loff_t *);  
    5. 1488        ssize_t (*write) (struct file *, constchar __user *, size_t, loff_t *);  
    6. 1489        ssize_t (*aio_read) (struct kiocb *,const struct iovec *, unsigned long, loff_t);  
    7. 1490        ssize_t (*aio_write) (struct kiocb *,const struct iovec *, unsigned long, loff_t);  
    8. 1491        int (*readdir) (struct file *, void *,filldir_t);  
    9. 1492        unsigned int (*poll) (struct file *,struct poll_table_struct *);  
    10. 1493        int (*ioctl) (struct inode *, structfile *, unsigned int, unsigned long);  
    11. 1494        long (*unlocked_ioctl) (struct file *,unsigned int, unsigned long);  
    12. 1495        long (*compat_ioctl) (struct file *,unsigned int, unsigned long);  
    13. 1496        int (*mmap) (struct file *, structvm_area_struct *);  
    14. 1497        int (*open) (struct inode *, structfile *);  
    15. 1498        int (*flush) (struct file *, fl_owner_tid);  
    16. 1499        int (*release) (struct inode *, structfile *);  
    17. 1500        int (*fsync) (struct file *, structdentry *, int datasync);  
    18. 1501        int (*aio_fsync) (struct kiocb *, intdatasync);  
    19. 1502        int (*fasync) (int, struct file *,int);  
    20. 1503        int (*lock) (struct file *, int, structfile_lock *);  
    21. 1504        ssize_t (*sendpage) (struct file *,struct page *, int, size_t, loff_t *, int);  
    22. 1505        unsigned long(*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsignedlong, unsigned long);  
    23. 1506        int (*check_flags)(int);  
    24. 1507        int (*flock) (struct file *, int,struct file_lock *);  
    25. 1508        ssize_t (*splice_write)(structpipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);  
    26. 1509        ssize_t (*splice_read)(struct file *,loff_t *, struct pipe_inode_info *, size_t, unsigned int);  
    27. 1510        int (*setlease)(struct file *, long,struct file_lock **);  
    28. 1511};  

     

    struct module *owner

    第一个file_operations 成员根本不是一个操作; 它是一个指向拥有这个结构的模块的指针. 这个成员用来在它的操作还在被使用时阻止模块被卸载.几乎所有时间中, 它被简单初始化为 THIS_MODULE, 一个在 <linux/module.h> 中定义的宏.

    loff_t (*llseek) (structfile *, loff_t, int);

    llseek方法用作改变文件中的当前读/写位置, 并且新位置作为(正的)返回值. loff_t 参数是一个"long offset", 并且就算在32位平台上也至少 64 位宽. 错误由一个负返回值指示. 如果这个函数指针是 NULL, seek 调用会以潜在地无法预知的方式修改 file结构中的位置计数器( 在"file 结构" 一节中描述).

    ssize_t (*read) (structfile *, char __user *, size_t, loff_t *);

    用来从设备中获取数据.在这个位置的一个空指针导致 read 系统调用以 -EINVAL("Invalid argument") 失败.一个非负返回值代表了成功读取的字节数( 返回值是一个 "signed size" 类型, 常常是目标平台本地的整数类型).

    ssize_t(*aio_read)(struct kiocb *, char __user *, size_t, loff_t);

    初始化一个异步读-- 可能在函数返回前不结束的读操作. 如果这个方法是 NULL, 所有的操作会由 read 代替进行(同步地).

    ssize_t (*write) (structfile *, const char __user *, size_t, loff_t *);

    发送数据给设备.如果 NULL, -EINVAL 返回给调用 write 系统调用的程序. 如果非负, 返回值代表成功写的字节数.

    ssize_t(*aio_write)(struct kiocb *, const char __user *, size_t, loff_t *);

    初始化设备上的一个异步写.

    int (*readdir) (structfile *, void *, filldir_t);

    对于设备文件这个成员应当为NULL; 它用来读取目录, 并且仅对文件系统有用.

    unsigned int (*poll)(struct file *, struct poll_table_struct *);

    poll方法是 3 个系统调用的后端: poll, epoll, 和 select, 都用作查询对一个或多个文件描述符的读或写是否会阻塞. poll方法应当返回一个位掩码指示是否非阻塞的读或写是可能的, 并且, 可能地, 提供给内核信息用来使调用进程睡眠直到 I/O 变为可能. 如果一个驱动的 poll方法为 NULL, 设备假定为不阻塞地可读可写.

    int (*ioctl) (structinode *, struct file *, unsigned int, unsigned long);

    ioctl系统调用提供了发出设备特定命令的方法(例如格式化软盘的一个磁道, 这不是读也不是写). 另外, 几个 ioctl 命令被内核识别而不必引用 fops 表.如果设备不提供 ioctl 方法, 对于任何未事先定义的请求(-ENOTTY, "设备无这样的 ioctl"), 系统调用返回一个错误.

    int (*mmap) (struct file*, struct vm_area_struct *);

    mmap用来请求将设备内存映射到进程的地址空间. 如果这个方法是 NULL, mmap 系统调用返回 -ENODEV.

    int (*open) (struct inode*, struct file *);

    尽管这常常是对设备文件进行的第一个操作,不要求驱动声明一个对应的方法. 如果这个项是 NULL, 设备打开一直成功, 但是你的驱动不会得到通知.

    int (*flush) (struct file*);

    flush操作在进程关闭它的设备文件描述符的拷贝时调用; 它应当执行(并且等待)设备的任何未完成的操作. 这个必须不要和用户查询请求的 fsync 操作混淆了. 当前,flush 在很少驱动中使用; SCSI 磁带驱动使用它, 例如, 为确保所有写的数据在设备关闭前写到磁带上. 如果 flush 为 NULL,内核简单地忽略用户应用程序的请求.

    int (*release) (structinode *, struct file *);

    在文件结构被释放时引用这个操作.如同 open, release 可以为 NULL.

    int (*fsync) (struct file*, struct dentry *, int);

    这个方法是fsync 系统调用的后端, 用户调用来刷新任何挂着的数据. 如果这个指针是 NULL, 系统调用返回 -EINVAL.

    int (*aio_fsync)(structkiocb *, int);

    这是fsync 方法的异步版本.

    int (*fasync) (int,struct file *, int);

    这个操作用来通知设备它的FASYNC 标志的改变. 异步通知是一个高级的主题, 在第 6 章中描述. 这个成员可以是NULL 如果驱动不支持异步通知.

    int (*lock) (struct file*, int, struct file_lock *);

    lock方法用来实现文件加锁; 加锁对常规文件是必不可少的特性, 但是设备驱动几乎从不实现它.

    ssize_t (*readv) (structfile *, const struct iovec *, unsigned long, loff_t *);

    ssize_t (*writev) (structfile *, const struct iovec *, unsigned long, loff_t *);

    这些方法实现发散/汇聚读和写操作.应用程序偶尔需要做一个包含多个内存区的单个读或写操作; 这些系统调用允许它们这样做而不必对数据进行额外拷贝. 如果这些函数指针为 NULL, read 和write 方法被调用( 可能多于一次 ).

    ssize_t(*sendfile)(struct file *, loff_t *, size_t, read_actor_t, void *);

    这个方法实现sendfile 系统调用的读, 使用最少的拷贝从一个文件描述符搬移数据到另一个. 例如, 它被一个需要发送文件内容到一个网络连接的 web 服务器使用.设备驱动常常使 sendfile 为 NULL.

    ssize_t (*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int);

    sendpage是 sendfile 的另一半; 它由内核调用来发送数据, 一次一页, 到对应的文件. 设备驱动实际上不实现 sendpage.

    unsigned long(*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsignedlong, unsigned long);

    这个方法的目的是在进程的地址空间找一个合适的位置来映射在底层设备上的内存段中.这个任务通常由内存管理代码进行; 这个方法存在为了使驱动能强制特殊设备可能有的任何的对齐请求. 大部分驱动可以置这个方法为 NULL.

    int (*check_flags)(int)

    这个方法允许模块检查传递给fnctl(F_SETFL...) 调用的标志.

    int (*dir_notify)(structfile *, unsigned long);

    这个方法在应用程序使用fcntl 来请求目录改变通知时调用. 只对文件系统有用; 驱动不需要实现 dir_notify.

    3.ioctl

    ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。它的调用个数如下：

    intioctl(int fd, ind cmd, …)；

    其中fd就是用户程序打开设备时使用open函数返回的文件标示符，cmd就是用户程序对设备的控制命令，至于后面的省略号，那是一些补充参数，一般最多一个，有或没有是和cmd的意义相关的。

    ioctl函数是文件结构中的一个属性分量，就是说如果你的驱动程序提供了对ioctl的支持，用户就可以在用户程序中使用ioctl函数控制设备的I/O通道。

    用法很简单就是通过switch解析命令

    4.设备节点的自动创建

    在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了udev。

    内核中定义了structclass结构体，顾名思义，一个structclass结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。通过device_destroy();class_destroy();来注销类和节点
  • 相关阅读:
    怎么把自己电脑上的文件传到服务器本地上
    查看hive中某个表中的数据、表结构及所在路径
    python2.7读汉字的时候出现乱码，如何解决
    如何连接服务器客户端
    java常用问题排查工具
    netty源码分析之一：server的启动
    java AQS 一：
    netty源码分析之二：accept请求
    java Resource
    二：基础概述netty
  • 原文地址：https://www.cnblogs.com/tdyizhen1314/p/4135935.html
Copyright © 2020-2023  润新知