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