Linux 驱动开发 五：Linux LED驱动开发

最新推荐文章于 2024-04-09 00:26:16 发布
最新推荐文章于 2024-04-09 00:26:16 发布
阅读量1.1k 收藏 5
点赞数 1
分类专栏： Linux驱动开发 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_/article/details/121864784
版权

Linux 下的任何外设驱动，最终都是要配置相应的硬件寄存器。所以本章的 LED 灯驱动最终也是对 I.MX6ULL 的 IO 口进行配置，与裸机实验不同的是，在 Linux 下编写驱动要符合 Linux 的驱动框架。

一、地址映射

Linux 内核启动的时候会初始化 MMU，设置好内存映射，设置好以后 CPU 访问的都是虚拟地址。

在编写驱动之前，我们需要先简单了解一下 MMU 这个神器，MMU 全称叫做 Memory Manage Unit，也就是内存管理单元。在老版本的 Linux 中要求处理器必须有 MMU，但是现在 Linux 内核已经支持无MMU的处理器了。MMU主要完成的功能如下：

1、完成虚拟空间到物理空间的映射。

2、内存保护，设置存储器的访问权限，设置虚拟存储空间的缓冲特性。

物理内存和虚拟内存之间的转换，需要用到两个函数：ioremap 和 iounmap。

1、ioremap

ioremap 函 数用于获取指定物理地址空间对应的虚拟地 址空 间，定 义在 arch/arm/include/asm/io.h 文件中，定义如下：

#define ioremap(cookie,size) __arm_ioremap((cookie), (size), MT_DEVICE)

void __iomem * __arm_ioremap(phys_addr_t phys_addr, size_t size, unsigned int mtype)
{
	return arch_ioremap_caller(phys_addr, size, mtype, __builtin_return_address(0));
}

2、iounmap

卸载驱动的时候需要使用 iounmap 函数释放掉 ioremap 函数所做的映射，iounmap 函数原型如下：

void iounmap (volatile void __iomem *addr)

二、I/O内存访问函数

这里说的 I/O 是输入/输出的意思。这里涉及到两个概念：I/O 端口和 I/O 内存。

当外部寄存器或内存映射到 IO 空间时，称为 I/O 端口。

当外部寄存器或内存映射到内存空间时，称为 I/O 内存。

但是对于 ARM 来说没有 I/O 空间这个概念，因此 ARM 体系下只有 I/O 内存(可以直接理解为内存)。使用 ioremap 函数将寄存器的物 理地址映射到虚拟地址以后，我们就可以直接通过指针访问这些地址，但是 Linux 内核不建议这么做，而是推荐使用一组操作函数来对映射后的内存进行读写操作。

1、读操作函数

u8 readb(const volatile void __iomem *addr)
u16 readw(const volatile void __iomem *addr)
u32 readl(const volatile void __iomem *addr)

readb、readw 和 readl 这三个函数分别对应 8bit、16bit 和 32bit 读操作，参数 addr 就是要读取写内存地址，返回值就是读取到的数据。

2、写操作函数

void writeb(u8 value, volatile void __iomem *addr)
void writew(u16 value, volatile void __iomem *addr)
void writel(u32 value, volatile void __iomem *addr)

writeb、writew 和 writel 这三个函数分别对应 8bit、16bit 和 32bit 写操作，参数 value 是要写入的数值，addr 是要写入的地址。

三、硬件原理图分析

https://blog.csdn.net/OnlyLove_/article/details/121757151

四、实验程序编写

1、工程配置

创建工程文件 c_cpp_properties.json，并添加头文件路径。

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/include",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/arch/arm/include",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/arch/arm/include/generated"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "gnu17",
            "cppStandard": "gnu++14",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

2、搭建驱动框架

1、led.c

#include "linux/init.h"
#include "linux/module.h"
#include "linux/fs.h"
#include "linux/types.h"

// struct inode 声明在 linux/fs.h 中
// struct file 声明在 linux/fs.h 中
int led_open (struct inode *i, struct file *f)
{
    // printk 声明在 linux/printk.h 中
    printk("led open!\r\n");
    return 0;
}

int led_release (struct inode *i, struct file *f)
{
    printk("led release!\r\n");
    return 0;
}

