关于字符设备驱动程序的一个样例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/uaccess.h>
#include <linux/cdev.h>

#define HELLO_MAJOR 248
#define HELLO_MINOR 1

#define HELLO_SIZE 4096
#define DEVICE_NAME "hello"

static unsigned char hello_count = 0;

static int hello_major = HELLO_MAJOR;
static int hello_minor = HELLO_MINOR;

static struct cdev *pdev = NULL;

int hello_open(struct inode *inode, struct file *file)
{
	if(hello_count > 0)
		return -1;

	file->private_data = kmalloc(HELLO_SIZE, GFP_KERNEL);
	if(file->private_data == NULL)
		return -1;
	memset(file->private_data, 0, HELLO_SIZE);

	printk(KERN_INFO "hello_open succeed: %d: %d\n", MAJOR(inode->i_rdev), MINOR(inode->i_rdev));
	hello_count ++;
	return 0;
}

int hello_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	switch(cmd)
	{
		case 0x01:
			printk(KERN_INFO "hello_ioctl succeed: %d\n", cmd);
			break;
		default:
			printk(KERN_ERR "hello_ioctl failed: %d\n", cmd);
			break;
	}

	return 0;
}

ssize_t hello_read(struct file *file, char __user *buffer, size_t length, loff_t *offset)
{
	if(length < HELLO_SIZE || copy_to_user(buffer, file->private_data, length) != 0)
	{
		printk(KERN_ERR "hello_read failed!\n");
		return -1;
	}

	printk(KERN_INFO "hello_read succeed\n");
	return 0;
}

ssize_t hello_write(struct file *file, const char __user *buffer, size_t length, loff_t *offset)
{
	if(length > HELLO_SIZE || copy_from_user(file->private_data, buffer, length) != 0)
	{
		printk(KERN_ERR "hello_write failed!\n");
		return -1;
	}

	printk(KERN_INFO "hello_write succeed\n");
	return 0;
}

int hello_close(struct inode *inode, struct file *file)
{
	if(file->private_data)
		kfree(file->private_data);

	hello_count --;
	return 0;
}

static struct file_operations hello_fops = {
    .owner   =   THIS_MODULE,
    .open    =   hello_open,
    .ioctl   =   hello_ioctl,
    .read    =   hello_read,
    .write   =   hello_write,
    .release =   hello_close,
};

static int __init hello_init(void)
{
	int ret = 0;
	dev_t dev_num = MKDEV(hello_major, hello_minor);

	ret = register_chrdev_region(dev_num, 1, DEVICE_NAME);
	if(ret != 0)
	{
		ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
		if(ret != 0)
			return ret;
		
		hello_major = MAJOR(dev_num);
		hello_minor = MINOR(dev_num);
	}

	pdev = kmalloc(sizeof(struct cdev), GFP_KERNEL);
	if(pdev == NULL)
		goto ErrP;
	memset(pdev, 0, sizeof(struct cdev));

	cdev_init(pdev, &hello_fops);
	pdev->owner = THIS_MODULE;
	pdev->ops = &hello_fops;

	printk(KERN_INFO "Hello, World\n");
	return cdev_add(pdev, dev_num, 1);
ErrP:
	unregister_chrdev_region(dev_num, 1);
	printk(KERN_ERR "hello_init failed!\n");
	return -1;
}

static void __exit hello_exit(void)
{
	if(pdev)
	{
		cdev_del(pdev);
		kfree(pdev);
	}

	unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1);
	printk(KERN_INFO "Goodbye, World\n");
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_AUTHOR("ljk@xdja.com");
MODULE_DESCRIPTION("LiJinKui");
MODULE_LICENSE("GPL");