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