Linux led子系统分析3

于 2024-12-19 14:26:48 发布
阅读量670 收藏 30
点赞数 12
CC 4.0 BY-SA版权
分类专栏： Linux内核子系统 文章标签： linux b树 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zouhaicheng/article/details/144584777

Linux led子系统分析3（基于Linux6.6）---驱动实现介绍

一、led设备驱动开发流程

Linux LED 设备驱动开发是通过内核提供的 LED 子系统进行的，涉及到 LED 设备的注册、控制、触发机制的实现，以及硬件层面的支持。以下是一个典型的 Linux LED 设备驱动开发流程：

1. 理解 LED 子系统

Linux LED 子系统提供了一种标准化的接口，用于控制 LED 设备。LED 设备可以是通过 GPIO、PWM 或其他硬件方式控制的设备。LED 驱动的核心组件包括 led_classdev、led_trigger 等。

2. 准备硬件支持

LED 设备驱动需要对接特定的硬件平台，比如 GPIO 或 PWM 以实现 LED 控制。如果硬件支持这些接口，可以直接使用；如果不支持，则需要通过适当的硬件驱动（如 GPIO 驱动）来进行控制。

3. 编写 LED 驱动代码

一个典型的 LED 驱动代码结构包括以下步骤：

a) 定义 led_classdev 结构

led_classdev 结构体是每个 LED 设备的核心，包含了 LED 的状态（如亮度、闪烁模式等）和控制操作。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/gpio.h>

static struct led_classdev my_led;

static void my_led_brightness_set(struct led_classdev *led_cdev, enum led_brightness brightness)
{
    /* 在这里实现硬件控制，比如通过 GPIO 控制 LED 的亮灭 */
    if (brightness == LED_OFF) {
        gpio_set_value(GPIO_PIN, 0);  // 关闭 LED
    } else {
        gpio_set_value(GPIO_PIN, 1);  // 打开 LED
    }
}

static int __init my_led_init(void)
{
    int ret;

    /* 初始化 GPIO 引脚 */
    ret = gpio_request(GPIO_PIN, "my_led");
    if (ret) {
        pr_err("Failed to request GPIO\n");
        return ret;
    }

    /* 设置 LED 控制操作 */
    my_led.brightness_set = my_led_brightness_set;
    my_led.default_trigger = NULL;  // 可选：设置默认触发器

    /* 注册 LED 设备 */
    ret = led_classdev_register(NULL, &my_led);
    if (ret) {
        pr_err("Failed to register LED class device\n");
        gpio_free(GPIO_PIN);
        return ret;
    }

    pr_info("LED driver initialized\n");
    return 0;
}

static void __exit my_led_exit(void)
{
    led_classdev_unregister(&my_led);
    gpio_free(GPIO_PIN);
    pr_info("LED driver exited\n");
}

module_init(my_led_init);
module_exit(my_led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple LED driver example");

b) LED 操作函数

  • brightness_set：这是 LED 驱动的核心函数，用于设置 LED 的亮度或状态（例如：开/关、闪烁等）。
  • default_trigger：设置默认的 LED 触发器，控制 LED 根据系统状态（如 CPU 使用率、网络活动等）自动变化。

c) 初始化与清理

  • 在初始化函数中，注册 LED 设备（led_classdev_register），并配置相关操作函数（如亮度设置函数）。
  • 在退出函数中，注销 LED 设备（led_classdev_unregister），并释放硬件资源（如 GPIO）。

4. 触发器（Triggers）支持

Linux LED 子系统支持多种 LED 触发器，可以根据系统事件（如 CPU 使用率、网络活动等）自动控制 LED 的状态。

a) 使用预定义触发器

在 LED 驱动中，可以通过 default_trigger 属性指定一个预定义的触发器：

my_led.default_trigger = "cpu0";

这里 "cpu0" 触发器表示 CPU 0 的使用情况会触发 LED 状态的变化。其他常见的触发器包括 "heartbeat"（心跳闪烁），"netdev"（网络活动），"input"（输入事件）等。

b) 定义自定义触发器

如果需要开发自定义触发器，可以定义一个新的触发器，并通过 led_trigger_register 注册。例如，创建一个触发器根据某个硬件事件来控制 LED。

5. 硬件控制层

如果 LED 通过 GPIO 控制，需要在驱动中直接操作 GPIO 引脚。在此过程中，需要了解如何请求、设置和释放 GPIO 引脚。

