从内核空间配置LED触发器的参数

Question

我正在开发一个嵌入式项目.我们的主板使用的是Linux内核v3.16.7.我正在努力支持一些监控活动的外围LED.我已经成功地修改了启动过程来加载驱动程序,并创建sysfs的条目中/sys/class/leds/,这是伟大的.我还将一个单触发器连接到LED上,这样我就可以echo 1 > shot从内部/sys/class/leds/actled1\:green/和LED 闪烁.正是我想要的.

但是,我想在启动过程中实例化驱动程序时配置每个LED的延迟,我不清楚如何做到这一点.司机在创建的sysfs条目/sys/class/leds/actled1\:green/叫delay_on和delay_off了,我可以从用户空间写信给他们配置的延迟,但它应该是可能的实例化过程中从内核空间设置的初始值.我还希望能够设置invert参数(这只是延迟时的另一个sysfs条目).

当我从内核空间实例化驱动程序时,如何配置led触发器的参数？

以下是我实例化LED GPIO的方法.首先,我设置所需的结构:

static struct gpio_led my_leds[] __initdata = {
    {
        .name = "actled1:green",
        .default_trigger = "oneshot"
        .gpio = ACTIVITY_LED_GPIO_BASE + 0,
        .active_low = true,
    },
    {
        .name = "actled2:red",
        .default_trigger = "oneshot"
        .gpio = ACTIVITY_LED_GPIO_BASE + 1,
        .active_low = true,
    },
};

static struct gpio_led_platform_data my_leds_pdata __initdata = {
    .num_leds = ARRAY_SIZE(my_leds),
    .leds = my_leds,
};

然后,我调用此函数来创建平台设备:

static int __init setup_my_leds (void)
{
    struct platform_device *pdev;
    int ret;

    pdev = platform_device_alloc("leds-gpio", -1);
    if (!pdev) {
        return -ENOMEM;
    }

    ret = platform_device_add_data(pdev,
                    &my_leds_pdata,
                    sizeof(my_leds_pdata));

    if (ret < 0) {
        platform_device_put(pdev);
        return ret;
    }

    ret = platform_device_add(pdev);
    if (ret < 0) {
        platform_device_put(pdev);
        return ret;
    }

    return 0;
}

对于定义gpio_led结构是include/linux/leds.h线327,并定义gpio_led_platform_data为同一个文件的341行.的定义platform_device_add_data是在drivers/base/platform.c线284.

查看oneshot trigger(drivers/leds/trigger/ledtrig-oneshot.c)的来源以回答问题可能很有用.另外相关的是"leds-gpio"驱动程序(drivers/leds/leds-gpio.c).

我怀疑答案是在某处drivers/base/platform.c和相关的文档中,但我没有看到任何处理我需要的数据的函数.

---

为了解决我无意中遗漏的一些信息:

1. 引导加载程序设置内核参数,我们无法修改引导加载程序.没关系; 我想设置的值是常量,我可以硬编码.
2. 驱动程序在编译时被烘焙到内核中(并且,我认为,由引导加载程序加载)而不是.ko稍后使用modprobe 加载.
3. 我希望能够设置任意触发参数的一般方法,而不仅仅是oneshot的delay_on/ delay_off.例如,oneshot的invert参数.
4. 我完全可以修改oneshot /创建新的触发器.事实上,一旦我使用oneshot,我需要创建一个新的触发器,扩展到oneshot(这也是我需要设置任意参数的原因).

Answer 1

有一些问题，我想我已经找到了解决方案，但即使您提供了大量信息，但还是缺少一些内容，所以我将列举所有可能的情况，所以请耐心等待......

(1) 获取要设置的初始值。我想您已经弄清楚了这一点，但是...您可以从内核命令行解析中获取这些内容（例如，您将值添加到 /boot/grub2/grub.cfg 中myleds.delay_on=...。如果您通过 加载modprobe，则设置一个模块参数.这些也可以是一个配置文件，如myleds.config_file=/etc/sysconfig/myleds.conf

(2) 您可以将它们设置在 setup_my_leds 中[除了 oneshot_trig_activate 的顽固性——我们很快就会处理这个问题]。从drivers/base/platform.c：

/**
 * arch_setup_pdev_archdata - Allow manipulation of archdata before its used
 * @pdev: platform device
 *
 * This is called before platform_device_add() such that any pdev_archdata may
 * be setup before the platform_notifier is called.  So if a user needs to
 * manipulate any relevant information in the pdev_archdata they can do:
 *
 *  platform_device_alloc()
 *  ... manipulate ...
 *  platform_device_add()
 *
 * And if they don't care they can just call platform_device_register() and
 * everything will just work out.
 */

