panel.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2016 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
  4. * Copyright (C) 2017 Broadcom
  5. */
  6. #include <drm/drm_atomic_helper.h>
  7. #include <drm/drm_bridge.h>
  8. #include <drm/drm_connector.h>
  9. #include <drm/drm_encoder.h>
  10. #include <drm/drm_modeset_helper_vtables.h>
  11. #include <drm/drm_panel.h>
  12. #include <drm/drm_print.h>
  13. #include <drm/drm_probe_helper.h>
  14. struct panel_bridge {
  15. struct drm_bridge bridge;
  16. struct drm_connector connector;
  17. struct drm_panel *panel;
  18. u32 connector_type;
  19. };
  20. static inline struct panel_bridge *
  21. drm_bridge_to_panel_bridge(struct drm_bridge *bridge)
  22. {
  23. return container_of(bridge, struct panel_bridge, bridge);
  24. }
  25. static inline struct panel_bridge *
  26. drm_connector_to_panel_bridge(struct drm_connector *connector)
  27. {
  28. return container_of(connector, struct panel_bridge, connector);
  29. }
  30. static int panel_bridge_connector_get_modes(struct drm_connector *connector)
  31. {
  32. struct panel_bridge *panel_bridge =
  33. drm_connector_to_panel_bridge(connector);
  34. return drm_panel_get_modes(panel_bridge->panel, connector);
  35. }
  36. static const struct drm_connector_helper_funcs
  37. panel_bridge_connector_helper_funcs = {
  38. .get_modes = panel_bridge_connector_get_modes,
  39. };
  40. static const struct drm_connector_funcs panel_bridge_connector_funcs = {
  41. .reset = drm_atomic_helper_connector_reset,
  42. .fill_modes = drm_helper_probe_single_connector_modes,
  43. .destroy = drm_connector_cleanup,
  44. .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  45. .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  46. };
  47. static int panel_bridge_attach(struct drm_bridge *bridge,
  48. enum drm_bridge_attach_flags flags)
  49. {
  50. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  51. struct drm_connector *connector = &panel_bridge->connector;
  52. int ret;
  53. if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
  54. return 0;
  55. if (!bridge->encoder) {
  56. DRM_ERROR("Missing encoder\n");
  57. return -ENODEV;
  58. }
  59. drm_connector_helper_add(connector,
  60. &panel_bridge_connector_helper_funcs);
  61. ret = drm_connector_init(bridge->dev, connector,
  62. &panel_bridge_connector_funcs,
  63. panel_bridge->connector_type);
  64. if (ret) {
  65. DRM_ERROR("Failed to initialize connector\n");
  66. return ret;
  67. }
  68. drm_connector_attach_encoder(&panel_bridge->connector,
  69. bridge->encoder);
  70. return 0;
  71. }
  72. static void panel_bridge_detach(struct drm_bridge *bridge)
  73. {
  74. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  75. struct drm_connector *connector = &panel_bridge->connector;
  76. /*
  77. * Cleanup the connector if we know it was initialized.
  78. *
  79. * FIXME: This wouldn't be needed if the panel_bridge structure was
  80. * allocated with drmm_kzalloc(). This might be tricky since the
  81. * drm_device pointer can only be retrieved when the bridge is attached.
  82. */
  83. if (connector->dev)
  84. drm_connector_cleanup(connector);
  85. }
  86. static void panel_bridge_pre_enable(struct drm_bridge *bridge)
  87. {
  88. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  89. drm_panel_prepare(panel_bridge->panel);
  90. }
  91. static void panel_bridge_enable(struct drm_bridge *bridge)
  92. {
  93. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  94. drm_panel_enable(panel_bridge->panel);
  95. }
  96. static void panel_bridge_disable(struct drm_bridge *bridge)
  97. {
  98. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  99. drm_panel_disable(panel_bridge->panel);
  100. }
  101. static void panel_bridge_post_disable(struct drm_bridge *bridge)
  102. {
  103. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  104. drm_panel_unprepare(panel_bridge->panel);
  105. }
  106. static int panel_bridge_get_modes(struct drm_bridge *bridge,
  107. struct drm_connector *connector)
  108. {
  109. struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  110. return drm_panel_get_modes(panel_bridge->panel, connector);
  111. }
  112. static const struct drm_bridge_funcs panel_bridge_bridge_funcs = {
  113. .attach = panel_bridge_attach,
  114. .detach = panel_bridge_detach,
  115. .pre_enable = panel_bridge_pre_enable,
  116. .enable = panel_bridge_enable,
  117. .disable = panel_bridge_disable,
  118. .post_disable = panel_bridge_post_disable,
  119. .get_modes = panel_bridge_get_modes,
  120. .atomic_reset = drm_atomic_helper_bridge_reset,
  121. .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
  122. .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
  123. .atomic_get_input_bus_fmts = drm_atomic_helper_bridge_propagate_bus_fmt,
  124. };
  125. /**
  126. * drm_panel_bridge_add - Creates a &drm_bridge and &drm_connector that
  127. * just calls the appropriate functions from &drm_panel.
  128. *
  129. * @panel: The drm_panel being wrapped. Must be non-NULL.
  130. *
  131. * For drivers converting from directly using drm_panel: The expected
  132. * usage pattern is that during either encoder module probe or DSI
  133. * host attach, a drm_panel will be looked up through
  134. * drm_of_find_panel_or_bridge(). drm_panel_bridge_add() is used to
  135. * wrap that panel in the new bridge, and the result can then be
  136. * passed to drm_bridge_attach(). The drm_panel_prepare() and related
  137. * functions can be dropped from the encoder driver (they're now
  138. * called by the KMS helpers before calling into the encoder), along
  139. * with connector creation. When done with the bridge (after
  140. * drm_mode_config_cleanup() if the bridge has already been attached), then
  141. * drm_panel_bridge_remove() to free it.
  142. *
  143. * The connector type is set to @panel->connector_type, which must be set to a
  144. * known type. Calling this function with a panel whose connector type is
  145. * DRM_MODE_CONNECTOR_Unknown will return ERR_PTR(-EINVAL).
  146. *
  147. * See devm_drm_panel_bridge_add() for an automatically managed version of this
  148. * function.
  149. */
  150. struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel)
  151. {
  152. if (WARN_ON(panel->connector_type == DRM_MODE_CONNECTOR_Unknown))
  153. return ERR_PTR(-EINVAL);
  154. return drm_panel_bridge_add_typed(panel, panel->connector_type);
  155. }
  156. EXPORT_SYMBOL(drm_panel_bridge_add);
  157. /**
  158. * drm_panel_bridge_add_typed - Creates a &drm_bridge and &drm_connector with
  159. * an explicit connector type.
  160. * @panel: The drm_panel being wrapped. Must be non-NULL.
  161. * @connector_type: The connector type (DRM_MODE_CONNECTOR_*)
  162. *
  163. * This is just like drm_panel_bridge_add(), but forces the connector type to
  164. * @connector_type instead of infering it from the panel.
  165. *
  166. * This function is deprecated and should not be used in new drivers. Use
  167. * drm_panel_bridge_add() instead, and fix panel drivers as necessary if they
  168. * don't report a connector type.
  169. */
  170. struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel,
  171. u32 connector_type)
  172. {
  173. struct panel_bridge *panel_bridge;
  174. if (!panel)
  175. return ERR_PTR(-EINVAL);
  176. panel_bridge = devm_kzalloc(panel->dev, sizeof(*panel_bridge),
  177. GFP_KERNEL);
  178. if (!panel_bridge)
  179. return ERR_PTR(-ENOMEM);
  180. panel_bridge->connector_type = connector_type;
  181. panel_bridge->panel = panel;
  182. panel_bridge->bridge.funcs = &panel_bridge_bridge_funcs;
  183. #ifdef CONFIG_OF
  184. panel_bridge->bridge.of_node = panel->dev->of_node;
  185. #endif
  186. panel_bridge->bridge.ops = DRM_BRIDGE_OP_MODES;
  187. panel_bridge->bridge.type = connector_type;
  188. drm_bridge_add(&panel_bridge->bridge);
  189. return &panel_bridge->bridge;
  190. }
  191. EXPORT_SYMBOL(drm_panel_bridge_add_typed);
  192. /**
  193. * drm_panel_bridge_remove - Unregisters and frees a drm_bridge
  194. * created by drm_panel_bridge_add().
  195. *
  196. * @bridge: The drm_bridge being freed.
  197. */
  198. void drm_panel_bridge_remove(struct drm_bridge *bridge)
  199. {
  200. struct panel_bridge *panel_bridge;
  201. if (!bridge)
  202. return;
  203. if (bridge->funcs != &panel_bridge_bridge_funcs)
  204. return;
  205. panel_bridge = drm_bridge_to_panel_bridge(bridge);
  206. drm_bridge_remove(bridge);
  207. devm_kfree(panel_bridge->panel->dev, bridge);
  208. }
  209. EXPORT_SYMBOL(drm_panel_bridge_remove);
  210. static void devm_drm_panel_bridge_release(struct device *dev, void *res)
  211. {
  212. struct drm_bridge **bridge = res;
  213. drm_panel_bridge_remove(*bridge);
  214. }
  215. /**
  216. * devm_drm_panel_bridge_add - Creates a managed &drm_bridge and &drm_connector
  217. * that just calls the appropriate functions from &drm_panel.
  218. * @dev: device to tie the bridge lifetime to
  219. * @panel: The drm_panel being wrapped. Must be non-NULL.
  220. *
  221. * This is the managed version of drm_panel_bridge_add() which automatically
  222. * calls drm_panel_bridge_remove() when @dev is unbound.
  223. */
  224. struct drm_bridge *devm_drm_panel_bridge_add(struct device *dev,
  225. struct drm_panel *panel)
  226. {
  227. if (WARN_ON(panel->connector_type == DRM_MODE_CONNECTOR_Unknown))
  228. return ERR_PTR(-EINVAL);
  229. return devm_drm_panel_bridge_add_typed(dev, panel,
  230. panel->connector_type);
  231. }
  232. EXPORT_SYMBOL(devm_drm_panel_bridge_add);
  233. /**
  234. * devm_drm_panel_bridge_add_typed - Creates a managed &drm_bridge and
  235. * &drm_connector with an explicit connector type.
  236. * @dev: device to tie the bridge lifetime to
  237. * @panel: The drm_panel being wrapped. Must be non-NULL.
  238. * @connector_type: The connector type (DRM_MODE_CONNECTOR_*)
  239. *
  240. * This is just like devm_drm_panel_bridge_add(), but forces the connector type
  241. * to @connector_type instead of infering it from the panel.
  242. *
  243. * This function is deprecated and should not be used in new drivers. Use
  244. * devm_drm_panel_bridge_add() instead, and fix panel drivers as necessary if
  245. * they don't report a connector type.
  246. */
  247. struct drm_bridge *devm_drm_panel_bridge_add_typed(struct device *dev,
  248. struct drm_panel *panel,
  249. u32 connector_type)
  250. {
  251. struct drm_bridge **ptr, *bridge;
  252. ptr = devres_alloc(devm_drm_panel_bridge_release, sizeof(*ptr),
  253. GFP_KERNEL);
  254. if (!ptr)
  255. return ERR_PTR(-ENOMEM);
  256. bridge = drm_panel_bridge_add_typed(panel, connector_type);
  257. if (!IS_ERR(bridge)) {
  258. *ptr = bridge;
  259. devres_add(dev, ptr);
  260. } else {
  261. devres_free(ptr);
  262. }
  263. return bridge;
  264. }
  265. EXPORT_SYMBOL(devm_drm_panel_bridge_add_typed);
  266. /**
  267. * drm_panel_bridge_connector - return the connector for the panel bridge
  268. * @bridge: The drm_bridge.
  269. *
  270. * drm_panel_bridge creates the connector.
  271. * This function gives external access to the connector.
  272. *
  273. * Returns: Pointer to drm_connector
  274. */
  275. struct drm_connector *drm_panel_bridge_connector(struct drm_bridge *bridge)
  276. {
  277. struct panel_bridge *panel_bridge;
  278. panel_bridge = drm_bridge_to_panel_bridge(bridge);
  279. return &panel_bridge->connector;
  280. }
  281. EXPORT_SYMBOL(drm_panel_bridge_connector);