a) GPIO 控制

通常，LED 设备会通过 GPIO 引脚控制开关。以下是如何设置和控制 GPIO：

int gpio_request(int gpio, const char *label);
int gpio_direction_output(int gpio, int value);
void gpio_set_value(int gpio, int value);
void gpio_free(int gpio);

二、led trigger驱动开发流程

在 Linux 中，LED 子系统支持使用触发器（Triggers）自动控制 LED 的状态。LED 触发器是根据系统状态或事件来改变 LED 的亮灭状态，比如 CPU 活动、网络流量等。开发一个 LED trigger 驱动，需要理解 Linux LED 子系统、触发器的工作机制，并结合相应的硬件或软件事件来设计触发器的行为。

以下是开发 Linux LED trigger 驱动的基本流程：

1. 理解 LED Trigger 的概念

LED trigger 是 LED 子系统的一部分，它会根据某些系统事件或状态来自动调整 LED 的状态。常见的 LED trigger 包括：

  • cpu0、cpu1（根据 CPU 的活动来控制 LED）
  • heartbeat（LED 闪烁表示系统健康状态）
  • netdev（网络设备活动）
  • input（输入设备的活动）
  • timer（基于定时器的 LED 闪烁）

2. 准备工作

开发 LED trigger 驱动之前，需要了解以下内容：

  • LED 子系统：LED 设备通常通过 struct led_classdev 注册。
  • 触发器类型：LED 可以绑定一个触发器，触发器定义了 LED 如何响应系统状态变化。
  • 触发器的回调函数：触发器事件发生时，会调用相应的回调函数来更新 LED 状态。

3. 创建 LED 驱动框架

开发 LED 驱动的第一步是定义并注册一个 LED 设备，通常需要创建一个 led_classdev 结构并设置亮度控制函数。

示例：定义一个简单的 LED 设备

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/gpio.h>

static struct led_classdev my_led;

/* 设置 LED 亮度控制函数 */
static void my_led_brightness_set(struct led_classdev *led_cdev, enum led_brightness brightness)
{
    /* 控制硬件的 GPIO 或其他接口来改变 LED 状态 */
    if (brightness == LED_OFF) {
        gpio_set_value(GPIO_PIN, 0);  // 关闭 LED
    } else {
        gpio_set_value(GPIO_PIN, 1);  // 打开 LED
    }
}

static int __init my_led_init(void)
{
    int ret;

    /* 初始化 GPIO */
    ret = gpio_request(GPIO_PIN, "my_led");
    if (ret) {
        pr_err("Failed to request GPIO\n");
        return ret;
    }

    /* 设置 LED 的亮度控制函数 */
    my_led.brightness_set = my_led_brightness_set;
    my_led.default_trigger = NULL;  // 暂时不使用触发器

    /* 注册 LED 设备 */
    ret = led_classdev_register(NULL, &my_led);
    if (ret) {
        pr_err("Failed to register LED class device\n");
        gpio_free(GPIO_PIN);
        return ret;
    }

    pr_info("LED driver initialized\n");
    return 0;
}

static void __exit my_led_exit(void)
{
    led_classdev_unregister(&my_led);
    gpio_free(GPIO_PIN);
    pr_info("LED driver exited\n");
}

