drivers/pwm/pwm-pca9685.c

   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/gpio/driver.h>
  24 #include <linux/i2c.h>
  25 #include <linux/module.h>
  26 #include <linux/mutex.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/property.h>
  29 #include <linux/pwm.h>
  30 #include <linux/regmap.h>
  31 #include <linux/slab.h>
  32 #include <linux/delay.h>
  33
  34 /*
  35  * Because the PCA9685 has only one prescaler per chip, changing the period of
  36  * one channel affects the period of all 16 PWM outputs!
  37  * However, the ratio between each configured duty cycle and the chip-wide
  38  * period remains constant, because the OFF time is set in proportion to the
  39  * counter range.
  40  */
  41
  42 #define PCA9685_MODE1           0x00
  43 #define PCA9685_MODE2           0x01
  44 #define PCA9685_SUBADDR1        0x02
  45 #define PCA9685_SUBADDR2        0x03
  46 #define PCA9685_SUBADDR3        0x04
  47 #define PCA9685_ALLCALLADDR     0x05
  48 #define PCA9685_LEDX_ON_L       0x06
  49 #define PCA9685_LEDX_ON_H       0x07
  50 #define PCA9685_LEDX_OFF_L      0x08
  51 #define PCA9685_LEDX_OFF_H      0x09
  52
  53 #define PCA9685_ALL_LED_ON_L    0xFA
  54 #define PCA9685_ALL_LED_ON_H    0xFB
  55 #define PCA9685_ALL_LED_OFF_L   0xFC
  56 #define PCA9685_ALL_LED_OFF_H   0xFD
  57 #define PCA9685_PRESCALE        0xFE
  58
  59 #define PCA9685_PRESCALE_MIN    0x03    /* => max. frequency of 1526 Hz */
  60 #define PCA9685_PRESCALE_MAX    0xFF    /* => min. frequency of 24 Hz */
  61
  62 #define PCA9685_COUNTER_RANGE   4096
  63 #define PCA9685_DEFAULT_PERIOD  5000000 /* Default period_ns = 1/200 Hz */
  64 #define PCA9685_OSC_CLOCK_MHZ   25      /* Internal oscillator with 25 MHz */
  65
  66 #define PCA9685_NUMREGS         0xFF
  67 #define PCA9685_MAXCHAN         0x10
  68
  69 #define LED_FULL                (1 << 4)
  70 #define MODE1_SLEEP             (1 << 4)
  71 #define MODE2_INVRT             (1 << 4)
  72 #define MODE2_OUTDRV            (1 << 2)
  73
  74 #define LED_N_ON_H(N)   (PCA9685_LEDX_ON_H + (4 * (N)))
  75 #define LED_N_ON_L(N)   (PCA9685_LEDX_ON_L + (4 * (N)))
  76 #define LED_N_OFF_H(N)  (PCA9685_LEDX_OFF_H + (4 * (N)))
  77 #define LED_N_OFF_L(N)  (PCA9685_LEDX_OFF_L + (4 * (N)))
  78
  79 struct pca9685 {
  80         struct pwm_chip chip;
  81         struct regmap *regmap;
  82         int active_cnt;
  83         int duty_ns;
  84         int period_ns;
  85 #if IS_ENABLED(CONFIG_GPIOLIB)
  86         struct mutex lock;
  87         struct gpio_chip gpio;
  88 #endif
  89 };
  90
  91 static inline struct pca9685 *to_pca(struct pwm_chip *chip)
  92 {
  93         return container_of(chip, struct pca9685, chip);
  94 }
  95
  96 #if IS_ENABLED(CONFIG_GPIOLIB)
  97 static int pca9685_pwm_gpio_request(struct gpio_chip *gpio, unsigned int offset)
  98 {
  99         struct pca9685 *pca = gpiochip_get_data(gpio);
 100         struct pwm_device *pwm;
 101
 102         mutex_lock(&pca->lock);
 103
 104         pwm = &pca->chip.pwms[offset];
 105
 106         if (pwm->flags & (PWMF_REQUESTED | PWMF_EXPORTED)) {
 107                 mutex_unlock(&pca->lock);
 108                 return -EBUSY;
 109         }
 110
 111         pwm_set_chip_data(pwm, (void *)1);
 112
 113         mutex_unlock(&pca->lock);
 114         return 0;
 115 }
 116
 117 static void pca9685_pwm_gpio_free(struct gpio_chip *gpio, unsigned int offset)
 118 {
 119         struct pca9685 *pca = gpiochip_get_data(gpio);
 120         struct pwm_device *pwm;
 121
 122         mutex_lock(&pca->lock);
 123         pwm = &pca->chip.pwms[offset];
 124         pwm_set_chip_data(pwm, NULL);
 125         mutex_unlock(&pca->lock);
 126 }
 127
 128 static bool pca9685_pwm_is_gpio(struct pca9685 *pca, struct pwm_device *pwm)
 129 {
 130         bool is_gpio = false;
 131
 132         mutex_lock(&pca->lock);
 133
 134         if (pwm->hwpwm >= PCA9685_MAXCHAN) {
 135                 unsigned int i;
 136
 137                 /*
 138                  * Check if any of the GPIOs are requested and in that case
 139                  * prevent using the "all LEDs" channel.
 140                  */
 141                 for (i = 0; i < pca->gpio.ngpio; i++)
 142                         if (gpiochip_is_requested(&pca->gpio, i)) {
 143                                 is_gpio = true;
 144                                 break;
 145                         }
 146         } else if (pwm_get_chip_data(pwm)) {
 147                 is_gpio = true;
 148         }
 149
 150         mutex_unlock(&pca->lock);
 151         return is_gpio;
 152 }
 153
 154 static int pca9685_pwm_gpio_get(struct gpio_chip *gpio, unsigned int offset)
 155 {
 156         struct pca9685 *pca = gpiochip_get_data(gpio);
 157         struct pwm_device *pwm = &pca->chip.pwms[offset];
 158         unsigned int value;
 159
 160         regmap_read(pca->regmap, LED_N_ON_H(pwm->hwpwm), &value);
 161
 162         return value & LED_FULL;
 163 }
 164
 165 static void pca9685_pwm_gpio_set(struct gpio_chip *gpio, unsigned int offset,
 166                                  int value)
 167 {
 168         struct pca9685 *pca = gpiochip_get_data(gpio);
 169         struct pwm_device *pwm = &pca->chip.pwms[offset];
 170         unsigned int on = value ? LED_FULL : 0;
 171
 172         /* Clear both OFF registers */
 173         regmap_write(pca->regmap, LED_N_OFF_L(pwm->hwpwm), 0);
 174         regmap_write(pca->regmap, LED_N_OFF_H(pwm->hwpwm), 0);
 175
 176         /* Set the full ON bit */
 177         regmap_write(pca->regmap, LED_N_ON_H(pwm->hwpwm), on);
 178 }
 179
 180 static int pca9685_pwm_gpio_get_direction(struct gpio_chip *chip,
 181                                           unsigned int offset)
 182 {
 183         /* Always out */
 184         return 0;
 185 }
 186
 187 static int pca9685_pwm_gpio_direction_input(struct gpio_chip *gpio,
 188                                             unsigned int offset)
 189 {
 190         return -EINVAL;
 191 }
 192
 193 static int pca9685_pwm_gpio_direction_output(struct gpio_chip *gpio,
 194                                              unsigned int offset, int value)
 195 {
 196         pca9685_pwm_gpio_set(gpio, offset, value);
 197
 198         return 0;
 199 }
 200
 201 /*
 202  * The PCA9685 has a bit for turning the PWM output full off or on. Some
 203  * boards like Intel Galileo actually uses these as normal GPIOs so we
 204  * expose a GPIO chip here which can exclusively take over the underlying
 205  * PWM channel.
 206  */
 207 static int pca9685_pwm_gpio_probe(struct pca9685 *pca)
 208 {
 209         struct device *dev = pca->chip.dev;
 210
 211         mutex_init(&pca->lock);
 212
 213         pca->gpio.label = dev_name(dev);
 214         pca->gpio.parent = dev;
 215         pca->gpio.request = pca9685_pwm_gpio_request;
 216         pca->gpio.free = pca9685_pwm_gpio_free;
 217         pca->gpio.get_direction = pca9685_pwm_gpio_get_direction;
 218         pca->gpio.direction_input = pca9685_pwm_gpio_direction_input;
 219         pca->gpio.direction_output = pca9685_pwm_gpio_direction_output;
 220         pca->gpio.get = pca9685_pwm_gpio_get;
 221         pca->gpio.set = pca9685_pwm_gpio_set;
 222         pca->gpio.base = -1;
 223         pca->gpio.ngpio = PCA9685_MAXCHAN;
 224         pca->gpio.can_sleep = true;
 225
 226         return devm_gpiochip_add_data(dev, &pca->gpio, pca);
 227 }
 228 #else
 229 static inline bool pca9685_pwm_is_gpio(struct pca9685 *pca,
 230                                        struct pwm_device *pwm)
 231 {
 232         return false;
 233 }
 234
 235 static inline int pca9685_pwm_gpio_probe(struct pca9685 *pca)
 236 {
 237         return 0;
 238 }
 239 #endif
 240
 241 static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
 242                               int duty_ns, int period_ns)
 243 {
 244         struct pca9685 *pca = to_pca(chip);
 245         unsigned long long duty;
 246         unsigned int reg;
 247         int prescale;
 248
 249         if (period_ns != pca->period_ns) {
 250                 prescale = DIV_ROUND_CLOSEST(PCA9685_OSC_CLOCK_MHZ * period_ns,
 251                                              PCA9685_COUNTER_RANGE * 1000) - 1;
 252
 253                 if (prescale >= PCA9685_PRESCALE_MIN &&
 254                         prescale <= PCA9685_PRESCALE_MAX) {
 255                         /* Put chip into sleep mode */
 256                         regmap_update_bits(pca->regmap, PCA9685_MODE1,
 257                                            MODE1_SLEEP, MODE1_SLEEP);
 258
 259                         /* Change the chip-wide output frequency */
 260                         regmap_write(pca->regmap, PCA9685_PRESCALE, prescale);
 261
 262                         /* Wake the chip up */
 263                         regmap_update_bits(pca->regmap, PCA9685_MODE1,
 264                                            MODE1_SLEEP, 0x0);
 265
 266                         /* Wait 500us for the oscillator to be back up */
 267                         udelay(500);
 268
 269                         pca->period_ns = period_ns;
 270                 } else {
 271                         dev_err(chip->dev,
 272                                 "prescaler not set: period out of bounds!\n");
 273                         return -EINVAL;
 274                 }
 275         }
 276
 277         pca->duty_ns = duty_ns;
 278
 279         if (duty_ns < 1) {
 280                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 281                         reg = PCA9685_ALL_LED_OFF_H;
 282                 else
 283                         reg = LED_N_OFF_H(pwm->hwpwm);
 284
 285                 regmap_write(pca->regmap, reg, LED_FULL);
 286
 287                 return 0;
 288         }
 289
 290         if (duty_ns == period_ns) {
 291                 /* Clear both OFF registers */
 292                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 293                         reg = PCA9685_ALL_LED_OFF_L;
 294                 else
 295                         reg = LED_N_OFF_L(pwm->hwpwm);
 296
 297                 regmap_write(pca->regmap, reg, 0x0);
 298
 299                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 300                         reg = PCA9685_ALL_LED_OFF_H;
 301                 else
 302                         reg = LED_N_OFF_H(pwm->hwpwm);
 303
 304                 regmap_write(pca->regmap, reg, 0x0);
 305
 306                 /* Set the full ON bit */
 307                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 308                         reg = PCA9685_ALL_LED_ON_H;
 309                 else
 310                         reg = LED_N_ON_H(pwm->hwpwm);
 311
 312                 regmap_write(pca->regmap, reg, LED_FULL);
 313
 314                 return 0;
 315         }
 316
 317         duty = PCA9685_COUNTER_RANGE * (unsigned long long)duty_ns;
 318         duty = DIV_ROUND_UP_ULL(duty, period_ns);
 319
 320         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 321                 reg = PCA9685_ALL_LED_OFF_L;
 322         else
 323                 reg = LED_N_OFF_L(pwm->hwpwm);
 324
 325         regmap_write(pca->regmap, reg, (int)duty & 0xff);
 326
 327         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 328                 reg = PCA9685_ALL_LED_OFF_H;
 329         else
 330                 reg = LED_N_OFF_H(pwm->hwpwm);
 331
 332         regmap_write(pca->regmap, reg, ((int)duty >> 8) & 0xf);
 333
 334         /* Clear the full ON bit, otherwise the set OFF time has no effect */
 335         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 336                 reg = PCA9685_ALL_LED_ON_H;
 337         else
 338                 reg = LED_N_ON_H(pwm->hwpwm);
 339
 340         regmap_write(pca->regmap, reg, 0);
 341
 342         return 0;
 343 }
 344
 345 static int pca9685_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 346 {
 347         struct pca9685 *pca = to_pca(chip);
 348         unsigned int reg;
 349
 350         /*
 351          * The PWM subsystem does not support a pre-delay.
 352          * So, set the ON-timeout to 0
 353          */
 354         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 355                 reg = PCA9685_ALL_LED_ON_L;
 356         else
 357                 reg = LED_N_ON_L(pwm->hwpwm);
 358
 359         regmap_write(pca->regmap, reg, 0);
 360
 361         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 362                 reg = PCA9685_ALL_LED_ON_H;
 363         else
 364                 reg = LED_N_ON_H(pwm->hwpwm);
 365
 366         regmap_write(pca->regmap, reg, 0);
 367
 368         /*
 369          * Clear the full-off bit.
 370          * It has precedence over the others and must be off.
 371          */
 372         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 373                 reg = PCA9685_ALL_LED_OFF_H;
 374         else
 375                 reg = LED_N_OFF_H(pwm->hwpwm);
 376
 377         regmap_update_bits(pca->regmap, reg, LED_FULL, 0x0);
 378
 379         return 0;
 380 }
 381
 382 static void pca9685_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 383 {
 384         struct pca9685 *pca = to_pca(chip);
 385         unsigned int reg;
 386
 387         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 388                 reg = PCA9685_ALL_LED_OFF_H;
 389         else
 390                 reg = LED_N_OFF_H(pwm->hwpwm);
 391
 392         regmap_write(pca->regmap, reg, LED_FULL);
 393
 394         /* Clear the LED_OFF counter. */
 395         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 396                 reg = PCA9685_ALL_LED_OFF_L;
 397         else
 398                 reg = LED_N_OFF_L(pwm->hwpwm);
 399
 400         regmap_write(pca->regmap, reg, 0x0);
 401 }
 402
 403 static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
 404 {
 405         struct pca9685 *pca = to_pca(chip);
 406
 407         if (pca9685_pwm_is_gpio(pca, pwm))
 408                 return -EBUSY;
 409
 410         if (pca->active_cnt++ == 0)
 411                 return regmap_update_bits(pca->regmap, PCA9685_MODE1,
 412                                           MODE1_SLEEP, 0x0);
 413
 414         return 0;
 415 }
 416
 417 static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
 418 {
 419         struct pca9685 *pca = to_pca(chip);
 420
 421         if (--pca->active_cnt == 0)
 422                 regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP,
 423                                    MODE1_SLEEP);
 424 }
 425
 426 static const struct pwm_ops pca9685_pwm_ops = {
 427         .enable = pca9685_pwm_enable,
 428         .disable = pca9685_pwm_disable,
 429         .config = pca9685_pwm_config,
 430         .request = pca9685_pwm_request,
 431         .free = pca9685_pwm_free,
 432         .owner = THIS_MODULE,
 433 };
 434
 435 static const struct regmap_config pca9685_regmap_i2c_config = {
 436         .reg_bits = 8,
 437         .val_bits = 8,
 438         .max_register = PCA9685_NUMREGS,
 439         .cache_type = REGCACHE_NONE,
 440 };
 441
 442 static int pca9685_pwm_probe(struct i2c_client *client,
 443                                 const struct i2c_device_id *id)
 444 {
 445         struct pca9685 *pca;
 446         int ret;
 447         int mode2;
 448
 449         pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL);
 450         if (!pca)
 451                 return -ENOMEM;
 452
 453         pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config);
 454         if (IS_ERR(pca->regmap)) {
 455                 ret = PTR_ERR(pca->regmap);
 456                 dev_err(&client->dev, "Failed to initialize register map: %d\n",
 457                         ret);
 458                 return ret;
 459         }
 460         pca->duty_ns = 0;
 461         pca->period_ns = PCA9685_DEFAULT_PERIOD;
 462
 463         i2c_set_clientdata(client, pca);
 464
 465         regmap_read(pca->regmap, PCA9685_MODE2, &mode2);
 466
 467         if (device_property_read_bool(&client->dev, "invert"))
 468                 mode2 |= MODE2_INVRT;
 469         else
 470                 mode2 &= ~MODE2_INVRT;
 471
 472         if (device_property_read_bool(&client->dev, "open-drain"))
 473                 mode2 &= ~MODE2_OUTDRV;
 474         else
 475                 mode2 |= MODE2_OUTDRV;
 476
 477         regmap_write(pca->regmap, PCA9685_MODE2, mode2);
 478
 479         /* clear all "full off" bits */
 480         regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_L, 0);
 481         regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_H, 0);
 482
 483         pca->chip.ops = &pca9685_pwm_ops;
 484         /* add an extra channel for ALL_LED */
 485         pca->chip.npwm = PCA9685_MAXCHAN + 1;
 486
 487         pca->chip.dev = &client->dev;
 488         pca->chip.base = -1;
 489
 490         ret = pwmchip_add(&pca->chip);
 491         if (ret < 0)
 492                 return ret;
 493
 494         ret = pca9685_pwm_gpio_probe(pca);
 495         if (ret < 0)
 496                 pwmchip_remove(&pca->chip);
 497
 498         return ret;
 499 }
 500
 501 static int pca9685_pwm_remove(struct i2c_client *client)
 502 {
 503         struct pca9685 *pca = i2c_get_clientdata(client);
 504
 505         regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP,
 506                            MODE1_SLEEP);
 507
 508         return pwmchip_remove(&pca->chip);
 509 }
 510
 511 static const struct i2c_device_id pca9685_id[] = {
 512         { "pca9685", 0 },
 513         { /* sentinel */ },
 514 };
 515 MODULE_DEVICE_TABLE(i2c, pca9685_id);
 516
 517 #ifdef CONFIG_ACPI
 518 static const struct acpi_device_id pca9685_acpi_ids[] = {
 519         { "INT3492", 0 },
 520         { /* sentinel */ },
 521 };
 522 MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids);
 523 #endif
 524
 525 #ifdef CONFIG_OF
 526 static const struct of_device_id pca9685_dt_ids[] = {
 527         { .compatible = "nxp,pca9685-pwm", },
 528         { /* sentinel */ }
 529 };
 530 MODULE_DEVICE_TABLE(of, pca9685_dt_ids);
 531 #endif
 532
 533 static struct i2c_driver pca9685_i2c_driver = {
 534         .driver = {
 535                 .name = "pca9685-pwm",
 536                 .acpi_match_table = ACPI_PTR(pca9685_acpi_ids),
 537                 .of_match_table = of_match_ptr(pca9685_dt_ids),
 538         },
 539         .probe = pca9685_pwm_probe,
 540         .remove = pca9685_pwm_remove,
 541         .id_table = pca9685_id,
 542 };
 543
 544 module_i2c_driver(pca9685_i2c_driver);
 545
 546 MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>");
 547 MODULE_DESCRIPTION("PWM driver for PCA9685");
 548 MODULE_LICENSE("GPL");