Linux驱动学习记录-17.platform设备驱动及其实验

最新推荐文章于 2022-03-02 15:33:43 发布
最新推荐文章于 2022-03-02 15:33:43 发布
阅读量139 收藏
点赞数 1
分类专栏： Linux Linux驱动 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41903358/article/details/121178315
版权

对于复杂的驱动，Linux系统要考虑驱动的可重用性，因此有了驱动的分层和分离。诞生了platform设备驱动。

目录标题

一、驱动的分层分离思想

对于不同的平台，有不同的驱动，但对于同一个设备，应该有相同的驱动，让平台驱动和设备驱动相匹配。这样可以减少开发量。因此最终呈现的应该这张图：

在这里插入图片描述

1.platform驱动

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;
	bool prevent_deferred_probe;
};

其中的probe函数非常重要，当设备匹配成功后probe函数会执行，由驱动提供者编写。
定义好结构体后，要在驱动入口函数调用platform_driver_register函数向Linux内核注册一个platform驱动。
在驱动卸载函数中，调用platform_driver_unregister函数卸载platform驱动。

int platform_driver_register(struct platform_driver *driver)
void platform_driver_unregister (struct platform_driver *driver)

2.驱动框架

/* 设备结构体 */
struct xxx_dev{
 struct cdev cdev;
 /* 设备结构体其他具体内容 */
};

static int xxx_open(struct inode *inode, struct file *filp) {}
static ssize_t xxx_write(struct file *filp, const char __user *buf,
size_t cnt, loff_t *offt){}
static struct file_operations xxx_fops = {
	.owner = THIS_MODULE,
	.open = xxx_open,
	.write = xxx_write,
};
static int xxx_probe(struct platform_device *dev)
{
	......
	cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 */
	/* 函数具体内容 */
	return 0;
}
static int xxx_remove(struct platform_device *dev)
{
	......
	cdev_del(&xxxdev.cdev);/* 删除 cdev */
	/* 函数具体内容 */
	return 0;
}
static const struct of_device_id xxx_of_match[] = {
	{ .compatible = "xxx-gpio" },
	{ /* Sentinel */ }
};
static struct platform_driver xxx_driver = {
	.driver = {
	.name = "xxx",
	.of_match_table = xxx_of_match,
	},
	.probe = xxx_probe,
	.remove = xxx_remove,
};
static int __init xxxdriver_init(void)
{
	return platform_driver_register(&xxx_driver);
}
static void __exit xxxdriver_exit(void)
{
	platform_driver_unregister(&xxx_driver);
}

当驱动和设备匹配成功后，probe会执行，以前在init函数的驱动初始化都放在probe里面。

3.platform设备

如果支持设备树就不需要platform设备了，可以用设备树描述。
设备的注册和注销函数如下：

int platform_device_register(struct platform_device *pdev)
void platform_device_unregister(struct platform_device *pdev)

4.platform设备框架

#define PERIPH1_REGISTER_BASE (0X20000000) /* 外设 1 寄存器首地址 */
#define PERIPH2_REGISTER_BASE (0X020E0068) /* 外设 2 寄存器首地址 */
#define REGISTER_LENGTH 4
/*资源*/
static struct resource xxx_resources[] = {
 [0] = {
 .start = PERIPH1_REGISTER_BASE,
 .end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),
 .flags = IORESOURCE_MEM,
	 },
	[1] = {
	.start = PERIPH2_REGISTER_BASE,
  .end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),
  .flags = IORESOURCE_MEM,
  },
};
/* platform 设备结构体 */
static struct platform_device xxxdevice = {
 .name = "xxx-gpio",
 .id = -1,
 .num_resources = ARRAY_SIZE(xxx_resources),
 .resource = xxx_resources,
};
/* 设备模块加载 */
 static int __init xxxdevice_init(void)
 {
 return platform_device_register(&xxxdevice);
 }

 /* 设备模块注销 */
 static void __exit xxx_resourcesdevice_exit(void)
 {
 platform_device_unregister(&xxxdevice);
 }

二、LEDplatform编写(不带设备树)

1.leddriver

参考newchaled程序,撷取主干

#define LEDDEV_CNT		1			/* 设备号长度 	*/
#define LEDDEV_NAME		"platled"	/* 设备名字 	*/
#define LEDOFF 			0
#define LEDON 			1

/* 寄存器名 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

/* leddev设备结构体 */
struct leddev_dev{
	dev_t devid;			/* 设备号	*/
	struct cdev cdev;		/* cdev		*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备		*/
	int major;				/* 主设备号	*/		
};

