OrgLion-Writes/DemoPublic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

misc 示例与 char 示例搞混了.

Browse Source 
Signed-off-by: ithink.chan <chenyang@autoai.com>
This commit is contained in:
ithink.chan 2020-04-28 14:46:23 +08:00
parent 27fabf3542
commit 8d435d912e
2 changed files with 178 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
Linux/KernelDriver/3.2/Misc/demo_misc.c
View File

@ -1,8 +1,23 @@
/**
* @file demo_char.c
* @file demo_misc.c
* @author Rick Chan (cy187lion@sina.com)
* @brief Linux char driver demo.
* @version 0.1.0
* @brief Linux misc driver demo.
在 Linux 驱动中，会把一些无法归类的设备定义为混杂设备，它们是拥
有着共同的特性的简单字符设备。它们的特点是共享统一的主设备号 10，
但每个设备可以选择一个单独的次设备号。
通常情况下，一个字符设备都不得不在初始化的过程中进行下面的步骤：
1.通过alloc_chrdev_region()分配主/次设备号
2.使用cdev_init()和cdev_add()来以一个字符设备注册自己
而一个misc驱动，则可以只用一个调用misc_register()来完成这所有
的步骤。
所有的 miscdevice 设备形成一个链表，对设备访问时，内核根据次设
备号查找对应的 miscdevice 设备，然后调用其 file_operations
中注册的文件操作方法进行操作。
* @version 0.1.1
* @date 2020-04-27
*
* @copyright Copyright (c) 2020
@ -11,13 +26,10 @@
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/device.h>
MODULE_AUTHOR("Rick Chan");
MODULE_LICENSE("GPL");
@ -29,32 +41,9 @@ MODULE_LICENSE("GPL");
#define DEMO_CTL_IOW _IOW(DEMO_MAGIC, 3, int32_t)
#define DEMO_CTL_IOWR _IOWR(DEMO_MAGIC, 4, uint32_t)
#define DEMO_CTL_MAX 5
#define DEMO_MODULE_NAME "demo_char"
#define DEMO_DEV_CNT 2
// This is a test.
#define DEMO_DATA_SIZE 5
static int demo_major = 0;
struct demo_dev
{
struct cdev cdev;
struct device *dev;
// This is a test.
char demo_text[DEMO_DATA_SIZE];
};
struct class *class;
struct demo_dev* demo_devp;
static int demo_open(struct inode *inode, struct file* filp)
{
struct demo_dev *demo;
demo = container_of(inode->i_cdev, struct demo_dev, cdev);
filp->private_data = demo;
return 0;
}
@ -65,92 +54,41 @@ static int demo_release(struct inode *inode, struct file* filp)
static loff_t demo_llseek(struct file *filp, loff_t offset, int origin)
{
struct demo_dev *devp = filp->private_data;
loff_t ret;
(void)devp;
// This is a test.
switch(origin)
{
case 0: // 从文件开头开始偏移
if(offset<0)
{
ret = -EINVAL;
break;
}
if((unsigned int)offset>DEMO_DATA_SIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1: // 从当前位置开始偏移
if((filp->f_pos+offset)>DEMO_DATA_SIZE)
{
ret = -EINVAL;
break;
}
if((filp->f_pos+offset)<0)
{
ret = -EINVAL;
break;
}
filp->f_pos += offset;
ret = filp->f_pos;
break;
default:
ret = -EINVAL;
}
return ret;
return filp->f_pos;
}
static ssize_t demo_read(struct file *filp, char __user *buffer, size_t count, loff_t *position)
static ssize_t demo_read(struct file *filp, char __user *buffer, size_t count, loff_t *offset)
{
struct demo_dev *devp = filp->private_data;
loff_t p = *position;
ssize_t ret = 0;
// This is a test.
// 分析和获取有效的读长度
if(DEMO_DATA_SIZE<=p) // 要读的偏移位置越界
return 0; // End of a file
if(DEMO_DATA_SIZE<(count+p)) // 要读的字节数太大
count = DEMO_DATA_SIZE-p;
if(copy_to_user((void*)buffer, &devp->demo_text[p], count))
ret = -EFAULT;
else
{
*position += count;
ret = count;
}
return ret;
const char __user *p = buffer;
return p-buffer;
}
static ssize_t demo_write(struct file *filp, const char __user *buffer, size_t count, loff_t *position)
static ssize_t demo_write(struct file *filp, const char __user *buffer, size_t count, loff_t *offset)
{
struct demo_dev *devp = filp->private_data;
const char __user *p = buffer;
(void)devp;
return p-buffer;
}
static long demo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
struct demo_dev *devp = filp->private_data;
(void)devp;
static int err = 0;
// 检测 cmd 合法性
if (DEMO_MAGIC!=_IOC_TYPE(cmd))
// 检测 cmd 合法性.
if(DEMO_MAGIC!=_IOC_TYPE(cmd))
return -EINVAL;
if (DEMO_CTL_MAX<_IOC_NR(cmd))
if(DEMO_CTL_MAX<_IOC_NR(cmd))
return -EINVAL;
// 根据命令类型, 检测参数空间是否可以访问.
if(_IOC_DIR(cmd)&_IOC_READ)
err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
else if(_IOC_DIR(cmd)&_IOC_WRITE)
err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
if (err)
return -EFAULT;
// 根据命令, 来选择执行哪个分支.
switch(cmd)
{
case DEMO_CTL_IOC:
@ -189,9 +127,6 @@ static long demo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
static int demo_mmap(struct file* filp, struct vm_area_struct* vma)
{
struct demo_dev *devp = filp->private_data;
(void)devp;
return 0;
}
@ -206,98 +141,22 @@ static struct file_operations demo_fops = {
.mmap = demo_mmap
};
static int demo_setup_cdev(struct demo_dev *devp, int index)
{
char name[16];
int err, devno = MKDEV(demo_major, index);
cdev_init(&devp->cdev, &demo_fops);
devp->cdev.owner = THIS_MODULE;
devp->cdev.ops = &demo_fops;
err = cdev_add(&devp->cdev, devno, 1);
if(err)
{
printk(KERN_ERR "demo add cdev:%d error:%d.\r\n", index, err);
goto out_cdev;
}
// 创建设备节点
memset(name, 0, 16);
sprintf(name, DEMO_MODULE_NAME"%d", index);
printk(KERN_INFO "demo new dev name:%s", name);
devp->dev = device_create(class, NULL, devp->cdev.dev, NULL, name);
// This is a test.
devp->demo_text[DEMO_DATA_SIZE-2] = '\n';
devp->demo_text[DEMO_DATA_SIZE-1] = 0;
sprintf(devp->demo_text, "%d", index);
return 0;
out_cdev:
cdev_del(&devp->cdev);
kfree(devp);
return err;
}
static struct miscdevice demo_dev = {
.minor = MISC_DYNAMIC_MINOR, // Dynamically allocate minor.
.name = "demo_misc",
.fops = &demo_fops,
};
static int __init demo_init(void)
{
int err, i;
dev_t devno = MKDEV(demo_major, 0);
if(demo_major) // 使用固定主设备号
err = register_chrdev_region(devno, DEMO_DEV_CNT, DEMO_MODULE_NAME);
else // 动态分配主设备号
{
err = alloc_chrdev_region(&devno, 0, DEMO_DEV_CNT, DEMO_MODULE_NAME);
demo_major = MAJOR(devno);
}
if(err<0)
return err;
demo_devp = kzalloc(DEMO_DEV_CNT*sizeof(struct demo_dev), GFP_KERNEL);
if(!demo_devp)
{
err = -ENOMEM;
goto out;
}
// 创建设备类, 子设备属于同一个设备类
class = class_create(THIS_MODULE, DEMO_MODULE_NAME);
for(i=0; i<DEMO_DEV_CNT; i++)
{
err = demo_setup_cdev(&demo_devp[i], i);
if(err)
goto out_class;
}
misc_register(&demo_dev); // 注册混杂设备驱动.
return 0;
out_class:
class_destroy(class);
out:
unregister_chrdev_region(devno, DEMO_DEV_CNT);
return err;
}
static void demo_clean_cdev(struct demo_dev *devp)
{
device_destroy(class, devp->cdev.dev);
cdev_del(&devp->cdev);
}
static void __exit demo_exit(void)
{
int i;
for(i=0; i<DEMO_DEV_CNT; i++)
demo_clean_cdev(&demo_devp[i]);
class_destroy(class);
kfree(demo_devp);
unregister_chrdev_region(MKDEV(demo_major, 0), DEMO_DEV_CNT);
misc_deregister(&demo_dev); // 撤销混杂设备驱动.
}
// insmod 时可传入参数
module_param(demo_major, int, S_IRUGO);
module_init(demo_init);
module_exit(demo_exit);

173
Linux/KernelDriver/4.19/Char/demo_char.c
View File

@ -11,11 +11,10 @@
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
@ -32,15 +31,22 @@ MODULE_LICENSE("GPL");
#define DEMO_CTL_MAX 5
#define DEMO_MODULE_NAME "demo_char"
#define DEMO_DEV_CNT 2
// This is a test.
#define DEMO_DATA_SIZE 5
static int demo_major = 0;
struct demo_dev
{
struct cdev cdev;
struct class *uclass;
struct device *udevice;
struct device *dev;
// This is a test.
char demo_text[DEMO_DATA_SIZE];
};
struct class *class;
struct demo_dev* demo_devp;
static int demo_open(struct inode *inode, struct file* filp)
@ -60,21 +66,72 @@ static int demo_release(struct inode *inode, struct file* filp)
static loff_t demo_llseek(struct file *filp, loff_t offset, int origin)
{
struct demo_dev *devp = filp->private_data;
loff_t ret;
(void)devp;
// This is a test.
switch(origin)
{
case 0: // 从文件开头开始偏移
if(offset<0)
{
ret = -EINVAL;
break;
}
if((unsigned int)offset>DEMO_DATA_SIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1: // 从当前位置开始偏移
if((filp->f_pos+offset)>DEMO_DATA_SIZE)
{
ret = -EINVAL;
break;
}
if((filp->f_pos+offset)<0)
{
ret = -EINVAL;
break;
}
filp->f_pos += offset;
ret = filp->f_pos;
break;
default:
ret = -EINVAL;
}
return ret;
return filp->f_pos;
}
static ssize_t demo_read(struct file *filp, char __user *buffer, size_t count, loff_t *offset)
static ssize_t demo_read(struct file *filp, char __user *buffer, size_t count, loff_t *position)
{
struct demo_dev *devp = filp->private_data;
const char __user *p = buffer;
loff_t p = *position;
ssize_t ret = 0;
(void)devp;
return p-buffer;
// This is a test.
// 分析和获取有效的读长度
if(DEMO_DATA_SIZE<=p) // 要读的偏移位置越界
return 0; // End of a file
if(DEMO_DATA_SIZE<(count+p)) // 要读的字节数太大
count = DEMO_DATA_SIZE-p;
if(copy_to_user((void*)buffer, &devp->demo_text[p], count))
ret = -EFAULT;
else
{
*position += count;
ret = count;
}
return ret;
}
static ssize_t demo_write(struct file *filp, const char __user *buffer, size_t count, loff_t *offset)
static ssize_t demo_write(struct file *filp, const char __user *buffer, size_t count, loff_t *position)
{
struct demo_dev *devp = filp->private_data;
const char __user *p = buffer;
@ -149,59 +206,97 @@ static struct file_operations demo_fops = {
.mmap = demo_mmap
};
static int demo_setup_cdev(struct demo_dev *devp, int index)
{
char name[16];
int err, devno = MKDEV(demo_major, index);
cdev_init(&devp->cdev, &demo_fops);
devp->cdev.owner = THIS_MODULE;
devp->cdev.ops = &demo_fops;
err = cdev_add(&devp->cdev, devno, 1);
if(err)
{
printk(KERN_ERR "demo add cdev:%d error:%d.\r\n", index, err);
goto out_cdev;
}
// 创建设备节点
memset(name, 0, 16);
sprintf(name, DEMO_MODULE_NAME"%d", index);
printk(KERN_INFO "demo new dev name:%s", name);
devp->dev = device_create(class, NULL, devp->cdev.dev, NULL, name);
// This is a test.
devp->demo_text[DEMO_DATA_SIZE-2] = '\n';
devp->demo_text[DEMO_DATA_SIZE-1] = 0;
sprintf(devp->demo_text, "%d", index);
return 0;
out_cdev:
cdev_del(&devp->cdev);
kfree(devp);
return err;
}
static int __init demo_init(void)
{
int result;
int err, i;
dev_t devno = MKDEV(demo_major, 0);
if(demo_major)
result = register_chrdev_region(devno, 1, DEMO_MODULE_NAME);
else
if(demo_major) // 使用固定主设备号
err = register_chrdev_region(devno, DEMO_DEV_CNT, DEMO_MODULE_NAME);
else // 动态分配主设备号
{
result = alloc_chrdev_region(&devno, 0, 1, DEMO_MODULE_NAME);
err = alloc_chrdev_region(&devno, 0, DEMO_DEV_CNT, DEMO_MODULE_NAME);
demo_major = MAJOR(devno);
}
if(result < 0)
return result;
if(err<0)
return err;
demo_devp = kzalloc(sizeof(struct demo_dev), GFP_KERNEL);
if (!demo_devp)
demo_devp = kzalloc(DEMO_DEV_CNT*sizeof(struct demo_dev), GFP_KERNEL);
if(!demo_devp)
{
result = - ENOMEM;
goto out_kmalloc;
err = -ENOMEM;
goto out;
}
cdev_init(&demo_devp->cdev, &demo_fops);
demo_devp->cdev.owner = THIS_MODULE;
demo_devp->cdev.ops = &demo_fops;
result = cdev_add(&demo_devp->cdev, devno, 1);
if(result)
// 创建设备类, 子设备属于同一个设备类
class = class_create(THIS_MODULE, DEMO_MODULE_NAME);
for(i=0; i<DEMO_DEV_CNT; i++)
{
printk(KERN_NOTICE "Error %d.\r\n", result);
goto out_cdev;
err = demo_setup_cdev(&demo_devp[i], i);
if(err)
goto out_class;
}
demo_devp->uclass = class_create(THIS_MODULE, DEMO_MODULE_NAME);
demo_devp->udevice = device_create(demo_devp->uclass, NULL, demo_devp->cdev.dev, NULL, DEMO_MODULE_NAME"0");
return 0;
out_cdev:
cdev_del(&demo_devp->cdev);
kfree(demo_devp);
out_kmalloc:
unregister_chrdev_region(devno, 1);
return result;
out_class:
class_destroy(class);
out:
unregister_chrdev_region(devno, DEMO_DEV_CNT);
return err;
}
static void demo_clean_cdev(struct demo_dev *devp)
{
device_destroy(class, devp->cdev.dev);
cdev_del(&devp->cdev);
}
static void __exit demo_exit(void)
{
device_destroy(demo_devp->uclass, demo_devp->cdev.dev);
class_destroy(demo_devp->uclass);
cdev_del(&demo_devp->cdev);
int i;
for(i=0; i<DEMO_DEV_CNT; i++)
demo_clean_cdev(&demo_devp[i]);
class_destroy(class);
kfree(demo_devp);
unregister_chrdev_region(MKDEV(demo_major, 0), 1);
unregister_chrdev_region(MKDEV(demo_major, 0), DEMO_DEV_CNT);
}
// insmod 时可传入参数
module_param(demo_major, int, S_IRUGO);
module_init(demo_init);