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
  32 #include <mach/display.h>
  33
  34 #include "dss.h"
  35
  36 static int num_overlays;
  37 static struct list_head overlay_list;
  38
  39 static ssize_t overlay_name_show(struct omap_overlay *ovl, char *buf)
  40 {
  41         return snprintf(buf, PAGE_SIZE, "%s\n", ovl->name);
  42 }
  43
  44 static ssize_t overlay_manager_show(struct omap_overlay *ovl, char *buf)
  45 {
  46         return snprintf(buf, PAGE_SIZE, "%s\n",
  47                         ovl->manager ? ovl->manager->name : "<none>");
  48 }
  49
  50 static ssize_t overlay_manager_store(struct omap_overlay *ovl, const char *buf, size_t size)
  51 {
  52         int i, r;
  53         struct omap_overlay_manager *mgr = NULL;
  54         int len = size;
  55
  56         if (buf[size-1] == '\n')
  57                 --len;
  58
  59         if (len > 0) {
  60                 for (i = 0; i < omap_dss_get_num_overlay_managers(); ++i) {
  61                         mgr = omap_dss_get_overlay_manager(i);
  62
  63                         if (strncmp(buf, mgr->name, len) == 0)
  64                                 break;
  65
  66                         mgr = NULL;
  67                 }
  68         }
  69
  70         if (len > 0 && mgr == NULL)
  71                 return -EINVAL;
  72
  73         if (mgr)
  74                 DSSDBG("manager %s found\n", mgr->name);
  75
  76         if (mgr != ovl->manager) {
  77                 /* detach old manager */
  78                 if (ovl->manager) {
  79                         r = ovl->unset_manager(ovl);
  80                         if (r) {
  81                                 DSSERR("detach failed\n");
  82                                 return r;
  83                         }
  84                 }
  85
  86                 if (mgr) {
  87                         r = ovl->set_manager(ovl, mgr);
  88                         if (r) {
  89                                 DSSERR("Failed to attach overlay\n");
  90                                 return r;
  91                         }
  92                 }
  93         }
  94
  95         if (ovl->manager && (r = ovl->manager->apply(ovl->manager)))
  96                 return r;
  97
  98         return size;
  99 }
 100
 101 static ssize_t overlay_input_size_show(struct omap_overlay *ovl, char *buf)
 102 {
 103         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 104                         ovl->info.width, ovl->info.height);
 105 }
 106
 107 static ssize_t overlay_screen_width_show(struct omap_overlay *ovl, char *buf)
 108 {
 109         return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.screen_width);
 110 }
 111
 112 static ssize_t overlay_position_show(struct omap_overlay *ovl, char *buf)
 113 {
 114         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 115                         ovl->info.pos_x, ovl->info.pos_y);
 116 }
 117
 118 static ssize_t overlay_position_store(struct omap_overlay *ovl,
 119                 const char *buf, size_t size)
 120 {
 121         int r;
 122         char *last;
 123         struct omap_overlay_info info;
 124
 125         ovl->get_overlay_info(ovl, &info);
 126
 127         info.pos_x = simple_strtoul(buf, &last, 10);
 128         ++last;
 129         if (last - buf >= size)
 130                 return -EINVAL;
 131
 132         info.pos_y = simple_strtoul(last, &last, 10);
 133
 134         if ((r = ovl->set_overlay_info(ovl, &info)))
 135                 return r;
 136
 137         if (ovl->manager && (r = ovl->manager->apply(ovl->manager)))
 138                 return r;
 139
 140         return size;
 141 }
 142
 143 static ssize_t overlay_output_size_show(struct omap_overlay *ovl, char *buf)
 144 {
 145         return snprintf(buf, PAGE_SIZE, "%d,%d\n",
 146                         ovl->info.out_width, ovl->info.out_height);
 147 }
 148
 149 static ssize_t overlay_output_size_store(struct omap_overlay *ovl,
 150                 const char *buf, size_t size)
 151 {
 152         int r;
 153         char *last;
 154         struct omap_overlay_info info;
 155
 156         ovl->get_overlay_info(ovl, &info);
 157
 158         info.out_width = simple_strtoul(buf, &last, 10);
 159         ++last;
 160         if (last - buf >= size)
 161                 return -EINVAL;
 162
 163         info.out_height = simple_strtoul(last, &last, 10);
 164
 165         if ((r = ovl->set_overlay_info(ovl, &info)))
 166                 return r;
 167
 168         if (ovl->manager && (r = ovl->manager->apply(ovl->manager)))
 169                 return r;
 170
 171         return size;
 172 }
 173
 174 static ssize_t overlay_enabled_show(struct omap_overlay *ovl, char *buf)
 175 {
 176         return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.enabled);
 177 }
 178
 179 static ssize_t overlay_enabled_store(struct omap_overlay *ovl, const char *buf, size_t size)
 180 {
 181         int r;
 182         struct omap_overlay_info info;
 183
 184         ovl->get_overlay_info(ovl, &info);
 185
 186         info.enabled = simple_strtoul(buf, NULL, 10);
 187
 188         if ((r = ovl->set_overlay_info(ovl, &info)))
 189                 return r;
 190
 191         if (ovl->manager && (r = ovl->manager->apply(ovl->manager)))
 192                 return r;
 193
 194         return size;
 195 }
 196
 197 static ssize_t overlay_global_alpha_show(struct omap_overlay *ovl, char *buf)
 198 {
 199         return snprintf(buf, PAGE_SIZE, "%d\n",
 200                         ovl->info.global_alpha);
 201 }
 202
 203 static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl,
 204                 const char *buf, size_t size)
 205 {
 206         int r;
 207         struct omap_overlay_info info;
 208
 209         ovl->get_overlay_info(ovl, &info);
 210
 211         /* Video1 plane does not support global alpha
 212          * to always make it 255 completely opaque
 213          */
 214         if (ovl->id == OMAP_DSS_VIDEO1)
 215                 info.global_alpha = 255;
 216         else
 217                 info.global_alpha = simple_strtoul(buf, NULL, 10);
 218
 219         if ((r = ovl->set_overlay_info(ovl, &info)))
 220                 return r;
 221
 222         if (ovl->manager && (r = ovl->manager->apply(ovl->manager)))
 223                 return r;
 224
 225         return size;
 226 }
 227
 228 struct overlay_attribute {
 229         struct attribute attr;
 230         ssize_t (*show)(struct omap_overlay *, char *);
 231         ssize_t (*store)(struct omap_overlay *, const char *, size_t);
 232 };
 233
 234 #define OVERLAY_ATTR(_name, _mode, _show, _store) \
 235         struct overlay_attribute overlay_attr_##_name = \
 236         __ATTR(_name, _mode, _show, _store)
 237
 238 static OVERLAY_ATTR(name, S_IRUGO, overlay_name_show, NULL);
 239 static OVERLAY_ATTR(manager, S_IRUGO|S_IWUSR,
 240                 overlay_manager_show, overlay_manager_store);
 241 static OVERLAY_ATTR(input_size, S_IRUGO, overlay_input_size_show, NULL);
 242 static OVERLAY_ATTR(screen_width, S_IRUGO, overlay_screen_width_show, NULL);
 243 static OVERLAY_ATTR(position, S_IRUGO|S_IWUSR,
 244                 overlay_position_show, overlay_position_store);
 245 static OVERLAY_ATTR(output_size, S_IRUGO|S_IWUSR,
 246                 overlay_output_size_show, overlay_output_size_store);
 247 static OVERLAY_ATTR(enabled, S_IRUGO|S_IWUSR,
 248                 overlay_enabled_show, overlay_enabled_store);
 249 static OVERLAY_ATTR(global_alpha, S_IRUGO|S_IWUSR,
 250                 overlay_global_alpha_show, overlay_global_alpha_store);
 251
 252 static struct attribute *overlay_sysfs_attrs[] = {
 253         &overlay_attr_name.attr,
 254         &overlay_attr_manager.attr,
 255         &overlay_attr_input_size.attr,
 256         &overlay_attr_screen_width.attr,
 257         &overlay_attr_position.attr,
 258         &overlay_attr_output_size.attr,
 259         &overlay_attr_enabled.attr,
 260         &overlay_attr_global_alpha.attr,
 261         NULL
 262 };
 263
 264 static ssize_t overlay_attr_show(struct kobject *kobj, struct attribute *attr, char *buf)
 265 {
 266         struct omap_overlay *overlay;
 267         struct overlay_attribute *overlay_attr;
 268
 269         overlay = container_of(kobj, struct omap_overlay, kobj);
 270         overlay_attr = container_of(attr, struct overlay_attribute, attr);
 271
 272         if (!overlay_attr->show)
 273                 return -ENOENT;
 274
 275         return overlay_attr->show(overlay, buf);
 276 }
 277
 278 static ssize_t overlay_attr_store(struct kobject *kobj, struct attribute *attr,
 279                 const char *buf, size_t size)
 280 {
 281         struct omap_overlay *overlay;
 282         struct overlay_attribute *overlay_attr;
 283
 284         overlay = container_of(kobj, struct omap_overlay, kobj);
 285         overlay_attr = container_of(attr, struct overlay_attribute, attr);
 286
 287         if (!overlay_attr->store)
 288                 return -ENOENT;
 289
 290         return overlay_attr->store(overlay, buf, size);
 291 }
 292
 293 static struct sysfs_ops overlay_sysfs_ops = {
 294         .show = overlay_attr_show,
 295         .store = overlay_attr_store,
 296 };
 297
 298 static struct kobj_type overlay_ktype = {
 299         .sysfs_ops = &overlay_sysfs_ops,
 300         .default_attrs = overlay_sysfs_attrs,
 301 };
 302
 303 /* Check if overlay parameters are compatible with display */
 304 int dss_check_overlay(struct omap_overlay *ovl, struct omap_display *display)
 305 {
 306         struct omap_overlay_info *info;
 307         u16 outw, outh;
 308         u16 dw, dh;
 309
 310         if (!display)
 311                 return 0;
 312
 313         if (!ovl->info.enabled)
 314                 return 0;
 315
 316         info = &ovl->info;
 317
 318         if (info->paddr == 0) {
 319                 DSSDBG("check_overlay failed: paddr 0\n");
 320                 return -EINVAL;
 321         }
 322
 323         display->get_resolution(display, &dw, &dh);
 324
 325         DSSDBG("check_overlay %d: (%d,%d %dx%d -> %dx%d) disp (%dx%d)\n",
 326                         ovl->id,
 327                         info->pos_x, info->pos_y,
 328                         info->width, info->height,
 329                         info->out_width, info->out_height,
 330                         dw, dh);
 331
 332         if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
 333                 outw = info->width;
 334                 outh = info->height;
 335         } else {
 336                 if (info->out_width == 0)
 337                         outw = info->width;
 338                 else
 339                         outw = info->out_width;
 340
 341                 if (info->out_height == 0)
 342                         outh = info->height;
 343                 else
 344                         outh = info->out_height;
 345         }
 346
 347         if (dw < info->pos_x + outw) {
 348                 DSSDBG("check_overlay failed 1: %d < %d + %d\n",
 349                                 dw, info->pos_x, outw);
 350                 return -EINVAL;
 351         }
 352
 353         if (dh < info->pos_y + outh) {
 354                 DSSDBG("check_overlay failed 2: %d < %d + %d\n",
 355                                 dh, info->pos_y, outh);
 356                 return -EINVAL;
 357         }
 358
 359         if ((ovl->supported_modes & info->color_mode) == 0) {
 360                 DSSERR("overlay doesn't support mode %d\n", info->color_mode);
 361                 return -EINVAL;
 362         }
 363
 364         return 0;
 365 }
 366
 367 static int dss_ovl_set_overlay_info(struct omap_overlay *ovl,
 368                 struct omap_overlay_info *info)
 369 {
 370         int r;
 371         struct omap_overlay_info old_info;
 372
 373         old_info = ovl->info;
 374         ovl->info = *info;
 375
 376         if (ovl->manager) {
 377                 r = dss_check_overlay(ovl, ovl->manager->display);
 378                 if (r) {
 379                         ovl->info = old_info;
 380                         return r;
 381                 }
 382         }
 383
 384         return 0;
 385 }
 386
 387 static void dss_ovl_get_overlay_info(struct omap_overlay *ovl,
 388                 struct omap_overlay_info *info)
 389 {
 390         *info = ovl->info;
 391 }
 392
 393 static int omap_dss_set_manager(struct omap_overlay *ovl,
 394                 struct omap_overlay_manager *mgr)
 395 {
 396         int r;
 397
 398         if (ovl->manager) {
 399                 DSSERR("overlay '%s' already has a manager '%s'\n",
 400                                 ovl->name, ovl->manager->name);
 401         }
 402
 403         r = dss_check_overlay(ovl, mgr->display);
 404         if (r)
 405                 return r;
 406
 407         ovl->manager = mgr;
 408
 409         return 0;
 410 }
 411
 412 static int omap_dss_unset_manager(struct omap_overlay *ovl)
 413 {
 414         if (!ovl->manager) {
 415                 DSSERR("failed to detach overlay: manager not set\n");
 416                 return -EINVAL;
 417         }
 418
 419         ovl->manager = NULL;
 420
 421         return 0;
 422 }
 423
 424 int omap_dss_get_num_overlays(void)
 425 {
 426         return num_overlays;
 427 }
 428 EXPORT_SYMBOL(omap_dss_get_num_overlays);
 429
 430 struct omap_overlay *omap_dss_get_overlay(int num)
 431 {
 432         int i = 0;
 433         struct omap_overlay *ovl;
 434
 435         list_for_each_entry(ovl, &overlay_list, list) {
 436                 if (i++ == num)
 437                         return ovl;
 438         }
 439
 440         return NULL;
 441 }
 442 EXPORT_SYMBOL(omap_dss_get_overlay);
 443
 444 static void omap_dss_add_overlay(struct omap_overlay *overlay)
 445 {
 446         ++num_overlays;
 447         list_add_tail(&overlay->list, &overlay_list);
 448 }
 449
 450 static struct omap_overlay *dispc_overlays[3];
 451
 452 void dss_overlay_setup_dispc_manager(struct omap_overlay_manager *mgr)
 453 {
 454         mgr->num_overlays = 3;
 455         mgr->overlays = dispc_overlays;
 456 }
 457
 458 void dss_init_overlays(struct platform_device *pdev, const char *def_disp_name)
 459 {
 460         int i, r;
 461         struct omap_overlay_manager *lcd_mgr;
 462         struct omap_overlay_manager *tv_mgr;
 463         struct omap_overlay_manager *def_mgr = NULL;
 464
 465         INIT_LIST_HEAD(&overlay_list);
 466
 467         num_overlays = 0;
 468
 469         for (i = 0; i < 3; ++i) {
 470                 struct omap_overlay *ovl;
 471                 ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);
 472
 473                 BUG_ON(ovl == NULL);
 474
 475                 switch (i) {
 476                 case 0:
 477                         ovl->name = "gfx";
 478                         ovl->id = OMAP_DSS_GFX;
 479                         ovl->supported_modes = OMAP_DSS_COLOR_GFX_OMAP3;
 480                         ovl->caps = OMAP_DSS_OVL_CAP_DISPC;
 481                         ovl->info.global_alpha = 255;
 482                         break;
 483                 case 1:
 484                         ovl->name = "vid1";
 485                         ovl->id = OMAP_DSS_VIDEO1;
 486                         ovl->supported_modes = OMAP_DSS_COLOR_VID_OMAP3;
 487                         ovl->caps = OMAP_DSS_OVL_CAP_SCALE |
 488                                 OMAP_DSS_OVL_CAP_DISPC;
 489                         ovl->info.global_alpha = 255;
 490                         break;
 491                 case 2:
 492                         ovl->name = "vid2";
 493                         ovl->id = OMAP_DSS_VIDEO2;
 494                         ovl->supported_modes = OMAP_DSS_COLOR_VID_OMAP3;
 495                         ovl->caps = OMAP_DSS_OVL_CAP_SCALE |
 496                                 OMAP_DSS_OVL_CAP_DISPC;
 497                         ovl->info.global_alpha = 255;
 498                         break;
 499                 }
 500
 501                 ovl->set_manager = &omap_dss_set_manager;
 502                 ovl->unset_manager = &omap_dss_unset_manager;
 503                 ovl->set_overlay_info = &dss_ovl_set_overlay_info;
 504                 ovl->get_overlay_info = &dss_ovl_get_overlay_info;
 505
 506                 omap_dss_add_overlay(ovl);
 507
 508                 r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
 509                                 &pdev->dev.kobj, "overlay%d", i);
 510
 511                 if (r) {
 512                         DSSERR("failed to create sysfs file\n");
 513                         continue;
 514                 }
 515
 516                 dispc_overlays[i] = ovl;
 517         }
 518
 519         lcd_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD);
 520         tv_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_TV);
 521
 522         if (def_disp_name) {
 523                 for (i = 0; i < omap_dss_get_num_displays() ; i++) {
 524                         struct omap_display *display = dss_get_display(i);
 525
 526                         if (strcmp(display->name, def_disp_name) == 0) {
 527                                 if (display->type != OMAP_DISPLAY_TYPE_VENC) {
 528                                         lcd_mgr->set_display(lcd_mgr, display);
 529                                         def_mgr = lcd_mgr;
 530                                 } else {
 531                                         lcd_mgr->set_display(tv_mgr, display);
 532                                         def_mgr = tv_mgr;
 533                                 }
 534
 535                                 break;
 536                         }
 537                 }
 538
 539                 if (!def_mgr)
 540                         DSSWARN("default display %s not found\n",
 541                                         def_disp_name);
 542         }
 543
 544         if (def_mgr != lcd_mgr) {
 545                 /* connect lcd manager to first non-VENC display found */
 546                 for (i = 0; i < omap_dss_get_num_displays(); i++) {
 547                         struct omap_display *display = dss_get_display(i);
 548                         if (display->type != OMAP_DISPLAY_TYPE_VENC) {
 549                                 lcd_mgr->set_display(lcd_mgr, display);
 550
 551                                 if (!def_mgr)
 552                                         def_mgr = lcd_mgr;
 553
 554                                 break;
 555                         }
 556                 }
 557         }
 558
 559         if (def_mgr != tv_mgr) {
 560                 /* connect tv manager to first VENC display found */
 561                 for (i = 0; i < omap_dss_get_num_displays(); i++) {
 562                         struct omap_display *display = dss_get_display(i);
 563                         if (display->type == OMAP_DISPLAY_TYPE_VENC) {
 564                                 tv_mgr->set_display(tv_mgr, display);
 565
 566                                 if (!def_mgr)
 567                                         def_mgr = tv_mgr;
 568
 569                                 break;
 570                         }
 571                 }
 572         }
 573
 574         /* connect all dispc overlays to def_mgr */
 575         if (def_mgr) {
 576                 for (i = 0; i < 3; i++) {
 577                         struct omap_overlay *ovl;
 578                         ovl = omap_dss_get_overlay(i);
 579                         omap_dss_set_manager(ovl, def_mgr);
 580                 }
 581         }
 582
 583 #ifdef L4_EXAMPLE
 584         /* setup L4 overlay as an example */
 585         {
 586                 static struct omap_overlay ovl = {
 587                         .name = "l4-ovl",
 588                         .supported_modes = OMAP_DSS_COLOR_RGB24U,
 589                         .set_manager = &omap_dss_set_manager,
 590                         .unset_manager = &omap_dss_unset_manager,
 591                         .setup_input = &omap_dss_setup_overlay_input,
 592                         .setup_output = &omap_dss_setup_overlay_output,
 593                         .enable = &omap_dss_enable_overlay,
 594                 };
 595
 596                 static struct omap_overlay_manager mgr = {
 597                         .name = "l4",
 598                         .num_overlays = 1,
 599                         .overlays = &ovl,
 600                         .set_display = &omap_dss_set_display,
 601                         .unset_display = &omap_dss_unset_display,
 602                         .apply = &ovl_mgr_apply_l4,
 603                         .supported_displays =
 604                                 OMAP_DISPLAY_TYPE_DBI | OMAP_DISPLAY_TYPE_DSI,
 605                 };
 606
 607                 omap_dss_add_overlay(&ovl);
 608                 omap_dss_add_overlay_manager(&mgr);
 609                 omap_dss_set_manager(&ovl, &mgr);
 610         }
 611 #endif
 612 }
 613
 614 void dss_uninit_overlays(struct platform_device *pdev)
 615 {
 616         struct omap_overlay *ovl;
 617
 618         while (!list_empty(&overlay_list)) {
 619                 ovl = list_first_entry(&overlay_list,
 620                                 struct omap_overlay, list);
 621                 list_del(&ovl->list);
 622                 kobject_del(&ovl->kobj);
 623                 kobject_put(&ovl->kobj);
 624                 kfree(ovl);
 625         }
 626
 627         num_overlays = 0;
 628 }
 629