led_bl.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2015-2019 Texas Instruments Incorporated - http://www.ti.com/
  4. * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
  5. *
  6. * Based on pwm_bl.c
  7. */
  8. #include <linux/backlight.h>
  9. #include <linux/leds.h>
  10. #include <linux/module.h>
  11. #include <linux/platform_device.h>
  12. struct led_bl_data {
  13. struct device *dev;
  14. struct backlight_device *bl_dev;
  15. struct led_classdev **leds;
  16. bool enabled;
  17. int nb_leds;
  18. unsigned int *levels;
  19. unsigned int default_brightness;
  20. unsigned int max_brightness;
  21. };
  22. static void led_bl_set_brightness(struct led_bl_data *priv, int level)
  23. {
  24. int i;
  25. int bkl_brightness;
  26. if (priv->levels)
  27. bkl_brightness = priv->levels[level];
  28. else
  29. bkl_brightness = level;
  30. for (i = 0; i < priv->nb_leds; i++)
  31. led_set_brightness(priv->leds[i], bkl_brightness);
  32. priv->enabled = true;
  33. }
  34. static void led_bl_power_off(struct led_bl_data *priv)
  35. {
  36. int i;
  37. if (!priv->enabled)
  38. return;
  39. for (i = 0; i < priv->nb_leds; i++)
  40. led_set_brightness(priv->leds[i], LED_OFF);
  41. priv->enabled = false;
  42. }
  43. static int led_bl_update_status(struct backlight_device *bl)
  44. {
  45. struct led_bl_data *priv = bl_get_data(bl);
  46. int brightness = backlight_get_brightness(bl);
  47. if (brightness > 0)
  48. led_bl_set_brightness(priv, brightness);
  49. else
  50. led_bl_power_off(priv);
  51. return 0;
  52. }
  53. static const struct backlight_ops led_bl_ops = {
  54. .update_status = led_bl_update_status,
  55. };
  56. static int led_bl_get_leds(struct device *dev,
  57. struct led_bl_data *priv)
  58. {
  59. int i, nb_leds, ret;
  60. struct device_node *node = dev->of_node;
  61. struct led_classdev **leds;
  62. unsigned int max_brightness;
  63. unsigned int default_brightness;
  64. ret = of_count_phandle_with_args(node, "leds", NULL);
  65. if (ret < 0) {
  66. dev_err(dev, "Unable to get led count\n");
  67. return -EINVAL;
  68. }
  69. nb_leds = ret;
  70. if (nb_leds < 1) {
  71. dev_err(dev, "At least one LED must be specified!\n");
  72. return -EINVAL;
  73. }
  74. leds = devm_kzalloc(dev, sizeof(struct led_classdev *) * nb_leds,
  75. GFP_KERNEL);
  76. if (!leds)
  77. return -ENOMEM;
  78. for (i = 0; i < nb_leds; i++) {
  79. leds[i] = devm_of_led_get(dev, i);
  80. if (IS_ERR(leds[i]))
  81. return PTR_ERR(leds[i]);
  82. }
  83. /* check that the LEDs all have the same brightness range */
  84. max_brightness = leds[0]->max_brightness;
  85. for (i = 1; i < nb_leds; i++) {
  86. if (max_brightness != leds[i]->max_brightness) {
  87. dev_err(dev, "LEDs must have identical ranges\n");
  88. return -EINVAL;
  89. }
  90. }
  91. /* get the default brightness from the first LED from the list */
  92. default_brightness = leds[0]->brightness;
  93. priv->nb_leds = nb_leds;
  94. priv->leds = leds;
  95. priv->max_brightness = max_brightness;
  96. priv->default_brightness = default_brightness;
  97. return 0;
  98. }
  99. static int led_bl_parse_levels(struct device *dev,
  100. struct led_bl_data *priv)
  101. {
  102. struct device_node *node = dev->of_node;
  103. int num_levels;
  104. u32 value;
  105. int ret;
  106. if (!node)
  107. return -ENODEV;
  108. num_levels = of_property_count_u32_elems(node, "brightness-levels");
  109. if (num_levels > 1) {
  110. int i;
  111. unsigned int db;
  112. u32 *levels = NULL;
  113. levels = devm_kzalloc(dev, sizeof(u32) * num_levels,
  114. GFP_KERNEL);
  115. if (!levels)
  116. return -ENOMEM;
  117. ret = of_property_read_u32_array(node, "brightness-levels",
  118. levels,
  119. num_levels);
  120. if (ret < 0)
  121. return ret;
  122. /*
  123. * Try to map actual LED brightness to backlight brightness
  124. * level
  125. */
  126. db = priv->default_brightness;
  127. for (i = 0 ; i < num_levels; i++) {
  128. if ((i && db > levels[i-1]) && db <= levels[i])
  129. break;
  130. }
  131. priv->default_brightness = i;
  132. priv->max_brightness = num_levels - 1;
  133. priv->levels = levels;
  134. } else if (num_levels >= 0)
  135. dev_warn(dev, "Not enough levels defined\n");
  136. ret = of_property_read_u32(node, "default-brightness-level", &value);
  137. if (!ret && value <= priv->max_brightness)
  138. priv->default_brightness = value;
  139. else if (!ret && value > priv->max_brightness)
  140. dev_warn(dev, "Invalid default brightness. Ignoring it\n");
  141. return 0;
  142. }
  143. static int led_bl_probe(struct platform_device *pdev)
  144. {
  145. struct backlight_properties props;
  146. struct led_bl_data *priv;
  147. int ret, i;
  148. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  149. if (!priv)
  150. return -ENOMEM;
  151. platform_set_drvdata(pdev, priv);
  152. priv->dev = &pdev->dev;
  153. ret = led_bl_get_leds(&pdev->dev, priv);
  154. if (ret)
  155. return ret;
  156. ret = led_bl_parse_levels(&pdev->dev, priv);
  157. if (ret < 0) {
  158. dev_err(&pdev->dev, "Failed to parse DT data\n");
  159. return ret;
  160. }
  161. memset(&props, 0, sizeof(struct backlight_properties));
  162. props.type = BACKLIGHT_RAW;
  163. props.max_brightness = priv->max_brightness;
  164. props.brightness = priv->default_brightness;
  165. props.power = (priv->default_brightness > 0) ? FB_BLANK_POWERDOWN :
  166. FB_BLANK_UNBLANK;
  167. priv->bl_dev = backlight_device_register(dev_name(&pdev->dev),
  168. &pdev->dev, priv, &led_bl_ops, &props);
  169. if (IS_ERR(priv->bl_dev)) {
  170. dev_err(&pdev->dev, "Failed to register backlight\n");
  171. return PTR_ERR(priv->bl_dev);
  172. }
  173. for (i = 0; i < priv->nb_leds; i++)
  174. led_sysfs_disable(priv->leds[i]);
  175. backlight_update_status(priv->bl_dev);
  176. return 0;
  177. }
  178. static int led_bl_remove(struct platform_device *pdev)
  179. {
  180. struct led_bl_data *priv = platform_get_drvdata(pdev);
  181. struct backlight_device *bl = priv->bl_dev;
  182. int i;
  183. backlight_device_unregister(bl);
  184. led_bl_power_off(priv);
  185. for (i = 0; i < priv->nb_leds; i++)
  186. led_sysfs_enable(priv->leds[i]);
  187. return 0;
  188. }
  189. static const struct of_device_id led_bl_of_match[] = {
  190. { .compatible = "led-backlight" },
  191. { }
  192. };
  193. MODULE_DEVICE_TABLE(of, led_bl_of_match);
  194. static struct platform_driver led_bl_driver = {
  195. .driver = {
  196. .name = "led-backlight",
  197. .of_match_table = of_match_ptr(led_bl_of_match),
  198. },
  199. .probe = led_bl_probe,
  200. .remove = led_bl_remove,
  201. };
  202. module_platform_driver(led_bl_driver);
  203. MODULE_DESCRIPTION("LED based Backlight Driver");
  204. MODULE_LICENSE("GPL");
  205. MODULE_ALIAS("platform:led-backlight");