lv15 平台总线框架及案例 2

一、总线、设备、驱动

硬编码式的驱动开发带来的问题：

  1. 垃圾代码太多

  2. 结构不清晰

  3. 一些统一设备功能难以支持

  4. 开发效率低下

1.1 初期解决思路：设备和驱动分离

struct device来表示一个具体设备，主要提供具体设备相关的资源（如寄存器地址、GPIO、中断等等）

struct device_driver来表示一个设备驱动，一个驱动可以支持多个操作逻辑相同的设备

带来的问题-------怎样将二者进行关联（匹配）？

硬件上同一总线上的设备遵循一致的时序通信，在其基础上增加管理设备和驱动的软件功能

于是引入总线（bus），各种总线的核心框架由内核来实现，通信时序一般由SOC供应商支持

内核中用struct bus_type来表示一种总线，总线可以是实际存在的总线，也可以是虚拟总线：

  1. 实际总线：提供时序通信方式 + 管理设备和驱动

  2. 虚拟总线：仅用来管理设备和驱动（最核心的作用之一就是完成设备和驱动的匹配）

理解方式：

设备：提供硬件资源——男方

驱动：提供驱动代码——女方

总线：匹配设备和驱动——婚介所：提供沟通机制，完成拉郎配

1.2 升级思路：根据设备树，在系统启动时自动产生每个节点对应的设备

初期方案，各种device需要编码方式注册进内核中的设备管理结构中，为了进一步减少这样的编码，引进设备树

二、总线开发的基本数据类型

2.1 struct device

struct device 
{struct bus_type *bus;   //总线类型dev_t           devt;   //设备号struct device_driver *driver;   //设备驱动struct device_node  *of_node;//设备树中的节点，重要void    (*release)(struct device *dev);//删除设备，重要//.......
}；

2.2 struct device_driver

struct device_driver 
{const char      *name;  //驱动名称，匹配device用，重要struct bus_type *bus;    //总线类型struct module       *owner; //模块THIS_MODULE const struct of_device_id   *of_match_table;//用于设备树匹配 of_match_ptr(某struct of_device_id对象地址) 重要//......
};

每种总线上的设备的device和device_driver都是总线的子类

struct of_device_id
{char name[32];//设备名char type[32];//设备类型char compatible[128]; //用于device和driver的match，重点
};
//用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

三、platform总线驱动

platform是一种虚拟总线，主要用来管理那些不需要时序通信的设备

什么是Platform Bus？
在计算机中有这样一类设备，它们通过各自的设备控制器，直接和CPU连接，CPU可以通过常规的寻址操作访问它们（或者说访问它们的控制器）。这种连接方式，并不属于传统意义上的总线连接。但设备模型应该具备普适性，因此Linux就虚构了一条Platform Bus，供这些设备挂靠。

基本结构图：

Linux设备模型的核心思想是（通过xxx手段，实现xxx目的）：

1. 用Device（struct device）和Device Driver（struct device_driver）两个数据结构，分别从“有什么用”和“怎么用”两个角度描述硬件设备。这样就统一了编写设备驱动的格式，使驱动开发从论述题变为填空体，从而简化了设备驱动的开发。

2. 同样使用Device和Device Driver两个数据结构，实现硬件设备的即插即用（热拔插）。
在Linux内核中，只要任何Device和Device Driver具有相同的名字，内核就会执行Device Driver结构中的初始化函数（probe），该函数会初始化设备，使其为可用状态。
而对大多数热拔插设备而言，它们的Device Driver一直存在内核中。当设备没有插入时，其Device结构不存在，因而其Driver也就不执行初始化操作。当设备插入时，内核会创建一个Device结构（名称和Driver相同），此时就会触发Driver的执行。这就是即插即用的概念。

3. 通过"Bus-->Device”类型的树状结构解决设备之间的依赖，而这种依赖在开关机、电源管理等过程中尤为重要。试想，一个设备挂载在一条总线上，要启动这个设备，必须先启动它所挂载的总线。很显然，如果系统中设备非常多、依赖关系非常复杂的时候，无论是内核还是驱动的开发人员，都无力维护这种关系。
而设备模型中的这种树状结构，可以自动处理这种依赖关系。启动某一个设备前，内核会检查该设备是否依赖其它设备或者总线，如果依赖，则检查所依赖的对象是否已经启动，如果没有，则会先启动它们，直到启动该设备的条件具备为止。而驱动开发人员需要做的，就是在编写设备驱动时，告知内核该设备的依赖关系即可。

