驱动源代码：
#include <linux/module.h>
#include <linux/kernel.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<mach/regs-gpio.h>
#include<mach/hardware.h>
#include<linux/device.h>
#include<linux/gpio.h>

#define DEVICE_NAME     "firstdrv_leds"  /* 加载模式后，执行”cat /proc/devices”命令看到的设备名称 */
#define LED_MAJOR       231     /* 主设备号 */



static struct class *firstdrv_class;
static struct device *firstdrv_class_devs[5];

/* bit0<=>D10, 0:亮, 1:灭
*  bit1<=>D11, 0:亮, 1:灭
*  bit2<=>D12, 0:亮, 1:灭
*/
static char leds_status = 0x0;  
static DECLARE_MUTEX(leds_lock); // 定义赋值

//static int minor;
static unsigned long gpio_va;

#define GPIO_OFT(x) ((x) - 0x56000000)
#define GPBCON  (*(volatile unsigned long *)(gpio_va + GPIO_OFT(0x56000010)))
#define GPBDAT  (*(volatile unsigned long *)(gpio_va + GPIO_OFT(0x56000014)))


static int first_drv_open(struct inode *inode, struct file *file)
{


        int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);

        switch(minor)
        {
        case 0: /* /dev/leds */
        {
           // 配置引脚为输出
           //s3c2410_gpio_cfgpin(S3C2410_GPB(5), S3C2410_GPB(5)_OUTP);
           //s3c2410_gpio_cfgpin(S3C2410_GPB(6), S3C2410_GPB(6)_OUTP);
           //s3c2410_gpio_cfgpin(S3C2410_GPB(7), S3C2410_GPB(7)_OUTP);
            //s3c2410_gpio_cfgpin(S3C2410_GPB(8), S3C2410_GPB(8)_OUTP);
            GPBCON &= ~(0x3<<(5*2));
            GPBCON |= (1<<(5*2));
            GPBCON &= ~(0x3<<(6*2));
            GPBCON |= (1<<(6*2));
            GPBCON &= ~(0x3<<(7*2));
            GPBCON |= (1<<(7*2));
            GPBCON &= ~(0x3<<(8*2));
            GPBCON |= (1<<(8*2));

             // 都输出0
            //s3c2410_gpio_setpin(S3C2410_GPB(5), 0);
            //s3c2410_gpio_setpin(S3C2410_GPB(6), 0);
            //s3c2410_gpio_setpin(S3C2410_GPB(7), 0);
             //s3c2410_gpio_setpin(S3C2410_GPB(8), 0);
            GPBDAT &= ~(1<<5);
            GPBDAT &= ~(1<<6);
            GPBDAT &= ~(1<<7);
            GPBDAT &= ~(1<<8);

            down(&leds_lock);
            leds_status = 0x0;
            up(&leds_lock);
            break;
        }
        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPB(5), S3C2410_GPIO_OUTPUT);
            s3c2410_gpio_setpin(S3C2410_GPB(5), 0);
            
            down(&leds_lock);
            leds_status &= ~(1<<0);
            up(&leds_lock);
            break;
        }
        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPB(6), S3C2410_GPIO_OUTPUT);
            s3c2410_gpio_setpin(S3C2410_GPB(6), 0);

             down(&leds_lock);
            leds_status &= ~(1<<1);
            up(&leds_lock);
            break;
        }
        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPB(7), S3C2410_GPIO_OUTPUT);
            s3c2410_gpio_setpin(S3C2410_GPB(7), 0);

            down(&leds_lock);
            leds_status &= ~(1<<2);
            up(&leds_lock);
            
            break;
        }
          case 4: /* /dev/led4 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPB(8), S3C2410_GPIO_OUTPUT);
            s3c2410_gpio_setpin(S3C2410_GPB(8), 0);

            down(&leds_lock);
            leds_status &= ~(1<<3);
            up(&leds_lock);
            break;
        }
        }
        return 0;
}


static int first_drv_read(struct file *filp, char __user *buff,
                                         size_t count, loff_t *offp)
{
        int minor = MINOR(filp->f_dentry->d_inode->i_rdev);
    char val;

    switch (minor)
    {
        case 0: /* /dev/leds */
        {
            copy_to_user(buff, (const void *)&leds_status, 1);                    
            break;
        }

        case 1: /* /dev/led1 */
        {
            down(&leds_lock);
            val = leds_status & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 2: /* /dev/led2 */
        {
            down(&leds_lock);
            val = (leds_status>>1) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 3: /* /dev/led3 */
        {
            down(&leds_lock);
            val = (leds_status>>2) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }
        case 4: /* /dev/led4 */
        {
            down(&leds_lock);
            val = (leds_status>>3) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }
}
    return 1;
   
}


static int first_drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
        int minor = MINOR( file ->f_dentry->d_inode->i_rdev);
        char val;
        copy_from_user(&val, buf, 1);

        switch (minor)
    {
        case 0: /* /dev/leds */
        {            
            s3c2410_gpio_setpin(S3C2410_GPB(5), (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPB(6), (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPB(7), (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPB(8), (val & 0x1));                       
            down(&leds_lock);
            leds_status = val;
            up(&leds_lock);
            break;
        }
        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_setpin(S3C2410_GPB(5), val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<0);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<0);               
                up(&leds_lock);
            }
            break;
        }
        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_setpin(S3C2410_GPB(6), val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<1);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<1);               
                up(&leds_lock);
            }
            break;
        }
        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_setpin(S3C2410_GPB(7), val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<2);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<2);               
                up(&leds_lock);
            }
            break;
        }
         case 4: /* /dev/led4 */
        {
            s3c2410_gpio_setpin(S3C2410_GPB(8), val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<3);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<3);               
                up(&leds_lock);
            }
            break;
          }
    }

    return 1;
}

static struct file_operations first_drv_fops = {
        .owner        =        THIS_MODULE,
        .open        =        first_drv_open,
        .read        =        first_drv_read,       
        .write        =        first_drv_write,
};

int first_drv_init(void)
{
         int ret;
        int minor = 0;

    gpio_va = ioremap(0x56000000, 0x100000);
        if (!gpio_va) {
                return -EIO;
        }

    ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &first_drv_fops);
    if (ret < 0) {
      printk(DEVICE_NAME " can't register major number ");
      return ret;
    }
       
        firstdrv_class = class_create(THIS_MODULE, "firstdrv_leds");
        if (IS_ERR(firstdrv_class))
                return PTR_ERR(firstdrv_class);

        firstdrv_class_devs[0] = device_create(firstdrv_class, NULL, MKDEV(LED_MAJOR, 0), NULL, "firstdrv_leds");
       
        for (minor = 1; minor < 5; minor++)
        {
                firstdrv_class_devs[minor] = device_create(firstdrv_class, NULL, MKDEV(LED_MAJOR, minor), NULL, "firstdrv_led%d", minor);
                if (unlikely(IS_ERR(firstdrv_class_devs[minor])))
                        return PTR_ERR(firstdrv_class_devs[minor]);
        }
        
    printk(DEVICE_NAME " initialized ");
    return 0;
       
}

void first_drv_exit(void)
{
                int minor;
            unregister_chrdev(LED_MAJOR, DEVICE_NAME);

        for (minor = 0; minor < 5; minor++)
        {
                device_unregister(firstdrv_class_devs[minor]);
        }

        class_destroy(firstdrv_class);
    iounmap(&gpio_va);
       
}

module_init(first_drv_init);
module_exit(first_drv_exit);

MODULE_LICENSE("GPL");