Linux设备驱动——字符驱动各种结构体
2015-09-03 19:04
555 查看
设备驱动程序：
Linux将所有外部设备看成是一类特殊文件，称之为“设备文件”，如果说系统调用是Linux内核和应用程序之间的接口，那么设备驱动程序则可以看成是Linux内核与外部设备之间的接口。设备驱动程序向应用程序屏蔽了硬件在实现上的细节，使得应用程序可以像操作普通文件一样来操作外部设备。
Linux字符设备驱动结构
1.1 cdev结构体
在Linux2.6 内核中，使用cdev结构体来描述一个字符设备，cdev结构体的定义如下：
struct cdev {
struct kobject kobj;
struct module *owner; /*通常为THIS_MODULE*/
struct file_operations *ops; /*在cdev_init()这个函数里面与cdev结构联系起来*/
struct list_head list;
dev_t dev; /*设备号*/
unsigned int count;
}；
cdev 结构体的dev_t 成员定义了设备号，为32位，其中12位是主设备号，20位是次设备号，我们只需使用二个简单的宏就可以从dev_t 中获取主设备号和次设备号：
MAJOR(dev_t dev)
MINOR(dev_t dev)
相反地，可以通过主次设备号来生成dev_t：
MKDEV(int major,int minor)
1.2 Linux 2.6内核提供一组函数用于操作cdev 结构体：
1：void cdev_init(struct cdev*,struct file_operations *);
2：struct cdev *cdev_alloc(void);
3：int cdev_add(struct cdev *,dev_t,unsigned);
4：void cdev_del(struct cdev *);
其中（1）用于初始化cdev结构体，并建立cdev与file_operations 之间的连接。（2）用于动态分配一个cdev结构，（3）向内核注册一个cdev结构，（4）向内核注销一个cdev结构
1.3 Linux 2.6内核分配和释放设备号
在调用cdev_add()函数向系统注册字符设备之前，首先应向系统申请设备号，有二种方法申请设备号，一种是静态申请设备号：
5：int register_chrdev_region(dev_t from,unsigned count,const char *name)
另一种是动态申请设备号：
6：int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name);
其中，静态申请是已知起始设备号的情况，如先使用cat /proc/devices 命令查得哪个设备号未事先使用（不推荐使用静态申请）；动态申请是由系统自动分配，只需设置major = 0即可。
相反地，在调用cdev_del()函数从系统中注销字符设备之后，应该向系统申请释放原先申请的设备号，使用：
7：void unregister_chrdev_region(dev_t from,unsigned count);
1.4 cdev结构的file_operations结构体
这个结构体是字符设备当中最重要的结构体之一，file_operations 结构体中的成员函数指针是字符设备驱动程序设计的主体内容，这些函数实际上在应用程序进行Linux 的 open()、read()、write()、close()、seek()、ioctl()等系统调用时最终被调用。在include/linux/fs.h文件中定义，这里不一一详解，仅仅解析一些常用的API。
struct file_operations {
/*拥有该结构的模块计数，一般为THIS_MODULE*/
struct module *owner;
/*用于修改文件当前的读写位置*/
loff_t (*llseek) (struct file *, loff_t, int);
/*从设备中同步读取数据*/
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
/*向设备中写数据*/
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
/*轮询函数，判断目前是否可以进行非阻塞的读取或写入*/
unsigned int (*poll) (struct file *, struct poll_table_struct *);
/*执行设备的I/O命令*/
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
/*用于请求将设备内存映射到进程地址空间*/
int (*mmap) (struct file *, struct vm_area_struct *);
/*打开设备文件*/
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
/*关闭设备文件*/
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, struct dentry *, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)
4000
(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
};
1.5 file结构
file 结构代表一个打开的文件，它的特点是一个文件可以对应多个file结构。它由内核再open时创建，并传递给在该文件上操作的所有函数，直到最后close函数，在文件的所有实例都被关闭之后，内核才释放这个数据结构。
在内核源代码中，指向 struct file 的指针通常比称为filp，file结构有以下几个重要的成员：
struct file{
mode_t fmode; /*文件模式，如FMODE_READ，FMODE_WRITE*/
......
loff_t f_pos; /*loff_t 是一个64位的数，需要时，须强制转换为32位*/
unsigned int f_flags; /*文件标志，如：O_NONBLOCK*/
struct file_operations *f_op;
void *private_data; /*非常重要，用于存放转换后的设备描述结构指针*/
.......
};
1.6 inode 结构
内核用inode 结构在内部表示文件，它是实实在在的表示物理硬件上的某一个文件，且一个文件仅有一个inode与之对应，同样它有二个比较重要的成员：
struct inode{
dev_t i_rdev; /*设备编号*/
struct cdev *i_cdev; /*cdev 是表示字符设备的内核的内部结构*/
};
可以从inode中获取主次设备号，使用下面二个宏：
/*驱动工程师一般不关心这二个宏*/
unsigned int imajor(struct inode *inode);
unsigned int iminor(struct inode *inode);
2.1 Linux字符设备驱动的组成
1、字符设备驱动模块加载与卸载函数
在字符设备驱动模块加载函数中应该实现设备号的申请和cdev 结构的注册，而在卸载函数中应该实现设备号的释放与cdev结构的注销。
我们一般习惯将cdev内嵌到另外一个设备相关的结构体里面，该设备包含所涉及的cdev、私有数据及信号量等等信息。常见的设备结构体、模块加载函数、模块卸载函数形式如下：
/*设备结构体*/
struct xxx_dev{
struct cdev cdev;
char *data;
struct semaphore sem;
......
};
/*模块加载函数*/
static int __init xxx_init(void)
{
.......
初始化cdev结构;
申请设备号；
注册设备号；
申请分配设备结构体的内存； /*非必须*/
}
/*模块卸载函数*/
static void __exit xxx_exit(void)
{
.......
释放原先申请的设备号；
释放原先申请的内存；
注销cdev设备；
}
2、字符设备驱动的 file_operations 结构体重成员函数
/*读设备*/
ssize_t xxx_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
......
使用filp->private_data获取设备结构体指针；
分析和获取有效的长度；
/*内核空间到用户空间的数据传递*/
copy_to_user(void __user *to, const void *from, unsigned long count);
......
}
/*写设备*/
ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
......
使用filp->private_data获取设备结构体指针；
分析和获取有效的长度；
/*用户空间到内核空间的数据传递*/
copy_from_user(void *to, const void __user *from, unsigned long count);
......
}
/*ioctl函数*/
static int xxx_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)
{
......
switch(cmd){
case xxx_CMD1:
......
break;
case xxx_CMD2:
.......
break;
default:
return -ENOTTY; /*不能支持的命令*/
}
return 0;
}
3、字符设备驱动文件操作结构体模板
struct file_operations xxx_fops = {
.owner = THIS_MODULE,
.open = xxx_open,
.read = xxx_read,
.write = xxx_write,
.close = xxx_release,
.ioctl = xxx_ioctl,
.lseek = xxx_llseek,
};
代码如下：
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/slab.h>
#define GLOBALMEM_SIZE 0x1000 /*全局内存最大4K字节*/
#define MEM_CLEAR 0x1 /*清0全局内存*/
#define GLOBALMEM_MAJOR 0 /*预设的globalmem的主设备号*/
static int globalmem_major = GLOBALMEM_MAJOR;
/*globalmem设备结构体*/
struct globalmem_dev
{
struct cdev cdev; /*cdev结构体*/
unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/
};
struct globalmem_dev *globalmem_devp; /*设备结构体指针*/
/*文件打开函数*/
int globalmem_open(struct inode *inode, struct file *filp)
{
/*将设备结构体指针赋值给文件私有数据指针*/
filp->private_data = globalmem_devp;
return 0;
}
/*文件释放函数*/
int globalmem_release(struct inode *inode, struct file *filp)
{
return 0;
}
/* ioctl设备控制函数 */
static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned
int cmd, unsigned long arg)
{
struct globalmem_dev *dev = filp->private_data;/*获得设备结构体指针*/
switch (cmd)
{
case MEM_CLEAR:
memset(dev->mem, 0, GLOBALMEM_SIZE);
printk(KERN_INFO "globalmem is set to zero\n");
break;
default:
return - EINVAL;
}
return 0;
}
/*读函数*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size,
loff_t *ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*分析和获取有效的写长度*/
if (p >= GLOBALMEM_SIZE)
return count ? - ENXIO: 0; /* return ENXIO: No such device or address */
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
/*内核空间->用户空间*/
if (copy_to_user(buf, (void*)(dev->mem + p), count))
{
ret = - EFAULT; /* Bad address */
}
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "read %d bytes(s) from position %d\n", count, p);
}
return ret;
}
/*写函数*/
static ssize_t globalmem_write(struct file *filp, const char __user *buf,
size_t size, loff_t *ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*分析和获取有效的写长度*/
if (p >= GLOBALMEM_SIZE)
return count ? - ENXIO: 0; //ENXIO: No such device or addres
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
/*用户空间->内核空间*/
if (copy_from_user(dev->mem + p, buf, count))
ret = - EFAULT;
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "written %d bytes(s) to position %d\n", count, p);
}
return ret;
}
/* seek文件定位函数 */
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
loff_t ret = 0;
switch (orig)
{
case 0: /*相对文件开始位置偏移*/
if (offset < 0)
{
ret = - EINVAL; /* Invalid argument */
break;
}
if ((unsigned int)offset > GLOBALMEM_SIZE)
{
ret = - EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1: /*相对文件当前位置偏移*/
if ((filp->f_pos + offset) > GLOBALMEM_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;
break;
}
return ret;
}
/*文件操作结构体*/
static const struct file_operations globalmem_fops =
{
.owner = THIS_MODULE,
.llseek = globalmem_llseek,
.read = globalmem_read,
.write = globalmem_write,
.ioctl = globalmem_ioctl,
.open = globalmem_open,
.release = globalmem_release,
};
/*初始化并注册cdev*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
int err, devno = MKDEV(globalmem_major, index);
cdev_init(&dev->cdev, &globalmem_fops);
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &globalmem_fops;
err = cdev_add(&dev->cdev, devno, 1);
if (err)
printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}
/*设备驱动模块加载函数*/
int globalmem_init(void)
{
int result;
dev_t devno = MKDEV(globalmem_major, 0);
/* 申请设备号*/
if (globalmem_major)
result = register_chrdev_region(devno, 1, "globalmem");
else /* 动态申请设备号 */
{
result = alloc_chrdev_region(&devno, 0, 1, "globalmem");
globalmem_major = MAJOR(devno);
}
if (result <
b1e3
0)
return result;
/* 动态申请设备结构体的内存*/
globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
if (!globalmem_devp) /*申请失败*/
{
result = - ENOMEM;
goto fail_malloc;
}
memset(globalmem_devp, 0, sizeof(struct globalmem_dev));
globalmem_setup_cdev(globalmem_devp, 0);
printk("globalmem driver installed!\n");
printk("globalmem_major is:%d\n",globalmem_major);
printk("the device name is %s\n", "globalmem");
return 0;
fail_malloc: unregister_chrdev_region(devno, 1);
return result;
}
/*模块卸载函数*/
void globalmem_exit(void)
{
cdev_del(&globalmem_devp->cdev); /*注销cdev*/
kfree(globalmem_devp); /*释放设备结构体内存*/
unregister_chrdev_region(MKDEV(globalmem_major, 0), 1); /*释放设备号*/
printk("globalmem driver uninstalled!\n");
}
MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");
module_param(globalmem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit);
上面的写法需要注意二点，一：结构体成员之间是以逗号分开的而不是分号，结构体字段结束时最后应加上分号。
文章转自 http://blog.csdn.net/lwj103862095/article/details/8539522
Linux将所有外部设备看成是一类特殊文件，称之为“设备文件”，如果说系统调用是Linux内核和应用程序之间的接口，那么设备驱动程序则可以看成是Linux内核与外部设备之间的接口。设备驱动程序向应用程序屏蔽了硬件在实现上的细节，使得应用程序可以像操作普通文件一样来操作外部设备。
Linux字符设备驱动结构
1.1 cdev结构体
在Linux2.6 内核中，使用cdev结构体来描述一个字符设备，cdev结构体的定义如下：
struct cdev {
struct kobject kobj;
struct module *owner; /*通常为THIS_MODULE*/
struct file_operations *ops; /*在cdev_init()这个函数里面与cdev结构联系起来*/
struct list_head list;
dev_t dev; /*设备号*/
unsigned int count;
}；
cdev 结构体的dev_t 成员定义了设备号，为32位，其中12位是主设备号，20位是次设备号，我们只需使用二个简单的宏就可以从dev_t 中获取主设备号和次设备号：
MAJOR(dev_t dev)
MINOR(dev_t dev)
相反地，可以通过主次设备号来生成dev_t：
MKDEV(int major,int minor)
1.2 Linux 2.6内核提供一组函数用于操作cdev 结构体：
1：void cdev_init(struct cdev*,struct file_operations *);
2：struct cdev *cdev_alloc(void);
3：int cdev_add(struct cdev *,dev_t,unsigned);
4：void cdev_del(struct cdev *);
其中（1）用于初始化cdev结构体，并建立cdev与file_operations 之间的连接。（2）用于动态分配一个cdev结构，（3）向内核注册一个cdev结构，（4）向内核注销一个cdev结构
1.3 Linux 2.6内核分配和释放设备号
在调用cdev_add()函数向系统注册字符设备之前，首先应向系统申请设备号，有二种方法申请设备号，一种是静态申请设备号：
5：int register_chrdev_region(dev_t from,unsigned count,const char *name)
另一种是动态申请设备号：
6：int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name);
其中，静态申请是已知起始设备号的情况，如先使用cat /proc/devices 命令查得哪个设备号未事先使用（不推荐使用静态申请）；动态申请是由系统自动分配，只需设置major = 0即可。
相反地，在调用cdev_del()函数从系统中注销字符设备之后，应该向系统申请释放原先申请的设备号，使用：
7：void unregister_chrdev_region(dev_t from,unsigned count);
1.4 cdev结构的file_operations结构体
这个结构体是字符设备当中最重要的结构体之一，file_operations 结构体中的成员函数指针是字符设备驱动程序设计的主体内容，这些函数实际上在应用程序进行Linux 的 open()、read()、write()、close()、seek()、ioctl()等系统调用时最终被调用。在include/linux/fs.h文件中定义，这里不一一详解，仅仅解析一些常用的API。
struct file_operations {
/*拥有该结构的模块计数，一般为THIS_MODULE*/
struct module *owner;
/*用于修改文件当前的读写位置*/
loff_t (*llseek) (struct file *, loff_t, int);
/*从设备中同步读取数据*/
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
/*向设备中写数据*/
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
/*轮询函数，判断目前是否可以进行非阻塞的读取或写入*/
unsigned int (*poll) (struct file *, struct poll_table_struct *);
/*执行设备的I/O命令*/
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
/*用于请求将设备内存映射到进程地址空间*/
int (*mmap) (struct file *, struct vm_area_struct *);
/*打开设备文件*/
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
/*关闭设备文件*/
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, struct dentry *, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)
4000
(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
};
1.5 file结构
file 结构代表一个打开的文件，它的特点是一个文件可以对应多个file结构。它由内核再open时创建，并传递给在该文件上操作的所有函数，直到最后close函数，在文件的所有实例都被关闭之后，内核才释放这个数据结构。
在内核源代码中，指向 struct file 的指针通常比称为filp，file结构有以下几个重要的成员：
struct file{
mode_t fmode; /*文件模式，如FMODE_READ，FMODE_WRITE*/
......
loff_t f_pos; /*loff_t 是一个64位的数，需要时，须强制转换为32位*/
unsigned int f_flags; /*文件标志，如：O_NONBLOCK*/
struct file_operations *f_op;
void *private_data; /*非常重要，用于存放转换后的设备描述结构指针*/
.......
};
1.6 inode 结构
内核用inode 结构在内部表示文件，它是实实在在的表示物理硬件上的某一个文件，且一个文件仅有一个inode与之对应，同样它有二个比较重要的成员：
struct inode{
dev_t i_rdev; /*设备编号*/
struct cdev *i_cdev; /*cdev 是表示字符设备的内核的内部结构*/
};
可以从inode中获取主次设备号，使用下面二个宏：
/*驱动工程师一般不关心这二个宏*/
unsigned int imajor(struct inode *inode);
unsigned int iminor(struct inode *inode);
2.1 Linux字符设备驱动的组成
1、字符设备驱动模块加载与卸载函数
在字符设备驱动模块加载函数中应该实现设备号的申请和cdev 结构的注册，而在卸载函数中应该实现设备号的释放与cdev结构的注销。
我们一般习惯将cdev内嵌到另外一个设备相关的结构体里面，该设备包含所涉及的cdev、私有数据及信号量等等信息。常见的设备结构体、模块加载函数、模块卸载函数形式如下：
/*设备结构体*/
struct xxx_dev{
struct cdev cdev;
char *data;
struct semaphore sem;
......
};
/*模块加载函数*/
static int __init xxx_init(void)
{
.......
初始化cdev结构;
申请设备号；
注册设备号；
申请分配设备结构体的内存； /*非必须*/
}
/*模块卸载函数*/
static void __exit xxx_exit(void)
{
.......
释放原先申请的设备号；
释放原先申请的内存；
注销cdev设备；
}
2、字符设备驱动的 file_operations 结构体重成员函数
/*读设备*/
ssize_t xxx_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
......
使用filp->private_data获取设备结构体指针；
分析和获取有效的长度；
/*内核空间到用户空间的数据传递*/
copy_to_user(void __user *to, const void *from, unsigned long count);
......
}
/*写设备*/
ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
......
使用filp->private_data获取设备结构体指针；
分析和获取有效的长度；
/*用户空间到内核空间的数据传递*/
copy_from_user(void *to, const void __user *from, unsigned long count);
......
}
/*ioctl函数*/
static int xxx_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)
{
......
switch(cmd){
case xxx_CMD1:
......
break;
case xxx_CMD2:
.......
break;
default:
return -ENOTTY; /*不能支持的命令*/
}
return 0;
}
3、字符设备驱动文件操作结构体模板
struct file_operations xxx_fops = {
.owner = THIS_MODULE,
.open = xxx_open,
.read = xxx_read,
.write = xxx_write,
.close = xxx_release,
.ioctl = xxx_ioctl,
.lseek = xxx_llseek,
};
代码如下：
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/slab.h>
#define GLOBALMEM_SIZE 0x1000 /*全局内存最大4K字节*/
#define MEM_CLEAR 0x1 /*清0全局内存*/
#define GLOBALMEM_MAJOR 0 /*预设的globalmem的主设备号*/
static int globalmem_major = GLOBALMEM_MAJOR;
/*globalmem设备结构体*/
struct globalmem_dev
{
struct cdev cdev; /*cdev结构体*/
unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/
};
struct globalmem_dev *globalmem_devp; /*设备结构体指针*/
/*文件打开函数*/
int globalmem_open(struct inode *inode, struct file *filp)
{
/*将设备结构体指针赋值给文件私有数据指针*/
filp->private_data = globalmem_devp;
return 0;
}
/*文件释放函数*/
int globalmem_release(struct inode *inode, struct file *filp)
{
return 0;
}
/* ioctl设备控制函数 */
static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned
int cmd, unsigned long arg)
{
struct globalmem_dev *dev = filp->private_data;/*获得设备结构体指针*/
switch (cmd)
{
case MEM_CLEAR:
memset(dev->mem, 0, GLOBALMEM_SIZE);
printk(KERN_INFO "globalmem is set to zero\n");
break;
default:
return - EINVAL;
}
return 0;
}
/*读函数*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size,
loff_t *ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*分析和获取有效的写长度*/
if (p >= GLOBALMEM_SIZE)
return count ? - ENXIO: 0; /* return ENXIO: No such device or address */
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
/*内核空间->用户空间*/
if (copy_to_user(buf, (void*)(dev->mem + p), count))
{
ret = - EFAULT; /* Bad address */
}
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "read %d bytes(s) from position %d\n", count, p);
}
return ret;
}
/*写函数*/
static ssize_t globalmem_write(struct file *filp, const char __user *buf,
size_t size, loff_t *ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*分析和获取有效的写长度*/
if (p >= GLOBALMEM_SIZE)
return count ? - ENXIO: 0; //ENXIO: No such device or addres
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
/*用户空间->内核空间*/
if (copy_from_user(dev->mem + p, buf, count))
ret = - EFAULT;
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "written %d bytes(s) to position %d\n", count, p);
}
return ret;
}
/* seek文件定位函数 */
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
loff_t ret = 0;
switch (orig)
{
case 0: /*相对文件开始位置偏移*/
if (offset < 0)
{
ret = - EINVAL; /* Invalid argument */
break;
}
if ((unsigned int)offset > GLOBALMEM_SIZE)
{
ret = - EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1: /*相对文件当前位置偏移*/
if ((filp->f_pos + offset) > GLOBALMEM_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;
break;
}
return ret;
}
/*文件操作结构体*/
static const struct file_operations globalmem_fops =
{
.owner = THIS_MODULE,
.llseek = globalmem_llseek,
.read = globalmem_read,
.write = globalmem_write,
.ioctl = globalmem_ioctl,
.open = globalmem_open,
.release = globalmem_release,
};
/*初始化并注册cdev*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
int err, devno = MKDEV(globalmem_major, index);
cdev_init(&dev->cdev, &globalmem_fops);
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &globalmem_fops;
err = cdev_add(&dev->cdev, devno, 1);
if (err)
printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}
/*设备驱动模块加载函数*/
int globalmem_init(void)
{
int result;
dev_t devno = MKDEV(globalmem_major, 0);
/* 申请设备号*/
if (globalmem_major)
result = register_chrdev_region(devno, 1, "globalmem");
else /* 动态申请设备号 */
{
result = alloc_chrdev_region(&devno, 0, 1, "globalmem");
globalmem_major = MAJOR(devno);
}
if (result <
b1e3
0)
return result;
/* 动态申请设备结构体的内存*/
globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
if (!globalmem_devp) /*申请失败*/
{
result = - ENOMEM;
goto fail_malloc;
}
memset(globalmem_devp, 0, sizeof(struct globalmem_dev));
globalmem_setup_cdev(globalmem_devp, 0);
printk("globalmem driver installed!\n");
printk("globalmem_major is:%d\n",globalmem_major);
printk("the device name is %s\n", "globalmem");
return 0;
fail_malloc: unregister_chrdev_region(devno, 1);
return result;
}
/*模块卸载函数*/
void globalmem_exit(void)
{
cdev_del(&globalmem_devp->cdev); /*注销cdev*/
kfree(globalmem_devp); /*释放设备结构体内存*/
unregister_chrdev_region(MKDEV(globalmem_major, 0), 1); /*释放设备号*/
printk("globalmem driver uninstalled!\n");
}
MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");
module_param(globalmem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit);
上面的写法需要注意二点，一：结构体成员之间是以逗号分开的而不是分号，结构体字段结束时最后应加上分号。
文章转自 http://blog.csdn.net/lwj103862095/article/details/8539522
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 注册表的组织结构
- SQLSERVER的非聚集索引结构深度理解
- 调整SQLServer2000运行中数据库结构
- C#基础语法：结构和类区别详解
- 深入c# 类和结构的区别总结详解
- c#结构和类的相关介绍
- C#中结构(struct)的部分初始化和完全初始化实例分析
- C#中类与结构的区别实例分析
- C#枚举类型与结构类型实例解析
- javascript实现表现、结构、行为分离的选项卡效果！
- 实用的js 焦点图切换效果 结构行为相分离
- asp下生成目录树结构的类
- thinkphp文件引用与分支结构用法实例
- php实现的树形结构数据存取类实例
- Swift教程之类与结构详解
- 第三话：关于数据结构的一些概念
- 树形结构java代码以及结果
- Oracle Database 9i/10g/11g编程艺术
- 数据结构的基本概念和术语
- 硬盘结构及其分区简介