因此，考虑到这一点，让我们稍微更改一下您的设置函数：

static int __init setup_my_leds (void)
{
    struct platform_device *pdev;
    int ret;

    // get initial values you want to set, possibly storing away for later use
    my_leds_get_init_values(...);

    pdev = platform_device_alloc("leds-gpio", -1);
    if (!pdev) {
        return -ENOMEM;
    }

    // Choice (1): set your initial values in my_leds_pdata here
    my_leds_set_init_values(&my_leds_pdata);

    // NOTE: just does kmemdup and sets pdev->dev.platform_data
    ret = platform_device_add_data(pdev,
                    &my_leds_pdata,
                    sizeof(my_leds_pdata));

    if (ret < 0) {
        platform_device_put(pdev);
        return ret;
    }

    // Choice (2): set your initial values in pdev->dev.platform_data here
    my_leds_set_init_values(pdev->dev.platform_data);

    ret = platform_device_add(pdev);
    if (ret < 0) {
        platform_device_put(pdev);
        return ret;
    }

    return 0;
}

(3) 不幸的是，由于您使用的是.default_trigger = "oneshot"，因此上述数据将被oneshot_trig_activatein炸毁drivers/leds/trigger/ledtrig-oneshot.c。所以，我们需要处理这个问题。

选项（A）：假设您可以根据您的选择重建整个内核，只需修改oneshot_trig_activate并ledtrig-oneshot.c删除使用DEFAULT_DELAY. 仅当您知道系统中可能需要默认值的其他任何东西都没有使用它时，这才真正有用。

选项 (B)：如果您不允许修改ledtrig-oneshot.c，但可以向 中添加新触发器drivers/leds/trigger，请将文件复制到 (eg)ledtrig-oneshot2.c并在那里进行更改。您需要将 更改.name为.name = "oneshot2". 最简单的方法[当然是在 vi 中:-)] 是:%s/oneshot/oneshot2/g。您还需要为此在 Kconfig 和 Makefile 中添加一个新条目。然后，更改结构定义以使用新驱动程序：.default_trigger = "oneshot2"

选项 (C)：假设您无法[或不想]触摸该drivers/leds/trigger目录，请复制ledtrig-oneshot.c到您的驱动程序目录[根据需要重命名]。从上面的选项 (B) 中进行编辑。通过 Makefile 中的一些技巧，您可以让它同时构建my_led_driver.ko 和 ledtrig-oneshot2.ko. 您需要修改您的 Kconfig，可能会添加depends on LED_TRIGGERSLED 触发驱动程序。您还可以将两者放入单独的子目录中，并且单独的 Makefile/Kconfig 可能会更简单my_led/my_driver：my_led/my_trigger

选项（C）需要更多的前期工作，但从长远来看可能更干净、更便携。当然，您可以执行选项 (A) 进行概念验证，然后执行选项 (B)，最后执行选项 (C) 的“最终船舶”。

设置初始值的另一种方法：记住my_leds_get_init_valueswas的注释possibly storing away for later use。您可以更改oneshot2_trig_activate为调用它而不是使用DEFAULT_DELAY. 我不太喜欢这个，更喜欢简单地 neuteroneshot_trig_activate的攻击行为的解决方案。但是，通过一些测试，您可能会发现这就是您必须这样做的方式。

希望以上内容能够发挥作用。如果没有，请用附加信息和/或限制编辑您的问题[并向我发送评论]，我会很高兴更新我的答案[我已经做了 40 岁以上的司机了]。

更新：好的，这里是一个经过完全注释和修改的 LED 触发驱动器，您可以将其用作drivers/led/trigger/ledtrig-oneshot.c.

由于该invert参数无法直接通过您在设置函数中有权访问的任何标准结构传递[即它存储在触发器驱动程序内的私有结构中]，因此删除“Choice (1)”和“Choice (2)”。我们将在 [modified] 中一次性设置它们oneshot_trig_activate。

此外，您想要的初始化参数必须设置并存储为全局变量，以便my_leds_get_init_values触发器驱动程序可以找到它们。也就是说，没有办法干净地完成此操作（例如，使用指向传递的私有结构的指针），因为您在设置中有权访问的结构没有为此的字段。有关于此的讨论，请参阅触发器驱动程序的顶部部分。

我的第一步是用描述性注释来注释基本驱动程序。除了K&R风格的版权和一句俏皮话之外，没有任何评论。我的注释是 ANSI（“//”）注释。