module_init(my_led_init);
module_exit(my_led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple LED driver with trigger support");

4. 实现和使用触发器

LED 触发器的关键是使用 led_trigger 和 led_classdev 配合来控制 LED 设备的状态变化。每个触发器都有一个相应的回调函数，当触发器事件发生时，内核会调用这个函数来改变 LED 的状态。

定义触发器

Linux 提供了一些内置的触发器，开发者可以选择其中的某个触发器，也可以实现自定义触发器。触发器通常是基于系统状态的事件，比如 CPU 活动或网络流量。

#include <linux/leds.h>
#include <linux/interrupt.h>
#include <linux/sched.h>

static void my_led_trigger_handler(struct led_classdev *led_cdev)
{
    /* 触发器的回调函数，用于更新 LED 状态 */
    if (led_cdev->brightness == LED_OFF) {
        led_cdev->brightness = LED_FULL;
    } else {
        led_cdev->brightness = LED_OFF;
    }
    led_classdev_notify(led_cdev);
}

/* 定义自定义触发器 */
static struct led_trigger my_led_trigger = {
    .name = "my_trigger",
    .handler = my_led_trigger_handler,
};

绑定触发器到 LED

在驱动的初始化过程中，可以选择性地将触发器与 LED 设备进行绑定。这样，当触发器事件发生时，LED 状态会根据触发器的回调函数进行更新。

static int __init my_led_init(void)
{
    int ret;

    ret = gpio_request(GPIO_PIN, "my_led");
    if (ret) {
        pr_err("Failed to request GPIO\n");
        return ret;
    }

    my_led.brightness_set = my_led_brightness_set;
    my_led.default_trigger = "my_trigger";  // 绑定自定义触发器
    ret = led_classdev_register(NULL, &my_led);
    if (ret) {
        pr_err("Failed to register LED class device\n");
        gpio_free(GPIO_PIN);
        return ret;
    }

    /* 注册自定义触发器 */
    ret = led_trigger_register(&my_led_trigger);
    if (ret) {
        pr_err("Failed to register trigger\n");
        led_classdev_unregister(&my_led);
        gpio_free(GPIO_PIN);
        return ret;
    }

    pr_info("LED driver with trigger initialized\n");
    return 0;
}

static void __exit my_led_exit(void)
{
    led_trigger_unregister(&my_led_trigger);
    led_classdev_unregister(&my_led);
    gpio_free(GPIO_PIN);
    pr_info("LED driver exited\n");
}

5. 常见触发器类型

Linux 内核提供了多种内置触发器类型，开发者可以选择不同的触发器来控制 LED。例如：

  • cpu0, cpu1: 根据 CPU 的负载情况控制 LED 闪烁，常用于显示系统的健康状态。
  • heartbeat: 使 LED 以一定的间隔周期性闪烁，常用于表示系统是否正常运行。
  • netdev: 根据网络设备的活动（例如发送/接收数据包）来控制 LED。
  • input: 基于输入设备的事件（如键盘按键）来控制 LED。

例如，使用 heartbeat 触发器：

my_led.default_trigger = "heartbeat";

此时，LED 会在系统运行时定期闪烁，表示系统正常。

三、led-gpio驱动开发说明

3.1、相关数据结构说明

struct led_gpio_data为该gpio-led设备的数据结构:

  1. 其内部包含led_classdev类型的变量led_dev，用于实现led设备的注册；
  2. 包含gpio的值；
  3. 该gpio是否为低有效

struct led_gpio_platform_data主要用于gpio-led对应的platform device设备向platform driver传递参数，参数包含gpio的值、gpio是否低有效，默认gpio值、默认选择的led-trigger名称等内容。

include/linux/leds.h 

/*
 * Generic LED platform data for describing LED names and default triggers.
 */
struct led_info {
	const char	*name;
	const char	*default_trigger;
	int		flags;
};

struct led_platform_data {
	int		num_leds;
	struct led_info	*leds;
};

struct led_properties {
	u32		color;
	bool		color_present;
	const char	*function;
	u32		func_enum;
	bool		func_enum_present;
	const char	*label;
};

typedef int (*gpio_blink_set_t)(struct gpio_desc *desc, int state,
				unsigned long *delay_on,
				unsigned long *delay_off);

/* For the leds-gpio driver */
struct gpio_led {
	const char *name;
	const char *default_trigger;
	unsigned 	gpio;
	unsigned	active_low : 1;
	unsigned	retain_state_suspended : 1;
	unsigned	panic_indicator : 1;
	unsigned	default_state : 2;
	unsigned	retain_state_shutdown : 1;
	/* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
	struct gpio_desc *gpiod;
};
#define LEDS_GPIO_DEFSTATE_OFF		LEDS_DEFSTATE_OFF
#define LEDS_GPIO_DEFSTATE_ON		LEDS_DEFSTATE_ON
#define LEDS_GPIO_DEFSTATE_KEEP		LEDS_DEFSTATE_KEEP

struct gpio_led_platform_data {
	int 		num_leds;
	const struct gpio_led *leds;

#define GPIO_LED_NO_BLINK_LOW	0	/* No blink GPIO state low */
#define GPIO_LED_NO_BLINK_HIGH	1	/* No blink GPIO state high */
#define GPIO_LED_BLINK		2	/* Please, blink */
	gpio_blink_set_t	gpio_blink_set;
};

3.2、代码实现说明

  1. 在platform driver的probe函数中，完成struct led_gpio_data类型变量的创建，对应gpio的申请及设置为输出模式，并完成struct led_classdev类型变量的设置（主要设置函数brightness_set、默认选择的led-trigger的名称等内容，接着调用led_classdev_register完成注册即可），如下是代码实现：

 drivers/leds/leds-gpio.c

static int gpio_led_probe(struct platform_device *pdev)
{
	struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
	struct gpio_leds_priv *priv;
	int i, ret = 0;

	if (pdata && pdata->num_leds) {
		priv = devm_kzalloc(&pdev->dev, struct_size(priv, leds, pdata->num_leds),
				    GFP_KERNEL);
		if (!priv)
			return -ENOMEM;

		priv->num_leds = pdata->num_leds;
		for (i = 0; i < priv->num_leds; i++) {
			const struct gpio_led *template = &pdata->leds[i];
			struct gpio_led_data *led_dat = &priv->leds[i];

			if (template->gpiod)
				led_dat->gpiod = template->gpiod;
			else
				led_dat->gpiod =
					gpio_led_get_gpiod(&pdev->dev,
							   i, template);
			if (IS_ERR(led_dat->gpiod)) {
				dev_info(&pdev->dev, "Skipping unavailable LED gpio %d (%s)\n",
					 template->gpio, template->name);
				continue;
			}

			ret = create_gpio_led(template, led_dat,
					      &pdev->dev, NULL,
					      pdata->gpio_blink_set);
			if (ret < 0)
				return ret;
		}
	} else {
		priv = gpio_leds_create(pdev);
		if (IS_ERR(priv))
			return PTR_ERR(priv);
	}

	platform_set_drvdata(pdev, priv);

	return 0;
}

四、led-trigger-pwm-gpio驱动开发说明

led-trigger-pwm-gpio 是 Linux LED 子系统中的一个触发器驱动，用于通过 PWM（脉宽调制）控制 GPIO（通用输入输出）引脚的状态，从而实现 LED 的亮度调节或其他类似的控制。该驱动利用 PWM 信号控制 GPIO 引脚的输出，以精确调节 LED 的亮度或使其闪烁。

以下是开发和使用 led-trigger-pwm-gpio 驱动的基本步骤和说明。

1. 背景和目标

该驱动将 GPIO 控制的 LED 与 PWM 控制器结合使用。通过使用 PWM，可以控制 GPIO 引脚的输出脉冲宽度，从而调节 LED 的亮度。例如，增加 PWM 信号的占空比可以使 LED 更亮，反之，则使 LED 更暗。该驱动将作为一个触发器使用，允许用户根据系统状态自动控制 LED。

2. 开发环境准备

确保你的开发环境已经具备以下条件：

  • 适当的硬件支持：一个通过 GPIO 控制的 LED 和 PWM 控制器（如某些嵌入式板子或者外接的 PWM 控制器）。
  • 必须的内核配置：内核必须启用 LED 支持和 PWM 支持。具体来说，检查以下配置选项：
  • CONFIG_LEDS_CLASS=m
CONFIG_PWM=m

3. PWM 控制器和 LED 子系统

Linux 内核中的 LED 子系统可以通过 led_classdev 结构来管理 LED 的状态，同时 PWM 控制器可以通过 pwm 子系统来控制脉宽调制信号。led-trigger-pwm-gpio 驱动将二者结合起来，提供一个基于 PWM 的 LED 触发器。

GPIO 与 PWM 驱动

在实现 led-trigger-pwm-gpio 驱动之前，首先需要了解如何使用 PWM 来控制 GPIO 引脚。例如，PWM 控制器通过设置频率和占空比来调节引脚的电平。

  • 频率（Frequency）：决定 PWM 信号的周期。
  • 占空比（Duty Cycle）：决定信号“高”电平持续的时间占整个周期的比例，通常以百分比表示。

4. led-trigger-pwm-gpio 驱动实现

在内核中实现 led-trigger-pwm-gpio 驱动时，关键是将 PWM 信号与 LED 状态结合起来。这个驱动需要能够根据系统事件（如 CPU 活动、网络活动等）控制 PWM 信号的频率或占空比，从而调节 LED 的亮度或闪烁模式。

LED 设备注册与 PWM 控制

首先，需要创建一个 LED 设备，并将其与 PWM 控制器绑定。以下是一个简单的例子，展示如何创建一个 LED 设备，并使用 PWM 来控制 GPIO 引脚。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pwm.h>
#include <linux/gpio.h>
#include <linux/leds.h>
#include <linux/of.h>

static struct pwm_device *pwm_led;  // PWM 控制器设备
static struct led_classdev led_cdev;  // LED 设备

/* 控制 LED 亮度的回调函数 */
static void pwm_led_brightness_set(struct led_classdev *led_cdev,
                                   enum led_brightness brightness)
{
    unsigned long duty_cycle;

    /* 计算 PWM 占空比，假设 brightness 范围是 0 到 255 */
    duty_cycle = (brightness * 100) / 255;  // 转换为百分比

    /* 设置 PWM 占空比 */
    pwm_config(pwm_led, duty_cycle * pwm_led->period / 100, pwm_led->period);
    pwm_enable(pwm_led);
}

static int __init pwm_led_init(void)
{
    int ret;

    /* 初始化 LED 类设备 */
    led_cdev.name = "pwm_led";
    led_cdev.brightness_set = pwm_led_brightness_set;
    led_cdev.default_trigger = NULL;

    ret = led_classdev_register(NULL, &led_cdev);
    if (ret) {
        pr_err("Failed to register LED class device\n");
        return ret;
    }

    /* 初始化 PWM 控制器 */
    pwm_led = pwm_request(0, "pwm_led");  // 获取 PWM 设备
    if (IS_ERR(pwm_led)) {
        pr_err("Failed to request PWM\n");
        led_classdev_unregister(&led_cdev);
        return PTR_ERR(pwm_led);
    }

    pwm_config(pwm_led, 0, 1000000);  // 设置 PWM 初始占空比为 0%
    pwm_enable(pwm_led);  // 启用 PWM 输出

    pr_info("PWM LED driver initialized\n");
    return 0;
}

static void __exit pwm_led_exit(void)
{
    pwm_disable(pwm_led);
    pwm_free(pwm_led);
    led_classdev_unregister(&led_cdev);
    pr_info("PWM LED driver exited\n");
}

module_init(pwm_led_init);
module_exit(pwm_led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("PWM-controlled LED driver");

注册 LED 触发器

led-trigger-pwm-gpio 驱动通常是作为一个触发器驱动使用，触发器根据系统事件来自动调节 LED 的状态。触发器的基本原理是根据事件（如 CPU 占用、网络流量等）来动态调节 LED 的亮度。

在上面的例子中，led_cdev.default_trigger 可以被设置为一个合适的触发器。例如，可以设置为 heartbeat 触发器，让 LED 在系统运行时周期性地闪烁。

led_cdev.default_trigger = "heartbeat";  // 设置为系统心跳触发器

这样，LED 就会在系统启动时开始周期性闪烁。

触发器实现

为了实现自定义触发器，可以定义触发器的回调函数。触发器会根据特定的系统事件（如网络流量变化、CPU 使用情况等）来改变 LED 的亮度。

static void my_trigger_handler(struct led_classdev *led_cdev)
{
    /* 根据需要更改亮度 */
    led_cdev->brightness = (led_cdev->brightness == LED_OFF) ? LED_FULL : LED_OFF;
    led_classdev_notify(led_cdev);  // 通知 LED 状态已更新
}

static struct led_trigger my_led_trigger = {
    .name = "my_trigger",
    .handler = my_trigger_handler,
};

然后，在驱动初始化时注册触发器：

ret = led_trigger_register(&my_led_trigger);
if (ret) {
    pr_err("Failed to register trigger\n");
    pwm_disable(pwm_led);
    pwm_free(pwm_led);
    led_classdev_unregister(&led_cdev);
    return ret;
}

5. 测试与调试

  • 使用 sysfs 查看和控制 LED 的状态：

  • # 查看当前 LED 的亮度
cat /sys/class/leds/pwm_led/brightness

# 设置 LED 的亮度
echo 255 > /sys/class/leds/pwm_led/brightness

  • 检查 LED 是否根据系统事件（如心跳、CPU 活动等）自动变化。

6. 总结

led-trigger-pwm-gpio 驱动开发涉及以下几个关键步骤：

  1. 创建 LED 类设备并通过 PWM 控制器控制 GPIO 引脚。
  2. 根据 PWM 占空比调整 LED 亮度。
  3. 注册触发器，根据系统事件动态调整 LED 状态。
  4. 使用 sysfs 接口进行测试和调试。

该驱动不仅可以用于简单的 LED 控制，还能与其他系统事件结合，提供更灵活的控制方式。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值