linux驱动开发（二）

1：上一章我们使用了register_chrdev这个函数来向内核注册字符设备

static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)

这个函数需要三个参数：主设备号、name、file_operations结构体

使用register_chrdev这个函数无法设置次设备号；

下面我们介绍一个新的函数：

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

这个函数也需要三个参数：设备号、同类设备的个数、name比如说我们led设备s5pv210中有4颗led设备，

我们led设备的主设备号可以设置为250，个数4个，name：led_dev

注意这里的参数from ，因为主设备号与次设备号在linux内核中共同组成一个4字节的int类型的数，第16位或者其它为次设备号，高16位或者其它为主设备号；

linux内核为我们提供了三个宏来确定from、主设备号、次设备号

MKDEV、MAJOR、NIMOR，这么是这三个宏在linux内核中定义的用法：

#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

比如说我们的主设备号为250 第一个次设备号为0，那么from应该赋值的参数为MKDEV(250, 0)

知道dev的话 主设备号为 MAJOR(dev)、次设备号为：MINOR(dev)

这个函数中只设置了主设备号、次设备号、与name还没有绑定file_operations结构体，所以我们还需要一个函数来把主设备号，与file_operations绑定起来；

这里就要用到：cdev、cdev_alloc、cdv_init、cdev_add、cdev_del 

cdev类型是下面这个结构体中，两个变量很重要一个是dev_t dev设备号，file_operations

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 *, const struct file_operations *);

cdev_init函数，这个函数是吧cdev与我们写的file_operations绑定起来完成注册；

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_add函数，这个函数才是真正的注册函数

这个函数有三个参数：cdev的结构体指针，dev设备号，count几个设备；

int cdev_add(struct cdev *p, dev_t dev, unsigned count)

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
p->dev = dev;
p->count = count;
return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}

以上几个是驱动设备注册的几个函数；

下面要到设备的注销，也是分两步的

涉及到两个函数：

cdev_del这个函数只需要一个参数就是cdev指针

void cdev_del(struct cdev *p)
{
cdev_unmap(p->dev, p->count);
kobject_put(&p->kobj);
}

unregister_chrdev_region函数

这个函数需要两个参数一个是设备号，一个是注册的同类设备的个数

