第一种:作为混杂设备驱动
/*
register globalmem as a miscdevice
*/
#include<linux/module.h>
#include<linux/init.h>
#include<linux/fs.h>
#include<linux/sched.h>
#include<linux/miscdevice.h>
#include<linux/string.h>
#include<linux/errno.h>
#include<linux/types.h>
#include<linux/slab.h>
#include<asm/uaccess.h>
#define GLOBALMEM_SIZE 0x1000
#define DEVICE_NAME "globalmem_misc"
//create a struct for globalmem
struct globalmem_dev {
unsigned char mem[GLOBALMEM_SIZE];
};
struct globalmem_dev *globalmem_devp;
int globalmem_open(struct inode *inode, struct file *filp)
{
filp->private_data = globalmem_devp; //storing the globalmem to the private_data of file struct
return 0;
}
int globalmem_release(struct inode *inode, struct file *filp)
{
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;//get globalmem_dev from file struct
if (p >= GLOBALMEM_SIZE)
return 0;
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
if (copy_to_user(buf, (void*)(dev->mem + p), count))
ret = -EFAULT;
else {
*ppos += count;
ret = count;
printk(KERN_INFO "read %d bytes(s) from %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 0;
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 butes(s) from %d \n", count, p);
}
return ret;
}
static const struct file_operations globalmem_fops = {
.owner = THIS_MODULE,
.read = globalmem_read,
.write = globalmem_write,
.open = globalmem_open,
.release = globalmem_release,
};
//miscdevice struct
static struct miscdevice misc =
{
.minor = MISC_DYNAMIC_MINOR,//allocate minor device number automatically,major number of msicdevice is 10
.name = DEVICE_NAME,
.fops = &globalmem_fops,
};
int globalmem_init(void)
{
int result;
result = misc_register(&misc);//register a miscdevice
if (result)
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));
return 0;
fail_malloc:
misc_deregister(&misc);
return result;
}
void globalmem_exit(void)
{
kfree(globalmem_devp);
misc_deregister(&misc);//deregister miscdevice
}
module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_LICENSE("GPL");
第二种:使用class_create和device_create
#include<linux/module.h>
#include<linux/init.h>
#include<linux/fs.h>
#include<linux/sched.h>
#include<linux/device.h>
#include<linux/string.h>
#include<linux/errno.h>
#include<linux/types.h>
#include<linux/slab.h>
#include<asm/uaccess.h>
#define GLOBALMEM_SIZE 0x1000
#define DEVICE_NAME "globalmem_class"
unsigned char globalmem_major;
static struct class *mem_class;
struct globalmem_dev {
unsigned char mem[GLOBALMEM_SIZE];
};
struct globalmem_dev *globalmem_devp;
int globalmem_open(struct inode *inode, struct file *filp)
{
···
}
int globalmem_release(struct inode *inode, struct file *filp)
{
···
}
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
···
}
static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
···
}
static const struct file_operations globalmem_fops = {
···
};
int globalmem_init(void)
{
globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
if (!globalmem_devp)
return -1;
memset(globalmem_devp, 0, sizeof(struct globalmem_dev));
//the first parameter 0 means allocate major device number automatically
globalmem_major = register_chrdev(0,DEVICE_NAME,&globalmem_fops);
if (globalmem_major < 0)
return globalmem_major;
//create a globalmem class
mem_class = class_create(THIS_MODULE,DEVICE_NAME);
if (IS_ERR(mem_class))
return -1;
//create a globalmem device from this class
device_create(mem_class,NULL,MKDEV(globalmem_major,0),NULL,DEVICE_NAME);
return 0;
}
void globalmem_exit(void)
{
unregister_chrdev(globalmem_major,DEVICE_NAME);//release major device number
device_destroy(mem_class,MKDEV(globalmem_major,0));//destroy globalmem device
class_destroy(mem_class);//destroy globalmem class
}
module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_LICENSE("GPL");
第三种:使用cdev结构体
/*
If we use cdev to register globalmem driver,we need to use command "mknod /dev/globalmem_cdev c 244 0"
to create a device node (postulate 244 is the major device number of globalmem).
*/
#include<linux/module.h>
#include<linux/init.h>
#include<linux/fs.h>
#include<linux/sched.h>
#include<linux/cdev.h>
#include<linux/string.h>
#include<linux/errno.h>
#include<linux/types.h>
#include<linux/slab.h>
#include<asm/uaccess.h>
#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
#define GLOBALMEM_MAJOR 0
static int globalmem_major = GLOBALMEM_MAJOR;
struct globalmem_dev {
struct cdev cdev;
unsigned char mem[GLOBALMEM_SIZE];
};
struct globalmem_dev *globalmem_devp;
int globalmem_open(struct inode *inode, struct file *filp)
{
···
}
int globalmem_release(struct inode *inode, struct file *filp)
{
···
}
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
···
}
static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
···
}
static const struct file_operations globalmem_fops = {
···
};
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
int err, devno = MKDEV(globalmem_major, 0);
cdev_init(&dev->cdev, &globalmem_fops);//initialize cdev
dev->cdev.owner = THIS_MODULE;
err = cdev_add(&dev->cdev, devno, 1);//add cdev to system
if (err)
printk(KERN_NOTICE "Error %d adding globalmem %d", err, index);
}
int globalmem_init(void)
{
int result;
globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);//allocate memory for globalmem_devp
if (!globalmem_devp) {
result = -ENOMEM;
return result;
}
memset(globalmem_devp, 0, sizeof(struct globalmem_dev));//initialize globalmem_devp
dev_t devno = MKDEV(globalmem_major, 0);//create a device number
if (globalmem_major)
result = register_chrdev_region(devno, 1, "globalmem_cdev");//request device number
else {
result = alloc_chrdev_region(&devno, 0, 1, "globalmem_cdev");//request device number automatically
globalmem_major = MAJOR(devno);
}
if (result < 0)
return result;
globalmem_setup_cdev(globalmem_devp, 0);
return 0;
}
void globalmem_exit(void)
{
cdev_del(&globalmem_devp->cdev);//delete cdev from system
kfree(globalmem_devp);
unregister_chrdev_region(MKDEV(globalmem_major, 0), 1);//release device number
}
module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_LICENSE("GPL");