drivers/pwm/pwm-pca9685.c

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