1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * pca9532.c - 16-bit Led dimmer 4 * 5 * Copyright (C) 2011 Jan Weitzel 6 * Copyright (C) 2008 Riku Voipio 7 * 8 * Datasheet: http://www.nxp.com/documents/data_sheet/PCA9532.pdf 9 */ 10 11 #include <linux/module.h> 12 #include <linux/i2c.h> 13 #include <linux/slab.h> 14 #include <linux/leds.h> 15 #include <linux/input.h> 16 #include <linux/mutex.h> 17 #include <linux/workqueue.h> 18 #include <linux/leds-pca9532.h> 19 #include <linux/gpio/driver.h> 20 #include <linux/of.h> 21 22 /* m = num_leds*/ 23 #define PCA9532_REG_INPUT(i) ((i) >> 3) 24 #define PCA9532_REG_OFFSET(m) ((m) >> 4) 25 #define PCA9532_REG_PSC(m, i) (PCA9532_REG_OFFSET(m) + 0x1 + (i) * 2) 26 #define PCA9532_REG_PWM(m, i) (PCA9532_REG_OFFSET(m) + 0x2 + (i) * 2) 27 #define LED_REG(m, led) (PCA9532_REG_OFFSET(m) + 0x5 + (led >> 2)) 28 #define LED_NUM(led) (led & 0x3) 29 #define LED_SHIFT(led) (LED_NUM(led) * 2) 30 #define LED_MASK(led) (0x3 << LED_SHIFT(led)) 31 32 #define PCA9532_PWM_PERIOD_DIV 152 33 #define PCA9532_PWM_DUTY_DIV 256 34 35 #define ldev_to_led(c) container_of(c, struct pca9532_led, ldev) 36 37 struct pca9532_chip_info { 38 u8 num_leds; 39 }; 40 41 struct pca9532_data { 42 struct i2c_client *client; 43 struct pca9532_led leds[16]; 44 struct mutex update_lock; 45 struct input_dev *idev; 46 struct work_struct work; 47 #ifdef CONFIG_LEDS_PCA9532_GPIO 48 struct gpio_chip gpio; 49 #endif 50 const struct pca9532_chip_info *chip_info; 51 52 #define PCA9532_PWM_ID_0 0 53 #define PCA9532_PWM_ID_1 1 54 u8 pwm[2]; 55 u8 psc[2]; 56 bool hw_blink; 57 }; 58 59 static int pca9532_probe(struct i2c_client *client); 60 static void pca9532_remove(struct i2c_client *client); 61 62 enum { 63 pca9530, 64 pca9531, 65 pca9532, 66 pca9533, 67 }; 68 69 static const struct i2c_device_id pca9532_id[] = { 70 { .name = "pca9530", .driver_data = pca9530 }, 71 { .name = "pca9531", .driver_data = pca9531 }, 72 { .name = "pca9532", .driver_data = pca9532 }, 73 { .name = "pca9533", .driver_data = pca9533 }, 74 { } 75 }; 76 77 MODULE_DEVICE_TABLE(i2c, pca9532_id); 78 79 static const struct pca9532_chip_info pca9532_chip_info_tbl[] = { 80 [pca9530] = { 81 .num_leds = 2, 82 }, 83 [pca9531] = { 84 .num_leds = 8, 85 }, 86 [pca9532] = { 87 .num_leds = 16, 88 }, 89 [pca9533] = { 90 .num_leds = 4, 91 }, 92 }; 93 94 #ifdef CONFIG_OF 95 static const struct of_device_id of_pca9532_leds_match[] = { 96 { .compatible = "nxp,pca9530", .data = (void *)pca9530 }, 97 { .compatible = "nxp,pca9531", .data = (void *)pca9531 }, 98 { .compatible = "nxp,pca9532", .data = (void *)pca9532 }, 99 { .compatible = "nxp,pca9533", .data = (void *)pca9533 }, 100 {}, 101 }; 102 103 MODULE_DEVICE_TABLE(of, of_pca9532_leds_match); 104 #endif 105 106 static struct i2c_driver pca9532_driver = { 107 .driver = { 108 .name = "leds-pca953x", 109 .of_match_table = of_match_ptr(of_pca9532_leds_match), 110 }, 111 .probe = pca9532_probe, 112 .remove = pca9532_remove, 113 .id_table = pca9532_id, 114 }; 115 116 /* We have two pwm/blinkers, but 16 possible leds to drive. Additionally, 117 * the clever Thecus people are using one pwm to drive the beeper. So, 118 * as a compromise we average one pwm to the values requested by all 119 * leds that are not ON/OFF. 120 * */ 121 static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink, 122 enum led_brightness value) 123 { 124 int a = 0, b = 0, i = 0; 125 struct pca9532_data *data = i2c_get_clientdata(client); 126 for (i = 0; i < data->chip_info->num_leds; i++) { 127 if (data->leds[i].type == PCA9532_TYPE_LED && 128 data->leds[i].state == PCA9532_PWM0+pwm) { 129 a++; 130 b += data->leds[i].ldev.brightness; 131 } 132 } 133 if (a == 0) { 134 dev_err(&client->dev, 135 "fear of division by zero %d/%d, wanted %d\n", 136 b, a, value); 137 return -EINVAL; 138 } 139 b = b/a; 140 if (b > 0xFF) 141 return -EINVAL; 142 data->pwm[pwm] = b; 143 data->psc[pwm] = blink; 144 return 0; 145 } 146 147 static int pca9532_setpwm(struct i2c_client *client, int pwm) 148 { 149 struct pca9532_data *data = i2c_get_clientdata(client); 150 u8 maxleds = data->chip_info->num_leds; 151 152 mutex_lock(&data->update_lock); 153 i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm), 154 data->pwm[pwm]); 155 i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm), 156 data->psc[pwm]); 157 mutex_unlock(&data->update_lock); 158 return 0; 159 } 160 161 /* Set LED routing */ 162 static void pca9532_setled(struct pca9532_led *led) 163 { 164 struct i2c_client *client = led->client; 165 struct pca9532_data *data = i2c_get_clientdata(client); 166 u8 maxleds = data->chip_info->num_leds; 167 char reg; 168 169 mutex_lock(&data->update_lock); 170 reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id)); 171 /* zero led bits */ 172 reg = reg & ~LED_MASK(led->id); 173 /* set the new value */ 174 reg = reg | (led->state << LED_SHIFT(led->id)); 175 i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg); 176 mutex_unlock(&data->update_lock); 177 } 178 179 static int pca9532_set_brightness(struct led_classdev *led_cdev, 180 enum led_brightness value) 181 { 182 int err = 0; 183 struct pca9532_led *led = ldev_to_led(led_cdev); 184 185 if (value == LED_OFF) { 186 led->state = PCA9532_OFF; 187 } else if (led->state == PCA9532_PWM1) { 188 return 0; /* Non-zero brightness shall not stop HW blinking */ 189 } else if (value == LED_FULL) { 190 led->state = PCA9532_ON; 191 } else { 192 led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */ 193 err = pca9532_calcpwm(led->client, PCA9532_PWM_ID_0, 0, value); 194 if (err) 195 return err; 196 } 197 if (led->state == PCA9532_PWM0) 198 pca9532_setpwm(led->client, PCA9532_PWM_ID_0); 199 pca9532_setled(led); 200 return err; 201 } 202 203 static int pca9532_update_hw_blink(struct pca9532_led *led, 204 unsigned long delay_on, unsigned long delay_off) 205 { 206 struct pca9532_data *data = i2c_get_clientdata(led->client); 207 unsigned int psc; 208 int i; 209 210 /* Look for others LEDs that already use PWM1 */ 211 for (i = 0; i < data->chip_info->num_leds; i++) { 212 struct pca9532_led *other = &data->leds[i]; 213 214 if (other == led) 215 continue; 216 217 if (other->state == PCA9532_PWM1) { 218 if (other->ldev.blink_delay_on != delay_on || 219 other->ldev.blink_delay_off != delay_off) { 220 /* HW can handle only one blink configuration at a time */ 221 return -EINVAL; 222 } 223 } 224 } 225 226 psc = ((delay_on + delay_off) * PCA9532_PWM_PERIOD_DIV - 1) / 1000; 227 if (psc > U8_MAX) { 228 /* Blink period too long to be handled by hardware */ 229 return -EINVAL; 230 } 231 232 led->state = PCA9532_PWM1; 233 data->psc[PCA9532_PWM_ID_1] = psc; 234 data->pwm[PCA9532_PWM_ID_1] = (delay_on * PCA9532_PWM_DUTY_DIV) / (delay_on + delay_off); 235 236 return pca9532_setpwm(data->client, PCA9532_PWM_ID_1); 237 } 238 239 static int pca9532_set_blink(struct led_classdev *led_cdev, 240 unsigned long *delay_on, unsigned long *delay_off) 241 { 242 struct pca9532_led *led = ldev_to_led(led_cdev); 243 struct i2c_client *client = led->client; 244 struct pca9532_data *data = i2c_get_clientdata(client); 245 int err; 246 247 if (!data->hw_blink) 248 return -EINVAL; 249 250 if (*delay_on == 0 && *delay_off == 0) { 251 /* led subsystem ask us for a blink rate */ 252 *delay_on = 500; 253 *delay_off = 500; 254 } 255 256 err = pca9532_update_hw_blink(led, *delay_on, *delay_off); 257 if (err) 258 return err; 259 260 pca9532_setled(led); 261 262 return 0; 263 } 264 265 static int pca9532_event(struct input_dev *dev, unsigned int type, 266 unsigned int code, int value) 267 { 268 struct pca9532_data *data = input_get_drvdata(dev); 269 270 if (!(type == EV_SND && (code == SND_BELL || code == SND_TONE))) 271 return -1; 272 273 /* XXX: allow different kind of beeps with psc/pwm modifications */ 274 if (value > 1 && value < 32767) 275 data->pwm[PCA9532_PWM_ID_1] = 127; 276 else 277 data->pwm[PCA9532_PWM_ID_1] = 0; 278 279 schedule_work(&data->work); 280 281 return 0; 282 } 283 284 static void pca9532_input_work(struct work_struct *work) 285 { 286 struct pca9532_data *data = 287 container_of(work, struct pca9532_data, work); 288 u8 maxleds = data->chip_info->num_leds; 289 290 mutex_lock(&data->update_lock); 291 i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(maxleds, 1), 292 data->pwm[PCA9532_PWM_ID_1]); 293 mutex_unlock(&data->update_lock); 294 } 295 296 static enum pca9532_state pca9532_getled(struct pca9532_led *led) 297 { 298 struct i2c_client *client = led->client; 299 struct pca9532_data *data = i2c_get_clientdata(client); 300 u8 maxleds = data->chip_info->num_leds; 301 int reg; 302 enum pca9532_state ret = PCA9532_OFF; 303 304 mutex_lock(&data->update_lock); 305 reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id)); 306 if (reg >= 0) 307 ret = (reg & LED_MASK(led->id)) >> LED_SHIFT(led->id); 308 else 309 dev_warn(&client->dev, "failed to read LED register: %d\n", reg); 310 mutex_unlock(&data->update_lock); 311 return ret; 312 } 313 314 #ifdef CONFIG_LEDS_PCA9532_GPIO 315 static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset) 316 { 317 struct pca9532_data *data = gpiochip_get_data(gc); 318 struct pca9532_led *led = &data->leds[offset]; 319 320 if (led->type == PCA9532_TYPE_GPIO) 321 return 0; 322 323 return -EBUSY; 324 } 325 326 static int pca9532_gpio_set_value(struct gpio_chip *gc, unsigned int offset, 327 int val) 328 { 329 struct pca9532_data *data = gpiochip_get_data(gc); 330 struct pca9532_led *led = &data->leds[offset]; 331 332 if (val) 333 led->state = PCA9532_OFF; 334 else 335 led->state = PCA9532_ON; 336 337 pca9532_setled(led); 338 339 return 0; 340 } 341 342 static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset) 343 { 344 struct pca9532_data *data = gpiochip_get_data(gc); 345 unsigned char reg; 346 347 reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset)); 348 349 return !!(reg & (1 << (offset % 8))); 350 } 351 352 static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset) 353 { 354 /* To use as input ensure pin is not driven */ 355 pca9532_gpio_set_value(gc, offset, 1); 356 357 return 0; 358 } 359 360 static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val) 361 { 362 return pca9532_gpio_set_value(gc, offset, val); 363 } 364 #endif /* CONFIG_LEDS_PCA9532_GPIO */ 365 366 static void pca9532_destroy_devices(struct pca9532_data *data, int n_devs) 367 { 368 int i = n_devs; 369 370 while (--i >= 0) { 371 switch (data->leds[i].type) { 372 case PCA9532_TYPE_NONE: 373 case PCA9532_TYPE_GPIO: 374 break; 375 case PCA9532_TYPE_LED: 376 led_classdev_unregister(&data->leds[i].ldev); 377 break; 378 case PCA9532_TYPE_N2100_BEEP: 379 if (data->idev != NULL) { 380 cancel_work_sync(&data->work); 381 data->idev = NULL; 382 } 383 break; 384 } 385 } 386 387 #ifdef CONFIG_LEDS_PCA9532_GPIO 388 if (data->gpio.parent) 389 gpiochip_remove(&data->gpio); 390 #endif 391 } 392 393 static int pca9532_configure(struct i2c_client *client, 394 struct pca9532_data *data, struct pca9532_platform_data *pdata) 395 { 396 int i, err = 0; 397 int gpios = 0; 398 u8 maxleds = data->chip_info->num_leds; 399 400 for (i = 0; i < 2; i++) { 401 data->pwm[i] = pdata->pwm[i]; 402 data->psc[i] = pdata->psc[i]; 403 err = i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i), 404 data->pwm[i]); 405 if (err < 0) 406 return err; 407 err = i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i), 408 data->psc[i]); 409 if (err < 0) 410 return err; 411 } 412 413 data->hw_blink = true; 414 for (i = 0; i < data->chip_info->num_leds; i++) { 415 struct pca9532_led *led = &data->leds[i]; 416 struct pca9532_led *pled = &pdata->leds[i]; 417 led->client = client; 418 led->id = i; 419 led->type = pled->type; 420 switch (led->type) { 421 case PCA9532_TYPE_NONE: 422 break; 423 case PCA9532_TYPE_GPIO: 424 gpios++; 425 break; 426 case PCA9532_TYPE_LED: 427 if (pled->state == PCA9532_KEEP) 428 led->state = pca9532_getled(led); 429 else 430 led->state = pled->state; 431 led->name = pled->name; 432 led->ldev.name = led->name; 433 led->ldev.default_trigger = pled->default_trigger; 434 led->ldev.brightness = LED_OFF; 435 led->ldev.brightness_set_blocking = 436 pca9532_set_brightness; 437 led->ldev.blink_set = pca9532_set_blink; 438 err = led_classdev_register(&client->dev, &led->ldev); 439 if (err < 0) { 440 dev_err(&client->dev, 441 "couldn't register LED %s\n", 442 led->name); 443 goto exit; 444 } 445 pca9532_setled(led); 446 break; 447 case PCA9532_TYPE_N2100_BEEP: 448 /* PWM1 is reserved for beeper so blink will not use hardware */ 449 data->hw_blink = false; 450 BUG_ON(data->idev); 451 led->state = PCA9532_PWM1; 452 pca9532_setled(led); 453 data->idev = devm_input_allocate_device(&client->dev); 454 if (data->idev == NULL) { 455 err = -ENOMEM; 456 goto exit; 457 } 458 data->idev->name = pled->name; 459 data->idev->phys = "i2c/pca9532"; 460 data->idev->id.bustype = BUS_HOST; 461 data->idev->id.vendor = 0x001f; 462 data->idev->id.product = 0x0001; 463 data->idev->id.version = 0x0100; 464 data->idev->evbit[0] = BIT_MASK(EV_SND); 465 data->idev->sndbit[0] = BIT_MASK(SND_BELL) | 466 BIT_MASK(SND_TONE); 467 data->idev->event = pca9532_event; 468 input_set_drvdata(data->idev, data); 469 INIT_WORK(&data->work, pca9532_input_work); 470 err = input_register_device(data->idev); 471 if (err) { 472 cancel_work_sync(&data->work); 473 data->idev = NULL; 474 goto exit; 475 } 476 break; 477 } 478 } 479 480 #ifdef CONFIG_LEDS_PCA9532_GPIO 481 if (gpios) { 482 data->gpio.label = "gpio-pca9532"; 483 data->gpio.direction_input = pca9532_gpio_direction_input; 484 data->gpio.direction_output = pca9532_gpio_direction_output; 485 data->gpio.set = pca9532_gpio_set_value; 486 data->gpio.get = pca9532_gpio_get_value; 487 data->gpio.request = pca9532_gpio_request_pin; 488 data->gpio.can_sleep = 1; 489 data->gpio.base = pdata->gpio_base; 490 data->gpio.ngpio = data->chip_info->num_leds; 491 data->gpio.parent = &client->dev; 492 data->gpio.owner = THIS_MODULE; 493 494 err = gpiochip_add_data(&data->gpio, data); 495 if (err) { 496 /* Use data->gpio.dev as a flag for freeing gpiochip */ 497 data->gpio.parent = NULL; 498 dev_warn(&client->dev, "could not add gpiochip\n"); 499 } else { 500 dev_info(&client->dev, "gpios %i...%i\n", 501 data->gpio.base, data->gpio.base + 502 data->gpio.ngpio - 1); 503 } 504 } 505 #endif 506 507 return 0; 508 509 exit: 510 pca9532_destroy_devices(data, i); 511 return err; 512 } 513 514 static struct pca9532_platform_data * 515 pca9532_of_populate_pdata(struct device *dev, struct device_node *np) 516 { 517 struct pca9532_platform_data *pdata; 518 int devid, maxleds; 519 int i = 0; 520 const char *state; 521 522 devid = (int)(uintptr_t)of_device_get_match_data(dev); 523 maxleds = pca9532_chip_info_tbl[devid].num_leds; 524 525 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 526 if (!pdata) 527 return ERR_PTR(-ENOMEM); 528 529 pdata->gpio_base = -1; 530 531 of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[PCA9532_PWM_ID_0], 532 ARRAY_SIZE(pdata->pwm)); 533 of_property_read_u8_array(np, "nxp,psc", &pdata->psc[PCA9532_PWM_ID_0], 534 ARRAY_SIZE(pdata->psc)); 535 536 for_each_available_child_of_node_scoped(np, child) { 537 if (of_property_read_string(child, "label", 538 &pdata->leds[i].name)) 539 pdata->leds[i].name = child->name; 540 of_property_read_u32(child, "type", &pdata->leds[i].type); 541 of_property_read_string(child, "linux,default-trigger", 542 &pdata->leds[i].default_trigger); 543 if (!of_property_read_string(child, "default-state", &state)) { 544 if (!strcmp(state, "on")) 545 pdata->leds[i].state = PCA9532_ON; 546 else if (!strcmp(state, "keep")) 547 pdata->leds[i].state = PCA9532_KEEP; 548 } 549 if (++i >= maxleds) 550 break; 551 } 552 553 return pdata; 554 } 555 556 static int pca9532_probe(struct i2c_client *client) 557 { 558 const struct i2c_device_id *id = i2c_client_get_device_id(client); 559 int devid; 560 struct pca9532_data *data = i2c_get_clientdata(client); 561 struct pca9532_platform_data *pca9532_pdata = 562 dev_get_platdata(&client->dev); 563 struct device_node *np = dev_of_node(&client->dev); 564 565 if (!pca9532_pdata) { 566 if (np) { 567 pca9532_pdata = 568 pca9532_of_populate_pdata(&client->dev, np); 569 if (IS_ERR(pca9532_pdata)) 570 return PTR_ERR(pca9532_pdata); 571 } else { 572 dev_err(&client->dev, "no platform data\n"); 573 return -EINVAL; 574 } 575 devid = (int)(uintptr_t)of_device_get_match_data(&client->dev); 576 } else { 577 devid = id->driver_data; 578 } 579 580 if (!i2c_check_functionality(client->adapter, 581 I2C_FUNC_SMBUS_BYTE_DATA)) 582 return -EIO; 583 584 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 585 if (!data) 586 return -ENOMEM; 587 588 data->chip_info = &pca9532_chip_info_tbl[devid]; 589 590 dev_info(&client->dev, "setting platform data\n"); 591 i2c_set_clientdata(client, data); 592 data->client = client; 593 mutex_init(&data->update_lock); 594 595 return pca9532_configure(client, data, pca9532_pdata); 596 } 597 598 static void pca9532_remove(struct i2c_client *client) 599 { 600 struct pca9532_data *data = i2c_get_clientdata(client); 601 602 pca9532_destroy_devices(data, data->chip_info->num_leds); 603 } 604 605 module_i2c_driver(pca9532_driver); 606 607 MODULE_AUTHOR("Riku Voipio"); 608 MODULE_LICENSE("GPL"); 609 MODULE_DESCRIPTION("PCA 9532 LED dimmer"); 610