mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-21 19:53:59 +08:00
LED core improvements:
- Fix misleading comment after workqueue removal from drivers.
- Avoid error message when a USB LED device is unplugged.
- Add helpers for calling brightness_set(_blocking)
LED triggers:
- Simplify led_trigger_store by using sysfs_streq().
LED class drivers improvements:
- Improve wording and formatting in a comment: lp3944.
- Fix return value check in create_gpio_led(): leds-gpio.
- Use GPIOF_OUT_INIT_LOW instead of hardcoded zero: leds-gpio.
- Use devm_led_classdev_register(): leds-lm3533, leds-lm3533, leds-lp8788,
leds-wm831x-status, leds-s3c24xx, leds-s3c24xx, leds: max8997.
New LED class driver:
- Add driver for the ISSI IS31FL32xx family of LED controllers.
Device Tree documentation:
- of: Add vendor prefixes for Integrated Silicon Solutions Inc. (issi)
and Si-En Technology (si-en).
- DT: Add common bindings for Si-En Technology SN3216/18 and IS31FL32xx
family of LED controllers, since they seem to be the same hardware,
just rebranded.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.17 (GNU/Linux)
iQIcBAABAgAGBQJW5oghAAoJEL1qUBy3i3wm4sMP/2pEXQVZ5sYbjT6i3xnkajPh
mgfCNof4uNm/PZnAqGLF7BCoTRQNsG89MG0wTx240c2wTNhWd3Iqo8QabpVu9UbE
kc+B/j+GTKvXmpmcEae5uLdGOhaqK9K/dBLW/FFTHyxJcwao26x1pj+rvi4CEEDl
z+u1uM+2Yh9QB8Q/+JgWRDSY0uRT5qKimN2OU+jwSO3iuSc49i39OzoBxpegP21l
rpO1X2NeziOXyQl/qa2DYSQ2xqjnHkTRSjpQ98LeUaEauavJQDlynDeugbaWX6t7
KCignPeeQMBvYySyDGLMtUYjUO5RW1AoikZ9eR4imdL+Oz9sw29xnp+FMr0nSE/U
D/T2Pt2nRAVVvkJEQ0K2B4PbFAI2KmlDLTMS3vb0uJoRTaTOZBdMKFpa4sju8THQ
bUeixSUi6rD6VoAVqO8VftaOFfmR4EjmZR1v8KSh5YHWLhAwq+GSTjcUHxpU6Dxx
l3oQnMBVNsrfQQhxqr889HB5lQu1+X663Snap7eTzMpUpxXoTgCOGGMt2alRNDUO
uYf4cue/m/aPvOZl25IRoHlujnxuCK7gS2stwKgoHqRqLKLzfABQ4NV5lnw1V4oI
4834uE3+IHDJIvWj3Y9gCUhKVazbIK3n3rDJcwxPaSGk7MCdFWqkZ+joIgtgnEEC
O1GD9sGRU93yBm8a/EoT
=+CW7
-----END PGP SIGNATURE-----
Merge tag 'leds_for_4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds
Pull LED updates from Jacek Anaszewski:
"LED core improvements:
- Fix misleading comment after workqueue removal from drivers
- Avoid error message when a USB LED device is unplugged
- Add helpers for calling brightness_set(_blocking)
LED triggers:
- Simplify led_trigger_store by using sysfs_streq()
LED class drivers improvements:
- Improve wording and formatting in a comment: lp3944
- Fix return value check in create_gpio_led(): leds-gpio
- Use GPIOF_OUT_INIT_LOW instead of hardcoded zero: leds-gpio
- Use devm_led_classdev_register(): leds-lm3533, leds-lm3533,
leds-lp8788, leds-wm831x-status, leds-s3c24xx, leds-s3c24xx,
leds-max8997.
New LED class driver:
- Add driver for the ISSI IS31FL32xx family of LED controllers.
Device Tree documentation:
- of: Add vendor prefixes for Integrated Silicon Solutions Inc.
(issi) and Si-En Technology (si-en).
- DT: Add common bindings for Si-En Technology SN3216/18 and
IS31FL32xx family of LED controllers, since they seem to be the
same hardware, just rebranded"
* tag 'leds_for_4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds:
leds: triggers: simplify led_trigger_store
leds: max8997: Use devm_led_classdev_register
leds: da903x: Use devm_led_classdev_register
leds: s3c24xx: Use devm_led_classdev_register
leds: wm831x-status: Use devm_led_classdev_register
leds: lp8788: Use devm_led_classdev_register
leds: 88pm860x: Use devm_led_classdev_register
leds: Add SN3218 and SN3216 support to the IS31FL32XX driver
of: Add vendor prefix for Si-En Technology
leds: Add driver for the ISSI IS31FL32xx family of LED controllers
DT: leds: Add binding for the ISSI IS31FL32xx family of LED controllers
DT: Add vendor prefix for Integrated Silicon Solutions Inc.
leds: lm3533: Use devm_led_classdev_register
leds: gpio: Use GPIOF_OUT_INIT_LOW instead of hardcoded zero
leds: core: add helpers for calling brightness_set(_blocking)
leds: leds-gpio: Fix return value check in create_gpio_led()
leds: lp3944: improve wording and formatting in a comment
leds: core: avoid error message when a USB LED device is unplugged
leds: core: fix misleading comment after workqueue removal from drivers
This commit is contained in:
Linus Torvalds
commit
9256d5a308
52
Documentation/devicetree/bindings/leds/leds-is31fl32xx.txt
Normal file
52
Documentation/devicetree/bindings/leds/leds-is31fl32xx.txt
Normal file
@ -0,0 +1,52 @@
|
||||
Binding for ISSI IS31FL32xx and Si-En SN32xx LED Drivers
|
||||
|
||||
The IS31FL32xx/SN32xx family of LED drivers are I2C devices with multiple
|
||||
constant-current channels, each with independent 256-level PWM control.
|
||||
Each LED is represented as a sub-node of the device.
|
||||
|
||||
Required properties:
|
||||
- compatible: one of
|
||||
issi,is31fl3236
|
||||
issi,is31fl3235
|
||||
issi,is31fl3218
|
||||
issi,is31fl3216
|
||||
si-en,sn3218
|
||||
si-en,sn3216
|
||||
- reg: I2C slave address
|
||||
- address-cells : must be 1
|
||||
- size-cells : must be 0
|
||||
|
||||
LED sub-node properties:
|
||||
- reg : LED channel number (1..N)
|
||||
- label : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- linux,default-trigger : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
|
||||
|
||||
Example:
|
||||
|
||||
is31fl3236: led-controller@3c {
|
||||
compatible = "issi,is31fl3236";
|
||||
reg = <0x3c>;
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
|
||||
led@1 {
|
||||
reg = <1>;
|
||||
label = "EB:blue:usr0";
|
||||
};
|
||||
led@2 {
|
||||
reg = <2>;
|
||||
label = "EB:blue:usr1";
|
||||
};
|
||||
...
|
||||
led@36 {
|
||||
reg = <36>;
|
||||
label = "EB:blue:usr35";
|
||||
};
|
||||
};
|
||||
|
||||
For more product information please see the links below:
|
||||
http://www.issi.com/US/product-analog-fxled-driver.shtml
|
||||
http://www.si-en.com/product.asp?parentid=890
|
||||
@ -120,6 +120,7 @@ intercontrol Inter Control Group
|
||||
invensense InvenSense Inc.
|
||||
isee ISEE 2007 S.L.
|
||||
isil Intersil
|
||||
issi Integrated Silicon Solutions Inc.
|
||||
jedec JEDEC Solid State Technology Association
|
||||
karo Ka-Ro electronics GmbH
|
||||
keymile Keymile GmbH
|
||||
@ -204,6 +205,7 @@ seagate Seagate Technology PLC
|
||||
semtech Semtech Corporation
|
||||
sgx SGX Sensortech
|
||||
sharp Sharp Corporation
|
||||
si-en Si-En Technology Ltd.
|
||||
sigma Sigma Designs, Inc.
|
||||
sil Silicon Image
|
||||
silabs Silicon Laboratories
|
||||
|
||||
@ -568,6 +568,14 @@ config LEDS_SEAD3
|
||||
This driver can also be built as a module. If so the module
|
||||
will be called leds-sead3.
|
||||
|
||||
config LEDS_IS31FL32XX
|
||||
tristate "LED support for ISSI IS31FL32XX I2C LED controller family"
|
||||
depends on LEDS_CLASS && I2C && OF
|
||||
help
|
||||
Say Y here to include support for ISSI IS31FL32XX and Si-En SN32xx
|
||||
LED controllers. They are I2C devices with multiple constant-current
|
||||
channels, each with independent 256-level PWM control.
|
||||
|
||||
comment "LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM)"
|
||||
|
||||
config LEDS_BLINKM
|
||||
|
||||
@ -66,6 +66,7 @@ obj-$(CONFIG_LEDS_MENF21BMC) += leds-menf21bmc.o
|
||||
obj-$(CONFIG_LEDS_KTD2692) += leds-ktd2692.o
|
||||
obj-$(CONFIG_LEDS_POWERNV) += leds-powernv.o
|
||||
obj-$(CONFIG_LEDS_SEAD3) += leds-sead3.o
|
||||
obj-$(CONFIG_LEDS_IS31FL32XX) += leds-is31fl32xx.o
|
||||
|
||||
# LED SPI Drivers
|
||||
obj-$(CONFIG_LEDS_DAC124S085) += leds-dac124s085.o
|
||||
|
||||
@ -245,6 +245,8 @@ void led_classdev_unregister(struct led_classdev *led_cdev)
|
||||
up_write(&led_cdev->trigger_lock);
|
||||
#endif
|
||||
|
||||
led_cdev->flags |= LED_UNREGISTERING;
|
||||
|
||||
/* Stop blinking */
|
||||
led_stop_software_blink(led_cdev);
|
||||
|
||||
|
||||
@ -25,6 +25,26 @@ EXPORT_SYMBOL_GPL(leds_list_lock);
|
||||
LIST_HEAD(leds_list);
|
||||
EXPORT_SYMBOL_GPL(leds_list);
|
||||
|
||||
static int __led_set_brightness(struct led_classdev *led_cdev,
|
||||
enum led_brightness value)
|
||||
{
|
||||
if (!led_cdev->brightness_set)
|
||||
return -ENOTSUPP;
|
||||
|
||||
led_cdev->brightness_set(led_cdev, value);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __led_set_brightness_blocking(struct led_classdev *led_cdev,
|
||||
enum led_brightness value)
|
||||
{
|
||||
if (!led_cdev->brightness_set_blocking)
|
||||
return -ENOTSUPP;
|
||||
|
||||
return led_cdev->brightness_set_blocking(led_cdev, value);
|
||||
}
|
||||
|
||||
static void led_timer_function(unsigned long data)
|
||||
{
|
||||
struct led_classdev *led_cdev = (void *)data;
|
||||
@ -91,14 +111,14 @@ static void set_brightness_delayed(struct work_struct *ws)
|
||||
led_cdev->flags &= ~LED_BLINK_DISABLE;
|
||||
}
|
||||
|
||||
if (led_cdev->brightness_set)
|
||||
led_cdev->brightness_set(led_cdev, led_cdev->delayed_set_value);
|
||||
else if (led_cdev->brightness_set_blocking)
|
||||
ret = led_cdev->brightness_set_blocking(led_cdev,
|
||||
led_cdev->delayed_set_value);
|
||||
else
|
||||
ret = -ENOTSUPP;
|
||||
if (ret < 0)
|
||||
ret = __led_set_brightness(led_cdev, led_cdev->delayed_set_value);
|
||||
if (ret == -ENOTSUPP)
|
||||
ret = __led_set_brightness_blocking(led_cdev,
|
||||
led_cdev->delayed_set_value);
|
||||
if (ret < 0 &&
|
||||
/* LED HW might have been unplugged, therefore don't warn */
|
||||
!(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) &&
|
||||
(led_cdev->flags & LED_HW_PLUGGABLE)))
|
||||
dev_err(led_cdev->dev,
|
||||
"Setting an LED's brightness failed (%d)\n", ret);
|
||||
}
|
||||
@ -233,10 +253,8 @@ void led_set_brightness_nopm(struct led_classdev *led_cdev,
|
||||
enum led_brightness value)
|
||||
{
|
||||
/* Use brightness_set op if available, it is guaranteed not to sleep */
|
||||
if (led_cdev->brightness_set) {
|
||||
led_cdev->brightness_set(led_cdev, value);
|
||||
if (!__led_set_brightness(led_cdev, value))
|
||||
return;
|
||||
}
|
||||
|
||||
/* If brightness setting can sleep, delegate it to a work queue task */
|
||||
led_cdev->delayed_set_value = value;
|
||||
@ -267,10 +285,7 @@ int led_set_brightness_sync(struct led_classdev *led_cdev,
|
||||
if (led_cdev->flags & LED_SUSPENDED)
|
||||
return 0;
|
||||
|
||||
if (led_cdev->brightness_set_blocking)
|
||||
return led_cdev->brightness_set_blocking(led_cdev,
|
||||
led_cdev->brightness);
|
||||
return -ENOTSUPP;
|
||||
return __led_set_brightness_blocking(led_cdev, led_cdev->brightness);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(led_set_brightness_sync);
|
||||
|
||||
|
||||
@ -34,9 +34,7 @@ ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
char trigger_name[TRIG_NAME_MAX];
|
||||
struct led_trigger *trig;
|
||||
size_t len;
|
||||
int ret = count;
|
||||
|
||||
mutex_lock(&led_cdev->led_access);
|
||||
@ -46,21 +44,14 @@ ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
trigger_name[sizeof(trigger_name) - 1] = '\0';
|
||||
strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
|
||||
len = strlen(trigger_name);
|
||||
|
||||
if (len && trigger_name[len - 1] == '\n')
|
||||
trigger_name[len - 1] = '\0';
|
||||
|
||||
if (!strcmp(trigger_name, "none")) {
|
||||
if (sysfs_streq(buf, "none")) {
|
||||
led_trigger_remove(led_cdev);
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
down_read(&triggers_list_lock);
|
||||
list_for_each_entry(trig, &trigger_list, next_trig) {
|
||||
if (!strcmp(trigger_name, trig->name)) {
|
||||
if (sysfs_streq(buf, trig->name)) {
|
||||
down_write(&led_cdev->trigger_lock);
|
||||
led_trigger_set(led_cdev, trig);
|
||||
up_write(&led_cdev->trigger_lock);
|
||||
|
||||
@ -195,7 +195,6 @@ static int pm860x_led_probe(struct platform_device *pdev)
|
||||
sprintf(data->name, "led1-blue");
|
||||
break;
|
||||
}
|
||||
platform_set_drvdata(pdev, data);
|
||||
data->chip = chip;
|
||||
data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
|
||||
data->port = pdev->id;
|
||||
@ -208,7 +207,7 @@ static int pm860x_led_probe(struct platform_device *pdev)
|
||||
data->cdev.brightness_set_blocking = pm860x_led_set;
|
||||
mutex_init(&data->lock);
|
||||
|
||||
ret = led_classdev_register(chip->dev, &data->cdev);
|
||||
ret = devm_led_classdev_register(chip->dev, &data->cdev);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
|
||||
return ret;
|
||||
@ -217,21 +216,12 @@ static int pm860x_led_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pm860x_led_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct pm860x_led *data = platform_get_drvdata(pdev);
|
||||
|
||||
led_classdev_unregister(&data->cdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver pm860x_led_driver = {
|
||||
.driver = {
|
||||
.name = "88pm860x-led",
|
||||
},
|
||||
.probe = pm860x_led_probe,
|
||||
.remove = pm860x_led_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(pm860x_led_driver);
|
||||
|
||||
@ -113,21 +113,12 @@ static int da903x_led_probe(struct platform_device *pdev)
|
||||
led->flags = pdata->flags;
|
||||
led->master = pdev->dev.parent;
|
||||
|
||||
ret = led_classdev_register(led->master, &led->cdev);
|
||||
ret = devm_led_classdev_register(led->master, &led->cdev);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "failed to register LED %d\n", id);
|
||||
return ret;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, led);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int da903x_led_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct da903x_led *led = platform_get_drvdata(pdev);
|
||||
|
||||
led_classdev_unregister(&led->cdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -136,7 +127,6 @@ static struct platform_driver da903x_led_driver = {
|
||||
.name = "da903x-led",
|
||||
},
|
||||
.probe = da903x_led_probe,
|
||||
.remove = da903x_led_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(da903x_led_driver);
|
||||
|
||||
@ -86,7 +86,7 @@ static int create_gpio_led(const struct gpio_led *template,
|
||||
* still uses GPIO numbers. Ultimately we would like to get
|
||||
* rid of this block completely.
|
||||
*/
|
||||
unsigned long flags = 0;
|
||||
unsigned long flags = GPIOF_OUT_INIT_LOW;
|
||||
|
||||
/* skip leds that aren't available */
|
||||
if (!gpio_is_valid(template->gpio)) {
|
||||
@ -104,8 +104,8 @@ static int create_gpio_led(const struct gpio_led *template,
|
||||
return ret;
|
||||
|
||||
led_dat->gpiod = gpio_to_desc(template->gpio);
|
||||
if (IS_ERR(led_dat->gpiod))
|
||||
return PTR_ERR(led_dat->gpiod);
|
||||
if (!led_dat->gpiod)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
led_dat->cdev.name = template->name;
|
||||
|
||||
508
drivers/leds/leds-is31fl32xx.c
Normal file
508
drivers/leds/leds-is31fl32xx.c
Normal file
@ -0,0 +1,508 @@
|
||||
/*
|
||||
* Driver for ISSI IS31FL32xx family of I2C LED controllers
|
||||
*
|
||||
* Copyright 2015 Allworx Corp.
|
||||
*
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Datasheets:
|
||||
* http://www.issi.com/US/product-analog-fxled-driver.shtml
|
||||
* http://www.si-en.com/product.asp?parentid=890
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/leds.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_device.h>
|
||||
|
||||
/* Used to indicate a device has no such register */
|
||||
#define IS31FL32XX_REG_NONE 0xFF
|
||||
|
||||
/* Software Shutdown bit in Shutdown Register */
|
||||
#define IS31FL32XX_SHUTDOWN_SSD_ENABLE 0
|
||||
#define IS31FL32XX_SHUTDOWN_SSD_DISABLE BIT(0)
|
||||
|
||||
/* IS31FL3216 has a number of unique registers */
|
||||
#define IS31FL3216_CONFIG_REG 0x00
|
||||
#define IS31FL3216_LIGHTING_EFFECT_REG 0x03
|
||||
#define IS31FL3216_CHANNEL_CONFIG_REG 0x04
|
||||
|
||||
/* Software Shutdown bit in 3216 Config Register */
|
||||
#define IS31FL3216_CONFIG_SSD_ENABLE BIT(7)
|
||||
#define IS31FL3216_CONFIG_SSD_DISABLE 0
|
||||
|
||||
struct is31fl32xx_priv;
|
||||
struct is31fl32xx_led_data {
|
||||
struct led_classdev cdev;
|
||||
u8 channel; /* 1-based, max priv->cdef->channels */
|
||||
struct is31fl32xx_priv *priv;
|
||||
};
|
||||
|
||||
struct is31fl32xx_priv {
|
||||
const struct is31fl32xx_chipdef *cdef;
|
||||
struct i2c_client *client;
|
||||
unsigned int num_leds;
|
||||
struct is31fl32xx_led_data leds[0];
|
||||
};
|
||||
|
||||
/**
|
||||
* struct is31fl32xx_chipdef - chip-specific attributes
|
||||
* @channels : Number of LED channels
|
||||
* @shutdown_reg : address of Shutdown register (optional)
|
||||
* @pwm_update_reg : address of PWM Update register
|
||||
* @global_control_reg : address of Global Control register (optional)
|
||||
* @reset_reg : address of Reset register (optional)
|
||||
* @pwm_register_base : address of first PWM register
|
||||
* @pwm_registers_reversed: : true if PWM registers count down instead of up
|
||||
* @led_control_register_base : address of first LED control register (optional)
|
||||
* @enable_bits_per_led_control_register: number of LEDs enable bits in each
|
||||
* @reset_func: : pointer to reset function
|
||||
*
|
||||
* For all optional register addresses, the sentinel value %IS31FL32XX_REG_NONE
|
||||
* indicates that this chip has no such register.
|
||||
*
|
||||
* If non-NULL, @reset_func will be called during probing to set all
|
||||
* necessary registers to a known initialization state. This is needed
|
||||
* for chips that do not have a @reset_reg.
|
||||
*
|
||||
* @enable_bits_per_led_control_register must be >=1 if
|
||||
* @led_control_register_base != %IS31FL32XX_REG_NONE.
|
||||
*/
|
||||
struct is31fl32xx_chipdef {
|
||||
u8 channels;
|
||||
u8 shutdown_reg;
|
||||
u8 pwm_update_reg;
|
||||
u8 global_control_reg;
|
||||
u8 reset_reg;
|
||||
u8 pwm_register_base;
|
||||
bool pwm_registers_reversed;
|
||||
u8 led_control_register_base;
|
||||
u8 enable_bits_per_led_control_register;
|
||||
int (*reset_func)(struct is31fl32xx_priv *priv);
|
||||
int (*sw_shutdown_func)(struct is31fl32xx_priv *priv, bool enable);
|
||||
};
|
||||
|
||||
static const struct is31fl32xx_chipdef is31fl3236_cdef = {
|
||||
.channels = 36,
|
||||
.shutdown_reg = 0x00,
|
||||
.pwm_update_reg = 0x25,
|
||||
.global_control_reg = 0x4a,
|
||||
.reset_reg = 0x4f,
|
||||
.pwm_register_base = 0x01,
|
||||
.led_control_register_base = 0x26,
|
||||
.enable_bits_per_led_control_register = 1,
|
||||
};
|
||||
|
||||
static const struct is31fl32xx_chipdef is31fl3235_cdef = {
|
||||
.channels = 28,
|
||||
.shutdown_reg = 0x00,
|
||||
.pwm_update_reg = 0x25,
|
||||
.global_control_reg = 0x4a,
|
||||
.reset_reg = 0x4f,
|
||||
.pwm_register_base = 0x05,
|
||||
.led_control_register_base = 0x2a,
|
||||
.enable_bits_per_led_control_register = 1,
|
||||
};
|
||||
|
||||
static const struct is31fl32xx_chipdef is31fl3218_cdef = {
|
||||
.channels = 18,
|
||||
.shutdown_reg = 0x00,
|
||||
.pwm_update_reg = 0x16,
|
||||
.global_control_reg = IS31FL32XX_REG_NONE,
|
||||
.reset_reg = 0x17,
|
||||
.pwm_register_base = 0x01,
|
||||
.led_control_register_base = 0x13,
|
||||
.enable_bits_per_led_control_register = 6,
|
||||
};
|
||||
|
||||
static int is31fl3216_reset(struct is31fl32xx_priv *priv);
|
||||
static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
|
||||
bool enable);
|
||||
static const struct is31fl32xx_chipdef is31fl3216_cdef = {
|
||||
.channels = 16,
|
||||
.shutdown_reg = IS31FL32XX_REG_NONE,
|
||||
.pwm_update_reg = 0xB0,
|
||||
.global_control_reg = IS31FL32XX_REG_NONE,
|
||||
.reset_reg = IS31FL32XX_REG_NONE,
|
||||
.pwm_register_base = 0x10,
|
||||
.pwm_registers_reversed = true,
|
||||
.led_control_register_base = 0x01,
|
||||
.enable_bits_per_led_control_register = 8,
|
||||
.reset_func = is31fl3216_reset,
|
||||
.sw_shutdown_func = is31fl3216_software_shutdown,
|
||||
};
|
||||
|
||||
static int is31fl32xx_write(struct is31fl32xx_priv *priv, u8 reg, u8 val)
|
||||
{
|
||||
int ret;
|
||||
|
||||
dev_dbg(&priv->client->dev, "writing register 0x%02X=0x%02X", reg, val);
|
||||
|
||||
ret = i2c_smbus_write_byte_data(priv->client, reg, val);
|
||||
if (ret) {
|
||||
dev_err(&priv->client->dev,
|
||||
"register write to 0x%02X failed (error %d)",
|
||||
reg, ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Custom reset function for IS31FL3216 because it does not have a RESET
|
||||
* register the way that the other IS31FL32xx chips do. We don't bother
|
||||
* writing the GPIO and animation registers, because the registers we
|
||||
* do write ensure those will have no effect.
|
||||
*/
|
||||
static int is31fl3216_reset(struct is31fl32xx_priv *priv)
|
||||
{
|
||||
unsigned int i;
|
||||
int ret;
|
||||
|
||||
ret = is31fl32xx_write(priv, IS31FL3216_CONFIG_REG,
|
||||
IS31FL3216_CONFIG_SSD_ENABLE);
|
||||
if (ret)
|
||||
return ret;
|
||||
for (i = 0; i < priv->cdef->channels; i++) {
|
||||
ret = is31fl32xx_write(priv, priv->cdef->pwm_register_base+i,
|
||||
0x00);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
ret = is31fl32xx_write(priv, priv->cdef->pwm_update_reg, 0);
|
||||
if (ret)
|
||||
return ret;
|
||||
ret = is31fl32xx_write(priv, IS31FL3216_LIGHTING_EFFECT_REG, 0x00);
|
||||
if (ret)
|
||||
return ret;
|
||||
ret = is31fl32xx_write(priv, IS31FL3216_CHANNEL_CONFIG_REG, 0x00);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Custom Software-Shutdown function for IS31FL3216 because it does not have
|
||||
* a SHUTDOWN register the way that the other IS31FL32xx chips do.
|
||||
* We don't bother doing a read/modify/write on the CONFIG register because
|
||||
* we only ever use a value of '0' for the other fields in that register.
|
||||
*/
|
||||
static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
|
||||
bool enable)
|
||||
{
|
||||
u8 value = enable ? IS31FL3216_CONFIG_SSD_ENABLE :
|
||||
IS31FL3216_CONFIG_SSD_DISABLE;
|
||||
|
||||
return is31fl32xx_write(priv, IS31FL3216_CONFIG_REG, value);
|
||||
}
|
||||
|
||||
/*
|
||||
* NOTE: A mutex is not needed in this function because:
|
||||
* - All referenced data is read-only after probe()
|
||||
* - The I2C core has a mutex on to protect the bus
|
||||
* - There are no read/modify/write operations
|
||||
* - Intervening operations between the write of the PWM register
|
||||
* and the Update register are harmless.
|
||||
*
|
||||
* Example:
|
||||
* PWM_REG_1 write 16
|
||||
* UPDATE_REG write 0
|
||||
* PWM_REG_2 write 128
|
||||
* UPDATE_REG write 0
|
||||
* vs:
|
||||
* PWM_REG_1 write 16
|
||||
* PWM_REG_2 write 128
|
||||
* UPDATE_REG write 0
|
||||
* UPDATE_REG write 0
|
||||
* are equivalent. Poking the Update register merely applies all PWM
|
||||
* register writes up to that point.
|
||||
*/
|
||||
static int is31fl32xx_brightness_set(struct led_classdev *led_cdev,
|
||||
enum led_brightness brightness)
|
||||
{
|
||||
const struct is31fl32xx_led_data *led_data =
|
||||
container_of(led_cdev, struct is31fl32xx_led_data, cdev);
|
||||
const struct is31fl32xx_chipdef *cdef = led_data->priv->cdef;
|
||||
u8 pwm_register_offset;
|
||||
int ret;
|
||||
|
||||
dev_dbg(led_cdev->dev, "%s: %d\n", __func__, brightness);
|
||||
|
||||
/* NOTE: led_data->channel is 1-based */
|
||||
if (cdef->pwm_registers_reversed)
|
||||
pwm_register_offset = cdef->channels - led_data->channel;
|
||||
else
|
||||
pwm_register_offset = led_data->channel - 1;
|
||||
|
||||
ret = is31fl32xx_write(led_data->priv,
|
||||
cdef->pwm_register_base + pwm_register_offset,
|
||||
brightness);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return is31fl32xx_write(led_data->priv, cdef->pwm_update_reg, 0);
|
||||
}
|
||||
|
||||
static int is31fl32xx_reset_regs(struct is31fl32xx_priv *priv)
|
||||
{
|
||||
const struct is31fl32xx_chipdef *cdef = priv->cdef;
|
||||
int ret;
|
||||
|
||||
if (cdef->reset_reg != IS31FL32XX_REG_NONE) {
|
||||
ret = is31fl32xx_write(priv, cdef->reset_reg, 0);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (cdef->reset_func)
|
||||
return cdef->reset_func(priv);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int is31fl32xx_software_shutdown(struct is31fl32xx_priv *priv,
|
||||
bool enable)
|
||||
{
|
||||
const struct is31fl32xx_chipdef *cdef = priv->cdef;
|
||||
int ret;
|
||||
|
||||
if (cdef->shutdown_reg != IS31FL32XX_REG_NONE) {
|
||||
u8 value = enable ? IS31FL32XX_SHUTDOWN_SSD_ENABLE :
|
||||
IS31FL32XX_SHUTDOWN_SSD_DISABLE;
|
||||
ret = is31fl32xx_write(priv, cdef->shutdown_reg, value);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (cdef->sw_shutdown_func)
|
||||
return cdef->sw_shutdown_func(priv, enable);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int is31fl32xx_init_regs(struct is31fl32xx_priv *priv)
|
||||
{
|
||||
const struct is31fl32xx_chipdef *cdef = priv->cdef;
|
||||
int ret;
|
||||
|
||||
ret = is31fl32xx_reset_regs(priv);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/*
|
||||
* Set enable bit for all channels.
|
||||
* We will control state with PWM registers alone.
|
||||
*/
|
||||
if (cdef->led_control_register_base != IS31FL32XX_REG_NONE) {
|
||||
u8 value =
|
||||
GENMASK(cdef->enable_bits_per_led_control_register-1, 0);
|
||||
u8 num_regs = cdef->channels /
|
||||
cdef->enable_bits_per_led_control_register;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < num_regs; i++) {
|
||||
ret = is31fl32xx_write(priv,
|
||||
cdef->led_control_register_base+i,
|
||||
value);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
ret = is31fl32xx_software_shutdown(priv, false);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (cdef->global_control_reg != IS31FL32XX_REG_NONE) {
|
||||
ret = is31fl32xx_write(priv, cdef->global_control_reg, 0x00);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline size_t sizeof_is31fl32xx_priv(int num_leds)
|
||||
{
|
||||
return sizeof(struct is31fl32xx_priv) +
|
||||
(sizeof(struct is31fl32xx_led_data) * num_leds);
|
||||
}
|
||||
|
||||
static int is31fl32xx_parse_child_dt(const struct device *dev,
|
||||
const struct device_node *child,
|
||||
struct is31fl32xx_led_data *led_data)
|
||||
{
|
||||
struct led_classdev *cdev = &led_data->cdev;
|
||||
int ret = 0;
|
||||
u32 reg;
|
||||
|
||||
if (of_property_read_string(child, "label", &cdev->name))
|
||||
cdev->name = child->name;
|
||||
|
||||
ret = of_property_read_u32(child, "reg", ®);
|
||||
if (ret || reg < 1 || reg > led_data->priv->cdef->channels) {
|
||||
dev_err(dev,
|
||||
"Child node %s does not have a valid reg property\n",
|
||||
child->full_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
led_data->channel = reg;
|
||||
|
||||
of_property_read_string(child, "linux,default-trigger",
|
||||
&cdev->default_trigger);
|
||||
|
||||
cdev->brightness_set_blocking = is31fl32xx_brightness_set;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct is31fl32xx_led_data *is31fl32xx_find_led_data(
|
||||
struct is31fl32xx_priv *priv,
|
||||
u8 channel)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < priv->num_leds; i++) {
|
||||
if (priv->leds[i].channel == channel)
|
||||
return &priv->leds[i];
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int is31fl32xx_parse_dt(struct device *dev,
|
||||
struct is31fl32xx_priv *priv)
|
||||
{
|
||||
struct device_node *child;
|
||||
int ret = 0;
|
||||
|
||||
for_each_child_of_node(dev->of_node, child) {
|
||||
struct is31fl32xx_led_data *led_data =
|
||||
&priv->leds[priv->num_leds];
|
||||
const struct is31fl32xx_led_data *other_led_data;
|
||||
|
||||
led_data->priv = priv;
|
||||
|
||||
ret = is31fl32xx_parse_child_dt(dev, child, led_data);
|
||||
if (ret)
|
||||
goto err;
|
||||
|
||||
/* Detect if channel is already in use by another child */
|
||||
other_led_data = is31fl32xx_find_led_data(priv,
|
||||
led_data->channel);
|
||||
if (other_led_data) {
|
||||
dev_err(dev,
|
||||
"%s and %s both attempting to use channel %d\n",
|
||||
led_data->cdev.name,
|
||||
other_led_data->cdev.name,
|
||||
led_data->channel);
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = devm_led_classdev_register(dev, &led_data->cdev);
|
||||
if (ret) {
|
||||
dev_err(dev, "failed to register PWM led for %s: %d\n",
|
||||
led_data->cdev.name, ret);
|
||||
goto err;
|
||||
}
|
||||
|
||||
priv->num_leds++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err:
|
||||
of_node_put(child);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct of_device_id of_is31fl31xx_match[] = {
|
||||
{ .compatible = "issi,is31fl3236", .data = &is31fl3236_cdef, },
|
||||
{ .compatible = "issi,is31fl3235", .data = &is31fl3235_cdef, },
|
||||
{ .compatible = "issi,is31fl3218", .data = &is31fl3218_cdef, },
|
||||
{ .compatible = "si-en,sn3218", .data = &is31fl3218_cdef, },
|
||||
{ .compatible = "issi,is31fl3216", .data = &is31fl3216_cdef, },
|
||||
{ .compatible = "si-en,sn3216", .data = &is31fl3216_cdef, },
|
||||
{},
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(of, of_is31fl31xx_match);
|
||||
|
||||
static int is31fl32xx_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
const struct is31fl32xx_chipdef *cdef;
|
||||
const struct of_device_id *of_dev_id;
|
||||
struct device *dev = &client->dev;
|
||||
struct is31fl32xx_priv *priv;
|
||||
int count;
|
||||
int ret = 0;
|
||||
|
||||
of_dev_id = of_match_device(of_is31fl31xx_match, dev);
|
||||
if (!of_dev_id)
|
||||
return -EINVAL;
|
||||
|
||||
cdef = of_dev_id->data;
|
||||
|
||||
count = of_get_child_count(dev->of_node);
|
||||
if (!count)
|
||||
return -EINVAL;
|
||||
|
||||
priv = devm_kzalloc(dev, sizeof_is31fl32xx_priv(count),
|
||||
GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
priv->client = client;
|
||||
priv->cdef = cdef;
|
||||
i2c_set_clientdata(client, priv);
|
||||
|
||||
ret = is31fl32xx_init_regs(priv);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = is31fl32xx_parse_dt(dev, priv);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int is31fl32xx_remove(struct i2c_client *client)
|
||||
{
|
||||
struct is31fl32xx_priv *priv = i2c_get_clientdata(client);
|
||||
|
||||
return is31fl32xx_reset_regs(priv);
|
||||
}
|
||||
|
||||
/*
|
||||
* i2c-core requires that id_table be non-NULL, even though
|
||||
* it is not used for DeviceTree based instantiation.
|
||||
*/
|
||||
static const struct i2c_device_id is31fl31xx_id[] = {
|
||||
{},
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(i2c, is31fl31xx_id);
|
||||
|
||||
static struct i2c_driver is31fl32xx_driver = {
|
||||
.driver = {
|
||||
.name = "is31fl32xx",
|
||||
.of_match_table = of_is31fl31xx_match,
|
||||
},
|
||||
.probe = is31fl32xx_probe,
|
||||
.remove = is31fl32xx_remove,
|
||||
.id_table = is31fl31xx_id,
|
||||
};
|
||||
|
||||
module_i2c_driver(is31fl32xx_driver);
|
||||
|
||||
MODULE_AUTHOR("David Rivshin <drivshin@allworx.com>");
|
||||
MODULE_DESCRIPTION("ISSI IS31FL32xx LED driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
@ -698,7 +698,7 @@ static int lm3533_led_probe(struct platform_device *pdev)
|
||||
|
||||
platform_set_drvdata(pdev, led);
|
||||
|
||||
ret = led_classdev_register(pdev->dev.parent, &led->cdev);
|
||||
ret = devm_led_classdev_register(pdev->dev.parent, &led->cdev);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "failed to register LED %d\n", pdev->id);
|
||||
return ret;
|
||||
@ -708,18 +708,13 @@ static int lm3533_led_probe(struct platform_device *pdev)
|
||||
|
||||
ret = lm3533_led_setup(led, pdata);
|
||||
if (ret)
|
||||
goto err_unregister;
|
||||
return ret;
|
||||
|
||||
ret = lm3533_ctrlbank_enable(&led->cb);
|
||||
if (ret)
|
||||
goto err_unregister;
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
|
||||
err_unregister:
|
||||
led_classdev_unregister(&led->cdev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int lm3533_led_remove(struct platform_device *pdev)
|
||||
@ -729,7 +724,6 @@ static int lm3533_led_remove(struct platform_device *pdev)
|
||||
dev_dbg(&pdev->dev, "%s\n", __func__);
|
||||
|
||||
lm3533_ctrlbank_disable(&led->cb);
|
||||
led_classdev_unregister(&led->cdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -199,8 +199,11 @@ static int lp3944_led_set(struct lp3944_led_data *led, u8 status)
|
||||
if (status > LP3944_LED_STATUS_DIM1)
|
||||
return -EINVAL;
|
||||
|
||||
/* invert only 0 and 1, leave unchanged the other values,
|
||||
* remember we are abusing status to set blink patterns
|
||||
/*
|
||||
* Invert status only when it's < 2 (i.e. 0 or 1) which means it's
|
||||
* controlling the on/off state directly.
|
||||
* When, instead, status is >= 2 don't invert it because it would mean
|
||||
* to mess with the hardware blinking mode.
|
||||
*/
|
||||
if (led->type == LP3944_LED_TYPE_LED_INVERTED && status < 2)
|
||||
status = 1 - status;
|
||||
|
||||
@ -146,15 +146,13 @@ static int lp8788_led_probe(struct platform_device *pdev)
|
||||
|
||||
mutex_init(&led->lock);
|
||||
|
||||
platform_set_drvdata(pdev, led);
|
||||
|
||||
ret = lp8788_led_init_device(led, led_pdata);
|
||||
if (ret) {
|
||||
dev_err(dev, "led init device err: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = led_classdev_register(dev, &led->led_dev);
|
||||
ret = devm_led_classdev_register(dev, &led->led_dev);
|
||||
if (ret) {
|
||||
dev_err(dev, "led register err: %d\n", ret);
|
||||
return ret;
|
||||
@ -163,18 +161,8 @@ static int lp8788_led_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int lp8788_led_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct lp8788_led *led = platform_get_drvdata(pdev);
|
||||
|
||||
led_classdev_unregister(&led->led_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver lp8788_led_driver = {
|
||||
.probe = lp8788_led_probe,
|
||||
.remove = lp8788_led_remove,
|
||||
.driver = {
|
||||
.name = LP8788_DEV_KEYLED,
|
||||
},
|
||||
|
||||
@ -281,30 +281,18 @@ static int max8997_led_probe(struct platform_device *pdev)
|
||||
|
||||
mutex_init(&led->mutex);
|
||||
|
||||
platform_set_drvdata(pdev, led);
|
||||
|
||||
ret = led_classdev_register(&pdev->dev, &led->cdev);
|
||||
ret = devm_led_classdev_register(&pdev->dev, &led->cdev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int max8997_led_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct max8997_led *led = platform_get_drvdata(pdev);
|
||||
|
||||
led_classdev_unregister(&led->cdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver max8997_led_driver = {
|
||||
.driver = {
|
||||
.name = "max8997-led",
|
||||
},
|
||||
.probe = max8997_led_probe,
|
||||
.remove = max8997_led_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(max8997_led_driver);
|
||||
|
||||
@ -29,11 +29,6 @@ struct s3c24xx_gpio_led {
|
||||
struct s3c24xx_led_platdata *pdata;
|
||||
};
|
||||
|
||||
static inline struct s3c24xx_gpio_led *pdev_to_gpio(struct platform_device *dev)
|
||||
{
|
||||
return platform_get_drvdata(dev);
|
||||
}
|
||||
|
||||
static inline struct s3c24xx_gpio_led *to_gpio(struct led_classdev *led_cdev)
|
||||
{
|
||||
return container_of(led_cdev, struct s3c24xx_gpio_led, cdev);
|
||||
@ -59,15 +54,6 @@ static void s3c24xx_led_set(struct led_classdev *led_cdev,
|
||||
}
|
||||
}
|
||||
|
||||
static int s3c24xx_led_remove(struct platform_device *dev)
|
||||
{
|
||||
struct s3c24xx_gpio_led *led = pdev_to_gpio(dev);
|
||||
|
||||
led_classdev_unregister(&led->cdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int s3c24xx_led_probe(struct platform_device *dev)
|
||||
{
|
||||
struct s3c24xx_led_platdata *pdata = dev_get_platdata(&dev->dev);
|
||||
@ -79,8 +65,6 @@ static int s3c24xx_led_probe(struct platform_device *dev)
|
||||
if (!led)
|
||||
return -ENOMEM;
|
||||
|
||||
platform_set_drvdata(dev, led);
|
||||
|
||||
led->cdev.brightness_set = s3c24xx_led_set;
|
||||
led->cdev.default_trigger = pdata->def_trigger;
|
||||
led->cdev.name = pdata->name;
|
||||
@ -104,7 +88,7 @@ static int s3c24xx_led_probe(struct platform_device *dev)
|
||||
|
||||
/* register our new led device */
|
||||
|
||||
ret = led_classdev_register(&dev->dev, &led->cdev);
|
||||
ret = devm_led_classdev_register(&dev->dev, &led->cdev);
|
||||
if (ret < 0)
|
||||
dev_err(&dev->dev, "led_classdev_register failed\n");
|
||||
|
||||
@ -113,7 +97,6 @@ static int s3c24xx_led_probe(struct platform_device *dev)
|
||||
|
||||
static struct platform_driver s3c24xx_led_driver = {
|
||||
.probe = s3c24xx_led_probe,
|
||||
.remove = s3c24xx_led_remove,
|
||||
.driver = {
|
||||
.name = "s3c24xx_led",
|
||||
},
|
||||
|
||||
@ -239,7 +239,6 @@ static int wm831x_status_probe(struct platform_device *pdev)
|
||||
GFP_KERNEL);
|
||||
if (!drvdata)
|
||||
return -ENOMEM;
|
||||
platform_set_drvdata(pdev, drvdata);
|
||||
|
||||
drvdata->wm831x = wm831x;
|
||||
drvdata->reg = res->start;
|
||||
@ -284,7 +283,7 @@ static int wm831x_status_probe(struct platform_device *pdev)
|
||||
drvdata->cdev.blink_set = wm831x_status_blink_set;
|
||||
drvdata->cdev.groups = wm831x_status_groups;
|
||||
|
||||
ret = led_classdev_register(wm831x->dev, &drvdata->cdev);
|
||||
ret = devm_led_classdev_register(wm831x->dev, &drvdata->cdev);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
|
||||
return ret;
|
||||
@ -293,21 +292,11 @@ static int wm831x_status_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wm831x_status_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct wm831x_status *drvdata = platform_get_drvdata(pdev);
|
||||
|
||||
led_classdev_unregister(&drvdata->cdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver wm831x_status_driver = {
|
||||
.driver = {
|
||||
.name = "wm831x-status",
|
||||
},
|
||||
.probe = wm831x_status_probe,
|
||||
.remove = wm831x_status_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(wm831x_status_driver);
|
||||
|
||||
@ -39,6 +39,7 @@ struct led_classdev {
|
||||
|
||||
/* Lower 16 bits reflect status */
|
||||
#define LED_SUSPENDED (1 << 0)
|
||||
#define LED_UNREGISTERING (1 << 1)
|
||||
/* Upper 16 bits reflect control information */
|
||||
#define LED_CORE_SUSPENDRESUME (1 << 16)
|
||||
#define LED_BLINK_ONESHOT (1 << 17)
|
||||
@ -48,9 +49,12 @@ struct led_classdev {
|
||||
#define LED_BLINK_DISABLE (1 << 21)
|
||||
#define LED_SYSFS_DISABLE (1 << 22)
|
||||
#define LED_DEV_CAP_FLASH (1 << 23)
|
||||
#define LED_HW_PLUGGABLE (1 << 24)
|
||||
|
||||
/* Set LED brightness level */
|
||||
/* Must not sleep, use a workqueue if needed */
|
||||
/* Set LED brightness level
|
||||
* Must not sleep. Use brightness_set_blocking for drivers
|
||||
* that can sleep while setting brightness.
|
||||
*/
|
||||
void (*brightness_set)(struct led_classdev *led_cdev,
|
||||
enum led_brightness brightness);
|
||||
/*
|
||||
|
||||
Loading…
Reference in New Issue
Block a user