Linux字符设备驱动--No.1

平台：tiny210SOC:s5pv210内核：Linux 3.0.8字符驱动：按键中断驱动源码：

 /*****************************************************************************
 简    述：简单字符型驱动程序，手动静态分配设备号，手动创建设备节点
 ******************************************************************************/
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/cdev.h>
 #include <linux/fs.h>
 #include <linux/wait.h>
 #include <linux/poll.h>
 #include <linux/sched.h>
 #include <linux/irq.h>
 #include <asm/irq.h>
 #include <linux/interrupt.h>

 #include <mach/map.h>
 #include <mach/gpio.h>
 #include <mach/regs-gpio.h>
 #include <plat/gpio-cfg.h>

 #include <linux/slab.h>

 #define DEVICE_NAME        "buttons"

 struct button_desc {
     int gpio;
     int number;
     char *name;
 };

 static struct button_desc buttons[] = {
     { S5PV210_GPH2(), , "KEY0" },
     { S5PV210_GPH2(), , "KEY1" },
     { S5PV210_GPH2(), , "KEY2" },
     { S5PV210_GPH2(), , "KEY3" },
     { S5PV210_GPH3(), , "KEY4" },
     { S5PV210_GPH3(), , "KEY5" },
     { S5PV210_GPH3(), , "KEY6" },
     { S5PV210_GPH3(), , "KEY7" },
 };
 #define OK            (0)
 #define ERROR         (-1)

 struct cdev *gDev;
 struct file_operations *gFile;
 dev_t  devNum;
 unsigned ;
 ;
 ;

 static irqreturn_t button_interrupt(int irq, void *dev_id)
 {
     struct button_desc *bdata = (struct button_desc *)dev_id;

     int down;
     unsigned tmp;

     tmp = gpio_get_value(bdata->gpio);

     /* active low */
     down = !tmp;
     printk("KEY %d: %08x\n", bdata->number, down);

     return IRQ_HANDLED;
 }

 int butsOpen(struct inode *p, struct file *f)
 {

         int irq;
     int i;
     ;
     printk(KERN_EMERG"butsOpen\r\n");
     ; i < ARRAY_SIZE(buttons); i++) {
         if (!buttons[i].gpio)
             continue;

         irq = gpio_to_irq(buttons[i].gpio);
         err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH,
                 buttons[i].name, (void *)&buttons[i]);
         if (err)
             break;
     }

     if (err) {
         i--;
         ; i--) {
             if (!buttons[i].gpio)
                 continue;

             irq = gpio_to_irq(buttons[i].gpio);
             disable_irq(irq);
             free_irq(irq, (void *)&buttons[i]);
         }

         return -EBUSY;
     }
     ;
 }

 int charDrvInit(void)
 {

     devNum = MKDEV(reg_major, reg_minor);

     printk(KERN_EMERG"devNum is %d\r\n", devNum);
     if(OK == register_chrdev_region(devNum, subDevNum, DEVICE_NAME))
     {
         printk(KERN_EMERG"register_chrdev_region ok\r\n");
     }
     else
     {
         printk(KERN_EMERG"register_chrdev_region error\r\n");
         return ERROR;
     }
     /*if(OK == alloc_chrdev_region(&devNum, subDevNum, subDevNum,"test"))
     {
         printk(KERN_EMERG"register_chrdev_region ok\r\n");
     }
     else
     {
         printk(KERN_EMERG"register_chrdev_region error\r\n");
         return ERROR;
     }*/

     gDev = kzalloc(sizeof(struct cdev), GFP_KERNEL);
     gFile = kzalloc(sizeof(struct file_operations), GFP_KERNEL);

     gFile->open = butsOpen;
 //注册设备函数到file_operations结构体gFile

    //gDev->owner = THIS_MODULE;
     gFile->owner = THIS_MODULE;
     cdev_init(gDev, gFile);
 //在cdev结构体中添加指针指向file_operations结构体gFile
     cdev_add(gDev, devNum, );
 //建立设备号与cdev结构体联系
     printk(KERN_EMERG"button driver initial done...\r\n");
     ;
 }

 void __exit charDrvExit(void)
 {
     int i;

     cdev_del(gDev);
     unregister_chrdev_region(devNum, subDevNum);
     return;
 }
 module_init(charDrvInit);
 module_exit(charDrvExit);
 MODULE_LICENSE("GPL");

