1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Driver for LEDs connected to the Intel Cherry Trail Whiskey Cove PMIC
4 *
5 * Copyright 2019 Yauhen Kharuzhy <jekhor@gmail.com>
6 * Copyright 2023 Hans de Goede <hansg@kernel.org>
7 *
8 * Register info comes from the Lenovo Yoga Book Android opensource code
9 * available from Lenovo. File lenovo_yb1_x90f_l_osc_201803.7z path in the 7z:
10 * YB1_source_code/kernel/cht/drivers/misc/charger_gp_led.c
11 */
12
13#include <linux/kernel.h>
14#include <linux/leds.h>
15#include <linux/mfd/intel_soc_pmic.h>
16#include <linux/module.h>
17#include <linux/mod_devicetable.h>
18#include <linux/platform_device.h>
19#include <linux/regmap.h>
20#include <linux/suspend.h>
21
22#define CHT_WC_LED1_CTRL 0x5e1f
23#define CHT_WC_LED1_FSM 0x5e20
24#define CHT_WC_LED1_PWM 0x5e21
25
26#define CHT_WC_LED2_CTRL 0x4fdf
27#define CHT_WC_LED2_FSM 0x4fe0
28#define CHT_WC_LED2_PWM 0x4fe1
29
30#define CHT_WC_LED1_SWCTL BIT(0) /* HW or SW control of charging led */
31#define CHT_WC_LED1_ON BIT(1)
32
33#define CHT_WC_LED2_ON BIT(0)
34#define CHT_WC_LED_I_MA2_5 (2 << 2) /* LED current limit */
35#define CHT_WC_LED_I_MASK GENMASK(3, 2) /* LED current limit mask */
36
37#define CHT_WC_LED_F_1_4_HZ (0 << 4)
38#define CHT_WC_LED_F_1_2_HZ (1 << 4)
39#define CHT_WC_LED_F_1_HZ (2 << 4)
40#define CHT_WC_LED_F_2_HZ (3 << 4)
41#define CHT_WC_LED_F_MASK GENMASK(5, 4)
42
43#define CHT_WC_LED_EFF_OFF (0 << 1)
44#define CHT_WC_LED_EFF_ON (1 << 1)
45#define CHT_WC_LED_EFF_BLINKING (2 << 1)
46#define CHT_WC_LED_EFF_BREATHING (3 << 1)
47#define CHT_WC_LED_EFF_MASK GENMASK(2, 1)
48
49#define CHT_WC_LED_COUNT 2
50
51struct cht_wc_led_regs {
52 /* Register addresses */
53 u16 ctrl;
54 u16 fsm;
55 u16 pwm;
56 /* Mask + values for turning the LED on/off */
57 u8 on_off_mask;
58 u8 on_val;
59 u8 off_val;
60};
61
62struct cht_wc_led_saved_regs {
63 unsigned int ctrl;
64 unsigned int fsm;
65 unsigned int pwm;
66};
67
68struct cht_wc_led {
69 struct led_classdev cdev;
70 const struct cht_wc_led_regs *regs;
71 struct regmap *regmap;
72 struct mutex mutex;
73 struct cht_wc_led_saved_regs saved_regs;
74};
75
76struct cht_wc_leds {
77 struct cht_wc_led leds[CHT_WC_LED_COUNT];
78 /* Saved LED1 initial register values */
79 struct cht_wc_led_saved_regs led1_initial_regs;
80};
81
82static const struct cht_wc_led_regs cht_wc_led_regs[CHT_WC_LED_COUNT] = {
83 {
84 .ctrl = CHT_WC_LED1_CTRL,
85 .fsm = CHT_WC_LED1_FSM,
86 .pwm = CHT_WC_LED1_PWM,
87 .on_off_mask = CHT_WC_LED1_SWCTL | CHT_WC_LED1_ON,
88 .on_val = CHT_WC_LED1_SWCTL | CHT_WC_LED1_ON,
89 .off_val = CHT_WC_LED1_SWCTL,
90 },
91 {
92 .ctrl = CHT_WC_LED2_CTRL,
93 .fsm = CHT_WC_LED2_FSM,
94 .pwm = CHT_WC_LED2_PWM,
95 .on_off_mask = CHT_WC_LED2_ON,
96 .on_val = CHT_WC_LED2_ON,
97 .off_val = 0,
98 },
99};
100
101static const char * const cht_wc_leds_names[CHT_WC_LED_COUNT] = {
102 "platform::" LED_FUNCTION_CHARGING,
103 "platform::" LED_FUNCTION_INDICATOR,
104};
105
106static int cht_wc_leds_brightness_set(struct led_classdev *cdev,
107 enum led_brightness value)
108{
109 struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
110 int ret;
111
112 mutex_lock(&led->mutex);
113
114 if (!value) {
115 ret = regmap_update_bits(map: led->regmap, reg: led->regs->ctrl,
116 mask: led->regs->on_off_mask, val: led->regs->off_val);
117 if (ret < 0) {
118 dev_err(cdev->dev, "Failed to turn off: %d\n", ret);
119 goto out;
120 }
121
122 /* Disable HW blinking */
123 ret = regmap_update_bits(map: led->regmap, reg: led->regs->fsm,
124 CHT_WC_LED_EFF_MASK, CHT_WC_LED_EFF_ON);
125 if (ret < 0)
126 dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);
127 } else {
128 ret = regmap_write(map: led->regmap, reg: led->regs->pwm, val: value);
129 if (ret < 0) {
130 dev_err(cdev->dev, "Failed to set brightness: %d\n", ret);
131 goto out;
132 }
133
134 ret = regmap_update_bits(map: led->regmap, reg: led->regs->ctrl,
135 mask: led->regs->on_off_mask, val: led->regs->on_val);
136 if (ret < 0)
137 dev_err(cdev->dev, "Failed to turn on: %d\n", ret);
138 }
139out:
140 mutex_unlock(lock: &led->mutex);
141 return ret;
142}
143
144static enum led_brightness cht_wc_leds_brightness_get(struct led_classdev *cdev)
145{
146 struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
147 unsigned int val;
148 int ret;
149
150 mutex_lock(&led->mutex);
151
152 ret = regmap_read(map: led->regmap, reg: led->regs->ctrl, val: &val);
153 if (ret < 0) {
154 dev_err(cdev->dev, "Failed to read LED CTRL reg: %d\n", ret);
155 ret = 0;
156 goto done;
157 }
158
159 val &= led->regs->on_off_mask;
160 if (val != led->regs->on_val) {
161 ret = 0;
162 goto done;
163 }
164
165 ret = regmap_read(map: led->regmap, reg: led->regs->pwm, val: &val);
166 if (ret < 0) {
167 dev_err(cdev->dev, "Failed to read LED PWM reg: %d\n", ret);
168 ret = 0;
169 goto done;
170 }
171
172 ret = val;
173done:
174 mutex_unlock(lock: &led->mutex);
175
176 return ret;
177}
178
179/* Return blinking period for given CTRL reg value */
180static unsigned long cht_wc_leds_get_period(int ctrl)
181{
182 ctrl &= CHT_WC_LED_F_MASK;
183
184 switch (ctrl) {
185 case CHT_WC_LED_F_1_4_HZ:
186 return 1000 * 4;
187 case CHT_WC_LED_F_1_2_HZ:
188 return 1000 * 2;
189 case CHT_WC_LED_F_1_HZ:
190 return 1000;
191 case CHT_WC_LED_F_2_HZ:
192 return 1000 / 2;
193 }
194
195 return 0;
196}
197
198/*
199 * Find suitable hardware blink mode for given period.
200 * period < 750 ms - select 2 HZ
201 * 750 ms <= period < 1500 ms - select 1 HZ
202 * 1500 ms <= period < 3000 ms - select 1/2 HZ
203 * 3000 ms <= period < 5000 ms - select 1/4 HZ
204 * 5000 ms <= period - return -1
205 */
206static int cht_wc_leds_find_freq(unsigned long period)
207{
208 if (period < 750)
209 return CHT_WC_LED_F_2_HZ;
210 else if (period < 1500)
211 return CHT_WC_LED_F_1_HZ;
212 else if (period < 3000)
213 return CHT_WC_LED_F_1_2_HZ;
214 else if (period < 5000)
215 return CHT_WC_LED_F_1_4_HZ;
216 else
217 return -1;
218}
219
220static int cht_wc_leds_set_effect(struct led_classdev *cdev,
221 unsigned long *delay_on,
222 unsigned long *delay_off,
223 u8 effect)
224{
225 struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
226 int ctrl, ret;
227
228 mutex_lock(&led->mutex);
229
230 /* Blink with 1 Hz as default if nothing specified */
231 if (!*delay_on && !*delay_off)
232 *delay_on = *delay_off = 500;
233
234 ctrl = cht_wc_leds_find_freq(period: *delay_on + *delay_off);
235 if (ctrl < 0) {
236 /* Disable HW blinking */
237 ret = regmap_update_bits(map: led->regmap, reg: led->regs->fsm,
238 CHT_WC_LED_EFF_MASK, CHT_WC_LED_EFF_ON);
239 if (ret < 0)
240 dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);
241
242 /* Fallback to software timer */
243 *delay_on = *delay_off = 0;
244 ret = -EINVAL;
245 goto done;
246 }
247
248 ret = regmap_update_bits(map: led->regmap, reg: led->regs->fsm,
249 CHT_WC_LED_EFF_MASK, val: effect);
250 if (ret < 0)
251 dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);
252
253 /* Set the frequency and make sure the LED is on */
254 ret = regmap_update_bits(map: led->regmap, reg: led->regs->ctrl,
255 CHT_WC_LED_F_MASK | led->regs->on_off_mask,
256 val: ctrl | led->regs->on_val);
257 if (ret < 0)
258 dev_err(cdev->dev, "Failed to update LED CTRL reg: %d\n", ret);
259
260 *delay_off = *delay_on = cht_wc_leds_get_period(ctrl) / 2;
261
262done:
263 mutex_unlock(lock: &led->mutex);
264
265 return ret;
266}
267
268static int cht_wc_leds_blink_set(struct led_classdev *cdev,
269 unsigned long *delay_on,
270 unsigned long *delay_off)
271{
272 u8 effect = CHT_WC_LED_EFF_BLINKING;
273
274 /*
275 * The desired default behavior of LED1 / the charge LED is breathing
276 * while charging and on/solid when full. Since triggers cannot select
277 * breathing, blink_set() gets called when charging. Use slow breathing
278 * when the default "charging-blink-full-solid" trigger is used to
279 * achieve the desired default behavior.
280 */
281 if (cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
282 *delay_on = *delay_off = 1000;
283 effect = CHT_WC_LED_EFF_BREATHING;
284 }
285
286 return cht_wc_leds_set_effect(cdev, delay_on, delay_off, effect);
287}
288
289static int cht_wc_leds_pattern_set(struct led_classdev *cdev,
290 struct led_pattern *pattern,
291 u32 len, int repeat)
292{
293 unsigned long delay_off, delay_on;
294
295 if (repeat > 0 || len != 2 ||
296 pattern[0].brightness != 0 || pattern[1].brightness != 1 ||
297 pattern[0].delta_t != pattern[1].delta_t ||
298 (pattern[0].delta_t != 250 && pattern[0].delta_t != 500 &&
299 pattern[0].delta_t != 1000 && pattern[0].delta_t != 2000))
300 return -EINVAL;
301
302 delay_off = pattern[0].delta_t;
303 delay_on = pattern[1].delta_t;
304
305 return cht_wc_leds_set_effect(cdev, delay_on: &delay_on, delay_off: &delay_off, CHT_WC_LED_EFF_BREATHING);
306}
307
308static int cht_wc_leds_pattern_clear(struct led_classdev *cdev)
309{
310 return cht_wc_leds_brightness_set(cdev, value: 0);
311}
312
313static int cht_wc_led_save_regs(struct cht_wc_led *led,
314 struct cht_wc_led_saved_regs *saved_regs)
315{
316 int ret;
317
318 ret = regmap_read(map: led->regmap, reg: led->regs->ctrl, val: &saved_regs->ctrl);
319 if (ret < 0)
320 return ret;
321
322 ret = regmap_read(map: led->regmap, reg: led->regs->fsm, val: &saved_regs->fsm);
323 if (ret < 0)
324 return ret;
325
326 return regmap_read(map: led->regmap, reg: led->regs->pwm, val: &saved_regs->pwm);
327}
328
329static void cht_wc_led_restore_regs(struct cht_wc_led *led,
330 const struct cht_wc_led_saved_regs *saved_regs)
331{
332 regmap_write(map: led->regmap, reg: led->regs->ctrl, val: saved_regs->ctrl);
333 regmap_write(map: led->regmap, reg: led->regs->fsm, val: saved_regs->fsm);
334 regmap_write(map: led->regmap, reg: led->regs->pwm, val: saved_regs->pwm);
335}
336
337static int cht_wc_leds_probe(struct platform_device *pdev)
338{
339 struct intel_soc_pmic *pmic = dev_get_drvdata(dev: pdev->dev.parent);
340 struct cht_wc_leds *leds;
341 int ret;
342 int i;
343
344 /*
345 * On the Lenovo Yoga Tab 3 the LED1 driver output is actually
346 * connected to a haptic feedback motor rather then a LED.
347 * So do not register a LED classdev there (LED2 is unused).
348 */
349 if (pmic->cht_wc_model == INTEL_CHT_WC_LENOVO_YT3_X90)
350 return -ENODEV;
351
352 leds = devm_kzalloc(dev: &pdev->dev, size: sizeof(*leds), GFP_KERNEL);
353 if (!leds)
354 return -ENOMEM;
355
356 /*
357 * LED1 might be in hw-controlled mode when this driver gets loaded; and
358 * since the PMIC is always powered by the battery any changes made are
359 * permanent. Save LED1 regs to restore them on remove() or shutdown().
360 */
361 leds->leds[0].regs = &cht_wc_led_regs[0];
362 leds->leds[0].regmap = pmic->regmap;
363 ret = cht_wc_led_save_regs(led: &leds->leds[0], saved_regs: &leds->led1_initial_regs);
364 if (ret < 0)
365 return ret;
366
367 /* Set LED1 default trigger based on machine model */
368 switch (pmic->cht_wc_model) {
369 case INTEL_CHT_WC_GPD_WIN_POCKET:
370 leds->leds[0].cdev.default_trigger = "max170xx_battery-charging-blink-full-solid";
371 break;
372 case INTEL_CHT_WC_XIAOMI_MIPAD2:
373 leds->leds[0].cdev.default_trigger = "bq27520-0-charging-blink-full-solid";
374 break;
375 case INTEL_CHT_WC_LENOVO_YOGABOOK1:
376 leds->leds[0].cdev.default_trigger = "bq27542-0-charging-blink-full-solid";
377 break;
378 default:
379 dev_warn(&pdev->dev, "Unknown model, no default charging trigger\n");
380 break;
381 }
382
383 for (i = 0; i < CHT_WC_LED_COUNT; i++) {
384 struct cht_wc_led *led = &leds->leds[i];
385
386 led->regs = &cht_wc_led_regs[i];
387 led->regmap = pmic->regmap;
388 mutex_init(&led->mutex);
389 led->cdev.name = cht_wc_leds_names[i];
390 led->cdev.brightness_set_blocking = cht_wc_leds_brightness_set;
391 led->cdev.brightness_get = cht_wc_leds_brightness_get;
392 led->cdev.blink_set = cht_wc_leds_blink_set;
393 led->cdev.pattern_set = cht_wc_leds_pattern_set;
394 led->cdev.pattern_clear = cht_wc_leds_pattern_clear;
395 led->cdev.max_brightness = 255;
396
397 ret = devm_led_classdev_register(parent: &pdev->dev, led_cdev: &led->cdev);
398 if (ret < 0)
399 return ret;
400 }
401
402 platform_set_drvdata(pdev, data: leds);
403 return 0;
404}
405
406static void cht_wc_leds_remove(struct platform_device *pdev)
407{
408 struct cht_wc_leds *leds = platform_get_drvdata(pdev);
409
410 /* Restore LED1 regs if hw-control was active else leave LED1 off */
411 if (!(leds->led1_initial_regs.ctrl & CHT_WC_LED1_SWCTL))
412 cht_wc_led_restore_regs(led: &leds->leds[0], saved_regs: &leds->led1_initial_regs);
413}
414
415static void cht_wc_leds_disable(struct platform_device *pdev)
416{
417 struct cht_wc_leds *leds = platform_get_drvdata(pdev);
418 int i;
419
420 for (i = 0; i < CHT_WC_LED_COUNT; i++)
421 cht_wc_leds_brightness_set(cdev: &leds->leds[i].cdev, value: 0);
422
423 /* Restore LED1 regs if hw-control was active else leave LED1 off */
424 if (!(leds->led1_initial_regs.ctrl & CHT_WC_LED1_SWCTL))
425 cht_wc_led_restore_regs(led: &leds->leds[0], saved_regs: &leds->led1_initial_regs);
426}
427
428/* On suspend save current settings and turn LEDs off */
429static int cht_wc_leds_suspend(struct device *dev)
430{
431 struct cht_wc_leds *leds = dev_get_drvdata(dev);
432 int i, ret;
433
434 for (i = 0; i < CHT_WC_LED_COUNT; i++) {
435 ret = cht_wc_led_save_regs(led: &leds->leds[i], saved_regs: &leds->leds[i].saved_regs);
436 if (ret < 0)
437 return ret;
438 }
439
440 cht_wc_leds_disable(to_platform_device(dev));
441 return 0;
442}
443
444/* On resume restore the saved settings */
445static int cht_wc_leds_resume(struct device *dev)
446{
447 struct cht_wc_leds *leds = dev_get_drvdata(dev);
448 int i;
449
450 for (i = 0; i < CHT_WC_LED_COUNT; i++)
451 cht_wc_led_restore_regs(led: &leds->leds[i], saved_regs: &leds->leds[i].saved_regs);
452
453 return 0;
454}
455
456static DEFINE_SIMPLE_DEV_PM_OPS(cht_wc_leds_pm, cht_wc_leds_suspend, cht_wc_leds_resume);
457
458static struct platform_driver cht_wc_leds_driver = {
459 .probe = cht_wc_leds_probe,
460 .remove = cht_wc_leds_remove,
461 .shutdown = cht_wc_leds_disable,
462 .driver = {
463 .name = "cht_wcove_leds",
464 .pm = pm_sleep_ptr(&cht_wc_leds_pm),
465 },
466};
467module_platform_driver(cht_wc_leds_driver);
468
469MODULE_ALIAS("platform:cht_wcove_leds");
470MODULE_DESCRIPTION("Intel Cherry Trail Whiskey Cove PMIC LEDs driver");
471MODULE_AUTHOR("Yauhen Kharuzhy <jekhor@gmail.com>");
472MODULE_LICENSE("GPL");
473

source code of linux/drivers/leds/leds-cht-wcove.c