嵌入式Linux系統：驅動編程_註冊字符設備驅動並生成設備節點

註冊字符設備驅動並生成設備節點的步驟：

 

1、註冊字符類設備號（註冊字符類設備號見博文：嵌入式Linux系統：驅動編程_註冊字符類設備號 ）；

        加載模塊時若通過“numdev_major”、“numdev_minor”傳入參數則靜態註冊字符類設備號；否則動態註冊字符類設備號（驅動模塊傳參數見博文：嵌入式Linux系統：驅動編程_驅動模塊傳參數 ）。

 

參考：

 

 

2、定義並初始化file_operations結構體；

 

參考：

 

 

3、註冊字符設備（分配內存空間、字符設備註冊）；

        前面介紹的雜項設備並沒有分配內存空間這個過程，是因爲系統自帶的代碼已經給雜項設備分配好了。Linux 中註冊字符類設備需要首先申請內存空間，有一個專門分配小內存空間的函數kmalloc，這個函數在頭文件“include/linux/slab.h”中。

        字符類設備的初始化函數爲 cdev_init，註冊函數爲 cdev_add，這兩個函數在頭文件“include/linux/cdev.h”中。

 

將申請的內存數據控件打個包爲結構體 reg_dev，因爲是有兩個子設備，所以接着定義一個結構體數組*my_devices。
 

 

然後申請內存空間，並將內存空間先清零，接着對設備進行初始化

 

添加模塊出口函數的代碼

 

參考：

 

4、創建設備類及設備節點；

        Linux 中的 class 是設備類，它是一個抽象的概念，沒有對應的實體。它是提供給用戶接口相似的一類設備的集合。常見的有輸入子系統 input、usb、串口 tty、塊設備 block 等。以 4412 的串口爲例，它有四個串口，不可能爲每一個串口都重複申請設備以及設備節點，因爲它們有類似的地方，而且很多代碼都是重複的地方，所以引入了一個抽象的類，將其打包爲 ttySACX，在實際調用串口的時候，只需要修改 X 值，就可以調用不同的串口。對於本實驗中的設備，它有兩個子設備，將對應兩個設備節點，所以需要用到 class 類這樣一個概念。

 

在初始化函數中添加申請設備類以及創建設備節點的代碼

 

退出函數中添加釋放設備以及釋放內存的代碼

 

 

        如下，是完整的註冊字符設備驅動並生成設備節點的程序：char_driver.c

        以下代碼的功能是生成class“chardevnode”(使用命令“ls /sys/class/”可以查看)，生成設備節點“chardevnode1”、“chardevnode2”（使用命令“ls /dev”可以查看）。

/*包含初始化宏定義的頭文件,代碼中的module_init和module_exit在此文件中*/
#include <linux/init.h>
/*包含初始化加載模塊的頭文件,代碼中的MODULE_LICENSE在此頭文件中*/
#include <linux/module.h>
/*定義module_param module_param_array的頭文件*/
#include <linux/moduleparam.h>
/*定義module_param module_param_array中perm的頭文件*/
#include <linux/stat.h>
/*三個字符設備函數*/
#include <linux/fs.h>
/*MKDEV轉換設備號數據類型的宏定義*/
#include <linux/kdev_t.h>
/*定義字符設備的結構體*/
#include <linux/cdev.h>
/*分配內存空間函數頭文件*/
#include <linux/slab.h>

/*包含函數device_create 結構體class等頭文件*/
#include <linux/device.h>

#define DEVICE_NAME "chardevnode"
#define DEVICE_MINOR_NUM 2
#define DEV_MAJOR 0
#define DEV_MINOR 0
#define REGDEV_SIZE 3000

MODULE_LICENSE("Dual BSD/GPL");
/*聲明是開源的，沒有內核版本限制*/
MODULE_AUTHOR("iTOPEET_dz");
/*聲明作者*/

int numdev_major = DEV_MAJOR;
int numdev_minor = DEV_MINOR;

/*輸入主設備號*/
module_param(numdev_major,int,S_IRUSR);
/*輸入次設備號*/
module_param(numdev_minor,int,S_IRUSR);

static struct class *myclass;

struct reg_dev
{
	char *data;
	unsigned long size;
	
	struct cdev cdev;
};
struct reg_dev *my_devices;
/*打開操作*/
static int chardevnode_open(struct inode *inode, struct file *file){
	printk(KERN_EMERG "chardevnode_open is success!\n");
	
	return 0;
}
/*關閉操作*/
static int chardevnode_release(struct inode *inode, struct file *file){
	printk(KERN_EMERG "chardevnode_release is success!\n");
	
	return 0;
}
/*IO操作*/
static long chardevnode_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
	printk(KERN_EMERG "chardevnode_ioctl is success! cmd is %d,arg is %d \n",cmd,arg);
	
	return 0;
}