struct leddev_dev leddev; 	/* led设备 */
static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &leddev; /* 设置私有数据  */
	return 0;
}
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;

	retvalue = copy_from_user(databuf, buf, cnt);
	return 0;
}

/* 设备操作函数 */
static struct file_operations led_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.write = led_write,
};

/*
 * @description		: flatform驱动的probe函数，当驱动与设备匹配以后此函数就会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int led_probe(struct platform_device *dev)
{	
	int i = 0;
	int ressize[5];
	u32 val = 0;
	struct resource *ledsource[5];

	printk("led driver and device has matched!\r\n");
	/* 1、获取资源 */
	for (i = 0; i < 5; i++) {
		ledsource[i] = platform_get_resource(dev, IORESOURCE_MEM, i); /* 依次MEM类型资源 */
		if (!ledsource[i]) {
			dev_err(&dev->dev, "No MEM resource for always on\n");
			return -ENXIO;
		}
		ressize[i] = resource_size(ledsource[i]);	
	}	

	/* 2、初始化LED */
	/* 寄存器地址映射 */
 	IMX6U_CCM_CCGR1 = ioremap(ledsource[0]->start, ressize[0]);
	SW_MUX_GPIO1_IO03 = ioremap(ledsource[1]->start, ressize[1]);
  SW_PAD_GPIO1_IO03 = ioremap(ledsource[2]->start, ressize[2]);
	GPIO1_DR = ioremap(ledsource[3]->start, ressize[3]);
	GPIO1_GDIR = ioremap(ledsource[4]->start, ressize[4]);
	
	val = readl(IMX6U_CCM_CCGR1);
	val &= ~(3 << 26);				/* 清除以前的设置 */
	val |= (3 << 26);				/* 设置新值 */
	writel(val, IMX6U_CCM_CCGR1);

	/* 设置GPIO1_IO03复用功能，将其复用为GPIO1_IO03 */
	writel(5, SW_MUX_GPIO1_IO03);
	writel(0x10B0, SW_PAD_GPIO1_IO03);

	/* 设置GPIO1_IO03为输出功能 */
	val = readl(GPIO1_GDIR);
	val &= ~(1 << 3);			/* 清除以前的设置 */
	val |= (1 << 3);			/* 设置为输出 */
	writel(val, GPIO1_GDIR);

	/* 默认关闭LED1 */
	val = readl(GPIO1_DR);
	val |= (1 << 3) ;	
	writel(val, GPIO1_DR);
	
	/* 注册字符设备驱动 */
	/*1、创建设备号 */
	if (leddev.major) {		/*  定义了设备号 */
		leddev.devid = MKDEV(leddev.major, 0);
		register_chrdev_region(leddev.devid, LEDDEV_CNT, LEDDEV_NAME);
	} else {						/* 没有定义设备号 */
		alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);	/* 申请设备号 */
		leddev.major = MAJOR(leddev.devid);	/* 获取分配号的主设备号 */
	}
	
	/* 2、初始化cdev */
	leddev.cdev.owner = THIS_MODULE;
	cdev_init(&leddev.cdev, &led_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);

	/* 4、创建类 */
	leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
	if (IS_ERR(leddev.class)) {
		return PTR_ERR(leddev.class);
	}

	/* 5、创建设备 */
	leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);
	if (IS_ERR(leddev.device)) {
		return PTR_ERR(leddev.device);
	}

	return 0;
}

/*
 * @description		: platform驱动的remove函数，移除platform驱动的时候此函数会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int led_remove(struct platform_device *dev)
{
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

	cdev_del(&leddev.cdev);/*  删除cdev */
	unregister_chrdev_region(leddev.devid, LEDDEV_CNT); /* 注销设备号 */
	device_destroy(leddev.class, leddev.devid);
	class_destroy(leddev.class);
	return 0;
}

/* platform驱动结构体 */
static struct platform_driver led_driver = {
	.driver		= {
		.name	= "imx6ul-led",			/* 驱动名字，用于和设备匹配 */
	},
	.probe		= led_probe,
	.remove		= led_remove,
};
static int __init leddriver_init(void)
{
	return platform_driver_register(&led_driver);
}
static void __exit leddriver_exit(void)
{
	platform_driver_unregister(&led_driver);
}
module_init(leddriver_init);
module_exit(leddriver_exit);

2.leddevice

/* 
 * 寄存器地址定义
 */
