source: src/linux/universal/linux-4.4/drivers/pwm/pwm-pca9685.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 8 days ago

use new squashfs in all kernels

File size: 9.5 KB
Line 
1/*
2 * Driver for PCA9685 16-channel 12-bit PWM LED controller
3 *
4 * Copyright (C) 2013 Steffen Trumtrar <s.trumtrar@pengutronix.de>
5 * Copyright (C) 2015 Clemens Gruber <clemens.gruber@pqgruber.com>
6 *
7 * based on the pwm-twl-led.c driver
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License version 2 as published by
11 * the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16 * more details.
17 *
18 * You should have received a copy of the GNU General Public License along with
19 * this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <linux/acpi.h>
23#include <linux/i2c.h>
24#include <linux/module.h>
25#include <linux/platform_device.h>
26#include <linux/property.h>
27#include <linux/pwm.h>
28#include <linux/regmap.h>
29#include <linux/slab.h>
30#include <linux/delay.h>
31
32/*
33 * Because the PCA9685 has only one prescaler per chip, changing the period of
34 * one channel affects the period of all 16 PWM outputs!
35 * However, the ratio between each configured duty cycle and the chip-wide
36 * period remains constant, because the OFF time is set in proportion to the
37 * counter range.
38 */
39
40#define PCA9685_MODE1           0x00
41#define PCA9685_MODE2           0x01
42#define PCA9685_SUBADDR1        0x02
43#define PCA9685_SUBADDR2        0x03
44#define PCA9685_SUBADDR3        0x04
45#define PCA9685_ALLCALLADDR     0x05
46#define PCA9685_LEDX_ON_L       0x06
47#define PCA9685_LEDX_ON_H       0x07
48#define PCA9685_LEDX_OFF_L      0x08
49#define PCA9685_LEDX_OFF_H      0x09
50
51#define PCA9685_ALL_LED_ON_L    0xFA
52#define PCA9685_ALL_LED_ON_H    0xFB
53#define PCA9685_ALL_LED_OFF_L   0xFC
54#define PCA9685_ALL_LED_OFF_H   0xFD
55#define PCA9685_PRESCALE        0xFE
56
57#define PCA9685_PRESCALE_MIN    0x03    /* => max. frequency of 1526 Hz */
58#define PCA9685_PRESCALE_MAX    0xFF    /* => min. frequency of 24 Hz */
59
60#define PCA9685_COUNTER_RANGE   4096
61#define PCA9685_DEFAULT_PERIOD  5000000 /* Default period_ns = 1/200 Hz */
62#define PCA9685_OSC_CLOCK_MHZ   25      /* Internal oscillator with 25 MHz */
63
64#define PCA9685_NUMREGS         0xFF
65#define PCA9685_MAXCHAN         0x10
66
67#define LED_FULL                (1 << 4)
68#define MODE1_SLEEP             (1 << 4)
69#define MODE2_INVRT             (1 << 4)
70#define MODE2_OUTDRV            (1 << 2)
71
72#define LED_N_ON_H(N)   (PCA9685_LEDX_ON_H + (4 * (N)))
73#define LED_N_ON_L(N)   (PCA9685_LEDX_ON_L + (4 * (N)))
74#define LED_N_OFF_H(N)  (PCA9685_LEDX_OFF_H + (4 * (N)))
75#define LED_N_OFF_L(N)  (PCA9685_LEDX_OFF_L + (4 * (N)))
76
77struct pca9685 {
78        struct pwm_chip chip;
79        struct regmap *regmap;
80        int active_cnt;
81        int duty_ns;
82        int period_ns;
83};
84
85static inline struct pca9685 *to_pca(struct pwm_chip *chip)
86{
87        return container_of(chip, struct pca9685, chip);
88}
89
90static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
91                              int duty_ns, int period_ns)
92{
93        struct pca9685 *pca = to_pca(chip);
94        unsigned long long duty;
95        unsigned int reg;
96        int prescale;
97
98        if (period_ns != pca->period_ns) {
99                prescale = DIV_ROUND_CLOSEST(PCA9685_OSC_CLOCK_MHZ * period_ns,
100                                             PCA9685_COUNTER_RANGE * 1000) - 1;
101
102                if (prescale >= PCA9685_PRESCALE_MIN &&
103                        prescale <= PCA9685_PRESCALE_MAX) {
104                        /* Put chip into sleep mode */
105                        regmap_update_bits(pca->regmap, PCA9685_MODE1,
106                                           MODE1_SLEEP, MODE1_SLEEP);
107
108                        /* Change the chip-wide output frequency */
109                        regmap_write(pca->regmap, PCA9685_PRESCALE, prescale);
110
111                        /* Wake the chip up */
112                        regmap_update_bits(pca->regmap, PCA9685_MODE1,
113                                           MODE1_SLEEP, 0x0);
114
115                        /* Wait 500us for the oscillator to be back up */
116                        udelay(500);
117
118                        pca->period_ns = period_ns;
119                } else {
120                        dev_err(chip->dev,
121                                "prescaler not set: period out of bounds!\n");
122                        return -EINVAL;
123                }
124        }
125
126        pca->duty_ns = duty_ns;
127
128        if (duty_ns < 1) {
129                if (pwm->hwpwm >= PCA9685_MAXCHAN)
130                        reg = PCA9685_ALL_LED_OFF_H;
131                else
132                        reg = LED_N_OFF_H(pwm->hwpwm);
133
134                regmap_write(pca->regmap, reg, LED_FULL);
135
136                return 0;
137        }
138
139        if (duty_ns == period_ns) {
140                /* Clear both OFF registers */
141                if (pwm->hwpwm >= PCA9685_MAXCHAN)
142                        reg = PCA9685_ALL_LED_OFF_L;
143                else
144                        reg = LED_N_OFF_L(pwm->hwpwm);
145
146                regmap_write(pca->regmap, reg, 0x0);
147
148                if (pwm->hwpwm >= PCA9685_MAXCHAN)
149                        reg = PCA9685_ALL_LED_OFF_H;
150                else
151                        reg = LED_N_OFF_H(pwm->hwpwm);
152
153                regmap_write(pca->regmap, reg, 0x0);
154
155                /* Set the full ON bit */
156                if (pwm->hwpwm >= PCA9685_MAXCHAN)
157                        reg = PCA9685_ALL_LED_ON_H;
158                else
159                        reg = LED_N_ON_H(pwm->hwpwm);
160
161                regmap_write(pca->regmap, reg, LED_FULL);
162
163                return 0;
164        }
165
166        duty = PCA9685_COUNTER_RANGE * (unsigned long long)duty_ns;
167        duty = DIV_ROUND_UP_ULL(duty, period_ns);
168
169        if (pwm->hwpwm >= PCA9685_MAXCHAN)
170                reg = PCA9685_ALL_LED_OFF_L;
171        else
172                reg = LED_N_OFF_L(pwm->hwpwm);
173
174        regmap_write(pca->regmap, reg, (int)duty & 0xff);
175
176        if (pwm->hwpwm >= PCA9685_MAXCHAN)
177                reg = PCA9685_ALL_LED_OFF_H;
178        else
179                reg = LED_N_OFF_H(pwm->hwpwm);
180
181        regmap_write(pca->regmap, reg, ((int)duty >> 8) & 0xf);
182
183        /* Clear the full ON bit, otherwise the set OFF time has no effect */
184        if (pwm->hwpwm >= PCA9685_MAXCHAN)
185                reg = PCA9685_ALL_LED_ON_H;
186        else
187                reg = LED_N_ON_H(pwm->hwpwm);
188
189        regmap_write(pca->regmap, reg, 0);
190
191        return 0;
192}
193
194static int pca9685_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
195{
196        struct pca9685 *pca = to_pca(chip);
197        unsigned int reg;
198
199        /*
200         * The PWM subsystem does not support a pre-delay.
201         * So, set the ON-timeout to 0
202         */
203        if (pwm->hwpwm >= PCA9685_MAXCHAN)
204                reg = PCA9685_ALL_LED_ON_L;
205        else
206                reg = LED_N_ON_L(pwm->hwpwm);
207
208        regmap_write(pca->regmap, reg, 0);
209
210        if (pwm->hwpwm >= PCA9685_MAXCHAN)
211                reg = PCA9685_ALL_LED_ON_H;
212        else
213                reg = LED_N_ON_H(pwm->hwpwm);
214
215        regmap_write(pca->regmap, reg, 0);
216
217        /*
218         * Clear the full-off bit.
219         * It has precedence over the others and must be off.
220         */
221        if (pwm->hwpwm >= PCA9685_MAXCHAN)
222                reg = PCA9685_ALL_LED_OFF_H;
223        else
224                reg = LED_N_OFF_H(pwm->hwpwm);
225
226        regmap_update_bits(pca->regmap, reg, LED_FULL, 0x0);
227
228        return 0;
229}
230
231static void pca9685_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
232{
233        struct pca9685 *pca = to_pca(chip);
234        unsigned int reg;
235
236        if (pwm->hwpwm >= PCA9685_MAXCHAN)
237                reg = PCA9685_ALL_LED_OFF_H;
238        else
239                reg = LED_N_OFF_H(pwm->hwpwm);
240
241        regmap_write(pca->regmap, reg, LED_FULL);
242
243        /* Clear the LED_OFF counter. */
244        if (pwm->hwpwm >= PCA9685_MAXCHAN)
245                reg = PCA9685_ALL_LED_OFF_L;
246        else
247                reg = LED_N_OFF_L(pwm->hwpwm);
248
249        regmap_write(pca->regmap, reg, 0x0);
250}
251
252static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
253{
254        struct pca9685 *pca = to_pca(chip);
255
256        if (pca->active_cnt++ == 0)
257                return regmap_update_bits(pca->regmap, PCA9685_MODE1,
258                                          MODE1_SLEEP, 0x0);
259
260        return 0;
261}
262
263static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
264{
265        struct pca9685 *pca = to_pca(chip);
266
267        if (--pca->active_cnt == 0)
268                regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP,
269                                   MODE1_SLEEP);
270}
271
272static const struct pwm_ops pca9685_pwm_ops = {
273        .enable = pca9685_pwm_enable,
274        .disable = pca9685_pwm_disable,
275        .config = pca9685_pwm_config,
276        .request = pca9685_pwm_request,
277        .free = pca9685_pwm_free,
278        .owner = THIS_MODULE,
279};
280
281static const struct regmap_config pca9685_regmap_i2c_config = {
282        .reg_bits = 8,
283        .val_bits = 8,
284        .max_register = PCA9685_NUMREGS,
285        .cache_type = REGCACHE_NONE,
286};
287
288static int pca9685_pwm_probe(struct i2c_client *client,
289                                const struct i2c_device_id *id)
290{
291        struct pca9685 *pca;
292        int ret;
293        int mode2;
294
295        pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL);
296        if (!pca)
297                return -ENOMEM;
298
299        pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config);
300        if (IS_ERR(pca->regmap)) {
301                ret = PTR_ERR(pca->regmap);
302                dev_err(&client->dev, "Failed to initialize register map: %d\n",
303                        ret);
304                return ret;
305        }
306        pca->duty_ns = 0;
307        pca->period_ns = PCA9685_DEFAULT_PERIOD;
308
309        i2c_set_clientdata(client, pca);
310
311        regmap_read(pca->regmap, PCA9685_MODE2, &mode2);
312
313        if (device_property_read_bool(&client->dev, "invert"))
314                mode2 |= MODE2_INVRT;
315        else
316                mode2 &= ~MODE2_INVRT;
317
318        if (device_property_read_bool(&client->dev, "open-drain"))
319                mode2 &= ~MODE2_OUTDRV;
320        else
321                mode2 |= MODE2_OUTDRV;
322
323        regmap_write(pca->regmap, PCA9685_MODE2, mode2);
324
325        /* clear all "full off" bits */
326        regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_L, 0);
327        regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_H, 0);
328
329        pca->chip.ops = &pca9685_pwm_ops;
330        /* add an extra channel for ALL_LED */
331        pca->chip.npwm = PCA9685_MAXCHAN + 1;
332
333        pca->chip.dev = &client->dev;
334        pca->chip.base = -1;
335        pca->chip.can_sleep = true;
336
337        return pwmchip_add(&pca->chip);
338}
339
340static int pca9685_pwm_remove(struct i2c_client *client)
341{
342        struct pca9685 *pca = i2c_get_clientdata(client);
343
344        regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP,
345                           MODE1_SLEEP);
346
347        return pwmchip_remove(&pca->chip);
348}
349
350static const struct i2c_device_id pca9685_id[] = {
351        { "pca9685", 0 },
352        { /* sentinel */ },
353};
354MODULE_DEVICE_TABLE(i2c, pca9685_id);
355
356#ifdef CONFIG_ACPI
357static const struct acpi_device_id pca9685_acpi_ids[] = {
358        { "INT3492", 0 },
359        { /* sentinel */ },
360};
361MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids);
362#endif
363
364#ifdef CONFIG_OF
365static const struct of_device_id pca9685_dt_ids[] = {
366        { .compatible = "nxp,pca9685-pwm", },
367        { /* sentinel */ }
368};
369MODULE_DEVICE_TABLE(of, pca9685_dt_ids);
370#endif
371
372static struct i2c_driver pca9685_i2c_driver = {
373        .driver = {
374                .name = "pca9685-pwm",
375                .acpi_match_table = ACPI_PTR(pca9685_acpi_ids),
376                .of_match_table = of_match_ptr(pca9685_dt_ids),
377        },
378        .probe = pca9685_pwm_probe,
379        .remove = pca9685_pwm_remove,
380        .id_table = pca9685_id,
381};
382
383module_i2c_driver(pca9685_i2c_driver);
384
385MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>");
386MODULE_DESCRIPTION("PWM driver for PCA9685");
387MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.