---

 int butsOpen(struct inode *p, struct file *f)
 {

         int irq;
     int i;
     ;
     printk(KERN_EMERG"butsOpen\r\n");
     ; i < ARRAY_SIZE(buttons); i++) {
         if (!buttons[i].gpio)
             continue;

         irq = gpio_to_irq(buttons[i].gpio);
         err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH,
                 buttons[i].name, (void *)&buttons[i]);
         if (err)
             break;
     }

     if (err) {
         i--;
         ; i--) {
             if (!buttons[i].gpio)
                 continue;

             irq = gpio_to_irq(buttons[i].gpio);
             disable_irq(irq);
             free_irq(irq, (void *)&buttons[i]);
         }

         return -EBUSY;
     }
     ;
 }

 #define gpio_to_irq    __gpio_to_irq

 int __gpio_to_irq(unsigned gpio)
 {
     struct gpio_chip    *chip;
     chip = gpio_to_chip(gpio);
     return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO;
 }

 int samsung_gpiolib_to_irq(struct gpio_chip *chip, unsigned int offset)
 {
     struct s3c_gpio_chip *s3c_chip = container_of(chip,
             struct s3c_gpio_chip, chip);

     return s3c_chip->irq_base + offset;
 }

 static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
 {
     return gpio_desc[gpio].chip;//此处的gpio_desc[gpio].chip实际完成赋值在gpio-s5pv210.c中的s5pv210_gpiolib_init(void)函数中实现
 }

gpio_desc[gpio].chip实际完成赋值在gpio-s5pv210.c中的s5pv210_gpiolib_init(void)函数中的实现：

 static __init int s5pv210_gpiolib_init(void)
 {
     struct s3c_gpio_chip *chip = s5pv210_gpio_4bit;
     int nr_chips = ARRAY_SIZE(s5pv210_gpio_4bit);
     ;
     ;

     ; i < nr_chips; i++, chip++) {
         if (chip->config == NULL) {
             chip->config = &gpio_cfg;
             chip->group = gpioint_group++;
         }
         if (chip->base == NULL)
             chip->base = S5PV210_BANK_BASE(i);
     }

     samsung_gpiolib_add_4bit_chips(s5pv210_gpio_4bit, nr_chips);
     s5p_register_gpioint_bank(IRQ_GPIOINT, , S5P_GPIOINT_GROUP_MAXNR);

     ;
 }

 static struct s3c_gpio_chip s5pv210_gpio_4bit[] = {
     {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_A0_NR,
             .label    = "GPA0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_A1_NR,
             .label    = "GPA1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_B_NR,
             .label    = "GPB",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_C0_NR,
             .label    = "GPC0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_C1_NR,
             .label    = "GPC1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_D0_NR,
             .label    = "GPD0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_D1_NR,
             .label    = "GPD1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_E0_NR,
             .label    = "GPE0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_E1_NR,
             .label    = "GPE1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_F0_NR,
             .label    = "GPF0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_F1_NR,
             .label    = "GPF1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_F2_NR,
             .label    = "GPF2",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_F3_NR,
             .label    = "GPF3",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_G0_NR,
             .label    = "GPG0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_G1_NR,
             .label    = "GPG1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_G2_NR,
             .label    = "GPG2",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_G3_NR,
             .label    = "GPG3",
         },
     }, {
         .config    = &gpio_cfg_noint,
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_I_NR,
             .label    = "GPI",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_J0_NR,
             .label    = "GPJ0",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_J1_NR,
             .label    = "GPJ1",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_J2_NR,
             .label    = "GPJ2",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_J3_NR,
             .label    = "GPJ3",
         },
     }, {
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_J4_NR,
             .label    = "GPJ4",
         },
     }, {
         .config    = &gpio_cfg_noint,
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_MP01_NR,
             .label    = "MP01",
         },
     }, {
         .config    = &gpio_cfg_noint,
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_MP02_NR,
             .label    = "MP02",
         },
     }, {
         .config    = &gpio_cfg_noint,
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_MP03_NR,
             .label    = "MP03",
         },
     }, {
         .config    = &gpio_cfg_noint,
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_MP04_NR,
             .label    = "MP04",
         },
     }, {
         .config    = &gpio_cfg_noint,
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_MP05_NR,
             .label    = "MP05",
         },
     }, {
         .base    = (S5P_VA_GPIO + 0xC00),
         .config    = &gpio_cfg_noint,
         .irq_base = IRQ_EINT(),
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_H0_NR,
             .label    = "GPH0",
             .to_irq = samsung_gpiolib_to_irq,
         },
     }, {
         .base    = (S5P_VA_GPIO + 0xC20),
         .config    = &gpio_cfg_noint,
         .irq_base = IRQ_EINT(),
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_H1_NR,
             .label    = "GPH1",
             .to_irq = samsung_gpiolib_to_irq,
         },
     }, {
         .base    = (S5P_VA_GPIO + 0xC40),
         .config    = &gpio_cfg_noint,
         .irq_base = IRQ_EINT(),
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_H2_NR,
             .label    = "GPH2",
             .to_irq = samsung_gpiolib_to_irq,
         },
     }, {
         .base    = (S5P_VA_GPIO + 0xC60),
         .config    = &gpio_cfg_noint,
         .irq_base = IRQ_EINT(),
         .chip    = {
             .),
             .ngpio    = S5PV210_GPIO_H3_NR,
             .label    = "GPH3",
             .to_irq = samsung_gpiolib_to_irq,
         },
     },
 };

