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 char reg; 302 enum pca9532_state ret; 303 304 mutex_lock(&data->update_lock); 305 reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id)); 306 ret = (reg & LED_MASK(led->id)) >> LED_SHIFT(led->id); 307 mutex_unlock(&data->update_lock); 308 return ret; 309 } 310 311 #ifdef CONFIG_LEDS_PCA9532_GPIO 312 static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset) 313 { 314 struct pca9532_data *data = gpiochip_get_data(gc); 315 struct pca9532_led *led = &data->leds[offset]; 316 317 if (led->type == PCA9532_TYPE_GPIO) 318 return 0; 319 320 return -EBUSY; 321 } 322 323 static int pca9532_gpio_set_value(struct gpio_chip *gc, unsigned int offset, 324 int val) 325 { 326 struct pca9532_data *data = gpiochip_get_data(gc); 327 struct pca9532_led *led = &data->leds[offset]; 328 329 if (val) 330 led->state = PCA9532_OFF; 331 else 332 led->state = PCA9532_ON; 333 334 pca9532_setled(led); 335 336 return 0; 337 } 338 339 static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset) 340 { 341 struct pca9532_data *data = gpiochip_get_data(gc); 342 unsigned char reg; 343 344 reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset)); 345 346 return !!(reg & (1 << (offset % 8))); 347 } 348 349 static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset) 350 { 351 /* To use as input ensure pin is not driven */ 352 pca9532_gpio_set_value(gc, offset, 1); 353 354 return 0; 355 } 356 357 static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val) 358 { 359 return pca9532_gpio_set_value(gc, offset, val); 360 } 361 #endif /* CONFIG_LEDS_PCA9532_GPIO */ 362 363 static void pca9532_destroy_devices(struct pca9532_data *data, int n_devs) 364 { 365 int i = n_devs; 366 367 while (--i >= 0) { 368 switch (data->leds[i].type) { 369 case PCA9532_TYPE_NONE: 370 case PCA9532_TYPE_GPIO: 371 break; 372 case PCA9532_TYPE_LED: 373 led_classdev_unregister(&data->leds[i].ldev); 374 break; 375 case PCA9532_TYPE_N2100_BEEP: 376 if (data->idev != NULL) { 377 cancel_work_sync(&data->work); 378 data->idev = NULL; 379 } 380 break; 381 } 382 } 383 384 #ifdef CONFIG_LEDS_PCA9532_GPIO 385 if (data->gpio.parent) 386 gpiochip_remove(&data->gpio); 387 #endif 388 } 389 390 static int pca9532_configure(struct i2c_client *client, 391 struct pca9532_data *data, struct pca9532_platform_data *pdata) 392 { 393 int i, err = 0; 394 int gpios = 0; 395 u8 maxleds = data->chip_info->num_leds; 396 397 for (i = 0; i < 2; i++) { 398 data->pwm[i] = pdata->pwm[i]; 399 data->psc[i] = pdata->psc[i]; 400 err = i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i), 401 data->pwm[i]); 402 if (err < 0) 403 return err; 404 err = i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i), 405 data->psc[i]); 406 if (err < 0) 407 return err; 408 } 409 410 data->hw_blink = true; 411 for (i = 0; i < data->chip_info->num_leds; i++) { 412 struct pca9532_led *led = &data->leds[i]; 413 struct pca9532_led *pled = &pdata->leds[i]; 414 led->client = client; 415 led->id = i; 416 led->type = pled->type; 417 switch (led->type) { 418 case PCA9532_TYPE_NONE: 419 break; 420 case PCA9532_TYPE_GPIO: 421 gpios++; 422 break; 423 case PCA9532_TYPE_LED: 424 if (pled->state == PCA9532_KEEP) 425 led->state = pca9532_getled(led); 426 else 427 led->state = pled->state; 428 led->name = pled->name; 429 led->ldev.name = led->name; 430 led->ldev.default_trigger = pled->default_trigger; 431 led->ldev.brightness = LED_OFF; 432 led->ldev.brightness_set_blocking = 433 pca9532_set_brightness; 434 led->ldev.blink_set = pca9532_set_blink; 435 err = led_classdev_register(&client->dev, &led->ldev); 436 if (err < 0) { 437 dev_err(&client->dev, 438 "couldn't register LED %s\n", 439 led->name); 440 goto exit; 441 } 442 pca9532_setled(led); 443 break; 444 case PCA9532_TYPE_N2100_BEEP: 445 /* PWM1 is reserved for beeper so blink will not use hardware */ 446 data->hw_blink = false; 447 BUG_ON(data->idev); 448 led->state = PCA9532_PWM1; 449 pca9532_setled(led); 450 data->idev = devm_input_allocate_device(&client->dev); 451 if (data->idev == NULL) { 452 err = -ENOMEM; 453 goto exit; 454 } 455 data->idev->name = pled->name; 456 data->idev->phys = "i2c/pca9532"; 457 data->idev->id.bustype = BUS_HOST; 458 data->idev->id.vendor = 0x001f; 459 data->idev->id.product = 0x0001; 460 data->idev->id.version = 0x0100; 461 data->idev->evbit[0] = BIT_MASK(EV_SND); 462 data->idev->sndbit[0] = BIT_MASK(SND_BELL) | 463 BIT_MASK(SND_TONE); 464 data->idev->event = pca9532_event; 465 input_set_drvdata(data->idev, data); 466 INIT_WORK(&data->work, pca9532_input_work); 467 err = input_register_device(data->idev); 468 if (err) { 469 cancel_work_sync(&data->work); 470 data->idev = NULL; 471 goto exit; 472 } 473 break; 474 } 475 } 476 477 #ifdef CONFIG_LEDS_PCA9532_GPIO 478 if (gpios) { 479 data->gpio.label = "gpio-pca9532"; 480 data->gpio.direction_input = pca9532_gpio_direction_input; 481 data->gpio.direction_output = pca9532_gpio_direction_output; 482 data->gpio.set = pca9532_gpio_set_value; 483 data->gpio.get = pca9532_gpio_get_value; 484 data->gpio.request = pca9532_gpio_request_pin; 485 data->gpio.can_sleep = 1; 486 data->gpio.base = pdata->gpio_base; 487 data->gpio.ngpio = data->chip_info->num_leds; 488 data->gpio.parent = &client->dev; 489 data->gpio.owner = THIS_MODULE; 490 491 err = gpiochip_add_data(&data->gpio, data); 492 if (err) { 493 /* Use data->gpio.dev as a flag for freeing gpiochip */ 494 data->gpio.parent = NULL; 495 dev_warn(&client->dev, "could not add gpiochip\n"); 496 } else { 497 dev_info(&client->dev, "gpios %i...%i\n", 498 data->gpio.base, data->gpio.base + 499 data->gpio.ngpio - 1); 500 } 501 } 502 #endif 503 504 return 0; 505 506 exit: 507 pca9532_destroy_devices(data, i); 508 return err; 509 } 510 511 static struct pca9532_platform_data * 512 pca9532_of_populate_pdata(struct device *dev, struct device_node *np) 513 { 514 struct pca9532_platform_data *pdata; 515 int devid, maxleds; 516 int i = 0; 517 const char *state; 518 519 devid = (int)(uintptr_t)of_device_get_match_data(dev); 520 maxleds = pca9532_chip_info_tbl[devid].num_leds; 521 522 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 523 if (!pdata) 524 return ERR_PTR(-ENOMEM); 525 526 pdata->gpio_base = -1; 527 528 of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[PCA9532_PWM_ID_0], 529 ARRAY_SIZE(pdata->pwm)); 530 of_property_read_u8_array(np, "nxp,psc", &pdata->psc[PCA9532_PWM_ID_0], 531 ARRAY_SIZE(pdata->psc)); 532 533 for_each_available_child_of_node_scoped(np, child) { 534 if (of_property_read_string(child, "label", 535 &pdata->leds[i].name)) 536 pdata->leds[i].name = child->name; 537 of_property_read_u32(child, "type", &pdata->leds[i].type); 538 of_property_read_string(child, "linux,default-trigger", 539 &pdata->leds[i].default_trigger); 540 if (!of_property_read_string(child, "default-state", &state)) { 541 if (!strcmp(state, "on")) 542 pdata->leds[i].state = PCA9532_ON; 543 else if (!strcmp(state, "keep")) 544 pdata->leds[i].state = PCA9532_KEEP; 545 } 546 if (++i >= maxleds) 547 break; 548 } 549 550 return pdata; 551 } 552 553 static int pca9532_probe(struct i2c_client *client) 554 { 555 const struct i2c_device_id *id = i2c_client_get_device_id(client); 556 int devid; 557 struct pca9532_data *data = i2c_get_clientdata(client); 558 struct pca9532_platform_data *pca9532_pdata = 559 dev_get_platdata(&client->dev); 560 struct device_node *np = dev_of_node(&client->dev); 561 562 if (!pca9532_pdata) { 563 if (np) { 564 pca9532_pdata = 565 pca9532_of_populate_pdata(&client->dev, np); 566 if (IS_ERR(pca9532_pdata)) 567 return PTR_ERR(pca9532_pdata); 568 } else { 569 dev_err(&client->dev, "no platform data\n"); 570 return -EINVAL; 571 } 572 devid = (int)(uintptr_t)of_device_get_match_data(&client->dev); 573 } else { 574 devid = id->driver_data; 575 } 576 577 if (!i2c_check_functionality(client->adapter, 578 I2C_FUNC_SMBUS_BYTE_DATA)) 579 return -EIO; 580 581 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 582 if (!data) 583 return -ENOMEM; 584 585 data->chip_info = &pca9532_chip_info_tbl[devid]; 586 587 dev_info(&client->dev, "setting platform data\n"); 588 i2c_set_clientdata(client, data); 589 data->client = client; 590 mutex_init(&data->update_lock); 591 592 return pca9532_configure(client, data, pca9532_pdata); 593 } 594 595 static void pca9532_remove(struct i2c_client *client) 596 { 597 struct pca9532_data *data = i2c_get_clientdata(client); 598 599 pca9532_destroy_devices(data, data->chip_info->num_leds); 600 } 601 602 module_i2c_driver(pca9532_driver); 603 604 MODULE_AUTHOR("Riku Voipio"); 605 MODULE_LICENSE("GPL"); 606 MODULE_DESCRIPTION("PCA 9532 LED dimmer"); 607