// ssize_t 定义在 linux/types.h 中
// __user 定义在 linux/compiler.h 中
// size_t 定义在 linux/types.h 中
// loff_t 定义在 linux/types.h 中
ssize_t led_read (struct file *f, char __user *b, size_t c, loff_t * l)
{
    printk("led read!\r\n");
    return 0;
}

ssize_t led_write (struct file *f, const char __user *b, size_t c, loff_t *l)
{
    printk("led write!\r\n");
    return 0;
}

// 声明在 linux/fs.h 头文件中
static struct file_operations fops = {
    .open = led_open,
    .release = led_release,
    .read = led_read,
    .write = led_write,
};

/* 驱动入口函数 */
static int __init led_init(void)
{
    /* 入口函数具体内容 */
    int retvalue = 0;
    // 声明在 linux/fs.h 头文件中
    retvalue = register_chrdev(200,"chrdev",&fops);
    if(retvalue < 0){
        /* 字符设备注册失败 */
    }
    return 0;
}

/* 驱动出口函数 */
static void __exit led_exit(void)
{
    /* 出口函数具体内容 */
    // 声明在 linux/fs.h 头文件中
    unregister_chrdev(200,"chrdev");
}

// 声明在 linux/init.h 头文件中
/* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(led_init);
module_exit(led_exit);

// 声明在 linux/module.h 头文件中
MODULE_LICENSE("GPL");

2、makefile

KERNELDIR := /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := led.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

3、LED 初始化

1、映射相关寄存器地址

/* 寄存器物理地址 */
#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)

/* 映射后的寄存器虚拟地址指针 */
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;

以上通过 define 定义物理地址，通过变量保存虚拟地址。物理地址和虚拟地址映射通过 open 函数完成，代码如下：

int led_open (struct inode *i, struct file *f)
{
    // printk 声明在 linux/printk.h 中
    printk("led open!\r\n");
    /* 寄存器地址映射 */
    IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
	SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
  	SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
	GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
	GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);

    return 0;
}

取消地址映射通过 close 函数完成，代码如下：

int led_release (struct inode *i, struct file *f)
{
    printk("led release!\r\n");
    /* 取消映射 */
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

    return 0;
}

2、初始化

初始化包括配置时钟、引脚复用、引脚电平。

初始化代码在 open 函数中完成，添加初始化程序后代码如下：

int led_open (struct inode *i, struct file *f)
{
    u32 val = 0;

    // printk 声明在 linux/printk.h 中
    printk("led open!\r\n");
    /* 1、寄存器地址映射 */
    IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
	SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
  	SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
	GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
	GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);

    /* 2、使能GPIO1时钟 */
	val = readl(IMX6U_CCM_CCGR1);
	val &= ~(3 << 26);	/* 清楚以前的设置 */
	val |= (3 << 26);	/* 设置新值 */
	writel(val, IMX6U_CCM_CCGR1);

	/* 3、设置GPIO1_IO03的复用功能，将其复用为
	 *    GPIO1_IO03，最后设置IO属性。
	 */
	writel(5, SW_MUX_GPIO1_IO03);
	
	/*寄存器SW_PAD_GPIO1_IO03设置IO属性
	 *bit 16:0 HYS关闭
	 *bit [15:14]: 00 默认下拉
     *bit [13]: 0 kepper功能
     *bit [12]: 1 pull/keeper使能
     *bit [11]: 0 关闭开路输出
     *bit [7:6]: 10 速度100Mhz
     *bit [5:3]: 110 R0/6驱动能力
     *bit [0]: 0 低转换率
	 */
	writel(0x10B0, SW_PAD_GPIO1_IO03);

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

	/* 5、默认关闭LED */
	val = readl(GPIO1_DR);
	val |= (1 << 3);	
	writel(val, GPIO1_DR);

    return 0;
}

3、控制 LED 灭亮

控制灯的灭亮，由 write 函数完成。

1、从用户空间拷贝数据
extern inline long
copy_from_user(void *to, const void __user *from, long n)
{
	return __copy_tofrom_user(to, (__force void *)from, n, from);
}

/*
 * to：内核空间数据存储缓存
 * from：指向用户空间数据缓存区
 * n：拷贝数据长度
 */
