《Linux驱动》分层分离

led_drv

#include <linux/module.h>
#include <linux/compat.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/smp_lock.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/vt.h>
#include <linux/init.h>
#include <linux/linux_logo.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/console.h>
#include <linux/kmod.h>
#include <linux/err.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include <linux/platform_device.h>

static int major  = 0;
static volatile unsigned long *gpxcon;
static volatile unsigned long *gpxdat;
static int pin;
static struct class *cls;

static int led_open(struct inode *inode, struct file *file)
{
    *gpxcon &= ~(0xf << (pin * 4));
    *gpxcon |= (0x1 << (pin * 4));
    return 0;
}

static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
{
    char val;
    copy_from_user(&val, buf, 1);
    if (val == 0)
    {
        /* 开灯 */
        *gpxdat &= ~(1<<pin);
    }
    else
    {
        *gpxdat |= (1<<pin);
    }
    return 1;   
}

static struct file_operations led_fops = {
    .owner    = THIS_MODULE,
    .open     = led_open,
    .write    = led_write,
};


static int led_probe(struct platform_device *dev)
{
    struct resource *res;

    res = platform_get_resource(dev, IORESOURCE_MEM, 0);
    gpxcon = ioremap(res->start, res->end - res->start + 1);
    gpxdat = gpxcon + 1;

    res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
    pin = res->start;

    major = register_chrdev(0, "led", &led_fops);
    cls = class_create(THIS_MODULE, "led"); /* sysfs */
    device_create(cls, NULL, MKDEV(major, 0), NULL, "led");

    return 0;
}

static int led_remove(struct platform_device *dev)
{
    device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    unregister_chrdev(major, "led");
    iounmap(gpxcon);
    return 0;
}

/* 1. 分配一个platform_driver */
/* 2. 设置 */
static struct platform_driver led_drv = {
    .probe      = led_probe,
    .remove     = __devexit_p(led_remove),
    .driver     = {
        .name   = "up6410_led",
        .owner  = THIS_MODULE,
    },
};

/* 3. 注册 */

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

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

module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

led_dev

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/platform_device.h>


/* 1. 分配一个platform_device */
/* 2. 设置 */
static struct resource led_resoures[] = {
    [0] = {
        .start  = 0x7F008820,  /* GPMCON */
        .end    = 0x7F008827,
        .flags  = IORESOURCE_MEM,
    },

    [1] = {
        .start  = 1,
        .end    = 1,
        .flags  = IORESOURCE_IRQ,
    },
};

static void led_release(struct device *dev)
{
}

static struct platform_device led_dev = {
    .name           = "up6410_led",
    .id             = 0,
    .num_resources  = 2,
    .resource       = led_resoures,
    .dev            = {
            .release = led_release,
    },
};

/* 3. 注册 */

static int led_dev_init(void)
{
    platform_device_register(&led_dev);
    return 0;
}

static void led_dev_exit(void)
{
    platform_device_del(&led_dev);
}

module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

led_test.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void print_usage(char *file)
{
    printf("Usage:\n");
    printf("%s <on|off>\n", file);
}

int main(int argc, char **argv)
{
    int fd;
    char val;

    if (argc != 2)
    {
        print_usage(argv[0]);
        return -1;
    }

    fd = open("/dev/led", O_RDWR);
    if (fd < 0)
    {
        printf("can't open /dev/led\n");
        return -1;
    }


    if (strcmp(argv[1], "on") == 0)
    {
        val = 0;
    }
    else
    {
        val = 1;
    }

    write(fd, &val, 1);

    return 0;
}