#define CCM_CCGR1_BASE				(0X020C406C)	
#define SW_MUX_GPIO1_IO03_BASE		(0X020E0068)
#define SW_PAD_GPIO1_IO03_BASE		(0X020E02F4)
#define GPIO1_DR_BASE				(0X0209C000)
#define GPIO1_GDIR_BASE				(0X0209C004)
#define REGISTER_LENGTH				4

/* @description		: 释放flatform设备模块的时候此函数会执行	
 * @param - dev 	: 要释放的设备 
 * @return 			: 无
 */
static void	led_release(struct device *dev)
{
	printk("led device released!\r\n");	
}

/*  
 * 设备资源信息，也就是LED0所使用的所有寄存器
 */
static struct resource led_resources[] = {
	[0] = {
		.start 	= CCM_CCGR1_BASE,
		.end 	= (CCM_CCGR1_BASE + REGISTER_LENGTH - 1),
		.flags 	= IORESOURCE_MEM,
	},	
	[1] = {
		.start	= SW_MUX_GPIO1_IO03_BASE,
		.end	= (SW_MUX_GPIO1_IO03_BASE + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= SW_PAD_GPIO1_IO03_BASE,
		.end	= (SW_PAD_GPIO1_IO03_BASE + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
	[3] = {
		.start	= GPIO1_DR_BASE,
		.end	= (GPIO1_DR_BASE + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
	[4] = {
		.start	= GPIO1_GDIR_BASE,
		.end	= (GPIO1_GDIR_BASE + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
};
/*
 * platform设备结构体 
 */
static struct platform_device leddevice = {
	.name = "imx6ul-led",
	.id = -1,
	.dev = {
		.release = &led_release,
	},
	.num_resources = ARRAY_SIZE(led_resources),
	.resource = led_resources,
};
	
static int __init leddevice_init(void)
{
	return platform_device_register(&leddevice);
}
static void __exit leddevice_exit(void)
{
	platform_device_unregister(&leddevice);
}
module_init(leddevice_init);
module_exit(leddevice_exit);

三、带设备树

带设备树可以不要leddevice，直接用设备树描述设备。用设备树的属性匹配

#define LEDDEV_CNT		1				/* 设备号长度 	*/
#define LEDDEV_NAME		"dtsplatled"	/* 设备名字 	*/
#define LEDOFF 			0
#define LEDON 			1

/* leddev设备结构体 */
struct leddev_dev{
	dev_t devid;				/* 设备号	*/
	struct cdev cdev;			/* cdev		*/
	struct class *class;		/* 类 		*/
	struct device *device;		/* 设备		*/
	int major;					/* 主设备号	*/	
	struct device_node *node;	/* LED设备节点 */
	int led0;					/* LED灯GPIO标号 */
};

struct leddev_dev leddev; 		/* led设备 */
static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &leddev; /* 设置私有数据  */
	return 0;
}
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[2];
	unsigned char ledstat;

	retvalue = copy_from_user(databuf, buf, cnt);
	return 0;
}

/* 设备操作函数 */
static struct file_operations led_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.write = led_write,
};

/*
 * @description		: flatform驱动的probe函数，当驱动与
 * 					  设备匹配以后此函数就会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int led_probe(struct platform_device *dev)
{	
	printk("led driver and device was matched!\r\n");
	/* 1、设置设备号 */
	if (leddev.major) {
		leddev.devid = MKDEV(leddev.major, 0);
		register_chrdev_region(leddev.devid, LEDDEV_CNT, LEDDEV_NAME);
	} else {
		alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);
		leddev.major = MAJOR(leddev.devid);
	}
	/* 2、注册设备      */
	cdev_init(&leddev.cdev, &led_fops);
	cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);
	/* 3、创建类      */
	leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
	if (IS_ERR(leddev.class)) {
		return PTR_ERR(leddev.class);
	}
	/* 4、创建设备 */
	leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);
	if (IS_ERR(leddev.device)) {
		return PTR_ERR(leddev.device);
	}
	/* 5、初始化IO */	
	leddev.node = of_find_node_by_path("/gpioled");
	if (leddev.node == NULL){
		printk("gpioled node nost find!\r\n");
		return -EINVAL;
	} 

	leddev.led0 = of_get_named_gpio(leddev.node, "led-gpio", 0);
	if (leddev.led0 < 0) {
		printk("can't get led-gpio\r\n");
		return -EINVAL;
	}

	gpio_request(leddev.led0, "led0");
	gpio_direction_output(leddev.led0, 1); /* led0 IO设置为输出，默认高电平	*/
	return 0;
}

