exynos_drm_connector.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332
  1. /*
  2. * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  3. * Authors:
  4. * Inki Dae <inki.dae@samsung.com>
  5. * Joonyoung Shim <jy0922.shim@samsung.com>
  6. * Seung-Woo Kim <sw0312.kim@samsung.com>
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License as published by the
  10. * Free Software Foundation; either version 2 of the License, or (at your
  11. * option) any later version.
  12. */
  13. #include <drm/drmP.h>
  14. #include <drm/drm_crtc_helper.h>
  15. #include <drm/exynos_drm.h>
  16. #include "exynos_drm_drv.h"
  17. #include "exynos_drm_encoder.h"
  18. #define to_exynos_connector(x) container_of(x, struct exynos_drm_connector,\
  19. drm_connector)
  20. struct exynos_drm_connector {
  21. struct drm_connector drm_connector;
  22. uint32_t encoder_id;
  23. struct exynos_drm_manager *manager;
  24. uint32_t dpms;
  25. };
  26. /* convert exynos_video_timings to drm_display_mode */
  27. static inline void
  28. convert_to_display_mode(struct drm_display_mode *mode,
  29. struct exynos_drm_panel_info *panel)
  30. {
  31. struct fb_videomode *timing = &panel->timing;
  32. mode->clock = timing->pixclock / 1000;
  33. mode->vrefresh = timing->refresh;
  34. mode->hdisplay = timing->xres;
  35. mode->hsync_start = mode->hdisplay + timing->right_margin;
  36. mode->hsync_end = mode->hsync_start + timing->hsync_len;
  37. mode->htotal = mode->hsync_end + timing->left_margin;
  38. mode->vdisplay = timing->yres;
  39. mode->vsync_start = mode->vdisplay + timing->lower_margin;
  40. mode->vsync_end = mode->vsync_start + timing->vsync_len;
  41. mode->vtotal = mode->vsync_end + timing->upper_margin;
  42. mode->width_mm = panel->width_mm;
  43. mode->height_mm = panel->height_mm;
  44. if (timing->vmode & FB_VMODE_INTERLACED)
  45. mode->flags |= DRM_MODE_FLAG_INTERLACE;
  46. if (timing->vmode & FB_VMODE_DOUBLE)
  47. mode->flags |= DRM_MODE_FLAG_DBLSCAN;
  48. }
  49. static int exynos_drm_connector_get_modes(struct drm_connector *connector)
  50. {
  51. struct exynos_drm_connector *exynos_connector =
  52. to_exynos_connector(connector);
  53. struct exynos_drm_manager *manager = exynos_connector->manager;
  54. struct exynos_drm_display_ops *display_ops = manager->display_ops;
  55. struct edid *edid = NULL;
  56. unsigned int count = 0;
  57. int ret;
  58. if (!display_ops) {
  59. DRM_DEBUG_KMS("display_ops is null.\n");
  60. return 0;
  61. }
  62. /*
  63. * if get_edid() exists then get_edid() callback of hdmi side
  64. * is called to get edid data through i2c interface else
  65. * get timing from the FIMD driver(display controller).
  66. *
  67. * P.S. in case of lcd panel, count is always 1 if success
  68. * because lcd panel has only one mode.
  69. */
  70. if (display_ops->get_edid) {
  71. edid = display_ops->get_edid(manager->dev, connector);
  72. if (IS_ERR_OR_NULL(edid)) {
  73. ret = PTR_ERR(edid);
  74. edid = NULL;
  75. DRM_ERROR("Panel operation get_edid failed %d\n", ret);
  76. goto out;
  77. }
  78. count = drm_add_edid_modes(connector, edid);
  79. if (!count) {
  80. DRM_ERROR("Add edid modes failed %d\n", count);
  81. goto out;
  82. }
  83. drm_mode_connector_update_edid_property(connector, edid);
  84. } else {
  85. struct exynos_drm_panel_info *panel;
  86. struct drm_display_mode *mode = drm_mode_create(connector->dev);
  87. if (!mode) {
  88. DRM_ERROR("failed to create a new display mode.\n");
  89. return 0;
  90. }
  91. if (display_ops->get_panel)
  92. panel = display_ops->get_panel(manager->dev);
  93. else {
  94. drm_mode_destroy(connector->dev, mode);
  95. return 0;
  96. }
  97. convert_to_display_mode(mode, panel);
  98. connector->display_info.width_mm = mode->width_mm;
  99. connector->display_info.height_mm = mode->height_mm;
  100. mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  101. drm_mode_set_name(mode);
  102. drm_mode_probed_add(connector, mode);
  103. count = 1;
  104. }
  105. out:
  106. kfree(edid);
  107. return count;
  108. }
  109. static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
  110. struct drm_display_mode *mode)
  111. {
  112. struct exynos_drm_connector *exynos_connector =
  113. to_exynos_connector(connector);
  114. struct exynos_drm_manager *manager = exynos_connector->manager;
  115. struct exynos_drm_display_ops *display_ops = manager->display_ops;
  116. int ret = MODE_BAD;
  117. DRM_DEBUG_KMS("%s\n", __FILE__);
  118. if (display_ops && display_ops->check_mode)
  119. if (!display_ops->check_mode(manager->dev, mode))
  120. ret = MODE_OK;
  121. return ret;
  122. }
  123. struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
  124. {
  125. struct drm_device *dev = connector->dev;
  126. struct exynos_drm_connector *exynos_connector =
  127. to_exynos_connector(connector);
  128. struct drm_mode_object *obj;
  129. struct drm_encoder *encoder;
  130. obj = drm_mode_object_find(dev, exynos_connector->encoder_id,
  131. DRM_MODE_OBJECT_ENCODER);
  132. if (!obj) {
  133. DRM_DEBUG_KMS("Unknown ENCODER ID %d\n",
  134. exynos_connector->encoder_id);
  135. return NULL;
  136. }
  137. encoder = obj_to_encoder(obj);
  138. return encoder;
  139. }
  140. static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
  141. .get_modes = exynos_drm_connector_get_modes,
  142. .mode_valid = exynos_drm_connector_mode_valid,
  143. .best_encoder = exynos_drm_best_encoder,
  144. };
  145. void exynos_drm_display_power(struct drm_connector *connector, int mode)
  146. {
  147. struct drm_encoder *encoder = exynos_drm_best_encoder(connector);
  148. struct exynos_drm_connector *exynos_connector;
  149. struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
  150. struct exynos_drm_display_ops *display_ops = manager->display_ops;
  151. exynos_connector = to_exynos_connector(connector);
  152. if (exynos_connector->dpms == mode) {
  153. DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
  154. return;
  155. }
  156. if (display_ops && display_ops->power_on)
  157. display_ops->power_on(manager->dev, mode);
  158. exynos_connector->dpms = mode;
  159. }
  160. static void exynos_drm_connector_dpms(struct drm_connector *connector,
  161. int mode)
  162. {
  163. /*
  164. * in case that drm_crtc_helper_set_mode() is called,
  165. * encoder/crtc->funcs->dpms() will be just returned
  166. * because they already were DRM_MODE_DPMS_ON so only
  167. * exynos_drm_display_power() will be called.
  168. */
  169. drm_helper_connector_dpms(connector, mode);
  170. exynos_drm_display_power(connector, mode);
  171. }
  172. static int exynos_drm_connector_fill_modes(struct drm_connector *connector,
  173. unsigned int max_width, unsigned int max_height)
  174. {
  175. struct exynos_drm_connector *exynos_connector =
  176. to_exynos_connector(connector);
  177. struct exynos_drm_manager *manager = exynos_connector->manager;
  178. struct exynos_drm_manager_ops *ops = manager->ops;
  179. unsigned int width, height;
  180. width = max_width;
  181. height = max_height;
  182. /*
  183. * if specific driver want to find desired_mode using maxmum
  184. * resolution then get max width and height from that driver.
  185. */
  186. if (ops && ops->get_max_resol)
  187. ops->get_max_resol(manager->dev, &width, &height);
  188. return drm_helper_probe_single_connector_modes(connector, width,
  189. height);
  190. }
  191. /* get detection status of display device. */
  192. static enum drm_connector_status
  193. exynos_drm_connector_detect(struct drm_connector *connector, bool force)
  194. {
  195. struct exynos_drm_connector *exynos_connector =
  196. to_exynos_connector(connector);
  197. struct exynos_drm_manager *manager = exynos_connector->manager;
  198. struct exynos_drm_display_ops *display_ops =
  199. manager->display_ops;
  200. enum drm_connector_status status = connector_status_disconnected;
  201. if (display_ops && display_ops->is_connected) {
  202. if (display_ops->is_connected(manager->dev))
  203. status = connector_status_connected;
  204. else
  205. status = connector_status_disconnected;
  206. }
  207. return status;
  208. }
  209. static void exynos_drm_connector_destroy(struct drm_connector *connector)
  210. {
  211. struct exynos_drm_connector *exynos_connector =
  212. to_exynos_connector(connector);
  213. drm_sysfs_connector_remove(connector);
  214. drm_connector_cleanup(connector);
  215. kfree(exynos_connector);
  216. }
  217. static struct drm_connector_funcs exynos_connector_funcs = {
  218. .dpms = exynos_drm_connector_dpms,
  219. .fill_modes = exynos_drm_connector_fill_modes,
  220. .detect = exynos_drm_connector_detect,
  221. .destroy = exynos_drm_connector_destroy,
  222. };
  223. struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
  224. struct drm_encoder *encoder)
  225. {
  226. struct exynos_drm_connector *exynos_connector;
  227. struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
  228. struct drm_connector *connector;
  229. int type;
  230. int err;
  231. exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL);
  232. if (!exynos_connector) {
  233. DRM_ERROR("failed to allocate connector\n");
  234. return NULL;
  235. }
  236. connector = &exynos_connector->drm_connector;
  237. switch (manager->display_ops->type) {
  238. case EXYNOS_DISPLAY_TYPE_HDMI:
  239. type = DRM_MODE_CONNECTOR_HDMIA;
  240. connector->interlace_allowed = true;
  241. connector->polled = DRM_CONNECTOR_POLL_HPD;
  242. break;
  243. case EXYNOS_DISPLAY_TYPE_VIDI:
  244. type = DRM_MODE_CONNECTOR_VIRTUAL;
  245. connector->polled = DRM_CONNECTOR_POLL_HPD;
  246. break;
  247. default:
  248. type = DRM_MODE_CONNECTOR_Unknown;
  249. break;
  250. }
  251. drm_connector_init(dev, connector, &exynos_connector_funcs, type);
  252. drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
  253. err = drm_sysfs_connector_add(connector);
  254. if (err)
  255. goto err_connector;
  256. exynos_connector->encoder_id = encoder->base.id;
  257. exynos_connector->manager = manager;
  258. exynos_connector->dpms = DRM_MODE_DPMS_OFF;
  259. connector->dpms = DRM_MODE_DPMS_OFF;
  260. connector->encoder = encoder;
  261. err = drm_mode_connector_attach_encoder(connector, encoder);
  262. if (err) {
  263. DRM_ERROR("failed to attach a connector to a encoder\n");
  264. goto err_sysfs;
  265. }
  266. DRM_DEBUG_KMS("connector has been created\n");
  267. return connector;
  268. err_sysfs:
  269. drm_sysfs_connector_remove(connector);
  270. err_connector:
  271. drm_connector_cleanup(connector);
  272. kfree(exynos_connector);
  273. return NULL;
  274. }