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 <video/omapdss.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, "%#x\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 r = kstrtouint(buf, 0, &color);
123 mgr->get_manager_info(mgr, &info);
125 info.default_color = color;
127 r = mgr->set_manager_info(mgr, &info);
138 static const char *trans_key_type_str[] = {
143 static ssize_t manager_trans_key_type_show(struct omap_overlay_manager *mgr,
146 enum omap_dss_trans_key_type key_type;
148 key_type = mgr->info.trans_key_type;
149 BUG_ON(key_type >= ARRAY_SIZE(trans_key_type_str));
151 return snprintf(buf, PAGE_SIZE, "%s\n", trans_key_type_str[key_type]);
154 static ssize_t manager_trans_key_type_store(struct omap_overlay_manager *mgr,
155 const char *buf, size_t size)
157 enum omap_dss_trans_key_type key_type;
158 struct omap_overlay_manager_info info;
161 for (key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
162 key_type < ARRAY_SIZE(trans_key_type_str); key_type++) {
163 if (sysfs_streq(buf, trans_key_type_str[key_type]))
167 if (key_type == ARRAY_SIZE(trans_key_type_str))
170 mgr->get_manager_info(mgr, &info);
172 info.trans_key_type = key_type;
174 r = mgr->set_manager_info(mgr, &info);
185 static ssize_t manager_trans_key_value_show(struct omap_overlay_manager *mgr,
188 return snprintf(buf, PAGE_SIZE, "%#x\n", mgr->info.trans_key);
191 static ssize_t manager_trans_key_value_store(struct omap_overlay_manager *mgr,
192 const char *buf, size_t size)
194 struct omap_overlay_manager_info info;
198 r = kstrtouint(buf, 0, &key_value);
202 mgr->get_manager_info(mgr, &info);
204 info.trans_key = key_value;
206 r = mgr->set_manager_info(mgr, &info);
217 static ssize_t manager_trans_key_enabled_show(struct omap_overlay_manager *mgr,
220 return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.trans_enabled);
223 static ssize_t manager_trans_key_enabled_store(struct omap_overlay_manager *mgr,
224 const char *buf, size_t size)
226 struct omap_overlay_manager_info info;
230 r = strtobool(buf, &enable);
234 mgr->get_manager_info(mgr, &info);
236 info.trans_enabled = enable;
238 r = mgr->set_manager_info(mgr, &info);
249 static ssize_t manager_alpha_blending_enabled_show(
250 struct omap_overlay_manager *mgr, char *buf)
252 WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));
254 return snprintf(buf, PAGE_SIZE, "%d\n",
255 mgr->info.partial_alpha_enabled);
258 static ssize_t manager_alpha_blending_enabled_store(
259 struct omap_overlay_manager *mgr,
260 const char *buf, size_t size)
262 struct omap_overlay_manager_info info;
266 WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));
268 r = strtobool(buf, &enable);
272 mgr->get_manager_info(mgr, &info);
274 info.partial_alpha_enabled = enable;
276 r = mgr->set_manager_info(mgr, &info);
287 static ssize_t manager_cpr_enable_show(struct omap_overlay_manager *mgr,
290 return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.cpr_enable);
293 static ssize_t manager_cpr_enable_store(struct omap_overlay_manager *mgr,
294 const char *buf, size_t size)
296 struct omap_overlay_manager_info info;
300 if (!dss_has_feature(FEAT_CPR))
303 r = strtobool(buf, &enable);
307 mgr->get_manager_info(mgr, &info);
309 if (info.cpr_enable == enable)
312 info.cpr_enable = enable;
314 r = mgr->set_manager_info(mgr, &info);
325 static ssize_t manager_cpr_coef_show(struct omap_overlay_manager *mgr,
328 struct omap_overlay_manager_info info;
330 mgr->get_manager_info(mgr, &info);
332 return snprintf(buf, PAGE_SIZE,
333 "%d %d %d %d %d %d %d %d %d\n",
345 static ssize_t manager_cpr_coef_store(struct omap_overlay_manager *mgr,
346 const char *buf, size_t size)
348 struct omap_overlay_manager_info info;
349 struct omap_dss_cpr_coefs coefs;
353 if (!dss_has_feature(FEAT_CPR))
356 if (sscanf(buf, "%hd %hd %hd %hd %hd %hd %hd %hd %hd",
357 &coefs.rr, &coefs.rg, &coefs.rb,
358 &coefs.gr, &coefs.gg, &coefs.gb,
359 &coefs.br, &coefs.bg, &coefs.bb) != 9)
362 arr = (s16[]){ coefs.rr, coefs.rg, coefs.rb,
363 coefs.gr, coefs.gg, coefs.gb,
364 coefs.br, coefs.bg, coefs.bb };
366 for (i = 0; i < 9; ++i) {
367 if (arr[i] < -512 || arr[i] > 511)
371 mgr->get_manager_info(mgr, &info);
373 info.cpr_coefs = coefs;
375 r = mgr->set_manager_info(mgr, &info);
386 struct manager_attribute {
387 struct attribute attr;
388 ssize_t (*show)(struct omap_overlay_manager *, char *);
389 ssize_t (*store)(struct omap_overlay_manager *, const char *, size_t);
392 #define MANAGER_ATTR(_name, _mode, _show, _store) \
393 struct manager_attribute manager_attr_##_name = \
394 __ATTR(_name, _mode, _show, _store)
396 static MANAGER_ATTR(name, S_IRUGO, manager_name_show, NULL);
397 static MANAGER_ATTR(display, S_IRUGO|S_IWUSR,
398 manager_display_show, manager_display_store);
399 static MANAGER_ATTR(default_color, S_IRUGO|S_IWUSR,
400 manager_default_color_show, manager_default_color_store);
401 static MANAGER_ATTR(trans_key_type, S_IRUGO|S_IWUSR,
402 manager_trans_key_type_show, manager_trans_key_type_store);
403 static MANAGER_ATTR(trans_key_value, S_IRUGO|S_IWUSR,
404 manager_trans_key_value_show, manager_trans_key_value_store);
405 static MANAGER_ATTR(trans_key_enabled, S_IRUGO|S_IWUSR,
406 manager_trans_key_enabled_show,
407 manager_trans_key_enabled_store);
408 static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO|S_IWUSR,
409 manager_alpha_blending_enabled_show,
410 manager_alpha_blending_enabled_store);
411 static MANAGER_ATTR(cpr_enable, S_IRUGO|S_IWUSR,
412 manager_cpr_enable_show,
413 manager_cpr_enable_store);
414 static MANAGER_ATTR(cpr_coef, S_IRUGO|S_IWUSR,
415 manager_cpr_coef_show,
416 manager_cpr_coef_store);
419 static struct attribute *manager_sysfs_attrs[] = {
420 &manager_attr_name.attr,
421 &manager_attr_display.attr,
422 &manager_attr_default_color.attr,
423 &manager_attr_trans_key_type.attr,
424 &manager_attr_trans_key_value.attr,
425 &manager_attr_trans_key_enabled.attr,
426 &manager_attr_alpha_blending_enabled.attr,
427 &manager_attr_cpr_enable.attr,
428 &manager_attr_cpr_coef.attr,
432 static ssize_t manager_attr_show(struct kobject *kobj, struct attribute *attr,
435 struct omap_overlay_manager *manager;
436 struct manager_attribute *manager_attr;
438 manager = container_of(kobj, struct omap_overlay_manager, kobj);
439 manager_attr = container_of(attr, struct manager_attribute, attr);
441 if (!manager_attr->show)
444 return manager_attr->show(manager, buf);
447 static ssize_t manager_attr_store(struct kobject *kobj, struct attribute *attr,
448 const char *buf, size_t size)
450 struct omap_overlay_manager *manager;
451 struct manager_attribute *manager_attr;
453 manager = container_of(kobj, struct omap_overlay_manager, kobj);
454 manager_attr = container_of(attr, struct manager_attribute, attr);
456 if (!manager_attr->store)
459 return manager_attr->store(manager, buf, size);
462 static const struct sysfs_ops manager_sysfs_ops = {
463 .show = manager_attr_show,
464 .store = manager_attr_store,
467 static struct kobj_type manager_ktype = {
468 .sysfs_ops = &manager_sysfs_ops,
469 .default_attrs = manager_sysfs_attrs,
473 * We have 4 levels of cache for the dispc settings. First two are in SW and
474 * the latter two in HW.
476 * +--------------------+
477 * |overlay/manager_info|
478 * +--------------------+
482 * +--------------------+
484 * +--------------------+
488 * +--------------------+
489 * | shadow registers |
490 * +--------------------+
492 * VFP or lcd/digit_enable
494 * +--------------------+
496 * +--------------------+
499 struct overlay_cache_data {
500 /* If true, cache changed, but not written to shadow registers. Set
501 * in apply(), cleared when registers written. */
503 /* If true, shadow registers contain changed values not yet in real
504 * registers. Set when writing to shadow registers, cleared at
510 struct omap_overlay_info info;
512 enum omap_channel channel;
520 struct manager_cache_data {
521 /* If true, cache changed, but not written to shadow registers. Set
522 * in apply(), cleared when registers written. */
524 /* If true, shadow registers contain changed values not yet in real
525 * registers. Set when writing to shadow registers, cleared at
529 struct omap_overlay_manager_info info;
532 bool do_manual_update;
534 /* manual update region */
537 /* enlarge the update area if the update area contains scaled
539 bool enlarge_update_area;
544 struct overlay_cache_data overlay_cache[MAX_DSS_OVERLAYS];
545 struct manager_cache_data manager_cache[MAX_DSS_MANAGERS];
552 static int omap_dss_set_device(struct omap_overlay_manager *mgr,
553 struct omap_dss_device *dssdev)
558 if (dssdev->manager) {
559 DSSERR("display '%s' already has a manager '%s'\n",
560 dssdev->name, dssdev->manager->name);
564 if ((mgr->supported_displays & dssdev->type) == 0) {
565 DSSERR("display '%s' does not support manager '%s'\n",
566 dssdev->name, mgr->name);
570 for (i = 0; i < mgr->num_overlays; i++) {
571 struct omap_overlay *ovl = mgr->overlays[i];
573 if (ovl->manager != mgr || !ovl->info.enabled)
576 r = dss_check_overlay(ovl, dssdev);
581 dssdev->manager = mgr;
582 mgr->device = dssdev;
583 mgr->device_changed = true;
588 static int omap_dss_unset_device(struct omap_overlay_manager *mgr)
591 DSSERR("failed to unset display, display not set.\n");
596 * Don't allow currently enabled displays to have the overlay manager
597 * pulled out from underneath them
599 if (mgr->device->state != OMAP_DSS_DISPLAY_DISABLED)
602 mgr->device->manager = NULL;
604 mgr->device_changed = true;
609 static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
611 unsigned long timeout = msecs_to_jiffies(500);
615 r = dispc_runtime_get();
619 if (mgr->device->type == OMAP_DISPLAY_TYPE_VENC) {
620 irq = DISPC_IRQ_EVSYNC_ODD;
621 } else if (mgr->device->type == OMAP_DISPLAY_TYPE_HDMI) {
622 irq = DISPC_IRQ_EVSYNC_EVEN;
624 if (mgr->id == OMAP_DSS_CHANNEL_LCD)
625 irq = DISPC_IRQ_VSYNC;
627 irq = DISPC_IRQ_VSYNC2;
630 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
637 static int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
639 unsigned long timeout = msecs_to_jiffies(500);
640 struct manager_cache_data *mc;
644 struct omap_dss_device *dssdev = mgr->device;
646 if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
649 if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
652 r = dispc_runtime_get();
656 if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
657 || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
658 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
660 irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
661 DISPC_IRQ_VSYNC : DISPC_IRQ_VSYNC2;
664 mc = &dss_cache.manager_cache[mgr->id];
668 bool shadow_dirty, dirty;
670 spin_lock_irqsave(&dss_cache.lock, flags);
672 shadow_dirty = mc->shadow_dirty;
673 spin_unlock_irqrestore(&dss_cache.lock, flags);
675 if (!dirty && !shadow_dirty) {
680 /* 4 iterations is the worst case:
681 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
682 * 2 - first VSYNC, dirty = true
683 * 3 - dirty = false, shadow_dirty = true
684 * 4 - shadow_dirty = false */
686 DSSERR("mgr(%d)->wait_for_go() not finishing\n",
692 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
693 if (r == -ERESTARTSYS)
697 DSSERR("mgr(%d)->wait_for_go() timeout\n", mgr->id);
707 int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
709 unsigned long timeout = msecs_to_jiffies(500);
710 struct overlay_cache_data *oc;
711 struct omap_dss_device *dssdev;
719 dssdev = ovl->manager->device;
721 if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
724 if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
727 r = dispc_runtime_get();
731 if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
732 || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
733 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
735 irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
736 DISPC_IRQ_VSYNC : DISPC_IRQ_VSYNC2;
739 oc = &dss_cache.overlay_cache[ovl->id];
743 bool shadow_dirty, dirty;
745 spin_lock_irqsave(&dss_cache.lock, flags);
747 shadow_dirty = oc->shadow_dirty;
748 spin_unlock_irqrestore(&dss_cache.lock, flags);
750 if (!dirty && !shadow_dirty) {
755 /* 4 iterations is the worst case:
756 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
757 * 2 - first VSYNC, dirty = true
758 * 3 - dirty = false, shadow_dirty = true
759 * 4 - shadow_dirty = false */
761 DSSERR("ovl(%d)->wait_for_go() not finishing\n",
767 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
768 if (r == -ERESTARTSYS)
772 DSSERR("ovl(%d)->wait_for_go() timeout\n", ovl->id);
782 static int overlay_enabled(struct omap_overlay *ovl)
784 return ovl->info.enabled && ovl->manager && ovl->manager->device;
787 /* Is rect1 a subset of rect2? */
788 static bool rectangle_subset(int x1, int y1, int w1, int h1,
789 int x2, int y2, int w2, int h2)
791 if (x1 < x2 || y1 < y2)
794 if (x1 + w1 > x2 + w2)
797 if (y1 + h1 > y2 + h2)
803 /* Do rect1 and rect2 overlap? */
804 static bool rectangle_intersects(int x1, int y1, int w1, int h1,
805 int x2, int y2, int w2, int h2)
822 static bool dispc_is_overlay_scaled(struct overlay_cache_data *oc)
824 struct omap_overlay_info *oi = &oc->info;
826 if (oi->out_width != 0 && oi->width != oi->out_width)
829 if (oi->out_height != 0 && oi->height != oi->out_height)
835 static int configure_overlay(enum omap_plane plane)
837 struct overlay_cache_data *c;
838 struct manager_cache_data *mc;
839 struct omap_overlay_info *oi, new_oi;
840 struct omap_overlay_manager_info *mi;
845 u16 orig_w, orig_h, orig_outw, orig_outh;
847 DSSDBGF("%d", plane);
849 c = &dss_cache.overlay_cache[plane];
853 dispc_ovl_enable(plane, 0);
857 mc = &dss_cache.manager_cache[c->channel];
864 outw = oi->out_width == 0 ? oi->width : oi->out_width;
865 outh = oi->out_height == 0 ? oi->height : oi->out_height;
873 if (mc->manual_update && mc->do_manual_update) {
875 unsigned scale_x_m = w, scale_x_d = outw;
876 unsigned scale_y_m = h, scale_y_d = outh;
878 /* If the overlay is outside the update region, disable it */
879 if (!rectangle_intersects(mc->x, mc->y, mc->w, mc->h,
881 dispc_ovl_enable(plane, 0);
885 switch (oi->color_mode) {
886 case OMAP_DSS_COLOR_NV12:
889 case OMAP_DSS_COLOR_RGB16:
890 case OMAP_DSS_COLOR_ARGB16:
891 case OMAP_DSS_COLOR_YUV2:
892 case OMAP_DSS_COLOR_UYVY:
893 case OMAP_DSS_COLOR_RGBA16:
894 case OMAP_DSS_COLOR_RGBX16:
895 case OMAP_DSS_COLOR_ARGB16_1555:
896 case OMAP_DSS_COLOR_XRGB16_1555:
900 case OMAP_DSS_COLOR_RGB24P:
904 case OMAP_DSS_COLOR_RGB24U:
905 case OMAP_DSS_COLOR_ARGB32:
906 case OMAP_DSS_COLOR_RGBA32:
907 case OMAP_DSS_COLOR_RGBX32:
915 if (mc->x > oi->pos_x) {
917 outw -= (mc->x - oi->pos_x);
918 paddr += (mc->x - oi->pos_x) *
919 scale_x_m / scale_x_d * bpp / 8;
921 x = oi->pos_x - mc->x;
924 if (mc->y > oi->pos_y) {
926 outh -= (mc->y - oi->pos_y);
927 paddr += (mc->y - oi->pos_y) *
928 scale_y_m / scale_y_d *
929 oi->screen_width * bpp / 8;
931 y = oi->pos_y - mc->y;
934 if (mc->w < (x + outw))
935 outw -= (x + outw) - (mc->w);
937 if (mc->h < (y + outh))
938 outh -= (y + outh) - (mc->h);
940 w = w * outw / orig_outw;
941 h = h * outh / orig_outh;
943 /* YUV mode overlay's input width has to be even and the
944 * algorithm above may adjust the width to be odd.
946 * Here we adjust the width if needed, preferring to increase
947 * the width if the original width was bigger.
950 (oi->color_mode == OMAP_DSS_COLOR_YUV2 ||
951 oi->color_mode == OMAP_DSS_COLOR_UYVY)) {
961 /* update new_oi members which could have been possibly updated */
966 new_oi.out_width = outw;
967 new_oi.out_height = outh;
968 new_oi.paddr = paddr;
970 r = dispc_ovl_setup(plane, &new_oi, c->ilace, c->channel,
971 c->replication, c->fifo_low, c->fifo_high);
973 /* this shouldn't happen */
974 DSSERR("dispc_ovl_setup failed for ovl %d\n", plane);
975 dispc_ovl_enable(plane, 0);
979 dispc_ovl_enable(plane, 1);
984 static void configure_manager(enum omap_channel channel)
986 struct omap_overlay_manager_info *mi;
988 DSSDBGF("%d", channel);
990 /* picking info from the cache */
991 mi = &dss_cache.manager_cache[channel].info;
993 dispc_mgr_set_default_color(channel, mi->default_color);
994 dispc_mgr_set_trans_key(channel, mi->trans_key_type, mi->trans_key);
995 dispc_mgr_enable_trans_key(channel, mi->trans_enabled);
996 dispc_mgr_enable_alpha_fixed_zorder(channel, mi->partial_alpha_enabled);
997 if (dss_has_feature(FEAT_CPR)) {
998 dispc_mgr_enable_cpr(channel, mi->cpr_enable);
999 dispc_mgr_set_cpr_coef(channel, &mi->cpr_coefs);
1003 /* configure_dispc() tries to write values from cache to shadow registers.
1004 * It writes only to those managers/overlays that are not busy.
1005 * returns 0 if everything could be written to shadow registers.
1006 * returns 1 if not everything could be written to shadow registers. */
1007 static int configure_dispc(void)
1009 struct overlay_cache_data *oc;
1010 struct manager_cache_data *mc;
1011 const int num_ovls = dss_feat_get_num_ovls();
1012 const int num_mgrs = dss_feat_get_num_mgrs();
1015 bool mgr_busy[MAX_DSS_MANAGERS];
1016 bool mgr_go[MAX_DSS_MANAGERS];
1022 for (i = 0; i < num_mgrs; i++) {
1023 mgr_busy[i] = dispc_mgr_go_busy(i);
1027 /* Commit overlay settings */
1028 for (i = 0; i < num_ovls; ++i) {
1029 oc = &dss_cache.overlay_cache[i];
1030 mc = &dss_cache.manager_cache[oc->channel];
1035 if (mc->manual_update && !mc->do_manual_update)
1038 if (mgr_busy[oc->channel]) {
1043 r = configure_overlay(i);
1045 DSSERR("configure_overlay %d failed\n", i);
1048 oc->shadow_dirty = true;
1049 mgr_go[oc->channel] = true;
1052 /* Commit manager settings */
1053 for (i = 0; i < num_mgrs; ++i) {
1054 mc = &dss_cache.manager_cache[i];
1059 if (mc->manual_update && !mc->do_manual_update)
1067 configure_manager(i);
1069 mc->shadow_dirty = true;
1074 for (i = 0; i < num_mgrs; ++i) {
1075 mc = &dss_cache.manager_cache[i];
1080 /* We don't need GO with manual update display. LCD iface will
1081 * always be turned off after frame, and new settings will be
1082 * taken in to use at next update */
1083 if (!mc->manual_update)
1095 /* Make the coordinates even. There are some strange problems with OMAP and
1096 * partial DSI update when the update widths are odd. */
1097 static void make_even(u16 *x, u16 *w)
1111 /* Configure dispc for partial update. Return possibly modified update
1113 void dss_setup_partial_planes(struct omap_dss_device *dssdev,
1114 u16 *xi, u16 *yi, u16 *wi, u16 *hi, bool enlarge_update_area)
1116 struct overlay_cache_data *oc;
1117 struct manager_cache_data *mc;
1118 struct omap_overlay_info *oi;
1119 const int num_ovls = dss_feat_get_num_ovls();
1120 struct omap_overlay_manager *mgr;
1123 unsigned long flags;
1131 DSSDBG("dispc_setup_partial_planes %d,%d %dx%d\n",
1132 *xi, *yi, *wi, *hi);
1134 mgr = dssdev->manager;
1137 DSSDBG("no manager\n");
1143 spin_lock_irqsave(&dss_cache.lock, flags);
1146 * Execute the outer loop until the inner loop has completed
1147 * once without increasing the update area. This will ensure that
1148 * all scaled overlays end up completely within the update area.
1151 area_changed = false;
1153 /* We need to show the whole overlay if it is scaled. So look
1154 * for those, and make the update area larger if found.
1155 * Also mark the overlay cache dirty */
1156 for (i = 0; i < num_ovls; ++i) {
1157 unsigned x1, y1, x2, y2;
1158 unsigned outw, outh;
1160 oc = &dss_cache.overlay_cache[i];
1163 if (oc->channel != mgr->id)
1168 if (!enlarge_update_area)
1174 if (!dispc_is_overlay_scaled(oc))
1177 outw = oi->out_width == 0 ?
1178 oi->width : oi->out_width;
1179 outh = oi->out_height == 0 ?
1180 oi->height : oi->out_height;
1182 /* is the overlay outside the update region? */
1183 if (!rectangle_intersects(x, y, w, h,
1184 oi->pos_x, oi->pos_y,
1188 /* if the overlay totally inside the update region? */
1189 if (rectangle_subset(oi->pos_x, oi->pos_y, outw, outh,
1203 if ((x + w) < (oi->pos_x + outw))
1204 x2 = oi->pos_x + outw;
1208 if ((y + h) < (oi->pos_y + outh))
1209 y2 = oi->pos_y + outh;
1220 DSSDBG("changing upd area due to ovl(%d) "
1221 "scaling %d,%d %dx%d\n",
1224 area_changed = true;
1226 } while (area_changed);
1228 mc = &dss_cache.manager_cache[mgr->id];
1229 mc->do_manual_update = true;
1230 mc->enlarge_update_area = enlarge_update_area;
1238 mc->do_manual_update = false;
1240 spin_unlock_irqrestore(&dss_cache.lock, flags);
1248 void dss_start_update(struct omap_dss_device *dssdev)
1250 struct manager_cache_data *mc;
1251 struct overlay_cache_data *oc;
1252 const int num_ovls = dss_feat_get_num_ovls();
1253 const int num_mgrs = dss_feat_get_num_mgrs();
1254 struct omap_overlay_manager *mgr;
1257 mgr = dssdev->manager;
1259 for (i = 0; i < num_ovls; ++i) {
1260 oc = &dss_cache.overlay_cache[i];
1261 if (oc->channel != mgr->id)
1264 oc->shadow_dirty = false;
1267 for (i = 0; i < num_mgrs; ++i) {
1268 mc = &dss_cache.manager_cache[i];
1272 mc->shadow_dirty = false;
1275 dssdev->manager->enable(dssdev->manager);
1278 static void dss_apply_irq_handler(void *data, u32 mask)
1280 struct manager_cache_data *mc;
1281 struct overlay_cache_data *oc;
1282 const int num_ovls = dss_feat_get_num_ovls();
1283 const int num_mgrs = dss_feat_get_num_mgrs();
1285 bool mgr_busy[MAX_DSS_MANAGERS];
1288 for (i = 0; i < num_mgrs; i++)
1289 mgr_busy[i] = dispc_mgr_go_busy(i);
1291 spin_lock(&dss_cache.lock);
1293 for (i = 0; i < num_ovls; ++i) {
1294 oc = &dss_cache.overlay_cache[i];
1295 if (!mgr_busy[oc->channel])
1296 oc->shadow_dirty = false;
1299 for (i = 0; i < num_mgrs; ++i) {
1300 mc = &dss_cache.manager_cache[i];
1302 mc->shadow_dirty = false;
1305 r = configure_dispc();
1309 /* re-read busy flags */
1310 for (i = 0; i < num_mgrs; i++)
1311 mgr_busy[i] = dispc_mgr_go_busy(i);
1313 /* keep running as long as there are busy managers, so that
1314 * we can collect overlay-applied information */
1315 for (i = 0; i < num_mgrs; ++i) {
1320 irq_mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_ODD |
1321 DISPC_IRQ_EVSYNC_EVEN;
1322 if (dss_has_feature(FEAT_MGR_LCD2))
1323 irq_mask |= DISPC_IRQ_VSYNC2;
1325 omap_dispc_unregister_isr(dss_apply_irq_handler, NULL, irq_mask);
1326 dss_cache.irq_enabled = false;
1329 spin_unlock(&dss_cache.lock);
1332 static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
1334 struct overlay_cache_data *oc;
1335 struct manager_cache_data *mc;
1337 struct omap_overlay *ovl;
1338 int num_planes_enabled = 0;
1340 unsigned long flags;
1343 DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
1345 r = dispc_runtime_get();
1349 spin_lock_irqsave(&dss_cache.lock, flags);
1351 /* Configure overlays */
1352 for (i = 0; i < omap_dss_get_num_overlays(); ++i) {
1353 struct omap_dss_device *dssdev;
1355 ovl = omap_dss_get_overlay(i);
1357 oc = &dss_cache.overlay_cache[ovl->id];
1359 if (ovl->manager_changed) {
1360 ovl->manager_changed = false;
1361 ovl->info_dirty = true;
1364 if (!overlay_enabled(ovl)) {
1366 oc->enabled = false;
1372 if (!ovl->info_dirty) {
1374 ++num_planes_enabled;
1378 dssdev = ovl->manager->device;
1380 if (dss_check_overlay(ovl, dssdev)) {
1382 oc->enabled = false;
1388 ovl->info_dirty = false;
1390 oc->info = ovl->info;
1393 dss_use_replication(dssdev, ovl->info.color_mode);
1395 oc->ilace = dssdev->type == OMAP_DISPLAY_TYPE_VENC;
1397 oc->channel = ovl->manager->id;
1401 ++num_planes_enabled;
1404 /* Configure managers */
1405 list_for_each_entry(mgr, &manager_list, list) {
1406 struct omap_dss_device *dssdev;
1408 mc = &dss_cache.manager_cache[mgr->id];
1410 if (mgr->device_changed) {
1411 mgr->device_changed = false;
1412 mgr->info_dirty = true;
1415 if (!mgr->info_dirty)
1421 dssdev = mgr->device;
1423 mgr->info_dirty = false;
1425 mc->info = mgr->info;
1428 dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
1431 /* XXX TODO: Try to get fifomerge working. The problem is that it
1432 * affects both managers, not individually but at the same time. This
1433 * means the change has to be well synchronized. I guess the proper way
1434 * is to have a two step process for fifo merge:
1436 * 1. disable other planes, leaving one plane enabled
1437 * 2. wait until the planes are disabled on HW
1438 * 3. config merged fifo thresholds, enable fifomerge
1439 * fifomerge disable:
1440 * 1. config unmerged fifo thresholds, disable fifomerge
1441 * 2. wait until fifo changes are in HW
1444 use_fifomerge = false;
1446 /* Configure overlay fifos */
1447 for (i = 0; i < omap_dss_get_num_overlays(); ++i) {
1448 struct omap_dss_device *dssdev;
1449 u32 size, burst_size;
1451 ovl = omap_dss_get_overlay(i);
1453 oc = &dss_cache.overlay_cache[ovl->id];
1458 dssdev = ovl->manager->device;
1460 size = dispc_ovl_get_fifo_size(ovl->id);
1464 burst_size = dispc_ovl_get_burst_size(ovl->id);
1466 switch (dssdev->type) {
1467 case OMAP_DISPLAY_TYPE_DPI:
1468 case OMAP_DISPLAY_TYPE_DBI:
1469 case OMAP_DISPLAY_TYPE_SDI:
1470 case OMAP_DISPLAY_TYPE_VENC:
1471 case OMAP_DISPLAY_TYPE_HDMI:
1472 default_get_overlay_fifo_thresholds(ovl->id, size,
1473 burst_size, &oc->fifo_low,
1476 #ifdef CONFIG_OMAP2_DSS_DSI
1477 case OMAP_DISPLAY_TYPE_DSI:
1478 dsi_get_overlay_fifo_thresholds(ovl->id, size,
1479 burst_size, &oc->fifo_low,
1489 if (!dss_cache.irq_enabled) {
1492 mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_ODD |
1493 DISPC_IRQ_EVSYNC_EVEN;
1494 if (dss_has_feature(FEAT_MGR_LCD2))
1495 mask |= DISPC_IRQ_VSYNC2;
1497 r = omap_dispc_register_isr(dss_apply_irq_handler, NULL, mask);
1498 dss_cache.irq_enabled = true;
1502 spin_unlock_irqrestore(&dss_cache.lock, flags);
1504 dispc_runtime_put();
1509 static int dss_check_manager(struct omap_overlay_manager *mgr)
1511 if (dss_has_feature(FEAT_ALPHA_FIXED_ZORDER)) {
1513 * OMAP3 supports only graphics source transparency color key
1514 * and alpha blending simultaneously. See TRM 15.4.2.4.2.2
1517 if (mgr->info.partial_alpha_enabled && mgr->info.trans_enabled
1518 && mgr->info.trans_key_type !=
1519 OMAP_DSS_COLOR_KEY_GFX_DST)
1526 static int omap_dss_mgr_set_info(struct omap_overlay_manager *mgr,
1527 struct omap_overlay_manager_info *info)
1530 struct omap_overlay_manager_info old_info;
1532 old_info = mgr->info;
1535 r = dss_check_manager(mgr);
1537 mgr->info = old_info;
1541 mgr->info_dirty = true;
1546 static void omap_dss_mgr_get_info(struct omap_overlay_manager *mgr,
1547 struct omap_overlay_manager_info *info)
1552 static int dss_mgr_enable(struct omap_overlay_manager *mgr)
1554 dispc_mgr_enable(mgr->id, 1);
1558 static int dss_mgr_disable(struct omap_overlay_manager *mgr)
1560 dispc_mgr_enable(mgr->id, 0);
1564 static void omap_dss_add_overlay_manager(struct omap_overlay_manager *manager)
1567 list_add_tail(&manager->list, &manager_list);
1570 int dss_init_overlay_managers(struct platform_device *pdev)
1574 spin_lock_init(&dss_cache.lock);
1576 INIT_LIST_HEAD(&manager_list);
1580 for (i = 0; i < dss_feat_get_num_mgrs(); ++i) {
1581 struct omap_overlay_manager *mgr;
1582 mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
1584 BUG_ON(mgr == NULL);
1589 mgr->id = OMAP_DSS_CHANNEL_LCD;
1593 mgr->id = OMAP_DSS_CHANNEL_DIGIT;
1597 mgr->id = OMAP_DSS_CHANNEL_LCD2;
1601 mgr->set_device = &omap_dss_set_device;
1602 mgr->unset_device = &omap_dss_unset_device;
1603 mgr->apply = &omap_dss_mgr_apply;
1604 mgr->set_manager_info = &omap_dss_mgr_set_info;
1605 mgr->get_manager_info = &omap_dss_mgr_get_info;
1606 mgr->wait_for_go = &dss_mgr_wait_for_go;
1607 mgr->wait_for_vsync = &dss_mgr_wait_for_vsync;
1609 mgr->enable = &dss_mgr_enable;
1610 mgr->disable = &dss_mgr_disable;
1613 mgr->supported_displays =
1614 dss_feat_get_supported_displays(mgr->id);
1616 dss_overlay_setup_dispc_manager(mgr);
1618 omap_dss_add_overlay_manager(mgr);
1620 r = kobject_init_and_add(&mgr->kobj, &manager_ktype,
1621 &pdev->dev.kobj, "manager%d", i);
1624 DSSERR("failed to create sysfs file\n");
1632 void dss_uninit_overlay_managers(struct platform_device *pdev)
1634 struct omap_overlay_manager *mgr;
1636 while (!list_empty(&manager_list)) {
1637 mgr = list_first_entry(&manager_list,
1638 struct omap_overlay_manager, list);
1639 list_del(&mgr->list);
1640 kobject_del(&mgr->kobj);
1641 kobject_put(&mgr->kobj);
1648 int omap_dss_get_num_overlay_managers(void)
1650 return num_managers;
1652 EXPORT_SYMBOL(omap_dss_get_num_overlay_managers);
1654 struct omap_overlay_manager *omap_dss_get_overlay_manager(int num)
1657 struct omap_overlay_manager *mgr;
1659 list_for_each_entry(mgr, &manager_list, list) {
1666 EXPORT_SYMBOL(omap_dss_get_overlay_manager);