• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2012 Texas Instruments Ltd
3  * Author: Archit Taneja <archit@ti.com>
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/slab.h>
22 #include <linux/of.h>
23 
24 #include "omapdss.h"
25 #include "dss.h"
26 
27 static LIST_HEAD(output_list);
28 static DEFINE_MUTEX(output_lock);
29 
omapdss_output_set_device(struct omap_dss_device * out,struct omap_dss_device * dssdev)30 int omapdss_output_set_device(struct omap_dss_device *out,
31 		struct omap_dss_device *dssdev)
32 {
33 	int r;
34 
35 	mutex_lock(&output_lock);
36 
37 	if (out->dst) {
38 		DSSERR("output already has device %s connected to it\n",
39 			out->dst->name);
40 		r = -EINVAL;
41 		goto err;
42 	}
43 
44 	if (out->output_type != dssdev->type) {
45 		DSSERR("output type and display type don't match\n");
46 		r = -EINVAL;
47 		goto err;
48 	}
49 
50 	out->dst = dssdev;
51 	dssdev->src = out;
52 
53 	mutex_unlock(&output_lock);
54 
55 	return 0;
56 err:
57 	mutex_unlock(&output_lock);
58 
59 	return r;
60 }
61 EXPORT_SYMBOL(omapdss_output_set_device);
62 
omapdss_output_unset_device(struct omap_dss_device * out)63 int omapdss_output_unset_device(struct omap_dss_device *out)
64 {
65 	int r;
66 
67 	mutex_lock(&output_lock);
68 
69 	if (!out->dst) {
70 		DSSERR("output doesn't have a device connected to it\n");
71 		r = -EINVAL;
72 		goto err;
73 	}
74 
75 	if (out->dst->state != OMAP_DSS_DISPLAY_DISABLED) {
76 		DSSERR("device %s is not disabled, cannot unset device\n",
77 				out->dst->name);
78 		r = -EINVAL;
79 		goto err;
80 	}
81 
82 	out->dst->src = NULL;
83 	out->dst = NULL;
84 
85 	mutex_unlock(&output_lock);
86 
87 	return 0;
88 err:
89 	mutex_unlock(&output_lock);
90 
91 	return r;
92 }
93 EXPORT_SYMBOL(omapdss_output_unset_device);
94 
omapdss_register_output(struct omap_dss_device * out)95 int omapdss_register_output(struct omap_dss_device *out)
96 {
97 	list_add_tail(&out->list, &output_list);
98 	return 0;
99 }
100 EXPORT_SYMBOL(omapdss_register_output);
101 
omapdss_unregister_output(struct omap_dss_device * out)102 void omapdss_unregister_output(struct omap_dss_device *out)
103 {
104 	list_del(&out->list);
105 }
106 EXPORT_SYMBOL(omapdss_unregister_output);
107 
omap_dss_get_output(enum omap_dss_output_id id)108 struct omap_dss_device *omap_dss_get_output(enum omap_dss_output_id id)
109 {
110 	struct omap_dss_device *out;
111 
112 	list_for_each_entry(out, &output_list, list) {
113 		if (out->id == id)
114 			return out;
115 	}
116 
117 	return NULL;
118 }
119 EXPORT_SYMBOL(omap_dss_get_output);
120 
omap_dss_find_output(const char * name)121 struct omap_dss_device *omap_dss_find_output(const char *name)
122 {
123 	struct omap_dss_device *out;
124 
125 	list_for_each_entry(out, &output_list, list) {
126 		if (strcmp(out->name, name) == 0)
127 			return omap_dss_get_device(out);
128 	}
129 
130 	return NULL;
131 }
132 EXPORT_SYMBOL(omap_dss_find_output);
133 
omap_dss_find_output_by_port_node(struct device_node * port)134 struct omap_dss_device *omap_dss_find_output_by_port_node(struct device_node *port)
135 {
136 	struct device_node *src_node;
137 	struct omap_dss_device *out;
138 	u32 reg;
139 
140 	src_node = dss_of_port_get_parent_device(port);
141 	if (!src_node)
142 		return NULL;
143 
144 	reg = dss_of_port_get_port_number(port);
145 
146 	list_for_each_entry(out, &output_list, list) {
147 		if (out->dev->of_node == src_node && out->port_num == reg) {
148 			of_node_put(src_node);
149 			return omap_dss_get_device(out);
150 		}
151 	}
152 
153 	of_node_put(src_node);
154 
155 	return NULL;
156 }
157 EXPORT_SYMBOL(omap_dss_find_output_by_port_node);
158 
omapdss_find_output_from_display(struct omap_dss_device * dssdev)159 struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device *dssdev)
160 {
161 	while (dssdev->src)
162 		dssdev = dssdev->src;
163 
164 	if (dssdev->id != 0)
165 		return omap_dss_get_device(dssdev);
166 
167 	return NULL;
168 }
169 EXPORT_SYMBOL(omapdss_find_output_from_display);
170 
171 static const struct dss_mgr_ops *dss_mgr_ops;
172 
dss_install_mgr_ops(const struct dss_mgr_ops * mgr_ops)173 int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops)
174 {
175 	if (dss_mgr_ops)
176 		return -EBUSY;
177 
178 	dss_mgr_ops = mgr_ops;
179 
180 	return 0;
181 }
182 EXPORT_SYMBOL(dss_install_mgr_ops);
183 
dss_uninstall_mgr_ops(void)184 void dss_uninstall_mgr_ops(void)
185 {
186 	dss_mgr_ops = NULL;
187 }
188 EXPORT_SYMBOL(dss_uninstall_mgr_ops);
189 
dss_mgr_connect(enum omap_channel channel,struct omap_dss_device * dst)190 int dss_mgr_connect(enum omap_channel channel,
191 		struct omap_dss_device *dst)
192 {
193 	return dss_mgr_ops->connect(channel, dst);
194 }
195 EXPORT_SYMBOL(dss_mgr_connect);
196 
dss_mgr_disconnect(enum omap_channel channel,struct omap_dss_device * dst)197 void dss_mgr_disconnect(enum omap_channel channel,
198 		struct omap_dss_device *dst)
199 {
200 	dss_mgr_ops->disconnect(channel, dst);
201 }
202 EXPORT_SYMBOL(dss_mgr_disconnect);
203 
dss_mgr_set_timings(enum omap_channel channel,const struct omap_video_timings * timings)204 void dss_mgr_set_timings(enum omap_channel channel,
205 		const struct omap_video_timings *timings)
206 {
207 	dss_mgr_ops->set_timings(channel, timings);
208 }
209 EXPORT_SYMBOL(dss_mgr_set_timings);
210 
dss_mgr_set_lcd_config(enum omap_channel channel,const struct dss_lcd_mgr_config * config)211 void dss_mgr_set_lcd_config(enum omap_channel channel,
212 		const struct dss_lcd_mgr_config *config)
213 {
214 	dss_mgr_ops->set_lcd_config(channel, config);
215 }
216 EXPORT_SYMBOL(dss_mgr_set_lcd_config);
217 
dss_mgr_enable(enum omap_channel channel)218 int dss_mgr_enable(enum omap_channel channel)
219 {
220 	return dss_mgr_ops->enable(channel);
221 }
222 EXPORT_SYMBOL(dss_mgr_enable);
223 
dss_mgr_disable(enum omap_channel channel)224 void dss_mgr_disable(enum omap_channel channel)
225 {
226 	dss_mgr_ops->disable(channel);
227 }
228 EXPORT_SYMBOL(dss_mgr_disable);
229 
dss_mgr_start_update(enum omap_channel channel)230 void dss_mgr_start_update(enum omap_channel channel)
231 {
232 	dss_mgr_ops->start_update(channel);
233 }
234 EXPORT_SYMBOL(dss_mgr_start_update);
235 
dss_mgr_register_framedone_handler(enum omap_channel channel,void (* handler)(void *),void * data)236 int dss_mgr_register_framedone_handler(enum omap_channel channel,
237 		void (*handler)(void *), void *data)
238 {
239 	return dss_mgr_ops->register_framedone_handler(channel, handler, data);
240 }
241 EXPORT_SYMBOL(dss_mgr_register_framedone_handler);
242 
dss_mgr_unregister_framedone_handler(enum omap_channel channel,void (* handler)(void *),void * data)243 void dss_mgr_unregister_framedone_handler(enum omap_channel channel,
244 		void (*handler)(void *), void *data)
245 {
246 	dss_mgr_ops->unregister_framedone_handler(channel, handler, data);
247 }
248 EXPORT_SYMBOL(dss_mgr_unregister_framedone_handler);
249