pwm_backlight.c 6.4 KB

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