1 /* exynos_drm_encoder.c
3 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
5 * Inki Dae <inki.dae@samsung.com>
6 * Joonyoung Shim <jy0922.shim@samsung.com>
7 * Seung-Woo Kim <sw0312.kim@samsung.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice (including the next
17 * paragraph) shall be included in all copies or substantial portions of the
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26 * OTHER DEALINGS IN THE SOFTWARE.
30 #include <drm/drm_crtc_helper.h>
32 #include "exynos_drm_drv.h"
33 #include "exynos_drm_encoder.h"
34 #include "exynos_drm_connector.h"
36 #define to_exynos_encoder(x) container_of(x, struct exynos_drm_encoder,\
40 * exynos specific encoder structure.
42 * @drm_encoder: encoder object.
43 * @manager: specific encoder has its own manager to control a hardware
44 * appropriately and we can access a hardware drawing on this manager.
45 * @dpms: store the encoder dpms value.
47 struct exynos_drm_encoder {
48 struct drm_crtc *old_crtc;
49 struct drm_encoder drm_encoder;
50 struct exynos_drm_manager *manager;
54 static void exynos_drm_connector_power(struct drm_encoder *encoder, int mode)
56 struct drm_device *dev = encoder->dev;
57 struct drm_connector *connector;
59 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
60 if (exynos_drm_best_encoder(connector) == encoder) {
61 DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
62 connector->base.id, mode);
64 exynos_drm_display_power(connector, mode);
69 static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
71 struct drm_device *dev = encoder->dev;
72 struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
73 struct exynos_drm_manager_ops *manager_ops = manager->ops;
74 struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
76 DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);
78 if (exynos_encoder->dpms == mode) {
79 DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
83 mutex_lock(&dev->struct_mutex);
86 case DRM_MODE_DPMS_ON:
87 if (manager_ops && manager_ops->apply)
88 manager_ops->apply(manager->dev);
89 exynos_drm_connector_power(encoder, mode);
90 exynos_encoder->dpms = mode;
92 case DRM_MODE_DPMS_STANDBY:
93 case DRM_MODE_DPMS_SUSPEND:
94 case DRM_MODE_DPMS_OFF:
95 exynos_drm_connector_power(encoder, mode);
96 exynos_encoder->dpms = mode;
99 DRM_ERROR("unspecified mode %d\n", mode);
103 mutex_unlock(&dev->struct_mutex);
107 exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
108 const struct drm_display_mode *mode,
109 struct drm_display_mode *adjusted_mode)
111 struct drm_device *dev = encoder->dev;
112 struct drm_connector *connector;
113 struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
114 struct exynos_drm_manager_ops *manager_ops = manager->ops;
116 DRM_DEBUG_KMS("%s\n", __FILE__);
118 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
119 if (connector->encoder == encoder)
120 if (manager_ops && manager_ops->mode_fixup)
121 manager_ops->mode_fixup(manager->dev, connector,
122 mode, adjusted_mode);
128 static void disable_plane_to_crtc(struct drm_device *dev,
129 struct drm_crtc *old_crtc,
130 struct drm_crtc *new_crtc)
132 struct drm_plane *plane;
135 * if old_crtc isn't same as encoder->crtc then it means that
136 * user changed crtc id to another one so the plane to old_crtc
137 * should be disabled and plane->crtc should be set to new_crtc
140 list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
141 if (plane->crtc == old_crtc) {
143 * do not change below call order.
145 * plane->funcs->disable_plane call checks
146 * if encoder->crtc is same as plane->crtc and if same
147 * then overlay_ops->disable callback will be called
148 * to diasble current hw overlay so plane->crtc should
149 * have new_crtc because new_crtc was set to
150 * encoder->crtc in advance.
152 plane->crtc = new_crtc;
153 plane->funcs->disable_plane(plane);
158 static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
159 struct drm_display_mode *mode,
160 struct drm_display_mode *adjusted_mode)
162 struct drm_device *dev = encoder->dev;
163 struct drm_connector *connector;
164 struct exynos_drm_manager *manager;
165 struct exynos_drm_manager_ops *manager_ops;
167 DRM_DEBUG_KMS("%s\n", __FILE__);
169 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
170 if (connector->encoder == encoder) {
171 struct exynos_drm_encoder *exynos_encoder;
173 exynos_encoder = to_exynos_encoder(encoder);
175 if (exynos_encoder->old_crtc != encoder->crtc &&
176 exynos_encoder->old_crtc) {
179 * disable a plane to old crtc and change
180 * crtc of the plane to new one.
182 disable_plane_to_crtc(dev,
183 exynos_encoder->old_crtc,
187 manager = exynos_drm_get_manager(encoder);
188 manager_ops = manager->ops;
190 if (manager_ops && manager_ops->mode_set)
191 manager_ops->mode_set(manager->dev,
194 exynos_encoder->old_crtc = encoder->crtc;
199 static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
201 DRM_DEBUG_KMS("%s\n", __FILE__);
203 /* drm framework doesn't check NULL. */
206 static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
208 struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
209 struct exynos_drm_manager_ops *manager_ops = manager->ops;
211 DRM_DEBUG_KMS("%s\n", __FILE__);
213 if (manager_ops && manager_ops->commit)
214 manager_ops->commit(manager->dev);
217 static void exynos_drm_encoder_disable(struct drm_encoder *encoder)
219 struct drm_plane *plane;
220 struct drm_device *dev = encoder->dev;
222 exynos_drm_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
224 /* all planes connected to this encoder should be also disabled. */
225 list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
226 if (plane->crtc == encoder->crtc)
227 plane->funcs->disable_plane(plane);
231 static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
232 .dpms = exynos_drm_encoder_dpms,
233 .mode_fixup = exynos_drm_encoder_mode_fixup,
234 .mode_set = exynos_drm_encoder_mode_set,
235 .prepare = exynos_drm_encoder_prepare,
236 .commit = exynos_drm_encoder_commit,
237 .disable = exynos_drm_encoder_disable,
240 static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
242 struct exynos_drm_encoder *exynos_encoder =
243 to_exynos_encoder(encoder);
245 DRM_DEBUG_KMS("%s\n", __FILE__);
247 exynos_encoder->manager->pipe = -1;
249 drm_encoder_cleanup(encoder);
250 kfree(exynos_encoder);
253 static struct drm_encoder_funcs exynos_encoder_funcs = {
254 .destroy = exynos_drm_encoder_destroy,
257 static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
259 struct drm_encoder *clone;
260 struct drm_device *dev = encoder->dev;
261 struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
262 struct exynos_drm_display_ops *display_ops =
263 exynos_encoder->manager->display_ops;
264 unsigned int clone_mask = 0;
267 list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
268 switch (display_ops->type) {
269 case EXYNOS_DISPLAY_TYPE_LCD:
270 case EXYNOS_DISPLAY_TYPE_HDMI:
271 case EXYNOS_DISPLAY_TYPE_VIDI:
272 clone_mask |= (1 << (cnt++));
282 void exynos_drm_encoder_setup(struct drm_device *dev)
284 struct drm_encoder *encoder;
286 DRM_DEBUG_KMS("%s\n", __FILE__);
288 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
289 encoder->possible_clones = exynos_drm_encoder_clones(encoder);
293 exynos_drm_encoder_create(struct drm_device *dev,
294 struct exynos_drm_manager *manager,
295 unsigned int possible_crtcs)
297 struct drm_encoder *encoder;
298 struct exynos_drm_encoder *exynos_encoder;
300 DRM_DEBUG_KMS("%s\n", __FILE__);
302 if (!manager || !possible_crtcs)
308 exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
309 if (!exynos_encoder) {
310 DRM_ERROR("failed to allocate encoder\n");
314 exynos_encoder->dpms = DRM_MODE_DPMS_OFF;
315 exynos_encoder->manager = manager;
316 encoder = &exynos_encoder->drm_encoder;
317 encoder->possible_crtcs = possible_crtcs;
319 DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
321 drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
322 DRM_MODE_ENCODER_TMDS);
324 drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);
326 DRM_DEBUG_KMS("encoder has been created\n");
331 struct exynos_drm_manager *exynos_drm_get_manager(struct drm_encoder *encoder)
333 return to_exynos_encoder(encoder)->manager;
336 void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
337 void (*fn)(struct drm_encoder *, void *))
339 struct drm_device *dev = crtc->dev;
340 struct drm_encoder *encoder;
341 struct exynos_drm_private *private = dev->dev_private;
342 struct exynos_drm_manager *manager;
344 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
346 * if crtc is detached from encoder, check pipe,
347 * otherwise check crtc attached to encoder
349 if (!encoder->crtc) {
350 manager = to_exynos_encoder(encoder)->manager;
351 if (manager->pipe < 0 ||
352 private->crtc[manager->pipe] != crtc)
355 if (encoder->crtc != crtc)
363 void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data)
365 struct exynos_drm_manager *manager =
366 to_exynos_encoder(encoder)->manager;
367 struct exynos_drm_manager_ops *manager_ops = manager->ops;
368 int crtc = *(int *)data;
370 if (manager->pipe != crtc)
373 if (manager_ops->enable_vblank)
374 manager_ops->enable_vblank(manager->dev);
377 void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data)
379 struct exynos_drm_manager *manager =
380 to_exynos_encoder(encoder)->manager;
381 struct exynos_drm_manager_ops *manager_ops = manager->ops;
382 int crtc = *(int *)data;
384 if (manager->pipe != crtc)
387 if (manager_ops->disable_vblank)
388 manager_ops->disable_vblank(manager->dev);
391 void exynos_drm_encoder_crtc_dpms(struct drm_encoder *encoder, void *data)
393 struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
394 struct exynos_drm_manager *manager = exynos_encoder->manager;
395 struct exynos_drm_manager_ops *manager_ops = manager->ops;
396 int mode = *(int *)data;
398 DRM_DEBUG_KMS("%s\n", __FILE__);
400 if (manager_ops && manager_ops->dpms)
401 manager_ops->dpms(manager->dev, mode);
404 * set current mode to new one so that data aren't updated into
405 * registers by drm_helper_connector_dpms two times.
407 * in case that drm_crtc_helper_set_mode() is called,
408 * overlay_ops->commit() and manager_ops->commit() callbacks
409 * can be called two times, first at drm_crtc_helper_set_mode()
410 * and second at drm_helper_connector_dpms().
411 * so with this setting, when drm_helper_connector_dpms() is called
412 * encoder->funcs->dpms() will be ignored.
414 exynos_encoder->dpms = mode;
417 * if this condition is ok then it means that the crtc is already
418 * detached from encoder and last function for detaching is properly
419 * done, so clear pipe from manager to prevent repeated call.
421 if (mode > DRM_MODE_DPMS_ON) {
427 void exynos_drm_encoder_crtc_pipe(struct drm_encoder *encoder, void *data)
429 struct exynos_drm_manager *manager =
430 to_exynos_encoder(encoder)->manager;
431 int pipe = *(int *)data;
433 DRM_DEBUG_KMS("%s\n", __FILE__);
436 * when crtc is detached from encoder, this pipe is used
437 * to select manager operation
439 manager->pipe = pipe;
442 void exynos_drm_encoder_plane_mode_set(struct drm_encoder *encoder, void *data)
444 struct exynos_drm_manager *manager =
445 to_exynos_encoder(encoder)->manager;
446 struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
447 struct exynos_drm_overlay *overlay = data;
449 DRM_DEBUG_KMS("%s\n", __FILE__);
451 if (overlay_ops && overlay_ops->mode_set)
452 overlay_ops->mode_set(manager->dev, overlay);
455 void exynos_drm_encoder_plane_commit(struct drm_encoder *encoder, void *data)
457 struct exynos_drm_manager *manager =
458 to_exynos_encoder(encoder)->manager;
459 struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
460 int zpos = DEFAULT_ZPOS;
462 DRM_DEBUG_KMS("%s\n", __FILE__);
467 if (overlay_ops && overlay_ops->commit)
468 overlay_ops->commit(manager->dev, zpos);
471 void exynos_drm_encoder_plane_enable(struct drm_encoder *encoder, void *data)
473 struct exynos_drm_manager *manager =
474 to_exynos_encoder(encoder)->manager;
475 struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
476 int zpos = DEFAULT_ZPOS;
478 DRM_DEBUG_KMS("%s\n", __FILE__);
483 if (overlay_ops && overlay_ops->enable)
484 overlay_ops->enable(manager->dev, zpos);
487 void exynos_drm_encoder_plane_disable(struct drm_encoder *encoder, void *data)
489 struct exynos_drm_manager *manager =
490 to_exynos_encoder(encoder)->manager;
491 struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
492 int zpos = DEFAULT_ZPOS;
494 DRM_DEBUG_KMS("%s\n", __FILE__);
499 if (overlay_ops && overlay_ops->disable)
500 overlay_ops->disable(manager->dev, zpos);
503 * wait for vblank interrupt
504 * - this makes sure that hardware overlay is disabled to avoid
505 * for the dma accesses to memory after gem buffer was released
506 * because the setting for disabling the overlay will be updated
509 if (overlay_ops->wait_for_vblank)
510 overlay_ops->wait_for_vblank(manager->dev);