2 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
4 * Inki Dae <inki.dae@samsung.com>
5 * Joonyoung Shim <jy0922.shim@samsung.com>
6 * Seung-Woo Kim <sw0312.kim@samsung.com>
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.
15 #include <drm/drm_crtc_helper.h>
17 #include <drm/exynos_drm.h>
18 #include "exynos_drm_drv.h"
19 #include "exynos_drm_encoder.h"
21 #define to_exynos_connector(x) container_of(x, struct exynos_drm_connector,\
24 struct exynos_drm_connector {
25 struct drm_connector drm_connector;
27 struct exynos_drm_manager *manager;
31 /* convert exynos_video_timings to drm_display_mode */
33 convert_to_display_mode(struct drm_display_mode *mode,
34 struct exynos_drm_panel_info *panel)
36 struct fb_videomode *timing = &panel->timing;
37 DRM_DEBUG_KMS("%s\n", __FILE__);
39 mode->clock = timing->pixclock / 1000;
40 mode->vrefresh = timing->refresh;
42 mode->hdisplay = timing->xres;
43 mode->hsync_start = mode->hdisplay + timing->right_margin;
44 mode->hsync_end = mode->hsync_start + timing->hsync_len;
45 mode->htotal = mode->hsync_end + timing->left_margin;
47 mode->vdisplay = timing->yres;
48 mode->vsync_start = mode->vdisplay + timing->lower_margin;
49 mode->vsync_end = mode->vsync_start + timing->vsync_len;
50 mode->vtotal = mode->vsync_end + timing->upper_margin;
51 mode->width_mm = panel->width_mm;
52 mode->height_mm = panel->height_mm;
54 if (timing->vmode & FB_VMODE_INTERLACED)
55 mode->flags |= DRM_MODE_FLAG_INTERLACE;
57 if (timing->vmode & FB_VMODE_DOUBLE)
58 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
61 /* convert drm_display_mode to exynos_video_timings */
63 convert_to_video_timing(struct fb_videomode *timing,
64 struct drm_display_mode *mode)
66 DRM_DEBUG_KMS("%s\n", __FILE__);
68 memset(timing, 0, sizeof(*timing));
70 timing->pixclock = mode->clock * 1000;
71 timing->refresh = drm_mode_vrefresh(mode);
73 timing->xres = mode->hdisplay;
74 timing->right_margin = mode->hsync_start - mode->hdisplay;
75 timing->hsync_len = mode->hsync_end - mode->hsync_start;
76 timing->left_margin = mode->htotal - mode->hsync_end;
78 timing->yres = mode->vdisplay;
79 timing->lower_margin = mode->vsync_start - mode->vdisplay;
80 timing->vsync_len = mode->vsync_end - mode->vsync_start;
81 timing->upper_margin = mode->vtotal - mode->vsync_end;
83 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
84 timing->vmode = FB_VMODE_INTERLACED;
86 timing->vmode = FB_VMODE_NONINTERLACED;
88 if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
89 timing->vmode |= FB_VMODE_DOUBLE;
92 static int exynos_drm_connector_get_modes(struct drm_connector *connector)
94 struct exynos_drm_connector *exynos_connector =
95 to_exynos_connector(connector);
96 struct exynos_drm_manager *manager = exynos_connector->manager;
97 struct exynos_drm_display_ops *display_ops = manager->display_ops;
98 struct edid *edid = NULL;
99 unsigned int count = 0;
102 DRM_DEBUG_KMS("%s\n", __FILE__);
105 DRM_DEBUG_KMS("display_ops is null.\n");
110 * if get_edid() exists then get_edid() callback of hdmi side
111 * is called to get edid data through i2c interface else
112 * get timing from the FIMD driver(display controller).
114 * P.S. in case of lcd panel, count is always 1 if success
115 * because lcd panel has only one mode.
117 if (display_ops->get_edid) {
118 edid = display_ops->get_edid(manager->dev, connector);
119 if (IS_ERR_OR_NULL(edid)) {
122 DRM_ERROR("Panel operation get_edid failed %d\n", ret);
126 count = drm_add_edid_modes(connector, edid);
128 DRM_ERROR("Add edid modes failed %d\n", count);
132 drm_mode_connector_update_edid_property(connector, edid);
134 struct exynos_drm_panel_info *panel;
135 struct drm_display_mode *mode = drm_mode_create(connector->dev);
137 DRM_ERROR("failed to create a new display mode.\n");
141 if (display_ops->get_panel)
142 panel = display_ops->get_panel(manager->dev);
144 drm_mode_destroy(connector->dev, mode);
148 convert_to_display_mode(mode, panel);
149 connector->display_info.width_mm = mode->width_mm;
150 connector->display_info.height_mm = mode->height_mm;
152 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
153 drm_mode_set_name(mode);
154 drm_mode_probed_add(connector, mode);
164 static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
165 struct drm_display_mode *mode)
167 struct exynos_drm_connector *exynos_connector =
168 to_exynos_connector(connector);
169 struct exynos_drm_manager *manager = exynos_connector->manager;
170 struct exynos_drm_display_ops *display_ops = manager->display_ops;
171 struct fb_videomode timing;
174 DRM_DEBUG_KMS("%s\n", __FILE__);
176 convert_to_video_timing(&timing, mode);
178 if (display_ops && display_ops->check_timing)
179 if (!display_ops->check_timing(manager->dev, (void *)&timing))
185 struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
187 struct drm_device *dev = connector->dev;
188 struct exynos_drm_connector *exynos_connector =
189 to_exynos_connector(connector);
190 struct drm_mode_object *obj;
191 struct drm_encoder *encoder;
193 DRM_DEBUG_KMS("%s\n", __FILE__);
195 obj = drm_mode_object_find(dev, exynos_connector->encoder_id,
196 DRM_MODE_OBJECT_ENCODER);
198 DRM_DEBUG_KMS("Unknown ENCODER ID %d\n",
199 exynos_connector->encoder_id);
203 encoder = obj_to_encoder(obj);
208 static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
209 .get_modes = exynos_drm_connector_get_modes,
210 .mode_valid = exynos_drm_connector_mode_valid,
211 .best_encoder = exynos_drm_best_encoder,
214 void exynos_drm_display_power(struct drm_connector *connector, int mode)
216 struct drm_encoder *encoder = exynos_drm_best_encoder(connector);
217 struct exynos_drm_connector *exynos_connector;
218 struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
219 struct exynos_drm_display_ops *display_ops = manager->display_ops;
221 exynos_connector = to_exynos_connector(connector);
223 if (exynos_connector->dpms == mode) {
224 DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
228 if (display_ops && display_ops->power_on)
229 display_ops->power_on(manager->dev, mode);
231 exynos_connector->dpms = mode;
234 static void exynos_drm_connector_dpms(struct drm_connector *connector,
237 DRM_DEBUG_KMS("%s\n", __FILE__);
240 * in case that drm_crtc_helper_set_mode() is called,
241 * encoder/crtc->funcs->dpms() will be just returned
242 * because they already were DRM_MODE_DPMS_ON so only
243 * exynos_drm_display_power() will be called.
245 drm_helper_connector_dpms(connector, mode);
247 exynos_drm_display_power(connector, mode);
251 static int exynos_drm_connector_fill_modes(struct drm_connector *connector,
252 unsigned int max_width, unsigned int max_height)
254 struct exynos_drm_connector *exynos_connector =
255 to_exynos_connector(connector);
256 struct exynos_drm_manager *manager = exynos_connector->manager;
257 struct exynos_drm_manager_ops *ops = manager->ops;
258 unsigned int width, height;
264 * if specific driver want to find desired_mode using maxmum
265 * resolution then get max width and height from that driver.
267 if (ops && ops->get_max_resol)
268 ops->get_max_resol(manager->dev, &width, &height);
270 return drm_helper_probe_single_connector_modes(connector, width,
274 /* get detection status of display device. */
275 static enum drm_connector_status
276 exynos_drm_connector_detect(struct drm_connector *connector, bool force)
278 struct exynos_drm_connector *exynos_connector =
279 to_exynos_connector(connector);
280 struct exynos_drm_manager *manager = exynos_connector->manager;
281 struct exynos_drm_display_ops *display_ops =
282 manager->display_ops;
283 enum drm_connector_status status = connector_status_disconnected;
285 DRM_DEBUG_KMS("%s\n", __FILE__);
287 if (display_ops && display_ops->is_connected) {
288 if (display_ops->is_connected(manager->dev))
289 status = connector_status_connected;
291 status = connector_status_disconnected;
297 static void exynos_drm_connector_destroy(struct drm_connector *connector)
299 struct exynos_drm_connector *exynos_connector =
300 to_exynos_connector(connector);
302 DRM_DEBUG_KMS("%s\n", __FILE__);
304 drm_sysfs_connector_remove(connector);
305 drm_connector_cleanup(connector);
306 kfree(exynos_connector);
309 static struct drm_connector_funcs exynos_connector_funcs = {
310 .dpms = exynos_drm_connector_dpms,
311 .fill_modes = exynos_drm_connector_fill_modes,
312 .detect = exynos_drm_connector_detect,
313 .destroy = exynos_drm_connector_destroy,
316 struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
317 struct drm_encoder *encoder)
319 struct exynos_drm_connector *exynos_connector;
320 struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
321 struct drm_connector *connector;
325 DRM_DEBUG_KMS("%s\n", __FILE__);
327 exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL);
328 if (!exynos_connector) {
329 DRM_ERROR("failed to allocate connector\n");
333 connector = &exynos_connector->drm_connector;
335 switch (manager->display_ops->type) {
336 case EXYNOS_DISPLAY_TYPE_HDMI:
337 type = DRM_MODE_CONNECTOR_HDMIA;
338 connector->interlace_allowed = true;
339 connector->polled = DRM_CONNECTOR_POLL_HPD;
341 case EXYNOS_DISPLAY_TYPE_VIDI:
342 type = DRM_MODE_CONNECTOR_VIRTUAL;
343 connector->polled = DRM_CONNECTOR_POLL_HPD;
346 type = DRM_MODE_CONNECTOR_Unknown;
350 drm_connector_init(dev, connector, &exynos_connector_funcs, type);
351 drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
353 err = drm_sysfs_connector_add(connector);
357 exynos_connector->encoder_id = encoder->base.id;
358 exynos_connector->manager = manager;
359 exynos_connector->dpms = DRM_MODE_DPMS_OFF;
360 connector->dpms = DRM_MODE_DPMS_OFF;
361 connector->encoder = encoder;
363 err = drm_mode_connector_attach_encoder(connector, encoder);
365 DRM_ERROR("failed to attach a connector to a encoder\n");
369 DRM_DEBUG_KMS("connector has been created\n");
374 drm_sysfs_connector_remove(connector);
376 drm_connector_cleanup(connector);
377 kfree(exynos_connector);