Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'leds-next-7.1' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/leds
Pull LED updates from Lee Jones:
Core:
- Implement fallback to software node name for LED names
- Fix formatting issues in `led-core.c` reported by checkpatch.pl
- Make `led_remove_lookup()` NULL-aware
- Switch from `class_find_device_by_of_node()` to
`class_find_device_by_fwnode()`
- Drop the unneeded dependency on `OF_GPIO` from `LEDS_NETXBIG`
in Kconfig
Kinetic KTD2692:
- Make the `ktd2692_timing` variable static to resolve a
sparse warning
LGM SSO:
- Fix a typo in the `GET_SRC_OFFSET` macro
- Remove a duplicate assignment of `priv->mmap` in
`intel_sso_led_probe()`
Multicolor:
- Fix a signedness error by changing the `intensity_value` type
to `unsigned int`
Qualcomm LPG:
- Prevent array overflow when selecting high-resolution values
Spreadtrum SC2731:
- Add a compatible string for the SC2730 PMIC LED controller
TI LM3642:
- Use `guard(mutex)` to simplify locking and avoid manual
`mutex_unlock()` calls
TI LP5569:
- Use `sysfs_emit()` instead of `sprintf()` for sysfs outputs
TI LP5860:
- Add the `enable-gpios` property for the `VIO_EN` pin"
TI LP8860:
- Do not unconditionally program the EEPROM on probe
- Hold the mutex lock for the entirety of the EEPROM programming
process
- Return directly from `lp8860_init()` instead of using empty `goto`
statements
- Use a single regmap table and an access table instead of separate
maps for normal and EEPROM registers
- Remove an unused read of the `STATUS` register during EEPROM
programming
TTY Trigger:
- Prefer `IS_ERR_OR_NULL()` over manual NULL checks"
* tag 'leds-next-7.1' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/leds:
leds: class: Make led_remove_lookup() NULL-aware
leds: led-class: Switch to using class_find_device_by_fwnode()
leds: Kconfig: Drop unneeded dependency on OF_GPIO
leds: lm3642: Use guard to simplify locking
leds: core: Fix formatting issues
leds: core: Implement fallback to software node name for LED names
leds: lgm-sso: Fix typo in macro for src offset
dt-bindings: leds: lp5860: add enable-gpio
leds: Prefer IS_ERR_OR_NULL over manual NULL check
dt-bindings: leds: sc2731: Add compatible for SC2730
leds: lp8860: Do not always program EEPROM on probe
leds: lp8860: Remove unused read of STATUS register
leds: lp8860: Hold lock for all of EEPROM programming
leds: lp8860: Return directly from lp8860_init
leds: lp8860: Use a single regmap table
leds: lgm-sso: Remove duplicate assignments for priv->mmap
leds: qcom-lpg: Check for array overflow when selecting the high resolution
leds: ktd2692: Make ktd2692_timing variable static
leds: lp5569: Use sysfs_emit instead of sprintf()
leds: multicolor: Change intensity_value to unsigned int
+103
-99
+7
Documentation/devicetree/bindings/leds/leds-lp5860.yaml
+7
Documentation/devicetree/bindings/leds/leds-lp5860.yaml
···
33
33
'#size-cells':
34
34
const: 0
35
35
36
+
enable-gpios:
37
+
maxItems: 1
38
+
description: |
39
+
GPIO attached to the chip's enable pin (VIO_EN).
40
+
36
41
patternProperties:
37
42
'^multi-led@[0-9a-f]+$':
38
43
type: object
···
79
74
80
75
examples:
81
76
- |
77
+
#include <dt-bindings/gpio/gpio.h>
82
78
#include <dt-bindings/leds/common.h>
83
79
84
80
spi {
···
89
83
led-controller@0 {
90
84
compatible = "ti,lp5860";
91
85
reg = <0x0>;
86
+
enable-gpios = <&gpio1 1 GPIO_ACTIVE_HIGH>;
92
87
#address-cells = <1>;
93
88
#size-cells = <0>;
94
89
+6
-1
Documentation/devicetree/bindings/leds/sprd,sc2731-bltc.yaml
+6
-1
Documentation/devicetree/bindings/leds/sprd,sc2731-bltc.yaml
-1
drivers/leds/Kconfig
-1
drivers/leds/Kconfig
+1
-3
drivers/leds/blink/leds-lgm-sso.c
+1
-3
drivers/leds/blink/leds-lgm-sso.c
···
25
25
#define LED_BLINK_H8_0 0x0
26
26
#define LED_BLINK_H8_1 0x4
27
27
#define GET_FREQ_OFFSET(pin, src) (((pin) * 6) + ((src) * 2))
28
-
#define GET_SRC_OFFSET(pinc) (((pin) * 6) + 4)
28
+
#define GET_SRC_OFFSET(pin) (((pin) * 6) + 4)
29
29
30
30
#define DUTY_CYCLE(x) (0x8 + ((x) * 4))
31
31
#define SSO_CON0 0x2B0
···
807
807
return ret;
808
808
809
809
priv->fpid_clkrate = clk_get_rate(priv->clocks[1].clk);
810
-
811
-
priv->mmap = syscon_node_to_regmap(dev->of_node);
812
810
813
811
priv->mmap = syscon_node_to_regmap(dev->of_node);
814
812
if (IS_ERR(priv->mmap)) {
+1
-1
drivers/leds/flash/leds-ktd2692.c
+1
-1
drivers/leds/flash/leds-ktd2692.c
+2
-2
drivers/leds/led-class-multicolor.c
+2
-2
drivers/leds/led-class-multicolor.c
···
34
34
struct led_classdev *led_cdev = dev_get_drvdata(dev);
35
35
struct led_classdev_mc *mcled_cdev = lcdev_to_mccdev(led_cdev);
36
36
int nrchars, offset = 0;
37
-
int intensity_value[LED_COLOR_ID_MAX];
37
+
unsigned int intensity_value[LED_COLOR_ID_MAX];
38
38
int i;
39
39
ssize_t ret;
40
40
41
41
mutex_lock(&led_cdev->led_access);
42
42
43
43
for (i = 0; i < mcled_cdev->num_colors; i++) {
44
-
ret = sscanf(buf + offset, "%i%n",
44
+
ret = sscanf(buf + offset, "%u%n",
45
45
&intensity_value[i], &nrchars);
46
46
if (ret != 1) {
47
47
ret = -EINVAL;
+4
-1
drivers/leds/led-class.c
+4
-1
drivers/leds/led-class.c
···
273
273
if (!led_node)
274
274
return ERR_PTR(-ENOENT);
275
275
276
-
led_dev = class_find_device_by_of_node(&leds_class, led_node);
276
+
led_dev = class_find_device_by_fwnode(&leds_class, of_fwnode_handle(led_node));
277
277
of_node_put(led_node);
278
278
279
279
return led_module_get(led_dev);
···
421
421
*/
422
422
void led_remove_lookup(struct led_lookup_data *led_lookup)
423
423
{
424
+
if (!led_lookup)
425
+
return;
426
+
424
427
mutex_lock(&leds_lookup_lock);
425
428
list_del(&led_lookup->list);
426
429
mutex_unlock(&leds_lookup_lock);
+11
-9
drivers/leds/led-core.c
+11
-9
drivers/leds/led-core.c
···
85
85
if (!brightness) {
86
86
/* Time to switch the LED on. */
87
87
if (test_and_clear_bit(LED_BLINK_BRIGHTNESS_CHANGE,
88
-
&led_cdev->work_flags))
88
+
&led_cdev->work_flags))
89
89
brightness = led_cdev->new_blink_brightness;
90
90
else
91
91
brightness = led_cdev->blink_brightness;
···
217
217
mod_timer(&led_cdev->blink_timer, jiffies + 1);
218
218
}
219
219
220
-
221
220
static void led_blink_setup(struct led_classdev *led_cdev,
222
-
unsigned long *delay_on,
223
-
unsigned long *delay_off)
221
+
unsigned long *delay_on,
222
+
unsigned long *delay_off)
224
223
{
225
224
if (!test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) &&
226
225
led_cdev->blink_set &&
···
261
262
int invert)
262
263
{
263
264
if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) &&
264
-
timer_pending(&led_cdev->blink_timer))
265
+
timer_pending(&led_cdev->blink_timer))
265
266
return;
266
267
267
268
set_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags);
···
346
347
/* Ensure delayed_set_value is seen before work_flags modification */
347
348
smp_mb__before_atomic();
348
349
349
-
if (value)
350
+
if (value) {
350
351
set_bit(LED_SET_BRIGHTNESS, &led_cdev->work_flags);
351
-
else {
352
+
} else {
352
353
clear_bit(LED_SET_BRIGHTNESS, &led_cdev->work_flags);
353
354
clear_bit(LED_SET_BLINK, &led_cdev->work_flags);
354
355
set_bit(LED_SET_BRIGHTNESS_OFF, &led_cdev->work_flags);
···
498
499
props->color_present = true;
499
500
}
500
501
501
-
502
502
if (!fwnode_property_present(fwnode, "function"))
503
503
return;
504
504
···
579
581
} else if (is_of_node(fwnode)) {
580
582
n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s",
581
583
to_of_node(fwnode)->name);
582
-
} else
584
+
} else if (is_software_node(fwnode)) {
585
+
n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s",
586
+
fwnode_get_name(fwnode));
587
+
} else {
583
588
return -EINVAL;
589
+
}
584
590
585
591
if (n >= LED_MAX_NAME_SIZE)
586
592
return -E2BIG;
+9
-11
drivers/leds/leds-lm3642.c
+9
-11
drivers/leds/leds-lm3642.c
···
3
3
* Simple driver for Texas Instruments LM3642 LED Flash driver chip
4
4
* Copyright (C) 2012 Texas Instruments
5
5
*/
6
-
#include <linux/module.h>
6
+
#include <linux/cleanup.h>
7
7
#include <linux/delay.h>
8
+
#include <linux/fs.h>
8
9
#include <linux/i2c.h>
9
10
#include <linux/leds.h>
10
-
#include <linux/slab.h>
11
-
#include <linux/platform_device.h>
12
-
#include <linux/fs.h>
13
-
#include <linux/regmap.h>
11
+
#include <linux/module.h>
14
12
#include <linux/platform_data/leds-lm3642.h>
13
+
#include <linux/platform_device.h>
14
+
#include <linux/regmap.h>
15
+
#include <linux/slab.h>
15
16
16
17
#define REG_FILT_TIME (0x0)
17
18
#define REG_IVFM_MODE (0x1)
···
203
202
container_of(cdev, struct lm3642_chip_data, cdev_torch);
204
203
int ret;
205
204
206
-
mutex_lock(&chip->lock);
205
+
guard(mutex)(&chip->lock);
207
206
chip->br_torch = brightness;
208
207
ret = lm3642_control(chip, chip->br_torch, MODES_TORCH);
209
-
mutex_unlock(&chip->lock);
210
208
return ret;
211
209
}
212
210
···
249
249
container_of(cdev, struct lm3642_chip_data, cdev_flash);
250
250
int ret;
251
251
252
-
mutex_lock(&chip->lock);
252
+
guard(mutex)(&chip->lock);
253
253
chip->br_flash = brightness;
254
254
ret = lm3642_control(chip, chip->br_flash, MODES_FLASH);
255
-
mutex_unlock(&chip->lock);
256
255
return ret;
257
256
}
258
257
···
263
264
container_of(cdev, struct lm3642_chip_data, cdev_indicator);
264
265
int ret;
265
266
266
-
mutex_lock(&chip->lock);
267
+
guard(mutex)(&chip->lock);
267
268
chip->br_indicator = brightness;
268
269
ret = lm3642_control(chip, chip->br_indicator, MODES_INDIC);
269
-
mutex_unlock(&chip->lock);
270
270
return ret;
271
271
}
272
272
+2
-2
drivers/leds/leds-lp5569.c
+2
-2
drivers/leds/leds-lp5569.c
···
410
410
/* Test LED Open */
411
411
pos = lp5569_led_open_test(led, buf);
412
412
if (pos < 0)
413
-
return sprintf(buf, "FAIL\n");
413
+
return sysfs_emit(buf, "FAIL\n");
414
414
415
415
/* Test LED Shorted */
416
416
pos += lp5569_led_short_test(led, buf);
417
417
if (pos < 0)
418
-
return sprintf(buf, "FAIL\n");
418
+
return sysfs_emit(buf, "FAIL\n");
419
419
420
420
for (i = 0; i < chip->pdata->num_channels; i++) {
421
421
/* Restore current */
+53
-66
drivers/leds/leds-lp8860.c
+53
-66
drivers/leds/leds-lp8860.c
···
89
89
* @client: Pointer to the I2C client
90
90
* @led_dev: led class device pointer
91
91
* @regmap: Devices register map
92
-
* @eeprom_regmap: EEPROM register map
93
92
*/
94
93
struct lp8860_led {
95
94
struct mutex lock;
96
95
struct i2c_client *client;
97
96
struct led_classdev led_dev;
98
97
struct regmap *regmap;
99
-
struct regmap *eeprom_regmap;
100
98
};
101
99
100
+
static bool program_eeprom;
101
+
module_param(program_eeprom, bool, 0644);
102
+
MODULE_PARM_DESC(program_eeprom, "Program the configuration EEPROM on device startup");
103
+
104
+
/*
105
+
* EEPROM bits are intended to be set/programmed before normal operation only
106
+
* once during silicon production, but can be reprogrammed for evaluation purposes
107
+
* up to 1000 cycles. To program this EEPROM using this driver, update the below
108
+
* table and set the module param "program_eeprom" to 1
109
+
*/
102
110
static const struct reg_sequence lp8860_eeprom_disp_regs[] = {
103
111
{ LP8860_EEPROM_REG_0, 0xed },
104
112
{ LP8860_EEPROM_REG_1, 0xdf },
···
134
126
{ LP8860_EEPROM_REG_23, 0x88 },
135
127
{ LP8860_EEPROM_REG_24, 0x3E },
136
128
};
137
-
138
-
static int lp8860_unlock_eeprom(struct lp8860_led *led)
139
-
{
140
-
int ret;
141
-
142
-
guard(mutex)(&led->lock);
143
-
144
-
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_1);
145
-
if (ret) {
146
-
dev_err(&led->client->dev, "EEPROM Unlock failed\n");
147
-
return ret;
148
-
}
149
-
150
-
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_2);
151
-
if (ret) {
152
-
dev_err(&led->client->dev, "EEPROM Unlock failed\n");
153
-
return ret;
154
-
}
155
-
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_3);
156
-
if (ret) {
157
-
dev_err(&led->client->dev, "EEPROM Unlock failed\n");
158
-
return ret;
159
-
}
160
-
161
-
return ret;
162
-
}
163
129
164
130
static int lp8860_fault_check(struct lp8860_led *led)
165
131
{
···
193
211
return 0;
194
212
}
195
213
196
-
static int lp8860_init(struct lp8860_led *led)
214
+
static int lp8860_program_eeprom(struct lp8860_led *led)
197
215
{
198
-
unsigned int read_buf;
199
216
int ret, reg_count;
200
217
218
+
guard(mutex)(&led->lock);
219
+
201
220
ret = lp8860_fault_check(led);
202
-
if (ret)
203
-
goto out;
204
-
205
-
ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf);
206
-
if (ret)
207
-
goto out;
208
-
209
-
ret = lp8860_unlock_eeprom(led);
210
221
if (ret) {
211
-
dev_err(&led->client->dev, "Failed unlocking EEPROM\n");
212
-
goto out;
222
+
dev_err(&led->client->dev, "Cannot read/clear faults\n");
223
+
return ret;
224
+
}
225
+
226
+
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_1);
227
+
if (ret) {
228
+
dev_err(&led->client->dev, "EEPROM Unlock failed\n");
229
+
return ret;
230
+
}
231
+
232
+
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_2);
233
+
if (ret) {
234
+
dev_err(&led->client->dev, "EEPROM Unlock failed\n");
235
+
return ret;
236
+
}
237
+
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_3);
238
+
if (ret) {
239
+
dev_err(&led->client->dev, "EEPROM Unlock failed\n");
240
+
return ret;
213
241
}
214
242
215
243
reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs);
216
-
ret = regmap_multi_reg_write(led->eeprom_regmap, lp8860_eeprom_disp_regs, reg_count);
244
+
ret = regmap_multi_reg_write(led->regmap, lp8860_eeprom_disp_regs, reg_count);
217
245
if (ret) {
218
246
dev_err(&led->client->dev, "Failed writing EEPROM\n");
219
-
goto out;
247
+
return ret;
220
248
}
221
249
222
250
ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_LOCK_EEPROM);
223
251
if (ret)
224
-
goto out;
252
+
return ret;
225
253
226
254
ret = regmap_write(led->regmap,
227
255
LP8860_EEPROM_CNTRL,
228
256
LP8860_PROGRAM_EEPROM);
229
257
if (ret) {
230
258
dev_err(&led->client->dev, "Failed programming EEPROM\n");
231
-
goto out;
259
+
return ret;
232
260
}
233
261
234
-
return ret;
235
-
236
-
out:
237
-
return ret;
262
+
return 0;
238
263
}
264
+
265
+
static const struct regmap_range lp8860_reg_ranges[] = {
266
+
regmap_reg_range(LP8860_DISP_CL1_BRT_MSB, LP8860_EEPROM_UNLOCK),
267
+
regmap_reg_range(LP8860_EEPROM_REG_0, LP8860_EEPROM_REG_24),
268
+
};
269
+
270
+
static const struct regmap_access_table lp8860_reg_table = {
271
+
.yes_ranges = lp8860_reg_ranges,
272
+
.n_yes_ranges = ARRAY_SIZE(lp8860_reg_ranges),
273
+
};
239
274
240
275
static const struct regmap_config lp8860_regmap_config = {
241
276
.reg_bits = 8,
242
277
.val_bits = 8,
243
-
244
-
.max_register = LP8860_EEPROM_UNLOCK,
245
-
};
246
-
247
-
static const struct regmap_config lp8860_eeprom_regmap_config = {
248
-
.reg_bits = 8,
249
-
.val_bits = 8,
250
-
278
+
.rd_table = &lp8860_reg_table,
279
+
.wr_table = &lp8860_reg_table,
251
280
.max_register = LP8860_EEPROM_REG_24,
252
281
};
253
282
···
312
319
return ret;
313
320
}
314
321
315
-
led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config);
316
-
if (IS_ERR(led->eeprom_regmap)) {
317
-
ret = PTR_ERR(led->eeprom_regmap);
318
-
dev_err(&client->dev, "Failed to allocate register map: %d\n",
319
-
ret);
320
-
return ret;
322
+
if (program_eeprom) {
323
+
ret = lp8860_program_eeprom(led);
324
+
if (ret)
325
+
return ret;
321
326
}
322
-
323
-
ret = lp8860_init(led);
324
-
if (ret)
325
-
return ret;
326
327
327
328
init_data.fwnode = of_fwnode_handle(child_node);
328
329
init_data.devicename = LP8860_NAME;
+6
-1
drivers/leds/rgb/leds-qcom-lpg.c
+6
-1
drivers/leds/rgb/leds-qcom-lpg.c
···
1273
1273
return ret;
1274
1274
1275
1275
if (chan->subtype == LPG_SUBTYPE_HI_RES_PWM) {
1276
-
refclk = lpg_clk_rates_hi_res[FIELD_GET(PWM_CLK_SELECT_HI_RES_MASK, val)];
1276
+
unsigned int clk_idx = FIELD_GET(PWM_CLK_SELECT_HI_RES_MASK, val);
1277
+
1278
+
if (clk_idx >= ARRAY_SIZE(lpg_clk_rates_hi_res))
1279
+
return -EINVAL;
1280
+
1281
+
refclk = lpg_clk_rates_hi_res[clk_idx];
1277
1282
resolution = lpg_pwm_resolution_hi_res[FIELD_GET(PWM_SIZE_HI_RES_MASK, val)];
1278
1283
} else {
1279
1284
refclk = lpg_clk_rates[FIELD_GET(PWM_CLK_SELECT_MASK, val)];