2 * linux/drivers/video/omap2/dss/manager.c
4 * Copyright (C) 2009 Nokia Corporation
5 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
7 * Some code and ideas taken from drivers/video/omap/ driver
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License version 2 as published by
12 * the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * You should have received a copy of the GNU General Public License along with
20 * this program. If not, see <http://www.gnu.org/licenses/>.
23 #define DSS_SUBSYS_NAME "MANAGER"
25 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/module.h>
28 #include <linux/platform_device.h>
29 #include <linux/spinlock.h>
30 #include <linux/jiffies.h>
32 #include <plat/display.h>
36 #include "dss_features.h"
38 static int num_managers;
39 static struct list_head manager_list;
41 static ssize_t manager_name_show(struct omap_overlay_manager *mgr, char *buf)
43 return snprintf(buf, PAGE_SIZE, "%s\n", mgr->name);
46 static ssize_t manager_display_show(struct omap_overlay_manager *mgr, char *buf)
48 return snprintf(buf, PAGE_SIZE, "%s\n",
49 mgr->device ? mgr->device->name : "<none>");
52 static ssize_t manager_display_store(struct omap_overlay_manager *mgr,
53 const char *buf, size_t size)
57 struct omap_dss_device *dssdev = NULL;
59 int match(struct omap_dss_device *dssdev, void *data)
61 const char *str = data;
62 return sysfs_streq(dssdev->name, str);
65 if (buf[size-1] == '\n')
69 dssdev = omap_dss_find_device((void *)buf, match);
71 if (len > 0 && dssdev == NULL)
75 DSSDBG("display %s found\n", dssdev->name);
78 r = mgr->unset_device(mgr);
80 DSSERR("failed to unset display\n");
86 r = mgr->set_device(mgr, dssdev);
88 DSSERR("failed to set manager\n");
94 DSSERR("failed to apply dispc config\n");
101 omap_dss_put_device(dssdev);
106 static ssize_t manager_default_color_show(struct omap_overlay_manager *mgr,
109 return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.default_color);
112 static ssize_t manager_default_color_store(struct omap_overlay_manager *mgr,
113 const char *buf, size_t size)
115 struct omap_overlay_manager_info info;
119 if (sscanf(buf, "%d", &color) != 1)
122 mgr->get_manager_info(mgr, &info);
124 info.default_color = color;
126 r = mgr->set_manager_info(mgr, &info);
137 static const char *trans_key_type_str[] = {
142 static ssize_t manager_trans_key_type_show(struct omap_overlay_manager *mgr,
145 enum omap_dss_trans_key_type key_type;
147 key_type = mgr->info.trans_key_type;
148 BUG_ON(key_type >= ARRAY_SIZE(trans_key_type_str));
150 return snprintf(buf, PAGE_SIZE, "%s\n", trans_key_type_str[key_type]);
153 static ssize_t manager_trans_key_type_store(struct omap_overlay_manager *mgr,
154 const char *buf, size_t size)
156 enum omap_dss_trans_key_type key_type;
157 struct omap_overlay_manager_info info;
160 for (key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
161 key_type < ARRAY_SIZE(trans_key_type_str); key_type++) {
162 if (sysfs_streq(buf, trans_key_type_str[key_type]))
166 if (key_type == ARRAY_SIZE(trans_key_type_str))
169 mgr->get_manager_info(mgr, &info);
171 info.trans_key_type = key_type;
173 r = mgr->set_manager_info(mgr, &info);
184 static ssize_t manager_trans_key_value_show(struct omap_overlay_manager *mgr,
187 return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.trans_key);
190 static ssize_t manager_trans_key_value_store(struct omap_overlay_manager *mgr,
191 const char *buf, size_t size)
193 struct omap_overlay_manager_info info;
197 if (sscanf(buf, "%d", &key_value) != 1)
200 mgr->get_manager_info(mgr, &info);
202 info.trans_key = key_value;
204 r = mgr->set_manager_info(mgr, &info);
215 static ssize_t manager_trans_key_enabled_show(struct omap_overlay_manager *mgr,
218 return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.trans_enabled);
221 static ssize_t manager_trans_key_enabled_store(struct omap_overlay_manager *mgr,
222 const char *buf, size_t size)
224 struct omap_overlay_manager_info info;
228 if (sscanf(buf, "%d", &enable) != 1)
231 mgr->get_manager_info(mgr, &info);
233 info.trans_enabled = enable ? true : false;
235 r = mgr->set_manager_info(mgr, &info);
246 static ssize_t manager_alpha_blending_enabled_show(
247 struct omap_overlay_manager *mgr, char *buf)
249 return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.alpha_enabled);
252 static ssize_t manager_alpha_blending_enabled_store(
253 struct omap_overlay_manager *mgr,
254 const char *buf, size_t size)
256 struct omap_overlay_manager_info info;
260 if (sscanf(buf, "%d", &enable) != 1)
263 mgr->get_manager_info(mgr, &info);
265 info.alpha_enabled = enable ? true : false;
267 r = mgr->set_manager_info(mgr, &info);
278 struct manager_attribute {
279 struct attribute attr;
280 ssize_t (*show)(struct omap_overlay_manager *, char *);
281 ssize_t (*store)(struct omap_overlay_manager *, const char *, size_t);
284 #define MANAGER_ATTR(_name, _mode, _show, _store) \
285 struct manager_attribute manager_attr_##_name = \
286 __ATTR(_name, _mode, _show, _store)
288 static MANAGER_ATTR(name, S_IRUGO, manager_name_show, NULL);
289 static MANAGER_ATTR(display, S_IRUGO|S_IWUSR,
290 manager_display_show, manager_display_store);
291 static MANAGER_ATTR(default_color, S_IRUGO|S_IWUSR,
292 manager_default_color_show, manager_default_color_store);
293 static MANAGER_ATTR(trans_key_type, S_IRUGO|S_IWUSR,
294 manager_trans_key_type_show, manager_trans_key_type_store);
295 static MANAGER_ATTR(trans_key_value, S_IRUGO|S_IWUSR,
296 manager_trans_key_value_show, manager_trans_key_value_store);
297 static MANAGER_ATTR(trans_key_enabled, S_IRUGO|S_IWUSR,
298 manager_trans_key_enabled_show,
299 manager_trans_key_enabled_store);
300 static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO|S_IWUSR,
301 manager_alpha_blending_enabled_show,
302 manager_alpha_blending_enabled_store);
305 static struct attribute *manager_sysfs_attrs[] = {
306 &manager_attr_name.attr,
307 &manager_attr_display.attr,
308 &manager_attr_default_color.attr,
309 &manager_attr_trans_key_type.attr,
310 &manager_attr_trans_key_value.attr,
311 &manager_attr_trans_key_enabled.attr,
312 &manager_attr_alpha_blending_enabled.attr,
316 static ssize_t manager_attr_show(struct kobject *kobj, struct attribute *attr,
319 struct omap_overlay_manager *manager;
320 struct manager_attribute *manager_attr;
322 manager = container_of(kobj, struct omap_overlay_manager, kobj);
323 manager_attr = container_of(attr, struct manager_attribute, attr);
325 if (!manager_attr->show)
328 return manager_attr->show(manager, buf);
331 static ssize_t manager_attr_store(struct kobject *kobj, struct attribute *attr,
332 const char *buf, size_t size)
334 struct omap_overlay_manager *manager;
335 struct manager_attribute *manager_attr;
337 manager = container_of(kobj, struct omap_overlay_manager, kobj);
338 manager_attr = container_of(attr, struct manager_attribute, attr);
340 if (!manager_attr->store)
343 return manager_attr->store(manager, buf, size);
346 static const struct sysfs_ops manager_sysfs_ops = {
347 .show = manager_attr_show,
348 .store = manager_attr_store,
351 static struct kobj_type manager_ktype = {
352 .sysfs_ops = &manager_sysfs_ops,
353 .default_attrs = manager_sysfs_attrs,
357 * We have 4 levels of cache for the dispc settings. First two are in SW and
358 * the latter two in HW.
360 * +--------------------+
361 * |overlay/manager_info|
362 * +--------------------+
366 * +--------------------+
368 * +--------------------+
372 * +--------------------+
373 * | shadow registers |
374 * +--------------------+
376 * VFP or lcd/digit_enable
378 * +--------------------+
380 * +--------------------+
383 struct overlay_cache_data {
384 /* If true, cache changed, but not written to shadow registers. Set
385 * in apply(), cleared when registers written. */
387 /* If true, shadow registers contain changed values not yet in real
388 * registers. Set when writing to shadow registers, cleared at
399 enum omap_color_mode color_mode;
401 enum omap_dss_rotation_type rotation_type;
406 u16 out_width; /* if 0, out_width == width */
407 u16 out_height; /* if 0, out_height == height */
411 enum omap_channel channel;
415 enum omap_burst_size burst_size;
422 struct manager_cache_data {
423 /* If true, cache changed, but not written to shadow registers. Set
424 * in apply(), cleared when registers written. */
426 /* If true, shadow registers contain changed values not yet in real
427 * registers. Set when writing to shadow registers, cleared at
433 enum omap_dss_trans_key_type trans_key_type;
439 bool manual_upd_display;
441 bool do_manual_update;
443 /* manual update region */
446 /* enlarge the update area if the update area contains scaled
448 bool enlarge_update_area;
453 struct overlay_cache_data overlay_cache[MAX_DSS_OVERLAYS];
454 struct manager_cache_data manager_cache[MAX_DSS_MANAGERS];
461 static int omap_dss_set_device(struct omap_overlay_manager *mgr,
462 struct omap_dss_device *dssdev)
467 if (dssdev->manager) {
468 DSSERR("display '%s' already has a manager '%s'\n",
469 dssdev->name, dssdev->manager->name);
473 if ((mgr->supported_displays & dssdev->type) == 0) {
474 DSSERR("display '%s' does not support manager '%s'\n",
475 dssdev->name, mgr->name);
479 for (i = 0; i < mgr->num_overlays; i++) {
480 struct omap_overlay *ovl = mgr->overlays[i];
482 if (ovl->manager != mgr || !ovl->info.enabled)
485 r = dss_check_overlay(ovl, dssdev);
490 dssdev->manager = mgr;
491 mgr->device = dssdev;
492 mgr->device_changed = true;
497 static int omap_dss_unset_device(struct omap_overlay_manager *mgr)
500 DSSERR("failed to unset display, display not set.\n");
504 mgr->device->manager = NULL;
506 mgr->device_changed = true;
511 static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
513 unsigned long timeout = msecs_to_jiffies(500);
516 if (mgr->device->type == OMAP_DISPLAY_TYPE_VENC) {
517 irq = DISPC_IRQ_EVSYNC_ODD;
519 if (mgr->id == OMAP_DSS_CHANNEL_LCD)
520 irq = DISPC_IRQ_VSYNC;
522 irq = DISPC_IRQ_VSYNC2;
524 return omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
527 static int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
529 unsigned long timeout = msecs_to_jiffies(500);
530 struct manager_cache_data *mc;
534 struct omap_dss_device *dssdev = mgr->device;
536 if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
539 if (dssdev->type == OMAP_DISPLAY_TYPE_VENC) {
540 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
542 if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
543 enum omap_dss_update_mode mode;
544 mode = dssdev->driver->get_update_mode(dssdev);
545 if (mode != OMAP_DSS_UPDATE_AUTO)
548 irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
550 : DISPC_IRQ_FRAMEDONE2;
552 irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
558 mc = &dss_cache.manager_cache[mgr->id];
562 bool shadow_dirty, dirty;
564 spin_lock_irqsave(&dss_cache.lock, flags);
566 shadow_dirty = mc->shadow_dirty;
567 spin_unlock_irqrestore(&dss_cache.lock, flags);
569 if (!dirty && !shadow_dirty) {
574 /* 4 iterations is the worst case:
575 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
576 * 2 - first VSYNC, dirty = true
577 * 3 - dirty = false, shadow_dirty = true
578 * 4 - shadow_dirty = false */
580 DSSERR("mgr(%d)->wait_for_go() not finishing\n",
586 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
587 if (r == -ERESTARTSYS)
591 DSSERR("mgr(%d)->wait_for_go() timeout\n", mgr->id);
599 int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
601 unsigned long timeout = msecs_to_jiffies(500);
602 struct overlay_cache_data *oc;
603 struct omap_dss_device *dssdev;
611 dssdev = ovl->manager->device;
613 if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
616 if (dssdev->type == OMAP_DISPLAY_TYPE_VENC) {
617 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
619 if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
620 enum omap_dss_update_mode mode;
621 mode = dssdev->driver->get_update_mode(dssdev);
622 if (mode != OMAP_DSS_UPDATE_AUTO)
625 irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
627 : DISPC_IRQ_FRAMEDONE2;
629 irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
635 oc = &dss_cache.overlay_cache[ovl->id];
639 bool shadow_dirty, dirty;
641 spin_lock_irqsave(&dss_cache.lock, flags);
643 shadow_dirty = oc->shadow_dirty;
644 spin_unlock_irqrestore(&dss_cache.lock, flags);
646 if (!dirty && !shadow_dirty) {
651 /* 4 iterations is the worst case:
652 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
653 * 2 - first VSYNC, dirty = true
654 * 3 - dirty = false, shadow_dirty = true
655 * 4 - shadow_dirty = false */
657 DSSERR("ovl(%d)->wait_for_go() not finishing\n",
663 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
664 if (r == -ERESTARTSYS)
668 DSSERR("ovl(%d)->wait_for_go() timeout\n", ovl->id);
676 static int overlay_enabled(struct omap_overlay *ovl)
678 return ovl->info.enabled && ovl->manager && ovl->manager->device;
681 /* Is rect1 a subset of rect2? */
682 static bool rectangle_subset(int x1, int y1, int w1, int h1,
683 int x2, int y2, int w2, int h2)
685 if (x1 < x2 || y1 < y2)
688 if (x1 + w1 > x2 + w2)
691 if (y1 + h1 > y2 + h2)
697 /* Do rect1 and rect2 overlap? */
698 static bool rectangle_intersects(int x1, int y1, int w1, int h1,
699 int x2, int y2, int w2, int h2)
716 static bool dispc_is_overlay_scaled(struct overlay_cache_data *oc)
718 if (oc->out_width != 0 && oc->width != oc->out_width)
721 if (oc->out_height != 0 && oc->height != oc->out_height)
727 static int configure_overlay(enum omap_plane plane)
729 struct overlay_cache_data *c;
730 struct manager_cache_data *mc;
735 u16 orig_w, orig_h, orig_outw, orig_outh;
737 DSSDBGF("%d", plane);
739 c = &dss_cache.overlay_cache[plane];
742 dispc_enable_plane(plane, 0);
746 mc = &dss_cache.manager_cache[c->channel];
752 outw = c->out_width == 0 ? c->width : c->out_width;
753 outh = c->out_height == 0 ? c->height : c->out_height;
761 if (c->manual_update && mc->do_manual_update) {
763 unsigned scale_x_m = w, scale_x_d = outw;
764 unsigned scale_y_m = h, scale_y_d = outh;
766 /* If the overlay is outside the update region, disable it */
767 if (!rectangle_intersects(mc->x, mc->y, mc->w, mc->h,
769 dispc_enable_plane(plane, 0);
773 switch (c->color_mode) {
774 case OMAP_DSS_COLOR_RGB16:
775 case OMAP_DSS_COLOR_ARGB16:
776 case OMAP_DSS_COLOR_YUV2:
777 case OMAP_DSS_COLOR_UYVY:
781 case OMAP_DSS_COLOR_RGB24P:
785 case OMAP_DSS_COLOR_RGB24U:
786 case OMAP_DSS_COLOR_ARGB32:
787 case OMAP_DSS_COLOR_RGBA32:
788 case OMAP_DSS_COLOR_RGBX32:
796 if (mc->x > c->pos_x) {
798 outw -= (mc->x - c->pos_x);
799 paddr += (mc->x - c->pos_x) *
800 scale_x_m / scale_x_d * bpp / 8;
802 x = c->pos_x - mc->x;
805 if (mc->y > c->pos_y) {
807 outh -= (mc->y - c->pos_y);
808 paddr += (mc->y - c->pos_y) *
809 scale_y_m / scale_y_d *
810 c->screen_width * bpp / 8;
812 y = c->pos_y - mc->y;
815 if (mc->w < (x + outw))
816 outw -= (x + outw) - (mc->w);
818 if (mc->h < (y + outh))
819 outh -= (y + outh) - (mc->h);
821 w = w * outw / orig_outw;
822 h = h * outh / orig_outh;
824 /* YUV mode overlay's input width has to be even and the
825 * algorithm above may adjust the width to be odd.
827 * Here we adjust the width if needed, preferring to increase
828 * the width if the original width was bigger.
831 (c->color_mode == OMAP_DSS_COLOR_YUV2 ||
832 c->color_mode == OMAP_DSS_COLOR_UYVY)) {
840 r = dispc_setup_plane(plane,
856 /* this shouldn't happen */
857 DSSERR("dispc_setup_plane failed for ovl %d\n", plane);
858 dispc_enable_plane(plane, 0);
862 dispc_enable_replication(plane, c->replication);
864 dispc_set_burst_size(plane, c->burst_size);
865 dispc_setup_plane_fifo(plane, c->fifo_low, c->fifo_high);
867 dispc_enable_plane(plane, 1);
872 static void configure_manager(enum omap_channel channel)
874 struct manager_cache_data *c;
876 DSSDBGF("%d", channel);
878 c = &dss_cache.manager_cache[channel];
880 dispc_set_default_color(channel, c->default_color);
881 dispc_set_trans_key(channel, c->trans_key_type, c->trans_key);
882 dispc_enable_trans_key(channel, c->trans_enabled);
883 dispc_enable_alpha_blending(channel, c->alpha_enabled);
886 /* configure_dispc() tries to write values from cache to shadow registers.
887 * It writes only to those managers/overlays that are not busy.
888 * returns 0 if everything could be written to shadow registers.
889 * returns 1 if not everything could be written to shadow registers. */
890 static int configure_dispc(void)
892 struct overlay_cache_data *oc;
893 struct manager_cache_data *mc;
894 const int num_ovls = dss_feat_get_num_ovls();
895 const int num_mgrs = dss_feat_get_num_mgrs();
898 bool mgr_busy[MAX_DSS_MANAGERS];
899 bool mgr_go[MAX_DSS_MANAGERS];
905 for (i = 0; i < num_mgrs; i++) {
906 mgr_busy[i] = dispc_go_busy(i);
910 /* Commit overlay settings */
911 for (i = 0; i < num_ovls; ++i) {
912 oc = &dss_cache.overlay_cache[i];
913 mc = &dss_cache.manager_cache[oc->channel];
918 if (oc->manual_update && !mc->do_manual_update)
921 if (mgr_busy[oc->channel]) {
926 r = configure_overlay(i);
928 DSSERR("configure_overlay %d failed\n", i);
931 oc->shadow_dirty = true;
932 mgr_go[oc->channel] = true;
935 /* Commit manager settings */
936 for (i = 0; i < num_mgrs; ++i) {
937 mc = &dss_cache.manager_cache[i];
942 if (mc->manual_update && !mc->do_manual_update)
950 configure_manager(i);
952 mc->shadow_dirty = true;
957 for (i = 0; i < num_mgrs; ++i) {
958 mc = &dss_cache.manager_cache[i];
963 /* We don't need GO with manual update display. LCD iface will
964 * always be turned off after frame, and new settings will be
965 * taken in to use at next update */
966 if (!mc->manual_upd_display)
978 /* Make the coordinates even. There are some strange problems with OMAP and
979 * partial DSI update when the update widths are odd. */
980 static void make_even(u16 *x, u16 *w)
994 /* Configure dispc for partial update. Return possibly modified update
996 void dss_setup_partial_planes(struct omap_dss_device *dssdev,
997 u16 *xi, u16 *yi, u16 *wi, u16 *hi, bool enlarge_update_area)
999 struct overlay_cache_data *oc;
1000 struct manager_cache_data *mc;
1001 const int num_ovls = dss_feat_get_num_ovls();
1002 struct omap_overlay_manager *mgr;
1005 unsigned long flags;
1013 DSSDBG("dispc_setup_partial_planes %d,%d %dx%d\n",
1014 *xi, *yi, *wi, *hi);
1016 mgr = dssdev->manager;
1019 DSSDBG("no manager\n");
1025 spin_lock_irqsave(&dss_cache.lock, flags);
1028 * Execute the outer loop until the inner loop has completed
1029 * once without increasing the update area. This will ensure that
1030 * all scaled overlays end up completely within the update area.
1033 area_changed = false;
1035 /* We need to show the whole overlay if it is scaled. So look
1036 * for those, and make the update area larger if found.
1037 * Also mark the overlay cache dirty */
1038 for (i = 0; i < num_ovls; ++i) {
1039 unsigned x1, y1, x2, y2;
1040 unsigned outw, outh;
1042 oc = &dss_cache.overlay_cache[i];
1044 if (oc->channel != mgr->id)
1049 if (!enlarge_update_area)
1055 if (!dispc_is_overlay_scaled(oc))
1058 outw = oc->out_width == 0 ?
1059 oc->width : oc->out_width;
1060 outh = oc->out_height == 0 ?
1061 oc->height : oc->out_height;
1063 /* is the overlay outside the update region? */
1064 if (!rectangle_intersects(x, y, w, h,
1065 oc->pos_x, oc->pos_y,
1069 /* if the overlay totally inside the update region? */
1070 if (rectangle_subset(oc->pos_x, oc->pos_y, outw, outh,
1084 if ((x + w) < (oc->pos_x + outw))
1085 x2 = oc->pos_x + outw;
1089 if ((y + h) < (oc->pos_y + outh))
1090 y2 = oc->pos_y + outh;
1101 DSSDBG("changing upd area due to ovl(%d) "
1102 "scaling %d,%d %dx%d\n",
1105 area_changed = true;
1107 } while (area_changed);
1109 mc = &dss_cache.manager_cache[mgr->id];
1110 mc->do_manual_update = true;
1111 mc->enlarge_update_area = enlarge_update_area;
1119 mc->do_manual_update = false;
1121 spin_unlock_irqrestore(&dss_cache.lock, flags);
1129 void dss_start_update(struct omap_dss_device *dssdev)
1131 struct manager_cache_data *mc;
1132 struct overlay_cache_data *oc;
1133 const int num_ovls = dss_feat_get_num_ovls();
1134 const int num_mgrs = dss_feat_get_num_mgrs();
1135 struct omap_overlay_manager *mgr;
1138 mgr = dssdev->manager;
1140 for (i = 0; i < num_ovls; ++i) {
1141 oc = &dss_cache.overlay_cache[i];
1142 if (oc->channel != mgr->id)
1145 oc->shadow_dirty = false;
1148 for (i = 0; i < num_mgrs; ++i) {
1149 mc = &dss_cache.manager_cache[i];
1153 mc->shadow_dirty = false;
1156 dssdev->manager->enable(dssdev->manager);
1159 static void dss_apply_irq_handler(void *data, u32 mask)
1161 struct manager_cache_data *mc;
1162 struct overlay_cache_data *oc;
1163 const int num_ovls = dss_feat_get_num_ovls();
1164 const int num_mgrs = dss_feat_get_num_mgrs();
1166 bool mgr_busy[MAX_DSS_MANAGERS];
1169 for (i = 0; i < num_mgrs; i++)
1170 mgr_busy[i] = dispc_go_busy(i);
1172 spin_lock(&dss_cache.lock);
1174 for (i = 0; i < num_ovls; ++i) {
1175 oc = &dss_cache.overlay_cache[i];
1176 if (!mgr_busy[oc->channel])
1177 oc->shadow_dirty = false;
1180 for (i = 0; i < num_mgrs; ++i) {
1181 mc = &dss_cache.manager_cache[i];
1183 mc->shadow_dirty = false;
1186 r = configure_dispc();
1190 /* re-read busy flags */
1191 for (i = 0; i < num_mgrs; i++)
1192 mgr_busy[i] = dispc_go_busy(i);
1194 /* keep running as long as there are busy managers, so that
1195 * we can collect overlay-applied information */
1196 for (i = 0; i < num_mgrs; ++i) {
1201 irq_mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_ODD |
1202 DISPC_IRQ_EVSYNC_EVEN;
1203 if (dss_has_feature(FEAT_MGR_LCD2))
1204 irq_mask |= DISPC_IRQ_VSYNC2;
1206 omap_dispc_unregister_isr(dss_apply_irq_handler, NULL, irq_mask);
1207 dss_cache.irq_enabled = false;
1210 spin_unlock(&dss_cache.lock);
1213 static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
1215 struct overlay_cache_data *oc;
1216 struct manager_cache_data *mc;
1218 struct omap_overlay *ovl;
1219 int num_planes_enabled = 0;
1221 unsigned long flags;
1224 DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
1226 spin_lock_irqsave(&dss_cache.lock, flags);
1228 /* Configure overlays */
1229 for (i = 0; i < omap_dss_get_num_overlays(); ++i) {
1230 struct omap_dss_device *dssdev;
1232 ovl = omap_dss_get_overlay(i);
1234 if (!(ovl->caps & OMAP_DSS_OVL_CAP_DISPC))
1237 oc = &dss_cache.overlay_cache[ovl->id];
1239 if (!overlay_enabled(ovl)) {
1241 oc->enabled = false;
1247 if (!ovl->info_dirty) {
1249 ++num_planes_enabled;
1253 dssdev = ovl->manager->device;
1255 if (dss_check_overlay(ovl, dssdev)) {
1257 oc->enabled = false;
1263 ovl->info_dirty = false;
1266 oc->paddr = ovl->info.paddr;
1267 oc->vaddr = ovl->info.vaddr;
1268 oc->screen_width = ovl->info.screen_width;
1269 oc->width = ovl->info.width;
1270 oc->height = ovl->info.height;
1271 oc->color_mode = ovl->info.color_mode;
1272 oc->rotation = ovl->info.rotation;
1273 oc->rotation_type = ovl->info.rotation_type;
1274 oc->mirror = ovl->info.mirror;
1275 oc->pos_x = ovl->info.pos_x;
1276 oc->pos_y = ovl->info.pos_y;
1277 oc->out_width = ovl->info.out_width;
1278 oc->out_height = ovl->info.out_height;
1279 oc->global_alpha = ovl->info.global_alpha;
1280 oc->pre_mult_alpha = ovl->info.pre_mult_alpha;
1283 dss_use_replication(dssdev, ovl->info.color_mode);
1285 oc->ilace = dssdev->type == OMAP_DISPLAY_TYPE_VENC;
1287 oc->channel = ovl->manager->id;
1292 dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE &&
1293 dssdev->driver->get_update_mode(dssdev) !=
1294 OMAP_DSS_UPDATE_AUTO;
1296 ++num_planes_enabled;
1299 /* Configure managers */
1300 list_for_each_entry(mgr, &manager_list, list) {
1301 struct omap_dss_device *dssdev;
1303 if (!(mgr->caps & OMAP_DSS_OVL_MGR_CAP_DISPC))
1306 mc = &dss_cache.manager_cache[mgr->id];
1308 if (mgr->device_changed) {
1309 mgr->device_changed = false;
1310 mgr->info_dirty = true;
1313 if (!mgr->info_dirty)
1319 dssdev = mgr->device;
1321 mgr->info_dirty = false;
1324 mc->default_color = mgr->info.default_color;
1325 mc->trans_key_type = mgr->info.trans_key_type;
1326 mc->trans_key = mgr->info.trans_key;
1327 mc->trans_enabled = mgr->info.trans_enabled;
1328 mc->alpha_enabled = mgr->info.alpha_enabled;
1330 mc->manual_upd_display =
1331 dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
1334 dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE &&
1335 dssdev->driver->get_update_mode(dssdev) !=
1336 OMAP_DSS_UPDATE_AUTO;
1339 /* XXX TODO: Try to get fifomerge working. The problem is that it
1340 * affects both managers, not individually but at the same time. This
1341 * means the change has to be well synchronized. I guess the proper way
1342 * is to have a two step process for fifo merge:
1344 * 1. disable other planes, leaving one plane enabled
1345 * 2. wait until the planes are disabled on HW
1346 * 3. config merged fifo thresholds, enable fifomerge
1347 * fifomerge disable:
1348 * 1. config unmerged fifo thresholds, disable fifomerge
1349 * 2. wait until fifo changes are in HW
1352 use_fifomerge = false;
1354 /* Configure overlay fifos */
1355 for (i = 0; i < omap_dss_get_num_overlays(); ++i) {
1356 struct omap_dss_device *dssdev;
1359 ovl = omap_dss_get_overlay(i);
1361 if (!(ovl->caps & OMAP_DSS_OVL_CAP_DISPC))
1364 oc = &dss_cache.overlay_cache[ovl->id];
1369 dssdev = ovl->manager->device;
1371 size = dispc_get_plane_fifo_size(ovl->id);
1375 switch (dssdev->type) {
1376 case OMAP_DISPLAY_TYPE_DPI:
1377 case OMAP_DISPLAY_TYPE_DBI:
1378 case OMAP_DISPLAY_TYPE_SDI:
1379 case OMAP_DISPLAY_TYPE_VENC:
1380 default_get_overlay_fifo_thresholds(ovl->id, size,
1381 &oc->burst_size, &oc->fifo_low,
1384 #ifdef CONFIG_OMAP2_DSS_DSI
1385 case OMAP_DISPLAY_TYPE_DSI:
1386 dsi_get_overlay_fifo_thresholds(ovl->id, size,
1387 &oc->burst_size, &oc->fifo_low,
1397 dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
1398 if (!dss_cache.irq_enabled) {
1401 mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_ODD |
1402 DISPC_IRQ_EVSYNC_EVEN;
1403 if (dss_has_feature(FEAT_MGR_LCD2))
1404 mask |= DISPC_IRQ_VSYNC2;
1406 r = omap_dispc_register_isr(dss_apply_irq_handler, NULL, mask);
1407 dss_cache.irq_enabled = true;
1410 dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
1412 spin_unlock_irqrestore(&dss_cache.lock, flags);
1417 static int dss_check_manager(struct omap_overlay_manager *mgr)
1419 /* OMAP supports only graphics source transparency color key and alpha
1420 * blending simultaneously. See TRM 15.4.2.4.2.2 Alpha Mode */
1422 if (mgr->info.alpha_enabled && mgr->info.trans_enabled &&
1423 mgr->info.trans_key_type != OMAP_DSS_COLOR_KEY_GFX_DST)
1429 static int omap_dss_mgr_set_info(struct omap_overlay_manager *mgr,
1430 struct omap_overlay_manager_info *info)
1433 struct omap_overlay_manager_info old_info;
1435 old_info = mgr->info;
1438 r = dss_check_manager(mgr);
1440 mgr->info = old_info;
1444 mgr->info_dirty = true;
1449 static void omap_dss_mgr_get_info(struct omap_overlay_manager *mgr,
1450 struct omap_overlay_manager_info *info)
1455 static int dss_mgr_enable(struct omap_overlay_manager *mgr)
1457 dispc_enable_channel(mgr->id, 1);
1461 static int dss_mgr_disable(struct omap_overlay_manager *mgr)
1463 dispc_enable_channel(mgr->id, 0);
1467 static void omap_dss_add_overlay_manager(struct omap_overlay_manager *manager)
1470 list_add_tail(&manager->list, &manager_list);
1473 int dss_init_overlay_managers(struct platform_device *pdev)
1477 spin_lock_init(&dss_cache.lock);
1479 INIT_LIST_HEAD(&manager_list);
1483 for (i = 0; i < dss_feat_get_num_mgrs(); ++i) {
1484 struct omap_overlay_manager *mgr;
1485 mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
1487 BUG_ON(mgr == NULL);
1492 mgr->id = OMAP_DSS_CHANNEL_LCD;
1496 mgr->id = OMAP_DSS_CHANNEL_DIGIT;
1500 mgr->id = OMAP_DSS_CHANNEL_LCD2;
1504 mgr->set_device = &omap_dss_set_device;
1505 mgr->unset_device = &omap_dss_unset_device;
1506 mgr->apply = &omap_dss_mgr_apply;
1507 mgr->set_manager_info = &omap_dss_mgr_set_info;
1508 mgr->get_manager_info = &omap_dss_mgr_get_info;
1509 mgr->wait_for_go = &dss_mgr_wait_for_go;
1510 mgr->wait_for_vsync = &dss_mgr_wait_for_vsync;
1512 mgr->enable = &dss_mgr_enable;
1513 mgr->disable = &dss_mgr_disable;
1515 mgr->caps = OMAP_DSS_OVL_MGR_CAP_DISPC;
1516 mgr->supported_displays =
1517 dss_feat_get_supported_displays(mgr->id);
1519 dss_overlay_setup_dispc_manager(mgr);
1521 omap_dss_add_overlay_manager(mgr);
1523 r = kobject_init_and_add(&mgr->kobj, &manager_ktype,
1524 &pdev->dev.kobj, "manager%d", i);
1527 DSSERR("failed to create sysfs file\n");
1534 int omap_dss_mgr_apply_l4(struct omap_overlay_manager *mgr)
1536 DSSDBG("omap_dss_mgr_apply_l4(%s)\n", mgr->name);
1541 struct omap_overlay_manager *mgr;
1542 mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
1544 BUG_ON(mgr == NULL);
1547 mgr->supported_displays =
1548 OMAP_DISPLAY_TYPE_DBI | OMAP_DISPLAY_TYPE_DSI;
1550 mgr->set_device = &omap_dss_set_device;
1551 mgr->unset_device = &omap_dss_unset_device;
1552 mgr->apply = &omap_dss_mgr_apply_l4;
1553 mgr->set_manager_info = &omap_dss_mgr_set_info;
1554 mgr->get_manager_info = &omap_dss_mgr_get_info;
1556 dss_overlay_setup_l4_manager(mgr);
1558 omap_dss_add_overlay_manager(mgr);
1560 r = kobject_init_and_add(&mgr->kobj, &manager_ktype,
1561 &pdev->dev.kobj, "managerl4");
1564 DSSERR("failed to create sysfs file\n");
1571 void dss_uninit_overlay_managers(struct platform_device *pdev)
1573 struct omap_overlay_manager *mgr;
1575 while (!list_empty(&manager_list)) {
1576 mgr = list_first_entry(&manager_list,
1577 struct omap_overlay_manager, list);
1578 list_del(&mgr->list);
1579 kobject_del(&mgr->kobj);
1580 kobject_put(&mgr->kobj);
1587 int omap_dss_get_num_overlay_managers(void)
1589 return num_managers;
1591 EXPORT_SYMBOL(omap_dss_get_num_overlay_managers);
1593 struct omap_overlay_manager *omap_dss_get_overlay_manager(int num)
1596 struct omap_overlay_manager *mgr;
1598 list_for_each_entry(mgr, &manager_list, list) {
1605 EXPORT_SYMBOL(omap_dss_get_overlay_manager);