改进的平台设备驱动——dev和drv完全分离

这是平台设备：
 1 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/irq.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 #include <linux/cdev.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/bitmap.h>
 #include <asm/gpio.h>
 #include <linux/platform_device.h>

 static struct resource led_data[] = {
       [] = {
            .start = 0x56000050,
            .end = 0x56000050 +  -,
            .flags = IORESOURCE_MEM,
       },
       [] = {
            .start = ,
            .end = ,
            .flags = IORESOURCE_IO,
       },
       [] = {
            .start = IRQ_EINT0,
            .end = IRQ_EINT0,
            .name = "IRQ_EINT0",
            .flags = IORESOURCE_IRQ,
       },
       [] = {
            .start = IRQ_EINT2,
            .end = IRQ_EINT2,
            .name = "IRQ_EINT2",
            .flags = IORESOURCE_IRQ,
       },
       [] = {
            .start = IRQ_EINT11,
            .end = IRQ_EINT11,
            .name = "IRQ_EINT11",
            .flags = IORESOURCE_IRQ,
       }
 };

 static struct platform_device led_device = {
     .name            = "jz2440_led",
     .num_resources    = ARRAY_SIZE(led_data),
     .resource = led_data,
 };

 int led_dev_init(void)
 {
      platform_device_register(&led_device);
      return ;
 }

 void led_dev_exit(void)
 {
      platform_device_unregister(&led_device);
 }

 module_init(led_dev_init);
 module_exit(led_dev_exit);

 MODULE_LICENSE("GPL");

这是平台驱动： 
 1 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/irq.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 #include <linux/cdev.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/bitmap.h>
 #include <asm/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/sched.h>

 static volatile unsigned long *ledcon;
 static volatile unsigned long *leddat;

 static int pin_nums;
 static int pin_start,pin_end;

 static struct resource *pRes;
 static unsigned long *pname;
 static struct resource *irq;

 static struct class *led_class;
 static struct timer_list led_timer;

 static int led_open(struct inode *inode, struct file *file)
 {
     int i;
     for(i = ; i < pin_nums; i++){
         *ledcon &= ~( << (pin_start + i) * );
         *leddat &= ~( << (pin_start + i));
         *ledcon |= ( << (pin_start + i) * );
     }

    return ;
 }

 static struct file_operations led_fops = {
                .owner = THIS_MODULE,
                .open = led_open,

 };

 static irqreturn_t led_irq(int dat, void *pvoid)
 {
       pRes = (struct resource *)pvoid;
       mod_timer(&led_timer, jiffies + HZ/);

       return IRQ_HANDLED;
 }

 static int STRCMP(const char *str1,const char *str2)
 {
      while((*str1++) == (*str2++)){
              if(*str1 == '\0' && *str2 == '\0')
                     return ;
              else if(*str1 == '\0' || *str2 == '\0')
                     break;
      }
      return -;
 }

 static int GetPinNum(struct resource *pres)
 {
    int i;
    for(i = ; i < pin_nums; i++){
       if( == STRCMP(pres->name,(char *)*(pname + i))){
             return i;
       }
        }
    return -;
 }

 static void led_time_function(unsigned long dat)
 {

         int ls = GetPinNum(pRes);
         if(ls >= )
              *leddat ^= ( << (pin_start + ls));
 }

 static int major;
 static int led_probe(struct platform_device *led_dev)
 {
     int i;
     struct resource *reg;
     struct resource *led_pins;

     major = register_chrdev(,"led",&led_fops);
     led_class = class_create(THIS_MODULE, "led");
     device_create(led_class,NULL,MKDEV(major,),NULL,"led0");
     reg = platform_get_resource(led_dev,IORESOURCE_MEM,);
     led_pins = platform_get_resource(led_dev,IORESOURCE_IO,);
     ledcon = ioremap(reg->start,reg->end - reg->start + );
     leddat = ledcon + ;
     pin_start = led_pins->start;
     pin_end = led_pins->end;
     pin_nums = led_pins->end - led_pins->start + ;
     pname = (unsigned long *)kmalloc(pin_nums * sizeof(unsigned long), GFP_KERNEL);   //pin_nums个指针
     for(i = ; i < pin_nums; i++){
            irq = platform_get_resource(led_dev,IORESOURCE_IRQ,i);
            request_irq(irq->start, led_irq, IRQ_TYPE_EDGE_BOTH, irq->name, irq);
            *(pname + i)= (unsigned long)irq->name;
     }

     init_timer(&led_timer);
     led_timer.function = led_time_function;
     add_timer(&led_timer);

     return ;
 }

 static int led_remove(struct platform_device *led_dev)
 {
     int i;
     del_timer(&led_timer);
     for(i = ; i < pin_nums; i++){
          irq = platform_get_resource(led_dev,IORESOURCE_IRQ,i);
          free_irq(irq->start,irq);
     }
     kfree(pname);
     iounmap(ledcon);
     device_destroy(led_class, MKDEV(major,));
     class_destroy(led_class);
     unregister_chrdev(major, "led");

     return ;
 }

 static struct platform_driver led_drv = {
     .driver = {
         .name  = "jz2440_led",
         .owner = THIS_MODULE,
     },
     .probe = led_probe,
     .remove = __devexit_p(led_remove),
 };

 static int led_init(void)
 {
     platform_driver_register(&led_drv);
     return ;
 }

 static void led_exit(void)
 {
      platform_driver_unregister(&led_drv);
 }

 module_init(led_init);
 module_exit(led_exit);

 MODULE_LICENSE("GPL");

这是应用程序： 
1 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>

 int main(int argc,char **argv)
 {
       int fd = open("/dev/led0",O_RDWR);
       if(fd < ){
           return -;
       }

       while();
       return ;
 }