总线——设备——驱动模型实际应用（点灯）-蒲公英云

在之前的输入子系统中，我们了解到分层的概念，可以将原来的一个.c文件分为软件层、硬件层和核心层。而输入子系统帮我们写好了软件层和核心层，我们只需要写硬件层即可。那如果我们不使用系统提供的输入子系统呢？那我们就需要自己编写软件层、硬件层和核心层，也就是我们所说的总线——设备——驱动模型。
总线是虚拟的概念，驱动部分就是较为稳定的代码，不会轻易改变，设备就是硬件相关的代码。
总线、驱动和设备都有专用的结构体。
驱动的结构体： struct platform_driver
设备的结构体： struct platform_device
而总线的结构体在平台驱动的device_driver结构体的bus_type中，如下图所示：

包含总线的结构体

当我们构造好平台驱动结构体，并调用平台驱动注册函数后，驱动的名字就会放入虚拟总线中，也就是bus的结构体中，等待设备和其匹配，当有设备匹配成功，那么就会调用平台驱动中的probe函数，进行一系列操作。

driver.c文件内容

#include <linux/module.h>
#include <linux/version.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
static struct class *led_class;
static volatile unsigned long *gpio_con;
static volatile unsigned long *gpio_dat;
static int pin1;
static int pin2 ;
static int pin3;
static int led_open(struct inode *inode, struct file *file)
{
    *gpio_con &= ~((3 << (2*pin1)) | (3 << (2*pin2)) | (3 << (2*pin3)));
    *gpio_con |= ((1 << (2*pin1)) | (1 << (2*pin2)) | (1 << (2*pin3)));
    return 0;
}
static void delay(int time)
{
    volatile int i = time;
    while(i--);
}
static void led_light(void)   //流水灯函数
{
        int val = 0;
        int tmp;
        int time = 100;
        *gpio_dat &= ~((1 << pin1) | (1 << pin2) | (1 << pin3));
        delay(10000000);
        *gpio_dat |= ((1 << pin1) | (1 << pin2) | (1 << pin3));
        delay(10000000);
        while (time--)
        {
            tmp = ~val;
            tmp &= 7;
            *gpio_dat &= ~(7<<4);
            *gpio_dat |= (tmp<<4);
            delay(10000000);
            val++;
            if (val == 8)
                val =0;
        }
}
static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    int val;
    copy_from_user(&val, buf, count);
    if (val == 1) {
        *gpio_dat &= ~(1 << pin1);
        printk("led is light\n");
    }
    else if (val == 2){
        printk("water lamp\n");
        led_light();
    }
    else {
        *gpio_dat |= ((1 << pin1) | (1 << pin2) | (1 << pin3));
        printk("led is unlight");
    }
    return 0;
}
static struct file_operations led_ops = {
      //注册file_operations结构体，便于上层应用进行调用
    .owner = THIS_MODULE,
    .open = led_open,
    .write = led_write,
};
int major;
static int led_probe(struct platform_device *pdev)   //构造probe函数，当驱动和设备匹配后就会调用probe函数
{
    printk("led device is connected\n");
    struct resource *res;
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);   //获取设备资源
    gpio_con = ioremap(res->start, res->end - res->start + 1);  //进行io映射
    gpio_dat = gpio_con + 1;  
    res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    pin1 = res->start;
    pin2 = pin1 + 1;
    pin3 = pin1 + 2;
    major = register_chrdev(0, "myled", &led_ops);
    led_class = class_create(THIS_MODULE, "myled");  //创建类和设备
    class_device_create(led_class, NULL, MKDEV(major, 0), NULL, "led");  //在linux系统上就会显示为 /dev/led文件
    return 0;
}
static int led_remove(struct platform_device *pdev)
{
    printk("led is remove\n");
    class_device_destroy(led_class, MKDEV(major, 0));
    class_destroy(led_class);
    unregister_chrdev(major, "myled");
    iounmap(gpio_con);
    return 0;
}
static struct platform_driver led_drv = {
    .probe = led_probe,
    .remove = led_remove,
    .driver = {
        .name = "myled",
    },
};
static void led_dev_init(void)
{
    platform_driver_register(&led_drv);  //注册平台驱动
}
static void led_dev_exit(void)
{
    platform_driver_unregister(&led_drv);
}
module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

device.c内容，硬件方面的，便于改动

#include <linux/module.h>
#include <linux/version.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>
static struct resource led_resource[] = {
    [0] = {
        .start = 0x56000050,
        .end   = 0x56000050 + 8 - 1,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = 4,
        .end   = 4,
        .flags = IORESOURCE_IRQ,
    },
};
static void led_release(void)
{
}
static struct platform_device led_dev = {
    .name = "myled",
    .id   = -1,
    .num_resources = ARRAY_SIZE(led_resource),
    .resource = led_resource,
    .dev = {
        .release = led_release,
    },
};
static void led_dev_init(void)
{
    platform_device_register(&led_dev);
}
static void led_dev_exit(void)
{
    platform_device_unregister(&led_dev);
}
module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

应用层内容 test.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
int main(int argc, char **argv)
{
    int fd;
    int val = 0;
    if ((fd=open("/dev/led", O_RDWR)) < 0) {
      //打开设备，实际上调用的是驱动中的led_open函数
        printf("can't open /dev/led\n");
    }
    if (strcmp("on", argv[1]) == 0) {
      //根据输入的不同内容变换点灯方式
        val = 1;
    }
    else if (strcmp("water", argv[1]) == 0) {
        val = 2;
    }
    else {
        val = 3;
    }
    printf("val = %d\n", val);
    write(fd, &val, 4);
    return 0;
}