字符设备实例（学习笔记）

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/cdev.h>
#include <linux/gpio.h>
#include <linux/types.h>
#include <linux/fs.h>           /* everything... */
#include <linux/interrupt.h>    /* request_irq() */
#include <linux/delay.h>        /* mdelay() */
#include <linux/device.h>       /*class_create()*/
#include <linux/slab.h>

#include <asm/uaccess.h>  



#ifndef LED_MAJOR
#define LED_MAJOR 0
#endif
#define DEVICENAME "led"
int led_major = LED_MAJOR;
int led_minor = 0;

static unsigned char led_inc = 0;

static struct class *led_class;

static char kbuf[50];

struct led_dev 
{
    unsigned long     size;
    struct semaphore  sem;
    struct cdev       cdev;
};
struct led_dev *led_dev;//定义一个设备结构体指针

static ssize_t led_open(struct inode *inode, struct file *filp)
{
    struct led_dev *dev;

    if(led_inc)
    {
        printk(KERN_NOTICE,"led has already opend begin");
        return -ERESTARTSYS;
    }
    led_inc++;
    dev = container_of(inode->i_cdev,struct led_dev,cdev);
    filp->private_data = dev ;

    printk("led dev opend");

    return 0;
}

static ssize_t led_read(struct file *filp, char *buf, size_t count, loff_t *f_ops)
{
 
      if(copy_to_user(buf, kbuf, count))
      {
            return -EFAULT;
      }
            printk("read led dev OK\n");
      return sizeof(int); //return the write cont
}

static ssize_t led_write(struct file *filp, const char *buf, size_t len, loff_t *off)
{
 
  if(copy_from_user(kbuf, buf, len))
  {
    return -EFAULT;
  }
  printk("write led dev OK\n");
  return sizeof(int); //return the write cont
}

static int led_release(struct inode *inode, struct file *filp)
{
      printk("close led dev OK\n");
      led_inc--;
      return 0;
}

struct file_operations led_fops = {
    .owner   = THIS_MODULE,
    .open    = led_open,
    .read    = led_read,
    .write   = led_write,
    //.unlocked_ioctl   = led_ioctl,
    .release = led_release,
};

static int __init led_init(void)
{
    int result;
    unsigned dev_cont = 1;//定义设备数
    dev_t led_dev_t;//定义led 设备号变量

    if(led_major){
        //获取设备号
        led_dev_t = MKDEV(led_major,led_minor);
        result = register_chrdev_region(led_dev_t, dev_cont, DEVICENAME);
    }
    else {
    //动态获取设备号
        result = alloc_chrdev_region(&led_dev_t, led_minor, dev_cont,DEVICENAME);
        led_major = MAJOR(led_dev_t);
    }
    if(result < 0)
    {
        printk(KERN_WARNING,"get majot fail!!!\n");
        return result;
    }
    //在内核中为设备申请空间
    led_dev = kmalloc( sizeof(struct led_dev),GFP_KERNEL);
    if(!led_dev)
    {
        unregister_chrdev_region(led_dev_t, 1);
        return -ENOMEM;
    }
    memset(led_dev,0,sizeof(struct led_dev));


    cdev_init(&led_dev->cdev,&led_fops);
    result = cdev_add(&led_dev->cdev,led_dev_t,1);


    // 加载模块是 自动创建设备节点
    led_class = class_create(THIS_MODULE,"Led_class");
    device_create(led_class,NULL,MKDEV(led_major,led_minor),NULL,DEVICENAME);


    if(result < 0)
    {
        kfree(led_dev);
        unregister_chrdev_region(led_dev_t, 1);
        printk(KERN_NOTICE,"add led device fail !!!!\n");
    }
    return result;
}

static void led_exit(void)
{
    dev_t led_dev_t;


    led_dev_t = MKDEV(led_major,led_minor);
    if(led_dev){
        cdev_del(&led_dev->cdev);
        kfree(led_dev);
    }
    unregister_chrdev_region(led_dev_t, 1);
    //  卸载模块时 自动删除设备节点
    device_destroy(led_class, MKDEV(led_major, led_minor));
    class_destroy(led_class);

}

MODULE_LICENSE("GPL");
module_init(led_init);
module_exit(led_exit);