2、LED 亮灭控制
#define LEDOFF 	0				/* 关灯 */
#define LEDON 	1				/* 开灯 */

/*
 * @description		: LED打开/关闭
 * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
 * @return 			: 无
 */
void led_switch(u8 sta)
{
	u32 val = 0;
	if(sta == LEDON) {
		val = readl(GPIO1_DR);
		val &= ~(1 << 3);	
		writel(val, GPIO1_DR);
	}else if(sta == LEDOFF) {
		val = readl(GPIO1_DR);
		val|= (1 << 3);	
		writel(val, GPIO1_DR);
	}	
}
3、write 代码
/*
 * @description	: 向设备写数据 
 * @param - f 	: 设备文件，表示打开的文件描述符
 * @param - b 	: 要写给设备写入的数据
 * @param - c 	: 要写入的数据长度
 * @param - l 	: 相对于文件首地址的偏移
 * @return 		: 写入的字节数，如果为负值，表示写入失败
 */
ssize_t led_write (struct file *f, const char __user *b, size_t c, loff_t *l)
{
    int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;

    printk("led write!\r\n");
	retvalue = copy_from_user(databuf, b, c);
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

	if(ledstat == LEDON) {	
		led_switch(LEDON);		/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		led_switch(LEDOFF);	/* 关闭LED灯 */
	}
	
    return 0;
}

4、驱动代码

#include "linux/init.h"
#include "linux/module.h"
#include "linux/fs.h"
#include "linux/types.h"
#include "asm/io.h"
#include "asm/uaccess.h"

#define LED_MAJOR		200		/* 主设备号 */
#define LED_NAME		"led" 	/* 设备名字 */

#define LEDOFF 	0				/* 关灯 */
#define LEDON 	1				/* 开灯 */

/* 寄存器物理地址 */
#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)

/* 映射后的寄存器虚拟地址指针 */
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;

/*
 * @description		: LED打开/关闭
 * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
 * @return 			: 无
 */
void led_switch(u8 sta)
{
	u32 val = 0;
	if(sta == LEDON) {
		val = readl(GPIO1_DR);
		val &= ~(1 << 3);	
		writel(val, GPIO1_DR);
	}else if(sta == LEDOFF) {
		val = readl(GPIO1_DR);
		val|= (1 << 3);	
		writel(val, GPIO1_DR);
	}	
}

// struct inode 声明在 linux/fs.h 中
// struct file 声明在 linux/fs.h 中
int led_open (struct inode *i, struct file *f)
{
    u32 val = 0;

    // printk 声明在 linux/printk.h 中
    printk("led open!\r\n");
    /* 1、寄存器地址映射 */
    IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
	SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
  	SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
	GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
	GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);

    /* 2、使能GPIO1时钟 */
	val = readl(IMX6U_CCM_CCGR1);
	val &= ~(3 << 26);	/* 清楚以前的设置 */
	val |= (3 << 26);	/* 设置新值 */
	writel(val, IMX6U_CCM_CCGR1);

	/* 3、设置GPIO1_IO03的复用功能，将其复用为
	 *    GPIO1_IO03，最后设置IO属性。
	 */
	writel(5, SW_MUX_GPIO1_IO03);
	
	/*寄存器SW_PAD_GPIO1_IO03设置IO属性
	 *bit 16:0 HYS关闭
	 *bit [15:14]: 00 默认下拉
     *bit [13]: 0 kepper功能
     *bit [12]: 1 pull/keeper使能
     *bit [11]: 0 关闭开路输出
     *bit [7:6]: 10 速度100Mhz
     *bit [5:3]: 110 R0/6驱动能力
     *bit [0]: 0 低转换率
	 */
	writel(0x10B0, SW_PAD_GPIO1_IO03);

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

	/* 5、默认关闭LED */
	val = readl(GPIO1_DR);
	val |= (1 << 3);	
	writel(val, GPIO1_DR);

    return 0;
}

int led_release (struct inode *i, struct file *f)
{
    printk("led release!\r\n");
    /* 取消映射 */
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

    return 0;
}

// ssize_t 定义在 linux/types.h 中
// __user 定义在 linux/compiler.h 中
// size_t 定义在 linux/types.h 中
// loff_t 定义在 linux/types.h 中
ssize_t led_read (struct file *f, char __user *b, size_t c, loff_t * l)
{
    printk("led read!\r\n");
    return 0;
}

