驱动入门的进一步深入

继上一篇驱动入门的进一步深入

*********************

注册字符设备驱动新接口

老接口：

ret = register_chrdev(MYMAJOR,MYNAME,&test_fops);

包括主设备号、名字、file_operations

新接口：

register_chrdev_region/alloc_chrdev_region + cdev_xx

register_chrdev_region:

需要指定设备号

alloc_chrdev_region ：

内核分配设备号

cdev_xx：

包括cdev_init 、 cdev_add 、cdev_del等操作

设备号：

MKDEV、MAJOR、MINOR三个宏

MKDEV 返回值类型：dev_t类型

***************************************

指定设备号方法：

首先，定义static dev_t dev_id;

先用MKDEV申请一个设备号：

dev_id = MKDEV(MYMAJOR, 0); //设备号

MYMAJOR是指定的主设备号

后面的是次设备号

然后注册：

int register_chrdev_region(dev_t from, unsigned count, const char *name)

retval = register_chrdev_region(dev_id, MYCNT,MYNAME);

if (retval) {

printk(KERN_ERR "Unable to register minors for usb_device\n");

return retval;

}

用返回的dev_id

MYCNT：注册的数量

MYNAME：注册的名字

retval：返回值成功是0 ，失败返回负数

然后，注册驱动：

static struct cdev test_cdev;

static const struct file_operations test_fops

cdev_init(&test_cdev, &test_fops); //绑定两个结构体

retval = cdev_add(&test_cdev, dev_id, 1); //添加驱动

if (retval)

cdev_del(&test_cdev);

最后，注销

unregister_chrdev_region(dev_id, 1);

**************************************

上面就是完整的用新接口注册驱动的步骤

***********************

用内核自动分配设备号：

自动分配的话就不需要先用MKDEV申请设备号：

dev_id = MKDEV(MYMAJOR, 0); //设备号

而是直接用定义的结构体变量加上定义定义的子设备号，加上名字

就可以完成自动分配设备号

typedef u_long dev_t;（源结构体）

static dev_t mydev;

// 第1步：分配主次设备号

retval = alloc_chrdev_region(&mydev, 12, MYCNT, MYNAME);

int alloc_chrdev_region(dev_t *dev, u[nsigned baseminor, unsigned count,

const char *name)

{

struct char_device_struct *cd;

cd = __register_chrdev_region(0, baseminor, count, name);

if (IS_ERR(cd))

return PTR_ERR(cd);

*dev = MKDEV(cd->major, cd->baseminor);

return 0;

}

*****************

这里对led灯的驱动操作

在模块层次代码中，应该要简洁，及对read进来的相关指令，这个指令应该是

简单的，例如1、2、3这样的，可以用宏定义

就是说，较为复杂的一些操作，例如对输入的指令的判断，用到的

strcmp等，应该在应用层完成

**********************

这里是对设备注册的一个操作

之前注册驱动时用到的是一个全局变量的结构体，

占据固定内存

static struct cdev test_cdev;

现在，用到

struct cdev *cdev_alloc(void)

{

struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);

if (p) {

INIT_LIST_HEAD(&p->list);

kobject_init(&p->kobj, &ktype_cdev_dynamic);

}

return p;

}

这一个函数，可以设置一个struct cdev类型的指针

struct cdev *cdev;

static struct cdev *test_cdev;

//注册驱动，使用cdev_alloc

test_cdev = cdev_alloc();

if (!test_cdev)

return -EINVAL;

test_cdev->owner = THIS_MODULE;

test_cdev->ops = test_fops;

//cdev_init(&test_cdev, &test_fops); //绑定两个结构体

这里使用的*指针的意义就是，用全局变量指定一个指针，只占一个指针大小的内存，

当需要使用时，就用cdev_alloc为指针动态分配一个堆内存，指向用的结构体，

需要注意的就是，在内核中，堆内存的释放一般都不是简单的对应关系，

它是内部有一个数的增加机制，有用到申请堆内存的就加一，用完就减一，

目前还不太了解其中机制

释放函数：

kfree(cls);

struct cdev {

struct kobject kobj;

struct module *owner;

const struct file_operations *ops;

struct list_head list;

dev_t dev;

unsigned int count;

};

这个就是用到的结构体，里面有指向模块、文件操作、链表、设备等

void cdev_init(struct cdev *cdev, const struct file_operations *fops)

{

memset(cdev, 0, sizeof *cdev);

INIT_LIST_HEAD(&cdev->list);

kobject_init(&cdev->kobj, &ktype_cdev_default);

cdev->ops = fops;

}

这里不使用cdev_init，

而是直接实例化结构体其中的几个，

实际上也是和上面的函数是一样的，只不过是少实例几个而已

还有就是，上面实例化的owner

是在file_operation中的那个，

.owner = THIS_MODULE,

********************

总结：

以上的就是关于设备号的新旧使用，手动/自动分配使用，

关于设备注册的函数使用，

一个是全局变量直接定义，一个是定义一个全局变量的指针使用

关于设备的初始化，

可以用init函数，也可以直接实例化

*************