1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Driver for TWL4030/6030 Pulse Width Modulator used as LED driver |
4 | * |
5 | * Copyright (C) 2012 Texas Instruments |
6 | * Author: Peter Ujfalusi <peter.ujfalusi@ti.com> |
7 | * |
8 | * This driver is a complete rewrite of the former pwm-twl6030.c authorded by: |
9 | * Hemanth V <hemanthv@ti.com> |
10 | * |
11 | * Reference manual for the twl6030 is available at: |
12 | * https://www.ti.com/lit/ds/symlink/twl6030.pdf |
13 | * |
14 | * Limitations: |
15 | * - The twl6030 hardware only supports two period lengths (128 clock ticks and |
16 | * 64 clock ticks), the driver only uses 128 ticks |
17 | * - The hardware doesn't support ON = 0, so the active part of a period doesn't |
18 | * start at its beginning. |
19 | * - The hardware could support inverted polarity (with a similar limitation as |
20 | * for normal: the last clock tick is always inactive). |
21 | * - The hardware emits a constant low output when disabled. |
22 | * - A request for .duty_cycle = 0 results in an output wave with one active |
23 | * clock tick per period. This should better use the disabled state. |
24 | * - The driver only implements setting the relative duty cycle. |
25 | * - The driver doesn't implement .get_state(). |
26 | */ |
27 | |
28 | #include <linux/module.h> |
29 | #include <linux/of.h> |
30 | #include <linux/platform_device.h> |
31 | #include <linux/pwm.h> |
32 | #include <linux/mfd/twl.h> |
33 | #include <linux/slab.h> |
34 | |
35 | /* |
36 | * This driver handles the PWM driven LED terminals of TWL4030 and TWL6030. |
37 | * To generate the signal on TWL4030: |
38 | * - LEDA uses PWMA |
39 | * - LEDB uses PWMB |
40 | * TWL6030 has one LED pin with dedicated LEDPWM |
41 | */ |
42 | |
43 | #define TWL4030_LED_MAX 0x7f |
44 | #define TWL6030_LED_MAX 0xff |
45 | |
46 | /* Registers, bits and macro for TWL4030 */ |
47 | #define TWL4030_LEDEN_REG 0x00 |
48 | #define TWL4030_PWMA_REG 0x01 |
49 | |
50 | #define TWL4030_LEDXON (1 << 0) |
51 | #define TWL4030_LEDXPWM (1 << 4) |
52 | #define TWL4030_LED_PINS (TWL4030_LEDXON | TWL4030_LEDXPWM) |
53 | #define TWL4030_LED_TOGGLE(led, x) ((x) << (led)) |
54 | |
55 | /* Register, bits and macro for TWL6030 */ |
56 | #define TWL6030_LED_PWM_CTRL1 0xf4 |
57 | #define TWL6030_LED_PWM_CTRL2 0xf5 |
58 | |
59 | #define TWL6040_LED_MODE_HW 0x00 |
60 | #define TWL6040_LED_MODE_ON 0x01 |
61 | #define TWL6040_LED_MODE_OFF 0x02 |
62 | #define TWL6040_LED_MODE_MASK 0x03 |
63 | |
64 | struct twl_pwmled_chip { |
65 | struct mutex mutex; |
66 | }; |
67 | |
68 | static inline struct twl_pwmled_chip *to_twl(struct pwm_chip *chip) |
69 | { |
70 | return pwmchip_get_drvdata(chip); |
71 | } |
72 | |
73 | static int twl4030_pwmled_config(struct pwm_chip *chip, struct pwm_device *pwm, |
74 | int duty_ns, int period_ns) |
75 | { |
76 | int duty_cycle = DIV_ROUND_UP(duty_ns * TWL4030_LED_MAX, period_ns) + 1; |
77 | u8 pwm_config[2] = { 1, 0 }; |
78 | int base, ret; |
79 | |
80 | /* |
81 | * To configure the duty period: |
82 | * On-cycle is set to 1 (the minimum allowed value) |
83 | * The off time of 0 is not configurable, so the mapping is: |
84 | * 0 -> off cycle = 2, |
85 | * 1 -> off cycle = 2, |
86 | * 2 -> off cycle = 3, |
87 | * 126 - > off cycle 127, |
88 | * 127 - > off cycle 1 |
89 | * When on cycle == off cycle the PWM will be always on |
90 | */ |
91 | if (duty_cycle == 1) |
92 | duty_cycle = 2; |
93 | else if (duty_cycle > TWL4030_LED_MAX) |
94 | duty_cycle = 1; |
95 | |
96 | base = pwm->hwpwm * 2 + TWL4030_PWMA_REG; |
97 | |
98 | pwm_config[1] = duty_cycle; |
99 | |
100 | ret = twl_i2c_write(TWL4030_MODULE_LED, value: pwm_config, reg: base, num_bytes: 2); |
101 | if (ret < 0) |
102 | dev_err(pwmchip_parent(chip), "%s: Failed to configure PWM\n" , pwm->label); |
103 | |
104 | return ret; |
105 | } |
106 | |
107 | static int twl4030_pwmled_enable(struct pwm_chip *chip, struct pwm_device *pwm) |
108 | { |
109 | struct twl_pwmled_chip *twl = to_twl(chip); |
110 | int ret; |
111 | u8 val; |
112 | |
113 | mutex_lock(&twl->mutex); |
114 | ret = twl_i2c_read_u8(TWL4030_MODULE_LED, val: &val, TWL4030_LEDEN_REG); |
115 | if (ret < 0) { |
116 | dev_err(pwmchip_parent(chip), "%s: Failed to read LEDEN\n" , pwm->label); |
117 | goto out; |
118 | } |
119 | |
120 | val |= TWL4030_LED_TOGGLE(pwm->hwpwm, TWL4030_LED_PINS); |
121 | |
122 | ret = twl_i2c_write_u8(TWL4030_MODULE_LED, val, TWL4030_LEDEN_REG); |
123 | if (ret < 0) |
124 | dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n" , pwm->label); |
125 | |
126 | out: |
127 | mutex_unlock(lock: &twl->mutex); |
128 | return ret; |
129 | } |
130 | |
131 | static void twl4030_pwmled_disable(struct pwm_chip *chip, |
132 | struct pwm_device *pwm) |
133 | { |
134 | struct twl_pwmled_chip *twl = to_twl(chip); |
135 | int ret; |
136 | u8 val; |
137 | |
138 | mutex_lock(&twl->mutex); |
139 | ret = twl_i2c_read_u8(TWL4030_MODULE_LED, val: &val, TWL4030_LEDEN_REG); |
140 | if (ret < 0) { |
141 | dev_err(pwmchip_parent(chip), "%s: Failed to read LEDEN\n" , pwm->label); |
142 | goto out; |
143 | } |
144 | |
145 | val &= ~TWL4030_LED_TOGGLE(pwm->hwpwm, TWL4030_LED_PINS); |
146 | |
147 | ret = twl_i2c_write_u8(TWL4030_MODULE_LED, val, TWL4030_LEDEN_REG); |
148 | if (ret < 0) |
149 | dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n" , pwm->label); |
150 | |
151 | out: |
152 | mutex_unlock(lock: &twl->mutex); |
153 | } |
154 | |
155 | static int twl4030_pwmled_apply(struct pwm_chip *chip, struct pwm_device *pwm, |
156 | const struct pwm_state *state) |
157 | { |
158 | int ret; |
159 | |
160 | if (state->polarity != PWM_POLARITY_NORMAL) |
161 | return -EINVAL; |
162 | |
163 | if (!state->enabled) { |
164 | if (pwm->state.enabled) |
165 | twl4030_pwmled_disable(chip, pwm); |
166 | |
167 | return 0; |
168 | } |
169 | |
170 | /* |
171 | * We cannot skip calling ->config even if state->period == |
172 | * pwm->state.period && state->duty_cycle == pwm->state.duty_cycle |
173 | * because we might have exited early in the last call to |
174 | * pwm_apply_might_sleep because of !state->enabled and so the two values in |
175 | * pwm->state might not be configured in hardware. |
176 | */ |
177 | ret = twl4030_pwmled_config(chip, pwm, |
178 | duty_ns: state->duty_cycle, period_ns: state->period); |
179 | if (ret) |
180 | return ret; |
181 | |
182 | if (!pwm->state.enabled) |
183 | ret = twl4030_pwmled_enable(chip, pwm); |
184 | |
185 | return ret; |
186 | } |
187 | |
188 | |
189 | static const struct pwm_ops twl4030_pwmled_ops = { |
190 | .apply = twl4030_pwmled_apply, |
191 | }; |
192 | |
193 | static int twl6030_pwmled_config(struct pwm_chip *chip, struct pwm_device *pwm, |
194 | int duty_ns, int period_ns) |
195 | { |
196 | int duty_cycle = (duty_ns * TWL6030_LED_MAX) / period_ns; |
197 | u8 on_time; |
198 | int ret; |
199 | |
200 | on_time = duty_cycle & 0xff; |
201 | |
202 | ret = twl_i2c_write_u8(mod_no: TWL6030_MODULE_ID1, val: on_time, |
203 | TWL6030_LED_PWM_CTRL1); |
204 | if (ret < 0) |
205 | dev_err(pwmchip_parent(chip), "%s: Failed to configure PWM\n" , pwm->label); |
206 | |
207 | return ret; |
208 | } |
209 | |
210 | static int twl6030_pwmled_enable(struct pwm_chip *chip, struct pwm_device *pwm) |
211 | { |
212 | struct twl_pwmled_chip *twl = to_twl(chip); |
213 | int ret; |
214 | u8 val; |
215 | |
216 | mutex_lock(&twl->mutex); |
217 | ret = twl_i2c_read_u8(mod_no: TWL6030_MODULE_ID1, val: &val, TWL6030_LED_PWM_CTRL2); |
218 | if (ret < 0) { |
219 | dev_err(pwmchip_parent(chip), "%s: Failed to read PWM_CTRL2\n" , |
220 | pwm->label); |
221 | goto out; |
222 | } |
223 | |
224 | val &= ~TWL6040_LED_MODE_MASK; |
225 | val |= TWL6040_LED_MODE_ON; |
226 | |
227 | ret = twl_i2c_write_u8(mod_no: TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2); |
228 | if (ret < 0) |
229 | dev_err(pwmchip_parent(chip), "%s: Failed to enable PWM\n" , pwm->label); |
230 | |
231 | out: |
232 | mutex_unlock(lock: &twl->mutex); |
233 | return ret; |
234 | } |
235 | |
236 | static void twl6030_pwmled_disable(struct pwm_chip *chip, |
237 | struct pwm_device *pwm) |
238 | { |
239 | struct twl_pwmled_chip *twl = to_twl(chip); |
240 | int ret; |
241 | u8 val; |
242 | |
243 | mutex_lock(&twl->mutex); |
244 | ret = twl_i2c_read_u8(mod_no: TWL6030_MODULE_ID1, val: &val, TWL6030_LED_PWM_CTRL2); |
245 | if (ret < 0) { |
246 | dev_err(pwmchip_parent(chip), "%s: Failed to read PWM_CTRL2\n" , |
247 | pwm->label); |
248 | goto out; |
249 | } |
250 | |
251 | val &= ~TWL6040_LED_MODE_MASK; |
252 | val |= TWL6040_LED_MODE_OFF; |
253 | |
254 | ret = twl_i2c_write_u8(mod_no: TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2); |
255 | if (ret < 0) |
256 | dev_err(pwmchip_parent(chip), "%s: Failed to disable PWM\n" , pwm->label); |
257 | |
258 | out: |
259 | mutex_unlock(lock: &twl->mutex); |
260 | } |
261 | |
262 | static int twl6030_pwmled_apply(struct pwm_chip *chip, struct pwm_device *pwm, |
263 | const struct pwm_state *state) |
264 | { |
265 | int err; |
266 | |
267 | if (state->polarity != pwm->state.polarity) |
268 | return -EINVAL; |
269 | |
270 | if (!state->enabled) { |
271 | if (pwm->state.enabled) |
272 | twl6030_pwmled_disable(chip, pwm); |
273 | |
274 | return 0; |
275 | } |
276 | |
277 | err = twl6030_pwmled_config(chip, pwm, |
278 | duty_ns: state->duty_cycle, period_ns: state->period); |
279 | if (err) |
280 | return err; |
281 | |
282 | if (!pwm->state.enabled) |
283 | err = twl6030_pwmled_enable(chip, pwm); |
284 | |
285 | return err; |
286 | } |
287 | |
288 | static int twl6030_pwmled_request(struct pwm_chip *chip, struct pwm_device *pwm) |
289 | { |
290 | struct twl_pwmled_chip *twl = to_twl(chip); |
291 | int ret; |
292 | u8 val; |
293 | |
294 | mutex_lock(&twl->mutex); |
295 | ret = twl_i2c_read_u8(mod_no: TWL6030_MODULE_ID1, val: &val, TWL6030_LED_PWM_CTRL2); |
296 | if (ret < 0) { |
297 | dev_err(pwmchip_parent(chip), "%s: Failed to read PWM_CTRL2\n" , |
298 | pwm->label); |
299 | goto out; |
300 | } |
301 | |
302 | val &= ~TWL6040_LED_MODE_MASK; |
303 | val |= TWL6040_LED_MODE_OFF; |
304 | |
305 | ret = twl_i2c_write_u8(mod_no: TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2); |
306 | if (ret < 0) |
307 | dev_err(pwmchip_parent(chip), "%s: Failed to request PWM\n" , pwm->label); |
308 | |
309 | out: |
310 | mutex_unlock(lock: &twl->mutex); |
311 | return ret; |
312 | } |
313 | |
314 | static void twl6030_pwmled_free(struct pwm_chip *chip, struct pwm_device *pwm) |
315 | { |
316 | struct twl_pwmled_chip *twl = to_twl(chip); |
317 | int ret; |
318 | u8 val; |
319 | |
320 | mutex_lock(&twl->mutex); |
321 | ret = twl_i2c_read_u8(mod_no: TWL6030_MODULE_ID1, val: &val, TWL6030_LED_PWM_CTRL2); |
322 | if (ret < 0) { |
323 | dev_err(pwmchip_parent(chip), "%s: Failed to read PWM_CTRL2\n" , |
324 | pwm->label); |
325 | goto out; |
326 | } |
327 | |
328 | val &= ~TWL6040_LED_MODE_MASK; |
329 | val |= TWL6040_LED_MODE_HW; |
330 | |
331 | ret = twl_i2c_write_u8(mod_no: TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2); |
332 | if (ret < 0) |
333 | dev_err(pwmchip_parent(chip), "%s: Failed to free PWM\n" , pwm->label); |
334 | |
335 | out: |
336 | mutex_unlock(lock: &twl->mutex); |
337 | } |
338 | |
339 | static const struct pwm_ops twl6030_pwmled_ops = { |
340 | .apply = twl6030_pwmled_apply, |
341 | .request = twl6030_pwmled_request, |
342 | .free = twl6030_pwmled_free, |
343 | }; |
344 | |
345 | static int twl_pwmled_probe(struct platform_device *pdev) |
346 | { |
347 | struct pwm_chip *chip; |
348 | struct twl_pwmled_chip *twl; |
349 | unsigned int npwm; |
350 | const struct pwm_ops *ops; |
351 | |
352 | if (twl_class_is_4030()) { |
353 | ops = &twl4030_pwmled_ops; |
354 | npwm = 2; |
355 | } else { |
356 | ops = &twl6030_pwmled_ops; |
357 | npwm = 1; |
358 | } |
359 | |
360 | chip = devm_pwmchip_alloc(parent: &pdev->dev, npwm, sizeof_priv: sizeof(*twl)); |
361 | if (IS_ERR(ptr: chip)) |
362 | return PTR_ERR(ptr: chip); |
363 | twl = to_twl(chip); |
364 | |
365 | chip->ops = ops; |
366 | |
367 | mutex_init(&twl->mutex); |
368 | |
369 | return devm_pwmchip_add(&pdev->dev, chip); |
370 | } |
371 | |
372 | #ifdef CONFIG_OF |
373 | static const struct of_device_id twl_pwmled_of_match[] = { |
374 | { .compatible = "ti,twl4030-pwmled" }, |
375 | { .compatible = "ti,twl6030-pwmled" }, |
376 | { }, |
377 | }; |
378 | MODULE_DEVICE_TABLE(of, twl_pwmled_of_match); |
379 | #endif |
380 | |
381 | static struct platform_driver twl_pwmled_driver = { |
382 | .driver = { |
383 | .name = "twl-pwmled" , |
384 | .of_match_table = of_match_ptr(twl_pwmled_of_match), |
385 | }, |
386 | .probe = twl_pwmled_probe, |
387 | }; |
388 | module_platform_driver(twl_pwmled_driver); |
389 | |
390 | MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>" ); |
391 | MODULE_DESCRIPTION("PWM driver for TWL4030 and TWL6030 LED outputs" ); |
392 | MODULE_ALIAS("platform:twl-pwmled" ); |
393 | MODULE_LICENSE("GPL" ); |
394 | |