改进的平台设备驱动——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[] = {
      [0] = {
           .start = 0x56000050,
           .end = 0x56000050 + 8 -1,
           .flags = IORESOURCE_MEM,
      },
      [1] = {
           .start = 4,
           .end = 6,
           .flags = IORESOURCE_IO,
      },
      [2] = {
           .start = IRQ_EINT0,
           .end = IRQ_EINT0,
           .name = "IRQ_EINT0",
           .flags = IORESOURCE_IRQ,
      },
      [3] = {
           .start = IRQ_EINT2,
           .end = IRQ_EINT2,
           .name = "IRQ_EINT2",
           .flags = IORESOURCE_IRQ,
      },
      [4] = {
           .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 0;
}

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 = 0; i < pin_nums; i++){
        *ledcon &= ~(3 << (pin_start + i) * 2);
        *leddat &= ~(1 << (pin_start + i));
        *ledcon |= (1 << (pin_start + i) * 2);
    }
    
   return 0;
}

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/100);
      
      return IRQ_HANDLED;
}

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

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

static void led_time_function(unsigned long dat)
{
        
        int ls = GetPinNum(pRes);
        if(ls >= 0)
             *leddat ^= (1 << (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(0,"led",&led_fops);
    led_class = class_create(THIS_MODULE, "led");
    device_create(led_class,NULL,MKDEV(major,0),NULL,"led0");
    reg = platform_get_resource(led_dev,IORESOURCE_MEM,0);
    led_pins = platform_get_resource(led_dev,IORESOURCE_IO,0);
    ledcon = ioremap(reg->start,reg->end - reg->start + 1);
    leddat = ledcon + 1;
    pin_start = led_pins->start;
    pin_end = led_pins->end;
    pin_nums = led_pins->end - led_pins->start + 1;
    pname = (unsigned long *)kmalloc(pin_nums * sizeof(unsigned long), GFP_KERNEL);   //pin_nums个指针
    for(i = 0; 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 0;
}

static int led_remove(struct platform_device *led_dev)
{
    int i;
    del_timer(&led_timer);
    for(i = 0; 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,0));
    class_destroy(led_class);
    unregister_chrdev(major, "led");

    return 0;
}

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 0;
}

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 < 0){
          return -1;
      }

      while(1);
      return 0;
}