#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
static int led_major;
struct cdev cdev;
static int led_drv_open(struct inode *inode, struct file *file)
{
    return 0;
}
static ssize_t led_drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    return 0;
}
static struct file_operations led_drv_fops = {
    .owner  =   THIS_MODULE,
    .open   =   led_drv_open,
    .write	=	led_drv_write,
};
static void led_setup_cdev(void)
{
  int err, devno = MKDEV(led_major, 0);//index 为从设备号
  cdev_init(&cdev, &led_drv_fops);
  cdev.owner = THIS_MODULE;
  cdev.ops = &led_drv_fops;
  err = cdev_add(&cdev, devno, 1);//devno 为第一个设备号，1为数量
  if (err)
    printk(KERN_NOTICE "Error %d adding", err);
}
static int led_drv_init(void)
{
    int result;
    dev_t devno;
    struct class *led_class;
    struct device *dev;
    devno=MKDEV(led_major,0);
    if(led_major)//静态申请设备号
        result=register_chrdev_region(devno,1,"led1_dev");
    else
    {
        result = alloc_chrdev_region(&devno,0,1,"led1_dev");//动态申请设备号
        led_major = MAJOR(devno);
    }
    if(result<0)
    {
        printk (KERN_WARNING "hello: can't get major number %d\n", led_major);
        return result;
    }
    led_setup_cdev();
    led_class = class_create(THIS_MODULE, "led_class");
	dev = device_create(led_class, NULL, devno, NULL, "%s", "led_dev");
	if (IS_ERR(dev)) {
		dev_err(dev, "device create failed error code(%ld)\n", PTR_ERR(dev));
		return PTR_ERR(dev);
	}
    return 0;
}
static void led_drv_exit(void)
{
    device_destroy(led_class, dev);     /* remove the device */
    class_destroy(led_class);           /* remove the device class */
    cdev_del(&cdev);
    unregister_chrdev_region(MKDEV(led_major,0),1);
}
module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <asm/unistd.h>
struct led_dev {
	struct miscdevice miscdev;
	void *data;
}
struct led_dev my_led;
static int leds_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
	return 0;
}
static int leds_open(struct inode *inode, struct file *filp)
{
	//filp->private_data = &my_led;
	return 0;
}
static int leds_release(struct inode *inode, struct file *filp)
{
	return 0;
}
static ssize_t leds_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
	  return 1;
}
static struct file_operations leds_fops =
{
	.owner   = THIS_MODULE,
	.read    = leds_read,
	.ioctl   = leds_ioctl,
	.open    = leds_open,
	.release = leds_release
};
static int __init dev_init(void)
{
	struct miscdevice *miscdev = &my_led.miscdev;

	miscdev->minor = MISC_DYNAMIC_MINOR,
	miscdev->name = "misc_leds",
	miscdev->fops = &leds_fops,
	miscdev->parent = NULL;
	int ret = misc_register(miscdev);
	return ret;
}
static void __exit dev_exit(void)
{
	misc_deregister(&my_led.miscdev);
}
module_init(dev_init);
module_exit(dev_exit);
MODULE_LICENSE("GPL");