/*** alloc_chrdev_region() - register a range of char device numbers* @dev: output parameter for first assigned number* @baseminor: first of the requested range of minor numbers* @count: the number of minor numbers required* @name: the name of the associated device or driver** Allocates a range of char device numbers.  The major number will be* chosen dynamically, and returned (along with the first minor number)* in @dev.  Returns zero or a negative error code.*/
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)

/*** register_chrdev_region() - register a range of device numbers* @from: the first in the desired range of device numbers; must include*        the major number.* @count: the number of consecutive device numbers required* @name: the name of the device or driver.** Return value is zero on success, a negative error code on failure.*/
int register_chrdev_region(dev_t from, unsigned count, const char *name)

/*** unregister_chrdev_region() - return a range of device numbers* @from: the first in the range of numbers to unregister* @count: the number of device numbers to unregister** This function will unregister a range of @count device numbers,* starting with @from.  The caller should normally be the one who* allocated those numbers in the first place...*/
void unregister_chrdev_region(dev_t from, unsigned count)

功能:分配一个表示字符设备的cdev结构体。

函数原型:

/*** cdev_alloc() - allocate a cdev structure** Allocates and returns a cdev structure, or NULL on failure.*/
struct cdev *cdev_alloc(void)

5.cdev_init()

功能:初始化由cdev_alloc()分配的表示字符设备的cdev结构体，并通过向该函数传入的struct file_operations *fops参数来指定该字符设备的文件操作函数。

函数原型:

/*** cdev_init() - initialize a cdev structure* @cdev: the structure to initialize* @fops: the file_operations for this device** Initializes @cdev, remembering @fops, making it ready to add to the* system with cdev_add().*/
void cdev_init(struct cdev *cdev, const struct file_operations *fops)

功能:添加一个(由cdev_alloc()分配并通过cdev_init()初始化的)字符设备到系统中。

函数原型:

/*** cdev_add() - add a char device to the system* @p: the cdev structure for the device* @dev: the first device number for which this device is responsible* @count: the number of consecutive minor numbers corresponding to this*         device** cdev_add() adds the device represented by @p to the system, making it* live immediately.  A negative error code is returned on failure.*/
int cdev_add(struct cdev *p, dev_t dev, unsigned count)

7.cdev_del()

功能:执行和cdev_add()相反的操作，将一个指定的字符设备从系统中删除。

函数原型:

/*** cdev_del() - remove a cdev from the system* @p: the cdev structure to be removed** cdev_del() removes @p from the system, possibly freeing the structure* itself.*/
void cdev_del(struct cdev *p)

以下为一个简单的字符设备初始化函数，函数中列出了向系统中添加一个字符设备的简单步骤:

struct cdev *myDev_dev;
/*主设备和从设备号变量*/
static int myDev_major = 0;
static int myDev_minor = 0;static int __init myDev_init(void)
{ int err = -1;dev_t dev = 0;/*1.动态分配主设备号和从设备号,第三个参数表示分配的此设备号的数量*/err = alloc_chrdev_region(&dev, 0, TOTAL_DEVICE_COUNT, "myDev");if(err < 0) {printk(KERN_ALERT"Failed to alloc char dev region.\n");return err;}myDev_major = MAJOR(dev);myDev_minor = MINOR(dev);        /*2.分配cdev字符设备结构体变量*/myDev_dev = cdev_alloc();if(!myDev_dev) {err = -ENOMEM;printk(KERN_ALERT"Failed to alloc myDev_dev.\n");return err;}        /*3.初始化cdev字符设备结构体*/cdev_init(myDev_dev, &myDev_fops); /*4.添加字符设备到系统中*/err = cdev_add(myDev_dev,dev, TOTAL_DEVICE_COUNT);if(err) {return err;}              return err;
}

8.register_chrdev()

自动创建设备节点相关函数

功能:创建一个struct class结构体，作为device_create()函数的参数。

函数原型:

#define class_create(owner, name)     \
({                      \static struct lock_class_key __key;    \__class_create(owner, name, &__key);   \
})

2.device_create()

功能:该函数创建一个设备并将其注册到sysfs中，同时在系统的sys/class和sys/device目录下会生成相应的类和设备入口。并且，该函数还会出发用户空间udev的动作，udev会根据sysfs下的class在/dev目录下创建设备节点，这也为自动创建设备节点提供了一种途径。通过device_create()函数，我们就可以不用通过mknod命令手动的创建设备节点了。

函数原型:

/*** device_create - creates a device and registers it with sysfs* @class: pointer to the struct class that this device should be registered to* @parent: pointer to the parent struct device of this new device, if any* @devt: the dev_t for the char device to be added* @drvdata: the data to be added to the device for callbacks* @fmt: string for the device's name** This function can be used by char device classes.  A struct device* will be created in sysfs, registered to the specified class.** A "dev" file will be created, showing the dev_t for the device, if* the dev_t is not 0,0.* If a pointer to a parent struct device is passed in, the newly created* struct device will be a child of that device in sysfs.* The pointer to the struct device will be returned from the call.* Any further sysfs files that might be required can be created using this* pointer.** Returns &struct device pointer on success, or ERR_PTR() on error.** Note: the struct class passed to this function must have previously* been created with a call to class_create().*/
struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)

3.device_create_file()

功能:该函数用于为指定设备在sysfs下建立属性文件，如：
device_create_file(dev, &dev_attr_val);

其中的dev_attr_val可以通过DEVICE_ATTR宏进行定义，也可以直接通过struct device_attribute xxx=__ATTR(_name,_mode,_show,_store)进行定义，区别就是用DEVICE_ATTR宏进行定义时得到的变量名都是以dev_attr_为前缀的，而通过struct device_attribute xxx=__ATTR(_name,_mode,_show,_store)进行定义时，变量名可以任意指定。建立属性文件之后，我们就可以通过属性文件对设备的属性进行配置和读取了，这也是应用程序和设备（驱动程序）进行信息交互的一种方式。

