openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

LEDs pull request for 5.8-rc1. 

New drivers: aw2013, sgm3140, some fixes. Nothing much to see here,
 next release should be more interesting.
 -----BEGIN PGP SIGNATURE-----
 
 iF0EABECAB0WIQRPfPO7r0eAhk010v0w5/Bqldv68gUCXtjlggAKCRAw5/Bqldv6
 8mi4AJ9sFTwt9zcnIB3dZcD+C9J/GtCU7ACgwlN9UsQ1qvpEG1xE0mSgLlPvebQ=
 =HymN
 -----END PGP SIGNATURE-----

Merge tag 'leds-5.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/pavel/linux-leds

Pull LED updates from Pavel Machek:
 "New drivers: aw2013, sgm3140, some fixes

  Nothing much to see here, next release should be more interesting"

* tag 'leds-5.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/pavel/linux-leds:
  leds: add aw2013 driver
  dt-bindings: leds: Add binding for aw2013
  leds: trigger: remove redundant assignment to variable ret
  leds: netxbig: Convert to use GPIO descriptors
  leds: add sgm3140 driver
  dt-bindings: leds: Add binding for sgm3140
  leds: ariel: Add driver for status LEDs on Dell Wyse 3020
  leds: pwm: check result of led_pwm_set() in led_pwm_add()
  leds: tlc591xxt: hide error on EPROBE_DEFER
  leds: tca6507: Include the right header
  leds: lt3593: Drop surplus include
  leds: lp3952: Include the right header
  leds: lm355x: Drop surplus include
This commit is contained in:
Linus Torvalds 2020-06-04 11:03:45 -07:00
parent 9875b201e0 59ea3c9faf
commit 86c67ce20d
15 changed files with 1173 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
Documentation/devicetree/bindings/leds/leds-aw2013.yaml Normal file
View File

@ -0,0 +1,91 @@
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
%YAML 1.2
---
$id: http://devicetree.org/schemas/leds/leds-aw2013.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: AWINIC AW2013 3-channel LED Driver
maintainers:
- Nikita Travkin <nikitos.tr@gmail.com>
description: |
The AW2013 is a 3-channel LED driver with I2C interface. It can control
LED brightness with PWM output.
properties:
compatible:
const: awinic,aw2013
reg:
maxItems: 1
vcc-supply:
description: Regulator providing power to the "VCC" pin.
"#address-cells":
const: 1
"#size-cells":
const: 0
patternProperties:
"^led@[0-2]$":
type: object
allOf:
- $ref: common.yaml#
properties:
reg:
description: Index of the LED.
minimum: 0
maximum: 2
required:
- compatible
- reg
- "#address-cells"
- "#size-cells"
additionalProperties: false
examples:
- |
#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/leds/common.h>
i2c0 {
#address-cells = <1>;
#size-cells = <0>;
led-controller@45 {
compatible = "awinic,aw2013";
reg = <0x45>;
#address-cells = <1>;
#size-cells = <0>;
vcc-supply = <&pm8916_l17>;
led@0 {
reg = <0>;
led-max-microamp = <5000>;
function = LED_FUNCTION_INDICATOR;
color = <LED_COLOR_ID_RED>;
};
led@1 {
reg = <1>;
led-max-microamp = <5000>;
function = LED_FUNCTION_INDICATOR;
color = <LED_COLOR_ID_GREEN>;
};
led@2 {
reg = <2>;
led-max-microamp = <5000>;
function = LED_FUNCTION_INDICATOR;
color = <LED_COLOR_ID_BLUE>;
};
};
};
...

62
Documentation/devicetree/bindings/leds/leds-sgm3140.yaml Normal file
View File

@ -0,0 +1,62 @@
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
%YAML 1.2
---
$id: http://devicetree.org/schemas/leds/leds-sgm3140.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: SGMICRO SGM3140 500mA Buck/Boost Charge Pump LED Driver
maintainers:
- Luca Weiss <luca@z3ntu.xyz>
description: |
The SGM3140 is a current-regulated charge pump which can regulate two current
levels for Flash and Torch modes.
The data sheet can be found at:
http://www.sg-micro.com/uploads/soft/20190626/1561535688.pdf
properties:
compatible:
const: sgmicro,sgm3140
enable-gpios:
maxItems: 1
description: A connection to the 'EN' pin.
flash-gpios:
maxItems: 1
description: A connection to the 'FLASH' pin.
vin-supply:
description: Regulator providing power to the 'VIN' pin.
led:
type: object
allOf:
- $ref: common.yaml#
required:
- compatible
- flash-gpios
- enable-gpios
additionalProperties: false
examples:
- |
#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/leds/common.h>
led-controller {
compatible = "sgmicro,sgm3140";
flash-gpios = <&pio 3 24 GPIO_ACTIVE_HIGH>; /* PD24 */
enable-gpios = <&pio 2 3 GPIO_ACTIVE_HIGH>; /* PC3 */
vin-supply = <&reg_dcdc1>;
sgm3140_flash: led {
function = LED_FUNCTION_FLASH;
color = <LED_COLOR_ID_WHITE>;
flash-max-timeout-us = <250000>;
};
};

29
drivers/leds/Kconfig
View File

