继上一篇驱动入门的进一步深入
*********************
注册字符设备驱动新接口
老接口：
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函数，也可以直接实例化
*************
解决每次需要手动增添设备文件的不足：
手动添加设备文件：
root@sugar /root# mknod /dev/test c 250 0
解决方案：
udev（嵌入式中使用mdev）
udev 是 Linux 系统中的一个子系统，用于管理设备事件。
mdev ：
BusyBox 提供的轻量级设备管理工具，相当于精简版的 udev。
rootfs中Etc/init.d/rcS文件
echo /sbin/mdev > /proc/sys/kernel/hotplug
mdev -s
echo /sbin/mdev > /proc/sys/kernel/hotplug
mdev -s
作用：初始化 /dev 目录下的设备节点。
原理：
-s 参数让 mdev 扫描 /sys 文件系统，根据当前已连接的硬件信息，
在 /dev 目录下动态创建设备节点（如 /dev/sda、/dev/ttyUSB0 等）
作用：将 /sbin/mdev 设置为内核的 热插拔事件处理程序。
补充：
/proc/sys/kernel/hotplug 的特殊性：
该文件存在于内存中（procfs），重启后失效，
需在启动脚本（如 /etc/rc.local）中持久化配置
完整 Linux 系统通常使用 udev 或 systemd-udevd，
但 mdev 更适合资源受限的嵌入式环境
总结：
这两条命令共同实现了 设备节点的动态创建/删除，
是嵌入式 Linux 自动识别硬件的基础
udev是应用层的一个应用程序
内核驱动和应用层udev之间有一套信息传输机制（netlink协议）
应用层启动udev，内核驱动中使用相应接口
驱动注册和注销时信息会传给udev，由udev在应用层进行设备
文件的创建和删除
使用相关函数添加设备文件：
1、class_create
//源定义源函数
static struct class *adb_dev_class;
#define class_create(owner, name) \
({ \
static struct lock_class_key __key; \
__class_create(owner, name, &__key); \
})
owner：fos中的owner，指定类的所有者是哪个模块
name：自定义的class名字
//创建类
test_dev_class = class_create(THIS_MODULE, "sugar_class");
if (IS_ERR(test_dev_class))
return -EINVAL;
//结束时销毁
void class_destroy(struct class *cls)
{
if ((cls == NULL) || (IS_ERR(cls)))
return;
class_unregister(cls);
}
class_destroy(test_dev_class);
2、device_create
//设备文件创建，就是mknod 创建的文件名
struct device *device_create(struct class *class, struct device *parent,
dev_t devt, void *drvdata, const char *fmt, ...)
{
va_list vargs;
struct device *dev;
va_start(vargs, fmt);
dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
va_end(vargs);
return dev;
}
device_create(test_dev_class, NULL, dev_id, NULL, "test");
void device_destroy(struct class *class, dev_t devt)
{
struct device *dev;
dev = class_find_device(class, NULL, &devt, __match_devt);
if (dev) {
put_device(dev);
device_unregister(dev);
}
}
device_destroy(test_dev_class,dev_id);
************************
上面的使用就是一个设备类的创建，
类中的一个设备文件的创建（就是mknod创建的设备文件的名字）
结合：
创建：
class_create（）
device_create（）
销毁：
device_destroy（）
class_destroy（）
*********************
成功现象：
root@sugar /root# insmod module_test.ko
39.180515 major = 250, minor = 0.
root@sugar /root# lsmod
Not tainted
module_test 2102 0 - Live 0xbf000000
root@sugar /root# ls /dev/test -l
crw-rw---- 1 root 0 250, 0 Jan 1 12:00 /dev/test
root@sugar /root# ./app
直接安装执行，不需要再手动mknod创建设备文件
insmod后直接查看也可以查看到device_destroy中输入的test文件
******************
查看创建的class
root@sugar /sys# cd class/
root@sugar class# ls
sugar_class
root@sugar class# cd sugar_class/
root@sugar sugar_class# ls
test
root@sugar sugar_class# cd test/
root@sugar test# ls
dev power subsystem uevent
用cat查看，可以查看里面的相关信息
root@sugar test# cat uevent
MAJOR=250
MINOR=0
DEVNAME=test
root@sugar test# cat dev
250:0
函数代码分析：
class_create（）
__class_create(owner, name, &__key); //实际调用
cls = kzalloc(sizeof(*cls), GFP_KERNEL);//申请堆内存
__class_register //注册
cp = kzalloc(sizeof(*cp), GFP_KERNEL);
kset_register
kobject_uevent
struct kobject *kobj //输出型参数，作为返回值
返回的就是kobject结构体的相应参数
struct kobject {
const char *name;
struct list_head entry;
struct kobject *parent;
struct kset *kset;
struct kobj_type *ktype;
struct sysfs_dirent *sd;
struct kref kref;
unsigned int state_initialized:1;
unsigned int state_in_sysfs:1;
unsigned int state_add_uevent_sent:1;
unsigned int state_remove_uevent_sent:1;
unsigned int uevent_suppress:1;
};
kfree(cls);
device_create（）
device_create_vargs
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
dev->devt = devt;
dev->class = class;
dev->parent = parent;
dev->release = device_create_release;
dev_set_drvdata(dev, drvdata);
kobject_set_name_vargs
device_register
device_initialize
device_add
kobject_add
device_create_file
device_create_sys_dev_entry
devtmpfs_create_node
device_add_class_symlinks
device_add_attrs
bus_add_device
dpm_sysfs_add
device_pm_add //power management
kobject_uevent //输出结构体相关参数
kfree(dev->p);
*************************
以上就是两个类和设备文件的函数分析
***********************
新旧字符设备号的注册：
register_chrdev
register_chrdev_region/alloc_chrdev_region
register_chrdev
__register_chrdev(major, 0, 256, name, fops);//实际调用
__register_chrdev_region(major, baseminor, count, name);
if (major == 0) {
for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
if (chrdevsi == NULL)
break;
}//这里的处理就是解释到为什么设备号的分配从后往前分配
register_chrdev_region
__register_chrdev_region(MAJOR(n), MINOR(n),
next - n, name);
alloc_chrdev_region
__register_chrdev_region(0, baseminor, count, name);
总结：
实际上，三个都是调用的__register_chrdev_region这个函数，
只不过是里面的传进去的参数的定义不同
新的这个两个主要是设备号定义，为0
旧的是无法定义子设备号
*************************
静态页表的分析：
之前对寄存器的操作有：
静态映射、动态映射两种方法
静态映射：
使用的就是自定义好的寄存器地址相关的虚拟地址
其中，涉及到的一个就是静态映射表，
有了这个表才能实现一段物理地址到虚拟地址的映射关系
1、映射表涉及到的物理地址和虚拟地址的值的相关宏定义
2、映射表的建立函数
/kernel/arch/arm/mach-s5pv210/mach-smdkc110.c
smdkc110_map_io
s5p_init_io(NULL, 0, S5P_VA_CHIPID);
iotable_init(s5p_iodesc, ARRAY_SIZE(s5p_iodesc));
create_mapping
上面函数涉及到的就是io表的初始化，创建映射
iotable_init中涉及到的映射有s5p_iodesc
这是一个结构体数组，数组中的每一个元素就是一个映射，
描述了一段物理地址到虚拟地址之间的映射
表中记录的这些映射关系被iotable_init调用，这个函数负责将这个结构体
数组格式的表建立称MMU所能识别的页表映射关系，这样开机后就可以直接
使用对应的虚拟地址访问对应的物理地址
其中，页表显示都是4k、8k、16k...
arch/arm/plat-s5p/cpu.c
映射表对应的结构体数组：
/* Initial IO mappings */
static struct map_desc s5p_iodesc\[\] __initdata = {
{
{
.virtual = (unsigned long)S5P_VA_GPIO,
.pfn = __phys_to_pfn(S5P_PA_GPIO),
.length = SZ_4K,
.type = MT_DEVICE,
},
这块就是我们要操作的gpio对应的映射关系转换模块
还有一个问题，就是开机时调用映射表建立函数
开机时（kernel启动时）smdkc110_map_io怎么被调用的
start_kernel（main.c）
setup_arch（573）
paging_init
devicemaps_init
/*
* Ask the machine support to map in the statically mapped devices.
*/
if (mdesc->map_io)
mdesc->map_io();
************************
动态映射
这里解决一个问题，就是动态映射对多个寄存器需要多次映射的问题
解决：
仿效真实驱动中，用结构体封装的方式来进行单次多个寄存器的地址映射
这样就可以不用多次进行单个寄存器的映射了
//定义一个结构体包含两个寄存器
typedef struct GPJ0REG{
volatile unsigned int gpj0_con;
volatile unsigned int gpj0_dat;
}gpj0_refs;
注意：
定义结构体不能用static，
如果我们在文件作用域内使用`static`关键字修饰一个结构体定义，
这是不允许的，编译器会报错。
因为结构体定义本身并不占用存储空间，它只是一个类型描述
还有，结构体内定义的变量不要与外部变量名字有冲突，否则有错
#define GPJ0_PA_BASE 0xe0200240
gpj0_refs *pGPJ0_REG;
//用两步完成动态映射
if (!request_mem_region(GPJ0_PA_BASE, sizeof(gpj0_refs), "GPJ0REG"))
return -EINVAL;
pGPJ0_REG=ioremap(GPJ0_PA_BASE, sizeof(gpj0_refs));
//销毁
iounmap(pGPJ0_REG);
release_mem_region(GPJ0_PA_BASE, sizeof(gpj0_refs));
**********************************
最后，是一个writel、readl函数
用来操作寄存器（当完成映射后）
writel（）
#define writel(b,addr) __raw_writel(__cpu_to_le32(b),addr)
__raw_writel
#define __raw_writel(v,a) (__chk_io_ptr(a), *(volatile unsigned int __force *)(a) = (v))
这个就是实际工作的函数
实质就是我们之前设置的一个定义即操作的寄存器地址+要进行的操作
#define rGPJ0CON *((volatile unsigned int *)S5PV210_GPJ0CON)
#define rGPJ0DAT *((volatile unsigned int *)S5PV210_GPJ0DAT)
#define GPJ0CON_PA 0xe0200240
static void __iomem *baseaddr; // 寄存器的虚拟地址的基地址
通过ioremap 得到虚拟地址
writel(0x11111111, baseaddr+0);
writel(((0<<3) | (0<<4) | (0<<5)), baseaddr+4);
iowrite32（）
#define iowrite32(v, addr) writel((v), (addr))
writel
实际就是上面的函数
************************
至此，可以完成一个led的驱动
其中，包括使用
1、新旧设备号注册函数、驱动的alloc申请（alloc_chrdev_region）
2、对test_cdev的一个操作，一个是用全局变量做全部的初始化，
一个使用一个全局指针，后面对齐实例化操作（替换一个cdev_init（）函数）
//static struct cdev test_cdev;
static struct cdev *test_cdev;
3、类的创建
目的就是不用手动mknod取创建设备文件
class_create
device_create
4、对动态映射的申请优化，使用一个指针接收虚拟地址映射，
可以用结构体定义其中的寄存器，亦可以自己在地址中加上相应的偏移量
request_mem_region
ioremap
5、对寄存器的操作
iowrite32
writel