1 /* linux/drivers/video/exynos/exynos_mipi_dsi.c
3 * Samsung SoC MIPI-DSIM driver.
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd
7 * InKi Dae, <inki.dae@samsung.com>
8 * Donghwa Lee, <dh09.lee@samsung.com>
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.
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>
24 #include <linux/ctype.h>
25 #include <linux/platform_device.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>
36 #include <video/exynos_mipi_dsim.h>
40 #include "exynos_mipi_dsi_common.h"
41 #include "exynos_mipi_dsi_lowlevel.h"
43 struct mipi_dsim_ddi {
45 struct list_head list;
46 struct mipi_dsim_lcd_device *dsim_lcd_dev;
47 struct mipi_dsim_lcd_driver *dsim_lcd_drv;
50 static LIST_HEAD(dsim_ddi_list);
52 static DEFINE_MUTEX(mipi_dsim_lock);
54 static struct mipi_dsim_platform_data *to_dsim_plat(struct platform_device
57 return pdev->dev.platform_data;
60 static struct regulator_bulk_data supplies[] = {
61 { .supply = "vdd11", },
62 { .supply = "vdd18", },
65 static int exynos_mipi_regulator_enable(struct mipi_dsim_device *dsim)
69 mutex_lock(&dsim->lock);
70 ret = regulator_bulk_enable(ARRAY_SIZE(supplies), supplies);
71 mutex_unlock(&dsim->lock);
76 static int exynos_mipi_regulator_disable(struct mipi_dsim_device *dsim)
80 mutex_lock(&dsim->lock);
81 ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
82 mutex_unlock(&dsim->lock);
87 /* update all register settings to MIPI DSI controller. */
88 static void exynos_mipi_update_cfg(struct mipi_dsim_device *dsim)
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
95 exynos_mipi_dsi_stand_by(dsim, 0);
97 exynos_mipi_dsi_init_dsim(dsim);
98 exynos_mipi_dsi_init_link(dsim);
100 exynos_mipi_dsi_set_hs_enable(dsim);
102 /* set display timing. */
103 exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);
105 exynos_mipi_dsi_init_interrupt(dsim);
108 * data from Display controller(FIMD) is transferred in video mode
109 * but in case of command mode, all settings are updated to registers.
111 exynos_mipi_dsi_stand_by(dsim, 1);
114 static int exynos_mipi_dsi_early_blank_mode(struct mipi_dsim_device *dsim,
117 struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
118 struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
121 case FB_BLANK_POWERDOWN:
125 if (client_drv && client_drv->suspend)
126 client_drv->suspend(client_dev);
128 clk_disable(dsim->clock);
130 exynos_mipi_regulator_disable(dsim);
132 dsim->suspended = true;
142 static int exynos_mipi_dsi_blank_mode(struct mipi_dsim_device *dsim, int power)
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;
149 case FB_BLANK_UNBLANK:
150 if (!dsim->suspended)
153 /* lcd panel power on. */
154 if (client_drv && client_drv->power_on)
155 client_drv->power_on(client_dev, 1);
157 exynos_mipi_regulator_enable(dsim);
159 /* enable MIPI-DSI PHY. */
160 if (dsim->pd->phy_enable)
161 dsim->pd->phy_enable(pdev, true);
163 clk_enable(dsim->clock);
165 exynos_mipi_update_cfg(dsim);
167 /* set lcd panel sequence commands. */
168 if (client_drv && client_drv->set_sequence)
169 client_drv->set_sequence(client_dev);
171 dsim->suspended = false;
174 case FB_BLANK_NORMAL:
184 int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
186 struct mipi_dsim_ddi *dsim_ddi;
188 if (!lcd_dev->name) {
189 pr_err("dsim_lcd_device name is NULL.\n");
193 dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
195 pr_err("failed to allocate dsim_ddi object.\n");
199 dsim_ddi->dsim_lcd_dev = lcd_dev;
201 mutex_lock(&mipi_dsim_lock);
202 list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
203 mutex_unlock(&mipi_dsim_lock);
208 static struct mipi_dsim_ddi *exynos_mipi_dsi_find_lcd_device(
209 struct mipi_dsim_lcd_driver *lcd_drv)
211 struct mipi_dsim_ddi *dsim_ddi, *next;
212 struct mipi_dsim_lcd_device *lcd_dev;
214 mutex_lock(&mipi_dsim_lock);
216 list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
220 lcd_dev = dsim_ddi->dsim_lcd_dev;
224 if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
226 * bus_id would be used to identify
229 dsim_ddi->bus_id = lcd_dev->bus_id;
230 mutex_unlock(&mipi_dsim_lock);
235 list_del(&dsim_ddi->list);
240 mutex_unlock(&mipi_dsim_lock);
245 int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
247 struct mipi_dsim_ddi *dsim_ddi;
249 if (!lcd_drv->name) {
250 pr_err("dsim_lcd_driver name is NULL.\n");
254 dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
256 pr_err("mipi_dsim_ddi object not found.\n");
260 dsim_ddi->dsim_lcd_drv = lcd_drv;
262 pr_info("registered panel driver(%s) to mipi-dsi driver.\n",
269 static struct mipi_dsim_ddi *exynos_mipi_dsi_bind_lcd_ddi(
270 struct mipi_dsim_device *dsim,
273 struct mipi_dsim_ddi *dsim_ddi, *next;
274 struct mipi_dsim_lcd_driver *lcd_drv;
275 struct mipi_dsim_lcd_device *lcd_dev;
278 mutex_lock(&dsim->lock);
280 list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
281 lcd_drv = dsim_ddi->dsim_lcd_drv;
282 lcd_dev = dsim_ddi->dsim_lcd_dev;
283 if (!lcd_drv || !lcd_dev ||
284 (dsim->id != dsim_ddi->bus_id))
287 dev_dbg(dsim->dev, "lcd_drv->id = %d, lcd_dev->id = %d\n",
288 lcd_drv->id, lcd_dev->id);
289 dev_dbg(dsim->dev, "lcd_dev->bus_id = %d, dsim->id = %d\n",
290 lcd_dev->bus_id, dsim->id);
292 if ((strcmp(lcd_drv->name, name) == 0)) {
293 lcd_dev->master = dsim;
295 lcd_dev->dev.parent = dsim->dev;
296 dev_set_name(&lcd_dev->dev, "%s", lcd_drv->name);
298 ret = device_register(&lcd_dev->dev);
301 "can't register %s, status %d\n",
302 dev_name(&lcd_dev->dev), ret);
303 mutex_unlock(&dsim->lock);
308 dsim->dsim_lcd_dev = lcd_dev;
309 dsim->dsim_lcd_drv = lcd_drv;
311 mutex_unlock(&dsim->lock);
317 mutex_unlock(&dsim->lock);
322 /* define MIPI-DSI Master operations. */
323 static struct mipi_dsim_master_ops master_ops = {
324 .cmd_read = exynos_mipi_dsi_rd_data,
325 .cmd_write = exynos_mipi_dsi_wr_data,
326 .get_dsim_frame_done = exynos_mipi_dsi_get_frame_done_status,
327 .clear_dsim_frame_done = exynos_mipi_dsi_clear_frame_done,
328 .set_early_blank_mode = exynos_mipi_dsi_early_blank_mode,
329 .set_blank_mode = exynos_mipi_dsi_blank_mode,
332 static int exynos_mipi_dsi_probe(struct platform_device *pdev)
334 struct resource *res;
335 struct mipi_dsim_device *dsim;
336 struct mipi_dsim_config *dsim_config;
337 struct mipi_dsim_platform_data *dsim_pd;
338 struct mipi_dsim_ddi *dsim_ddi;
341 dsim = devm_kzalloc(&pdev->dev, sizeof(struct mipi_dsim_device),
344 dev_err(&pdev->dev, "failed to allocate dsim object.\n");
348 dsim->pd = to_dsim_plat(pdev);
349 dsim->dev = &pdev->dev;
352 /* get mipi_dsim_platform_data. */
353 dsim_pd = (struct mipi_dsim_platform_data *)dsim->pd;
354 if (dsim_pd == NULL) {
355 dev_err(&pdev->dev, "failed to get platform data for dsim.\n");
358 /* get mipi_dsim_config. */
359 dsim_config = dsim_pd->dsim_config;
360 if (dsim_config == NULL) {
361 dev_err(&pdev->dev, "failed to get dsim config data.\n");
365 dsim->dsim_config = dsim_config;
366 dsim->master_ops = &master_ops;
368 mutex_init(&dsim->lock);
370 ret = devm_regulator_bulk_get(&pdev->dev, ARRAY_SIZE(supplies),
373 dev_err(&pdev->dev, "Failed to get regulators: %d\n", ret);
377 dsim->clock = devm_clk_get(&pdev->dev, "dsim0");
378 if (IS_ERR(dsim->clock)) {
379 dev_err(&pdev->dev, "failed to get dsim clock source\n");
383 clk_enable(dsim->clock);
385 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
387 dsim->reg_base = devm_request_and_ioremap(&pdev->dev, res);
388 if (!dsim->reg_base) {
389 dev_err(&pdev->dev, "failed to remap io region\n");
394 mutex_init(&dsim->lock);
396 /* bind lcd ddi matched with panel name. */
397 dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
399 dev_err(&pdev->dev, "mipi_dsim_ddi object not found.\n");
404 dsim->irq = platform_get_irq(pdev, 0);
405 if (IS_ERR_VALUE(dsim->irq)) {
406 dev_err(&pdev->dev, "failed to request dsim irq resource\n");
411 init_completion(&dsim_wr_comp);
412 init_completion(&dsim_rd_comp);
413 platform_set_drvdata(pdev, dsim);
415 ret = devm_request_irq(&pdev->dev, dsim->irq,
416 exynos_mipi_dsi_interrupt_handler,
417 IRQF_SHARED, dev_name(&pdev->dev), dsim);
419 dev_err(&pdev->dev, "failed to request dsim irq\n");
424 /* enable interrupts */
425 exynos_mipi_dsi_init_interrupt(dsim);
427 /* initialize mipi-dsi client(lcd panel). */
428 if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->probe)
429 dsim_ddi->dsim_lcd_drv->probe(dsim_ddi->dsim_lcd_dev);
431 /* in case mipi-dsi has been enabled by bootloader */
432 if (dsim_pd->enabled) {
433 exynos_mipi_regulator_enable(dsim);
437 /* lcd panel power on. */
438 if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->power_on)
439 dsim_ddi->dsim_lcd_drv->power_on(dsim_ddi->dsim_lcd_dev, 1);
441 exynos_mipi_regulator_enable(dsim);
443 /* enable MIPI-DSI PHY. */
444 if (dsim->pd->phy_enable)
445 dsim->pd->phy_enable(pdev, true);
447 exynos_mipi_update_cfg(dsim);
449 /* set lcd panel sequence commands. */
450 if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->set_sequence)
451 dsim_ddi->dsim_lcd_drv->set_sequence(dsim_ddi->dsim_lcd_dev);
453 dsim->suspended = false;
456 platform_set_drvdata(pdev, dsim);
458 dev_dbg(&pdev->dev, "%s() completed successfully (%s mode)\n", __func__,
459 dsim_config->e_interface == DSIM_COMMAND ? "CPU" : "RGB");
464 clk_disable(dsim->clock);
468 static int exynos_mipi_dsi_remove(struct platform_device *pdev)
470 struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
471 struct mipi_dsim_ddi *dsim_ddi, *next;
472 struct mipi_dsim_lcd_driver *dsim_lcd_drv;
474 clk_disable(dsim->clock);
476 list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
478 if (dsim->id != dsim_ddi->bus_id)
481 dsim_lcd_drv = dsim_ddi->dsim_lcd_drv;
483 if (dsim_lcd_drv->remove)
484 dsim_lcd_drv->remove(dsim_ddi->dsim_lcd_dev);
493 #ifdef CONFIG_PM_SLEEP
494 static int exynos_mipi_dsi_suspend(struct device *dev)
496 struct platform_device *pdev = to_platform_device(dev);
497 struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
498 struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
499 struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
501 disable_irq(dsim->irq);
506 if (client_drv && client_drv->suspend)
507 client_drv->suspend(client_dev);
509 /* enable MIPI-DSI PHY. */
510 if (dsim->pd->phy_enable)
511 dsim->pd->phy_enable(pdev, false);
513 clk_disable(dsim->clock);
515 exynos_mipi_regulator_disable(dsim);
517 dsim->suspended = true;
522 static int exynos_mipi_dsi_resume(struct device *dev)
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;
529 enable_irq(dsim->irq);
531 if (!dsim->suspended)
534 /* lcd panel power on. */
535 if (client_drv && client_drv->power_on)
536 client_drv->power_on(client_dev, 1);
538 exynos_mipi_regulator_enable(dsim);
540 /* enable MIPI-DSI PHY. */
541 if (dsim->pd->phy_enable)
542 dsim->pd->phy_enable(pdev, true);
544 clk_enable(dsim->clock);
546 exynos_mipi_update_cfg(dsim);
548 /* set lcd panel sequence commands. */
549 if (client_drv && client_drv->set_sequence)
550 client_drv->set_sequence(client_dev);
552 dsim->suspended = false;
558 static const struct dev_pm_ops exynos_mipi_dsi_pm_ops = {
559 SET_SYSTEM_SLEEP_PM_OPS(exynos_mipi_dsi_suspend, exynos_mipi_dsi_resume)
562 static struct platform_driver exynos_mipi_dsi_driver = {
563 .probe = exynos_mipi_dsi_probe,
564 .remove = exynos_mipi_dsi_remove,
566 .name = "exynos-mipi-dsim",
567 .owner = THIS_MODULE,
568 .pm = &exynos_mipi_dsi_pm_ops,
572 module_platform_driver(exynos_mipi_dsi_driver);
574 MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
575 MODULE_DESCRIPTION("Samusung SoC MIPI-DSI driver");
576 MODULE_LICENSE("GPL");