xref: /openbmc/linux/drivers/gpu/drm/omapdrm/dss/output.c (revision 68198dca)
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 
26 static LIST_HEAD(output_list);
27 static DEFINE_MUTEX(output_lock);
28 
29 int omapdss_output_set_device(struct omap_dss_device *out,
30 		struct omap_dss_device *dssdev)
31 {
32 	int r;
33 
34 	mutex_lock(&output_lock);
35 
36 	if (out->dst) {
37 		dev_err(out->dev,
38 			"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 		dev_err(out->dev, "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 
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 		dev_err(out->dev,
71 			"output doesn't have a device connected to it\n");
72 		r = -EINVAL;
73 		goto err;
74 	}
75 
76 	if (out->dst->state != OMAP_DSS_DISPLAY_DISABLED) {
77 		dev_err(out->dev,
78 			"device %s is not disabled, cannot unset device\n",
79 			out->dst->name);
80 		r = -EINVAL;
81 		goto err;
82 	}
83 
84 	out->dst->src = NULL;
85 	out->dst = NULL;
86 
87 	mutex_unlock(&output_lock);
88 
89 	return 0;
90 err:
91 	mutex_unlock(&output_lock);
92 
93 	return r;
94 }
95 EXPORT_SYMBOL(omapdss_output_unset_device);
96 
97 int omapdss_register_output(struct omap_dss_device *out)
98 {
99 	list_add_tail(&out->list, &output_list);
100 	return 0;
101 }
102 EXPORT_SYMBOL(omapdss_register_output);
103 
104 void omapdss_unregister_output(struct omap_dss_device *out)
105 {
106 	list_del(&out->list);
107 }
108 EXPORT_SYMBOL(omapdss_unregister_output);
109 
110 bool omapdss_component_is_output(struct device_node *node)
111 {
112 	struct omap_dss_device *out;
113 
114 	list_for_each_entry(out, &output_list, list) {
115 		if (out->dev->of_node == node)
116 			return true;
117 	}
118 
119 	return false;
120 }
121 EXPORT_SYMBOL(omapdss_component_is_output);
122 
123 struct omap_dss_device *omap_dss_get_output(enum omap_dss_output_id id)
124 {
125 	struct omap_dss_device *out;
126 
127 	list_for_each_entry(out, &output_list, list) {
128 		if (out->id == id)
129 			return out;
130 	}
131 
132 	return NULL;
133 }
134 EXPORT_SYMBOL(omap_dss_get_output);
135 
136 struct omap_dss_device *omap_dss_find_output_by_port_node(struct device_node *port)
137 {
138 	struct device_node *src_node;
139 	struct omap_dss_device *out;
140 	u32 reg;
141 
142 	src_node = dss_of_port_get_parent_device(port);
143 	if (!src_node)
144 		return NULL;
145 
146 	reg = dss_of_port_get_port_number(port);
147 
148 	list_for_each_entry(out, &output_list, list) {
149 		if (out->dev->of_node == src_node && out->port_num == reg) {
150 			of_node_put(src_node);
151 			return omap_dss_get_device(out);
152 		}
153 	}
154 
155 	of_node_put(src_node);
156 
157 	return NULL;
158 }
159 EXPORT_SYMBOL(omap_dss_find_output_by_port_node);
160 
161 struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device *dssdev)
162 {
163 	while (dssdev->src)
164 		dssdev = dssdev->src;
165 
166 	if (dssdev->id != 0)
167 		return omap_dss_get_device(dssdev);
168 
169 	return NULL;
170 }
171 EXPORT_SYMBOL(omapdss_find_output_from_display);
172 
173 static const struct dss_mgr_ops *dss_mgr_ops;
174 
175 int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops)
176 {
177 	if (dss_mgr_ops)
178 		return -EBUSY;
179 
180 	dss_mgr_ops = mgr_ops;
181 
182 	return 0;
183 }
184 EXPORT_SYMBOL(dss_install_mgr_ops);
185 
186 void dss_uninstall_mgr_ops(void)
187 {
188 	dss_mgr_ops = NULL;
189 }
190 EXPORT_SYMBOL(dss_uninstall_mgr_ops);
191 
192 int dss_mgr_connect(enum omap_channel channel,
193 		struct omap_dss_device *dst)
194 {
195 	return dss_mgr_ops->connect(channel, dst);
196 }
197 EXPORT_SYMBOL(dss_mgr_connect);
198 
199 void dss_mgr_disconnect(enum omap_channel channel,
200 		struct omap_dss_device *dst)
201 {
202 	dss_mgr_ops->disconnect(channel, dst);
203 }
204 EXPORT_SYMBOL(dss_mgr_disconnect);
205 
206 void dss_mgr_set_timings(enum omap_channel channel, const struct videomode *vm)
207 {
208 	dss_mgr_ops->set_timings(channel, vm);
209 }
210 EXPORT_SYMBOL(dss_mgr_set_timings);
211 
212 void dss_mgr_set_lcd_config(enum omap_channel channel,
213 		const struct dss_lcd_mgr_config *config)
214 {
215 	dss_mgr_ops->set_lcd_config(channel, config);
216 }
217 EXPORT_SYMBOL(dss_mgr_set_lcd_config);
218 
219 int dss_mgr_enable(enum omap_channel channel)
220 {
221 	return dss_mgr_ops->enable(channel);
222 }
223 EXPORT_SYMBOL(dss_mgr_enable);
224 
225 void dss_mgr_disable(enum omap_channel channel)
226 {
227 	dss_mgr_ops->disable(channel);
228 }
229 EXPORT_SYMBOL(dss_mgr_disable);
230 
231 void dss_mgr_start_update(enum omap_channel channel)
232 {
233 	dss_mgr_ops->start_update(channel);
234 }
235 EXPORT_SYMBOL(dss_mgr_start_update);
236 
237 int dss_mgr_register_framedone_handler(enum omap_channel channel,
238 		void (*handler)(void *), void *data)
239 {
240 	return dss_mgr_ops->register_framedone_handler(channel, handler, data);
241 }
242 EXPORT_SYMBOL(dss_mgr_register_framedone_handler);
243 
244 void dss_mgr_unregister_framedone_handler(enum omap_channel channel,
245 		void (*handler)(void *), void *data)
246 {
247 	dss_mgr_ops->unregister_framedone_handler(channel, handler, data);
248 }
249 EXPORT_SYMBOL(dss_mgr_unregister_framedone_handler);
250