leds-tlc591xx.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright 2014 Belkin Inc.
  4. * Copyright 2015 Andrew Lunn <[email protected]>
  5. */
  6. #include <linux/i2c.h>
  7. #include <linux/leds.h>
  8. #include <linux/module.h>
  9. #include <linux/of.h>
  10. #include <linux/of_device.h>
  11. #include <linux/regmap.h>
  12. #include <linux/slab.h>
  13. #define TLC591XX_MAX_LEDS 16
  14. #define TLC591XX_MAX_BRIGHTNESS 256
  15. #define TLC591XX_REG_MODE1 0x00
  16. #define MODE1_RESPON_ADDR_MASK 0xF0
  17. #define MODE1_NORMAL_MODE (0 << 4)
  18. #define MODE1_SPEED_MODE (1 << 4)
  19. #define TLC591XX_REG_MODE2 0x01
  20. #define MODE2_DIM (0 << 5)
  21. #define MODE2_BLINK (1 << 5)
  22. #define MODE2_OCH_STOP (0 << 3)
  23. #define MODE2_OCH_ACK (1 << 3)
  24. #define TLC591XX_REG_PWM(x) (0x02 + (x))
  25. #define TLC591XX_REG_GRPPWM 0x12
  26. #define TLC591XX_REG_GRPFREQ 0x13
  27. /* LED Driver Output State, determine the source that drives LED outputs */
  28. #define LEDOUT_OFF 0x0 /* Output LOW */
  29. #define LEDOUT_ON 0x1 /* Output HI-Z */
  30. #define LEDOUT_DIM 0x2 /* Dimming */
  31. #define LEDOUT_BLINK 0x3 /* Blinking */
  32. #define LEDOUT_MASK 0x3
  33. #define ldev_to_led(c) container_of(c, struct tlc591xx_led, ldev)
  34. struct tlc591xx_led {
  35. bool active;
  36. unsigned int led_no;
  37. struct led_classdev ldev;
  38. struct tlc591xx_priv *priv;
  39. };
  40. struct tlc591xx_priv {
  41. struct tlc591xx_led leds[TLC591XX_MAX_LEDS];
  42. struct regmap *regmap;
  43. unsigned int reg_ledout_offset;
  44. };
  45. struct tlc591xx {
  46. unsigned int max_leds;
  47. unsigned int reg_ledout_offset;
  48. };
  49. static const struct tlc591xx tlc59116 = {
  50. .max_leds = 16,
  51. .reg_ledout_offset = 0x14,
  52. };
  53. static const struct tlc591xx tlc59108 = {
  54. .max_leds = 8,
  55. .reg_ledout_offset = 0x0c,
  56. };
  57. static int
  58. tlc591xx_set_mode(struct regmap *regmap, u8 mode)
  59. {
  60. int err;
  61. u8 val;
  62. err = regmap_write(regmap, TLC591XX_REG_MODE1, MODE1_NORMAL_MODE);
  63. if (err)
  64. return err;
  65. val = MODE2_OCH_STOP | mode;
  66. return regmap_write(regmap, TLC591XX_REG_MODE2, val);
  67. }
  68. static int
  69. tlc591xx_set_ledout(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
  70. u8 val)
  71. {
  72. unsigned int i = (led->led_no % 4) * 2;
  73. unsigned int mask = LEDOUT_MASK << i;
  74. unsigned int addr = priv->reg_ledout_offset + (led->led_no >> 2);
  75. val = val << i;
  76. return regmap_update_bits(priv->regmap, addr, mask, val);
  77. }
  78. static int
  79. tlc591xx_set_pwm(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
  80. u8 brightness)
  81. {
  82. u8 pwm = TLC591XX_REG_PWM(led->led_no);
  83. return regmap_write(priv->regmap, pwm, brightness);
  84. }
  85. static int
  86. tlc591xx_brightness_set(struct led_classdev *led_cdev,
  87. enum led_brightness brightness)
  88. {
  89. struct tlc591xx_led *led = ldev_to_led(led_cdev);
  90. struct tlc591xx_priv *priv = led->priv;
  91. int err;
  92. switch ((int)brightness) {
  93. case 0:
  94. err = tlc591xx_set_ledout(priv, led, LEDOUT_OFF);
  95. break;
  96. case TLC591XX_MAX_BRIGHTNESS:
  97. err = tlc591xx_set_ledout(priv, led, LEDOUT_ON);
  98. break;
  99. default:
  100. err = tlc591xx_set_ledout(priv, led, LEDOUT_DIM);
  101. if (!err)
  102. err = tlc591xx_set_pwm(priv, led, brightness);
  103. }
  104. return err;
  105. }
  106. static const struct regmap_config tlc591xx_regmap = {
  107. .reg_bits = 8,
  108. .val_bits = 8,
  109. .max_register = 0x1e,
  110. };
  111. static const struct of_device_id of_tlc591xx_leds_match[] = {
  112. { .compatible = "ti,tlc59116",
  113. .data = &tlc59116 },
  114. { .compatible = "ti,tlc59108",
  115. .data = &tlc59108 },
  116. {},
  117. };
  118. MODULE_DEVICE_TABLE(of, of_tlc591xx_leds_match);
  119. static int
  120. tlc591xx_probe(struct i2c_client *client,
  121. const struct i2c_device_id *id)
  122. {
  123. struct device_node *np, *child;
  124. struct device *dev = &client->dev;
  125. const struct tlc591xx *tlc591xx;
  126. struct tlc591xx_priv *priv;
  127. int err, count, reg;
  128. np = dev_of_node(dev);
  129. if (!np)
  130. return -ENODEV;
  131. tlc591xx = device_get_match_data(dev);
  132. if (!tlc591xx)
  133. return -ENODEV;
  134. count = of_get_available_child_count(np);
  135. if (!count || count > tlc591xx->max_leds)
  136. return -EINVAL;
  137. priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
  138. if (!priv)
  139. return -ENOMEM;
  140. priv->regmap = devm_regmap_init_i2c(client, &tlc591xx_regmap);
  141. if (IS_ERR(priv->regmap)) {
  142. err = PTR_ERR(priv->regmap);
  143. dev_err(dev, "Failed to allocate register map: %d\n", err);
  144. return err;
  145. }
  146. priv->reg_ledout_offset = tlc591xx->reg_ledout_offset;
  147. i2c_set_clientdata(client, priv);
  148. err = tlc591xx_set_mode(priv->regmap, MODE2_DIM);
  149. if (err < 0)
  150. return err;
  151. for_each_available_child_of_node(np, child) {
  152. struct tlc591xx_led *led;
  153. struct led_init_data init_data = {};
  154. init_data.fwnode = of_fwnode_handle(child);
  155. err = of_property_read_u32(child, "reg", &reg);
  156. if (err) {
  157. of_node_put(child);
  158. return err;
  159. }
  160. if (reg < 0 || reg >= tlc591xx->max_leds ||
  161. priv->leds[reg].active) {
  162. of_node_put(child);
  163. return -EINVAL;
  164. }
  165. led = &priv->leds[reg];
  166. led->active = true;
  167. led->priv = priv;
  168. led->led_no = reg;
  169. led->ldev.brightness_set_blocking = tlc591xx_brightness_set;
  170. led->ldev.max_brightness = TLC591XX_MAX_BRIGHTNESS;
  171. err = devm_led_classdev_register_ext(dev, &led->ldev,
  172. &init_data);
  173. if (err < 0) {
  174. of_node_put(child);
  175. return dev_err_probe(dev, err,
  176. "couldn't register LED %s\n",
  177. led->ldev.name);
  178. }
  179. }
  180. return 0;
  181. }
  182. static const struct i2c_device_id tlc591xx_id[] = {
  183. { "tlc59116" },
  184. { "tlc59108" },
  185. {},
  186. };
  187. MODULE_DEVICE_TABLE(i2c, tlc591xx_id);
  188. static struct i2c_driver tlc591xx_driver = {
  189. .driver = {
  190. .name = "tlc591xx",
  191. .of_match_table = of_match_ptr(of_tlc591xx_leds_match),
  192. },
  193. .probe = tlc591xx_probe,
  194. .id_table = tlc591xx_id,
  195. };
  196. module_i2c_driver(tlc591xx_driver);
  197. MODULE_AUTHOR("Andrew Lunn <[email protected]>");
  198. MODULE_LICENSE("GPL");
  199. MODULE_DESCRIPTION("TLC591XX LED driver");