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
= kzalloc(sizeof(struct mipi_dsim_device
), GFP_KERNEL
);
343 dev_err(&pdev
->dev
, "failed to allocate dsim object.\n");
347 dsim
->pd
= to_dsim_plat(pdev
);
348 dsim
->dev
= &pdev
->dev
;
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");
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");
364 dsim
->dsim_config
= dsim_config
;
365 dsim
->master_ops
= &master_ops
;
367 mutex_init(&dsim
->lock
);
369 ret
= regulator_bulk_get(&pdev
->dev
, ARRAY_SIZE(supplies
), supplies
);
371 dev_err(&pdev
->dev
, "Failed to get regulators: %d\n", ret
);
375 dsim
->clock
= clk_get(&pdev
->dev
, "dsim0");
376 if (IS_ERR(dsim
->clock
)) {
377 dev_err(&pdev
->dev
, "failed to get dsim clock source\n");
382 clk_enable(dsim
->clock
);
384 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
386 dev_err(&pdev
->dev
, "failed to get io memory region\n");
388 goto err_platform_get
;
391 dsim
->res
= request_mem_region(res
->start
, resource_size(res
),
392 dev_name(&pdev
->dev
));
394 dev_err(&pdev
->dev
, "failed to request io memory region\n");
399 dsim
->reg_base
= ioremap(res
->start
, resource_size(res
));
400 if (!dsim
->reg_base
) {
401 dev_err(&pdev
->dev
, "failed to remap io region\n");
406 mutex_init(&dsim
->lock
);
408 /* bind lcd ddi matched with panel name. */
409 dsim_ddi
= exynos_mipi_dsi_bind_lcd_ddi(dsim
, dsim_pd
->lcd_panel_name
);
411 dev_err(&pdev
->dev
, "mipi_dsim_ddi object not found.\n");
416 dsim
->irq
= platform_get_irq(pdev
, 0);
418 dev_err(&pdev
->dev
, "failed to request dsim irq resource\n");
420 goto err_platform_get_irq
;
423 init_completion(&dsim_wr_comp
);
424 init_completion(&dsim_rd_comp
);
425 platform_set_drvdata(pdev
, dsim
);
427 ret
= request_irq(dsim
->irq
, exynos_mipi_dsi_interrupt_handler
,
428 IRQF_SHARED
, dev_name(&pdev
->dev
), dsim
);
430 dev_err(&pdev
->dev
, "failed to request dsim irq\n");
435 /* enable interrupts */
436 exynos_mipi_dsi_init_interrupt(dsim
);
438 /* initialize mipi-dsi client(lcd panel). */
439 if (dsim_ddi
->dsim_lcd_drv
&& dsim_ddi
->dsim_lcd_drv
->probe
)
440 dsim_ddi
->dsim_lcd_drv
->probe(dsim_ddi
->dsim_lcd_dev
);
442 /* in case mipi-dsi has been enabled by bootloader */
443 if (dsim_pd
->enabled
) {
444 exynos_mipi_regulator_enable(dsim
);
448 /* lcd panel power on. */
449 if (dsim_ddi
->dsim_lcd_drv
&& dsim_ddi
->dsim_lcd_drv
->power_on
)
450 dsim_ddi
->dsim_lcd_drv
->power_on(dsim_ddi
->dsim_lcd_dev
, 1);
452 exynos_mipi_regulator_enable(dsim
);
454 /* enable MIPI-DSI PHY. */
455 if (dsim
->pd
->phy_enable
)
456 dsim
->pd
->phy_enable(pdev
, true);
458 exynos_mipi_update_cfg(dsim
);
460 /* set lcd panel sequence commands. */
461 if (dsim_ddi
->dsim_lcd_drv
&& dsim_ddi
->dsim_lcd_drv
->set_sequence
)
462 dsim_ddi
->dsim_lcd_drv
->set_sequence(dsim_ddi
->dsim_lcd_dev
);
464 dsim
->suspended
= false;
467 platform_set_drvdata(pdev
, dsim
);
469 dev_dbg(&pdev
->dev
, "%s() completed successfully (%s mode)\n", __func__
,
470 dsim_config
->e_interface
== DSIM_COMMAND
? "CPU" : "RGB");
475 iounmap(dsim
->reg_base
);
478 release_mem_region(dsim
->res
->start
, resource_size(dsim
->res
));
481 release_resource(dsim
->res
);
484 clk_disable(dsim
->clock
);
485 clk_put(dsim
->clock
);
489 err_platform_get_irq
:
493 static int exynos_mipi_dsi_remove(struct platform_device
*pdev
)
495 struct mipi_dsim_device
*dsim
= platform_get_drvdata(pdev
);
496 struct mipi_dsim_ddi
*dsim_ddi
, *next
;
497 struct mipi_dsim_lcd_driver
*dsim_lcd_drv
;
499 iounmap(dsim
->reg_base
);
501 clk_disable(dsim
->clock
);
502 clk_put(dsim
->clock
);
504 release_resource(dsim
->res
);
505 release_mem_region(dsim
->res
->start
, resource_size(dsim
->res
));
507 list_for_each_entry_safe(dsim_ddi
, next
, &dsim_ddi_list
, list
) {
509 if (dsim
->id
!= dsim_ddi
->bus_id
)
512 dsim_lcd_drv
= dsim_ddi
->dsim_lcd_drv
;
514 if (dsim_lcd_drv
->remove
)
515 dsim_lcd_drv
->remove(dsim_ddi
->dsim_lcd_dev
);
521 regulator_bulk_free(ARRAY_SIZE(supplies
), supplies
);
527 #ifdef CONFIG_PM_SLEEP
528 static int exynos_mipi_dsi_suspend(struct device
*dev
)
530 struct platform_device
*pdev
= to_platform_device(dev
);
531 struct mipi_dsim_device
*dsim
= platform_get_drvdata(pdev
);
532 struct mipi_dsim_lcd_driver
*client_drv
= dsim
->dsim_lcd_drv
;
533 struct mipi_dsim_lcd_device
*client_dev
= dsim
->dsim_lcd_dev
;
535 disable_irq(dsim
->irq
);
540 if (client_drv
&& client_drv
->suspend
)
541 client_drv
->suspend(client_dev
);
543 /* enable MIPI-DSI PHY. */
544 if (dsim
->pd
->phy_enable
)
545 dsim
->pd
->phy_enable(pdev
, false);
547 clk_disable(dsim
->clock
);
549 exynos_mipi_regulator_disable(dsim
);
551 dsim
->suspended
= true;
556 static int exynos_mipi_dsi_resume(struct device
*dev
)
558 struct platform_device
*pdev
= to_platform_device(dev
);
559 struct mipi_dsim_device
*dsim
= platform_get_drvdata(pdev
);
560 struct mipi_dsim_lcd_driver
*client_drv
= dsim
->dsim_lcd_drv
;
561 struct mipi_dsim_lcd_device
*client_dev
= dsim
->dsim_lcd_dev
;
563 enable_irq(dsim
->irq
);
565 if (!dsim
->suspended
)
568 /* lcd panel power on. */
569 if (client_drv
&& client_drv
->power_on
)
570 client_drv
->power_on(client_dev
, 1);
572 exynos_mipi_regulator_enable(dsim
);
574 /* enable MIPI-DSI PHY. */
575 if (dsim
->pd
->phy_enable
)
576 dsim
->pd
->phy_enable(pdev
, true);
578 clk_enable(dsim
->clock
);
580 exynos_mipi_update_cfg(dsim
);
582 /* set lcd panel sequence commands. */
583 if (client_drv
&& client_drv
->set_sequence
)
584 client_drv
->set_sequence(client_dev
);
586 dsim
->suspended
= false;
592 static const struct dev_pm_ops exynos_mipi_dsi_pm_ops
= {
593 SET_SYSTEM_SLEEP_PM_OPS(exynos_mipi_dsi_suspend
, exynos_mipi_dsi_resume
)
596 static struct platform_driver exynos_mipi_dsi_driver
= {
597 .probe
= exynos_mipi_dsi_probe
,
598 .remove
= exynos_mipi_dsi_remove
,
600 .name
= "exynos-mipi-dsim",
601 .owner
= THIS_MODULE
,
602 .pm
= &exynos_mipi_dsi_pm_ops
,
606 module_platform_driver(exynos_mipi_dsi_driver
);
608 MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
609 MODULE_DESCRIPTION("Samusung SoC MIPI-DSI driver");
610 MODULE_LICENSE("GPL");