函数原型:

/*** device_create_file - create sysfs attribute file for device.* @dev: device.* @attr: device attribute descriptor.*/int device_create_file(struct device *dev,const struct device_attribute *attr)#define DEVICE_ATTR(_name, _mode, _show, _store) \
struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)

如下代码可以实现自动创建设备节点:

   static struct class* myDev_class = NULL;struct device* devc= NULL;      /*5.创建一个struct class结构体*/myDev_class = class_create(THIS_MODULE,"myDevClass");if(IS_ERR(myDev_class)) {err = PTR_ERR(myDev_class);printk(KERN_ALERT"Failed to create  class.\n");return err;}        /*6.在sysf中生成设备文件并在/dev下自动生成设备节点*/devc = device_create(myDev_class,NULL,dev,NULL,"myDev");if(IS_ERR(devc)) {err = PTR_ERR(devc);printk(KERN_ALERT"Failed to create device.");return err;}   

以下贴出以上分两部分介绍的字符设备的初始化代码:

struct cdev *myDev_dev;
/*主设备号和从设备号变量*/
static int myDev_major = 0;
static int myDev_minor = 0;static int __init myDev_init(void)
{ int err = -1;dev_t dev = 0;struct device *devc = NULL;/* 1.动态分配主设备号和从设备号,第三个参数表示分配的次设备号的数量 */err = alloc_chrdev_region(&dev, 0, TOTAL_DEVICE_COUNT, "myDev");if(err < 0) {printk(KERN_ALERT"Failed to alloc char dev region.\n");return err;}myDev_major = MAJOR(dev);myDev_minor = MINOR(dev);        /* 2.分配cdev字符设备结构体变量 */myDev_dev = cdev_alloc();if(!myDev_dev) {err = -ENOMEM;printk(KERN_ALERT"Failed to alloc myDev_dev.\n");return err;}        /* 3.初始化cdev字符设备结构体 */cdev_init(myDev_dev, &myDev_fops); /* 4.添加字符设备到系统中 */err = cdev_add(myDev_dev,dev, TOTAL_DEVICE_COUNT);if(err) {return err;}              /* 5.创建一个struct class结构体 */myDev_class = class_create(THIS_MODULE,"myDevClass");if(IS_ERR(myDev_class)) {err = PTR_ERR(myDev_class);printk(KERN_ALERT"Failed to create  class.\n");return err;}        /* 6.在sysf中生成设备文件并在/dev下自动生成设备节点 */devc = device_create(myDev_class,NULL,dev,NULL,"myDev");if(IS_ERR(devc)) {err = PTR_ERR(devc);printk(KERN_ALERT"Failed to create device.");return err;}    return err;
}

通用函数

/*** kzalloc - allocate memory. The memory is set to zero.* @size: how many bytes of memory are required.* @flags: the type of memory to allocate (see kmalloc).*/
static inline void *kzalloc(size_t size, gfp_t flags)
{return kmalloc(size, flags | __GFP_ZERO);
}

/* module_platform_driver() - Helper macro for drivers that don't do* anything special in module init/exit.  This eliminates a lot of* boilerplate.  Each module may only use this macro once, and* calling it replaces module_init() and module_exit()*/
#define module_platform_driver(__platform_driver) \module_driver(__platform_driver, platform_driver_register, \platform_driver_unregister)

/*** module_driver() - Helper macro for drivers that don't do anything* special in module init/exit. This eliminates a lot of boilerplate.* Each module may only use this macro once, and calling it replaces* module_init() and module_exit().** @__driver: driver name* @__register: register function for this driver type* @__unregister: unregister function for this driver type* @...: Additional arguments to be passed to __register and __unregister.** Use this macro to construct bus specific macros for registering* drivers, and do not use it on its own.*/
#define module_driver(__driver, __register, __unregister, ...) \
static int __init __driver##_init(void) \
{ \return __register(&(__driver) , ##__VA_ARGS__); \
} \
module_init(__driver##_init); \
static void __exit __driver##_exit(void) \
{ \__unregister(&(__driver) , ##__VA_ARGS__); \
} \
module_exit(__driver##_exit);

该函数其实是一个宏，定义于include/linux/kernel.h，如下所示：

/*** container_of - cast a member of a structure out to the containing structure* @ptr:   the pointer to the member.* @type:  the type of the container struct this is embedded in.* @member: the name of the member within the struct.**/
#define container_of(ptr, type, member) ({          \const typeof( ((type *)0)->member ) *__mptr = (ptr);    \(type *)( (char *)__mptr - offsetof(type,member) );})

#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif

该宏定义的功能是，通过结构体某一个已知成员的指针（成员变量的地址），反向计算出该结构体的地址。其原理也很简单，就是用已知成员变量的地址，减去该成员变量在结构体中的偏移量。

这个功能在kernel编程中十分有用。举一个简单的例子，如下：

struct child_struct
{int m;int n;
};struct parent_struct
{int a;int b;struct child_struct c;
};struct parent_struct test;int *address = &test.c.n;
struct parent_struct *test_addr = container_of(address,struct parent_struct,c.n);通过上述语句，获取到的就是test变量的地址。

注意：需要注意的是，在使用container_of()宏来获取父结构体的地址时，一定不要用指针类型的成员变量进行计算。
因为指针类型的成员变量本身就是用来保存一个地址，并且该地址是不确定的，它可以被赋值成任意值，因此不能用来计算父结构体的地址。