drivers/gpu/drm/panel/panel-simple.c

   1 /*
   2  * Copyright (C) 2013, NVIDIA Corporation.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the
  12  * next paragraph) shall be included in all copies or substantial portions
  13  * of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <linux/backlight.h>
  25 #include <linux/gpio.h>
  26 #include <linux/module.h>
  27 #include <linux/of_gpio.h>
  28 #include <linux/of_platform.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/regulator/consumer.h>
  31
  32 #include <drm/drmP.h>
  33 #include <drm/drm_crtc.h>
  34 #include <drm/drm_mipi_dsi.h>
  35 #include <drm/drm_panel.h>
  36
  37 struct panel_desc {
  38         const struct drm_display_mode *modes;
  39         unsigned int num_modes;
  40
  41         struct {
  42                 unsigned int width;
  43                 unsigned int height;
  44         } size;
  45 };
  46
  47 /* TODO: convert to gpiod_*() API once it's been merged */
  48 #define GPIO_ACTIVE_LOW (1 << 0)
  49
  50 struct panel_simple {
  51         struct drm_panel base;
  52         bool enabled;
  53
  54         const struct panel_desc *desc;
  55
  56         struct backlight_device *backlight;
  57         struct regulator *supply;
  58         struct i2c_adapter *ddc;
  59
  60         unsigned long enable_gpio_flags;
  61         int enable_gpio;
  62 };
  63
  64 static inline struct panel_simple *to_panel_simple(struct drm_panel *panel)
  65 {
  66         return container_of(panel, struct panel_simple, base);
  67 }
  68
  69 static int panel_simple_get_fixed_modes(struct panel_simple *panel)
  70 {
  71         struct drm_connector *connector = panel->base.connector;
  72         struct drm_device *drm = panel->base.drm;
  73         struct drm_display_mode *mode;
  74         unsigned int i, num = 0;
  75
  76         if (!panel->desc)
  77                 return 0;
  78
  79         for (i = 0; i < panel->desc->num_modes; i++) {
  80                 const struct drm_display_mode *m = &panel->desc->modes[i];
  81
  82                 mode = drm_mode_duplicate(drm, m);
  83                 if (!mode) {
  84                         dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
  85                                 m->hdisplay, m->vdisplay, m->vrefresh);
  86                         continue;
  87                 }
  88
  89                 drm_mode_set_name(mode);
  90
  91                 drm_mode_probed_add(connector, mode);
  92                 num++;
  93         }
  94
  95         connector->display_info.width_mm = panel->desc->size.width;
  96         connector->display_info.height_mm = panel->desc->size.height;
  97
  98         return num;
  99 }
 100
 101 static int panel_simple_disable(struct drm_panel *panel)
 102 {
 103         struct panel_simple *p = to_panel_simple(panel);
 104
 105         if (!p->enabled)
 106                 return 0;
 107
 108         if (p->backlight) {
 109                 p->backlight->props.power = FB_BLANK_POWERDOWN;
 110                 backlight_update_status(p->backlight);
 111         }
 112
 113         if (gpio_is_valid(p->enable_gpio)) {
 114                 if (p->enable_gpio_flags & GPIO_ACTIVE_LOW)
 115                         gpio_set_value(p->enable_gpio, 1);
 116                 else
 117                         gpio_set_value(p->enable_gpio, 0);
 118         }
 119
 120         regulator_disable(p->supply);
 121         p->enabled = false;
 122
 123         return 0;
 124 }
 125
 126 static int panel_simple_enable(struct drm_panel *panel)
 127 {
 128         struct panel_simple *p = to_panel_simple(panel);
 129         int err;
 130
 131         if (p->enabled)
 132                 return 0;
 133
 134         err = regulator_enable(p->supply);
 135         if (err < 0) {
 136                 dev_err(panel->dev, "failed to enable supply: %d\n", err);
 137                 return err;
 138         }
 139
 140         if (gpio_is_valid(p->enable_gpio)) {
 141                 if (p->enable_gpio_flags & GPIO_ACTIVE_LOW)
 142                         gpio_set_value(p->enable_gpio, 0);
 143                 else
 144                         gpio_set_value(p->enable_gpio, 1);
 145         }
 146
 147         if (p->backlight) {
 148                 p->backlight->props.power = FB_BLANK_UNBLANK;
 149                 backlight_update_status(p->backlight);
 150         }
 151
 152         p->enabled = true;
 153
 154         return 0;
 155 }
 156
 157 static int panel_simple_get_modes(struct drm_panel *panel)
 158 {
 159         struct panel_simple *p = to_panel_simple(panel);
 160         int num = 0;
 161
 162         /* probe EDID if a DDC bus is available */
 163         if (p->ddc) {
 164                 struct edid *edid = drm_get_edid(panel->connector, p->ddc);
 165                 drm_mode_connector_update_edid_property(panel->connector, edid);
 166                 if (edid) {
 167                         num += drm_add_edid_modes(panel->connector, edid);
 168                         kfree(edid);
 169                 }
 170         }
 171
 172         /* add hard-coded panel modes */
 173         num += panel_simple_get_fixed_modes(p);
 174
 175         return num;
 176 }
 177
 178 static const struct drm_panel_funcs panel_simple_funcs = {
 179         .disable = panel_simple_disable,
 180         .enable = panel_simple_enable,
 181         .get_modes = panel_simple_get_modes,
 182 };
 183
 184 static int panel_simple_probe(struct device *dev, const struct panel_desc *desc)
 185 {
 186         struct device_node *backlight, *ddc;
 187         struct panel_simple *panel;
 188         enum of_gpio_flags flags;
 189         int err;
 190
 191         panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
 192         if (!panel)
 193                 return -ENOMEM;
 194
 195         panel->enabled = false;
 196         panel->desc = desc;
 197
 198         panel->supply = devm_regulator_get(dev, "power");
 199         if (IS_ERR(panel->supply))
 200                 return PTR_ERR(panel->supply);
 201
 202         panel->enable_gpio = of_get_named_gpio_flags(dev->of_node,
 203                                                      "enable-gpios", 0,
 204                                                      &flags);
 205         if (gpio_is_valid(panel->enable_gpio)) {
 206                 unsigned int value;
 207
 208                 if (flags & OF_GPIO_ACTIVE_LOW)
 209                         panel->enable_gpio_flags |= GPIO_ACTIVE_LOW;
 210
 211                 err = gpio_request(panel->enable_gpio, "enable");
 212                 if (err < 0) {
 213                         dev_err(dev, "failed to request GPIO#%u: %d\n",
 214                                 panel->enable_gpio, err);
 215                         return err;
 216                 }
 217
 218                 value = (panel->enable_gpio_flags & GPIO_ACTIVE_LOW) != 0;
 219
 220                 err = gpio_direction_output(panel->enable_gpio, value);
 221                 if (err < 0) {
 222                         dev_err(dev, "failed to setup GPIO%u: %d\n",
 223                                 panel->enable_gpio, err);
 224                         goto free_gpio;
 225                 }
 226         }
 227
 228         backlight = of_parse_phandle(dev->of_node, "backlight", 0);
 229         if (backlight) {
 230                 panel->backlight = of_find_backlight_by_node(backlight);
 231                 of_node_put(backlight);
 232
 233                 if (!panel->backlight) {
 234                         err = -EPROBE_DEFER;
 235                         goto free_gpio;
 236                 }
 237         }
 238
 239         ddc = of_parse_phandle(dev->of_node, "ddc-i2c-bus", 0);
 240         if (ddc) {
 241                 panel->ddc = of_find_i2c_adapter_by_node(ddc);
 242                 of_node_put(ddc);
 243
 244                 if (!panel->ddc) {
 245                         err = -EPROBE_DEFER;
 246                         goto free_backlight;
 247                 }
 248         }
 249
 250         drm_panel_init(&panel->base);
 251         panel->base.dev = dev;
 252         panel->base.funcs = &panel_simple_funcs;
 253
 254         err = drm_panel_add(&panel->base);
 255         if (err < 0)
 256                 goto free_ddc;
 257
 258         dev_set_drvdata(dev, panel);
 259
 260         return 0;
 261
 262 free_ddc:
 263         if (panel->ddc)
 264                 put_device(&panel->ddc->dev);
 265 free_backlight:
 266         if (panel->backlight)
 267                 put_device(&panel->backlight->dev);
 268 free_gpio:
 269         if (gpio_is_valid(panel->enable_gpio))
 270                 gpio_free(panel->enable_gpio);
 271
 272         return err;
 273 }
 274
 275 static int panel_simple_remove(struct device *dev)
 276 {
 277         struct panel_simple *panel = dev_get_drvdata(dev);
 278
 279         drm_panel_detach(&panel->base);
 280         drm_panel_remove(&panel->base);
 281
 282         panel_simple_disable(&panel->base);
 283
 284         if (panel->ddc)
 285                 put_device(&panel->ddc->dev);
 286
 287         if (panel->backlight)
 288                 put_device(&panel->backlight->dev);
 289
 290         if (gpio_is_valid(panel->enable_gpio))
 291                 gpio_free(panel->enable_gpio);
 292
 293         regulator_disable(panel->supply);
 294
 295         return 0;
 296 }
 297
 298 static const struct drm_display_mode auo_b101aw03_mode = {
 299         .clock = 51450,
 300         .hdisplay = 1024,
 301         .hsync_start = 1024 + 156,
 302         .hsync_end = 1024 + 156 + 8,
 303         .htotal = 1024 + 156 + 8 + 156,
 304         .vdisplay = 600,
 305         .vsync_start = 600 + 16,
 306         .vsync_end = 600 + 16 + 6,
 307         .vtotal = 600 + 16 + 6 + 16,
 308         .vrefresh = 60,
 309 };
 310
 311 static const struct panel_desc auo_b101aw03 = {
 312         .modes = &auo_b101aw03_mode,
 313         .num_modes = 1,
 314         .size = {
 315                 .width = 223,
 316                 .height = 125,
 317         },
 318 };
 319
 320 static const struct drm_display_mode chunghwa_claa101wa01a_mode = {
 321         .clock = 72070,
 322         .hdisplay = 1366,
 323         .hsync_start = 1366 + 58,
 324         .hsync_end = 1366 + 58 + 58,
 325         .htotal = 1366 + 58 + 58 + 58,
 326         .vdisplay = 768,
 327         .vsync_start = 768 + 4,
 328         .vsync_end = 768 + 4 + 4,
 329         .vtotal = 768 + 4 + 4 + 4,
 330         .vrefresh = 60,
 331 };
 332
 333 static const struct panel_desc chunghwa_claa101wa01a = {
 334         .modes = &chunghwa_claa101wa01a_mode,
 335         .num_modes = 1,
 336         .size = {
 337                 .width = 220,
 338                 .height = 120,
 339         },
 340 };
 341
 342 static const struct drm_display_mode chunghwa_claa101wb01_mode = {
 343         .clock = 69300,
 344         .hdisplay = 1366,
 345         .hsync_start = 1366 + 48,
 346         .hsync_end = 1366 + 48 + 32,
 347         .htotal = 1366 + 48 + 32 + 20,
 348         .vdisplay = 768,
 349         .vsync_start = 768 + 16,
 350         .vsync_end = 768 + 16 + 8,
 351         .vtotal = 768 + 16 + 8 + 16,
 352         .vrefresh = 60,
 353 };
 354
 355 static const struct panel_desc chunghwa_claa101wb01 = {
 356         .modes = &chunghwa_claa101wb01_mode,
 357         .num_modes = 1,
 358         .size = {
 359                 .width = 223,
 360                 .height = 125,
 361         },
 362 };
 363
 364 static const struct drm_display_mode samsung_ltn101nt05_mode = {
 365         .clock = 54030,
 366         .hdisplay = 1024,
 367         .hsync_start = 1024 + 24,
 368         .hsync_end = 1024 + 24 + 136,
 369         .htotal = 1024 + 24 + 136 + 160,
 370         .vdisplay = 600,
 371         .vsync_start = 600 + 3,
 372         .vsync_end = 600 + 3 + 6,
 373         .vtotal = 600 + 3 + 6 + 61,
 374         .vrefresh = 60,
 375 };
 376
 377 static const struct panel_desc samsung_ltn101nt05 = {
 378         .modes = &samsung_ltn101nt05_mode,
 379         .num_modes = 1,
 380         .size = {
 381                 .width = 1024,
 382                 .height = 600,
 383         },
 384 };
 385
 386 static const struct of_device_id platform_of_match[] = {
 387         {
 388                 .compatible = "auo,b101aw03",
 389                 .data = &auo_b101aw03,
 390         }, {
 391                 .compatible = "chunghwa,claa101wa01a",
 392                 .data = &chunghwa_claa101wa01a
 393         }, {
 394                 .compatible = "chunghwa,claa101wb01",
 395                 .data = &chunghwa_claa101wb01
 396         }, {
 397                 .compatible = "samsung,ltn101nt05",
 398                 .data = &samsung_ltn101nt05,
 399         }, {
 400                 .compatible = "simple-panel",
 401         }, {
 402                 /* sentinel */
 403         }
 404 };
 405 MODULE_DEVICE_TABLE(of, platform_of_match);
 406
 407 static int panel_simple_platform_probe(struct platform_device *pdev)
 408 {
 409         const struct of_device_id *id;
 410
 411         id = of_match_node(platform_of_match, pdev->dev.of_node);
 412         if (!id)
 413                 return -ENODEV;
 414
 415         return panel_simple_probe(&pdev->dev, id->data);
 416 }
 417
 418 static int panel_simple_platform_remove(struct platform_device *pdev)
 419 {
 420         return panel_simple_remove(&pdev->dev);
 421 }
 422
 423 static struct platform_driver panel_simple_platform_driver = {
 424         .driver = {
 425                 .name = "panel-simple",
 426                 .owner = THIS_MODULE,
 427                 .of_match_table = platform_of_match,
 428         },
 429         .probe = panel_simple_platform_probe,
 430         .remove = panel_simple_platform_remove,
 431 };
 432
 433 struct panel_desc_dsi {
 434         struct panel_desc desc;
 435
 436         enum mipi_dsi_pixel_format format;
 437         unsigned int lanes;
 438 };
 439
 440 static const struct drm_display_mode panasonic_vvx10f004b00_mode = {
 441         .clock = 157200,
 442         .hdisplay = 1920,
 443         .hsync_start = 1920 + 154,
 444         .hsync_end = 1920 + 154 + 16,
 445         .htotal = 1920 + 154 + 16 + 32,
 446         .vdisplay = 1200,
 447         .vsync_start = 1200 + 17,
 448         .vsync_end = 1200 + 17 + 2,
 449         .vtotal = 1200 + 17 + 2 + 16,
 450         .vrefresh = 60,
 451 };
 452
 453 static const struct panel_desc_dsi panasonic_vvx10f004b00 = {
 454         .desc = {
 455                 .modes = &panasonic_vvx10f004b00_mode,
 456                 .num_modes = 1,
 457                 .size = {
 458                         .width = 217,
 459                         .height = 136,
 460                 },
 461         },
 462         .format = MIPI_DSI_FMT_RGB888,
 463         .lanes = 4,
 464 };
 465
 466 static const struct of_device_id dsi_of_match[] = {
 467         {
 468                 .compatible = "panasonic,vvx10f004b00",
 469                 .data = &panasonic_vvx10f004b00
 470         }, {
 471                 /* sentinel */
 472         }
 473 };
 474 MODULE_DEVICE_TABLE(of, dsi_of_match);
 475
 476 static int panel_simple_dsi_probe(struct mipi_dsi_device *dsi)
 477 {
 478         const struct panel_desc_dsi *desc;
 479         const struct of_device_id *id;
 480         int err;
 481
 482         id = of_match_node(dsi_of_match, dsi->dev.of_node);
 483         if (!id)
 484                 return -ENODEV;
 485
 486         desc = id->data;
 487
 488         err = panel_simple_probe(&dsi->dev, &desc->desc);
 489         if (err < 0)
 490                 return err;
 491
 492         dsi->format = desc->format;
 493         dsi->lanes = desc->lanes;
 494
 495         return mipi_dsi_attach(dsi);
 496 }
 497
 498 static int panel_simple_dsi_remove(struct mipi_dsi_device *dsi)
 499 {
 500         int err;
 501
 502         err = mipi_dsi_detach(dsi);
 503         if (err < 0)
 504                 dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err);
 505
 506         return panel_simple_remove(&dsi->dev);
 507 }
 508
 509 static struct mipi_dsi_driver panel_simple_dsi_driver = {
 510         .driver = {
 511                 .name = "panel-simple-dsi",
 512                 .owner = THIS_MODULE,
 513                 .of_match_table = dsi_of_match,
 514         },
 515         .probe = panel_simple_dsi_probe,
 516         .remove = panel_simple_dsi_remove,
 517 };
 518
 519 static int __init panel_simple_init(void)
 520 {
 521         int err;
 522
 523         err = platform_driver_register(&panel_simple_platform_driver);
 524         if (err < 0)
 525                 return err;
 526
 527         if (IS_ENABLED(CONFIG_DRM_MIPI_DSI)) {
 528                 err = mipi_dsi_driver_register(&panel_simple_dsi_driver);
 529                 if (err < 0)
 530                         return err;
 531         }
 532
 533         return 0;
 534 }
 535 module_init(panel_simple_init);
 536
 537 static void __exit panel_simple_exit(void)
 538 {
 539         if (IS_ENABLED(CONFIG_DRM_MIPI_DSI))
 540                 mipi_dsi_driver_unregister(&panel_simple_dsi_driver);
 541
 542         platform_driver_unregister(&panel_simple_platform_driver);
 543 }
 544 module_exit(panel_simple_exit);
 545
 546 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
 547 MODULE_DESCRIPTION("DRM Driver for Simple Panels");
 548 MODULE_LICENSE("GPL and additional rights");