4. 使用Class结构，在设备模型中引入面向对象的概念，这样可以最大限度地抽象共性，减少驱动开发过程中的重复劳动，降低工作量。

3.1 核心数据类型之platform_device

继承了 struct device，可以通过name或者id_entry进行匹配

struct platform_device 
{const char    *name;    //匹配用的名字int        id;//设备id,用于在该总线上同名的设备进行编号，如果只有一个设备，则为-1struct device    dev;   //设备模块必须包含该结构体struct resource    *resource;//资源结构体 指向资源数组u32        num_resources;//资源的数量 资源数组的元素个数const struct platform_device_id    *id_entry;//设备八字
};

可以通过name或者driver_data匹配，常用name 

struct platform_device_id
{char name[20];//匹配用名称kernel_ulong_t driver_data;//需要向驱动传输的其它数据
};

总的资源

struct resource 
{resource_size_t start;  //资源起始位置   resource_size_t end;   //资源结束位置const char *name;      unsigned long flags;   //区分资源是什么类型的
};#define IORESOURCE_MEM        0x00000200
#define IORESOURCE_IRQ        0x00000400 
/*
flags 指资源类型，我们常用的是 IORESOURCE_MEM、IORESOURCE_IRQ  这两种。start 和 end 的含义会随着 flags而变更，如
​
a -- flags为IORESOURCE_MEM 时，start 、end 分别表示该platform_device占据的内存的开始地址和结束值；注意不同MEM的地址值不能重叠
​
b -- flags为 IORESOURCE_IRQ   时，start 、end 分别表示该platform_device使用的中断号的开始地址和结束值
*/

开发device方法

/***注册：把指定设备添加到内核中平台总线的设备列表，等待匹配,匹配成功则回调驱动中probe；*/
int platform_device_register(struct platform_device *);
/***注销：把指定设备从设备列表中删除，如果驱动已匹配则回调驱动方法和设备信息中的release；*/
void platform_device_unregister(struct platform_device *);

 获取platform_device.resource，其中num不是数组下标，如下图如果想使用第三个mem，num对应2

struct resource *platform_get_resource(struct platform_device *dev,unsigned int type, unsigned int num);
/*功能：获取设备资源参数：dev:平台驱动type:获取的资源类型num:对应类型资源的序号（如第0个MEM、第2个IRQ等，不是数组下标）返回值：成功：资源结构体首地址,失败:NULL
*/

3.2 核心数据类型之platform_driver

继承了 struct device_driver，driver中的name可以用于匹配

struct platform_driver 
{int (*probe)(struct platform_device *);//设备和驱动匹配成功之后调用该函数int (*remove)(struct platform_device *);//设备卸载了调用该函数void (*shutdown)(struct platform_device *);                    //关机时调用int (*suspend)(struct platform_device *, pm_message_t state);  //休眠时调用，可协助省电int (*resume)(struct platform_device *);                       //唤醒时调用struct device_driver driver;//内核里所有的驱动必须包含该结构体const struct platform_device_id *id_table;  //能够支持的设备八字数组，用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束
};

 开发platform_driver

int platform_driver_register(struct platform_driver*pdrv);
/*功能：注册平台设备驱动参数：pdrv:平台设备驱动结构体返回值：成功：0失败：错误码
*/
void platform_driver_unregister(struct platform_driver*pdrv);

四、platform的三种匹配方式

4.1 名称匹配：一个驱动只对应一个设备 ----- 优先级最低（name）

4.2 id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低

device模块中，id的name成员必须与struct platform_device中的name成员内容一致

因此device模块中，struct platform_device中的name成员必须指定

driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

4.3 设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高（不需要开发）

使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符

注意：id_table可不设置，但struct platform_driver成员driver的name成员必须设置

五、名称匹配之基础框架

5.1 框架示例

test_device.c

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>//定义资源数组static void device_release(struct device *dev)
{printk("platform: device release\n");
}struct platform_device test_device = {.id = -1,.name = "test_device",//必须初始化.dev.release = device_release, 
};static int __init platform_device_init(void)
{platform_device_register(&test_device);return 0;
}static void __exit platform_device_exit(void)
{platform_device_unregister(&test_device);
}module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

