1 /*
2  * linux/drivers/video/omap2/dss/display.c
3  *
4  * Copyright (C) 2009 Nokia Corporation
5  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
6  *
7  * Some code and ideas taken from drivers/video/omap/ driver
8  * by Imre Deak.
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License version 2 as published by
12  * the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
17  * more details.
18  *
19  * You should have received a copy of the GNU General Public License along with
20  * this program.  If not, see <http://www.gnu.org/licenses/>.
21  */
22 
23 #define DSS_SUBSYS_NAME "DISPLAY"
24 
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/jiffies.h>
28 #include <linux/platform_device.h>
29 #include <linux/of.h>
30 
31 #include <video/omapdss.h>
32 #include "dss.h"
33 #include "dss_features.h"
34 
35 void omapdss_default_get_resolution(struct omap_dss_device *dssdev,
36 			u16 *xres, u16 *yres)
37 {
38 	*xres = dssdev->panel.timings.x_res;
39 	*yres = dssdev->panel.timings.y_res;
40 }
41 EXPORT_SYMBOL(omapdss_default_get_resolution);
42 
43 int omapdss_default_get_recommended_bpp(struct omap_dss_device *dssdev)
44 {
45 	switch (dssdev->type) {
46 	case OMAP_DISPLAY_TYPE_DPI:
47 		if (dssdev->phy.dpi.data_lines == 24)
48 			return 24;
49 		else
50 			return 16;
51 
52 	case OMAP_DISPLAY_TYPE_DBI:
53 		if (dssdev->ctrl.pixel_size == 24)
54 			return 24;
55 		else
56 			return 16;
57 	case OMAP_DISPLAY_TYPE_DSI:
58 		if (dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt) > 16)
59 			return 24;
60 		else
61 			return 16;
62 	case OMAP_DISPLAY_TYPE_VENC:
63 	case OMAP_DISPLAY_TYPE_SDI:
64 	case OMAP_DISPLAY_TYPE_HDMI:
65 	case OMAP_DISPLAY_TYPE_DVI:
66 		return 24;
67 	default:
68 		BUG();
69 		return 0;
70 	}
71 }
72 EXPORT_SYMBOL(omapdss_default_get_recommended_bpp);
73 
74 void omapdss_default_get_timings(struct omap_dss_device *dssdev,
75 		struct omap_video_timings *timings)
76 {
77 	*timings = dssdev->panel.timings;
78 }
79 EXPORT_SYMBOL(omapdss_default_get_timings);
80 
81 int dss_suspend_all_devices(void)
82 {
83 	struct omap_dss_device *dssdev = NULL;
84 
85 	for_each_dss_dev(dssdev) {
86 		if (!dssdev->driver)
87 			continue;
88 
89 		if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
90 			dssdev->driver->disable(dssdev);
91 			dssdev->activate_after_resume = true;
92 		} else {
93 			dssdev->activate_after_resume = false;
94 		}
95 	}
96 
97 	return 0;
98 }
99 
100 int dss_resume_all_devices(void)
101 {
102 	struct omap_dss_device *dssdev = NULL;
103 
104 	for_each_dss_dev(dssdev) {
105 		if (!dssdev->driver)
106 			continue;
107 
108 		if (dssdev->activate_after_resume) {
109 			dssdev->driver->enable(dssdev);
110 			dssdev->activate_after_resume = false;
111 		}
112 	}
113 
114 	return 0;
115 }
116 
117 void dss_disable_all_devices(void)
118 {
119 	struct omap_dss_device *dssdev = NULL;
120 
121 	for_each_dss_dev(dssdev) {
122 		if (!dssdev->driver)
123 			continue;
124 
125 		if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
126 			dssdev->driver->disable(dssdev);
127 	}
128 }
129 
130 static LIST_HEAD(panel_list);
131 static DEFINE_MUTEX(panel_list_mutex);
132 static int disp_num_counter;
133 
134 int omapdss_register_display(struct omap_dss_device *dssdev)
135 {
136 	struct omap_dss_driver *drv = dssdev->driver;
137 	int id;
138 
139 	/*
140 	 * Note: this presumes all the displays are either using DT or non-DT,
141 	 * which normally should be the case. This also presumes that all
142 	 * displays either have an DT alias, or none has.
143 	 */
144 
145 	if (dssdev->dev->of_node) {
146 		id = of_alias_get_id(dssdev->dev->of_node, "display");
147 
148 		if (id < 0)
149 			id = disp_num_counter++;
150 	} else {
151 		id = disp_num_counter++;
152 	}
153 
154 	snprintf(dssdev->alias, sizeof(dssdev->alias), "display%d", id);
155 
156 	/* Use 'label' property for name, if it exists */
157 	if (dssdev->dev->of_node)
158 		of_property_read_string(dssdev->dev->of_node, "label",
159 			&dssdev->name);
160 
161 	if (dssdev->name == NULL)
162 		dssdev->name = dssdev->alias;
163 
164 	if (drv && drv->get_resolution == NULL)
165 		drv->get_resolution = omapdss_default_get_resolution;
166 	if (drv && drv->get_recommended_bpp == NULL)
167 		drv->get_recommended_bpp = omapdss_default_get_recommended_bpp;
168 	if (drv && drv->get_timings == NULL)
169 		drv->get_timings = omapdss_default_get_timings;
170 
171 	mutex_lock(&panel_list_mutex);
172 	list_add_tail(&dssdev->panel_list, &panel_list);
173 	mutex_unlock(&panel_list_mutex);
174 	return 0;
175 }
176 EXPORT_SYMBOL(omapdss_register_display);
177 
178 void omapdss_unregister_display(struct omap_dss_device *dssdev)
179 {
180 	mutex_lock(&panel_list_mutex);
181 	list_del(&dssdev->panel_list);
182 	mutex_unlock(&panel_list_mutex);
183 }
184 EXPORT_SYMBOL(omapdss_unregister_display);
185 
186 struct omap_dss_device *omap_dss_get_device(struct omap_dss_device *dssdev)
187 {
188 	if (!try_module_get(dssdev->owner))
189 		return NULL;
190 
191 	if (get_device(dssdev->dev) == NULL) {
192 		module_put(dssdev->owner);
193 		return NULL;
194 	}
195 
196 	return dssdev;
197 }
198 EXPORT_SYMBOL(omap_dss_get_device);
199 
200 void omap_dss_put_device(struct omap_dss_device *dssdev)
201 {
202 	put_device(dssdev->dev);
203 	module_put(dssdev->owner);
204 }
205 EXPORT_SYMBOL(omap_dss_put_device);
206 
207 /*
208  * ref count of the found device is incremented.
209  * ref count of from-device is decremented.
210  */
211 struct omap_dss_device *omap_dss_get_next_device(struct omap_dss_device *from)
212 {
213 	struct list_head *l;
214 	struct omap_dss_device *dssdev;
215 
216 	mutex_lock(&panel_list_mutex);
217 
218 	if (list_empty(&panel_list)) {
219 		dssdev = NULL;
220 		goto out;
221 	}
222 
223 	if (from == NULL) {
224 		dssdev = list_first_entry(&panel_list, struct omap_dss_device,
225 				panel_list);
226 		omap_dss_get_device(dssdev);
227 		goto out;
228 	}
229 
230 	omap_dss_put_device(from);
231 
232 	list_for_each(l, &panel_list) {
233 		dssdev = list_entry(l, struct omap_dss_device, panel_list);
234 		if (dssdev == from) {
235 			if (list_is_last(l, &panel_list)) {
236 				dssdev = NULL;
237 				goto out;
238 			}
239 
240 			dssdev = list_entry(l->next, struct omap_dss_device,
241 					panel_list);
242 			omap_dss_get_device(dssdev);
243 			goto out;
244 		}
245 	}
246 
247 	WARN(1, "'from' dssdev not found\n");
248 
249 	dssdev = NULL;
250 out:
251 	mutex_unlock(&panel_list_mutex);
252 	return dssdev;
253 }
254 EXPORT_SYMBOL(omap_dss_get_next_device);
255 
256 struct omap_dss_device *omap_dss_find_device(void *data,
257 		int (*match)(struct omap_dss_device *dssdev, void *data))
258 {
259 	struct omap_dss_device *dssdev = NULL;
260 
261 	while ((dssdev = omap_dss_get_next_device(dssdev)) != NULL) {
262 		if (match(dssdev, data))
263 			return dssdev;
264 	}
265 
266 	return NULL;
267 }
268 EXPORT_SYMBOL(omap_dss_find_device);
269 
270 void videomode_to_omap_video_timings(const struct videomode *vm,
271 		struct omap_video_timings *ovt)
272 {
273 	memset(ovt, 0, sizeof(*ovt));
274 
275 	ovt->pixelclock = vm->pixelclock;
276 	ovt->x_res = vm->hactive;
277 	ovt->hbp = vm->hback_porch;
278 	ovt->hfp = vm->hfront_porch;
279 	ovt->hsw = vm->hsync_len;
280 	ovt->y_res = vm->vactive;
281 	ovt->vbp = vm->vback_porch;
282 	ovt->vfp = vm->vfront_porch;
283 	ovt->vsw = vm->vsync_len;
284 
285 	ovt->vsync_level = vm->flags & DISPLAY_FLAGS_VSYNC_HIGH ?
286 		OMAPDSS_SIG_ACTIVE_HIGH :
287 		OMAPDSS_SIG_ACTIVE_LOW;
288 	ovt->hsync_level = vm->flags & DISPLAY_FLAGS_HSYNC_HIGH ?
289 		OMAPDSS_SIG_ACTIVE_HIGH :
290 		OMAPDSS_SIG_ACTIVE_LOW;
291 	ovt->de_level = vm->flags & DISPLAY_FLAGS_DE_HIGH ?
292 		OMAPDSS_SIG_ACTIVE_HIGH :
293 		OMAPDSS_SIG_ACTIVE_LOW;
294 	ovt->data_pclk_edge = vm->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE ?
295 		OMAPDSS_DRIVE_SIG_RISING_EDGE :
296 		OMAPDSS_DRIVE_SIG_FALLING_EDGE;
297 
298 	ovt->sync_pclk_edge = ovt->data_pclk_edge;
299 }
300 EXPORT_SYMBOL(videomode_to_omap_video_timings);
301 
302 void omap_video_timings_to_videomode(const struct omap_video_timings *ovt,
303 		struct videomode *vm)
304 {
305 	memset(vm, 0, sizeof(*vm));
306 
307 	vm->pixelclock = ovt->pixelclock;
308 
309 	vm->hactive = ovt->x_res;
310 	vm->hback_porch = ovt->hbp;
311 	vm->hfront_porch = ovt->hfp;
312 	vm->hsync_len = ovt->hsw;
313 	vm->vactive = ovt->y_res;
314 	vm->vback_porch = ovt->vbp;
315 	vm->vfront_porch = ovt->vfp;
316 	vm->vsync_len = ovt->vsw;
317 
318 	if (ovt->hsync_level == OMAPDSS_SIG_ACTIVE_HIGH)
319 		vm->flags |= DISPLAY_FLAGS_HSYNC_HIGH;
320 	else
321 		vm->flags |= DISPLAY_FLAGS_HSYNC_LOW;
322 
323 	if (ovt->vsync_level == OMAPDSS_SIG_ACTIVE_HIGH)
324 		vm->flags |= DISPLAY_FLAGS_VSYNC_HIGH;
325 	else
326 		vm->flags |= DISPLAY_FLAGS_VSYNC_LOW;
327 
328 	if (ovt->de_level == OMAPDSS_SIG_ACTIVE_HIGH)
329 		vm->flags |= DISPLAY_FLAGS_DE_HIGH;
330 	else
331 		vm->flags |= DISPLAY_FLAGS_DE_LOW;
332 
333 	if (ovt->data_pclk_edge == OMAPDSS_DRIVE_SIG_RISING_EDGE)
334 		vm->flags |= DISPLAY_FLAGS_PIXDATA_POSEDGE;
335 	else
336 		vm->flags |= DISPLAY_FLAGS_PIXDATA_NEGEDGE;
337 }
338 EXPORT_SYMBOL(omap_video_timings_to_videomode);
339