drm_panel.h 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218
  1. /*
  2. * Copyright (C) 2013, NVIDIA Corporation. All rights reserved.
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the "Software"),
  6. * to deal in the Software without restriction, including without limitation
  7. * the rights to use, copy, modify, merge, publish, distribute, sub license,
  8. * and/or sell copies of the Software, and to permit persons to whom the
  9. * Software is furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice (including the
  12. * next paragraph) shall be included in all copies or substantial portions
  13. * of the Software.
  14. *
  15. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17. * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21. * DEALINGS IN THE SOFTWARE.
  22. */
  23. #ifndef __DRM_PANEL_H__
  24. #define __DRM_PANEL_H__
  25. #include <linux/err.h>
  26. #include <linux/errno.h>
  27. #include <linux/list.h>
  28. struct backlight_device;
  29. struct device_node;
  30. struct drm_connector;
  31. struct drm_device;
  32. struct drm_panel;
  33. struct display_timing;
  34. enum drm_panel_orientation;
  35. /**
  36. * struct drm_panel_funcs - perform operations on a given panel
  37. *
  38. * The .prepare() function is typically called before the display controller
  39. * starts to transmit video data. Panel drivers can use this to turn the panel
  40. * on and wait for it to become ready. If additional configuration is required
  41. * (via a control bus such as I2C, SPI or DSI for example) this is a good time
  42. * to do that.
  43. *
  44. * After the display controller has started transmitting video data, it's safe
  45. * to call the .enable() function. This will typically enable the backlight to
  46. * make the image on screen visible. Some panels require a certain amount of
  47. * time or frames before the image is displayed. This function is responsible
  48. * for taking this into account before enabling the backlight to avoid visual
  49. * glitches.
  50. *
  51. * Before stopping video transmission from the display controller it can be
  52. * necessary to turn off the panel to avoid visual glitches. This is done in
  53. * the .disable() function. Analogously to .enable() this typically involves
  54. * turning off the backlight and waiting for some time to make sure no image
  55. * is visible on the panel. It is then safe for the display controller to
  56. * cease transmission of video data.
  57. *
  58. * To save power when no video data is transmitted, a driver can power down
  59. * the panel. This is the job of the .unprepare() function.
  60. *
  61. * Backlight can be handled automatically if configured using
  62. * drm_panel_of_backlight(). Then the driver does not need to implement the
  63. * functionality to enable/disable backlight.
  64. */
  65. struct drm_panel_funcs {
  66. /**
  67. * @prepare:
  68. *
  69. * Turn on panel and perform set up.
  70. *
  71. * This function is optional.
  72. */
  73. int (*prepare)(struct drm_panel *panel);
  74. /**
  75. * @enable:
  76. *
  77. * Enable panel (turn on back light, etc.).
  78. *
  79. * This function is optional.
  80. */
  81. int (*enable)(struct drm_panel *panel);
  82. /**
  83. * @disable:
  84. *
  85. * Disable panel (turn off back light, etc.).
  86. *
  87. * This function is optional.
  88. */
  89. int (*disable)(struct drm_panel *panel);
  90. /**
  91. * @unprepare:
  92. *
  93. * Turn off panel.
  94. *
  95. * This function is optional.
  96. */
  97. int (*unprepare)(struct drm_panel *panel);
  98. /**
  99. * @get_modes:
  100. *
  101. * Add modes to the connector that the panel is attached to
  102. * and returns the number of modes added.
  103. *
  104. * This function is mandatory.
  105. */
  106. int (*get_modes)(struct drm_panel *panel,
  107. struct drm_connector *connector);
  108. /**
  109. * @get_timings:
  110. *
  111. * Copy display timings into the provided array and return
  112. * the number of display timings available.
  113. *
  114. * This function is optional.
  115. */
  116. int (*get_timings)(struct drm_panel *panel, unsigned int num_timings,
  117. struct display_timing *timings);
  118. };
  119. /**
  120. * struct drm_panel - DRM panel object
  121. */
  122. struct drm_panel {
  123. /**
  124. * @dev:
  125. *
  126. * Parent device of the panel.
  127. */
  128. struct device *dev;
  129. /**
  130. * @backlight:
  131. *
  132. * Backlight device, used to turn on backlight after the call
  133. * to enable(), and to turn off backlight before the call to
  134. * disable().
  135. * backlight is set by drm_panel_of_backlight() and drivers
  136. * shall not assign it.
  137. */
  138. struct backlight_device *backlight;
  139. /**
  140. * @funcs:
  141. *
  142. * Operations that can be performed on the panel.
  143. */
  144. const struct drm_panel_funcs *funcs;
  145. /**
  146. * @connector_type:
  147. *
  148. * Type of the panel as a DRM_MODE_CONNECTOR_* value. This is used to
  149. * initialise the drm_connector corresponding to the panel with the
  150. * correct connector type.
  151. */
  152. int connector_type;
  153. /**
  154. * @list:
  155. *
  156. * Panel entry in registry.
  157. */
  158. struct list_head list;
  159. };
  160. void drm_panel_init(struct drm_panel *panel, struct device *dev,
  161. const struct drm_panel_funcs *funcs,
  162. int connector_type);
  163. void drm_panel_add(struct drm_panel *panel);
  164. void drm_panel_remove(struct drm_panel *panel);
  165. int drm_panel_prepare(struct drm_panel *panel);
  166. int drm_panel_unprepare(struct drm_panel *panel);
  167. int drm_panel_enable(struct drm_panel *panel);
  168. int drm_panel_disable(struct drm_panel *panel);
  169. int drm_panel_get_modes(struct drm_panel *panel, struct drm_connector *connector);
  170. #if defined(CONFIG_OF) && defined(CONFIG_DRM_PANEL)
  171. struct drm_panel *of_drm_find_panel(const struct device_node *np);
  172. int of_drm_get_panel_orientation(const struct device_node *np,
  173. enum drm_panel_orientation *orientation);
  174. #else
  175. static inline struct drm_panel *of_drm_find_panel(const struct device_node *np)
  176. {
  177. return ERR_PTR(-ENODEV);
  178. }
  179. static inline int of_drm_get_panel_orientation(const struct device_node *np,
  180. enum drm_panel_orientation *orientation)
  181. {
  182. return -ENODEV;
  183. }
  184. #endif
  185. #if IS_ENABLED(CONFIG_DRM_PANEL) && (IS_BUILTIN(CONFIG_BACKLIGHT_CLASS_DEVICE) || \
  186. (IS_MODULE(CONFIG_DRM) && IS_MODULE(CONFIG_BACKLIGHT_CLASS_DEVICE)))
  187. int drm_panel_of_backlight(struct drm_panel *panel);
  188. #else
  189. static inline int drm_panel_of_backlight(struct drm_panel *panel)
  190. {
  191. return 0;
  192. }
  193. #endif
  194. #endif