exynos_drm_dpi.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Exynos DRM Parallel output support.
  4. *
  5. * Copyright (c) 2014 Samsung Electronics Co., Ltd
  6. *
  7. * Contacts: Andrzej Hajda <a.hajda@samsung.com>
  8. */
  9. #include <linux/of_graph.h>
  10. #include <linux/regulator/consumer.h>
  11. #include <drm/drm_atomic_helper.h>
  12. #include <drm/drm_panel.h>
  13. #include <drm/drm_print.h>
  14. #include <drm/drm_probe_helper.h>
  15. #include <drm/drm_simple_kms_helper.h>
  16. #include <video/of_videomode.h>
  17. #include <video/videomode.h>
  18. #include "exynos_drm_crtc.h"
  19. struct exynos_dpi {
  20. struct drm_encoder encoder;
  21. struct device *dev;
  22. struct device_node *panel_node;
  23. struct drm_panel *panel;
  24. struct drm_connector connector;
  25. struct videomode *vm;
  26. };
  27. #define connector_to_dpi(c) container_of(c, struct exynos_dpi, connector)
  28. static inline struct exynos_dpi *encoder_to_dpi(struct drm_encoder *e)
  29. {
  30. return container_of(e, struct exynos_dpi, encoder);
  31. }
  32. static enum drm_connector_status
  33. exynos_dpi_detect(struct drm_connector *connector, bool force)
  34. {
  35. return connector_status_connected;
  36. }
  37. static void exynos_dpi_connector_destroy(struct drm_connector *connector)
  38. {
  39. drm_connector_unregister(connector);
  40. drm_connector_cleanup(connector);
  41. }
  42. static const struct drm_connector_funcs exynos_dpi_connector_funcs = {
  43. .detect = exynos_dpi_detect,
  44. .fill_modes = drm_helper_probe_single_connector_modes,
  45. .destroy = exynos_dpi_connector_destroy,
  46. .reset = drm_atomic_helper_connector_reset,
  47. .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  48. .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  49. };
  50. static int exynos_dpi_get_modes(struct drm_connector *connector)
  51. {
  52. struct exynos_dpi *ctx = connector_to_dpi(connector);
  53. /* fimd timings gets precedence over panel modes */
  54. if (ctx->vm) {
  55. struct drm_display_mode *mode;
  56. mode = drm_mode_create(connector->dev);
  57. if (!mode) {
  58. DRM_DEV_ERROR(ctx->dev,
  59. "failed to create a new display mode\n");
  60. return 0;
  61. }
  62. drm_display_mode_from_videomode(ctx->vm, mode);
  63. mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  64. drm_mode_probed_add(connector, mode);
  65. return 1;
  66. }
  67. if (ctx->panel)
  68. return drm_panel_get_modes(ctx->panel, connector);
  69. return 0;
  70. }
  71. static const struct drm_connector_helper_funcs exynos_dpi_connector_helper_funcs = {
  72. .get_modes = exynos_dpi_get_modes,
  73. };
  74. static int exynos_dpi_create_connector(struct drm_encoder *encoder)
  75. {
  76. struct exynos_dpi *ctx = encoder_to_dpi(encoder);
  77. struct drm_connector *connector = &ctx->connector;
  78. int ret;
  79. connector->polled = DRM_CONNECTOR_POLL_HPD;
  80. ret = drm_connector_init(encoder->dev, connector,
  81. &exynos_dpi_connector_funcs,
  82. DRM_MODE_CONNECTOR_VGA);
  83. if (ret) {
  84. DRM_DEV_ERROR(ctx->dev,
  85. "failed to initialize connector with drm\n");
  86. return ret;
  87. }
  88. drm_connector_helper_add(connector, &exynos_dpi_connector_helper_funcs);
  89. drm_connector_attach_encoder(connector, encoder);
  90. return 0;
  91. }
  92. static void exynos_dpi_mode_set(struct drm_encoder *encoder,
  93. struct drm_display_mode *mode,
  94. struct drm_display_mode *adjusted_mode)
  95. {
  96. }
  97. static void exynos_dpi_enable(struct drm_encoder *encoder)
  98. {
  99. struct exynos_dpi *ctx = encoder_to_dpi(encoder);
  100. if (ctx->panel) {
  101. drm_panel_prepare(ctx->panel);
  102. drm_panel_enable(ctx->panel);
  103. }
  104. }
  105. static void exynos_dpi_disable(struct drm_encoder *encoder)
  106. {
  107. struct exynos_dpi *ctx = encoder_to_dpi(encoder);
  108. if (ctx->panel) {
  109. drm_panel_disable(ctx->panel);
  110. drm_panel_unprepare(ctx->panel);
  111. }
  112. }
  113. static const struct drm_encoder_helper_funcs exynos_dpi_encoder_helper_funcs = {
  114. .mode_set = exynos_dpi_mode_set,
  115. .enable = exynos_dpi_enable,
  116. .disable = exynos_dpi_disable,
  117. };
  118. enum {
  119. FIMD_PORT_IN0,
  120. FIMD_PORT_IN1,
  121. FIMD_PORT_IN2,
  122. FIMD_PORT_RGB,
  123. FIMD_PORT_WRB,
  124. };
  125. static int exynos_dpi_parse_dt(struct exynos_dpi *ctx)
  126. {
  127. struct device *dev = ctx->dev;
  128. struct device_node *dn = dev->of_node;
  129. struct device_node *np;
  130. ctx->panel_node = of_graph_get_remote_node(dn, FIMD_PORT_RGB, 0);
  131. np = of_get_child_by_name(dn, "display-timings");
  132. if (np) {
  133. struct videomode *vm;
  134. int ret;
  135. of_node_put(np);
  136. vm = devm_kzalloc(dev, sizeof(*ctx->vm), GFP_KERNEL);
  137. if (!vm)
  138. return -ENOMEM;
  139. ret = of_get_videomode(dn, vm, 0);
  140. if (ret < 0) {
  141. devm_kfree(dev, vm);
  142. return ret;
  143. }
  144. ctx->vm = vm;
  145. return 0;
  146. }
  147. if (!ctx->panel_node)
  148. return -EINVAL;
  149. return 0;
  150. }
  151. int exynos_dpi_bind(struct drm_device *dev, struct drm_encoder *encoder)
  152. {
  153. int ret;
  154. drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_TMDS);
  155. drm_encoder_helper_add(encoder, &exynos_dpi_encoder_helper_funcs);
  156. ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_LCD);
  157. if (ret < 0)
  158. return ret;
  159. ret = exynos_dpi_create_connector(encoder);
  160. if (ret) {
  161. DRM_DEV_ERROR(encoder_to_dpi(encoder)->dev,
  162. "failed to create connector ret = %d\n", ret);
  163. drm_encoder_cleanup(encoder);
  164. return ret;
  165. }
  166. return 0;
  167. }
  168. struct drm_encoder *exynos_dpi_probe(struct device *dev)
  169. {
  170. struct exynos_dpi *ctx;
  171. int ret;
  172. ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
  173. if (!ctx)
  174. return ERR_PTR(-ENOMEM);
  175. ctx->dev = dev;
  176. ret = exynos_dpi_parse_dt(ctx);
  177. if (ret < 0) {
  178. devm_kfree(dev, ctx);
  179. return NULL;
  180. }
  181. if (ctx->panel_node) {
  182. ctx->panel = of_drm_find_panel(ctx->panel_node);
  183. if (IS_ERR(ctx->panel))
  184. return ERR_CAST(ctx->panel);
  185. }
  186. return &ctx->encoder;
  187. }
  188. int exynos_dpi_remove(struct drm_encoder *encoder)
  189. {
  190. struct exynos_dpi *ctx = encoder_to_dpi(encoder);
  191. exynos_dpi_disable(&ctx->encoder);
  192. return 0;
  193. }