/*
 * @description	: 向设备写数据 
 * @param - f 	: 设备文件，表示打开的文件描述符
 * @param - b 	: 要写给设备写入的数据
 * @param - c 	: 要写入的数据长度
 * @param - l 	: 相对于文件首地址的偏移
 * @return 		: 写入的字节数，如果为负值，表示写入失败
 */
ssize_t led_write (struct file *f, const char __user *b, size_t c, loff_t *l)
{
    int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;

    printk("led write!\r\n");
	retvalue = copy_from_user(databuf, b, c);
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

	if(ledstat == LEDON) {	
		led_switch(LEDON);		/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		led_switch(LEDOFF);	/* 关闭LED灯 */
	}
	
    return 0;
}

// 声明在 linux/fs.h 头文件中
static struct file_operations fops = {
    .open = led_open,
    .release = led_release,
    .read = led_read,
    .write = led_write,
};

/* 驱动入口函数 */
static int __init led_init(void)
{
    /* 入口函数具体内容 */
    int retvalue = 0;
    // 声明在 linux/fs.h 头文件中
    retvalue = register_chrdev(LED_MAJOR,LED_NAME,&fops);
    if(retvalue < 0){
        /* 字符设备注册失败 */
    }
    return 0;
}

/* 驱动出口函数 */
static void __exit led_exit(void)
{
    /* 出口函数具体内容 */
    // 声明在 linux/fs.h 头文件中
    unregister_chrdev(LED_MAJOR,LED_NAME);
}

