字符设备驱动（二）

驱动LED灯

首先加入头文件

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>

还要定义几个类

static struct class *leds_class;
static struct class_device  *leds_class_devs[4];

定义一个类，然后再在类下定义4个设备，下面会用到。

然后创建open函数myled_open

static int myled_open(struct inode *inode, struct file *file)
{
    *gpfcon &= ~((0x3<<4*2)|(0x03<<5*2)|(0x3<<6*2));
    *gpfcon |= (1<<4*2)|(1<<5*2)|(1<<6*2);
    return 0;
}

当再测试文件中执行open(“/dev/xxx”,”x”);时，系统就会根据file_operations结构体运行myled_open函数。所以在这个函数中初始化led引脚为输出。该函数参数为 设备节点结构体指针，和文件流指针。

然后创建write函数myled_write

static int myled_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    int minor=MINOR(file->f_dentry->d_inode->i_rdev);
    char val;
    copy_from_user(&val,buf,count);//copy variable from user to kernel
    switch(minor){
        case 0:
        {
            if(val==1)*gpfdat &=(0<<4|0<<5|0<<6);//点灯
            else    *gpfdat |=(1<<4|1<<5|1<<6);//关灯
            break;
        }
        case 1:
        {
            *gpfdat |=(1<<4|1<<5|1<<6);//关灯
            if(val==1)
            *gpfdat &=(~(1<<4));//点灯
            break;
        }
        case 2:
        {
            *gpfdat |=(1<<4|1<<5|1<<6);//关灯
            if(val==1)
            *gpfdat &=(~(1<<5));
            break;
        }
        case 3:
        {
            *gpfdat |=(1<<4|1<<5|1<<6);//关灯
            if(val==1)
            *gpfdat &=(~(1<<6));
            break;
        }
    }
    return 0;
}

myled_write函数的参数为文件流指针、传递进来的数据指针、数据大小

MINOR(file->f_dentry->d_inode->i_rdev);是取文件的次设备号，copy_from_user(void *to, const void __user *from, unsigned long n)从用户空间拷贝数据到内核空间，失败返回没有被拷贝的字节数，成功返回0.

当测试程序执行write(fd,&val,1);时，系统就会调用该函数。fd为执行open函数时返回的唯一的文件文件描述符，

然后接下来就是填充file_operations结构体

static struct .file_operations myled_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   myled_open,
    .write  =   myled_write,
};

系统启动后，会自动执行这个结构体，然后将创建的函数与底层open,write函数关联起来。

接下来就是注册函数

static int myled_init(void)//加载
{
    major=register_chrdev(111,"myled",&myled_fops);//major为自己定义的全局整型变量
    if (major < 0) {
      printk("myled can‘t register major number\n");
      return major;
    }

    myled_class=class_create(THIS_MODULE, "myled");
    if (IS_ERR(myled_class))
        return PTR_ERR(myled_class);
    int i;
    for(i=0;i<4;i++){
        myled_class_devs[i]=class_device_create(myled_class, NULL, MKDEV(111, i), NULL, "led%d",i);//
        if (unlikely(IS_ERR(myled_class_devs[i])))//先建立一个类 再建立一个设备，然后自动创建一个xyz设备节点
            return PTR_ERR(myled_class_devs[i]);
    }

    gpfcon=(unsigned long *)ioremap(0x56000050,16);
    gpfdat=gpfcon+1;

    return 0;
}

major=register_chrdev(111,”myled”,&myled_fops);就是将file_operations创建的myled_fops结构题告诉内核，然后给该设备的主设备号赋值为111，设备名字为myled.

myled_class=class_create(THIS_MODULE, “myled”);

myled_class_devs[i]=class_device_create(myled_class, NULL, MKDEV(111, i), NULL, “led%d”,i);

就是给该设备创建一个类，然后再创建的类下，再创建四个设备节点。最终在系统中节点是/dev/led0 /dev/led1 /dev/led2 /dev/led3.应用层序中open函数中的参数就是这些节点。它们的主设备号相同，但是次设备号不同。都归属于myled这个节点。

gpfcon=(unsigned long *)ioremap(0x56000050,16);

gpfdat=gpfcon+1;

ioremap函数就是将一段连续的物理地址映射为虚拟地址。因为指针大小为4字节，所以加一就表示加了4字节。在注册函数中映射地址，那么就得在卸载函数中取消映射地址。

下面是卸载函数

static void myled_exit(void)
{
    int i;
    unregister_chrdev(111,"myled");//卸载;

    for(i=0;i<4;i++){
        class_device_unregister(myled_class_devs[i]);
    }

    class_destroy(myled_class);

    iounmap(gpfcon);
}

unregister_chrdev(111,”myled”);是从内核中删除创建的myled_fops结构体，这里只需要主设备号和设备名。

class_device_unregister(myled_class_devs[i]);class_destroy(myled_class);与上面的创建类的函数相对应

iounmap(gpfcon);就是取消虚拟地址映射。

最后还要加上如下几行

module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");

module_init(myled_init);创建一个结构体，里面有myled_init函数的地址，当执行insmod myled.ko时，系统会自动找到这个结构体,然后找到里面的函数地址，去执行myled_init。

module_exit(myled_exit);创建一个结构体，里面有first_drv_init函数的地址，当执行rmmod myled.ko时，系统会自动找到这个结构体,然后找到里面的函数地址，去执行myled_exit

MODULE_LICENSE(“GPL”);是将钥匙设置为GPL.

下面是测试函数

加入头文件

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>

void print_usage(char *file)
{
    printf("Usage:\n");
    printf("%s /dev/led0 <on|off>\n", file);
    printf("%s /dev/led1 <on|off>\n", file);
    printf("%s /dev/led2 <on|off>\n", file);
    printf("%s /dev/led3 <on|off>\n", file);
}
int main(int argc,char *argv[])
{
    int fd;
    int val=1;
    if(argc<3){
        print_usage(argv[0]);
        return 0;
    }
    fd=open(argv[1],O_RDWR);
    if(fd<0){
        printf("error,can‘t open %s\n",argv[1]);
        return 0;
    }
    if(strcmp(argv[2],"on")==0)
        val=1;
    else if(strcmp(argv[2],"off")==0)
        val=0;
    else print_usage(argv[0]);
        write(fd,&val,1);
    return 0;
}

例如执行/myledtest /dev/led0 on

当执行 fd=open(argv[1],O_RDWR);函数时，就会运行/dev/led0对应open函数，返回的是每个次设备号不同的描述符，每个主设备里的次设备的描述符不一样。

然后下面执行write(fd,&val,1);就会运行/dev/led0对应的write函数。

执行/myledtest /dev/led1 on /myledtest /dev/led2 on时也会这样。

是因为在注册函数中将同一主设备号的write，read函数填充在myled_fops结构体中了。然后又将这个结构体和主设备名绑定在一起并告诉内核了，然后又利用主设备名创建一个类，类里又创建四个次设备。所以每次调用次设备时就会执行主设备对应的底层函数，然后在该函数中分别是哪一个次设备调用的。如int minor=MINOR(file->f_dentry->d_inode->i_rdev);就是返回调用该函数的次设备号。