/*
 * @description		: platform驱动的remove函数，移除platform驱动的时候此函数会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int led_remove(struct platform_device *dev)
{
	gpio_set_value(leddev.led0, 1); 	/* 卸载驱动的时候关闭LED */

	cdev_del(&leddev.cdev);				/*  删除cdev */
	unregister_chrdev_region(leddev.devid, LEDDEV_CNT); /* 注销设备号 */
	device_destroy(leddev.class, leddev.devid);
	class_destroy(leddev.class);
	return 0;
}

/* 匹配列表 */
static const struct of_device_id led_of_match[] = {
	{ .compatible = "atkalpha-gpioled" },
	{ /* Sentinel */ }
};

/* platform驱动结构体 */
static struct platform_driver led_driver = {
	.driver		= {
		.name	= "imx6ul-led",			/* 驱动名字，用于和设备匹配 */
		.of_match_table	= led_of_match, /* 设备树匹配表 		 */
	},
	.probe		= led_probe,
	.remove		= led_remove,
};
static int __init leddriver_init(void)
{
	return platform_driver_register(&led_driver);
}
static void __exit leddriver_exit(void)
{
	platform_driver_unregister(&led_driver);
}
module_init(leddriver_init);
module_exit(leddriver_exit);

和不带设备树的驱动差不多。这里多了匹配列表，用来和设备树相匹配。

四、编译测试

参考第四章

