simple-bridge.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2015-2016 Free Electrons
  4. * Copyright (C) 2015-2016 NextThing Co
  5. *
  6. * Maxime Ripard <maxime.ripard@free-electrons.com>
  7. */
  8. #include <linux/gpio/consumer.h>
  9. #include <linux/module.h>
  10. #include <linux/of_device.h>
  11. #include <linux/of_graph.h>
  12. #include <linux/regulator/consumer.h>
  13. #include <drm/drm_atomic_helper.h>
  14. #include <drm/drm_bridge.h>
  15. #include <drm/drm_crtc.h>
  16. #include <drm/drm_print.h>
  17. #include <drm/drm_probe_helper.h>
  18. struct simple_bridge_info {
  19. const struct drm_bridge_timings *timings;
  20. unsigned int connector_type;
  21. };
  22. struct simple_bridge {
  23. struct drm_bridge bridge;
  24. struct drm_connector connector;
  25. const struct simple_bridge_info *info;
  26. struct drm_bridge *next_bridge;
  27. struct regulator *vdd;
  28. struct gpio_desc *enable;
  29. };
  30. static inline struct simple_bridge *
  31. drm_bridge_to_simple_bridge(struct drm_bridge *bridge)
  32. {
  33. return container_of(bridge, struct simple_bridge, bridge);
  34. }
  35. static inline struct simple_bridge *
  36. drm_connector_to_simple_bridge(struct drm_connector *connector)
  37. {
  38. return container_of(connector, struct simple_bridge, connector);
  39. }
  40. static int simple_bridge_get_modes(struct drm_connector *connector)
  41. {
  42. struct simple_bridge *sbridge = drm_connector_to_simple_bridge(connector);
  43. struct edid *edid;
  44. int ret;
  45. if (sbridge->next_bridge->ops & DRM_BRIDGE_OP_EDID) {
  46. edid = drm_bridge_get_edid(sbridge->next_bridge, connector);
  47. if (!edid)
  48. DRM_INFO("EDID read failed. Fallback to standard modes\n");
  49. } else {
  50. edid = NULL;
  51. }
  52. if (!edid) {
  53. /*
  54. * In case we cannot retrieve the EDIDs (missing or broken DDC
  55. * bus from the next bridge), fallback on the XGA standards and
  56. * prefer a mode pretty much anyone can handle.
  57. */
  58. ret = drm_add_modes_noedid(connector, 1920, 1200);
  59. drm_set_preferred_mode(connector, 1024, 768);
  60. return ret;
  61. }
  62. drm_connector_update_edid_property(connector, edid);
  63. ret = drm_add_edid_modes(connector, edid);
  64. kfree(edid);
  65. return ret;
  66. }
  67. static const struct drm_connector_helper_funcs simple_bridge_con_helper_funcs = {
  68. .get_modes = simple_bridge_get_modes,
  69. };
  70. static enum drm_connector_status
  71. simple_bridge_connector_detect(struct drm_connector *connector, bool force)
  72. {
  73. struct simple_bridge *sbridge = drm_connector_to_simple_bridge(connector);
  74. return drm_bridge_detect(sbridge->next_bridge);
  75. }
  76. static const struct drm_connector_funcs simple_bridge_con_funcs = {
  77. .detect = simple_bridge_connector_detect,
  78. .fill_modes = drm_helper_probe_single_connector_modes,
  79. .destroy = drm_connector_cleanup,
  80. .reset = drm_atomic_helper_connector_reset,
  81. .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  82. .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  83. };
  84. static int simple_bridge_attach(struct drm_bridge *bridge,
  85. enum drm_bridge_attach_flags flags)
  86. {
  87. struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
  88. int ret;
  89. ret = drm_bridge_attach(bridge->encoder, sbridge->next_bridge, bridge,
  90. DRM_BRIDGE_ATTACH_NO_CONNECTOR);
  91. if (ret < 0)
  92. return ret;
  93. if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
  94. return 0;
  95. if (!bridge->encoder) {
  96. DRM_ERROR("Missing encoder\n");
  97. return -ENODEV;
  98. }
  99. drm_connector_helper_add(&sbridge->connector,
  100. &simple_bridge_con_helper_funcs);
  101. ret = drm_connector_init_with_ddc(bridge->dev, &sbridge->connector,
  102. &simple_bridge_con_funcs,
  103. sbridge->info->connector_type,
  104. sbridge->next_bridge->ddc);
  105. if (ret) {
  106. DRM_ERROR("Failed to initialize connector\n");
  107. return ret;
  108. }
  109. drm_connector_attach_encoder(&sbridge->connector, bridge->encoder);
  110. return 0;
  111. }
  112. static void simple_bridge_enable(struct drm_bridge *bridge)
  113. {
  114. struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
  115. int ret;
  116. if (sbridge->vdd) {
  117. ret = regulator_enable(sbridge->vdd);
  118. if (ret)
  119. DRM_ERROR("Failed to enable vdd regulator: %d\n", ret);
  120. }
  121. gpiod_set_value_cansleep(sbridge->enable, 1);
  122. }
  123. static void simple_bridge_disable(struct drm_bridge *bridge)
  124. {
  125. struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
  126. gpiod_set_value_cansleep(sbridge->enable, 0);
  127. if (sbridge->vdd)
  128. regulator_disable(sbridge->vdd);
  129. }
  130. static const struct drm_bridge_funcs simple_bridge_bridge_funcs = {
  131. .attach = simple_bridge_attach,
  132. .enable = simple_bridge_enable,
  133. .disable = simple_bridge_disable,
  134. };
  135. static int simple_bridge_probe(struct platform_device *pdev)
  136. {
  137. struct simple_bridge *sbridge;
  138. struct device_node *remote;
  139. sbridge = devm_kzalloc(&pdev->dev, sizeof(*sbridge), GFP_KERNEL);
  140. if (!sbridge)
  141. return -ENOMEM;
  142. platform_set_drvdata(pdev, sbridge);
  143. sbridge->info = of_device_get_match_data(&pdev->dev);
  144. /* Get the next bridge in the pipeline. */
  145. remote = of_graph_get_remote_node(pdev->dev.of_node, 1, -1);
  146. if (!remote)
  147. return -EINVAL;
  148. sbridge->next_bridge = of_drm_find_bridge(remote);
  149. of_node_put(remote);
  150. if (!sbridge->next_bridge) {
  151. dev_dbg(&pdev->dev, "Next bridge not found, deferring probe\n");
  152. return -EPROBE_DEFER;
  153. }
  154. /* Get the regulator and GPIO resources. */
  155. sbridge->vdd = devm_regulator_get_optional(&pdev->dev, "vdd");
  156. if (IS_ERR(sbridge->vdd)) {
  157. int ret = PTR_ERR(sbridge->vdd);
  158. if (ret == -EPROBE_DEFER)
  159. return -EPROBE_DEFER;
  160. sbridge->vdd = NULL;
  161. dev_dbg(&pdev->dev, "No vdd regulator found: %d\n", ret);
  162. }
  163. sbridge->enable = devm_gpiod_get_optional(&pdev->dev, "enable",
  164. GPIOD_OUT_LOW);
  165. if (IS_ERR(sbridge->enable)) {
  166. if (PTR_ERR(sbridge->enable) != -EPROBE_DEFER)
  167. dev_err(&pdev->dev, "Unable to retrieve enable GPIO\n");
  168. return PTR_ERR(sbridge->enable);
  169. }
  170. /* Register the bridge. */
  171. sbridge->bridge.funcs = &simple_bridge_bridge_funcs;
  172. sbridge->bridge.of_node = pdev->dev.of_node;
  173. sbridge->bridge.timings = sbridge->info->timings;
  174. drm_bridge_add(&sbridge->bridge);
  175. return 0;
  176. }
  177. static int simple_bridge_remove(struct platform_device *pdev)
  178. {
  179. struct simple_bridge *sbridge = platform_get_drvdata(pdev);
  180. drm_bridge_remove(&sbridge->bridge);
  181. return 0;
  182. }
  183. /*
  184. * We assume the ADV7123 DAC is the "default" for historical reasons
  185. * Information taken from the ADV7123 datasheet, revision D.
  186. * NOTE: the ADV7123EP seems to have other timings and need a new timings
  187. * set if used.
  188. */
  189. static const struct drm_bridge_timings default_bridge_timings = {
  190. /* Timing specifications, datasheet page 7 */
  191. .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
  192. .setup_time_ps = 500,
  193. .hold_time_ps = 1500,
  194. };
  195. /*
  196. * Information taken from the THS8134, THS8134A, THS8134B datasheet named
  197. * "SLVS205D", dated May 1990, revised March 2000.
  198. */
  199. static const struct drm_bridge_timings ti_ths8134_bridge_timings = {
  200. /* From timing diagram, datasheet page 9 */
  201. .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
  202. /* From datasheet, page 12 */
  203. .setup_time_ps = 3000,
  204. /* I guess this means latched input */
  205. .hold_time_ps = 0,
  206. };
  207. /*
  208. * Information taken from the THS8135 datasheet named "SLAS343B", dated
  209. * May 2001, revised April 2013.
  210. */
  211. static const struct drm_bridge_timings ti_ths8135_bridge_timings = {
  212. /* From timing diagram, datasheet page 14 */
  213. .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
  214. /* From datasheet, page 16 */
  215. .setup_time_ps = 2000,
  216. .hold_time_ps = 500,
  217. };
  218. static const struct of_device_id simple_bridge_match[] = {
  219. {
  220. .compatible = "dumb-vga-dac",
  221. .data = &(const struct simple_bridge_info) {
  222. .connector_type = DRM_MODE_CONNECTOR_VGA,
  223. },
  224. }, {
  225. .compatible = "adi,adv7123",
  226. .data = &(const struct simple_bridge_info) {
  227. .timings = &default_bridge_timings,
  228. .connector_type = DRM_MODE_CONNECTOR_VGA,
  229. },
  230. }, {
  231. .compatible = "ti,opa362",
  232. .data = &(const struct simple_bridge_info) {
  233. .connector_type = DRM_MODE_CONNECTOR_Composite,
  234. },
  235. }, {
  236. .compatible = "ti,ths8135",
  237. .data = &(const struct simple_bridge_info) {
  238. .timings = &ti_ths8135_bridge_timings,
  239. .connector_type = DRM_MODE_CONNECTOR_VGA,
  240. },
  241. }, {
  242. .compatible = "ti,ths8134",
  243. .data = &(const struct simple_bridge_info) {
  244. .timings = &ti_ths8134_bridge_timings,
  245. .connector_type = DRM_MODE_CONNECTOR_VGA,
  246. },
  247. },
  248. {},
  249. };
  250. MODULE_DEVICE_TABLE(of, simple_bridge_match);
  251. static struct platform_driver simple_bridge_driver = {
  252. .probe = simple_bridge_probe,
  253. .remove = simple_bridge_remove,
  254. .driver = {
  255. .name = "simple-bridge",
  256. .of_match_table = simple_bridge_match,
  257. },
  258. };
  259. module_platform_driver(simple_bridge_driver);
  260. MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
  261. MODULE_DESCRIPTION("Simple DRM bridge driver");
  262. MODULE_LICENSE("GPL");