如果我接管驱动程序，我会添加这些并保留它们。但是，根据内核风格指南，我的评论级别可能被认为是“过度评论”，并且可能被认为是“粗俗的”，特别是对于以下驱动程序：这很简单吗？

下一步是添加必要的更改。所有有添加/更改的地方都标有以“C:”开头的注释块。这些是重要的地方。请注意，这些评论是留在 中的合法候选者。在其他更复杂的驱动程序中，评论的级别取决于作者。“C:”只是为了突出显示您的位置。

有了注释，直线阅读现在可能会更容易。另外，adiff -u也可能有帮助。如果你已经把所有东西都搞定了git，那就更好了。

因此，我会删除“选项（A）”[直接修改原始文件]并仅执行“选项（B）”或“选项（C）”。

触发器驱动程序使用所有定义，因此不需要static我之前建议的全局编辑。我确实这样做了，所以你需要将其与 相匹配。请随意使用，以与您现有的命名约定保持一致。当我为自己做这件事时，我通常使用我的姓名首字母，所以它变成--YMMV.name = "myled_oneshot";.default_trigger = "myled_oneshot";my_leds_whateverce_leds_whatever

无论如何，这是整个修改后的触发器驱动程序。请注意，我已经完成了编辑，但没有尝试编译/构建它。

/*
 * One-shot LED Trigger
 *
 * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
 *
 * Based on ledtrig-timer.c by Richard Purdie <rpurdie@openedhand.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/ctype.h>
#include <linux/slab.h>
#include <linux/leds.h>
#include "../leds.h"

// C: we need to get access to the init data populated by the setup function
// we have the "clean way" with a struct definition inside a header file and
// the "dirty way" using three separate int globals
// in either case, the externs referenced here must be defined in the "my_leds"
// driver as global

// C: the "clean way"
// (1) requires that we have a path to the .h (e.g. -I<whatever)
// (2) this would be easier/preferable for the "Option (C)"
// (3) once done, easily extensible [probably not a consideration here]
#ifdef MYLED_USESTRUCT
#include "whatever/myled_init.h"
extern struct myled_init myled_init;

// C: the "ugly way"
// (1) no need to use a separate .h file
// (2) three separate global variables is wasteful
// (3) more than three, and we really should consider the "struct"
#else
extern int myled_init_delay_on;
extern int myled_init_delay_off;
extern int myled_init_invert;
#endif

#define DEFAULT_DELAY 100

// oneshot trigger driver private data
struct oneshot_trig_data {
    unsigned int invert;                // current invert state
};

// arm oneshot sequence from sysfs write to shot file
static ssize_t led_shot(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t size)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);
    struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;

    led_blink_set_oneshot(led_cdev,
            &led_cdev->blink_delay_on, &led_cdev->blink_delay_off,
            oneshot_data->invert);

    /* content is ignored */
    return size;
}

// show invert state for "cat invert"
static ssize_t led_invert_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);
    struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;

    return sprintf(buf, "%u\n", oneshot_data->invert);
}

// set invert from sysfs write to invert file (e.g. echo 1 > invert)
static ssize_t led_invert_store(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t size)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);
    struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
    unsigned long state;
    int ret;

    ret = kstrtoul(buf, 0, &state);
    if (ret)
        return ret;

    oneshot_data->invert = !!state;

    if (oneshot_data->invert)
        led_set_brightness_async(led_cdev, LED_FULL);
    else
        led_set_brightness_async(led_cdev, LED_OFF);

    return size;
}

// show delay_on state for "cat delay_on"
static ssize_t led_delay_on_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);

    return sprintf(buf, "%lu\n", led_cdev->blink_delay_on);
}

// set delay_on from sysfs write to delay_on file (e.g. echo 20 > delay_on)
static ssize_t led_delay_on_store(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t size)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);
    unsigned long state;
    int ret;

    ret = kstrtoul(buf, 0, &state);
    if (ret)
        return ret;

    led_cdev->blink_delay_on = state;

    return size;
}

// show delay_off state for "cat delay_off"
static ssize_t led_delay_off_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);

    return sprintf(buf, "%lu\n", led_cdev->blink_delay_off);
}

// set delay_off from sysfs write to delay_off file (e.g. echo 20 > delay_off)
static ssize_t led_delay_off_store(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t size)
{
    struct led_classdev *led_cdev = dev_get_drvdata(dev);
    unsigned long state;
    int ret;

    ret = kstrtoul(buf, 0, &state);
    if (ret)
        return ret;

    led_cdev->blink_delay_off = state;

    return size;
}

