drivers/video/omap2/dss/display.c

   1 /*
   2  * linux/drivers/video/omap2/dss/display.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 "DISPLAY"
  24
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/jiffies.h>
  28 #include <linux/list.h>
  29 #include <linux/platform_device.h>
  30
  31 #include <plat/display.h>
  32 #include "dss.h"
  33
  34 static LIST_HEAD(display_list);
  35
  36 static ssize_t display_enabled_show(struct device *dev,
  37                 struct device_attribute *attr, char *buf)
  38 {
  39         struct omap_dss_device *dssdev = to_dss_device(dev);
  40         bool enabled = dssdev->state != OMAP_DSS_DISPLAY_DISABLED;
  41
  42         return snprintf(buf, PAGE_SIZE, "%d\n", enabled);
  43 }
  44
  45 static ssize_t display_enabled_store(struct device *dev,
  46                 struct device_attribute *attr,
  47                 const char *buf, size_t size)
  48 {
  49         struct omap_dss_device *dssdev = to_dss_device(dev);
  50         bool enabled, r;
  51
  52         enabled = simple_strtoul(buf, NULL, 10);
  53
  54         if (enabled != (dssdev->state != OMAP_DSS_DISPLAY_DISABLED)) {
  55                 if (enabled) {
  56                         r = dssdev->enable(dssdev);
  57                         if (r)
  58                                 return r;
  59                 } else {
  60                         dssdev->disable(dssdev);
  61                 }
  62         }
  63
  64         return size;
  65 }
  66
  67 static ssize_t display_upd_mode_show(struct device *dev,
  68                 struct device_attribute *attr, char *buf)
  69 {
  70         struct omap_dss_device *dssdev = to_dss_device(dev);
  71         enum omap_dss_update_mode mode = OMAP_DSS_UPDATE_AUTO;
  72         if (dssdev->get_update_mode)
  73                 mode = dssdev->get_update_mode(dssdev);
  74         return snprintf(buf, PAGE_SIZE, "%d\n", mode);
  75 }
  76
  77 static ssize_t display_upd_mode_store(struct device *dev,
  78                 struct device_attribute *attr,
  79                 const char *buf, size_t size)
  80 {
  81         struct omap_dss_device *dssdev = to_dss_device(dev);
  82         int val, r;
  83         enum omap_dss_update_mode mode;
  84
  85         val = simple_strtoul(buf, NULL, 10);
  86
  87         switch (val) {
  88         case OMAP_DSS_UPDATE_DISABLED:
  89         case OMAP_DSS_UPDATE_AUTO:
  90         case OMAP_DSS_UPDATE_MANUAL:
  91                 mode = (enum omap_dss_update_mode)val;
  92                 break;
  93         default:
  94                 return -EINVAL;
  95         }
  96
  97         r = dssdev->set_update_mode(dssdev, mode);
  98         if (r)
  99                 return r;
 100
 101         return size;
 102 }
 103
 104 static ssize_t display_tear_show(struct device *dev,
 105                 struct device_attribute *attr, char *buf)
 106 {
 107         struct omap_dss_device *dssdev = to_dss_device(dev);
 108         return snprintf(buf, PAGE_SIZE, "%d\n",
 109                         dssdev->get_te ? dssdev->get_te(dssdev) : 0);
 110 }
 111
 112 static ssize_t display_tear_store(struct device *dev,
 113                 struct device_attribute *attr, const char *buf, size_t size)
 114 {
 115         struct omap_dss_device *dssdev = to_dss_device(dev);
 116         unsigned long te;
 117         int r;
 118
 119         if (!dssdev->enable_te || !dssdev->get_te)
 120                 return -ENOENT;
 121
 122         te = simple_strtoul(buf, NULL, 0);
 123
 124         r = dssdev->enable_te(dssdev, te);
 125         if (r)
 126                 return r;
 127
 128         return size;
 129 }
 130
 131 static ssize_t display_timings_show(struct device *dev,
 132                 struct device_attribute *attr, char *buf)
 133 {
 134         struct omap_dss_device *dssdev = to_dss_device(dev);
 135         struct omap_video_timings t;
 136
 137         if (!dssdev->get_timings)
 138                 return -ENOENT;
 139
 140         dssdev->get_timings(dssdev, &t);
 141
 142         return snprintf(buf, PAGE_SIZE, "%u,%u/%u/%u/%u,%u/%u/%u/%u\n",
 143                         t.pixel_clock,
 144                         t.x_res, t.hfp, t.hbp, t.hsw,
 145                         t.y_res, t.vfp, t.vbp, t.vsw);
 146 }
 147
 148 static ssize_t display_timings_store(struct device *dev,
 149                 struct device_attribute *attr, const char *buf, size_t size)
 150 {
 151         struct omap_dss_device *dssdev = to_dss_device(dev);
 152         struct omap_video_timings t;
 153         int r, found;
 154
 155         if (!dssdev->set_timings || !dssdev->check_timings)
 156                 return -ENOENT;
 157
 158         found = 0;
 159 #ifdef CONFIG_OMAP2_DSS_VENC
 160         if (strncmp("pal", buf, 3) == 0) {
 161                 t = omap_dss_pal_timings;
 162                 found = 1;
 163         } else if (strncmp("ntsc", buf, 4) == 0) {
 164                 t = omap_dss_ntsc_timings;
 165                 found = 1;
 166         }
 167 #endif
 168         if (!found && sscanf(buf, "%u,%hu/%hu/%hu/%hu,%hu/%hu/%hu/%hu",
 169                                 &t.pixel_clock,
 170                                 &t.x_res, &t.hfp, &t.hbp, &t.hsw,
 171                                 &t.y_res, &t.vfp, &t.vbp, &t.vsw) != 9)
 172                 return -EINVAL;
 173
 174         r = dssdev->check_timings(dssdev, &t);
 175         if (r)
 176                 return r;
 177
 178         dssdev->set_timings(dssdev, &t);
 179
 180         return size;
 181 }
 182
 183 static ssize_t display_rotate_show(struct device *dev,
 184                 struct device_attribute *attr, char *buf)
 185 {
 186         struct omap_dss_device *dssdev = to_dss_device(dev);
 187         int rotate;
 188         if (!dssdev->driver->get_rotate)
 189                 return -ENOENT;
 190         rotate = dssdev->driver->get_rotate(dssdev);
 191         return snprintf(buf, PAGE_SIZE, "%u\n", rotate);
 192 }
 193
 194 static ssize_t display_rotate_store(struct device *dev,
 195                 struct device_attribute *attr, const char *buf, size_t size)
 196 {
 197         struct omap_dss_device *dssdev = to_dss_device(dev);
 198         unsigned long rot;
 199         int r;
 200
 201         if (!dssdev->driver->set_rotate || !dssdev->driver->get_rotate)
 202                 return -ENOENT;
 203
 204         rot = simple_strtoul(buf, NULL, 0);
 205
 206         r = dssdev->driver->set_rotate(dssdev, rot);
 207         if (r)
 208                 return r;
 209
 210         return size;
 211 }
 212
 213 static ssize_t display_mirror_show(struct device *dev,
 214                 struct device_attribute *attr, char *buf)
 215 {
 216         struct omap_dss_device *dssdev = to_dss_device(dev);
 217         int mirror;
 218         if (!dssdev->driver->get_mirror)
 219                 return -ENOENT;
 220         mirror = dssdev->driver->get_mirror(dssdev);
 221         return snprintf(buf, PAGE_SIZE, "%u\n", mirror);
 222 }
 223
 224 static ssize_t display_mirror_store(struct device *dev,
 225                 struct device_attribute *attr, const char *buf, size_t size)
 226 {
 227         struct omap_dss_device *dssdev = to_dss_device(dev);
 228         unsigned long mirror;
 229         int r;
 230
 231         if (!dssdev->driver->set_mirror || !dssdev->driver->get_mirror)
 232                 return -ENOENT;
 233
 234         mirror = simple_strtoul(buf, NULL, 0);
 235
 236         r = dssdev->driver->set_mirror(dssdev, mirror);
 237         if (r)
 238                 return r;
 239
 240         return size;
 241 }
 242
 243 static ssize_t display_wss_show(struct device *dev,
 244                 struct device_attribute *attr, char *buf)
 245 {
 246         struct omap_dss_device *dssdev = to_dss_device(dev);
 247         unsigned int wss;
 248
 249         if (!dssdev->get_wss)
 250                 return -ENOENT;
 251
 252         wss = dssdev->get_wss(dssdev);
 253
 254         return snprintf(buf, PAGE_SIZE, "0x%05x\n", wss);
 255 }
 256
 257 static ssize_t display_wss_store(struct device *dev,
 258                 struct device_attribute *attr, const char *buf, size_t size)
 259 {
 260         struct omap_dss_device *dssdev = to_dss_device(dev);
 261         unsigned long wss;
 262         int r;
 263
 264         if (!dssdev->get_wss || !dssdev->set_wss)
 265                 return -ENOENT;
 266
 267         if (strict_strtoul(buf, 0, &wss))
 268                 return -EINVAL;
 269
 270         if (wss > 0xfffff)
 271                 return -EINVAL;
 272
 273         r = dssdev->set_wss(dssdev, wss);
 274         if (r)
 275                 return r;
 276
 277         return size;
 278 }
 279
 280 static DEVICE_ATTR(enabled, S_IRUGO|S_IWUSR,
 281                 display_enabled_show, display_enabled_store);
 282 static DEVICE_ATTR(update_mode, S_IRUGO|S_IWUSR,
 283                 display_upd_mode_show, display_upd_mode_store);
 284 static DEVICE_ATTR(tear_elim, S_IRUGO|S_IWUSR,
 285                 display_tear_show, display_tear_store);
 286 static DEVICE_ATTR(timings, S_IRUGO|S_IWUSR,
 287                 display_timings_show, display_timings_store);
 288 static DEVICE_ATTR(rotate, S_IRUGO|S_IWUSR,
 289                 display_rotate_show, display_rotate_store);
 290 static DEVICE_ATTR(mirror, S_IRUGO|S_IWUSR,
 291                 display_mirror_show, display_mirror_store);
 292 static DEVICE_ATTR(wss, S_IRUGO|S_IWUSR,
 293                 display_wss_show, display_wss_store);
 294
 295 static struct device_attribute *display_sysfs_attrs[] = {
 296         &dev_attr_enabled,
 297         &dev_attr_update_mode,
 298         &dev_attr_tear_elim,
 299         &dev_attr_timings,
 300         &dev_attr_rotate,
 301         &dev_attr_mirror,
 302         &dev_attr_wss,
 303         NULL
 304 };
 305
 306 static void default_get_resolution(struct omap_dss_device *dssdev,
 307                         u16 *xres, u16 *yres)
 308 {
 309         *xres = dssdev->panel.timings.x_res;
 310         *yres = dssdev->panel.timings.y_res;
 311 }
 312
 313 void default_get_overlay_fifo_thresholds(enum omap_plane plane,
 314                 u32 fifo_size, enum omap_burst_size *burst_size,
 315                 u32 *fifo_low, u32 *fifo_high)
 316 {
 317         unsigned burst_size_bytes;
 318
 319         *burst_size = OMAP_DSS_BURST_16x32;
 320         burst_size_bytes = 16 * 32 / 8;
 321
 322         *fifo_high = fifo_size - 1;
 323         *fifo_low = fifo_size - burst_size_bytes;
 324 }
 325
 326 static int default_get_recommended_bpp(struct omap_dss_device *dssdev)
 327 {
 328         if (dssdev->panel.recommended_bpp)
 329                 return dssdev->panel.recommended_bpp;
 330
 331         switch (dssdev->type) {
 332         case OMAP_DISPLAY_TYPE_DPI:
 333                 if (dssdev->phy.dpi.data_lines == 24)
 334                         return 24;
 335                 else
 336                         return 16;
 337
 338         case OMAP_DISPLAY_TYPE_DBI:
 339         case OMAP_DISPLAY_TYPE_DSI:
 340                 if (dssdev->ctrl.pixel_size == 24)
 341                         return 24;
 342                 else
 343                         return 16;
 344         case OMAP_DISPLAY_TYPE_VENC:
 345         case OMAP_DISPLAY_TYPE_SDI:
 346                 return 24;
 347                 return 24;
 348         default:
 349                 BUG();
 350         }
 351 }
 352
 353 /* Checks if replication logic should be used. Only use for active matrix,
 354  * when overlay is in RGB12U or RGB16 mode, and LCD interface is
 355  * 18bpp or 24bpp */
 356 bool dss_use_replication(struct omap_dss_device *dssdev,
 357                 enum omap_color_mode mode)
 358 {
 359         int bpp;
 360
 361         if (mode != OMAP_DSS_COLOR_RGB12U && mode != OMAP_DSS_COLOR_RGB16)
 362                 return false;
 363
 364         if (dssdev->type == OMAP_DISPLAY_TYPE_DPI &&
 365                         (dssdev->panel.config & OMAP_DSS_LCD_TFT) == 0)
 366                 return false;
 367
 368         switch (dssdev->type) {
 369         case OMAP_DISPLAY_TYPE_DPI:
 370                 bpp = dssdev->phy.dpi.data_lines;
 371                 break;
 372         case OMAP_DISPLAY_TYPE_VENC:
 373         case OMAP_DISPLAY_TYPE_SDI:
 374                 bpp = 24;
 375                 break;
 376         case OMAP_DISPLAY_TYPE_DBI:
 377         case OMAP_DISPLAY_TYPE_DSI:
 378                 bpp = dssdev->ctrl.pixel_size;
 379                 break;
 380         default:
 381                 BUG();
 382         }
 383
 384         return bpp > 16;
 385 }
 386
 387 void dss_init_device(struct platform_device *pdev,
 388                 struct omap_dss_device *dssdev)
 389 {
 390         struct device_attribute *attr;
 391         int i;
 392         int r;
 393
 394         switch (dssdev->type) {
 395         case OMAP_DISPLAY_TYPE_DPI:
 396 #ifdef CONFIG_OMAP2_DSS_RFBI
 397         case OMAP_DISPLAY_TYPE_DBI:
 398 #endif
 399 #ifdef CONFIG_OMAP2_DSS_SDI
 400         case OMAP_DISPLAY_TYPE_SDI:
 401 #endif
 402 #ifdef CONFIG_OMAP2_DSS_DSI
 403         case OMAP_DISPLAY_TYPE_DSI:
 404 #endif
 405 #ifdef CONFIG_OMAP2_DSS_VENC
 406         case OMAP_DISPLAY_TYPE_VENC:
 407 #endif
 408                 break;
 409         default:
 410                 DSSERR("Support for display '%s' not compiled in.\n",
 411                                 dssdev->name);
 412                 return;
 413         }
 414
 415         dssdev->get_resolution = default_get_resolution;
 416         dssdev->get_recommended_bpp = default_get_recommended_bpp;
 417
 418         switch (dssdev->type) {
 419         case OMAP_DISPLAY_TYPE_DPI:
 420                 r = dpi_init_display(dssdev);
 421                 break;
 422 #ifdef CONFIG_OMAP2_DSS_RFBI
 423         case OMAP_DISPLAY_TYPE_DBI:
 424                 r = rfbi_init_display(dssdev);
 425                 break;
 426 #endif
 427 #ifdef CONFIG_OMAP2_DSS_VENC
 428         case OMAP_DISPLAY_TYPE_VENC:
 429                 r = venc_init_display(dssdev);
 430                 break;
 431 #endif
 432 #ifdef CONFIG_OMAP2_DSS_SDI
 433         case OMAP_DISPLAY_TYPE_SDI:
 434                 r = sdi_init_display(dssdev);
 435                 break;
 436 #endif
 437 #ifdef CONFIG_OMAP2_DSS_DSI
 438         case OMAP_DISPLAY_TYPE_DSI:
 439                 r = dsi_init_display(dssdev);
 440                 break;
 441 #endif
 442         default:
 443                 BUG();
 444         }
 445
 446         if (r) {
 447                 DSSERR("failed to init display %s\n", dssdev->name);
 448                 return;
 449         }
 450
 451         /* create device sysfs files */
 452         i = 0;
 453         while ((attr = display_sysfs_attrs[i++]) != NULL) {
 454                 r = device_create_file(&dssdev->dev, attr);
 455                 if (r)
 456                         DSSERR("failed to create sysfs file\n");
 457         }
 458
 459         /* create display? sysfs links */
 460         r = sysfs_create_link(&pdev->dev.kobj, &dssdev->dev.kobj,
 461                         dev_name(&dssdev->dev));
 462         if (r)
 463                 DSSERR("failed to create sysfs display link\n");
 464 }
 465
 466 void dss_uninit_device(struct platform_device *pdev,
 467                 struct omap_dss_device *dssdev)
 468 {
 469         struct device_attribute *attr;
 470         int i = 0;
 471
 472         sysfs_remove_link(&pdev->dev.kobj, dev_name(&dssdev->dev));
 473
 474         while ((attr = display_sysfs_attrs[i++]) != NULL)
 475                 device_remove_file(&dssdev->dev, attr);
 476
 477         if (dssdev->manager)
 478                 dssdev->manager->unset_device(dssdev->manager);
 479 }
 480
 481 static int dss_suspend_device(struct device *dev, void *data)
 482 {
 483         int r;
 484         struct omap_dss_device *dssdev = to_dss_device(dev);
 485
 486         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE) {
 487                 dssdev->activate_after_resume = false;
 488                 return 0;
 489         }
 490
 491         if (!dssdev->suspend) {
 492                 DSSERR("display '%s' doesn't implement suspend\n",
 493                                 dssdev->name);
 494                 return -ENOSYS;
 495         }
 496
 497         r = dssdev->suspend(dssdev);
 498         if (r)
 499                 return r;
 500
 501         dssdev->activate_after_resume = true;
 502
 503         return 0;
 504 }
 505
 506 int dss_suspend_all_devices(void)
 507 {
 508         int r;
 509         struct bus_type *bus = dss_get_bus();
 510
 511         r = bus_for_each_dev(bus, NULL, NULL, dss_suspend_device);
 512         if (r) {
 513                 /* resume all displays that were suspended */
 514                 dss_resume_all_devices();
 515                 return r;
 516         }
 517
 518         return 0;
 519 }
 520
 521 static int dss_resume_device(struct device *dev, void *data)
 522 {
 523         int r;
 524         struct omap_dss_device *dssdev = to_dss_device(dev);
 525
 526         if (dssdev->activate_after_resume && dssdev->resume) {
 527                 r = dssdev->resume(dssdev);
 528                 if (r)
 529                         return r;
 530         }
 531
 532         dssdev->activate_after_resume = false;
 533
 534         return 0;
 535 }
 536
 537 int dss_resume_all_devices(void)
 538 {
 539         struct bus_type *bus = dss_get_bus();
 540
 541         return bus_for_each_dev(bus, NULL, NULL, dss_resume_device);
 542 }
 543
 544 static int dss_disable_device(struct device *dev, void *data)
 545 {
 546         struct omap_dss_device *dssdev = to_dss_device(dev);
 547         dssdev->disable(dssdev);
 548         return 0;
 549 }
 550
 551 void dss_disable_all_devices(void)
 552 {
 553         struct bus_type *bus = dss_get_bus();
 554         bus_for_each_dev(bus, NULL, NULL, dss_disable_device);
 555 }
 556
 557
 558 void omap_dss_get_device(struct omap_dss_device *dssdev)
 559 {
 560         get_device(&dssdev->dev);
 561 }
 562 EXPORT_SYMBOL(omap_dss_get_device);
 563
 564 void omap_dss_put_device(struct omap_dss_device *dssdev)
 565 {
 566         put_device(&dssdev->dev);
 567 }
 568 EXPORT_SYMBOL(omap_dss_put_device);
 569
 570 /* ref count of the found device is incremented. ref count
 571  * of from-device is decremented. */
 572 struct omap_dss_device *omap_dss_get_next_device(struct omap_dss_device *from)
 573 {
 574         struct device *dev;
 575         struct device *dev_start = NULL;
 576         struct omap_dss_device *dssdev = NULL;
 577
 578         int match(struct device *dev, void *data)
 579         {
 580                 return 1;
 581         }
 582
 583         if (from)
 584                 dev_start = &from->dev;
 585         dev = bus_find_device(dss_get_bus(), dev_start, NULL, match);
 586         if (dev)
 587                 dssdev = to_dss_device(dev);
 588         if (from)
 589                 put_device(&from->dev);
 590
 591         return dssdev;
 592 }
 593 EXPORT_SYMBOL(omap_dss_get_next_device);
 594
 595 struct omap_dss_device *omap_dss_find_device(void *data,
 596                 int (*match)(struct omap_dss_device *dssdev, void *data))
 597 {
 598         struct omap_dss_device *dssdev = NULL;
 599
 600         while ((dssdev = omap_dss_get_next_device(dssdev)) != NULL) {
 601                 if (match(dssdev, data))
 602                         return dssdev;
 603         }
 604
 605         return NULL;
 606 }
 607 EXPORT_SYMBOL(omap_dss_find_device);
 608
 609 int omap_dss_start_device(struct omap_dss_device *dssdev)
 610 {
 611         if (!dssdev->driver) {
 612                 DSSDBG("no driver\n");
 613                 return -ENODEV;
 614         }
 615
 616         if (!try_module_get(dssdev->dev.driver->owner)) {
 617                 return -ENODEV;
 618         }
 619
 620         return 0;
 621 }
 622 EXPORT_SYMBOL(omap_dss_start_device);
 623
 624 void omap_dss_stop_device(struct omap_dss_device *dssdev)
 625 {
 626         module_put(dssdev->dev.driver->owner);
 627 }
 628 EXPORT_SYMBOL(omap_dss_stop_device);
 629