pwm_backlight.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  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. * @min_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. duty_cycle = priv->period_ns * (priv->cur_level - priv->min_level) /
  61. (priv->max_level - priv->min_level + 1);
  62. ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
  63. duty_cycle);
  64. if (ret)
  65. return log_ret(ret);
  66. ret = pwm_set_invert(priv->pwm, priv->channel, priv->polarity);
  67. if (ret == -ENOSYS && !priv->polarity)
  68. ret = 0;
  69. return log_ret(ret);
  70. }
  71. static int enable_sequence(struct udevice *dev, int seq)
  72. {
  73. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  74. int ret;
  75. switch (seq) {
  76. case 0:
  77. if (priv->reg) {
  78. __maybe_unused struct dm_regulator_uclass_platdata
  79. *plat;
  80. plat = dev_get_uclass_platdata(priv->reg);
  81. log_debug("Enable '%s', regulator '%s'/'%s'\n",
  82. dev->name, priv->reg->name, plat->name);
  83. ret = regulator_set_enable(priv->reg, true);
  84. if (ret) {
  85. log_debug("Cannot enable regulator for PWM '%s'\n",
  86. dev->name);
  87. return log_ret(ret);
  88. }
  89. mdelay(120);
  90. }
  91. break;
  92. case 1:
  93. mdelay(10);
  94. dm_gpio_set_value(&priv->enable, 1);
  95. break;
  96. }
  97. return 0;
  98. }
  99. static int pwm_backlight_enable(struct udevice *dev)
  100. {
  101. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  102. int ret;
  103. ret = enable_sequence(dev, 0);
  104. if (ret)
  105. return log_ret(ret);
  106. ret = set_pwm(priv);
  107. if (ret)
  108. return log_ret(ret);
  109. ret = pwm_set_enable(priv->pwm, priv->channel, true);
  110. if (ret)
  111. return log_ret(ret);
  112. ret = enable_sequence(dev, 1);
  113. if (ret)
  114. return log_ret(ret);
  115. priv->enabled = true;
  116. return 0;
  117. }
  118. static int pwm_backlight_set_brightness(struct udevice *dev, int percent)
  119. {
  120. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  121. bool disable = false;
  122. int level;
  123. int ret;
  124. if (!priv->enabled) {
  125. ret = enable_sequence(dev, 0);
  126. if (ret)
  127. return log_ret(ret);
  128. }
  129. if (percent == BACKLIGHT_OFF) {
  130. disable = true;
  131. percent = 0;
  132. }
  133. if (percent == BACKLIGHT_DEFAULT) {
  134. level = priv->default_level;
  135. } else {
  136. if (priv->levels) {
  137. level = priv->levels[percent * (priv->num_levels - 1)
  138. / 100];
  139. } else {
  140. level = priv->min_level +
  141. (priv->max_level - priv->min_level) *
  142. percent / 100;
  143. }
  144. }
  145. priv->cur_level = level;
  146. ret = set_pwm(priv);
  147. if (ret)
  148. return log_ret(ret);
  149. if (!priv->enabled) {
  150. ret = enable_sequence(dev, 1);
  151. if (ret)
  152. return log_ret(ret);
  153. priv->enabled = true;
  154. }
  155. if (disable) {
  156. dm_gpio_set_value(&priv->enable, 0);
  157. if (priv->reg) {
  158. ret = regulator_set_enable(priv->reg, false);
  159. if (ret)
  160. return log_ret(ret);
  161. }
  162. priv->enabled = false;
  163. }
  164. return 0;
  165. }
  166. static int pwm_backlight_ofdata_to_platdata(struct udevice *dev)
  167. {
  168. struct pwm_backlight_priv *priv = dev_get_priv(dev);
  169. struct ofnode_phandle_args args;
  170. int index, ret, count, len;
  171. const u32 *cell;
  172. log_debug("start\n");
  173. ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
  174. "power-supply", &priv->reg);
  175. if (ret)
  176. log_debug("Cannot get power supply: ret=%d\n", ret);
  177. ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
  178. GPIOD_IS_OUT);
  179. if (ret) {
  180. log_debug("Warning: cannot get enable GPIO: ret=%d\n", ret);
  181. if (ret != -ENOENT)
  182. return log_ret(ret);
  183. }
  184. ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0,
  185. &args);
  186. if (ret) {
  187. log_debug("Cannot get PWM phandle: ret=%d\n", ret);
  188. return log_ret(ret);
  189. }
  190. ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
  191. if (ret) {
  192. log_debug("Cannot get PWM: ret=%d\n", ret);
  193. return log_ret(ret);
  194. }
  195. if (args.args_count < 2)
  196. return log_msg_ret("Not enough arguments to pwm\n", -EINVAL);
  197. priv->channel = args.args[0];
  198. priv->period_ns = args.args[1];
  199. if (args.args_count > 2)
  200. priv->polarity = args.args[2];
  201. index = dev_read_u32_default(dev, "default-brightness-level", 255);
  202. cell = dev_read_prop(dev, "brightness-levels", &len);
  203. count = len / sizeof(u32);
  204. if (cell && count > index) {
  205. priv->levels = malloc(len);
  206. if (!priv->levels)
  207. return log_ret(-ENOMEM);
  208. dev_read_u32_array(dev, "brightness-levels", priv->levels,
  209. count);
  210. priv->num_levels = count;
  211. priv->default_level = priv->levels[index];
  212. priv->max_level = priv->levels[count - 1];
  213. } else {
  214. priv->default_level = index;
  215. priv->max_level = 255;
  216. }
  217. priv->cur_level = priv->default_level;
  218. log_debug("done\n");
  219. return 0;
  220. }
  221. static int pwm_backlight_probe(struct udevice *dev)
  222. {
  223. return 0;
  224. }
  225. static const struct backlight_ops pwm_backlight_ops = {
  226. .enable = pwm_backlight_enable,
  227. .set_brightness = pwm_backlight_set_brightness,
  228. };
  229. static const struct udevice_id pwm_backlight_ids[] = {
  230. { .compatible = "pwm-backlight" },
  231. { }
  232. };
  233. U_BOOT_DRIVER(pwm_backlight) = {
  234. .name = "pwm_backlight",
  235. .id = UCLASS_PANEL_BACKLIGHT,
  236. .of_match = pwm_backlight_ids,
  237. .ops = &pwm_backlight_ops,
  238. .ofdata_to_platdata = pwm_backlight_ofdata_to_platdata,
  239. .probe = pwm_backlight_probe,
  240. .priv_auto_alloc_size = sizeof(struct pwm_backlight_priv),
  241. };