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