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_crtc_helper.h"
32 #include "exynos_drm_drv.h"
33 #include "exynos_drm_encoder.h"
35 #define to_exynos_encoder(x) container_of(x, struct exynos_drm_encoder,\
39 * exynos specific encoder structure.
41 * @drm_encoder: encoder object.
42 * @manager: specific encoder has its own manager to control a hardware
43 * appropriately and we can access a hardware drawing on this manager.
44 * @dpms: store the encoder dpms value.
46 struct exynos_drm_encoder
{
47 struct drm_encoder drm_encoder
;
48 struct exynos_drm_manager
*manager
;
52 static void exynos_drm_display_power(struct drm_encoder
*encoder
, int mode
)
54 struct drm_device
*dev
= encoder
->dev
;
55 struct drm_connector
*connector
;
56 struct exynos_drm_manager
*manager
= exynos_drm_get_manager(encoder
);
58 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
59 if (connector
->encoder
== encoder
) {
60 struct exynos_drm_display_ops
*display_ops
=
63 DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
64 connector
->base
.id
, mode
);
65 if (display_ops
&& display_ops
->power_on
)
66 display_ops
->power_on(manager
->dev
, mode
);
71 static void exynos_drm_encoder_dpms(struct drm_encoder
*encoder
, int mode
)
73 struct drm_device
*dev
= encoder
->dev
;
74 struct exynos_drm_manager
*manager
= exynos_drm_get_manager(encoder
);
75 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
76 struct exynos_drm_encoder
*exynos_encoder
= to_exynos_encoder(encoder
);
78 DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__
, mode
);
80 if (exynos_encoder
->dpms
== mode
) {
81 DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
85 mutex_lock(&dev
->struct_mutex
);
88 case DRM_MODE_DPMS_ON
:
89 if (manager_ops
&& manager_ops
->apply
)
90 manager_ops
->apply(manager
->dev
);
91 exynos_drm_display_power(encoder
, mode
);
92 exynos_encoder
->dpms
= mode
;
94 case DRM_MODE_DPMS_STANDBY
:
95 case DRM_MODE_DPMS_SUSPEND
:
96 case DRM_MODE_DPMS_OFF
:
97 exynos_drm_display_power(encoder
, mode
);
98 exynos_encoder
->dpms
= mode
;
101 DRM_ERROR("unspecified mode %d\n", mode
);
105 mutex_unlock(&dev
->struct_mutex
);
109 exynos_drm_encoder_mode_fixup(struct drm_encoder
*encoder
,
110 const struct drm_display_mode
*mode
,
111 struct drm_display_mode
*adjusted_mode
)
113 struct drm_device
*dev
= encoder
->dev
;
114 struct drm_connector
*connector
;
115 struct exynos_drm_manager
*manager
= exynos_drm_get_manager(encoder
);
116 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
118 DRM_DEBUG_KMS("%s\n", __FILE__
);
120 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
121 if (connector
->encoder
== encoder
)
122 if (manager_ops
&& manager_ops
->mode_fixup
)
123 manager_ops
->mode_fixup(manager
->dev
, connector
,
124 mode
, adjusted_mode
);
130 static void exynos_drm_encoder_mode_set(struct drm_encoder
*encoder
,
131 struct drm_display_mode
*mode
,
132 struct drm_display_mode
*adjusted_mode
)
134 struct drm_device
*dev
= encoder
->dev
;
135 struct drm_connector
*connector
;
136 struct exynos_drm_manager
*manager
= exynos_drm_get_manager(encoder
);
137 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
139 DRM_DEBUG_KMS("%s\n", __FILE__
);
141 exynos_drm_encoder_dpms(encoder
, DRM_MODE_DPMS_ON
);
143 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
144 if (connector
->encoder
== encoder
)
145 if (manager_ops
&& manager_ops
->mode_set
)
146 manager_ops
->mode_set(manager
->dev
,
151 static void exynos_drm_encoder_prepare(struct drm_encoder
*encoder
)
153 DRM_DEBUG_KMS("%s\n", __FILE__
);
155 /* drm framework doesn't check NULL. */
158 static void exynos_drm_encoder_commit(struct drm_encoder
*encoder
)
160 struct exynos_drm_manager
*manager
= exynos_drm_get_manager(encoder
);
161 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
163 DRM_DEBUG_KMS("%s\n", __FILE__
);
165 if (manager_ops
&& manager_ops
->commit
)
166 manager_ops
->commit(manager
->dev
);
169 static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs
= {
170 .dpms
= exynos_drm_encoder_dpms
,
171 .mode_fixup
= exynos_drm_encoder_mode_fixup
,
172 .mode_set
= exynos_drm_encoder_mode_set
,
173 .prepare
= exynos_drm_encoder_prepare
,
174 .commit
= exynos_drm_encoder_commit
,
177 static void exynos_drm_encoder_destroy(struct drm_encoder
*encoder
)
179 struct exynos_drm_encoder
*exynos_encoder
=
180 to_exynos_encoder(encoder
);
182 DRM_DEBUG_KMS("%s\n", __FILE__
);
184 exynos_encoder
->manager
->pipe
= -1;
186 drm_encoder_cleanup(encoder
);
187 kfree(exynos_encoder
);
190 static struct drm_encoder_funcs exynos_encoder_funcs
= {
191 .destroy
= exynos_drm_encoder_destroy
,
194 static unsigned int exynos_drm_encoder_clones(struct drm_encoder
*encoder
)
196 struct drm_encoder
*clone
;
197 struct drm_device
*dev
= encoder
->dev
;
198 struct exynos_drm_encoder
*exynos_encoder
= to_exynos_encoder(encoder
);
199 struct exynos_drm_display_ops
*display_ops
=
200 exynos_encoder
->manager
->display_ops
;
201 unsigned int clone_mask
= 0;
204 list_for_each_entry(clone
, &dev
->mode_config
.encoder_list
, head
) {
205 switch (display_ops
->type
) {
206 case EXYNOS_DISPLAY_TYPE_LCD
:
207 case EXYNOS_DISPLAY_TYPE_HDMI
:
208 case EXYNOS_DISPLAY_TYPE_VIDI
:
209 clone_mask
|= (1 << (cnt
++));
219 void exynos_drm_encoder_setup(struct drm_device
*dev
)
221 struct drm_encoder
*encoder
;
223 DRM_DEBUG_KMS("%s\n", __FILE__
);
225 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
)
226 encoder
->possible_clones
= exynos_drm_encoder_clones(encoder
);
230 exynos_drm_encoder_create(struct drm_device
*dev
,
231 struct exynos_drm_manager
*manager
,
232 unsigned int possible_crtcs
)
234 struct drm_encoder
*encoder
;
235 struct exynos_drm_encoder
*exynos_encoder
;
237 DRM_DEBUG_KMS("%s\n", __FILE__
);
239 if (!manager
|| !possible_crtcs
)
245 exynos_encoder
= kzalloc(sizeof(*exynos_encoder
), GFP_KERNEL
);
246 if (!exynos_encoder
) {
247 DRM_ERROR("failed to allocate encoder\n");
251 exynos_encoder
->dpms
= DRM_MODE_DPMS_OFF
;
252 exynos_encoder
->manager
= manager
;
253 encoder
= &exynos_encoder
->drm_encoder
;
254 encoder
->possible_crtcs
= possible_crtcs
;
256 DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder
->possible_crtcs
);
258 drm_encoder_init(dev
, encoder
, &exynos_encoder_funcs
,
259 DRM_MODE_ENCODER_TMDS
);
261 drm_encoder_helper_add(encoder
, &exynos_encoder_helper_funcs
);
263 DRM_DEBUG_KMS("encoder has been created\n");
268 struct exynos_drm_manager
*exynos_drm_get_manager(struct drm_encoder
*encoder
)
270 return to_exynos_encoder(encoder
)->manager
;
273 void exynos_drm_fn_encoder(struct drm_crtc
*crtc
, void *data
,
274 void (*fn
)(struct drm_encoder
*, void *))
276 struct drm_device
*dev
= crtc
->dev
;
277 struct drm_encoder
*encoder
;
278 struct exynos_drm_private
*private = dev
->dev_private
;
279 struct exynos_drm_manager
*manager
;
281 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
283 * if crtc is detached from encoder, check pipe,
284 * otherwise check crtc attached to encoder
286 if (!encoder
->crtc
) {
287 manager
= to_exynos_encoder(encoder
)->manager
;
288 if (manager
->pipe
< 0 ||
289 private->crtc
[manager
->pipe
] != crtc
)
292 if (encoder
->crtc
!= crtc
)
300 void exynos_drm_enable_vblank(struct drm_encoder
*encoder
, void *data
)
302 struct exynos_drm_manager
*manager
=
303 to_exynos_encoder(encoder
)->manager
;
304 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
305 int crtc
= *(int *)data
;
307 if (manager
->pipe
!= crtc
)
310 if (manager_ops
->enable_vblank
)
311 manager_ops
->enable_vblank(manager
->dev
);
314 void exynos_drm_disable_vblank(struct drm_encoder
*encoder
, void *data
)
316 struct exynos_drm_manager
*manager
=
317 to_exynos_encoder(encoder
)->manager
;
318 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
319 int crtc
= *(int *)data
;
321 if (manager
->pipe
!= crtc
)
324 if (manager_ops
->disable_vblank
)
325 manager_ops
->disable_vblank(manager
->dev
);
328 void exynos_drm_encoder_crtc_dpms(struct drm_encoder
*encoder
, void *data
)
330 struct exynos_drm_encoder
*exynos_encoder
= to_exynos_encoder(encoder
);
331 struct exynos_drm_manager
*manager
= exynos_encoder
->manager
;
332 struct exynos_drm_manager_ops
*manager_ops
= manager
->ops
;
333 int mode
= *(int *)data
;
335 DRM_DEBUG_KMS("%s\n", __FILE__
);
337 if (manager_ops
&& manager_ops
->dpms
)
338 manager_ops
->dpms(manager
->dev
, mode
);
341 * if this condition is ok then it means that the crtc is already
342 * detached from encoder and last function for detaching is properly
343 * done, so clear pipe from manager to prevent repeated call.
345 if (mode
> DRM_MODE_DPMS_ON
) {
351 void exynos_drm_encoder_crtc_pipe(struct drm_encoder
*encoder
, void *data
)
353 struct exynos_drm_manager
*manager
=
354 to_exynos_encoder(encoder
)->manager
;
355 int pipe
= *(int *)data
;
357 DRM_DEBUG_KMS("%s\n", __FILE__
);
360 * when crtc is detached from encoder, this pipe is used
361 * to select manager operation
363 manager
->pipe
= pipe
;
366 void exynos_drm_encoder_plane_mode_set(struct drm_encoder
*encoder
, void *data
)
368 struct exynos_drm_manager
*manager
=
369 to_exynos_encoder(encoder
)->manager
;
370 struct exynos_drm_overlay_ops
*overlay_ops
= manager
->overlay_ops
;
371 struct exynos_drm_overlay
*overlay
= data
;
373 DRM_DEBUG_KMS("%s\n", __FILE__
);
375 if (overlay_ops
&& overlay_ops
->mode_set
)
376 overlay_ops
->mode_set(manager
->dev
, overlay
);
379 void exynos_drm_encoder_plane_commit(struct drm_encoder
*encoder
, void *data
)
381 struct exynos_drm_manager
*manager
=
382 to_exynos_encoder(encoder
)->manager
;
383 struct exynos_drm_overlay_ops
*overlay_ops
= manager
->overlay_ops
;
384 int zpos
= DEFAULT_ZPOS
;
386 DRM_DEBUG_KMS("%s\n", __FILE__
);
391 if (overlay_ops
&& overlay_ops
->commit
)
392 overlay_ops
->commit(manager
->dev
, zpos
);
395 void exynos_drm_encoder_plane_enable(struct drm_encoder
*encoder
, void *data
)
397 struct exynos_drm_manager
*manager
=
398 to_exynos_encoder(encoder
)->manager
;
399 struct exynos_drm_overlay_ops
*overlay_ops
= manager
->overlay_ops
;
400 int zpos
= DEFAULT_ZPOS
;
402 DRM_DEBUG_KMS("%s\n", __FILE__
);
407 if (overlay_ops
&& overlay_ops
->enable
)
408 overlay_ops
->enable(manager
->dev
, zpos
);
411 void exynos_drm_encoder_plane_disable(struct drm_encoder
*encoder
, void *data
)
413 struct exynos_drm_manager
*manager
=
414 to_exynos_encoder(encoder
)->manager
;
415 struct exynos_drm_overlay_ops
*overlay_ops
= manager
->overlay_ops
;
416 int zpos
= DEFAULT_ZPOS
;
418 DRM_DEBUG_KMS("%s\n", __FILE__
);
423 if (overlay_ops
&& overlay_ops
->disable
)
424 overlay_ops
->disable(manager
->dev
, zpos
);