// these are the "attribute" definitions -- one for each sysfs entry
// pointers to these show up in the above functions as the "attr" argument
static DEVICE_ATTR(delay_on, 0644, led_delay_on_show, led_delay_on_store);
static DEVICE_ATTR(delay_off, 0644, led_delay_off_show, led_delay_off_store);
static DEVICE_ATTR(invert, 0644, led_invert_show, led_invert_store);
static DEVICE_ATTR(shot, 0200, NULL, led_shot);

// activate the trigger device
static void oneshot_trig_activate(struct led_classdev *led_cdev)
{
    struct oneshot_trig_data *oneshot_data;
    int rc;

    // create an instance of the private data we need
    oneshot_data = kzalloc(sizeof(*oneshot_data), GFP_KERNEL);
    if (!oneshot_data)
        return;

    // save the pointer in the led class struct so it's available to other
    // functions above
    led_cdev->trigger_data = oneshot_data;

    // attach the sysfs entries
    rc = device_create_file(led_cdev->dev, &dev_attr_delay_on);
    if (rc)
        goto err_out_trig_data;
    rc = device_create_file(led_cdev->dev, &dev_attr_delay_off);
    if (rc)
        goto err_out_delayon;
    rc = device_create_file(led_cdev->dev, &dev_attr_invert);
    if (rc)
        goto err_out_delayoff;
    rc = device_create_file(led_cdev->dev, &dev_attr_shot);
    if (rc)
        goto err_out_invert;

    // C: this is what the driver used to do
#if 0
    led_cdev->blink_delay_on = DEFAULT_DELAY;
    led_cdev->blink_delay_off = DEFAULT_DELAY;
#endif

    led_cdev->activated = true;

    // C: from here to the return is what the modified driver must do

#ifdef MYLED_USESTRUCT
    led_cdev->blink_delay_on = myled_init.delay_on;
    led_cdev->blink_delay_off = myled_init.delay_off;
    oneshot_data->invert = myled_init.invert;
#else
    led_cdev->blink_delay_on = myled_init_delay_on;
    led_cdev->blink_delay_off = myled_init_delay_off;
    oneshot_data->invert = myled_init_invert;
#endif

    // C: if invert is off, nothing to do -- just like before
    // if invert is set, we implement this as if we just got an instantaneous
    // write to the sysfs "invert" file (which would call led_invert_store
    // above)

    // C: this is a direct rip-off of the above led_invert_store function which
    // we can _not_ call here directly because we don't have access to the
    // data it needs for its arguments [at least, not conveniently]
    // so, we extract the one line we actually need
    if (oneshot_data->invert)
        led_set_brightness_async(led_cdev, LED_FULL);

    return;

    // release everything if an error occurs
err_out_invert:
    device_remove_file(led_cdev->dev, &dev_attr_invert);
err_out_delayoff:
    device_remove_file(led_cdev->dev, &dev_attr_delay_off);
err_out_delayon:
    device_remove_file(led_cdev->dev, &dev_attr_delay_on);
err_out_trig_data:
    kfree(led_cdev->trigger_data);
}

// deactivate the trigger device
static void oneshot_trig_deactivate(struct led_classdev *led_cdev)
{
    struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;

    // release/destroy all the sysfs entries [and free the private data]
    if (led_cdev->activated) {
        device_remove_file(led_cdev->dev, &dev_attr_delay_on);
        device_remove_file(led_cdev->dev, &dev_attr_delay_off);
        device_remove_file(led_cdev->dev, &dev_attr_invert);
        device_remove_file(led_cdev->dev, &dev_attr_shot);
        kfree(oneshot_data);
        led_cdev->activated = false;
    }

    /* Stop blinking */
    led_set_brightness(led_cdev, LED_OFF);
}

// definition/control for trigger device registration
// C: changed the name to "myled_oneshot"
static struct led_trigger oneshot_led_trigger = {
    .name     = "myled_oneshot",
    .activate = oneshot_trig_activate,
    .deactivate = oneshot_trig_deactivate,
};

// module init function -- register the trigger device
static int __init oneshot_trig_init(void)
{
    return led_trigger_register(&oneshot_led_trigger);
}

// module exit function -- unregister the trigger device
static void __exit oneshot_trig_exit(void)
{
    led_trigger_unregister(&oneshot_led_trigger);
}

module_init(oneshot_trig_init);
module_exit(oneshot_trig_exit);

MODULE_AUTHOR("Fabio Baltieri <fabio.baltieri@gmail.com>");
MODULE_DESCRIPTION("One-shot LED trigger");
MODULE_LICENSE("GPL");