test_deriver.c

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>static int driver_probe(struct platform_device *dev)
{printk("platform: match ok!\n");return 0;
}static int driver_remove(struct platform_device *dev)
{printk("platform: driver remove\n");return 0;
}struct platform_driver test_driver = {.probe = driver_probe,.remove = driver_remove,.driver = {.name = "test_device", //必须初始化},
};static int __init platform_driver_init(void)
{platform_driver_register(&test_driver);return 0;
}static void __exit platform_driver_exit(void)
{platform_driver_unregister(&test_driver);
}module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

修改Makefile

ifeq ($(KERNELRELEASE),)ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesmodules_install:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_installclean:rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versionselseCONFIG_MODULE_SIG=n
obj-m += test_device.o
obj-m += test_driver.oendif

测试 

5.2 设备中增加资源，驱动中访问资源示例

test_device.c

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>//<---------------设计成数组形式
struct resource test_dev_res [] =
{[0] = {.start = 0x1000, .end = 0x1003, .name = "reg1", .flags = IORESOURCE_MEM},[1] = {.start = 0x2000, .end = 0x2003, .name = "reg2", .flags = IORESOURCE_MEM},[2] = {.start = 10, .end = 10, .name = "irq1", .flags = IORESOURCE_IRQ},            //中断号10[3] = {.start = 0x3000, .end = 0x3003, .name = "reg3", .flags = IORESOURCE_MEM},[4] = {.start = 100, .end = 100, .name = "irq2", .flags = IORESOURCE_IRQ},[5] = {.start = 62, .end = 62, .name = "irq3", .flags = IORESOURCE_IRQ},
};//定义资源数组static void device_release(struct device *dev)
{printk("platform: device release\n");
}struct platform_device test_device = {.id = -1,.name = "test_device",//必须初始化.dev.release = device_release,  .resource = test_dev_res,                      //<--------------- .num_resources = ARRAY_SIZE(test_dev_res),     //<--------------- 相当于n = sizeof/sizeof(t)
};static int __init platform_device_init(void)
{platform_device_register(&test_device);return 0;
}static void __exit platform_device_exit(void)
{platform_device_unregister(&test_device);
}module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

test_driver.c 

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>static int driver_probe(struct platform_device *dev)
{struct resource * pres = NULL;                        //<----------printk("platform: match ok!\n");pres = platform_get_resource(dev,IORESOURCE_MEM,2);   //2理解为第3个MEM   <-----------printk("res.start = 0x%x\n",(unsigned int)pres->start);pres = platform_get_resource(dev,IORESOURCE_IRQ,1);   //1理解为第2个IRQ   <-----------printk("res.start = %d\n",(int)pres->start);return 0;
}static int driver_remove(struct platform_device *dev)
{printk("platform: driver remove\n");return 0;
}struct platform_driver test_driver = {.probe = driver_probe,.remove = driver_remove,.driver = {.name = "test_device", //必须初始化},
};static int __init platform_driver_init(void)
{platform_driver_register(&test_driver);return 0;
}static void __exit platform_driver_exit(void)
{platform_driver_unregister(&test_driver);
}module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

测试驱动访问硬件资源 

后续把init中的实现功能放在probe中，把exit实现的功能放在remove中，便形成了驱动代码 

六、名称匹配之led实例

fs4412_led_device.c（在test_device.c基础上修改）

  • 添加结构体struct resource提供寄存器地址信息
/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>#include "leddrv.h"#define GPX1CON 0x11000C20
#define GPX1DAT 0x11000C24#define GPX2CON 0x11000C40
#define GPX2DAT 0x11000C44#define GPF3CON 0x114001E0
#define GPF3DAT 0x114001E4//<---------------修改寄存器地址
struct resource fs4412led_dev_res [] =
{[0] = {.start = GPX1CON, .end = GPX1CON+3, .name = "GPX1CON", .flags = IORESOURCE_MEM},[1] = {.start = GPX1DAT, .end = GPX1DAT+3, .name = "GPX1DAT", .flags = IORESOURCE_MEM},[2] = {.start = GPX2CON, .end = GPX2CON+3, .name = "GPX2CON", .flags = IORESOURCE_MEM},[3] = {.start = GPX2DAT, .end = GPX2DAT+3, .name = "GPX2DAT", .flags = IORESOURCE_MEM},[4] = {.start = GPF3CON, .end = GPF3CON+3, .name = "GPF3CON", .flags = IORESOURCE_MEM},[5] = {.start = GPF3DAT, .end = GPF3DAT+3, .name = "GPF3DAT", .flags = IORESOURCE_MEM},
};//定义资源数组static void fs4412led_dev_release(struct device *dev)
{printk("platform: fs4412led_dev_release is called\n");
}                                             struct platform_device fs4412led_device = {//.id = -1,.name = "fs4412led",//必须初始化.dev.release = fs4412led_dev_release,  .resource = fs4412led_dev_res,                     .num_resources = ARRAY_SIZE(fs4412led_dev_res),     
};static int __init fs4412led_dev_init(void)
{platform_device_register(&fs4412led_device);return 0;
}static void __exit fs4412led_dev_exit(void)
{platform_device_unregister(&fs4412led_device);
}module_init(fs4412led_dev_init);
module_exit(fs4412led_dev_exit);
MODULE_LICENSE("Dual BSD/GPL");

fs4412_led_driver.c（在leddrv.c基础上修改并增加自动mknod）

  • 定义结构体struct device_driver
  • 把原本init中的内容在fs4412led_driver_probe实现
  • fs4412led_driver_init中注册
  • 把原本exit中的内容在fs4412led_driver_remove实现
  • 增加fs4412led_driver_exit中注销
  • 把寄存器地址通过struct platform_device *p_pltdev从device.c中传递过来

/*platform driver框架*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>#include "leddrv.h"int major = 11;
int minor = 0;
int myled_num  = 1;struct myled_dev
{struct cdev mydev;volatile unsigned long *pled2_con;  volatile unsigned long *pled2_dat;volatile unsigned long *pled3_con;volatile unsigned long *pled3_dat;volatile unsigned long *pled4_con;volatile unsigned long *pled4_dat;volatile unsigned long *pled5_con;volatile unsigned long *pled5_dat;
/*
volatile 防止优化。对这块指针指向的内存，有时候cpu会把外设寄存器中的值读到内部寄存器中，方便下次读的时候更快.加了voltatile就不会优化，否则cpu可能会从内部寄存器中读取，而不是去外设寄存器中读取。
*/struct class *cls;       //<-----------------struct device *dvs;       //<-----------------};struct myled_dev *pgmydev = NULL;int myled_open(struct inode *pnode,struct file *pfile)
{pfile->private_data =(void *) (container_of(pnode->i_cdev,struct myled_dev,mydev));return 0;
}int myled_close(struct inode *pnode,struct file *pfile)
{return 0;
}void led_on(struct myled_dev *pmydev,int ledno)
{switch(ledno){case 2:writel(readl(pmydev->pled2_dat) | (0x1 << 7),pmydev->pled2_dat);break;case 3:writel(readl(pmydev->pled3_dat) | (0x1),pmydev->pled3_dat);break;case 4:writel(readl(pmydev->pled4_dat) | (0x1 << 4),pmydev->pled4_dat);break;case 5:writel(readl(pmydev->pled5_dat) | (0x1 << 5),pmydev->pled5_dat);break;}
}void led_off(struct myled_dev *pmydev,int ledno)
{switch(ledno){case 2:writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);break;case 3:writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);break;case 4:writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);break;case 5:writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);break;}
}long myled_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;if(arg < 2 || arg > 5){return -1;}switch(cmd){case MY_LED_ON:led_on(pmydev,arg);break;case MY_LED_OFF:led_off(pmydev,arg);break;default:return -1;}return 0;
}void ioremap_ledreg(struct myled_dev *pmydev,struct platform_device *p_pltdev)
{struct resource *pres = NULL;pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,2);pmydev->pled2_con = ioremap(pres->start,4);pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,3);pmydev->pled2_dat = ioremap(pres->start,4);pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,0);pmydev->pled3_con = ioremap(pres->start,4);pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,1);pmydev->pled3_dat = ioremap(pres->start,4);pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,4);pmydev->pled4_con = ioremap(pres->start,4);pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,5);pmydev->pled4_dat = ioremap(pres->start,4);pmydev->pled5_con = pmydev->pled4_con;pmydev->pled5_dat = pmydev->pled4_dat;
}void iounmap_ledreg(struct myled_dev *pmydev)
{iounmap(pmydev->pled2_con);pmydev->pled2_con = NULL;iounmap(pmydev->pled2_dat);pmydev->pled2_dat = NULL;iounmap(pmydev->pled3_con);pmydev->pled3_con = NULL;iounmap(pmydev->pled3_dat);pmydev->pled3_dat = NULL;iounmap(pmydev->pled4_con);pmydev->pled4_con = NULL;iounmap(pmydev->pled4_dat);pmydev->pled4_dat = NULL;pmydev->pled5_con = NULL;pmydev->pled5_dat = NULL;
}void set_output_ledconreg(struct myled_dev *pmydev)
{writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0x1 << 28),pmydev->pled2_con);writel((readl(pmydev->pled3_con) & (~(0xF))) | (0x1),pmydev->pled3_con);writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0x1 << 16),pmydev->pled4_con);writel((readl(pmydev->pled5_con) & (~(0xF << 20))) | (0x1 << 20),pmydev->pled5_con);writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
}struct file_operations myops = {.owner = THIS_MODULE,.open = myled_open,.release = myled_close,.unlocked_ioctl = myled_ioctl,
};static int fs4412led_driver_probe(struct platform_device *p_pltdev)
{int ret = 0;dev_t devno = MKDEV(major,minor);/*申请设备号*/ret = register_chrdev_region(devno,myled_num,"myled");if(ret){ret = alloc_chrdev_region(&devno,minor,myled_num,"myled");if(ret){printk("get devno failed\n");return -1;}major = MAJOR(devno);//容易遗漏，注意}pgmydev = (struct myled_dev *)kmalloc(sizeof(struct myled_dev),GFP_KERNEL);if(NULL == pgmydev){unregister_chrdev_region(devno,myled_num);printk("kmalloc failed\n");return -1;}memset(pgmydev,0,sizeof(struct myled_dev)); //这里的memset并非c库的函数，而是内核自己实现的memset函数/*给struct cdev对象指定操作函数集*/	cdev_init(&pgmydev->mydev,&myops);/*将struct cdev对象添加到内核对应的数据结构里*/pgmydev->mydev.owner = THIS_MODULE;cdev_add(&pgmydev->mydev,devno,myled_num);/*ioremap*/ioremap_ledreg(pgmydev,p_pltdev);/*con-register set output*/set_output_ledconreg(pgmydev);pgmydev->cls = class_create(THIS_MODULE, "myled");    //<-----------------if(IS_ERR(pgmydev->cls)){printk("class_create failed\n");cdev_del(&pgmydev->mydev);unregister_chrdev_region(devno,myled_num);return -1;}pgmydev->dvs = device_create(pgmydev->cls, NULL, devno, NULL,"myled");   //<-----------------if(pgmydev->dvs == NULL){printk("device_create failed\n");class_destroy(pgmydev->cls);cdev_del(&pgmydev->mydev);unregister_chrdev_region(devno,myled_num);return -1;}return 0;
}static int fs4412led_driver_remove(struct platform_device *dev)
{dev_t devno = MKDEV(major,minor);/*iounmap*/iounmap_ledreg(pgmydev);cdev_del(&pgmydev->mydev);unregister_chrdev_region(devno,myled_num);kfree(pgmydev);pgmydev = NULL;printk("platform: driver remove\n");return 0;
}struct platform_driver fs4412led_driver = {.probe = fs4412led_driver_probe,.remove = fs4412led_driver_remove,.driver = {.name = "fs4412led", //必须初始化},
};static int __init fs4412led_driver_init(void)
{platform_driver_register(&fs4412led_driver);return 0;
}static void __exit fs4412led_driver_exit(void)
{platform_driver_unregister(&fs4412led_driver);return;
}module_init(fs4412led_driver_init);
module_exit(fs4412led_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

Makefile

ifeq ($(KERNELRELEASE),)ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesmodules_install:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_installclean:rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versionselseCONFIG_MODULE_SIG=n
obj-m += fs4412_led_device.o
obj-m += fs4412_led_driver.oendif

编译

测试

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/681000.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Python爬虫之文件存储#5

Python爬虫之文件存储#5

爬虫专栏&#xff1a;http://t.csdnimg.cn/WfCSx 文件存储形式多种多样&#xff0c;比如可以保存成 TXT 纯文本形式&#xff0c;也可以保存为 JSON 格式、CSV 格式等&#xff0c;本节就来了解一下文本文件的存储方式。 TXT 文本存储 将数据保存到 TXT 文本的操作非常简单&am…
阅读更多...
Python基于大数据的电影预测分析系统

Python基于大数据的电影预测分析系统

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝30W、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
多尺度神经网络新一代创新！精度与速度完美平衡，实现多领域应用落地

多尺度神经网络新一代创新！精度与速度完美平衡，实现多领域应用落地

多尺度神经网络的设计通常基于对频率原则的理解&#xff0c;目的是为了解决高频成分学习慢的问题。这些网络通过特殊设计&#xff0c;比如给高频成分加更多的权重或者将高频成分平移到低频&#xff0c;来提高学习效率。 为了满足在不同层次上理解和处理数据的需求&#xff0c;…
阅读更多...
【Java程序设计】【C00254】基于Springboot的java学习平台（有论文）

【Java程序设计】【C00254】基于Springboot的java学习平台（有论文）

基于Springboot的java学习平台&#xff08;有论文&#xff09;&#xff09; 项目简介项目获取开发环境项目技术运行截图 项目简介 这是一个基于Springboot的学习平台 本系统分为系统功能模块、管理员功能模块、教师功能模块以及学生功能模块。 系统功能模块&#xff1a;在平台…
阅读更多...
GEE：梯度提升树（Gradient Boosting Tree）回归教程（样本点、特征添加、训练、精度、参数优化）

GEE：梯度提升树（Gradient Boosting Tree）回归教程（样本点、特征添加、训练、精度、参数优化）

作者：CSDN @ _养乐多_ 对于分类问题，这个输出通常是一个类别标签 ，而对于回归问题，输出通常是一个连续的数值。回归可以应用于多种场景，包括预测土壤PH值、土壤有机碳、土壤水分、碳密度、生物量、气温、海冰厚度、不透水面积百分比、植被覆盖度等。 本文将介绍在Google…
阅读更多...
【Linux学习】线程互斥与同步

【Linux学习】线程互斥与同步

目录 二十.线程互斥 20.1 什么是线程互斥&#xff1f; 20.2 为什么需要线程互斥? 20.3 互斥锁mutex 20.4 互斥量的接口 20.4.1 互斥量初始 20.4.2 互斥量销毁 20.4.3 互斥量加锁 20.4.4 互斥量解锁 20.4.5 互斥量的基本原理 20.4.6 带上互斥锁后的抢票程序 20.5 死锁问题 死锁…
阅读更多...
React18原理: 核心包结构与两大工作循环

React18原理: 核心包结构与两大工作循环

React核心包结构 1 ) react react基础包&#xff0c;只提供定义 react组件(ReactElement)的必要函数一般来说需要和渲染器(react-dom,react-native)一同使用在编写react应用的代码时, 大部分都是调用此包的api比如, 我们定义组件的时候&#xff0c;就是它提供的class Demo ext…
阅读更多...
[VulnHub靶机渗透] Nyx

[VulnHub靶机渗透] Nyx

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【python】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收藏…
阅读更多...
2月3日作业

2月3日作业

1.编程实现单向循环链表的头插&#xff0c;头删、尾插、尾删 尾插/头插&#xff0c;头删&#xff0c;尾删&#xff1a; 头文件&#xff1a; #ifndef __HEAD_H_ #define __HEAD_H_#include<stdio.h> #include<string.h> #include<stdlib.h>enum {FALSE-1,SU…
阅读更多...
Spring Cloud Gateway 网关路由

Spring Cloud Gateway 网关路由

一、路由断言 路由断言就是判断路由转发的规则 二、路由过滤器 1. 路由过滤器可以实现对网关请求的处理&#xff0c;可以使用 Gateway 提供的&#xff0c;也可以自定义过滤器 2. 路由过滤器 GatewayFilter&#xff08;默认不生效&#xff0c;只有配置到路由后才会生效&#x…
阅读更多...
浅谈进制的转换

浅谈进制的转换

本文创作灵感来自CSDN咸鱼WCY 的 咸鱼小白学嵌入式之C语言&#xff08;2.进制&#xff09; 博主更完就没更了&#xff0c;决定书接上回&#xff08;喜 进制是个啥 要理解进制&#xff0c;首先哈&#xff0c;咱得知道不同进制的含义 说到底&#xff0c;各个进制其实有点像在…
阅读更多...
学生公寓|基于Springboot的学生公寓管理系统设计与实现(源码+数据库+文档)

学生公寓|基于Springboot的学生公寓管理系统设计与实现(源码+数据库+文档)

学生公寓管理系统目录 目录 基于Springboot的学生公寓管理系统设计与实现 一、前言 二、系统功能设计 三、系统实现 1、宿舍列表 2、宿舍公告信息管理 3、宿舍公告类型管理 四、数据库设计 1、实体ER图 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八…
阅读更多...
学生成绩管理系统|基于Springboot的学生成绩管理系统设计与实现(源码+数据库+文档)

学生成绩管理系统|基于Springboot的学生成绩管理系统设计与实现(源码+数据库+文档)

学生成绩管理系统目录 目录 基于Springboot的学生成绩管理系统设计与实现 一、前言 二、系统功能设计 三、系统实现 1、管理员功能模块 2、学生功能模块 3、教师功能模块 四、数据库设计 1、实体ER图 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八、源…
阅读更多...
AI引领低代码革命：未来应用开发的新主流

AI引领低代码革命：未来应用开发的新主流

距离ChatGPT发布已经过去快一年时间。 在这一年里&#xff0c;以ChatGPT为代表的自然语言处理领域的重大进步&#xff0c;为我们的对话系统和语言交流提供了更加智能和自然的体验。随着ChatGPT的应用不断扩大&#xff0c;人们开始认识到人工智能&#xff08;AI&#xff09;技术…
阅读更多...
elasticsearch增删改查

elasticsearch增删改查

一、数据类型 1、字符串类型 &#xff08;1&#xff09;text &#xff08;2&#xff09;keyword 2、数值类型 &#xff08;1&#xff09;long、integer、short、byte、float、double 3、日期类型 &#xff08;1&#xff09;date 4、布尔类型 &#xff08;1&#xff0…
阅读更多...
【AI绘图】初见·小白入门stable diffusion的初体验

【AI绘图】初见·小白入门stable diffusion的初体验

首先&#xff0c;感谢赛博菩萨秋葉aaaki的整合包 上手 stable diffusion还是挺好上手的&#xff08;如果使用整合包的话&#xff09;&#xff0c;看看界面功能介绍简单写几个prompt就能生成图片了。 尝试 我在网上找了一张赛博朋克边缘行者Lucy的cos图&#xff0c;可能会侵…
阅读更多...
开发自定义标记应用程序

开发自定义标记应用程序

开发自定义标记应用程序 问题陈述 Larry Williams 是ABC Inc.公司的CEO，他希望公司能够拥有一个交互式网站以向访问网站的用户表示问候并显示当前时间。他还希望最终用户能够指定主页的背景颜色。您是公司的网站管理员。Larry要您修改网站的主页，以便向最终用户显示自定义问…
阅读更多...
鸿蒙小案例-你画我猜

鸿蒙小案例-你画我猜

鸿蒙小案例-你画我猜 1.准备组件(组件布局) 2.实现跟随鼠标画笔画出图案功能 3.实现复制上面的画笔的图案功能 4.其他小功能1.组件的准备 画布的组件官方给的API是Canvas&#xff0c;需要传递一个参数CanvasRenderingContext2D 直接搜索API 使用官方案例 private settings: …
阅读更多...
【蓝桥杯Python】试题 算法训练 藏匿的刺客

【蓝桥杯Python】试题 算法训练 藏匿的刺客

资源限制 内存限制&#xff1a;256.0MB C/C时间限制&#xff1a;1.0s Java时间限制&#xff1a;3.0s Python时间限制&#xff1a;5.0s 问题描述 强大的kAc建立了强大的帝国&#xff0c;但人民深受其学霸及23文化的压迫&#xff0c;于是勇敢的鹏决心反抗。 　　kAc帝国防守…
阅读更多...
书生谱语-基于 InternLM 和 LangChain 搭建知识库

书生谱语-基于 InternLM 和 LangChain 搭建知识库

大语言模型与外挂知识库&#xff08;RAG&#xff09;的优缺点 RAG方案构建与优化 作业 在创建web_demo时&#xff0c;需要根据教程将服务器端口映射到本地端口&#xff0c;另外需要将链接的demo从服务器中复制出来&#xff0c;不要直接从服务器打开demo页面&#xff0c;不然会…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023