blob: e688d10f061a976ab5c603e3578796cedb2a2914 [file] [log] [blame]
Tomi Valkeineneed07e02009-08-07 13:43:20 +03001/*
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>
Tomi Valkeineneed07e02009-08-07 13:43:20 +030028#include <linux/platform_device.h>
29
Tomi Valkeinena0b38cc2011-05-11 14:05:07 +030030#include <video/omapdss.h>
Tomi Valkeineneed07e02009-08-07 13:43:20 +030031#include "dss.h"
Tomi Valkeinen5ed8cf52011-06-21 09:35:36 +030032#include "dss_features.h"
Tomi Valkeineneed07e02009-08-07 13:43:20 +030033
Tomi Valkeineneed07e02009-08-07 13:43:20 +030034static ssize_t display_enabled_show(struct device *dev,
35 struct device_attribute *attr, char *buf)
36{
37 struct omap_dss_device *dssdev = to_dss_device(dev);
38 bool enabled = dssdev->state != OMAP_DSS_DISPLAY_DISABLED;
39
40 return snprintf(buf, PAGE_SIZE, "%d\n", enabled);
41}
42
43static ssize_t display_enabled_store(struct device *dev,
44 struct device_attribute *attr,
45 const char *buf, size_t size)
46{
47 struct omap_dss_device *dssdev = to_dss_device(dev);
Tomi Valkeinene3a26ae2011-08-15 15:55:55 +030048 int r;
49 bool enabled;
Tomi Valkeineneed07e02009-08-07 13:43:20 +030050
Tomi Valkeinene3a26ae2011-08-15 15:55:55 +030051 r = strtobool(buf, &enabled);
Tomi Valkeinene3502ce2011-04-04 15:40:23 +030052 if (r)
53 return r;
54
Tomi Valkeineneed07e02009-08-07 13:43:20 +030055 if (enabled != (dssdev->state != OMAP_DSS_DISPLAY_DISABLED)) {
56 if (enabled) {
Tomi Valkeinen37ac60e2010-01-12 15:12:07 +020057 r = dssdev->driver->enable(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +030058 if (r)
59 return r;
60 } else {
Tomi Valkeinen37ac60e2010-01-12 15:12:07 +020061 dssdev->driver->disable(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +030062 }
63 }
64
65 return size;
66}
67
Tomi Valkeineneed07e02009-08-07 13:43:20 +030068static ssize_t display_tear_show(struct device *dev,
69 struct device_attribute *attr, char *buf)
70{
71 struct omap_dss_device *dssdev = to_dss_device(dev);
72 return snprintf(buf, PAGE_SIZE, "%d\n",
Tomi Valkeinen225b6502010-01-11 15:11:01 +020073 dssdev->driver->get_te ?
74 dssdev->driver->get_te(dssdev) : 0);
Tomi Valkeineneed07e02009-08-07 13:43:20 +030075}
76
77static ssize_t display_tear_store(struct device *dev,
78 struct device_attribute *attr, const char *buf, size_t size)
79{
80 struct omap_dss_device *dssdev = to_dss_device(dev);
Tomi Valkeinene3a26ae2011-08-15 15:55:55 +030081 int r;
82 bool te;
Tomi Valkeineneed07e02009-08-07 13:43:20 +030083
Tomi Valkeinen225b6502010-01-11 15:11:01 +020084 if (!dssdev->driver->enable_te || !dssdev->driver->get_te)
Tomi Valkeineneed07e02009-08-07 13:43:20 +030085 return -ENOENT;
86
Tomi Valkeinene3a26ae2011-08-15 15:55:55 +030087 r = strtobool(buf, &te);
Tomi Valkeinene3502ce2011-04-04 15:40:23 +030088 if (r)
89 return r;
90
Tomi Valkeinen225b6502010-01-11 15:11:01 +020091 r = dssdev->driver->enable_te(dssdev, te);
Tomi Valkeineneed07e02009-08-07 13:43:20 +030092 if (r)
93 return r;
94
95 return size;
96}
97
98static ssize_t display_timings_show(struct device *dev,
99 struct device_attribute *attr, char *buf)
100{
101 struct omap_dss_device *dssdev = to_dss_device(dev);
102 struct omap_video_timings t;
103
Tomi Valkeinen69b20482010-01-20 12:11:25 +0200104 if (!dssdev->driver->get_timings)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300105 return -ENOENT;
106
Tomi Valkeinen69b20482010-01-20 12:11:25 +0200107 dssdev->driver->get_timings(dssdev, &t);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300108
109 return snprintf(buf, PAGE_SIZE, "%u,%u/%u/%u/%u,%u/%u/%u/%u\n",
110 t.pixel_clock,
111 t.x_res, t.hfp, t.hbp, t.hsw,
112 t.y_res, t.vfp, t.vbp, t.vsw);
113}
114
115static ssize_t display_timings_store(struct device *dev,
116 struct device_attribute *attr, const char *buf, size_t size)
117{
118 struct omap_dss_device *dssdev = to_dss_device(dev);
119 struct omap_video_timings t;
120 int r, found;
121
Tomi Valkeinen69b20482010-01-20 12:11:25 +0200122 if (!dssdev->driver->set_timings || !dssdev->driver->check_timings)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300123 return -ENOENT;
124
125 found = 0;
126#ifdef CONFIG_OMAP2_DSS_VENC
127 if (strncmp("pal", buf, 3) == 0) {
128 t = omap_dss_pal_timings;
129 found = 1;
130 } else if (strncmp("ntsc", buf, 4) == 0) {
131 t = omap_dss_ntsc_timings;
132 found = 1;
133 }
134#endif
135 if (!found && sscanf(buf, "%u,%hu/%hu/%hu/%hu,%hu/%hu/%hu/%hu",
136 &t.pixel_clock,
137 &t.x_res, &t.hfp, &t.hbp, &t.hsw,
138 &t.y_res, &t.vfp, &t.vbp, &t.vsw) != 9)
139 return -EINVAL;
140
Tomi Valkeinen69b20482010-01-20 12:11:25 +0200141 r = dssdev->driver->check_timings(dssdev, &t);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300142 if (r)
143 return r;
144
Tomi Valkeinen69b20482010-01-20 12:11:25 +0200145 dssdev->driver->set_timings(dssdev, &t);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300146
147 return size;
148}
149
150static ssize_t display_rotate_show(struct device *dev,
151 struct device_attribute *attr, char *buf)
152{
153 struct omap_dss_device *dssdev = to_dss_device(dev);
154 int rotate;
Tomi Valkeinen87424e12010-01-08 16:52:48 +0200155 if (!dssdev->driver->get_rotate)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300156 return -ENOENT;
Tomi Valkeinen87424e12010-01-08 16:52:48 +0200157 rotate = dssdev->driver->get_rotate(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300158 return snprintf(buf, PAGE_SIZE, "%u\n", rotate);
159}
160
161static ssize_t display_rotate_store(struct device *dev,
162 struct device_attribute *attr, const char *buf, size_t size)
163{
164 struct omap_dss_device *dssdev = to_dss_device(dev);
Tomi Valkeinene3502ce2011-04-04 15:40:23 +0300165 int rot, r;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300166
Tomi Valkeinen87424e12010-01-08 16:52:48 +0200167 if (!dssdev->driver->set_rotate || !dssdev->driver->get_rotate)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300168 return -ENOENT;
169
Tomi Valkeinene3502ce2011-04-04 15:40:23 +0300170 r = kstrtoint(buf, 0, &rot);
171 if (r)
172 return r;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300173
Tomi Valkeinen87424e12010-01-08 16:52:48 +0200174 r = dssdev->driver->set_rotate(dssdev, rot);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300175 if (r)
176 return r;
177
178 return size;
179}
180
181static ssize_t display_mirror_show(struct device *dev,
182 struct device_attribute *attr, char *buf)
183{
184 struct omap_dss_device *dssdev = to_dss_device(dev);
185 int mirror;
Tomi Valkeinen8d8aa612010-01-08 16:30:33 +0200186 if (!dssdev->driver->get_mirror)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300187 return -ENOENT;
Tomi Valkeinen8d8aa612010-01-08 16:30:33 +0200188 mirror = dssdev->driver->get_mirror(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300189 return snprintf(buf, PAGE_SIZE, "%u\n", mirror);
190}
191
192static ssize_t display_mirror_store(struct device *dev,
193 struct device_attribute *attr, const char *buf, size_t size)
194{
195 struct omap_dss_device *dssdev = to_dss_device(dev);
Tomi Valkeinene3a26ae2011-08-15 15:55:55 +0300196 int r;
197 bool mirror;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300198
Tomi Valkeinen8d8aa612010-01-08 16:30:33 +0200199 if (!dssdev->driver->set_mirror || !dssdev->driver->get_mirror)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300200 return -ENOENT;
201
Tomi Valkeinene3a26ae2011-08-15 15:55:55 +0300202 r = strtobool(buf, &mirror);
Tomi Valkeinene3502ce2011-04-04 15:40:23 +0300203 if (r)
204 return r;
205
Tomi Valkeinen8d8aa612010-01-08 16:30:33 +0200206 r = dssdev->driver->set_mirror(dssdev, mirror);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300207 if (r)
208 return r;
209
210 return size;
211}
212
213static ssize_t display_wss_show(struct device *dev,
214 struct device_attribute *attr, char *buf)
215{
216 struct omap_dss_device *dssdev = to_dss_device(dev);
217 unsigned int wss;
218
Tomi Valkeinen36511312010-01-19 15:53:16 +0200219 if (!dssdev->driver->get_wss)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300220 return -ENOENT;
221
Tomi Valkeinen36511312010-01-19 15:53:16 +0200222 wss = dssdev->driver->get_wss(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300223
224 return snprintf(buf, PAGE_SIZE, "0x%05x\n", wss);
225}
226
227static ssize_t display_wss_store(struct device *dev,
228 struct device_attribute *attr, const char *buf, size_t size)
229{
230 struct omap_dss_device *dssdev = to_dss_device(dev);
Tomi Valkeinene3502ce2011-04-04 15:40:23 +0300231 u32 wss;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300232 int r;
233
Tomi Valkeinen36511312010-01-19 15:53:16 +0200234 if (!dssdev->driver->get_wss || !dssdev->driver->set_wss)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300235 return -ENOENT;
236
Tomi Valkeinene3502ce2011-04-04 15:40:23 +0300237 r = kstrtou32(buf, 0, &wss);
238 if (r)
239 return r;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300240
241 if (wss > 0xfffff)
242 return -EINVAL;
243
Tomi Valkeinen36511312010-01-19 15:53:16 +0200244 r = dssdev->driver->set_wss(dssdev, wss);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300245 if (r)
246 return r;
247
248 return size;
249}
250
251static DEVICE_ATTR(enabled, S_IRUGO|S_IWUSR,
252 display_enabled_show, display_enabled_store);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300253static DEVICE_ATTR(tear_elim, S_IRUGO|S_IWUSR,
254 display_tear_show, display_tear_store);
255static DEVICE_ATTR(timings, S_IRUGO|S_IWUSR,
256 display_timings_show, display_timings_store);
257static DEVICE_ATTR(rotate, S_IRUGO|S_IWUSR,
258 display_rotate_show, display_rotate_store);
259static DEVICE_ATTR(mirror, S_IRUGO|S_IWUSR,
260 display_mirror_show, display_mirror_store);
261static DEVICE_ATTR(wss, S_IRUGO|S_IWUSR,
262 display_wss_show, display_wss_store);
263
264static struct device_attribute *display_sysfs_attrs[] = {
265 &dev_attr_enabled,
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300266 &dev_attr_tear_elim,
267 &dev_attr_timings,
268 &dev_attr_rotate,
269 &dev_attr_mirror,
270 &dev_attr_wss,
271 NULL
272};
273
Tomi Valkeinen96adcec2010-01-11 13:54:33 +0200274void omapdss_default_get_resolution(struct omap_dss_device *dssdev,
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300275 u16 *xres, u16 *yres)
276{
277 *xres = dssdev->panel.timings.x_res;
278 *yres = dssdev->panel.timings.y_res;
279}
Tomi Valkeinen96adcec2010-01-11 13:54:33 +0200280EXPORT_SYMBOL(omapdss_default_get_resolution);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300281
Tomi Valkeinena2699502010-01-11 14:33:40 +0200282int omapdss_default_get_recommended_bpp(struct omap_dss_device *dssdev)
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300283{
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300284 switch (dssdev->type) {
285 case OMAP_DISPLAY_TYPE_DPI:
286 if (dssdev->phy.dpi.data_lines == 24)
287 return 24;
288 else
289 return 16;
290
291 case OMAP_DISPLAY_TYPE_DBI:
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300292 if (dssdev->ctrl.pixel_size == 24)
293 return 24;
294 else
295 return 16;
Archit Tanejaa3b3cc22011-09-08 18:42:16 +0530296 case OMAP_DISPLAY_TYPE_DSI:
297 if (dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt) > 16)
298 return 24;
299 else
300 return 16;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300301 case OMAP_DISPLAY_TYPE_VENC:
302 case OMAP_DISPLAY_TYPE_SDI:
Mythri P Kb1196012011-03-08 17:15:54 +0530303 case OMAP_DISPLAY_TYPE_HDMI:
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300304 return 24;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300305 default:
306 BUG();
307 }
308}
Tomi Valkeinena2699502010-01-11 14:33:40 +0200309EXPORT_SYMBOL(omapdss_default_get_recommended_bpp);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300310
Grazvydas Ignotas4b6430f2012-03-15 20:00:23 +0200311void omapdss_default_get_timings(struct omap_dss_device *dssdev,
312 struct omap_video_timings *timings)
313{
314 *timings = dssdev->panel.timings;
315}
316EXPORT_SYMBOL(omapdss_default_get_timings);
317
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300318/* Checks if replication logic should be used. Only use for active matrix,
319 * when overlay is in RGB12U or RGB16 mode, and LCD interface is
320 * 18bpp or 24bpp */
321bool dss_use_replication(struct omap_dss_device *dssdev,
322 enum omap_color_mode mode)
323{
324 int bpp;
325
326 if (mode != OMAP_DSS_COLOR_RGB12U && mode != OMAP_DSS_COLOR_RGB16)
327 return false;
328
329 if (dssdev->type == OMAP_DISPLAY_TYPE_DPI &&
330 (dssdev->panel.config & OMAP_DSS_LCD_TFT) == 0)
331 return false;
332
333 switch (dssdev->type) {
334 case OMAP_DISPLAY_TYPE_DPI:
335 bpp = dssdev->phy.dpi.data_lines;
336 break;
Mythri P Kb1196012011-03-08 17:15:54 +0530337 case OMAP_DISPLAY_TYPE_HDMI:
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300338 case OMAP_DISPLAY_TYPE_VENC:
339 case OMAP_DISPLAY_TYPE_SDI:
340 bpp = 24;
341 break;
342 case OMAP_DISPLAY_TYPE_DBI:
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300343 bpp = dssdev->ctrl.pixel_size;
344 break;
Archit Tanejaa3b3cc22011-09-08 18:42:16 +0530345 case OMAP_DISPLAY_TYPE_DSI:
346 bpp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt);
347 break;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300348 default:
349 BUG();
350 }
351
352 return bpp > 16;
353}
354
355void dss_init_device(struct platform_device *pdev,
356 struct omap_dss_device *dssdev)
357{
358 struct device_attribute *attr;
359 int i;
360 int r;
361
362 switch (dssdev->type) {
Roger Quadrosb4d78bf2010-03-17 13:35:19 +0100363#ifdef CONFIG_OMAP2_DSS_DPI
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300364 case OMAP_DISPLAY_TYPE_DPI:
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300365 r = dpi_init_display(dssdev);
366 break;
Roger Quadrosb4d78bf2010-03-17 13:35:19 +0100367#endif
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300368#ifdef CONFIG_OMAP2_DSS_RFBI
369 case OMAP_DISPLAY_TYPE_DBI:
370 r = rfbi_init_display(dssdev);
371 break;
372#endif
373#ifdef CONFIG_OMAP2_DSS_VENC
374 case OMAP_DISPLAY_TYPE_VENC:
375 r = venc_init_display(dssdev);
376 break;
377#endif
378#ifdef CONFIG_OMAP2_DSS_SDI
379 case OMAP_DISPLAY_TYPE_SDI:
380 r = sdi_init_display(dssdev);
381 break;
382#endif
383#ifdef CONFIG_OMAP2_DSS_DSI
384 case OMAP_DISPLAY_TYPE_DSI:
385 r = dsi_init_display(dssdev);
386 break;
387#endif
Mythri P Kc3198a52011-03-12 12:04:27 +0530388 case OMAP_DISPLAY_TYPE_HDMI:
389 r = hdmi_init_display(dssdev);
390 break;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300391 default:
Tomi Valkeinene528e3a2011-02-24 13:59:13 +0200392 DSSERR("Support for display '%s' not compiled in.\n",
393 dssdev->name);
394 return;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300395 }
396
397 if (r) {
398 DSSERR("failed to init display %s\n", dssdev->name);
399 return;
400 }
401
402 /* create device sysfs files */
403 i = 0;
404 while ((attr = display_sysfs_attrs[i++]) != NULL) {
405 r = device_create_file(&dssdev->dev, attr);
406 if (r)
407 DSSERR("failed to create sysfs file\n");
408 }
409
410 /* create display? sysfs links */
411 r = sysfs_create_link(&pdev->dev.kobj, &dssdev->dev.kobj,
412 dev_name(&dssdev->dev));
413 if (r)
414 DSSERR("failed to create sysfs display link\n");
415}
416
417void dss_uninit_device(struct platform_device *pdev,
418 struct omap_dss_device *dssdev)
419{
420 struct device_attribute *attr;
421 int i = 0;
422
423 sysfs_remove_link(&pdev->dev.kobj, dev_name(&dssdev->dev));
424
425 while ((attr = display_sysfs_attrs[i++]) != NULL)
426 device_remove_file(&dssdev->dev, attr);
427
428 if (dssdev->manager)
429 dssdev->manager->unset_device(dssdev->manager);
430}
431
432static int dss_suspend_device(struct device *dev, void *data)
433{
434 int r;
435 struct omap_dss_device *dssdev = to_dss_device(dev);
436
437 if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE) {
438 dssdev->activate_after_resume = false;
439 return 0;
440 }
441
Tomi Valkeinen37ac60e2010-01-12 15:12:07 +0200442 if (!dssdev->driver->suspend) {
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300443 DSSERR("display '%s' doesn't implement suspend\n",
444 dssdev->name);
445 return -ENOSYS;
446 }
447
Tomi Valkeinen37ac60e2010-01-12 15:12:07 +0200448 r = dssdev->driver->suspend(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300449 if (r)
450 return r;
451
452 dssdev->activate_after_resume = true;
453
454 return 0;
455}
456
457int dss_suspend_all_devices(void)
458{
459 int r;
460 struct bus_type *bus = dss_get_bus();
461
462 r = bus_for_each_dev(bus, NULL, NULL, dss_suspend_device);
463 if (r) {
464 /* resume all displays that were suspended */
465 dss_resume_all_devices();
466 return r;
467 }
468
469 return 0;
470}
471
472static int dss_resume_device(struct device *dev, void *data)
473{
474 int r;
475 struct omap_dss_device *dssdev = to_dss_device(dev);
476
Tomi Valkeinen37ac60e2010-01-12 15:12:07 +0200477 if (dssdev->activate_after_resume && dssdev->driver->resume) {
478 r = dssdev->driver->resume(dssdev);
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300479 if (r)
480 return r;
481 }
482
483 dssdev->activate_after_resume = false;
484
485 return 0;
486}
487
488int dss_resume_all_devices(void)
489{
490 struct bus_type *bus = dss_get_bus();
491
492 return bus_for_each_dev(bus, NULL, NULL, dss_resume_device);
493}
494
495static int dss_disable_device(struct device *dev, void *data)
496{
497 struct omap_dss_device *dssdev = to_dss_device(dev);
Jani Nikula279fcd42010-03-24 11:59:38 +0100498
499 if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED)
500 dssdev->driver->disable(dssdev);
501
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300502 return 0;
503}
504
505void dss_disable_all_devices(void)
506{
507 struct bus_type *bus = dss_get_bus();
508 bus_for_each_dev(bus, NULL, NULL, dss_disable_device);
509}
510
511
512void omap_dss_get_device(struct omap_dss_device *dssdev)
513{
514 get_device(&dssdev->dev);
515}
516EXPORT_SYMBOL(omap_dss_get_device);
517
518void omap_dss_put_device(struct omap_dss_device *dssdev)
519{
520 put_device(&dssdev->dev);
521}
522EXPORT_SYMBOL(omap_dss_put_device);
523
524/* ref count of the found device is incremented. ref count
525 * of from-device is decremented. */
526struct omap_dss_device *omap_dss_get_next_device(struct omap_dss_device *from)
527{
528 struct device *dev;
529 struct device *dev_start = NULL;
530 struct omap_dss_device *dssdev = NULL;
531
532 int match(struct device *dev, void *data)
533 {
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300534 return 1;
535 }
536
537 if (from)
538 dev_start = &from->dev;
539 dev = bus_find_device(dss_get_bus(), dev_start, NULL, match);
540 if (dev)
541 dssdev = to_dss_device(dev);
542 if (from)
543 put_device(&from->dev);
544
545 return dssdev;
546}
547EXPORT_SYMBOL(omap_dss_get_next_device);
548
549struct omap_dss_device *omap_dss_find_device(void *data,
550 int (*match)(struct omap_dss_device *dssdev, void *data))
551{
552 struct omap_dss_device *dssdev = NULL;
553
554 while ((dssdev = omap_dss_get_next_device(dssdev)) != NULL) {
555 if (match(dssdev, data))
556 return dssdev;
557 }
558
559 return NULL;
560}
561EXPORT_SYMBOL(omap_dss_find_device);
562
563int omap_dss_start_device(struct omap_dss_device *dssdev)
564{
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300565 if (!dssdev->driver) {
566 DSSDBG("no driver\n");
Tomi Valkeinene020f9a2010-02-17 13:36:48 +0200567 return -ENODEV;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300568 }
569
570 if (!try_module_get(dssdev->dev.driver->owner)) {
Tomi Valkeinene020f9a2010-02-17 13:36:48 +0200571 return -ENODEV;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300572 }
573
574 return 0;
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300575}
576EXPORT_SYMBOL(omap_dss_start_device);
577
578void omap_dss_stop_device(struct omap_dss_device *dssdev)
579{
Tomi Valkeineneed07e02009-08-07 13:43:20 +0300580 module_put(dssdev->dev.driver->owner);
581}
582EXPORT_SYMBOL(omap_dss_stop_device);
583