GNU Linux-libre 4.14.259-gnu1
[releases.git] / drivers / gpu / drm / omapdrm / dss / output.c
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);