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_ON; 331 else 332 led->state = PCA9532_OFF; 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, 0); 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 i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i), 401 data->pwm[i]); 402 i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i), 403 data->psc[i]); 404 } 405 406 data->hw_blink = true; 407 for (i = 0; i < data->chip_info->num_leds; i++) { 408 struct pca9532_led *led = &data->leds[i]; 409 struct pca9532_led *pled = &pdata->leds[i]; 410 led->client = client; 411 led->id = i; 412 led->type = pled->type; 413 switch (led->type) { 414 case PCA9532_TYPE_NONE: 415 break; 416 case PCA9532_TYPE_GPIO: 417 gpios++; 418 break; 419 case PCA9532_TYPE_LED: 420 if (pled->state == PCA9532_KEEP) 421 led->state = pca9532_getled(led); 422 else 423 led->state = pled->state; 424 led->name = pled->name; 425 led->ldev.name = led->name; 426 led->ldev.default_trigger = pled->default_trigger; 427 led->ldev.brightness = LED_OFF; 428 led->ldev.brightness_set_blocking = 429 pca9532_set_brightness; 430 led->ldev.blink_set = pca9532_set_blink; 431 err = led_classdev_register(&client->dev, &led->ldev); 432 if (err < 0) { 433 dev_err(&client->dev, 434 "couldn't register LED %s\n", 435 led->name); 436 goto exit; 437 } 438 pca9532_setled(led); 439 break; 440 case PCA9532_TYPE_N2100_BEEP: 441 /* PWM1 is reserved for beeper so blink will not use hardware */ 442 data->hw_blink = false; 443 BUG_ON(data->idev); 444 led->state = PCA9532_PWM1; 445 pca9532_setled(led); 446 data->idev = devm_input_allocate_device(&client->dev); 447 if (data->idev == NULL) { 448 err = -ENOMEM; 449 goto exit; 450 } 451 data->idev->name = pled->name; 452 data->idev->phys = "i2c/pca9532"; 453 data->idev->id.bustype = BUS_HOST; 454 data->idev->id.vendor = 0x001f; 455 data->idev->id.product = 0x0001; 456 data->idev->id.version = 0x0100; 457 data->idev->evbit[0] = BIT_MASK(EV_SND); 458 data->idev->sndbit[0] = BIT_MASK(SND_BELL) | 459 BIT_MASK(SND_TONE); 460 data->idev->event = pca9532_event; 461 input_set_drvdata(data->idev, data); 462 INIT_WORK(&data->work, pca9532_input_work); 463 err = input_register_device(data->idev); 464 if (err) { 465 cancel_work_sync(&data->work); 466 data->idev = NULL; 467 goto exit; 468 } 469 break; 470 } 471 } 472 473 #ifdef CONFIG_LEDS_PCA9532_GPIO 474 if (gpios) { 475 data->gpio.label = "gpio-pca9532"; 476 data->gpio.direction_input = pca9532_gpio_direction_input; 477 data->gpio.direction_output = pca9532_gpio_direction_output; 478 data->gpio.set = pca9532_gpio_set_value; 479 data->gpio.get = pca9532_gpio_get_value; 480 data->gpio.request = pca9532_gpio_request_pin; 481 data->gpio.can_sleep = 1; 482 data->gpio.base = pdata->gpio_base; 483 data->gpio.ngpio = data->chip_info->num_leds; 484 data->gpio.parent = &client->dev; 485 data->gpio.owner = THIS_MODULE; 486 487 err = gpiochip_add_data(&data->gpio, data); 488 if (err) { 489 /* Use data->gpio.dev as a flag for freeing gpiochip */ 490 data->gpio.parent = NULL; 491 dev_warn(&client->dev, "could not add gpiochip\n"); 492 } else { 493 dev_info(&client->dev, "gpios %i...%i\n", 494 data->gpio.base, data->gpio.base + 495 data->gpio.ngpio - 1); 496 } 497 } 498 #endif 499 500 return 0; 501 502 exit: 503 pca9532_destroy_devices(data, i); 504 return err; 505 } 506 507 static struct pca9532_platform_data * 508 pca9532_of_populate_pdata(struct device *dev, struct device_node *np) 509 { 510 struct pca9532_platform_data *pdata; 511 int devid, maxleds; 512 int i = 0; 513 const char *state; 514 515 devid = (int)(uintptr_t)of_device_get_match_data(dev); 516 maxleds = pca9532_chip_info_tbl[devid].num_leds; 517 518 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 519 if (!pdata) 520 return ERR_PTR(-ENOMEM); 521 522 pdata->gpio_base = -1; 523 524 of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[PCA9532_PWM_ID_0], 525 ARRAY_SIZE(pdata->pwm)); 526 of_property_read_u8_array(np, "nxp,psc", &pdata->psc[PCA9532_PWM_ID_0], 527 ARRAY_SIZE(pdata->psc)); 528 529 for_each_available_child_of_node_scoped(np, child) { 530 if (of_property_read_string(child, "label", 531 &pdata->leds[i].name)) 532 pdata->leds[i].name = child->name; 533 of_property_read_u32(child, "type", &pdata->leds[i].type); 534 of_property_read_string(child, "linux,default-trigger", 535 &pdata->leds[i].default_trigger); 536 if (!of_property_read_string(child, "default-state", &state)) { 537 if (!strcmp(state, "on")) 538 pdata->leds[i].state = PCA9532_ON; 539 else if (!strcmp(state, "keep")) 540 pdata->leds[i].state = PCA9532_KEEP; 541 } 542 if (++i >= maxleds) 543 break; 544 } 545 546 return pdata; 547 } 548 549 static int pca9532_probe(struct i2c_client *client) 550 { 551 const struct i2c_device_id *id = i2c_client_get_device_id(client); 552 int devid; 553 struct pca9532_data *data = i2c_get_clientdata(client); 554 struct pca9532_platform_data *pca9532_pdata = 555 dev_get_platdata(&client->dev); 556 struct device_node *np = dev_of_node(&client->dev); 557 558 if (!pca9532_pdata) { 559 if (np) { 560 pca9532_pdata = 561 pca9532_of_populate_pdata(&client->dev, np); 562 if (IS_ERR(pca9532_pdata)) 563 return PTR_ERR(pca9532_pdata); 564 } else { 565 dev_err(&client->dev, "no platform data\n"); 566 return -EINVAL; 567 } 568 devid = (int)(uintptr_t)of_device_get_match_data(&client->dev); 569 } else { 570 devid = id->driver_data; 571 } 572 573 if (!i2c_check_functionality(client->adapter, 574 I2C_FUNC_SMBUS_BYTE_DATA)) 575 return -EIO; 576 577 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 578 if (!data) 579 return -ENOMEM; 580 581 data->chip_info = &pca9532_chip_info_tbl[devid]; 582 583 dev_info(&client->dev, "setting platform data\n"); 584 i2c_set_clientdata(client, data); 585 data->client = client; 586 mutex_init(&data->update_lock); 587 588 return pca9532_configure(client, data, pca9532_pdata); 589 } 590 591 static void pca9532_remove(struct i2c_client *client) 592 { 593 struct pca9532_data *data = i2c_get_clientdata(client); 594 595 pca9532_destroy_devices(data, data->chip_info->num_leds); 596 } 597 598 module_i2c_driver(pca9532_driver); 599 600 MODULE_AUTHOR("Riku Voipio"); 601 MODULE_LICENSE("GPL"); 602 MODULE_DESCRIPTION("PCA 9532 LED dimmer"); 603