@ -83,6 +83,17 @@ config LEDS_APU
To compile this driver as a module, choose M here: the
module will be called leds-apu.
config LEDS_ARIEL
tristate "Dell Wyse 3020 status LED support"
depends on LEDS_CLASS
depends on (MACH_MMP3_DT && MFD_ENE_KB3930) || COMPILE_TEST
help
This driver adds support for controlling the front panel status
LEDs on Dell Wyse 3020 (Ariel) board via the KB3930 Embedded
Controller.
Say Y to if your machine is a Dell Wyse 3020 thin client.
config LEDS_AS3645A
tristate "AS3645A and LM3555 LED flash controllers support"
depends on I2C && LEDS_CLASS_FLASH
@ -92,6 +103,16 @@ config LEDS_AS3645A
controller. V4L2 flash API is provided as well if
CONFIG_V4L2_FLASH_API is enabled.
config LEDS_AW2013
tristate "LED support for Awinic AW2013"
depends on LEDS_CLASS && I2C && OF
help
This option enables support for the AW2013 3-channel
LED driver.
To compile this driver as a module, choose M here: the module
will be called leds-aw2013.
config LEDS_BCM6328
tristate "LED Support for Broadcom BCM6328"
depends on LEDS_CLASS
@ -857,6 +878,14 @@ config LEDS_IP30
To compile this driver as a module, choose M here: the module
will be called leds-ip30.
config LEDS_SGM3140
tristate "LED support for the SGM3140"
depends on LEDS_CLASS_FLASH
depends on V4L2_FLASH_LED_CLASS || !V4L2_FLASH_LED_CLASS
help
This option enables support for the SGM3140 500mA Buck/Boost Charge
Pump LED Driver.
comment "LED Triggers"
source "drivers/leds/trigger/Kconfig"

3
drivers/leds/Makefile
View File

@ -12,8 +12,10 @@ obj-$(CONFIG_LEDS_AAT1290) += leds-aat1290.o
obj-$(CONFIG_LEDS_ADP5520) += leds-adp5520.o
obj-$(CONFIG_LEDS_AN30259A) += leds-an30259a.o
obj-$(CONFIG_LEDS_APU) += leds-apu.o
obj-$(CONFIG_LEDS_ARIEL) += leds-ariel.o
obj-$(CONFIG_LEDS_AS3645A) += leds-as3645a.o
obj-$(CONFIG_LEDS_ASIC3) += leds-asic3.o
obj-$(CONFIG_LEDS_AW2013) += leds-aw2013.o
obj-$(CONFIG_LEDS_BCM6328) += leds-bcm6328.o
obj-$(CONFIG_LEDS_BCM6358) += leds-bcm6358.o
obj-$(CONFIG_LEDS_BD2802) += leds-bd2802.o
@ -77,6 +79,7 @@ obj-$(CONFIG_LEDS_PWM) += leds-pwm.o
obj-$(CONFIG_LEDS_REGULATOR) += leds-regulator.o
obj-$(CONFIG_LEDS_S3C24XX) += leds-s3c24xx.o
obj-$(CONFIG_LEDS_SC27XX_BLTC) += leds-sc27xx-bltc.o
obj-$(CONFIG_LEDS_SGM3140) += leds-sgm3140.o
obj-$(CONFIG_LEDS_SUNFIRE) += leds-sunfire.o
obj-$(CONFIG_LEDS_SYSCON) += leds-syscon.o
obj-$(CONFIG_LEDS_TCA6507) += leds-tca6507.o

133
drivers/leds/leds-ariel.c Normal file
View File

@ -0,0 +1,133 @@
// SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0-or-later
/*
* Dell Wyse 3020 a.k.a. "Ariel" Embedded Controller LED Driver
*
* Copyright (C) 2020 Lubomir Rintel
*/
#include <linux/module.h>
#include <linux/leds.h>
#include <linux/regmap.h>
#include <linux/of_platform.h>
enum ec_index {
EC_BLUE_LED = 0x01,
EC_AMBER_LED = 0x02,
EC_GREEN_LED = 0x03,
};
enum {
EC_LED_OFF = 0x00,
EC_LED_STILL = 0x01,
EC_LED_FADE = 0x02,
EC_LED_BLINK = 0x03,
};
struct ariel_led {
struct regmap *ec_ram;
enum ec_index ec_index;
struct led_classdev led_cdev;
};
#define led_cdev_to_ariel_led(c) container_of(c, struct ariel_led, led_cdev)
static enum led_brightness ariel_led_get(struct led_classdev *led_cdev)
{
struct ariel_led *led = led_cdev_to_ariel_led(led_cdev);
unsigned int led_status = 0;
if (regmap_read(led->ec_ram, led->ec_index, &led_status))
return LED_OFF;
if (led_status == EC_LED_STILL)
return LED_FULL;
else
return LED_OFF;
}
static void ariel_led_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct ariel_led *led = led_cdev_to_ariel_led(led_cdev);
if (brightness == LED_OFF)
regmap_write(led->ec_ram, led->ec_index, EC_LED_OFF);
else
regmap_write(led->ec_ram, led->ec_index, EC_LED_STILL);
}
static int ariel_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
struct ariel_led *led = led_cdev_to_ariel_led(led_cdev);
if (*delay_on == 0 && *delay_off == 0)
return -EINVAL;
if (*delay_on == 0) {
regmap_write(led->ec_ram, led->ec_index, EC_LED_OFF);
} else if (*delay_off == 0) {
regmap_write(led->ec_ram, led->ec_index, EC_LED_STILL);
} else {
*delay_on = 500;
*delay_off = 500;
regmap_write(led->ec_ram, led->ec_index, EC_LED_BLINK);
}
return 0;
}
#define NLEDS 3
static int ariel_led_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct ariel_led *leds;
struct regmap *ec_ram;
int ret;
int i;
ec_ram = dev_get_regmap(dev->parent, "ec_ram");
if (!ec_ram)
return -ENODEV;
leds = devm_kcalloc(dev, NLEDS, sizeof(*leds), GFP_KERNEL);
if (!leds)
return -ENOMEM;
leds[0].ec_index = EC_BLUE_LED;
leds[0].led_cdev.name = "blue:power",
leds[0].led_cdev.default_trigger = "default-on";
leds[1].ec_index = EC_AMBER_LED;
leds[1].led_cdev.name = "amber:status",
leds[2].ec_index = EC_GREEN_LED;
leds[2].led_cdev.name = "green:status",
leds[2].led_cdev.default_trigger = "default-on";
for (i = 0; i < NLEDS; i++) {
leds[i].ec_ram = ec_ram;
leds[i].led_cdev.brightness_get = ariel_led_get;
leds[i].led_cdev.brightness_set = ariel_led_set;
leds[i].led_cdev.blink_set = ariel_blink_set;
ret = devm_led_classdev_register(dev, &leds[i].led_cdev);
if (ret)
return ret;
}
return 0;
}
static struct platform_driver ariel_led_driver = {
.probe = ariel_led_probe,
.driver = {
.name = "dell-wyse-ariel-led",
},
};
module_platform_driver(ariel_led_driver);
MODULE_AUTHOR("Lubomir Rintel <lkundrak@v3.sk>");
MODULE_DESCRIPTION("Dell Wyse 3020 Status LEDs Driver");
MODULE_LICENSE("Dual BSD/GPL");

