linux下字符设备驱动的三种创建方式

/*
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");

#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");

/*
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");