ssize_t chardevnode_read(struct file *file, char __user *buf, size_t count, loff_t *f_ops){
	return 0;
}

ssize_t chardevnode_write(struct file *file, const char __user *buf, size_t count, loff_t *f_ops){
	return 0;
}

loff_t chardevnode_llseek(struct file *file, loff_t offset, int ence){
	return 0;
}
struct file_operations my_fops = {
	.owner = THIS_MODULE,
	.open = chardevnode_open,
	.release = chardevnode_release,
	.unlocked_ioctl = chardevnode_ioctl,
	.read = chardevnode_read,
	.write = chardevnode_write,
	.llseek = chardevnode_llseek,
};


/*設備註冊到系統*/
static void reg_init_cdev(struct reg_dev *dev,int index){
	int err;
	int devno = MKDEV(numdev_major,numdev_minor+index);
	
	/*數據初始化*/
	cdev_init(&dev->cdev,&my_fops);
	dev->cdev.owner = THIS_MODULE;
	dev->cdev.ops = &my_fops;
	
	/*註冊到系統*/
	err = cdev_add(&dev->cdev,devno,1);
	if(err){
		printk(KERN_EMERG "cdev_add %d is fail! %d\n",index,err);
	}
	else{
		printk(KERN_EMERG "cdev_add %d is success!\n",numdev_minor+index);
	}
}

static int scdev_init(void)
{
	int ret = 0,i;
	dev_t num_dev;
	
	
	printk(KERN_EMERG "numdev_major is %d!\n",numdev_major);
	printk(KERN_EMERG "numdev_minor is %d!\n",numdev_minor);
	
	if(numdev_major){
		num_dev = MKDEV(numdev_major,numdev_minor);
		ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NAME);
	}
	else{
		/*動態註冊設備號*/
		ret = alloc_chrdev_region(&num_dev,numdev_minor,DEVICE_MINOR_NUM,DEVICE_NAME);
		/*獲得主設備號*/
		numdev_major = MAJOR(num_dev);
		printk(KERN_EMERG "adev_region req %d !\n",numdev_major);
	}
	if(ret<0){
		printk(KERN_EMERG "register_chrdev_region req %d is failed!\n",numdev_major);		
	}
	myclass = class_create(THIS_MODULE,DEVICE_NAME);
	
	
	my_devices = kmalloc(DEVICE_MINOR_NUM * sizeof(struct reg_dev),GFP_KERNEL);
	if(!my_devices){
		ret = -ENOMEM;
		goto fail;
	}
	memset(my_devices,0,DEVICE_MINOR_NUM * sizeof(struct reg_dev));
	
	/*設備初始化*/
	for(i=0;i<DEVICE_MINOR_NUM;i++){
		my_devices[i].data = kmalloc(REGDEV_SIZE,GFP_KERNEL);
		memset(my_devices[i].data,0,REGDEV_SIZE);
		/*設備註冊到系統*/
		reg_init_cdev(&my_devices[i],i);
		
		/*創建設備節點*/
		device_create(myclass,NULL,MKDEV(numdev_major,numdev_minor+i),NULL,DEVICE_NAME"%d",i);
	}
	
		
	printk(KERN_EMERG "scdev_init!\n");
	/*打印信息，KERN_EMERG表示緊急信息*/
	return 0;

fail:
	/*註銷設備號*/
	unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
	printk(KERN_EMERG "kmalloc is fail!\n");
	
	return ret;
}

static void scdev_exit(void)
{
	int i;
	printk(KERN_EMERG "scdev_exit!\n");
	
	/*除去字符設備*/
	for(i=0;i<DEVICE_MINOR_NUM;i++){
		cdev_del(&(my_devices[i].cdev));
		/*摧毀設備節點函數d*/
		device_destroy(myclass,MKDEV(numdev_major,numdev_minor+i));
	}
	/*釋放設備class*/
	class_destroy(myclass);
	/*釋放內存*/
	kfree(my_devices);
	
	unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
}


module_init(scdev_init);
/*初始化函數*/
module_exit(scdev_exit);
/*卸載函數*/

編寫簡單的應用程序invoke_char_driver.c測試驅動。

 

        將生成的驅動模塊“char_driver.ko”以及應用“invoke_char_driver”拷貝到 U 盤。啓動開發板，將 U 盤插入開發板，使用命令“mount /dev/sda1 /mnt/udisk/”加載 U盤。使用命令“insmod /mnt/udisk/char_driver.ko”加載驅動模塊。

 

        使用命令“./mnt/udisk/invoke_char_driver”運行應用，調用驅動模塊生成的設備節點，如下圖所示，可以看到兩個設備節點都可以正常打開，說明驅動底層的 open 函數可以正常使用。