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 list_head overlay_list;
  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         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 128                         ovl->info.width, ovl->info.height);
 129 }
 130
 131 static ssize_t overlay_screen_width_show(struct omap_overlay *ovl, char *buf)
 132 {
 133         return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.screen_width);
 134 }
 135
 136 static ssize_t overlay_position_show(struct omap_overlay *ovl, char *buf)
 137 {
 138         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 139                         ovl->info.pos_x, ovl->info.pos_y);
 140 }
 141
 142 static ssize_t overlay_position_store(struct omap_overlay *ovl,
 143                 const char *buf, size_t size)
 144 {
 145         int r;
 146         char *last;
 147         struct omap_overlay_info info;
 148
 149         ovl->get_overlay_info(ovl, &info);
 150
 151         info.pos_x = simple_strtoul(buf, &last, 10);
 152         ++last;
 153         if (last - buf >= size)
 154                 return -EINVAL;
 155
 156         info.pos_y = simple_strtoul(last, &last, 10);
 157
 158         r = ovl->set_overlay_info(ovl, &info);
 159         if (r)
 160                 return r;
 161
 162         if (ovl->manager) {
 163                 r = ovl->manager->apply(ovl->manager);
 164                 if (r)
 165                         return r;
 166         }
 167
 168         return size;
 169 }
 170
 171 static ssize_t overlay_output_size_show(struct omap_overlay *ovl, char *buf)
 172 {
 173         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 174                         ovl->info.out_width, ovl->info.out_height);
 175 }
 176
 177 static ssize_t overlay_output_size_store(struct omap_overlay *ovl,
 178                 const char *buf, size_t size)
 179 {
 180         int r;
 181         char *last;
 182         struct omap_overlay_info info;
 183
 184         ovl->get_overlay_info(ovl, &info);
 185
 186         info.out_width = simple_strtoul(buf, &last, 10);
 187         ++last;
 188         if (last - buf >= size)
 189                 return -EINVAL;
 190
 191         info.out_height = simple_strtoul(last, &last, 10);
 192
 193         r = ovl->set_overlay_info(ovl, &info);
 194         if (r)
 195                 return r;
 196
 197         if (ovl->manager) {
 198                 r = ovl->manager->apply(ovl->manager);
 199                 if (r)
 200                         return r;
 201         }
 202
 203         return size;
 204 }
 205
 206 static ssize_t overlay_enabled_show(struct omap_overlay *ovl, char *buf)
 207 {
 208         return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.enabled);
 209 }
 210
 211 static ssize_t overlay_enabled_store(struct omap_overlay *ovl, const char *buf,
 212                 size_t size)
 213 {
 214         int r, enable;
 215         struct omap_overlay_info info;
 216
 217         ovl->get_overlay_info(ovl, &info);
 218
 219         r = kstrtoint(buf, 0, &enable);
 220         if (r)
 221                 return r;
 222
 223         info.enabled = !!enable;
 224
 225         r = ovl->set_overlay_info(ovl, &info);
 226         if (r)
 227                 return r;
 228
 229         if (ovl->manager) {
 230                 r = ovl->manager->apply(ovl->manager);
 231                 if (r)
 232                         return r;
 233         }
 234
 235         return size;
 236 }
 237
 238 static ssize_t overlay_global_alpha_show(struct omap_overlay *ovl, char *buf)
 239 {
 240         return snprintf(buf, PAGE_SIZE, "%d\n",
 241                         ovl->info.global_alpha);
 242 }
 243
 244 static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl,
 245                 const char *buf, size_t size)
 246 {
 247         int r;
 248         u8 alpha;
 249         struct omap_overlay_info info;
 250
 251         if (!dss_has_feature(FEAT_GLOBAL_ALPHA))
 252                 return -ENODEV;
 253
 254         r = kstrtou8(buf, 0, &alpha);
 255         if (r)
 256                 return r;
 257
 258         ovl->get_overlay_info(ovl, &info);
 259
 260         /* Video1 plane does not support global alpha
 261          * to always make it 255 completely opaque
 262          */
 263         if (!dss_has_feature(FEAT_GLOBAL_ALPHA_VID1) &&
 264                         ovl->id == OMAP_DSS_VIDEO1)
 265                 info.global_alpha = 255;
 266         else
 267                 info.global_alpha = alpha;
 268
 269         r = ovl->set_overlay_info(ovl, &info);
 270         if (r)
 271                 return r;
 272
 273         if (ovl->manager) {
 274                 r = ovl->manager->apply(ovl->manager);
 275                 if (r)
 276                         return r;
 277         }
 278
 279         return size;
 280 }
 281
 282 static ssize_t overlay_pre_mult_alpha_show(struct omap_overlay *ovl,
 283                 char *buf)
 284 {
 285         return snprintf(buf, PAGE_SIZE, "%d\n",
 286                         ovl->info.pre_mult_alpha);
 287 }
 288
 289 static ssize_t overlay_pre_mult_alpha_store(struct omap_overlay *ovl,
 290                 const char *buf, size_t size)
 291 {
 292         int r;
 293         u8 alpha;
 294         struct omap_overlay_info info;
 295
 296         r = kstrtou8(buf, 0, &alpha);
 297         if (r)
 298                 return r;
 299
 300         ovl->get_overlay_info(ovl, &info);
 301
 302         /* only GFX and Video2 plane support pre alpha multiplied
 303          * set zero for Video1 plane
 304          */
 305         if (!dss_has_feature(FEAT_GLOBAL_ALPHA_VID1) &&
 306                 ovl->id == OMAP_DSS_VIDEO1)
 307                 info.pre_mult_alpha = 0;
 308         else
 309                 info.pre_mult_alpha = alpha;
 310
 311         r = ovl->set_overlay_info(ovl, &info);
 312         if (r)
 313                 return r;
 314
 315         if (ovl->manager) {
 316                 r = ovl->manager->apply(ovl->manager);
 317                 if (r)
 318                         return r;
 319         }
 320
 321         return size;
 322 }
 323
 324 struct overlay_attribute {
 325         struct attribute attr;
 326         ssize_t (*show)(struct omap_overlay *, char *);
 327         ssize_t (*store)(struct omap_overlay *, const char *, size_t);
 328 };
 329
 330 #define OVERLAY_ATTR(_name, _mode, _show, _store) \
 331         struct overlay_attribute overlay_attr_##_name = \
 332         __ATTR(_name, _mode, _show, _store)
 333
 334 static OVERLAY_ATTR(name, S_IRUGO, overlay_name_show, NULL);
 335 static OVERLAY_ATTR(manager, S_IRUGO|S_IWUSR,
 336                 overlay_manager_show, overlay_manager_store);
 337 static OVERLAY_ATTR(input_size, S_IRUGO, overlay_input_size_show, NULL);
 338 static OVERLAY_ATTR(screen_width, S_IRUGO, overlay_screen_width_show, NULL);
 339 static OVERLAY_ATTR(position, S_IRUGO|S_IWUSR,
 340                 overlay_position_show, overlay_position_store);
 341 static OVERLAY_ATTR(output_size, S_IRUGO|S_IWUSR,
 342                 overlay_output_size_show, overlay_output_size_store);
 343 static OVERLAY_ATTR(enabled, S_IRUGO|S_IWUSR,
 344                 overlay_enabled_show, overlay_enabled_store);
 345 static OVERLAY_ATTR(global_alpha, S_IRUGO|S_IWUSR,
 346                 overlay_global_alpha_show, overlay_global_alpha_store);
 347 static OVERLAY_ATTR(pre_mult_alpha, S_IRUGO|S_IWUSR,
 348                 overlay_pre_mult_alpha_show,
 349                 overlay_pre_mult_alpha_store);
 350
 351 static struct attribute *overlay_sysfs_attrs[] = {
 352         &overlay_attr_name.attr,
 353         &overlay_attr_manager.attr,
 354         &overlay_attr_input_size.attr,
 355         &overlay_attr_screen_width.attr,
 356         &overlay_attr_position.attr,
 357         &overlay_attr_output_size.attr,
 358         &overlay_attr_enabled.attr,
 359         &overlay_attr_global_alpha.attr,
 360         &overlay_attr_pre_mult_alpha.attr,
 361         NULL
 362 };
 363
 364 static ssize_t overlay_attr_show(struct kobject *kobj, struct attribute *attr,
 365                 char *buf)
 366 {
 367         struct omap_overlay *overlay;
 368         struct overlay_attribute *overlay_attr;
 369
 370         overlay = container_of(kobj, struct omap_overlay, kobj);
 371         overlay_attr = container_of(attr, struct overlay_attribute, attr);
 372
 373         if (!overlay_attr->show)
 374                 return -ENOENT;
 375
 376         return overlay_attr->show(overlay, buf);
 377 }
 378
 379 static ssize_t overlay_attr_store(struct kobject *kobj, struct attribute *attr,
 380                 const char *buf, size_t size)
 381 {
 382         struct omap_overlay *overlay;
 383         struct overlay_attribute *overlay_attr;
 384
 385         overlay = container_of(kobj, struct omap_overlay, kobj);
 386         overlay_attr = container_of(attr, struct overlay_attribute, attr);
 387
 388         if (!overlay_attr->store)
 389                 return -ENOENT;
 390
 391         return overlay_attr->store(overlay, buf, size);
 392 }
 393
 394 static const struct sysfs_ops overlay_sysfs_ops = {
 395         .show = overlay_attr_show,
 396         .store = overlay_attr_store,
 397 };
 398
 399 static struct kobj_type overlay_ktype = {
 400         .sysfs_ops = &overlay_sysfs_ops,
 401         .default_attrs = overlay_sysfs_attrs,
 402 };
 403
 404 /* Check if overlay parameters are compatible with display */
 405 int dss_check_overlay(struct omap_overlay *ovl, struct omap_dss_device *dssdev)
 406 {
 407         struct omap_overlay_info *info;
 408         u16 outw, outh;
 409         u16 dw, dh;
 410
 411         if (!dssdev)
 412                 return 0;
 413
 414         if (!ovl->info.enabled)
 415                 return 0;
 416
 417         info = &ovl->info;
 418
 419         if (info->paddr == 0) {
 420                 DSSDBG("check_overlay failed: paddr 0\n");
 421                 return -EINVAL;
 422         }
 423
 424         dssdev->driver->get_resolution(dssdev, &dw, &dh);
 425
 426         DSSDBG("check_overlay %d: (%d,%d %dx%d -> %dx%d) disp (%dx%d)\n",
 427                         ovl->id,
 428                         info->pos_x, info->pos_y,
 429                         info->width, info->height,
 430                         info->out_width, info->out_height,
 431                         dw, dh);
 432
 433         if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
 434                 outw = info->width;
 435                 outh = info->height;
 436         } else {
 437                 if (info->out_width == 0)
 438                         outw = info->width;
 439                 else
 440                         outw = info->out_width;
 441
 442                 if (info->out_height == 0)
 443                         outh = info->height;
 444                 else
 445                         outh = info->out_height;
 446         }
 447
 448         if (dw < info->pos_x + outw) {
 449                 DSSDBG("check_overlay failed 1: %d < %d + %d\n",
 450                                 dw, info->pos_x, outw);
 451                 return -EINVAL;
 452         }
 453
 454         if (dh < info->pos_y + outh) {
 455                 DSSDBG("check_overlay failed 2: %d < %d + %d\n",
 456                                 dh, info->pos_y, outh);
 457                 return -EINVAL;
 458         }
 459
 460         if ((ovl->supported_modes & info->color_mode) == 0) {
 461                 DSSERR("overlay doesn't support mode %d\n", info->color_mode);
 462                 return -EINVAL;
 463         }
 464
 465         return 0;
 466 }
 467
 468 static int dss_ovl_set_overlay_info(struct omap_overlay *ovl,
 469                 struct omap_overlay_info *info)
 470 {
 471         int r;
 472         struct omap_overlay_info old_info;
 473
 474         old_info = ovl->info;
 475         ovl->info = *info;
 476
 477         if (ovl->manager) {
 478                 r = dss_check_overlay(ovl, ovl->manager->device);
 479                 if (r) {
 480                         ovl->info = old_info;
 481                         return r;
 482                 }
 483         }
 484
 485         ovl->info_dirty = true;
 486
 487         return 0;
 488 }
 489
 490 static void dss_ovl_get_overlay_info(struct omap_overlay *ovl,
 491                 struct omap_overlay_info *info)
 492 {
 493         *info = ovl->info;
 494 }
 495
 496 static int dss_ovl_wait_for_go(struct omap_overlay *ovl)
 497 {
 498         return dss_mgr_wait_for_go_ovl(ovl);
 499 }
 500
 501 static int omap_dss_set_manager(struct omap_overlay *ovl,
 502                 struct omap_overlay_manager *mgr)
 503 {
 504         if (!mgr)
 505                 return -EINVAL;
 506
 507         if (ovl->manager) {
 508                 DSSERR("overlay '%s' already has a manager '%s'\n",
 509                                 ovl->name, ovl->manager->name);
 510                 return -EINVAL;
 511         }
 512
 513         if (ovl->info.enabled) {
 514                 DSSERR("overlay has to be disabled to change the manager\n");
 515                 return -EINVAL;
 516         }
 517
 518         ovl->manager = mgr;
 519
 520         /* XXX: When there is an overlay on a DSI manual update display, and
 521          * the overlay is first disabled, then moved to tv, and enabled, we
 522          * seem to get SYNC_LOST_DIGIT error.
 523          *
 524          * Waiting doesn't seem to help, but updating the manual update display
 525          * after disabling the overlay seems to fix this. This hints that the
 526          * overlay is perhaps somehow tied to the LCD output until the output
 527          * is updated.
 528          *
 529          * Userspace workaround for this is to update the LCD after disabling
 530          * the overlay, but before moving the overlay to TV.
 531          */
 532         dispc_set_channel_out(ovl->id, mgr->id);
 533
 534         return 0;
 535 }
 536
 537 static int omap_dss_unset_manager(struct omap_overlay *ovl)
 538 {
 539         int r;
 540
 541         if (!ovl->manager) {
 542                 DSSERR("failed to detach overlay: manager not set\n");
 543                 return -EINVAL;
 544         }
 545
 546         if (ovl->info.enabled) {
 547                 DSSERR("overlay has to be disabled to unset the manager\n");
 548                 return -EINVAL;
 549         }
 550
 551         r = ovl->wait_for_go(ovl);
 552         if (r)
 553                 return r;
 554
 555         ovl->manager = NULL;
 556
 557         return 0;
 558 }
 559
 560 int omap_dss_get_num_overlays(void)
 561 {
 562         return num_overlays;
 563 }
 564 EXPORT_SYMBOL(omap_dss_get_num_overlays);
 565
 566 struct omap_overlay *omap_dss_get_overlay(int num)
 567 {
 568         int i = 0;
 569         struct omap_overlay *ovl;
 570
 571         list_for_each_entry(ovl, &overlay_list, list) {
 572                 if (i++ == num)
 573                         return ovl;
 574         }
 575
 576         return NULL;
 577 }
 578 EXPORT_SYMBOL(omap_dss_get_overlay);
 579
 580 static void omap_dss_add_overlay(struct omap_overlay *overlay)
 581 {
 582         ++num_overlays;
 583         list_add_tail(&overlay->list, &overlay_list);
 584 }
 585
 586 static struct omap_overlay *dispc_overlays[MAX_DSS_OVERLAYS];
 587
 588 void dss_overlay_setup_dispc_manager(struct omap_overlay_manager *mgr)
 589 {
 590         mgr->num_overlays = dss_feat_get_num_ovls();
 591         mgr->overlays = dispc_overlays;
 592 }
 593
 594 #ifdef L4_EXAMPLE
 595 static struct omap_overlay *l4_overlays[1];
 596 void dss_overlay_setup_l4_manager(struct omap_overlay_manager *mgr)
 597 {
 598         mgr->num_overlays = 1;
 599         mgr->overlays = l4_overlays;
 600 }
 601 #endif
 602
 603 void dss_init_overlays(struct platform_device *pdev)
 604 {
 605         int i, r;
 606
 607         INIT_LIST_HEAD(&overlay_list);
 608
 609         num_overlays = 0;
 610
 611         for (i = 0; i < dss_feat_get_num_ovls(); ++i) {
 612                 struct omap_overlay *ovl;
 613                 ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);
 614
 615                 BUG_ON(ovl == NULL);
 616
 617                 switch (i) {
 618                 case 0:
 619                         ovl->name = "gfx";
 620                         ovl->id = OMAP_DSS_GFX;
 621                         ovl->caps = OMAP_DSS_OVL_CAP_DISPC;
 622                         ovl->info.global_alpha = 255;
 623                         break;
 624                 case 1:
 625                         ovl->name = "vid1";
 626                         ovl->id = OMAP_DSS_VIDEO1;
 627                         ovl->caps = OMAP_DSS_OVL_CAP_SCALE |
 628                                 OMAP_DSS_OVL_CAP_DISPC;
 629                         ovl->info.global_alpha = 255;
 630                         break;
 631                 case 2:
 632                         ovl->name = "vid2";
 633                         ovl->id = OMAP_DSS_VIDEO2;
 634                         ovl->caps = OMAP_DSS_OVL_CAP_SCALE |
 635                                 OMAP_DSS_OVL_CAP_DISPC;
 636                         ovl->info.global_alpha = 255;
 637                         break;
 638                 }
 639
 640                 ovl->set_manager = &omap_dss_set_manager;
 641                 ovl->unset_manager = &omap_dss_unset_manager;
 642                 ovl->set_overlay_info = &dss_ovl_set_overlay_info;
 643                 ovl->get_overlay_info = &dss_ovl_get_overlay_info;
 644                 ovl->wait_for_go = &dss_ovl_wait_for_go;
 645
 646                 ovl->supported_modes =
 647                         dss_feat_get_supported_color_modes(ovl->id);
 648
 649                 omap_dss_add_overlay(ovl);
 650
 651                 r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
 652                                 &pdev->dev.kobj, "overlay%d", i);
 653
 654                 if (r) {
 655                         DSSERR("failed to create sysfs file\n");
 656                         continue;
 657                 }
 658
 659                 dispc_overlays[i] = ovl;
 660         }
 661
 662 #ifdef L4_EXAMPLE
 663         {
 664                 struct omap_overlay *ovl;
 665                 ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);
 666
 667                 BUG_ON(ovl == NULL);
 668
 669                 ovl->name = "l4";
 670                 ovl->supported_modes = OMAP_DSS_COLOR_RGB24U;
 671
 672                 ovl->set_manager = &omap_dss_set_manager;
 673                 ovl->unset_manager = &omap_dss_unset_manager;
 674                 ovl->set_overlay_info = &dss_ovl_set_overlay_info;
 675                 ovl->get_overlay_info = &dss_ovl_get_overlay_info;
 676
 677                 omap_dss_add_overlay(ovl);
 678
 679                 r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
 680                                 &pdev->dev.kobj, "overlayl4");
 681
 682                 if (r)
 683                         DSSERR("failed to create sysfs file\n");
 684
 685                 l4_overlays[0] = ovl;
 686         }
 687 #endif
 688 }
 689
 690 /* connect overlays to the new device, if not already connected. if force
 691  * selected, connect always. */
 692 void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
 693 {
 694         int i;
 695         struct omap_overlay_manager *lcd_mgr;
 696         struct omap_overlay_manager *tv_mgr;
 697         struct omap_overlay_manager *lcd2_mgr = NULL;
 698         struct omap_overlay_manager *mgr = NULL;
 699
 700         lcd_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD);
 701         tv_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_TV);
 702         if (dss_has_feature(FEAT_MGR_LCD2))
 703                 lcd2_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD2);
 704
 705         if (dssdev->channel == OMAP_DSS_CHANNEL_LCD2) {
 706                 if (!lcd2_mgr->device || force) {
 707                         if (lcd2_mgr->device)
 708                                 lcd2_mgr->unset_device(lcd2_mgr);
 709                         lcd2_mgr->set_device(lcd2_mgr, dssdev);
 710                         mgr = lcd2_mgr;
 711                 }
 712         } else if (dssdev->type != OMAP_DISPLAY_TYPE_VENC
 713                         && dssdev->type != OMAP_DISPLAY_TYPE_HDMI) {
 714                 if (!lcd_mgr->device || force) {
 715                         if (lcd_mgr->device)
 716                                 lcd_mgr->unset_device(lcd_mgr);
 717                         lcd_mgr->set_device(lcd_mgr, dssdev);
 718                         mgr = lcd_mgr;
 719                 }
 720         }
 721
 722         if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
 723                         || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
 724                 if (!tv_mgr->device || force) {
 725                         if (tv_mgr->device)
 726                                 tv_mgr->unset_device(tv_mgr);
 727                         tv_mgr->set_device(tv_mgr, dssdev);
 728                         mgr = tv_mgr;
 729                 }
 730         }
 731
 732         if (mgr) {
 733                 dispc_runtime_get();
 734
 735                 for (i = 0; i < dss_feat_get_num_ovls(); i++) {
 736                         struct omap_overlay *ovl;
 737                         ovl = omap_dss_get_overlay(i);
 738                         if (!ovl->manager || force) {
 739                                 if (ovl->manager)
 740                                         omap_dss_unset_manager(ovl);
 741                                 omap_dss_set_manager(ovl, mgr);
 742                         }
 743                 }
 744
 745                 dispc_runtime_put();
 746         }
 747 }
 748
 749 void dss_uninit_overlays(struct platform_device *pdev)
 750 {
 751         struct omap_overlay *ovl;
 752
 753         while (!list_empty(&overlay_list)) {
 754                 ovl = list_first_entry(&overlay_list,
 755                                 struct omap_overlay, list);
 756                 list_del(&ovl->list);
 757                 kobject_del(&ovl->kobj);
 758                 kobject_put(&ovl->kobj);
 759                 kfree(ovl);
 760         }
 761
 762         num_overlays = 0;
 763 }
 764