总线——设备——驱动模型实际应用（点灯）

不念不忘少年蓝@ 2023-07-07 15:56 48阅读 0赞

在之前的输入子系统中，我们了解到分层的概念，可以将原来的一个.c文件分为软件层、硬件层和核心层。而输入子系统帮我们写好了软件层和核心层，我们只需要写硬件层即可。那如果我们不使用系统提供的输入子系统呢？那我们就需要自己编写软件层、硬件层和核心层，也就是我们所说的总线——设备——驱动模型。  
**总线是虚拟的概念，驱动部分就是较为稳定的代码，不会轻易改变，设备就是硬件相关的代码。**  
总线、驱动和设备都有专用的结构体。  
驱动的结构体： struct platform\_driver  
设备的结构体： struct platform\_device  
而总线的结构体在平台驱动的device\_driver结构体的bus\_type中，如下图所示：  
![平台驱动结构体][20200224121639213.png]  
![包含总线的结构体][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvaGUxMg_size_16_color_FFFFFF_t_70]  
![平台驱动注册函数][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvaGUxMg_size_16_color_FFFFFF_t_70 1]  
**当我们构造好平台驱动结构体，并调用平台驱动注册函数后，驱动的名字就会放入虚拟总线中，也就是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;
    }

[20200224121639213.png]: https://img-blog.csdnimg.cn/20200224121639213.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvaGUxMg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200224121729863.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvaGUxMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvaGUxMg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200224121753983.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvaGUxMg==,size_16,color_FFFFFF,t_70