struct s3c_gpio_chip s5pv210_gpio_4bit[]

 void __init samsung_gpiolib_add_4bit_chips(struct s3c_gpio_chip *chip,
2                        int nr_chips)
 {
     ; nr_chips--, chip++) {
         samsung_gpiolib_add_4bit(chip);
         s3c_gpiolib_add(chip);
     }
 }

 __init void s3c_gpiolib_add(struct s3c_gpio_chip *chip)
 {
     struct gpio_chip *gc = &chip->chip;//将struct s3c_gpio_chip结构体成员结构体chip赋值给struct gpio_chip结构体局部变量gc
     int ret;

     BUG_ON(!chip->base);
     BUG_ON(!gc->label);
     BUG_ON(!gc->ngpio);

     spin_lock_init(&chip->lock);

     if (!gc->direction_input)
         gc->direction_input = s3c_gpiolib_input;
     if (!gc->direction_output)
         gc->direction_output = s3c_gpiolib_output;
     if (!gc->set)
         gc->set = s3c_gpiolib_set;
     if (!gc->get)
         gc->get = s3c_gpiolib_get;

 #ifdef CONFIG_PM
     if (chip->pm != NULL) {
         if (!chip->pm->save || !chip->pm->resume)
             printk(KERN_ERR "gpio: %s has missing PM functions\n",
                    gc->label);
     } else
         printk(KERN_ERR "gpio: %s has no PM function\n", gc->label);
 #endif

     /* gpiochip_add() prints own failure message on error. */
     ret = gpiochip_add(gc);
     )
         s3c_gpiolib_track(chip);
 }

 int gpiochip_add(struct gpio_chip *chip)
 {
     unsigned long    flags;
     ;
     unsigned    id;
     int        base = chip->base;

     ))
             && ) {
         status = -EINVAL;
         goto fail;
     }

     spin_lock_irqsave(&gpio_lock, flags);

     ) {
         base = gpiochip_find_base(chip->ngpio);
         ) {
             status = base;
             goto unlock;
         }
         chip->base = base;
     }

     /* these GPIO numbers must not be managed by another gpio_chip */
     for (id = base; id < base + chip->ngpio; id++) {
         if (gpio_desc[id].chip != NULL) {
             status = -EBUSY;
             break;
         }
     }
     ) {
         for (id = base; id < base + chip->ngpio; id++) {
             gpio_desc[id].chip = chip;//在这里gpio_desc[id].chip和struct s3c_gpio_chip建立联系

             /* REVISIT:  most hardware initializes GPIOs as
              * inputs (often with pullups enabled) so power
              * usage is minimized.  Linux code should set the
              * gpio direction first thing; but until it does,
              * we may expose the wrong direction in sysfs.
              */
             gpio_desc[id].flags = !chip->direction_input
                 ? ( << FLAG_IS_OUT)
                 : ;
         }
     }

     of_gpiochip_add(chip);

 unlock:
     spin_unlock_irqrestore(&gpio_lock, flags);

     if (status)
         goto fail;

     status = gpiochip_export(chip);
     if (status)
         goto fail;

     ;
 fail:
     /* failures here can mean systems won't boot... */
     pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
         chip->,
         chip->label ? : "generic");
     return status;
 }