1 /*
2  * Copyright (C) 2012 Samsung Electronics
3  *
4  * Author: InKi Dae <inki.dae@samsung.com>
5  * Author: Donghwa Lee <dh09.lee@samsung.com>
6  *
7  * SPDX-License-Identifier:	GPL-2.0+
8  */
9 
10 #include <common.h>
11 #include <malloc.h>
12 #include <fdtdec.h>
13 #include <libfdt.h>
14 #include <linux/compat.h>
15 #include <linux/err.h>
16 #include <asm/arch/dsim.h>
17 #include <asm/arch/mipi_dsim.h>
18 #include <asm/arch/power.h>
19 #include <asm/arch/cpu.h>
20 #include <asm/arch/clk.h>
21 
22 #include "exynos_mipi_dsi_lowlevel.h"
23 #include "exynos_mipi_dsi_common.h"
24 
25 #define master_to_driver(a)	(a->dsim_lcd_drv)
26 #define master_to_device(a)	(a->dsim_lcd_dev)
27 
28 DECLARE_GLOBAL_DATA_PTR;
29 
30 struct mipi_dsim_ddi {
31 	int				bus_id;
32 	struct list_head		list;
33 	struct mipi_dsim_lcd_device	*dsim_lcd_dev;
34 	struct mipi_dsim_lcd_driver	*dsim_lcd_drv;
35 };
36 
37 static LIST_HEAD(dsim_ddi_list);
38 static LIST_HEAD(dsim_lcd_dev_list);
39 
40 int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
41 {
42 	struct mipi_dsim_ddi *dsim_ddi;
43 
44 	if (!lcd_dev) {
45 		debug("mipi_dsim_lcd_device is NULL.\n");
46 		return -EFAULT;
47 	}
48 
49 	if (!lcd_dev->name) {
50 		debug("dsim_lcd_device name is NULL.\n");
51 		return -EFAULT;
52 	}
53 
54 	dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
55 	if (!dsim_ddi) {
56 		debug("failed to allocate dsim_ddi object.\n");
57 		return -EFAULT;
58 	}
59 
60 	dsim_ddi->dsim_lcd_dev = lcd_dev;
61 
62 	list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
63 
64 	return 0;
65 }
66 
67 struct mipi_dsim_ddi
68 	*exynos_mipi_dsi_find_lcd_device(struct mipi_dsim_lcd_driver *lcd_drv)
69 {
70 	struct mipi_dsim_ddi *dsim_ddi;
71 	struct mipi_dsim_lcd_device *lcd_dev;
72 
73 	list_for_each_entry(dsim_ddi, &dsim_ddi_list, list) {
74 		lcd_dev = dsim_ddi->dsim_lcd_dev;
75 		if (!lcd_dev)
76 			continue;
77 
78 		if (lcd_drv->id >= 0) {
79 			if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0 &&
80 					lcd_drv->id == lcd_dev->id) {
81 				/**
82 				 * bus_id would be used to identify
83 				 * connected bus.
84 				 */
85 				dsim_ddi->bus_id = lcd_dev->bus_id;
86 
87 				return dsim_ddi;
88 			}
89 		} else {
90 			if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
91 				/**
92 				 * bus_id would be used to identify
93 				 * connected bus.
94 				 */
95 				dsim_ddi->bus_id = lcd_dev->bus_id;
96 
97 				return dsim_ddi;
98 			}
99 		}
100 
101 		kfree(dsim_ddi);
102 		list_del(&dsim_ddi_list);
103 	}
104 
105 	return NULL;
106 }
107 
108 int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
109 {
110 	struct mipi_dsim_ddi *dsim_ddi;
111 
112 	if (!lcd_drv) {
113 		debug("mipi_dsim_lcd_driver is NULL.\n");
114 		return -EFAULT;
115 	}
116 
117 	if (!lcd_drv->name) {
118 		debug("dsim_lcd_driver name is NULL.\n");
119 		return -EFAULT;
120 	}
121 
122 	dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
123 	if (!dsim_ddi) {
124 		debug("mipi_dsim_ddi object not found.\n");
125 		return -EFAULT;
126 	}
127 
128 	dsim_ddi->dsim_lcd_drv = lcd_drv;
129 
130 	debug("registered panel driver(%s) to mipi-dsi driver.\n",
131 		lcd_drv->name);
132 
133 	return 0;
134 
135 }
136 
137 struct mipi_dsim_ddi
138 	*exynos_mipi_dsi_bind_lcd_ddi(struct mipi_dsim_device *dsim,
139 			const char *name)
140 {
141 	struct mipi_dsim_ddi *dsim_ddi;
142 	struct mipi_dsim_lcd_driver *lcd_drv;
143 	struct mipi_dsim_lcd_device *lcd_dev;
144 
145 	list_for_each_entry(dsim_ddi, &dsim_ddi_list, list) {
146 		lcd_drv = dsim_ddi->dsim_lcd_drv;
147 		lcd_dev = dsim_ddi->dsim_lcd_dev;
148 		if (!lcd_drv || !lcd_dev)
149 			continue;
150 
151 		debug("lcd_drv->id = %d, lcd_dev->id = %d\n",
152 					lcd_drv->id, lcd_dev->id);
153 
154 		if ((strcmp(lcd_drv->name, name) == 0)) {
155 			lcd_dev->master = dsim;
156 
157 			dsim->dsim_lcd_dev = lcd_dev;
158 			dsim->dsim_lcd_drv = lcd_drv;
159 
160 			return dsim_ddi;
161 		}
162 	}
163 
164 	return NULL;
165 }
166 
167 /* define MIPI-DSI Master operations. */
168 static struct mipi_dsim_master_ops master_ops = {
169 	.cmd_write			= exynos_mipi_dsi_wr_data,
170 	.get_dsim_frame_done		= exynos_mipi_dsi_get_frame_done_status,
171 	.clear_dsim_frame_done		= exynos_mipi_dsi_clear_frame_done,
172 };
173 
174 int exynos_mipi_dsi_init(struct exynos_platform_mipi_dsim *dsim_pd)
175 {
176 	struct mipi_dsim_device *dsim;
177 	struct mipi_dsim_config *dsim_config;
178 	struct mipi_dsim_ddi *dsim_ddi;
179 
180 	dsim = kzalloc(sizeof(struct mipi_dsim_device), GFP_KERNEL);
181 	if (!dsim) {
182 		debug("failed to allocate dsim object.\n");
183 		return -EFAULT;
184 	}
185 
186 	/* get mipi_dsim_config. */
187 	dsim_config = dsim_pd->dsim_config;
188 	if (dsim_config == NULL) {
189 		debug("failed to get dsim config data.\n");
190 		return -EFAULT;
191 	}
192 
193 	dsim->pd = dsim_pd;
194 	dsim->dsim_config = dsim_config;
195 	dsim->master_ops = &master_ops;
196 
197 	/* bind lcd ddi matched with panel name. */
198 	dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
199 	if (!dsim_ddi) {
200 		debug("mipi_dsim_ddi object not found.\n");
201 		return -ENOSYS;
202 	}
203 	if (dsim_pd->lcd_power)
204 		dsim_pd->lcd_power();
205 
206 	if (dsim_pd->mipi_power)
207 		dsim_pd->mipi_power();
208 
209 	/* phy_enable(unsigned int dev_index, unsigned int enable) */
210 	if (dsim_pd->phy_enable)
211 		dsim_pd->phy_enable(0, 1);
212 
213 	set_mipi_clk();
214 
215 	exynos_mipi_dsi_init_dsim(dsim);
216 	exynos_mipi_dsi_init_link(dsim);
217 	exynos_mipi_dsi_set_hs_enable(dsim);
218 
219 	/* set display timing. */
220 	exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);
221 
222 	/* initialize mipi-dsi client(lcd panel). */
223 	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->mipi_panel_init) {
224 		dsim_ddi->dsim_lcd_drv->mipi_panel_init(dsim);
225 		dsim_ddi->dsim_lcd_drv->mipi_display_on(dsim);
226 	}
227 
228 	debug("mipi-dsi driver(%s mode) has been probed.\n",
229 		(dsim_config->e_interface == DSIM_COMMAND) ?
230 			"CPU" : "RGB");
231 
232 	return 0;
233 }
234 
235 int exynos_dsim_config_parse_dt(const void *blob, struct mipi_dsim_config *dt,
236 				struct mipi_dsim_lcd_device *lcd_dt)
237 {
238 	int node;
239 
240 	node = fdtdec_next_compatible(blob, 0, COMPAT_SAMSUNG_EXYNOS_MIPI_DSI);
241 	if (node <= 0) {
242 		printf("exynos_mipi_dsi: Can't get device node for mipi dsi\n");
243 		return -ENODEV;
244 	}
245 
246 	dt->e_interface = fdtdec_get_int(blob, node,
247 				"samsung,dsim-config-e-interface", 0);
248 
249 	dt->e_virtual_ch = fdtdec_get_int(blob, node,
250 				"samsung,dsim-config-e-virtual-ch", 0);
251 
252 	dt->e_pixel_format = fdtdec_get_int(blob, node,
253 				"samsung,dsim-config-e-pixel-format", 0);
254 
255 	dt->e_burst_mode = fdtdec_get_int(blob, node,
256 				"samsung,dsim-config-e-burst-mode", 0);
257 
258 	dt->e_no_data_lane = fdtdec_get_int(blob, node,
259 				"samsung,dsim-config-e-no-data-lane", 0);
260 
261 	dt->e_byte_clk = fdtdec_get_int(blob, node,
262 				"samsung,dsim-config-e-byte-clk", 0);
263 
264 	dt->hfp = fdtdec_get_int(blob, node,
265 				"samsung,dsim-config-hfp", 0);
266 
267 	dt->p = fdtdec_get_int(blob, node,
268 					  "samsung,dsim-config-p", 0);
269 	dt->m = fdtdec_get_int(blob, node,
270 					  "samsung,dsim-config-m", 0);
271 	dt->s = fdtdec_get_int(blob, node,
272 					  "samsung,dsim-config-s", 0);
273 
274 	dt->pll_stable_time = fdtdec_get_int(blob, node,
275 				"samsung,dsim-config-pll-stable-time", 0);
276 
277 	dt->esc_clk = fdtdec_get_int(blob, node,
278 				"samsung,dsim-config-esc-clk", 0);
279 
280 	dt->stop_holding_cnt = fdtdec_get_int(blob, node,
281 				"samsung,dsim-config-stop-holding-cnt", 0);
282 
283 	dt->bta_timeout = fdtdec_get_int(blob, node,
284 				"samsung,dsim-config-bta-timeout", 0);
285 
286 	dt->rx_timeout = fdtdec_get_int(blob, node,
287 				"samsung,dsim-config-rx-timeout", 0);
288 
289 	lcd_dt->name = fdtdec_get_config_string(blob,
290 				"samsung,dsim-device-name");
291 
292 	lcd_dt->id = fdtdec_get_int(blob, node,
293 				"samsung,dsim-device-id", 0);
294 
295 	lcd_dt->bus_id = fdtdec_get_int(blob, node,
296 				"samsung,dsim-device-bus_id", 0);
297 
298 	lcd_dt->reverse_panel = fdtdec_get_int(blob, node,
299 				"samsung,dsim-device-reverse-panel", 0);
300 
301 	return 0;
302 }
303 
304 void exynos_init_dsim_platform_data(vidinfo_t *vid)
305 {
306 	static struct mipi_dsim_config dsim_config_dt;
307 	static struct exynos_platform_mipi_dsim dsim_platform_data_dt;
308 	static struct mipi_dsim_lcd_device mipi_lcd_device_dt;
309 
310 	if (exynos_dsim_config_parse_dt(gd->fdt_blob, &dsim_config_dt,
311 					&mipi_lcd_device_dt))
312 		debug("Can't get proper dsim config.\n");
313 
314 	strcpy(dsim_platform_data_dt.lcd_panel_name, mipi_lcd_device_dt.name);
315 	dsim_platform_data_dt.dsim_config = &dsim_config_dt;
316 	dsim_platform_data_dt.mipi_power = mipi_power;
317 	dsim_platform_data_dt.phy_enable = set_mipi_phy_ctrl;
318 	dsim_platform_data_dt.lcd_panel_info = (void *)vid;
319 
320 	mipi_lcd_device_dt.platform_data = (void *)&dsim_platform_data_dt;
321 	exynos_mipi_dsi_register_lcd_device(&mipi_lcd_device_dt);
322 
323 	vid->dsim_platform_data_dt = &dsim_platform_data_dt;
324 }
325