leds-pca9532.c 14 KB

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