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         struct pwm_device *pwm;
 163
 164         pca9685_pwm_gpio_set(gpio, offset, 0);
 165         pm_runtime_put(pca->chip.dev);
 166         mutex_lock(&pca->lock);
 167         pwm = &pca->chip.pwms[offset];
 168         mutex_unlock(&pca->lock);
 169 }
 170
 171 static int pca9685_pwm_gpio_get_direction(struct gpio_chip *chip,
 172                                           unsigned int offset)
 173 {
 174         /* Always out */
 175         return 0;
 176 }
 177
 178 static int pca9685_pwm_gpio_direction_input(struct gpio_chip *gpio,
 179                                             unsigned int offset)
 180 {
 181         return -EINVAL;
 182 }
 183
 184 static int pca9685_pwm_gpio_direction_output(struct gpio_chip *gpio,
 185                                              unsigned int offset, int value)
 186 {
 187         pca9685_pwm_gpio_set(gpio, offset, value);
 188
 189         return 0;
 190 }
 191
 192 /*
 193  * The PCA9685 has a bit for turning the PWM output full off or on. Some
 194  * boards like Intel Galileo actually uses these as normal GPIOs so we
 195  * expose a GPIO chip here which can exclusively take over the underlying
 196  * PWM channel.
 197  */
 198 static int pca9685_pwm_gpio_probe(struct pca9685 *pca)
 199 {
 200         struct device *dev = pca->chip.dev;
 201
 202         mutex_init(&pca->lock);
 203
 204         pca->gpio.label = dev_name(dev);
 205         pca->gpio.parent = dev;
 206         pca->gpio.request = pca9685_pwm_gpio_request;
 207         pca->gpio.free = pca9685_pwm_gpio_free;
 208         pca->gpio.get_direction = pca9685_pwm_gpio_get_direction;
 209         pca->gpio.direction_input = pca9685_pwm_gpio_direction_input;
 210         pca->gpio.direction_output = pca9685_pwm_gpio_direction_output;
 211         pca->gpio.get = pca9685_pwm_gpio_get;
 212         pca->gpio.set = pca9685_pwm_gpio_set;
 213         pca->gpio.base = -1;
 214         pca->gpio.ngpio = PCA9685_MAXCHAN;
 215         pca->gpio.can_sleep = true;
 216
 217         return devm_gpiochip_add_data(dev, &pca->gpio, pca);
 218 }
 219 #else
 220 static inline bool pca9685_pwm_is_gpio(struct pca9685 *pca,
 221                                        struct pwm_device *pwm)
 222 {
 223         return false;
 224 }
 225
 226 static inline int pca9685_pwm_gpio_probe(struct pca9685 *pca)
 227 {
 228         return 0;
 229 }
 230 #endif
 231
 232 static void pca9685_set_sleep_mode(struct pca9685 *pca, bool enable)
 233 {
 234         regmap_update_bits(pca->regmap, PCA9685_MODE1,
 235                            MODE1_SLEEP, enable ? MODE1_SLEEP : 0);
 236         if (!enable) {
 237                 /* Wait 500us for the oscillator to be back up */
 238                 udelay(500);
 239         }
 240 }
 241
 242 static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
 243                               int duty_ns, int period_ns)
 244 {
 245         struct pca9685 *pca = to_pca(chip);
 246         unsigned long long duty;
 247         unsigned int reg;
 248         int prescale;
 249
 250         if (period_ns != pca->period_ns) {
 251                 prescale = DIV_ROUND_CLOSEST(PCA9685_OSC_CLOCK_MHZ * period_ns,
 252                                              PCA9685_COUNTER_RANGE * 1000) - 1;
 253
 254                 if (prescale >= PCA9685_PRESCALE_MIN &&
 255                         prescale <= PCA9685_PRESCALE_MAX) {
 256                         /*
 257                          * putting the chip briefly into SLEEP mode
 258                          * at this point won't interfere with the
 259                          * pm_runtime framework, because the pm_runtime
 260                          * state is guaranteed active here.
 261                          */
 262                         /* Put chip into sleep mode */
 263                         pca9685_set_sleep_mode(pca, true);
 264
 265                         /* Change the chip-wide output frequency */
 266                         regmap_write(pca->regmap, PCA9685_PRESCALE, prescale);
 267
 268                         /* Wake the chip up */
 269                         pca9685_set_sleep_mode(pca, false);
 270
 271                         pca->period_ns = period_ns;
 272                 } else {
 273                         dev_err(chip->dev,
 274                                 "prescaler not set: period out of bounds!\n");
 275                         return -EINVAL;
 276                 }
 277         }
 278
 279         pca->duty_ns = duty_ns;
 280
 281         if (duty_ns < 1) {
 282                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 283                         reg = PCA9685_ALL_LED_OFF_H;
 284                 else
 285                         reg = LED_N_OFF_H(pwm->hwpwm);
 286
 287                 regmap_write(pca->regmap, reg, LED_FULL);
 288
 289                 return 0;
 290         }
 291
 292         if (duty_ns == period_ns) {
 293                 /* Clear both OFF registers */
 294                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 295                         reg = PCA9685_ALL_LED_OFF_L;
 296                 else
 297                         reg = LED_N_OFF_L(pwm->hwpwm);
 298
 299                 regmap_write(pca->regmap, reg, 0x0);
 300
 301                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 302                         reg = PCA9685_ALL_LED_OFF_H;
 303                 else
 304                         reg = LED_N_OFF_H(pwm->hwpwm);
 305
 306                 regmap_write(pca->regmap, reg, 0x0);
 307
 308                 /* Set the full ON bit */
 309                 if (pwm->hwpwm >= PCA9685_MAXCHAN)
 310                         reg = PCA9685_ALL_LED_ON_H;
 311                 else
 312                         reg = LED_N_ON_H(pwm->hwpwm);
 313
 314                 regmap_write(pca->regmap, reg, LED_FULL);
 315
 316                 return 0;
 317         }
 318
 319         duty = PCA9685_COUNTER_RANGE * (unsigned long long)duty_ns;
 320         duty = DIV_ROUND_UP_ULL(duty, period_ns);
 321
 322         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 323                 reg = PCA9685_ALL_LED_OFF_L;
 324         else
 325                 reg = LED_N_OFF_L(pwm->hwpwm);
 326
 327         regmap_write(pca->regmap, reg, (int)duty & 0xff);
 328
 329         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 330                 reg = PCA9685_ALL_LED_OFF_H;
 331         else
 332                 reg = LED_N_OFF_H(pwm->hwpwm);
 333
 334         regmap_write(pca->regmap, reg, ((int)duty >> 8) & 0xf);
 335
 336         /* Clear the full ON bit, otherwise the set OFF time has no effect */
 337         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 338                 reg = PCA9685_ALL_LED_ON_H;
 339         else
 340                 reg = LED_N_ON_H(pwm->hwpwm);
 341
 342         regmap_write(pca->regmap, reg, 0);
 343
 344         return 0;
 345 }
 346
 347 static int pca9685_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 348 {
 349         struct pca9685 *pca = to_pca(chip);
 350         unsigned int reg;
 351
 352         /*
 353          * The PWM subsystem does not support a pre-delay.
 354          * So, set the ON-timeout to 0
 355          */
 356         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 357                 reg = PCA9685_ALL_LED_ON_L;
 358         else
 359                 reg = LED_N_ON_L(pwm->hwpwm);
 360
 361         regmap_write(pca->regmap, reg, 0);
 362
 363         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 364                 reg = PCA9685_ALL_LED_ON_H;
 365         else
 366                 reg = LED_N_ON_H(pwm->hwpwm);
 367
 368         regmap_write(pca->regmap, reg, 0);
 369
 370         /*
 371          * Clear the full-off bit.
 372          * It has precedence over the others and must be off.
 373          */
 374         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 375                 reg = PCA9685_ALL_LED_OFF_H;
 376         else
 377                 reg = LED_N_OFF_H(pwm->hwpwm);
 378
 379         regmap_update_bits(pca->regmap, reg, LED_FULL, 0x0);
 380
 381         return 0;
 382 }
 383
 384 static void pca9685_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 385 {
 386         struct pca9685 *pca = to_pca(chip);
 387         unsigned int reg;
 388
 389         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 390                 reg = PCA9685_ALL_LED_OFF_H;
 391         else
 392                 reg = LED_N_OFF_H(pwm->hwpwm);
 393
 394         regmap_write(pca->regmap, reg, LED_FULL);
 395
 396         /* Clear the LED_OFF counter. */
 397         if (pwm->hwpwm >= PCA9685_MAXCHAN)
 398                 reg = PCA9685_ALL_LED_OFF_L;
 399         else
 400                 reg = LED_N_OFF_L(pwm->hwpwm);
 401
 402         regmap_write(pca->regmap, reg, 0x0);
 403 }
 404
 405 static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
 406 {
 407         struct pca9685 *pca = to_pca(chip);
 408
 409         if (pca9685_pwm_is_gpio(pca, pwm))
 410                 return -EBUSY;
 411         pm_runtime_get_sync(chip->dev);
 412
 413         return 0;
 414 }
 415
 416 static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
 417 {
 418         pca9685_pwm_disable(chip, pwm);
 419         pm_runtime_put(chip->dev);
 420 }
 421
 422 static const struct pwm_ops pca9685_pwm_ops = {
 423         .enable = pca9685_pwm_enable,
 424         .disable = pca9685_pwm_disable,
 425         .config = pca9685_pwm_config,
 426         .request = pca9685_pwm_request,
 427         .free = pca9685_pwm_free,
 428         .owner = THIS_MODULE,
 429 };
 430
 431 static const struct regmap_config pca9685_regmap_i2c_config = {
 432         .reg_bits = 8,
 433         .val_bits = 8,
 434         .max_register = PCA9685_NUMREGS,
 435         .cache_type = REGCACHE_NONE,
 436 };
 437
 438 static int pca9685_pwm_probe(struct i2c_client *client,
 439                                 const struct i2c_device_id *id)
 440 {
 441         struct pca9685 *pca;
 442         int ret;
 443         int mode2;
 444
 445         pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL);
 446         if (!pca)
 447                 return -ENOMEM;
 448
 449         pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config);
 450         if (IS_ERR(pca->regmap)) {
 451                 ret = PTR_ERR(pca->regmap);
 452                 dev_err(&client->dev, "Failed to initialize register map: %d\n",
 453                         ret);
 454                 return ret;
 455         }
 456         pca->duty_ns = 0;
 457         pca->period_ns = PCA9685_DEFAULT_PERIOD;
 458
 459         i2c_set_clientdata(client, pca);
 460
 461         regmap_read(pca->regmap, PCA9685_MODE2, &mode2);
 462
 463         if (device_property_read_bool(&client->dev, "invert"))
 464                 mode2 |= MODE2_INVRT;
 465         else
 466                 mode2 &= ~MODE2_INVRT;
 467
 468         if (device_property_read_bool(&client->dev, "open-drain"))
 469                 mode2 &= ~MODE2_OUTDRV;
 470         else
 471                 mode2 |= MODE2_OUTDRV;
 472
 473         regmap_write(pca->regmap, PCA9685_MODE2, mode2);
 474
 475         /* clear all "full off" bits */
 476         regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_L, 0);
 477         regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_H, 0);
 478
 479         pca->chip.ops = &pca9685_pwm_ops;
 480         /* add an extra channel for ALL_LED */
 481         pca->chip.npwm = PCA9685_MAXCHAN + 1;
 482
 483         pca->chip.dev = &client->dev;
 484         pca->chip.base = -1;
 485
 486         ret = pwmchip_add(&pca->chip);
 487         if (ret < 0)
 488                 return ret;
 489
 490         ret = pca9685_pwm_gpio_probe(pca);
 491         if (ret < 0) {
 492                 pwmchip_remove(&pca->chip);
 493                 return ret;
 494         }
 495
 496         /* the chip comes out of power-up in the active state */
 497         pm_runtime_set_active(&client->dev);
 498         /*
 499          * enable will put the chip into suspend, which is what we
 500          * want as all outputs are disabled at this point
 501          */
 502         pm_runtime_enable(&client->dev);
 503
 504         return 0;
 505 }
 506
 507 static int pca9685_pwm_remove(struct i2c_client *client)
 508 {
 509         struct pca9685 *pca = i2c_get_clientdata(client);
 510         int ret;
 511
 512         ret = pwmchip_remove(&pca->chip);
 513         if (ret)
 514                 return ret;
 515         pm_runtime_disable(&client->dev);
 516         return 0;
 517 }
 518
 519 #ifdef CONFIG_PM
 520 static int pca9685_pwm_runtime_suspend(struct device *dev)
 521 {
 522         struct i2c_client *client = to_i2c_client(dev);
 523         struct pca9685 *pca = i2c_get_clientdata(client);
 524
 525         pca9685_set_sleep_mode(pca, true);
 526         return 0;
 527 }
 528
 529 static int pca9685_pwm_runtime_resume(struct device *dev)
 530 {
 531         struct i2c_client *client = to_i2c_client(dev);
 532         struct pca9685 *pca = i2c_get_clientdata(client);
 533
 534         pca9685_set_sleep_mode(pca, false);
 535         return 0;
 536 }
 537 #endif
 538
 539 static const struct i2c_device_id pca9685_id[] = {
 540         { "pca9685", 0 },
 541         { /* sentinel */ },
 542 };
 543 MODULE_DEVICE_TABLE(i2c, pca9685_id);
 544
 545 #ifdef CONFIG_ACPI
 546 static const struct acpi_device_id pca9685_acpi_ids[] = {
 547         { "INT3492", 0 },
 548         { /* sentinel */ },
 549 };
 550 MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids);
 551 #endif
 552
 553 #ifdef CONFIG_OF
 554 static const struct of_device_id pca9685_dt_ids[] = {
 555         { .compatible = "nxp,pca9685-pwm", },
 556         { /* sentinel */ }
 557 };
 558 MODULE_DEVICE_TABLE(of, pca9685_dt_ids);
 559 #endif
 560
 561 static const struct dev_pm_ops pca9685_pwm_pm = {
 562         SET_RUNTIME_PM_OPS(pca9685_pwm_runtime_suspend,
 563                            pca9685_pwm_runtime_resume, NULL)
 564 };
 565
 566 static struct i2c_driver pca9685_i2c_driver = {
 567         .driver = {
 568                 .name = "pca9685-pwm",
 569                 .acpi_match_table = ACPI_PTR(pca9685_acpi_ids),
 570                 .of_match_table = of_match_ptr(pca9685_dt_ids),
 571                 .pm = &pca9685_pwm_pm,
 572         },
 573         .probe = pca9685_pwm_probe,
 574         .remove = pca9685_pwm_remove,
 575         .id_table = pca9685_id,
 576 };
 577
 578 module_i2c_driver(pca9685_i2c_driver);
 579
 580 MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>");
 581 MODULE_DESCRIPTION("PWM driver for PCA9685");
 582 MODULE_LICENSE("GPL");