436
drivers/leds/leds-aw2013.c Normal file
View File

@ -0,0 +1,436 @@
// SPDX-License-Identifier: GPL-2.0+
// Driver for Awinic AW2013 3-channel LED driver
#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/regulator/consumer.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/regmap.h>
#define AW2013_MAX_LEDS 3
/* Reset and ID register */
#define AW2013_RSTR 0x00
#define AW2013_RSTR_RESET 0x55
#define AW2013_RSTR_CHIP_ID 0x33
/* Global control register */
#define AW2013_GCR 0x01
#define AW2013_GCR_ENABLE BIT(0)
/* LED channel enable register */
#define AW2013_LCTR 0x30
#define AW2013_LCTR_LE(x) BIT((x))
/* LED channel control registers */
#define AW2013_LCFG(x) (0x31 + (x))
#define AW2013_LCFG_IMAX_MASK (BIT(0) | BIT(1)) // Should be 0-3
#define AW2013_LCFG_MD BIT(4)
#define AW2013_LCFG_FI BIT(5)
#define AW2013_LCFG_FO BIT(6)
/* LED channel PWM registers */
#define AW2013_REG_PWM(x) (0x34 + (x))
/* LED channel timing registers */
#define AW2013_LEDT0(x) (0x37 + (x) * 3)
#define AW2013_LEDT0_T1(x) ((x) << 4) // Should be 0-7
#define AW2013_LEDT0_T2(x) (x) // Should be 0-5
#define AW2013_LEDT1(x) (0x38 + (x) * 3)
#define AW2013_LEDT1_T3(x) ((x) << 4) // Should be 0-7
#define AW2013_LEDT1_T4(x) (x) // Should be 0-7
#define AW2013_LEDT2(x) (0x39 + (x) * 3)
#define AW2013_LEDT2_T0(x) ((x) << 4) // Should be 0-8
#define AW2013_LEDT2_REPEAT(x) (x) // Should be 0-15
#define AW2013_REG_MAX 0x77
#define AW2013_TIME_STEP 130 /* ms */
struct aw2013;
struct aw2013_led {
struct aw2013 *chip;
struct led_classdev cdev;
u32 num;
unsigned int imax;
};
struct aw2013 {
struct mutex mutex; /* held when writing to registers */
struct regulator *vcc_regulator;
struct i2c_client *client;
struct aw2013_led leds[AW2013_MAX_LEDS];
struct regmap *regmap;
int num_leds;
bool enabled;
};
static int aw2013_chip_init(struct aw2013 *chip)
{
int i, ret;
ret = regmap_write(chip->regmap, AW2013_GCR, AW2013_GCR_ENABLE);
if (ret) {
dev_err(&chip->client->dev, "Failed to enable the chip: %d\n",
ret);
return ret;
}
for (i = 0; i < chip->num_leds; i++) {
ret = regmap_update_bits(chip->regmap,
AW2013_LCFG(chip->leds[i].num),
AW2013_LCFG_IMAX_MASK,
chip->leds[i].imax);
if (ret) {
dev_err(&chip->client->dev,
"Failed to set maximum current for led %d: %d\n",
chip->leds[i].num, ret);
return ret;
}
}
return ret;
}
static void aw2013_chip_disable(struct aw2013 *chip)
{
int ret;
if (!chip->enabled)
return;
regmap_write(chip->regmap, AW2013_GCR, 0);
ret = regulator_disable(chip->vcc_regulator);
if (ret) {
dev_err(&chip->client->dev,
"Failed to disable regulator: %d\n", ret);
return;
}
chip->enabled = false;
}
static int aw2013_chip_enable(struct aw2013 *chip)
{
int ret;
if (chip->enabled)
return 0;
ret = regulator_enable(chip->vcc_regulator);
if (ret) {
dev_err(&chip->client->dev,
"Failed to enable regulator: %d\n", ret);
return ret;
}
chip->enabled = true;
ret = aw2013_chip_init(chip);
if (ret)
aw2013_chip_disable(chip);
return ret;
}
static bool aw2013_chip_in_use(struct aw2013 *chip)
{
int i;
for (i = 0; i < chip->num_leds; i++)
if (chip->leds[i].cdev.brightness)
return true;
return false;
}
static int aw2013_brightness_set(struct led_classdev *cdev,
enum led_brightness brightness)
{
struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
int ret, num;
mutex_lock(&led->chip->mutex);
if (aw2013_chip_in_use(led->chip)) {
ret = aw2013_chip_enable(led->chip);
if (ret)
goto error;
}
num = led->num;
ret = regmap_write(led->chip->regmap, AW2013_REG_PWM(num), brightness);
if (ret)
goto error;
if (brightness) {
ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
AW2013_LCTR_LE(num), 0xFF);
} else {
ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
AW2013_LCTR_LE(num), 0);
if (ret)
goto error;
ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
AW2013_LCFG_MD, 0);
}
if (ret)
goto error;
if (!aw2013_chip_in_use(led->chip))
aw2013_chip_disable(led->chip);
error:
mutex_unlock(&led->chip->mutex);
return ret;
}
static int aw2013_blink_set(struct led_classdev *cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
int ret, num = led->num;
unsigned long off = 0, on = 0;
/* If no blink specified, default to 1 Hz. */
if (!*delay_off && !*delay_on) {
*delay_off = 500;
*delay_on = 500;
}
if (!led->cdev.brightness) {
led->cdev.brightness = LED_FULL;
ret = aw2013_brightness_set(&led->cdev, led->cdev.brightness);
if (ret)
return ret;
}
/* Never on - just set to off */
if (!*delay_on) {
led->cdev.brightness = LED_OFF;
return aw2013_brightness_set(&led->cdev, LED_OFF);
}
mutex_lock(&led->chip->mutex);
/* Never off - brightness is already set, disable blinking */
if (!*delay_off) {
ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
AW2013_LCFG_MD, 0);
goto out;
}
/* Convert into values the HW will understand. */
off = min(5, ilog2((*delay_off - 1) / AW2013_TIME_STEP) + 1);
on = min(7, ilog2((*delay_on - 1) / AW2013_TIME_STEP) + 1);
*delay_off = BIT(off) * AW2013_TIME_STEP;
*delay_on = BIT(on) * AW2013_TIME_STEP;
/* Set timings */
ret = regmap_write(led->chip->regmap,
AW2013_LEDT0(num), AW2013_LEDT0_T2(on));
if (ret)
goto out;
ret = regmap_write(led->chip->regmap,
AW2013_LEDT1(num), AW2013_LEDT1_T4(off));
if (ret)
goto out;
/* Finally, enable the LED */
ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
AW2013_LCFG_MD, 0xFF);
if (ret)
goto out;
ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
AW2013_LCTR_LE(num), 0xFF);
out:
mutex_unlock(&led->chip->mutex);
return ret;
}
static int aw2013_probe_dt(struct aw2013 *chip)
{
struct device_node *np = chip->client->dev.of_node, *child;
int count, ret = 0, i = 0;
struct aw2013_led *led;
count = of_get_child_count(np);
if (!count || count > AW2013_MAX_LEDS)
return -EINVAL;
regmap_write(chip->regmap, AW2013_RSTR, AW2013_RSTR_RESET);
for_each_available_child_of_node(np, child) {
struct led_init_data init_data = {};
u32 source;
u32 imax;
ret = of_property_read_u32(child, "reg", &source);
if (ret != 0 || source >= AW2013_MAX_LEDS) {
dev_err(&chip->client->dev,
"Couldn't read LED address: %d\n", ret);
count--;
continue;
}
led = &chip->leds[i];
led->num = source;
led->chip = chip;
init_data.fwnode = of_fwnode_handle(child);
if (!of_property_read_u32(child, "led-max-microamp", &imax)) {
led->imax = min_t(u32, imax / 5000, 3);
} else {
led->imax = 1; // 5mA
dev_info(&chip->client->dev,
"DT property led-max-microamp is missing\n");
}
of_property_read_string(child, "linux,default-trigger",
&led->cdev.default_trigger);
led->cdev.brightness_set_blocking = aw2013_brightness_set;
led->cdev.blink_set = aw2013_blink_set;
ret = devm_led_classdev_register_ext(&chip->client->dev,
&led->cdev, &init_data);
if (ret < 0)
return ret;
i++;
}
if (!count)
return -EINVAL;
chip->num_leds = i;
return 0;
}
static const struct regmap_config aw2013_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = AW2013_REG_MAX,
};
static int aw2013_probe(struct i2c_client *client)
{
struct aw2013 *chip;
int ret;
unsigned int chipid;
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
mutex_init(&chip->mutex);
mutex_lock(&chip->mutex);
chip->client = client;
i2c_set_clientdata(client, chip);
chip->regmap = devm_regmap_init_i2c(client, &aw2013_regmap_config);
if (IS_ERR(chip->regmap)) {
ret = PTR_ERR(chip->regmap);
dev_err(&client->dev, "Failed to allocate register map: %d\n",
ret);
goto error;
}
chip->vcc_regulator = devm_regulator_get(&client->dev, "vcc");
ret = PTR_ERR_OR_ZERO(chip->vcc_regulator);
if (ret) {
if (ret != -EPROBE_DEFER)
dev_err(&client->dev,
"Failed to request regulator: %d\n", ret);
goto error;
}
ret = regulator_enable(chip->vcc_regulator);
if (ret) {
dev_err(&client->dev,
"Failed to enable regulator: %d\n", ret);
goto error;
}
ret = regmap_read(chip->regmap, AW2013_RSTR, &chipid);
if (ret) {
dev_err(&client->dev, "Failed to read chip ID: %d\n",
ret);
goto error_reg;
}
if (chipid != AW2013_RSTR_CHIP_ID) {
dev_err(&client->dev, "Chip reported wrong ID: %x\n",
chipid);
ret = -ENODEV;
goto error_reg;
}
ret = aw2013_probe_dt(chip);
if (ret < 0)
goto error_reg;
ret = regulator_disable(chip->vcc_regulator);
if (ret) {
dev_err(&client->dev,
"Failed to disable regulator: %d\n", ret);
goto error;
}
mutex_unlock(&chip->mutex);
return 0;
error_reg:
regulator_disable(chip->vcc_regulator);
error:
mutex_destroy(&chip->mutex);
return ret;
}
static int aw2013_remove(struct i2c_client *client)
{
struct aw2013 *chip = i2c_get_clientdata(client);
aw2013_chip_disable(chip);
mutex_destroy(&chip->mutex);
return 0;
}
static const struct of_device_id aw2013_match_table[] = {
{ .compatible = "awinic,aw2013", },
{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, aw2013_match_table);
static struct i2c_driver aw2013_driver = {
.driver = {
.name = "leds-aw2013",
.of_match_table = of_match_ptr(aw2013_match_table),
},
.probe_new = aw2013_probe,
.remove = aw2013_remove,
};
module_i2c_driver(aw2013_driver);
MODULE_AUTHOR("Nikita Travkin <nikitos.tr@gmail.com>");
MODULE_DESCRIPTION("AW2013 LED driver");
MODULE_LICENSE("GPL v2");

1
drivers/leds/leds-lm355x.c
View File

@ -7,7 +7,6 @@
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/platform_device.h>

2
drivers/leds/leds-lp3952.c
View File

@ -7,7 +7,7 @@
*/
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/io.h>
#include <linux/kernel.h>

1
drivers/leds/leds-lt3593.c
View File

@ -5,7 +5,6 @@
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/slab.h>
#include <linux/module.h>

148
drivers/leds/leds-netxbig.c
View File

@ -12,16 +12,17 @@
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/leds.h>
#include <linux/of.h>
#include <linux/of_platform.h>
struct netxbig_gpio_ext {
unsigned int *addr;
struct gpio_desc **addr;
int num_addr;
unsigned int *data;
struct gpio_desc **data;
int num_data;
unsigned int enable;
struct gpio_desc *enable;
};
enum netxbig_led_mode {
@ -69,7 +70,7 @@ static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr)
int pin;
for (pin = 0; pin < gpio_ext->num_addr; pin++)
gpio_set_value(gpio_ext->addr[pin], (addr >> pin) & 1);
gpiod_set_value(gpio_ext->addr[pin], (addr >> pin) & 1);
}
static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data)
@ -77,14 +78,14 @@ static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data)
int pin;
for (pin = 0; pin < gpio_ext->num_data; pin++)
gpio_set_value(gpio_ext->data[pin], (data >> pin) & 1);
gpiod_set_value(gpio_ext->data[pin], (data >> pin) & 1);
}
static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext)
{
/* Enable select is done on the raising edge. */
gpio_set_value(gpio_ext->enable, 0);
gpio_set_value(gpio_ext->enable, 1);
gpiod_set_value(gpio_ext->enable, 0);
gpiod_set_value(gpio_ext->enable, 1);
}
static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext,
@ -99,41 +100,6 @@ static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext,
spin_unlock_irqrestore(&gpio_ext_lock, flags);
}
static int gpio_ext_init(struct platform_device *pdev,
struct netxbig_gpio_ext *gpio_ext)
{
int err;
int i;
if (unlikely(!gpio_ext))
return -EINVAL;
/* Configure address GPIOs. */
for (i = 0; i < gpio_ext->num_addr; i++) {
err = devm_gpio_request_one(&pdev->dev, gpio_ext->addr[i],
GPIOF_OUT_INIT_LOW,
"GPIO extension addr");
if (err)
return err;
}
/* Configure data GPIOs. */
for (i = 0; i < gpio_ext->num_data; i++) {
err = devm_gpio_request_one(&pdev->dev, gpio_ext->data[i],
GPIOF_OUT_INIT_LOW,
"GPIO extension data");
if (err)
return err;
}
/* Configure "enable select" GPIO. */
err = devm_gpio_request_one(&pdev->dev, gpio_ext->enable,
GPIOF_OUT_INIT_LOW,
"GPIO extension enable");
if (err)
return err;
return 0;
}
/*
* Class LED driver.
*/
@ -347,15 +313,47 @@ static int create_netxbig_led(struct platform_device *pdev,
return devm_led_classdev_register(&pdev->dev, &led_dat->cdev);
}
static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np,
struct netxbig_gpio_ext *gpio_ext)
/**
* netxbig_gpio_ext_remove() - Clean up GPIO extension data
* @data: managed resource data to clean up
*
* Since we pick GPIO descriptors from another device than the device our
* driver is probing to, we need to register a specific callback to free
* these up using managed resources.
*/
static void netxbig_gpio_ext_remove(void *data)
{
int *addr, *data;
struct netxbig_gpio_ext *gpio_ext = data;
int i;
for (i = 0; i < gpio_ext->num_addr; i++)
gpiod_put(gpio_ext->addr[i]);
for (i = 0; i < gpio_ext->num_data; i++)
gpiod_put(gpio_ext->data[i]);
gpiod_put(gpio_ext->enable);
}
/**
* netxbig_gpio_ext_get() - Obtain GPIO extension device data
* @dev: main LED device
* @gpio_ext_dev: the GPIO extension device
* @gpio_ext: the data structure holding the GPIO extension data
*
* This function walks the subdevice that only contain GPIO line
* handles in the device tree and obtains the GPIO descriptors from that
* device.
*/
static int netxbig_gpio_ext_get(struct device *dev,
struct device *gpio_ext_dev,
struct netxbig_gpio_ext *gpio_ext)
{
struct gpio_desc **addr, **data;
int num_addr, num_data;
struct gpio_desc *gpiod;
int ret;
int i;
ret = of_gpio_named_count(np, "addr-gpios");
ret = gpiod_count(gpio_ext_dev, "addr");
if (ret < 0) {
dev_err(dev,
"Failed to count GPIOs in DT property addr-gpios\n");
@ -366,16 +364,25 @@ static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np,
if (!addr)
return -ENOMEM;
/*
* We cannot use devm_ managed resources with these GPIO descriptors
* since they are associated with the "GPIO extension device" which
* does not probe any driver. The device tree parser will however
* populate a platform device for it so we can anyway obtain the
* GPIO descriptors from the device.
*/
for (i = 0; i < num_addr; i++) {
ret = of_get_named_gpio(np, "addr-gpios", i);
if (ret < 0)
return ret;
addr[i] = ret;
gpiod = gpiod_get_index(gpio_ext_dev, "addr", i,
GPIOD_OUT_LOW);
if (IS_ERR(gpiod))
return PTR_ERR(gpiod);
gpiod_set_consumer_name(gpiod, "GPIO extension addr");
addr[i] = gpiod;
}
gpio_ext->addr = addr;
gpio_ext->num_addr = num_addr;
ret = of_gpio_named_count(np, "data-gpios");
ret = gpiod_count(gpio_ext_dev, "data");
if (ret < 0) {
dev_err(dev,
"Failed to count GPIOs in DT property data-gpios\n");
@ -387,23 +394,26 @@ static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np,
return -ENOMEM;
for (i = 0; i < num_data; i++) {
ret = of_get_named_gpio(np, "data-gpios", i);
if (ret < 0)
return ret;
data[i] = ret;
gpiod = gpiod_get_index(gpio_ext_dev, "data", i,
GPIOD_OUT_LOW);
if (IS_ERR(gpiod))
return PTR_ERR(gpiod);
gpiod_set_consumer_name(gpiod, "GPIO extension data");
data[i] = gpiod;
}
gpio_ext->data = data;
gpio_ext->num_data = num_data;
ret = of_get_named_gpio(np, "enable-gpio", 0);
if (ret < 0) {
gpiod = gpiod_get(gpio_ext_dev, "enable", GPIOD_OUT_LOW);
if (IS_ERR(gpiod)) {
dev_err(dev,
"Failed to get GPIO from DT property enable-gpio\n");
return ret;
return PTR_ERR(gpiod);
}
gpio_ext->enable = ret;
gpiod_set_consumer_name(gpiod, "GPIO extension enable");
gpio_ext->enable = gpiod;
return 0;
return devm_add_action_or_reset(dev, netxbig_gpio_ext_remove, gpio_ext);
}
static int netxbig_leds_get_of_pdata(struct device *dev,
@ -411,6 +421,8 @@ static int netxbig_leds_get_of_pdata(struct device *dev,
{
struct device_node *np = dev->of_node;
struct device_node *gpio_ext_np;
struct platform_device *gpio_ext_pdev;
struct device *gpio_ext_dev;
struct device_node *child;
struct netxbig_gpio_ext *gpio_ext;
struct netxbig_led_timer *timers;
@ -426,13 +438,19 @@ static int netxbig_leds_get_of_pdata(struct device *dev,
dev_err(dev, "Failed to get DT handle gpio-ext\n");
return -EINVAL;
}
gpio_ext_pdev = of_find_device_by_node(gpio_ext_np);
if (!gpio_ext_pdev) {
dev_err(dev, "Failed to find platform device for gpio-ext\n");
return -ENODEV;
}
gpio_ext_dev = &gpio_ext_pdev->dev;
gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL);
if (!gpio_ext) {
of_node_put(gpio_ext_np);
return -ENOMEM;
}
ret = gpio_ext_get_of_pdata(dev, gpio_ext_np, gpio_ext);
ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext);
of_node_put(gpio_ext_np);
if (ret)
return ret;
@ -585,10 +603,6 @@ static int netxbig_led_probe(struct platform_device *pdev)
if (!leds_data)
return -ENOMEM;
ret = gpio_ext_init(pdev, pdata->gpio_ext);
if (ret < 0)
return ret;
for (i = 0; i < pdata->num_leds; i++) {
ret = create_netxbig_led(pdev, pdata,
&leds_data[i], &pdata->leds[i]);

16
drivers/leds/leds-pwm.c
View File

@ -91,15 +91,21 @@ static int led_pwm_add(struct device *dev, struct led_pwm_priv *priv,
pwm_init_state(led_data->pwm, &led_data->pwmstate);
ret = devm_led_classdev_register(dev, &led_data->cdev);
if (ret == 0) {
priv->num_leds++;
led_pwm_set(&led_data->cdev, led_data->cdev.brightness);
} else {
if (ret) {
dev_err(dev, "failed to register PWM led for %s: %d\n",
led->name, ret);
return ret;
}
return ret;
ret = led_pwm_set(&led_data->cdev, led_data->cdev.brightness);
if (ret) {
dev_err(dev, "failed to set led PWM value for %s: %d",
led->name, ret);
return ret;
}
priv->num_leds++;
return 0;
}
static int led_pwm_create_fwnode(struct device *dev, struct led_pwm_priv *priv)

320
drivers/leds/leds-sgm3140.c Normal file
View File

@ -0,0 +1,320 @@
// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2020 Luca Weiss <luca@z3ntu.xyz>
#include <linux/gpio/consumer.h>
#include <linux/led-class-flash.h>
#include <linux/module.h>
#include <linux/regulator/consumer.h>
#include <linux/platform_device.h>
#include <media/v4l2-flash-led-class.h>
#define FLASH_TIMEOUT_DEFAULT 250000U /* 250ms */
#define FLASH_MAX_TIMEOUT_DEFAULT 300000U /* 300ms */
struct sgm3140 {
struct led_classdev_flash fled_cdev;
struct v4l2_flash *v4l2_flash;
struct timer_list powerdown_timer;
struct gpio_desc *flash_gpio;
struct gpio_desc *enable_gpio;
struct regulator *vin_regulator;
bool enabled;
/* current timeout in us */
u32 timeout;
/* maximum timeout in us */
u32 max_timeout;
};
static struct sgm3140 *flcdev_to_sgm3140(struct led_classdev_flash *flcdev)
{
return container_of(flcdev, struct sgm3140, fled_cdev);
}
static int sgm3140_strobe_set(struct led_classdev_flash *fled_cdev, bool state)
{
struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
int ret;
if (priv->enabled == state)
return 0;
if (state) {
ret = regulator_enable(priv->vin_regulator);
if (ret) {
dev_err(fled_cdev->led_cdev.dev,
"failed to enable regulator: %d\n", ret);
return ret;
}
gpiod_set_value_cansleep(priv->flash_gpio, 1);
gpiod_set_value_cansleep(priv->enable_gpio, 1);
mod_timer(&priv->powerdown_timer,
jiffies + usecs_to_jiffies(priv->timeout));
} else {
del_timer_sync(&priv->powerdown_timer);
gpiod_set_value_cansleep(priv->enable_gpio, 0);
gpiod_set_value_cansleep(priv->flash_gpio, 0);
ret = regulator_disable(priv->vin_regulator);
if (ret) {
dev_err(fled_cdev->led_cdev.dev,
"failed to disable regulator: %d\n", ret);
return ret;
}
}
priv->enabled = state;
return 0;
}
static int sgm3140_strobe_get(struct led_classdev_flash *fled_cdev, bool *state)
{
struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
*state = timer_pending(&priv->powerdown_timer);
return 0;
}
static int sgm3140_timeout_set(struct led_classdev_flash *fled_cdev,
u32 timeout)
{
struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
priv->timeout = timeout;
return 0;
}
static const struct led_flash_ops sgm3140_flash_ops = {
.strobe_set = sgm3140_strobe_set,
.strobe_get = sgm3140_strobe_get,
.timeout_set = sgm3140_timeout_set,
};
static int sgm3140_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
bool enable = brightness == LED_ON;
int ret;
if (priv->enabled == enable)
return 0;
if (enable) {
ret = regulator_enable(priv->vin_regulator);
if (ret) {
dev_err(led_cdev->dev,
"failed to enable regulator: %d\n", ret);
return ret;
}
gpiod_set_value_cansleep(priv->enable_gpio, 1);
} else {
gpiod_set_value_cansleep(priv->enable_gpio, 0);
ret = regulator_disable(priv->vin_regulator);
if (ret) {
dev_err(led_cdev->dev,
"failed to disable regulator: %d\n", ret);
return ret;
}
}
priv->enabled = enable;
return 0;
}
static void sgm3140_powerdown_timer(struct timer_list *t)
{
struct sgm3140 *priv = from_timer(priv, t, powerdown_timer);
gpiod_set_value(priv->enable_gpio, 0);
gpiod_set_value(priv->flash_gpio, 0);
regulator_disable(priv->vin_regulator);
priv->enabled = false;
}
static void sgm3140_init_flash_timeout(struct sgm3140 *priv)
{
struct led_classdev_flash *fled_cdev = &priv->fled_cdev;
struct led_flash_setting *s;
/* Init flash timeout setting */
s = &fled_cdev->timeout;
s->min = 1;
s->max = priv->max_timeout;
s->step = 1;
s->val = FLASH_TIMEOUT_DEFAULT;
}
#if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv,
struct v4l2_flash_config *v4l2_sd_cfg)
{
struct led_classdev *led_cdev = &priv->fled_cdev.led_cdev;
struct led_flash_setting *s;
strscpy(v4l2_sd_cfg->dev_name, led_cdev->dev->kobj.name,
sizeof(v4l2_sd_cfg->dev_name));
/* Init flash intensity setting */
s = &v4l2_sd_cfg->intensity;
s->min = 0;
s->max = 1;
s->step = 1;
s->val = 1;
}
#else
static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv,
struct v4l2_flash_config *v4l2_sd_cfg)
{
}
#endif
static int sgm3140_probe(struct platform_device *pdev)
{
struct sgm3140 *priv;
struct led_classdev *led_cdev;
struct led_classdev_flash *fled_cdev;
struct led_init_data init_data = {};
struct fwnode_handle *child_node;
struct v4l2_flash_config v4l2_sd_cfg = {};
int ret;
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->flash_gpio = devm_gpiod_get(&pdev->dev, "flash", GPIOD_OUT_LOW);
ret = PTR_ERR_OR_ZERO(priv->flash_gpio);
if (ret) {
if (ret != -EPROBE_DEFER)
dev_err(&pdev->dev,
"Failed to request flash gpio: %d\n", ret);
return ret;
}
priv->enable_gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW);
ret = PTR_ERR_OR_ZERO(priv->enable_gpio);
if (ret) {
if (ret != -EPROBE_DEFER)
dev_err(&pdev->dev,
"Failed to request enable gpio: %d\n", ret);
return ret;
}
priv->vin_regulator = devm_regulator_get(&pdev->dev, "vin");
ret = PTR_ERR_OR_ZERO(priv->vin_regulator);
if (ret) {
if (ret != -EPROBE_DEFER)
dev_err(&pdev->dev,
"Failed to request regulator: %d\n", ret);
return ret;
}
child_node = fwnode_get_next_available_child_node(pdev->dev.fwnode,
NULL);
if (!child_node) {
dev_err(&pdev->dev,
"No fwnode child node found for connected LED.\n");
return -EINVAL;
}
ret = fwnode_property_read_u32(child_node, "flash-max-timeout-us",
&priv->max_timeout);
if (ret) {
priv->max_timeout = FLASH_MAX_TIMEOUT_DEFAULT;
dev_warn(&pdev->dev,
"flash-max-timeout-us property missing\n");
}
/*
* Set default timeout to FLASH_DEFAULT_TIMEOUT except if max_timeout
* from DT is lower.
*/
priv->timeout = min(priv->max_timeout, FLASH_TIMEOUT_DEFAULT);
timer_setup(&priv->powerdown_timer, sgm3140_powerdown_timer, 0);
fled_cdev = &priv->fled_cdev;
led_cdev = &fled_cdev->led_cdev;
fled_cdev->ops = &sgm3140_flash_ops;
led_cdev->brightness_set_blocking = sgm3140_brightness_set;
led_cdev->max_brightness = LED_ON;
led_cdev->flags |= LED_DEV_CAP_FLASH;
sgm3140_init_flash_timeout(priv);
init_data.fwnode = child_node;
platform_set_drvdata(pdev, priv);
/* Register in the LED subsystem */
ret = devm_led_classdev_flash_register_ext(&pdev->dev,
fled_cdev, &init_data);
if (ret) {
dev_err(&pdev->dev, "Failed to register flash device: %d\n",
ret);
goto err;
}
sgm3140_init_v4l2_flash_config(priv, &v4l2_sd_cfg);
/* Create V4L2 Flash subdev */
priv->v4l2_flash = v4l2_flash_init(&pdev->dev,
child_node,
fled_cdev, NULL,
&v4l2_sd_cfg);
if (IS_ERR(priv->v4l2_flash)) {
ret = PTR_ERR(priv->v4l2_flash);
goto err;
}
return ret;
err:
fwnode_handle_put(child_node);
return ret;
}
static int sgm3140_remove(struct platform_device *pdev)
{
struct sgm3140 *priv = platform_get_drvdata(pdev);
del_timer_sync(&priv->powerdown_timer);
v4l2_flash_release(priv->v4l2_flash);
return 0;
}
static const struct of_device_id sgm3140_dt_match[] = {
{ .compatible = "sgmicro,sgm3140" },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, sgm3140_dt_match);
static struct platform_driver sgm3140_driver = {
.probe = sgm3140_probe,
.remove = sgm3140_remove,
.driver = {
.name = "sgm3140",
.of_match_table = sgm3140_dt_match,
},
};
module_platform_driver(sgm3140_driver);
MODULE_AUTHOR("Luca Weiss <luca@z3ntu.xyz>");
MODULE_DESCRIPTION("SG Micro SGM3140 charge pump led driver");
MODULE_LICENSE("GPL v2");

2
drivers/leds/leds-tca6507.c
View File

@ -93,7 +93,7 @@
#include <linux/leds.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/gpio/driver.h>
#include <linux/workqueue.h>
#include <linux/leds-tca6507.h>
#include <linux/of.h>

5
drivers/leds/leds-tlc591xx.c
View File

@ -214,8 +214,9 @@ tlc591xx_probe(struct i2c_client *client,
err = devm_led_classdev_register_ext(dev, &led->ldev,
&init_data);
if (err < 0) {
dev_err(dev, "couldn't register LED %s\n",
led->ldev.name);
if (err != -EPROBE_DEFER)
dev_err(dev, "couldn't register LED %s\n",
led->ldev.name);
return err;
}
}

4
drivers/leds/trigger/ledtrig-timer.c
View File

@ -28,7 +28,7 @@ static ssize_t led_delay_on_store(struct device *dev,
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
unsigned long state;
ssize_t ret = -EINVAL;
ssize_t ret;
ret = kstrtoul(buf, 10, &state);
if (ret)
@ -53,7 +53,7 @@ static ssize_t led_delay_off_store(struct device *dev,
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
unsigned long state;
ssize_t ret = -EINVAL;
ssize_t ret;
ret = kstrtoul(buf, 10, &state);
if (ret)