// 声明在 linux/init.h 头文件中
/* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(led_init);
module_exit(led_exit);

// 声明在 linux/module.h 头文件中
MODULE_LICENSE("GPL");

5、应用程序代码

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "stdio.h"

int main(int argc, char *argv[])
{
    int fd = 0, retvalue = 0;
    char writebuf[1] = "";
    fd = open(argv[1],O_RDWR);
    if(fd < 0){
        printf("Can't open file %s\r\n", argv[1]);
        return -1;
    }
     writebuf[0] = atoi(argv[2]);
    // 打开 led
    write(fd, writebuf, 1);
    retvalue = close(fd);
    if(retvalue < 0){
        printf("Can't close file %s\r\n", argv[1]);
        return -1;
    }

    return 0;
}

编译应用程序指令如下：

arm-linux-gnueabihf-gcc led_app.c -o led_app

6、验证

1、加载驱动

加载驱动：

/ # ls
bin      etc      led_app  linuxrc  proc     sbin     tmp
dev      led.ko   lib      mnt      root     sys      usr
/ # insmod led.ko
/ #
/ # lsmod
Module                  Size  Used by    Tainted: G
led                     2274  0

加载驱动也可以使用 modprobe 命令。

查看驱动加载情况：

/ # cat /proc/devices
Character devices:
  1 mem
  4 /dev/vc/0
  4 tty
  5 /dev/tty
  5 /dev/console
  5 /dev/ptmx
  7 vcs
 10 misc
 13 input
 29 fb
 81 video4linux
 89 i2c
 90 mtd
116 alsa
128 ptm
136 pts
180 usb
189 usb_device
200 led
207 ttymxc
216 rfcomm
226 drm
249 ttyLP
250 iio
251 watchdog
252 ptp
253 pps
254 rtc

Block devices:
  1 ramdisk
259 blkext
  7 loop
  8 sd
 31 mtdblock
 65 sd
 66 sd
 67 sd
 68 sd
 69 sd
 70 sd
 71 sd
128 sd
129 sd
130 sd
131 sd
132 sd
133 sd
134 sd
135 sd
179 mmc
/ #

2、创建设备文件

命令如下所示：

mknod /dev/led c 200 0

查看创建结果：

/ # ls /dev/
autofs              ram11               tty36
bus                 ram12               tty37
console             ram13               tty38
cpu_dma_latency     ram14               tty39
dri                 ram15               tty4
fb0                 ram2                tty40
full                ram3                tty41
fuse                ram4                tty42
hwrng               ram5                tty43
i2c-0               ram6                tty44
i2c-1               ram7                tty45
input               ram8                tty46
kmsg                ram9                tty47
led                 random              tty48
loop-control        rtc0                tty49
loop0               snd                 tty5
loop1               tty                 tty50
loop2               tty0                tty51
loop3               tty1                tty52
loop4               tty10               tty53
loop5               tty11               tty54
loop6               tty12               tty55
loop7               tty13               tty56
mem                 tty14               tty57
memory_bandwidth    tty15               tty58
mmcblk0             tty16               tty59
mmcblk0p1           tty17               tty6
mmcblk1             tty18               tty60
mmcblk1boot0        tty19               tty61
mmcblk1boot1        tty2                tty62
mmcblk1p1           tty20               tty63
mmcblk1p2           tty21               tty7
mmcblk1rpmb         tty22               tty8
mxc_asrc            tty23               tty9
network_latency     tty24               ttymxc0
network_throughput  tty25               ttymxc1
null                tty26               ubi_ctrl
pps0                tty27               urandom
pps1                tty28               vcs
ptmx                tty29               vcs1
ptp0                tty3                vcsa
ptp1                tty30               vcsa1
pts                 tty31               video0
pxp_device          tty32               watchdog
ram0                tty33               watchdog0
ram1                tty34               zero
ram10               tty35               ⚌A-⚌
/ #

通过以上日志可以确定驱动文件加载成功。

3、运行应用程序

点亮 LED，指令如下：

./led_app /dev/led 1

熄灭 LED ，指令如下：

./led_app /dev/led 1

4、测试

执行 app 程序日志如下：

/ # ./led_app /dev/led 1
led open!
led write!
led release!
/ # ./led_app /dev/led 0
led open!
led write!
led release!
/ #

通过观察开发板上 LED 灯状态，可以确定 LED 可以正常打开和关闭。

lqonlylove
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leds.rar_led 驱动_linux 驱动_驱动开发
09-24
嵌入式linux驱动开发-lED驱动开发实例及测试
Linux led_class子系统
hwx1546的博客
03-01 1994
LED子系统是Linux内核中有关LED的框架，开发者可以使用这个框架来进行LED设备的注册。 LED子系统程序在/driver/leds/led-class.c中 led_classdev结构体 内核把LED设备的属性抽象成了一个结构体，开发人员需要填充这个结构体里面的的一些成员变量，然后注册到内核中。 struct led_classdev { const char *name; enum led_brightness brightness; enum led_brightness ma
Linux内核自带的LED灯驱动框架：驱动与设备匹配分析
最新发布
wojiaxiaohuang2014的博客
04-09 195
Linux内核自带的LED灯驱动的框架
linux子系统led,【linux】led子系统
weixin_32046225的博客
04-29 439
前言接下来记录的是 led子系统目前不涉及驱动源码linux子系统在 Linux 系统中绝大多数硬件设备都有非常成熟的驱动框架驱动工程师使用这些框架添加与板子相关的硬件支持建立硬件与Linux内核的联系内核再通过统一文件系统接口呈现给用户用户通过对应的设备文件控制硬件。led子系统led子系统相关描述可在内核源码 Documentation/leds/leds-class.txt 了解。led子系...
Linux驱动入门（6.1）LED驱动---设备树
在嵌入式嵌入式领域奋斗的程序猿的博客
08-07 512
韦东山Linux驱动入门实验班（6）LED驱动---设备树
【Linux 驱动篇（二）】LED 驱动开发
K3169的博客
06-27 1773
Linux 下的任何外设驱动，最终都是要配置相应的硬件寄存器。
Linux驱动之Linux自带的LED灯驱动
Wang_XB_3434的博客
09-03 1098
每日一个简单的驱动，日久方长，对Linux驱动就越来越熟悉，也越来容易学会写驱动程序。今日进行第六个Linux自带的led设备驱动。
【linux驱动开发】-驱动入门之LED
钟浩森的博客
08-21 1147
可以清晰的看出与之前的区别，之前我们写"散养的"驱动时，我们首先需要注册，这中间就需要调用很多的内核函数，除此之外我们要在sys/class/下面创建类和设备，也需要调用其他的函数，而在驱动框架里，所有的一切都在框架里帮我们完成了，也就是在led-class.c中的led_classdev_register函数！都能够实现，并且程序里使用的led_classdev结构体，也是驱动框架里提供，我们直接用就可以，他的一些变量，比如name、brightness、brightness_set函数指针都是可以直接
Linux驱动基础篇（一）GPIO（上）LED驱动
AF_INET6的博客
10-24 301
Linux驱动基础（一）GPIO（上）LED驱动
Linux驱动_LED驱动
qq_42174306的博客
01-16 1414
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、地址映射 1、在裸机实验的时候操作LED等外设实际上是操作相应外设的寄存器。 2、linux下驱动开发最终要操作的也是寄存器，然而在Linux环境下不能直接对寄存器的物理地址进行操作。比如LED寄存器的地址为0x01010101,在裸机开发环境下可以直接对该地址进行赋值，而Lin......
NXP i.MX8系列平台开发讲解 - 3.1 Linux 之LED子系统(一)
hywelstar的嵌入式软件开发笔记
08-16 410
Linux内核的LED子系统是一种重要的框架，用于管理和控制设备上的LED指示灯。在嵌入式系统和物联网设备中，LED子系统发挥着关键作用，为开发者提供了一种统一的方式来控制和定制LED的行为和效果。这些API可以在应用程序中调用，以实现对LED的控制和操作。内核空间：内核配置LED相关的GPIO，初始化，提供各种控制LED的接口，并且在Linux 系统需要通过设备节点形式呈现，可通过读写设备节点去控制。可以控制LED的亮灭，闪烁模式，可以灵活改变相关触发方式；修改触发方式，改为时间，可以实现使得灯亮多久。
2_led_IMX6ULL、Linux驱动开发_源码
10-04
IMX6ULL芯片，LINUX驱动LED实例
fs4412_led.zip_FS4412 LED_FSLEDDRIVER_LED_linux_驱动开发
09-24
在fs4412开发板上的，led驱动源代码。
树莓派驱动开发实战，基于Raspberry Pi 3B+平台学习Linux驱动开发的记录与分享
01-04
基于Raspberry Pi 3B+平台学习Linux驱动开发的记录与分享，旨于对Linux内核模块机制的熟悉、常见接口的Linux驱动实现、常用模块的原理掌握。原则上，每个驱动模块我都会编写对应的教程（因为我相信掌握知识最有效的...
基于嵌入式Linux的LED驱动开发与应用.pdf
09-06
基于嵌入式Linux的LED驱动开发与应用.pdf
Linux LED子系统详解
nb124667390的博客
05-29 208
Linux LED子系统详解
linux下led驱动程序,linux 驱动之led子系统（一）
weixin_32770541的博客
05-01 520
linux系统基于3.4平台msm8x26android 4.4.2linux 中存在众多的子系统，包括led子系统，input子系统等等，那么就先从最简单的led子系统开始分析了。这次要尽量分析彻底。在andorid中的led系统是在\kernel\drivers\leds，在经常分析代码的过程中，首先需要看的是Kconfig和makefile文件，那好先看Kconfigmenuconfig N...
Linux驱动入门（4）LED驱动
在嵌入式嵌入式领域奋斗的程序猿的博客
07-19 1465
详细介绍了GPIO子系统和引脚号获取，并且分析了韦东山Linux驱动实验班的LED驱动代码
linux内核自带的LED驱动（六）
qq_41169114的博客
05-31 339
选择“LED Support for GPIO connected LEDs”，将其编译进 Linux 内核此选项上按下“Y”键，使此选项前面变为“”⑤可以设置“default-state”属性值，可以设置为 on、 off 或 keep，为 on 的时候 LED 灯默。认打开，为 off 的话 LED 灯默认关闭，为 keep 的话 LED 灯保持当前模式。heartbeat： LED 灯作为心跳指示灯，可以作为系统运行提示灯。timer： LED 灯周期性闪烁，由定时器驱动，闪烁频率可以修改。
linux驱动开发学习笔记
09-14
学习Linux驱动开发可以从以下几个方面入手： 1. 了解驱动加载方式：根据引用所提到的，Linux驱动有两种运行方式，一种是将驱动编译进内核，另一种是将驱动编译成模块。了解这两种方式的特点和使用场景可以帮助你...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值