pwm_backlight.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2016 Google, Inc
  4. * Written by Simon Glass <sjg@chromium.org>
  5. */
  6. #define LOG_CATEGORY UCLASS_PANEL_BACKLIGHT
  7. #include <common.h>
  8. #include <dm.h>
  9. #include <backlight.h>
  10. #include <log.h>
  11. #include <malloc.h>
  12. #include <pwm.h>
  13. #include <asm/gpio.h>
  14. #include <linux/delay.h>
  15. #include <power/regulator.h>
  16. /**
  17. * Private information for the PWM backlight
  18. *
  19. * If @num_levels is 0 then the levels are simple values with the backlight
  20. * value going between the minimum (default 0) and the maximum (default 255).
  21. * Otherwise the levels are an index into @levels (0..n-1).
  22. *
  23. * @reg: Regulator to enable to turn the backlight on (NULL if none)
  24. * @enable, GPIO to set to enable the backlight (can be missing)
  25. * @pwm: PWM to use to change the backlight brightness
  26. * @channel: PWM channel to use
  27. * @period_ns: Period of the backlight in nanoseconds
  28. * @levels: Levels for the backlight, or NULL if not using indexed levels
  29. * @num_levels: Number of levels
  30. * @cur_level: Current level for the backlight (index or value)
  31. * @default_level: Default level for the backlight (index or value)
  32. * @min_level: Minimum level of the backlight (full off)
  33. * @max_level: Maximum level of the backlight (full on)
  34. * @enabled: true if backlight is enabled
  35. */
  36. struct pwm_backlight_priv {
  37. struct udevice *reg;
  38. struct gpio_desc enable;
  39. struct udevice *pwm;
  40. uint channel;
  41. uint period_ns;
  42. /*
  43. * the polarity of one PWM
  44. * 0: normal polarity
  45. * 1: inverted polarity
  46. */
  47. bool polarity;
  48. u32 *levels;
  49. int num_levels;
  50. uint default_level;
  51. int cur_level;
  52. uint min_level;
  53. uint max_level;
  54. bool enabled;
  55. };
  56. static int set_pwm(struct pwm_backlight_priv *priv)
  57. {
  58. uint duty_cycle;
  59. int ret;
  60. if (priv->period_ns) {
  61. duty_cycle = priv->period_ns * (priv->cur_level - priv->min_level) /
  62. (priv->max_level - priv->min_level);
  63. ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
  64. duty_cycle);
  65. } else {
  66. /* PWM driver will internally scale these like the above. */
  67. ret = pwm_set_config(priv->pwm, priv->channel,
  68. priv->max_level - priv->min_level,
  69. priv->cur_level - priv->min_level);
  70. }
  71. if (ret)
  72. return log_ret(ret);
  73. ret = pwm_set_invert(priv->pwm, priv->channel, priv->polarity);
  74. if (ret == -ENOSYS && !priv->polarity)
  75. ret = 0;
  76. return log_ret(ret);
  77. }
  78. static int enable_sequence(struct udevice *dev, int seq)
  79. {
  80. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  81. int ret;
  82. switch (seq) {
  83. case 0:
  84. if (priv->reg) {
  85. __maybe_unused struct dm_regulator_uclass_plat
  86. *plat;
  87. plat = dev_get_uclass_plat(priv->reg);
  88. log_debug("Enable '%s', regulator '%s'/'%s'\n",
  89. dev->name, priv->reg->name, plat->name);
  90. ret = regulator_set_enable(priv->reg, true);
  91. if (ret) {
  92. log_debug("Cannot enable regulator for PWM '%s'\n",
  93. dev->name);
  94. return log_ret(ret);
  95. }
  96. mdelay(120);
  97. }
  98. break;
  99. case 1:
  100. mdelay(10);
  101. dm_gpio_set_value(&priv->enable, 1);
  102. break;
  103. }
  104. return 0;
  105. }
  106. static int pwm_backlight_enable(struct udevice *dev)
  107. {
  108. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  109. int ret;
  110. ret = enable_sequence(dev, 0);
  111. if (ret)
  112. return log_ret(ret);
  113. ret = set_pwm(priv);
  114. if (ret)
  115. return log_ret(ret);
  116. ret = pwm_set_enable(priv->pwm, priv->channel, true);
  117. if (ret)
  118. return log_ret(ret);
  119. ret = enable_sequence(dev, 1);
  120. if (ret)
  121. return log_ret(ret);
  122. priv->enabled = true;
  123. return 0;
  124. }
  125. static int pwm_backlight_set_brightness(struct udevice *dev, int percent)
  126. {
  127. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  128. bool disable = false;
  129. int level;
  130. int ret;
  131. if (!priv->enabled) {
  132. ret = enable_sequence(dev, 0);
  133. if (ret)
  134. return log_ret(ret);
  135. }
  136. if (percent == BACKLIGHT_OFF) {
  137. disable = true;
  138. percent = 0;
  139. }
  140. if (percent == BACKLIGHT_DEFAULT) {
  141. level = priv->default_level;
  142. } else {
  143. if (priv->levels) {
  144. level = priv->levels[percent * (priv->num_levels - 1)
  145. / 100];
  146. } else {
  147. level = priv->min_level +
  148. (priv->max_level - priv->min_level) *
  149. percent / 100;
  150. }
  151. }
  152. priv->cur_level = level;
  153. ret = set_pwm(priv);
  154. if (ret)
  155. return log_ret(ret);
  156. if (!priv->enabled) {
  157. ret = enable_sequence(dev, 1);
  158. if (ret)
  159. return log_ret(ret);
  160. priv->enabled = true;
  161. }
  162. if (disable) {
  163. dm_gpio_set_value(&priv->enable, 0);
  164. if (priv->reg) {
  165. ret = regulator_set_enable(priv->reg, false);
  166. if (ret)
  167. return log_ret(ret);
  168. }
  169. priv->enabled = false;
  170. }
  171. return 0;
  172. }
  173. static int pwm_backlight_of_to_plat(struct udevice *dev)
  174. {
  175. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  176. struct ofnode_phandle_args args;
  177. int index, ret, count, len;
  178. const u32 *cell;
  179. log_debug("start\n");
  180. ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
  181. "power-supply", &priv->reg);
  182. if (ret)
  183. log_debug("Cannot get power supply: ret=%d\n", ret);
  184. ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
  185. GPIOD_IS_OUT);
  186. if (ret) {
  187. log_debug("Warning: cannot get enable GPIO: ret=%d\n", ret);
  188. if (ret != -ENOENT)
  189. return log_ret(ret);
  190. }
  191. ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0,
  192. &args);
  193. if (ret) {
  194. log_debug("Cannot get PWM phandle: ret=%d\n", ret);
  195. return log_ret(ret);
  196. }
  197. ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
  198. if (ret) {
  199. log_debug("Cannot get PWM: ret=%d\n", ret);
  200. return log_ret(ret);
  201. }
  202. if (args.args_count < 1)
  203. return log_msg_ret("Not enough arguments to pwm\n", -EINVAL);
  204. priv->channel = args.args[0];
  205. if (args.args_count > 1)
  206. priv->period_ns = args.args[1];
  207. if (args.args_count > 2)
  208. priv->polarity = args.args[2];
  209. index = dev_read_u32_default(dev, "default-brightness-level", 255);
  210. cell = dev_read_prop(dev, "brightness-levels", &len);
  211. count = len / sizeof(u32);
  212. if (cell && count > index) {
  213. priv->levels = malloc(len);
  214. if (!priv->levels)
  215. return log_ret(-ENOMEM);
  216. ret = dev_read_u32_array(dev, "brightness-levels", priv->levels,
  217. count);
  218. if (ret)
  219. return log_msg_ret("levels", ret);
  220. priv->num_levels = count;
  221. priv->default_level = priv->levels[index];
  222. priv->max_level = priv->levels[count - 1];
  223. } else {
  224. priv->default_level = index;
  225. priv->max_level = 255;
  226. }
  227. priv->cur_level = priv->default_level;
  228. log_debug("done\n");
  229. return 0;
  230. }
  231. static int pwm_backlight_probe(struct udevice *dev)
  232. {
  233. return 0;
  234. }
  235. static const struct backlight_ops pwm_backlight_ops = {
  236. .enable = pwm_backlight_enable,
  237. .set_brightness = pwm_backlight_set_brightness,
  238. };
  239. static const struct udevice_id pwm_backlight_ids[] = {
  240. { .compatible = "pwm-backlight" },
  241. { }
  242. };
  243. U_BOOT_DRIVER(pwm_backlight) = {
  244. .name = "pwm_backlight",
  245. .id = UCLASS_PANEL_BACKLIGHT,
  246. .of_match = pwm_backlight_ids,
  247. .ops = &pwm_backlight_ops,
  248. .of_to_plat = pwm_backlight_of_to_plat,
  249. .probe = pwm_backlight_probe,
  250. .priv_auto = sizeof(struct pwm_backlight_priv),
  251. };