不良高须
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
8810音频驱动linux-android。完整资料.zip
03-26
在音频设备驱动中ASoC被分为Machine、Platform和Codec三大部分。 Codec部分：负责音频解码，这部分代码全然无平台无关（设备原厂提供） Platform部分：包括了平台的音频DMA和音频接口的配置和控制（I2S，PCM。AC97...
platform平台设备_railroadzts_q_linux驱动_platform驱动_
10-03
linux驱动之平台设备的流程，函数详解
linux 驱动probe不执行
aifei7320的专栏
11-02 5603
自己的工作内容比较乱，今天gui明天内核驱动，偶尔还弄一下430。这脑子就跟饺子馅似的。 好记性不如烂笔头，稍微记录一下，只为自己留个印象。如果有碰到相同问题的，可以讨论讨论 写了个很简单的驱动程序，然后修改Kconfig，使它可以被编译成模块： config LEDS_CTL tristate "Enable LEDS config" default y
linux驱动学习（六） 应用中的linux驱动 platform_device
emowuyi
10-26 159
一个现实的linux设备和驱动通常要挂接在一种总线上，像pci，usb，iic，spi等都是总线结构，这当然不是问题，但是嵌入式系统中，Soc系统集成的独立外设控制器，挂接在soc内存空间的外设等却不依附于此类总线。 基于这个背景，linux发明了一种虚拟总线：platform总线，相应的设备称为platform_device，而驱动成为platform_driver。 注意，pl...
module_platform_driver()
铁头小哥的博客
03-02 5714
在Linux设备驱动开发过程中，在定义且初始化好platform_driver结构体变量以后，我们需要向 Linux 内核注册一个 platform 驱动。下面介绍两种方法。 方法一： /** * 在驱动入口函数里面调用platform_driver_register函数,platform_driver_register函数 * 原型如下所示： */ int platform_driver_register(struct platform_driver *driver) // driver：要注册的 p.
linux的platform驱动
qlexcel的专栏
10-25 1930
如下内容来自《【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.5.2.pdf》   将设备信息从设备驱动中剥离开来，驱动使用标准方法去获取到设备信息(比如从设备树中获取到设备信息)，然后根据获取到的设备信息来初始化设备。 这样就相当于驱动只负责驱动，设备只负责设备，想办法将两者进行匹配即可。这个就是 Linux 中的总线(bus)、驱动(driver)和设备(device)模型，也就是常说的驱动分离。总线就是驱动和设备信息的月老，负责给两者牵线搭桥，如图：   当我们向系统注册一个驱动的时候，总
linux 系统内核日志,Linux中的log介绍(三)---内核日志
weixin_39695954的博客
04-28 667
http://blog.csdn.net/henni386/article/details/7447259内核日志的存储1. 地址内核的日志存在log_buf指向的内存缓冲区中。大小在新的内核是可配置的，CONFIG_LOG_BUF_SHIFT=xx2.格式xxxxxxAPI(1) printk：内核代码中常见的日志输出方式(2)do_syslog/syslog: 内核提供的系统调用，用...
ZYNQ 7010-7020实现platform总线编程（Linux驱动）.zip
03-21
ZYNQ 7010-7020驱动程序，Linux驱动库。 项目代码可完美编译运行~
i.MX6ULL实现platform驱动【Linux驱动】.zip
02-21
i.MX6ULL Linux驱动程序。 项目代码可直接编译运行。
ARM-Linux下SPI设备的添加与驱动实现.pdf
09-06
ARM-Linux下SPI设备的添加与驱动实现 一、ARM-Linux下的SPI设备添加 ARM-Linux操作系统提供了完整而成熟的硬件抽象层和通用的SPI驱动spi-driver，可以快速实现SPI设备的添加。SPI设备的添加可以借用SPI通用驱动，...
Linux内核---17.platform_device的添加过程
wangcong02345的专栏
07-02 1225
Linux内核---17.platform_device的添加过程
Linux platform设备驱动
qq_31487199的博客
11-25 319
本文章来源于正点原子资料，记录下来，以后参考。 基于正点原子imx6ull开发板 1、platform总线 Linux系统内核使用bus_type结构体表示总线，此结构体定义在文件include/linux/device.h， bus_type 结构体内容如下： struct bus_type { const char *name; /* 总线名字*/ const char *dev_name; struct device *dev_root; struct device_attribu
Linux设备驱动工程师之路——platform类型按键驱动
mmdev
09-25 197
Linux设备驱动工程师之路——platform按键驱动 Y-Kee 转载请注明来自于衡阳师范学院08电2 Y-Kee http://blog.csdn.net/ayangke,QQ:843308498 一 、重要知识点： 1.platform设备模型 从Linux 2.6起引入了一套新的驱动管理和注册机制，platform_device和platform_driver...
platform 设备驱动实验
zhuguanlin121的博客
11-09 916
目录Linux 驱动的分离与分层驱动的分隔与分离驱动的分层platform 平台驱动模型简介platform 总线platform 驱动platform 设备硬件原理图分析试验程序编写platform 设备与驱动程序编写测试APP 编写54.5 运行测试编译驱动程序和测试APP运行测试 我们在前面几章编写的设备驱动都非常的简单，都是对IO 进行最简单的读写操作。像I2C、SPI、LCD 等这些复杂外设的驱动就不能这么去写了，Linux 系统要考虑到驱动的可重用性，因此提出了驱动的分离与分层这样的软件思路，在
linux内核调试
fengying765的专栏
03-10 575
<br />1  printk及控制台的日志级别<br />函数printk的使用方法和printf相似，用于内核打印消息。printk根据日志级别（loglevel）对消息进行分类。<br />日志级别用宏定义，日志级别宏展开为一个字符串，在编译时由预处理器将它和消息文本拼接成一个字符串，因此printk 函数中日志级别宏和格式字符串间不能有逗号。<br />下面是两个printk的例子，一个用于打印调试信息，另一个用于打印临界条件信息。<br /><br />  <br />  printk(KERN_
字符设备驱动之LED-平台设备驱动（platform设备驱动）
qingkongyeyue的博客
07-26 918
转自http://blog.csdn.net/yicao821/article/details/6783261 怎么利用平台设备驱动机制来写驱动： ------------------------------------------------------------------------- 1.先实现设备方向的：      1）看芯片手册，和原理图获取资源      2）构建平
linux 内核module_platform_driver解析
longyuelang的专栏
02-24 537
该函数实际是一个宏，module_platform_driver在include/linux/platform_device.h中定义如下： /* module_platform_driver() - Helper macro for drivers that don't do * anything special in module init/exit. This eliminates a lot of * boilerplate. Each module may only use this...
Linux驱动——platform平台驱动(无设备树)
ZigeSu的博客
07-01 636
个人声明：转发请注明出处，个人原创，实属不易。本人水平有限，文章若有不妥之处，还请留言批评指正，不胜感激。 无设备树下的platform平台驱动测试 加载完设备，再加载驱动；或者加载完驱动，再加载设备，控制台卡死，如下图： 只加载完了设备模块，在/sys/bus/platform/decives/目录下查看设备，部分显示如下： 20c9000.usbphy gpioled 20ca000.usbphy imx6q-
linux/platform_data/spi-rockchip.h 下载
最新发布
10-27
linux/platform_data/spi-rockchip.h 是一个用于Rockchip平台的SPI驱动的头文件。通过这个文件，用户可以配置和定义Rockchip平台上的SPI设备。具体来说，该文件包含了一些结构体和函数定义，用于描述和初始化SPI驱动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值