drivers/video/exynos/exynos_mipi_dsi.c

   1 /* linux/drivers/video/exynos/exynos_mipi_dsi.c
   2  *
   3  * Samsung SoC MIPI-DSIM driver.
   4  *
   5  * Copyright (c) 2012 Samsung Electronics Co., Ltd
   6  *
   7  * InKi Dae, <inki.dae@samsung.com>
   8  * Donghwa Lee, <dh09.lee@samsung.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13 */
  14
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/errno.h>
  18 #include <linux/clk.h>
  19 #include <linux/mutex.h>
  20 #include <linux/wait.h>
  21 #include <linux/fs.h>
  22 #include <linux/mm.h>
  23 #include <linux/fb.h>
  24 #include <linux/ctype.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/io.h>
  27 #include <linux/irq.h>
  28 #include <linux/memory.h>
  29 #include <linux/delay.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/kthread.h>
  32 #include <linux/notifier.h>
  33 #include <linux/phy/phy.h>
  34 #include <linux/regulator/consumer.h>
  35 #include <linux/pm_runtime.h>
  36 #include <linux/err.h>
  37
  38 #include <video/exynos_mipi_dsim.h>
  39
  40 #include "exynos_mipi_dsi_common.h"
  41 #include "exynos_mipi_dsi_lowlevel.h"
  42
  43 struct mipi_dsim_ddi {
  44         int                             bus_id;
  45         struct list_head                list;
  46         struct mipi_dsim_lcd_device     *dsim_lcd_dev;
  47         struct mipi_dsim_lcd_driver     *dsim_lcd_drv;
  48 };
  49
  50 static LIST_HEAD(dsim_ddi_list);
  51
  52 static DEFINE_MUTEX(mipi_dsim_lock);
  53
  54 static struct mipi_dsim_platform_data *to_dsim_plat(struct platform_device
  55                                                         *pdev)
  56 {
  57         return pdev->dev.platform_data;
  58 }
  59
  60 static struct regulator_bulk_data supplies[] = {
  61         { .supply = "vdd11", },
  62         { .supply = "vdd18", },
  63 };
  64
  65 static int exynos_mipi_regulator_enable(struct mipi_dsim_device *dsim)
  66 {
  67         int ret;
  68
  69         mutex_lock(&dsim->lock);
  70         ret = regulator_bulk_enable(ARRAY_SIZE(supplies), supplies);
  71         mutex_unlock(&dsim->lock);
  72
  73         return ret;
  74 }
  75
  76 static int exynos_mipi_regulator_disable(struct mipi_dsim_device *dsim)
  77 {
  78         int ret;
  79
  80         mutex_lock(&dsim->lock);
  81         ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
  82         mutex_unlock(&dsim->lock);
  83
  84         return ret;
  85 }
  86
  87 /* update all register settings to MIPI DSI controller. */
  88 static void exynos_mipi_update_cfg(struct mipi_dsim_device *dsim)
  89 {
  90         /*
  91          * data from Display controller(FIMD) is not transferred in video mode
  92          * but in case of command mode, all settings is not updated to
  93          * registers.
  94          */
  95         exynos_mipi_dsi_stand_by(dsim, 0);
  96
  97         exynos_mipi_dsi_init_dsim(dsim);
  98         exynos_mipi_dsi_init_link(dsim);
  99
 100         exynos_mipi_dsi_set_hs_enable(dsim);
 101
 102         /* set display timing. */
 103         exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);
 104
 105         exynos_mipi_dsi_init_interrupt(dsim);
 106
 107         /*
 108          * data from Display controller(FIMD) is transferred in video mode
 109          * but in case of command mode, all settings are updated to registers.
 110          */
 111         exynos_mipi_dsi_stand_by(dsim, 1);
 112 }
 113
 114 static int exynos_mipi_dsi_early_blank_mode(struct mipi_dsim_device *dsim,
 115                 int power)
 116 {
 117         struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
 118         struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
 119
 120         switch (power) {
 121         case FB_BLANK_POWERDOWN:
 122                 if (dsim->suspended)
 123                         return 0;
 124
 125                 if (client_drv && client_drv->suspend)
 126                         client_drv->suspend(client_dev);
 127
 128                 clk_disable(dsim->clock);
 129
 130                 exynos_mipi_regulator_disable(dsim);
 131
 132                 dsim->suspended = true;
 133
 134                 break;
 135         default:
 136                 break;
 137         }
 138
 139         return 0;
 140 }
 141
 142 static int exynos_mipi_dsi_blank_mode(struct mipi_dsim_device *dsim, int power)
 143 {
 144         struct platform_device *pdev = to_platform_device(dsim->dev);
 145         struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
 146         struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
 147
 148         switch (power) {
 149         case FB_BLANK_UNBLANK:
 150                 if (!dsim->suspended)
 151                         return 0;
 152
 153                 /* lcd panel power on. */
 154                 if (client_drv && client_drv->power_on)
 155                         client_drv->power_on(client_dev, 1);
 156
 157                 exynos_mipi_regulator_enable(dsim);
 158
 159                 /* enable MIPI-DSI PHY. */
 160                 phy_power_on(dsim->phy);
 161
 162                 clk_enable(dsim->clock);
 163
 164                 exynos_mipi_update_cfg(dsim);
 165
 166                 /* set lcd panel sequence commands. */
 167                 if (client_drv && client_drv->set_sequence)
 168                         client_drv->set_sequence(client_dev);
 169
 170                 dsim->suspended = false;
 171
 172                 break;
 173         case FB_BLANK_NORMAL:
 174                 /* TODO. */
 175                 break;
 176         default:
 177                 break;
 178         }
 179
 180         return 0;
 181 }
 182
 183 int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
 184 {
 185         struct mipi_dsim_ddi *dsim_ddi;
 186
 187         if (!lcd_dev->name) {
 188                 pr_err("dsim_lcd_device name is NULL.\n");
 189                 return -EFAULT;
 190         }
 191
 192         dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
 193         if (!dsim_ddi) {
 194                 pr_err("failed to allocate dsim_ddi object.\n");
 195                 return -ENOMEM;
 196         }
 197
 198         dsim_ddi->dsim_lcd_dev = lcd_dev;
 199
 200         mutex_lock(&mipi_dsim_lock);
 201         list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
 202         mutex_unlock(&mipi_dsim_lock);
 203
 204         return 0;
 205 }
 206
 207 static struct mipi_dsim_ddi *exynos_mipi_dsi_find_lcd_device(
 208                                         struct mipi_dsim_lcd_driver *lcd_drv)
 209 {
 210         struct mipi_dsim_ddi *dsim_ddi, *next;
 211         struct mipi_dsim_lcd_device *lcd_dev;
 212
 213         mutex_lock(&mipi_dsim_lock);
 214
 215         list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
 216                 if (!dsim_ddi)
 217                         goto out;
 218
 219                 lcd_dev = dsim_ddi->dsim_lcd_dev;
 220                 if (!lcd_dev)
 221                         continue;
 222
 223                 if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
 224                         /**
 225                          * bus_id would be used to identify
 226                          * connected bus.
 227                          */
 228                         dsim_ddi->bus_id = lcd_dev->bus_id;
 229                         mutex_unlock(&mipi_dsim_lock);
 230
 231                         return dsim_ddi;
 232                 }
 233
 234                 list_del(&dsim_ddi->list);
 235                 kfree(dsim_ddi);
 236         }
 237
 238 out:
 239         mutex_unlock(&mipi_dsim_lock);
 240
 241         return NULL;
 242 }
 243
 244 int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
 245 {
 246         struct mipi_dsim_ddi *dsim_ddi;
 247
 248         if (!lcd_drv->name) {
 249                 pr_err("dsim_lcd_driver name is NULL.\n");
 250                 return -EFAULT;
 251         }
 252
 253         dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
 254         if (!dsim_ddi) {
 255                 pr_err("mipi_dsim_ddi object not found.\n");
 256                 return -EFAULT;
 257         }
 258
 259         dsim_ddi->dsim_lcd_drv = lcd_drv;
 260
 261         pr_info("registered panel driver(%s) to mipi-dsi driver.\n",
 262                 lcd_drv->name);
 263
 264         return 0;
 265
 266 }
 267
 268 static struct mipi_dsim_ddi *exynos_mipi_dsi_bind_lcd_ddi(
 269                                                 struct mipi_dsim_device *dsim,
 270                                                 const char *name)
 271 {
 272         struct mipi_dsim_ddi *dsim_ddi, *next;
 273         struct mipi_dsim_lcd_driver *lcd_drv;
 274         struct mipi_dsim_lcd_device *lcd_dev;
 275         int ret;
 276
 277         mutex_lock(&dsim->lock);
 278
 279         list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
 280                 lcd_drv = dsim_ddi->dsim_lcd_drv;
 281                 lcd_dev = dsim_ddi->dsim_lcd_dev;
 282                 if (!lcd_drv || !lcd_dev ||
 283                         (dsim->id != dsim_ddi->bus_id))
 284                                 continue;
 285
 286                 dev_dbg(dsim->dev, "lcd_drv->id = %d, lcd_dev->id = %d\n",
 287                                 lcd_drv->id, lcd_dev->id);
 288                 dev_dbg(dsim->dev, "lcd_dev->bus_id = %d, dsim->id = %d\n",
 289                                 lcd_dev->bus_id, dsim->id);
 290
 291                 if ((strcmp(lcd_drv->name, name) == 0)) {
 292                         lcd_dev->master = dsim;
 293
 294                         lcd_dev->dev.parent = dsim->dev;
 295                         dev_set_name(&lcd_dev->dev, "%s", lcd_drv->name);
 296
 297                         ret = device_register(&lcd_dev->dev);
 298                         if (ret < 0) {
 299                                 dev_err(dsim->dev,
 300                                         "can't register %s, status %d\n",
 301                                         dev_name(&lcd_dev->dev), ret);
 302                                 mutex_unlock(&dsim->lock);
 303
 304                                 return NULL;
 305                         }
 306
 307                         dsim->dsim_lcd_dev = lcd_dev;
 308                         dsim->dsim_lcd_drv = lcd_drv;
 309
 310                         mutex_unlock(&dsim->lock);
 311
 312                         return dsim_ddi;
 313                 }
 314         }
 315
 316         mutex_unlock(&dsim->lock);
 317
 318         return NULL;
 319 }
 320
 321 /* define MIPI-DSI Master operations. */
 322 static struct mipi_dsim_master_ops master_ops = {
 323         .cmd_read                       = exynos_mipi_dsi_rd_data,
 324         .cmd_write                      = exynos_mipi_dsi_wr_data,
 325         .get_dsim_frame_done            = exynos_mipi_dsi_get_frame_done_status,
 326         .clear_dsim_frame_done          = exynos_mipi_dsi_clear_frame_done,
 327         .set_early_blank_mode           = exynos_mipi_dsi_early_blank_mode,
 328         .set_blank_mode                 = exynos_mipi_dsi_blank_mode,
 329 };
 330
 331 static int exynos_mipi_dsi_probe(struct platform_device *pdev)
 332 {
 333         struct resource *res;
 334         struct mipi_dsim_device *dsim;
 335         struct mipi_dsim_config *dsim_config;
 336         struct mipi_dsim_platform_data *dsim_pd;
 337         struct mipi_dsim_ddi *dsim_ddi;
 338         int ret = -EINVAL;
 339
 340         dsim = devm_kzalloc(&pdev->dev, sizeof(struct mipi_dsim_device),
 341                                 GFP_KERNEL);
 342         if (!dsim) {
 343                 dev_err(&pdev->dev, "failed to allocate dsim object.\n");
 344                 return -ENOMEM;
 345         }
 346
 347         dsim->pd = to_dsim_plat(pdev);
 348         dsim->dev = &pdev->dev;
 349         dsim->id = pdev->id;
 350
 351         /* get mipi_dsim_platform_data. */
 352         dsim_pd = (struct mipi_dsim_platform_data *)dsim->pd;
 353         if (dsim_pd == NULL) {
 354                 dev_err(&pdev->dev, "failed to get platform data for dsim.\n");
 355                 return -EINVAL;
 356         }
 357         /* get mipi_dsim_config. */
 358         dsim_config = dsim_pd->dsim_config;
 359         if (dsim_config == NULL) {
 360                 dev_err(&pdev->dev, "failed to get dsim config data.\n");
 361                 return -EINVAL;
 362         }
 363
 364         dsim->dsim_config = dsim_config;
 365         dsim->master_ops = &master_ops;
 366
 367         mutex_init(&dsim->lock);
 368
 369         ret = devm_regulator_bulk_get(&pdev->dev, ARRAY_SIZE(supplies),
 370                                         supplies);
 371         if (ret) {
 372                 dev_err(&pdev->dev, "Failed to get regulators: %d\n", ret);
 373                 return ret;
 374         }
 375
 376         dsim->phy = devm_phy_get(&pdev->dev, "dsim");
 377         if (IS_ERR(dsim->phy))
 378                 return PTR_ERR(dsim->phy);
 379
 380         dsim->clock = devm_clk_get(&pdev->dev, "dsim0");
 381         if (IS_ERR(dsim->clock)) {
 382                 dev_err(&pdev->dev, "failed to get dsim clock source\n");
 383                 return -ENODEV;
 384         }
 385
 386         clk_enable(dsim->clock);
 387
 388         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 389
 390         dsim->reg_base = devm_ioremap_resource(&pdev->dev, res);
 391         if (IS_ERR(dsim->reg_base)) {
 392                 ret = PTR_ERR(dsim->reg_base);
 393                 goto error;
 394         }
 395
 396         mutex_init(&dsim->lock);
 397
 398         /* bind lcd ddi matched with panel name. */
 399         dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
 400         if (!dsim_ddi) {
 401                 dev_err(&pdev->dev, "mipi_dsim_ddi object not found.\n");
 402                 ret = -EINVAL;
 403                 goto error;
 404         }
 405
 406         dsim->irq = platform_get_irq(pdev, 0);
 407         if (IS_ERR_VALUE(dsim->irq)) {
 408                 dev_err(&pdev->dev, "failed to request dsim irq resource\n");
 409                 ret = -EINVAL;
 410                 goto error;
 411         }
 412
 413         init_completion(&dsim_wr_comp);
 414         init_completion(&dsim_rd_comp);
 415         platform_set_drvdata(pdev, dsim);
 416
 417         ret = devm_request_irq(&pdev->dev, dsim->irq,
 418                         exynos_mipi_dsi_interrupt_handler,
 419                         IRQF_SHARED, dev_name(&pdev->dev), dsim);
 420         if (ret != 0) {
 421                 dev_err(&pdev->dev, "failed to request dsim irq\n");
 422                 ret = -EINVAL;
 423                 goto error;
 424         }
 425
 426         /* enable interrupts */
 427         exynos_mipi_dsi_init_interrupt(dsim);
 428
 429         /* initialize mipi-dsi client(lcd panel). */
 430         if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->probe)
 431                 dsim_ddi->dsim_lcd_drv->probe(dsim_ddi->dsim_lcd_dev);
 432
 433         /* in case mipi-dsi has been enabled by bootloader */
 434         if (dsim_pd->enabled) {
 435                 exynos_mipi_regulator_enable(dsim);
 436                 goto done;
 437         }
 438
 439         /* lcd panel power on. */
 440         if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->power_on)
 441                 dsim_ddi->dsim_lcd_drv->power_on(dsim_ddi->dsim_lcd_dev, 1);
 442
 443         exynos_mipi_regulator_enable(dsim);
 444
 445         /* enable MIPI-DSI PHY. */
 446         phy_power_on(dsim->phy);
 447
 448         exynos_mipi_update_cfg(dsim);
 449
 450         /* set lcd panel sequence commands. */
 451         if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->set_sequence)
 452                 dsim_ddi->dsim_lcd_drv->set_sequence(dsim_ddi->dsim_lcd_dev);
 453
 454         dsim->suspended = false;
 455
 456 done:
 457         platform_set_drvdata(pdev, dsim);
 458
 459         dev_dbg(&pdev->dev, "%s() completed successfully (%s mode)\n", __func__,
 460                 dsim_config->e_interface == DSIM_COMMAND ? "CPU" : "RGB");
 461
 462         return 0;
 463
 464 error:
 465         clk_disable(dsim->clock);
 466         return ret;
 467 }
 468
 469 static int exynos_mipi_dsi_remove(struct platform_device *pdev)
 470 {
 471         struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
 472         struct mipi_dsim_ddi *dsim_ddi, *next;
 473         struct mipi_dsim_lcd_driver *dsim_lcd_drv;
 474
 475         clk_disable(dsim->clock);
 476
 477         list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
 478                 if (dsim_ddi) {
 479                         if (dsim->id != dsim_ddi->bus_id)
 480                                 continue;
 481
 482                         dsim_lcd_drv = dsim_ddi->dsim_lcd_drv;
 483
 484                         if (dsim_lcd_drv->remove)
 485                                 dsim_lcd_drv->remove(dsim_ddi->dsim_lcd_dev);
 486
 487                         kfree(dsim_ddi);
 488                 }
 489         }
 490
 491         return 0;
 492 }
 493
 494 #ifdef CONFIG_PM_SLEEP
 495 static int exynos_mipi_dsi_suspend(struct device *dev)
 496 {
 497         struct platform_device *pdev = to_platform_device(dev);
 498         struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
 499         struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
 500         struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
 501
 502         disable_irq(dsim->irq);
 503
 504         if (dsim->suspended)
 505                 return 0;
 506
 507         if (client_drv && client_drv->suspend)
 508                 client_drv->suspend(client_dev);
 509
 510         /* disable MIPI-DSI PHY. */
 511         phy_power_off(dsim->phy);
 512
 513         clk_disable(dsim->clock);
 514
 515         exynos_mipi_regulator_disable(dsim);
 516
 517         dsim->suspended = true;
 518
 519         return 0;
 520 }
 521
 522 static int exynos_mipi_dsi_resume(struct device *dev)
 523 {
 524         struct platform_device *pdev = to_platform_device(dev);
 525         struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
 526         struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
 527         struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
 528
 529         enable_irq(dsim->irq);
 530
 531         if (!dsim->suspended)
 532                 return 0;
 533
 534         /* lcd panel power on. */
 535         if (client_drv && client_drv->power_on)
 536                 client_drv->power_on(client_dev, 1);
 537
 538         exynos_mipi_regulator_enable(dsim);
 539
 540         /* enable MIPI-DSI PHY. */
 541         phy_power_on(dsim->phy);
 542
 543         clk_enable(dsim->clock);
 544
 545         exynos_mipi_update_cfg(dsim);
 546
 547         /* set lcd panel sequence commands. */
 548         if (client_drv && client_drv->set_sequence)
 549                 client_drv->set_sequence(client_dev);
 550
 551         dsim->suspended = false;
 552
 553         return 0;
 554 }
 555 #endif
 556
 557 static const struct dev_pm_ops exynos_mipi_dsi_pm_ops = {
 558         SET_SYSTEM_SLEEP_PM_OPS(exynos_mipi_dsi_suspend, exynos_mipi_dsi_resume)
 559 };
 560
 561 static struct platform_driver exynos_mipi_dsi_driver = {
 562         .probe = exynos_mipi_dsi_probe,
 563         .remove = exynos_mipi_dsi_remove,
 564         .driver = {
 565                    .name = "exynos-mipi-dsim",
 566                    .owner = THIS_MODULE,
 567                    .pm = &exynos_mipi_dsi_pm_ops,
 568         },
 569 };
 570
 571 module_platform_driver(exynos_mipi_dsi_driver);
 572
 573 MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
 574 MODULE_DESCRIPTION("Samusung SoC MIPI-DSI driver");
 575 MODULE_LICENSE("GPL");