drivers/video/omap2/dss/overlay.c

   1 /*
   2  * linux/drivers/video/omap2/dss/overlay.c
   3  *
   4  * Copyright (C) 2009 Nokia Corporation
   5  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
   6  *
   7  * Some code and ideas taken from drivers/video/omap/ driver
   8  * by Imre Deak.
   9  *
  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.
  13  *
  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
  17  * more details.
  18  *
  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/>.
  21  */
  22
  23 #define DSS_SUBSYS_NAME "OVERLAY"
  24
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/err.h>
  28 #include <linux/sysfs.h>
  29 #include <linux/kobject.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/delay.h>
  32 #include <linux/slab.h>
  33
  34 #include <video/omapdss.h>
  35 #include <plat/cpu.h>
  36
  37 #include "dss.h"
  38 #include "dss_features.h"
  39
  40 static int num_overlays;
  41 static struct omap_overlay *overlays;
  42
  43 static ssize_t overlay_name_show(struct omap_overlay *ovl, char *buf)
  44 {
  45         return snprintf(buf, PAGE_SIZE, "%s\n", ovl->name);
  46 }
  47
  48 static ssize_t overlay_manager_show(struct omap_overlay *ovl, char *buf)
  49 {
  50         return snprintf(buf, PAGE_SIZE, "%s\n",
  51                         ovl->manager ? ovl->manager->name : "<none>");
  52 }
  53
  54 static ssize_t overlay_manager_store(struct omap_overlay *ovl, const char *buf,
  55                 size_t size)
  56 {
  57         int i, r;
  58         struct omap_overlay_manager *mgr = NULL;
  59         struct omap_overlay_manager *old_mgr;
  60         int len = size;
  61
  62         if (buf[size-1] == '\n')
  63                 --len;
  64
  65         if (len > 0) {
  66                 for (i = 0; i < omap_dss_get_num_overlay_managers(); ++i) {
  67                         mgr = omap_dss_get_overlay_manager(i);
  68
  69                         if (sysfs_streq(buf, mgr->name))
  70                                 break;
  71
  72                         mgr = NULL;
  73                 }
  74         }
  75
  76         if (len > 0 && mgr == NULL)
  77                 return -EINVAL;
  78
  79         if (mgr)
  80                 DSSDBG("manager %s found\n", mgr->name);
  81
  82         if (mgr == ovl->manager)
  83                 return size;
  84
  85         old_mgr = ovl->manager;
  86
  87         r = dispc_runtime_get();
  88         if (r)
  89                 return r;
  90
  91         /* detach old manager */
  92         if (old_mgr) {
  93                 r = ovl->unset_manager(ovl);
  94                 if (r) {
  95                         DSSERR("detach failed\n");
  96                         goto err;
  97                 }
  98
  99                 r = old_mgr->apply(old_mgr);
 100                 if (r)
 101                         goto err;
 102         }
 103
 104         if (mgr) {
 105                 r = ovl->set_manager(ovl, mgr);
 106                 if (r) {
 107                         DSSERR("Failed to attach overlay\n");
 108                         goto err;
 109                 }
 110
 111                 r = mgr->apply(mgr);
 112                 if (r)
 113                         goto err;
 114         }
 115
 116         dispc_runtime_put();
 117
 118         return size;
 119
 120 err:
 121         dispc_runtime_put();
 122         return r;
 123 }
 124
 125 static ssize_t overlay_input_size_show(struct omap_overlay *ovl, char *buf)
 126 {
 127         struct omap_overlay_info info;
 128
 129         ovl->get_overlay_info(ovl, &info);
 130
 131         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 132                         info.width, info.height);
 133 }
 134
 135 static ssize_t overlay_screen_width_show(struct omap_overlay *ovl, char *buf)
 136 {
 137         struct omap_overlay_info info;
 138
 139         ovl->get_overlay_info(ovl, &info);
 140
 141         return snprintf(buf, PAGE_SIZE, "%d\n", info.screen_width);
 142 }
 143
 144 static ssize_t overlay_position_show(struct omap_overlay *ovl, char *buf)
 145 {
 146         struct omap_overlay_info info;
 147
 148         ovl->get_overlay_info(ovl, &info);
 149
 150         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 151                         info.pos_x, info.pos_y);
 152 }
 153
 154 static ssize_t overlay_position_store(struct omap_overlay *ovl,
 155                 const char *buf, size_t size)
 156 {
 157         int r;
 158         char *last;
 159         struct omap_overlay_info info;
 160
 161         ovl->get_overlay_info(ovl, &info);
 162
 163         info.pos_x = simple_strtoul(buf, &last, 10);
 164         ++last;
 165         if (last - buf >= size)
 166                 return -EINVAL;
 167
 168         info.pos_y = simple_strtoul(last, &last, 10);
 169
 170         r = ovl->set_overlay_info(ovl, &info);
 171         if (r)
 172                 return r;
 173
 174         if (ovl->manager) {
 175                 r = ovl->manager->apply(ovl->manager);
 176                 if (r)
 177                         return r;
 178         }
 179
 180         return size;
 181 }
 182
 183 static ssize_t overlay_output_size_show(struct omap_overlay *ovl, char *buf)
 184 {
 185         struct omap_overlay_info info;
 186
 187         ovl->get_overlay_info(ovl, &info);
 188
 189         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 190                         info.out_width, info.out_height);
 191 }
 192
 193 static ssize_t overlay_output_size_store(struct omap_overlay *ovl,
 194                 const char *buf, size_t size)
 195 {
 196         int r;
 197         char *last;
 198         struct omap_overlay_info info;
 199
 200         ovl->get_overlay_info(ovl, &info);
 201
 202         info.out_width = simple_strtoul(buf, &last, 10);
 203         ++last;
 204         if (last - buf >= size)
 205                 return -EINVAL;
 206
 207         info.out_height = simple_strtoul(last, &last, 10);
 208
 209         r = ovl->set_overlay_info(ovl, &info);
 210         if (r)
 211                 return r;
 212
 213         if (ovl->manager) {
 214                 r = ovl->manager->apply(ovl->manager);
 215                 if (r)
 216                         return r;
 217         }
 218
 219         return size;
 220 }
 221
 222 static ssize_t overlay_enabled_show(struct omap_overlay *ovl, char *buf)
 223 {
 224         return snprintf(buf, PAGE_SIZE, "%d\n", ovl->is_enabled(ovl));
 225 }
 226
 227 static ssize_t overlay_enabled_store(struct omap_overlay *ovl, const char *buf,
 228                 size_t size)
 229 {
 230         int r;
 231         bool enable;
 232
 233         r = strtobool(buf, &enable);
 234         if (r)
 235                 return r;
 236
 237         if (enable)
 238                 r = ovl->enable(ovl);
 239         else
 240                 r = ovl->disable(ovl);
 241
 242         if (r)
 243                 return r;
 244
 245         return size;
 246 }
 247
 248 static ssize_t overlay_global_alpha_show(struct omap_overlay *ovl, char *buf)
 249 {
 250         struct omap_overlay_info info;
 251
 252         ovl->get_overlay_info(ovl, &info);
 253
 254         return snprintf(buf, PAGE_SIZE, "%d\n",
 255                         info.global_alpha);
 256 }
 257
 258 static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl,
 259                 const char *buf, size_t size)
 260 {
 261         int r;
 262         u8 alpha;
 263         struct omap_overlay_info info;
 264
 265         if ((ovl->caps & OMAP_DSS_OVL_CAP_GLOBAL_ALPHA) == 0)
 266                 return -ENODEV;
 267
 268         r = kstrtou8(buf, 0, &alpha);
 269         if (r)
 270                 return r;
 271
 272         ovl->get_overlay_info(ovl, &info);
 273
 274         info.global_alpha = alpha;
 275
 276         r = ovl->set_overlay_info(ovl, &info);
 277         if (r)
 278                 return r;
 279
 280         if (ovl->manager) {
 281                 r = ovl->manager->apply(ovl->manager);
 282                 if (r)
 283                         return r;
 284         }
 285
 286         return size;
 287 }
 288
 289 static ssize_t overlay_pre_mult_alpha_show(struct omap_overlay *ovl,
 290                 char *buf)
 291 {
 292         struct omap_overlay_info info;
 293
 294         ovl->get_overlay_info(ovl, &info);
 295
 296         return snprintf(buf, PAGE_SIZE, "%d\n",
 297                         info.pre_mult_alpha);
 298 }
 299
 300 static ssize_t overlay_pre_mult_alpha_store(struct omap_overlay *ovl,
 301                 const char *buf, size_t size)
 302 {
 303         int r;
 304         u8 alpha;
 305         struct omap_overlay_info info;
 306
 307         if ((ovl->caps & OMAP_DSS_OVL_CAP_PRE_MULT_ALPHA) == 0)
 308                 return -ENODEV;
 309
 310         r = kstrtou8(buf, 0, &alpha);
 311         if (r)
 312                 return r;
 313
 314         ovl->get_overlay_info(ovl, &info);
 315
 316         info.pre_mult_alpha = alpha;
 317
 318         r = ovl->set_overlay_info(ovl, &info);
 319         if (r)
 320                 return r;
 321
 322         if (ovl->manager) {
 323                 r = ovl->manager->apply(ovl->manager);
 324                 if (r)
 325                         return r;
 326         }
 327
 328         return size;
 329 }
 330
 331 static ssize_t overlay_zorder_show(struct omap_overlay *ovl, char *buf)
 332 {
 333         struct omap_overlay_info info;
 334
 335         ovl->get_overlay_info(ovl, &info);
 336
 337         return snprintf(buf, PAGE_SIZE, "%d\n", info.zorder);
 338 }
 339
 340 static ssize_t overlay_zorder_store(struct omap_overlay *ovl,
 341                 const char *buf, size_t size)
 342 {
 343         int r;
 344         u8 zorder;
 345         struct omap_overlay_info info;
 346
 347         if ((ovl->caps & OMAP_DSS_OVL_CAP_ZORDER) == 0)
 348                 return -ENODEV;
 349
 350         r = kstrtou8(buf, 0, &zorder);
 351         if (r)
 352                 return r;
 353
 354         ovl->get_overlay_info(ovl, &info);
 355
 356         info.zorder = zorder;
 357
 358         r = ovl->set_overlay_info(ovl, &info);
 359         if (r)
 360                 return r;
 361
 362         if (ovl->manager) {
 363                 r = ovl->manager->apply(ovl->manager);
 364                 if (r)
 365                         return r;
 366         }
 367
 368         return size;
 369 }
 370
 371 struct overlay_attribute {
 372         struct attribute attr;
 373         ssize_t (*show)(struct omap_overlay *, char *);
 374         ssize_t (*store)(struct omap_overlay *, const char *, size_t);
 375 };
 376
 377 #define OVERLAY_ATTR(_name, _mode, _show, _store) \
 378         struct overlay_attribute overlay_attr_##_name = \
 379         __ATTR(_name, _mode, _show, _store)
 380
 381 static OVERLAY_ATTR(name, S_IRUGO, overlay_name_show, NULL);
 382 static OVERLAY_ATTR(manager, S_IRUGO|S_IWUSR,
 383                 overlay_manager_show, overlay_manager_store);
 384 static OVERLAY_ATTR(input_size, S_IRUGO, overlay_input_size_show, NULL);
 385 static OVERLAY_ATTR(screen_width, S_IRUGO, overlay_screen_width_show, NULL);
 386 static OVERLAY_ATTR(position, S_IRUGO|S_IWUSR,
 387                 overlay_position_show, overlay_position_store);
 388 static OVERLAY_ATTR(output_size, S_IRUGO|S_IWUSR,
 389                 overlay_output_size_show, overlay_output_size_store);
 390 static OVERLAY_ATTR(enabled, S_IRUGO|S_IWUSR,
 391                 overlay_enabled_show, overlay_enabled_store);
 392 static OVERLAY_ATTR(global_alpha, S_IRUGO|S_IWUSR,
 393                 overlay_global_alpha_show, overlay_global_alpha_store);
 394 static OVERLAY_ATTR(pre_mult_alpha, S_IRUGO|S_IWUSR,
 395                 overlay_pre_mult_alpha_show,
 396                 overlay_pre_mult_alpha_store);
 397 static OVERLAY_ATTR(zorder, S_IRUGO|S_IWUSR,
 398                 overlay_zorder_show, overlay_zorder_store);
 399
 400 static struct attribute *overlay_sysfs_attrs[] = {
 401         &overlay_attr_name.attr,
 402         &overlay_attr_manager.attr,
 403         &overlay_attr_input_size.attr,
 404         &overlay_attr_screen_width.attr,
 405         &overlay_attr_position.attr,
 406         &overlay_attr_output_size.attr,
 407         &overlay_attr_enabled.attr,
 408         &overlay_attr_global_alpha.attr,
 409         &overlay_attr_pre_mult_alpha.attr,
 410         &overlay_attr_zorder.attr,
 411         NULL
 412 };
 413
 414 static ssize_t overlay_attr_show(struct kobject *kobj, struct attribute *attr,
 415                 char *buf)
 416 {
 417         struct omap_overlay *overlay;
 418         struct overlay_attribute *overlay_attr;
 419
 420         overlay = container_of(kobj, struct omap_overlay, kobj);
 421         overlay_attr = container_of(attr, struct overlay_attribute, attr);
 422
 423         if (!overlay_attr->show)
 424                 return -ENOENT;
 425
 426         return overlay_attr->show(overlay, buf);
 427 }
 428
 429 static ssize_t overlay_attr_store(struct kobject *kobj, struct attribute *attr,
 430                 const char *buf, size_t size)
 431 {
 432         struct omap_overlay *overlay;
 433         struct overlay_attribute *overlay_attr;
 434
 435         overlay = container_of(kobj, struct omap_overlay, kobj);
 436         overlay_attr = container_of(attr, struct overlay_attribute, attr);
 437
 438         if (!overlay_attr->store)
 439                 return -ENOENT;
 440
 441         return overlay_attr->store(overlay, buf, size);
 442 }
 443
 444 static const struct sysfs_ops overlay_sysfs_ops = {
 445         .show = overlay_attr_show,
 446         .store = overlay_attr_store,
 447 };
 448
 449 static struct kobj_type overlay_ktype = {
 450         .sysfs_ops = &overlay_sysfs_ops,
 451         .default_attrs = overlay_sysfs_attrs,
 452 };
 453
 454 int omap_dss_get_num_overlays(void)
 455 {
 456         return num_overlays;
 457 }
 458 EXPORT_SYMBOL(omap_dss_get_num_overlays);
 459
 460 struct omap_overlay *omap_dss_get_overlay(int num)
 461 {
 462         if (num >= num_overlays)
 463                 return NULL;
 464
 465         return &overlays[num];
 466 }
 467 EXPORT_SYMBOL(omap_dss_get_overlay);
 468
 469 void dss_init_overlays(struct platform_device *pdev)
 470 {
 471         int i, r;
 472
 473         num_overlays = dss_feat_get_num_ovls();
 474
 475         overlays = kzalloc(sizeof(struct omap_overlay) * num_overlays,
 476                         GFP_KERNEL);
 477
 478         BUG_ON(overlays == NULL);
 479
 480         for (i = 0; i < num_overlays; ++i) {
 481                 struct omap_overlay *ovl = &overlays[i];
 482
 483                 switch (i) {
 484                 case 0:
 485                         ovl->name = "gfx";
 486                         ovl->id = OMAP_DSS_GFX;
 487                         break;
 488                 case 1:
 489                         ovl->name = "vid1";
 490                         ovl->id = OMAP_DSS_VIDEO1;
 491                         break;
 492                 case 2:
 493                         ovl->name = "vid2";
 494                         ovl->id = OMAP_DSS_VIDEO2;
 495                         break;
 496                 case 3:
 497                         ovl->name = "vid3";
 498                         ovl->id = OMAP_DSS_VIDEO3;
 499                         break;
 500                 }
 501
 502                 ovl->is_enabled = &dss_ovl_is_enabled;
 503                 ovl->enable = &dss_ovl_enable;
 504                 ovl->disable = &dss_ovl_disable;
 505                 ovl->set_manager = &dss_ovl_set_manager;
 506                 ovl->unset_manager = &dss_ovl_unset_manager;
 507                 ovl->set_overlay_info = &dss_ovl_set_info;
 508                 ovl->get_overlay_info = &dss_ovl_get_info;
 509                 ovl->wait_for_go = &dss_mgr_wait_for_go_ovl;
 510
 511                 ovl->caps = dss_feat_get_overlay_caps(ovl->id);
 512                 ovl->supported_modes =
 513                         dss_feat_get_supported_color_modes(ovl->id);
 514
 515                 r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
 516                                 &pdev->dev.kobj, "overlay%d", i);
 517
 518                 if (r)
 519                         DSSERR("failed to create sysfs file\n");
 520         }
 521 }
 522
 523 /* connect overlays to the new device, if not already connected. if force
 524  * selected, connect always. */
 525 void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
 526 {
 527         int i;
 528         struct omap_overlay_manager *lcd_mgr;
 529         struct omap_overlay_manager *tv_mgr;
 530         struct omap_overlay_manager *lcd2_mgr = NULL;
 531         struct omap_overlay_manager *lcd3_mgr = NULL;
 532         struct omap_overlay_manager *mgr = NULL;
 533
 534         lcd_mgr = omap_dss_get_overlay_manager(OMAP_DSS_CHANNEL_LCD);
 535         tv_mgr = omap_dss_get_overlay_manager(OMAP_DSS_CHANNEL_DIGIT);
 536         if (dss_has_feature(FEAT_MGR_LCD3))
 537                 lcd3_mgr = omap_dss_get_overlay_manager(OMAP_DSS_CHANNEL_LCD3);
 538         if (dss_has_feature(FEAT_MGR_LCD2))
 539                 lcd2_mgr = omap_dss_get_overlay_manager(OMAP_DSS_CHANNEL_LCD2);
 540
 541         if (dssdev->channel == OMAP_DSS_CHANNEL_LCD3) {
 542                 if (!lcd3_mgr->device || force) {
 543                         if (lcd3_mgr->device)
 544                                 lcd3_mgr->unset_device(lcd3_mgr);
 545                         lcd3_mgr->set_device(lcd3_mgr, dssdev);
 546                         mgr = lcd3_mgr;
 547                 }
 548         } else if (dssdev->channel == OMAP_DSS_CHANNEL_LCD2) {
 549                 if (!lcd2_mgr->device || force) {
 550                         if (lcd2_mgr->device)
 551                                 lcd2_mgr->unset_device(lcd2_mgr);
 552                         lcd2_mgr->set_device(lcd2_mgr, dssdev);
 553                         mgr = lcd2_mgr;
 554                 }
 555         } else if (dssdev->type != OMAP_DISPLAY_TYPE_VENC
 556                         && dssdev->type != OMAP_DISPLAY_TYPE_HDMI) {
 557                 if (!lcd_mgr->device || force) {
 558                         if (lcd_mgr->device)
 559                                 lcd_mgr->unset_device(lcd_mgr);
 560                         lcd_mgr->set_device(lcd_mgr, dssdev);
 561                         mgr = lcd_mgr;
 562                 }
 563         }
 564
 565         if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
 566                         || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
 567                 if (!tv_mgr->device || force) {
 568                         if (tv_mgr->device)
 569                                 tv_mgr->unset_device(tv_mgr);
 570                         tv_mgr->set_device(tv_mgr, dssdev);
 571                         mgr = tv_mgr;
 572                 }
 573         }
 574
 575         if (mgr) {
 576                 dispc_runtime_get();
 577
 578                 for (i = 0; i < dss_feat_get_num_ovls(); i++) {
 579                         struct omap_overlay *ovl;
 580                         ovl = omap_dss_get_overlay(i);
 581                         if (!ovl->manager || force) {
 582                                 if (ovl->manager)
 583                                         ovl->unset_manager(ovl);
 584                                 ovl->set_manager(ovl, mgr);
 585                         }
 586                 }
 587
 588                 dispc_runtime_put();
 589         }
 590 }
 591
 592 void dss_uninit_overlays(struct platform_device *pdev)
 593 {
 594         int i;
 595
 596         for (i = 0; i < num_overlays; ++i) {
 597                 struct omap_overlay *ovl = &overlays[i];
 598
 599                 kobject_del(&ovl->kobj);
 600                 kobject_put(&ovl->kobj);
 601         }
 602
 603         kfree(overlays);
 604         overlays = NULL;
 605         num_overlays = 0;
 606 }
 607
 608 int dss_ovl_simple_check(struct omap_overlay *ovl,
 609                 const struct omap_overlay_info *info)
 610 {
 611         if (info->paddr == 0) {
 612                 DSSERR("check_overlay: paddr cannot be 0\n");
 613                 return -EINVAL;
 614         }
 615
 616         if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
 617                 if (info->out_width != 0 && info->width != info->out_width) {
 618                         DSSERR("check_overlay: overlay %d doesn't support "
 619                                         "scaling\n", ovl->id);
 620                         return -EINVAL;
 621                 }
 622
 623                 if (info->out_height != 0 && info->height != info->out_height) {
 624                         DSSERR("check_overlay: overlay %d doesn't support "
 625                                         "scaling\n", ovl->id);
 626                         return -EINVAL;
 627                 }
 628         }
 629
 630         if ((ovl->supported_modes & info->color_mode) == 0) {
 631                 DSSERR("check_overlay: overlay %d doesn't support mode %d\n",
 632                                 ovl->id, info->color_mode);
 633                 return -EINVAL;
 634         }
 635
 636         if (info->zorder >= omap_dss_get_num_overlays()) {
 637                 DSSERR("check_overlay: zorder %d too high\n", info->zorder);
 638                 return -EINVAL;
 639         }
 640
 641         if (dss_feat_rotation_type_supported(info->rotation_type) == 0) {
 642                 DSSERR("check_overlay: rotation type %d not supported\n",
 643                                 info->rotation_type);
 644                 return -EINVAL;
 645         }
 646
 647         return 0;
 648 }
 649
 650 int dss_ovl_check(struct omap_overlay *ovl, struct omap_overlay_info *info,
 651                 const struct omap_video_timings *mgr_timings)
 652 {
 653         u16 outw, outh;
 654         u16 dw, dh;
 655
 656         dw = mgr_timings->x_res;
 657         dh = mgr_timings->y_res;
 658
 659         if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
 660                 outw = info->width;
 661                 outh = info->height;
 662         } else {
 663                 if (info->out_width == 0)
 664                         outw = info->width;
 665                 else
 666                         outw = info->out_width;
 667
 668                 if (info->out_height == 0)
 669                         outh = info->height;
 670                 else
 671                         outh = info->out_height;
 672         }
 673
 674         if (dw < info->pos_x + outw) {
 675                 DSSERR("overlay %d horizontally not inside the display area "
 676                                 "(%d + %d >= %d)\n",
 677                                 ovl->id, info->pos_x, outw, dw);
 678                 return -EINVAL;
 679         }
 680
 681         if (dh < info->pos_y + outh) {
 682                 DSSERR("overlay %d vertically not inside the display area "
 683                                 "(%d + %d >= %d)\n",
 684                                 ovl->id, info->pos_y, outh, dh);
 685                 return -EINVAL;
 686         }
 687
 688         return 0;
 689 }
 690
 691 /*
 692  * Checks if replication logic should be used. Only use when overlay is in
 693  * RGB12U or RGB16 mode, and video port width interface is 18bpp or 24bpp
 694  */
 695 bool dss_ovl_use_replication(struct dss_lcd_mgr_config config,
 696                 enum omap_color_mode mode)
 697 {
 698         if (mode != OMAP_DSS_COLOR_RGB12U && mode != OMAP_DSS_COLOR_RGB16)
 699                 return false;
 700
 701         return config.video_port_width > 16;
 702 }