void unregister_chrdev_region(dev_t from, unsigned count)
{
dev_t to = from + count;
dev_t n, next;

for (n = from; n < to; n = next) {
next = MKDEV(MAJOR(n)+1, 0);
if (next > to)
next = to;
kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
}
上面为进行注册的必须要提前知道主设备号，

下面我们来进行一下代码实战：

#include <linux/module.h>        // module_init  module_exit
#include <linux/init.h>            // __init   __exit
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <plat/map-base.h>
#include <plat/map-s5p.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/ioport.h>
#include <linux/string.h>
#include <asm/io.h>
#include <linux/cdev.h>

//#define MYMAJOR            200
//#define MYNAME            "LED_DEVICE"
#define MYDEV             250
#define LED_COUNT        1



#define GPJ0_PA_base        0xE0200240        
#define GPJ0CON_PA_OFFSET    0x0


struct cdev my_led_cdev;

unsigned int *pGPJ0CON;
unsigned int *pGPJ0DAT;



static char kbuf[100];
static int mymojor;

static int led_dev_open(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "led_dev open
");
    
    return 0;
}

static int led_dev_release(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "led_dev close
");
    
    return 0;
}

ssize_t led_dev_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    int ret = -1;
        
    ret = copy_to_user(buf, kbuf, sizeof(kbuf));
    if(ret) {
        printk(KERN_ERR "kernel led read error
");
    }
    printk(KERN_INFO "led device read success
");
}

static ssize_t led_dev_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos)
{
    int ret = -1;
    
    //首先把kbuf清零
    memset(kbuf, 0, sizeof(kbuf));
    
    ret = copy_from_user(kbuf, user_buf, count);
    if(ret) {
        printk(KERN_ERR "kernel led write error
");
        return -EINVAL;
    }
    
    printk(KERN_INFO "led device write success
");
    
    if (kbuf[0] == '1') {
        *pGPJ0CON = 0x11111111;
        *(pGPJ0CON + 1) = ((0<<3) | (0<<4) | (0<<5));
    }
    
    if (kbuf[0] == '0') {
        *(pGPJ0CON + 1) = ((1<<3) | (1<<4) | (1<<5));
    }
    
    return 0;
}

static const struct file_operations led_dev_fops = {
    .open = led_dev_open,
    .write = led_dev_write,
    .read = led_dev_read,    
    .release = led_dev_release,
    .owner = THIS_MODULE,
};





// 模块安装函数
static int __init leddev_init(void)
{    
    int err = 0;
    printk(KERN_INFO "led_device init
");
    
    
    //在这里进行注册驱动，因为安装驱动实际上执行的就是这个函数；
    err = register_chrdev_region(MKDEV(MYDEV,0), LED_COUNT, "MY_LED_DEV");
    
    if(err)
    {
        printk(KERN_ERR " register_chrdev_region failed
");
        
        return -EINVAL;
    }
    
    printk(KERN_INFO "leddev_dev regist success
");
    
    cdev_init(&my_led_cdev, &led_dev_fops);
    
    cdev_add(&my_led_cdev, MKDEV(MYDEV,0), LED_COUNT);
    
    
    if(!request_mem_region(GPJ0_PA_base + GPJ0CON_PA_OFFSET, 8, "GPJ0PABAST")) {
        return -EINVAL;
    }
    
    pGPJ0CON = ioremap(GPJ0_PA_base + GPJ0CON_PA_OFFSET, 4);
        
    return 0;
}

// 模块下载函数
static void __exit leddev_exit(void)
{
    printk(KERN_INFO "leddev_dev  exit
");
    
    //注销led设备驱动
    cdev_del(&my_led_cdev);
    
    unregister_chrdev_region(MKDEV(MYDEV,0), LED_COUNT);
    
    iounmap(GPJ0_PA_base + GPJ0CON_PA_OFFSET);
    
    release_mem_region(GPJ0_PA_base + GPJ0CON_PA_OFFSET, 8);
    
    printk(KERN_INFO "leddev_dev  unregist success
");

    
}


module_init(leddev_init);
module_exit(leddev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");                // 描述模块的许可证
MODULE_AUTHOR("bhc");                // 描述模块的作者
MODULE_DESCRIPTION("led test");    // 描述模块的介绍信息
MODULE_ALIAS("alias xxx");            // 描述模块的别名信息

上面使用到的函数：

这里关于cdev_init在内核中的具体实现可以参考下面这篇博客

linux内核cdev_init系列函数（字符设备的注册）

module_init：

　　register_chrdev_region

　　cdev_init

　　cdev_add

module_exit

　　cdev_del

　　unregister_chrdev_region

中间层：

　　file_operations

　　mknod /dev/led1 c 250 0

　　mknod /dev/led1 c 250 1

　　mknod /dev/led1 c 250 2

　　mknod /dev/led1 c 250  3

 这里注意安装驱动以后，设备文件没有自动创建需要我们手动来创建；

下面我们介绍一下自动分配设备号的注册函数：

alloc_chrdev_regio

这个函数需要4个参数：把dev_t dev的地址传进去，次设备号的最小值一般为0，几个设备，名字 四个参数

int alloc_chrdev_region(dev_t *dev, unsigned 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;
}

测试代码如下：

// 模块安装函数
static int __init leddev_init(void)
{    
    int err = 0;
    printk(KERN_INFO "led_device init
");
    
    
    //在这里进行注册驱动，因为安装驱动实际上执行的就是这个函数；
    err = alloc_chrdev_region(&mydev, 0, LED_COUNT, "MY_LED_DEV");
    
    if(err)
    {
        printk(KERN_ERR " register_chrdev_region failed
");
        
        return -EINVAL;
    }
    
    printk(KERN_INFO "leddev_dev regist success
");
    
    printk(KERN_INFO "major device NO. is %u,
", MAJOR(mydev));
    printk(KERN_INFO "minor device NO. is %u,
", MINOR(mydev));
    
    cdev_init(&my_led_cdev, &led_dev_fops);
    
    cdev_add(&my_led_cdev, mydev, LED_COUNT);
    
    
    if(!request_mem_region(GPJ0_PA_base + GPJ0CON_PA_OFFSET, 8, "GPJ0PABAST")) {
        return -EINVAL;
    }
    
    pGPJ0CON = ioremap(GPJ0_PA_base + GPJ0CON_PA_OFFSET, 4);
        
    return 0;
}

// 模块下载函数
static void __exit leddev_exit(void)
{
    printk(KERN_INFO "leddev_dev  exit
");
    
    //注销led设备驱动
    cdev_del(&my_led_cdev);
    
    unregister_chrdev_region(mydev, LED_COUNT);
    
    iounmap(GPJ0_PA_base + GPJ0CON_PA_OFFSET);
    
    release_mem_region(GPJ0_PA_base + GPJ0CON_PA_OFFSET, 8);
    
    printk(KERN_INFO "leddev_dev  unregist success
");

    
}


module_init(leddev_init);
module_exit(leddev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");                // 描述模块的许可证
MODULE_AUTHOR("bhc");                // 描述模块的作者
MODULE_DESCRIPTION("led test");    // 描述模块的介绍信息
MODULE_ALIAS("alias xxx");            // 描述模块的别名信息

cdev_alloc函数：

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;
}

cdev_alloc函数用来自动分配内存空间，并初始化链表；

module_exit的时候用 cdev_del来释放就可以；

这里要注意到cdev_alloc分配一段内存，

void cdev_del(struct cdev *p)
{
cdev_unmap(p->dev, p->count);
kobject_put(&p->kobj);
}

static void cdev_unmap(dev_t dev, unsigned count)
{
kobj_unmap(cdev_map, dev, count);
}

void kobj_unmap(struct kobj_map *domain, dev_t dev, unsigned long range)
{
unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;
unsigned index = MAJOR(dev);
unsigned i;
struct probe *found = NULL;

if (n > 255)
n = 255;

mutex_lock(domain->lock);
for (i = 0; i < n; i++, index++) {
struct probe **s;
for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) {
struct probe *p = *s;
if (p->dev == dev && p->range == range) {
*s = p->next;
if (!found)
found = p;
break;
}
}
}
mutex_unlock(domain->lock);
kfree(found);

中调用的

cdev_del

　　cdev_unmap 

　　　　kobj_unmap

　　　　　　kfree

cdev_del中调用cdev_unmap在调用kobj_unmap在调用kfree来释放我们用cdev_alloc申请的这段内存，所以卸载模块的时候不用自己来释放这段内存了；

还有一般用　　cdev_alloc的时候直接

pcdev->owner = THIS_MODULE;

pcdev->opt = &led_dev_fops; 有时候用这两句来代替cdev_init函数；