diff options
author | Rob Clark <robdclark@gmail.com> | 2013-01-22 17:02:21 -0500 |
---|---|---|
committer | Rob Clark <robdclark@gmail.com> | 2013-02-19 17:57:44 -0500 |
commit | 6e8de0bd6a51fdeebd5d975c4fcc426f730b339b (patch) | |
tree | 16578d6569e031751ddfbb3db2991833c70201dd /drivers/gpu | |
parent | e7792ce2da5ded80861db787ace9b57ecf7bc96c (diff) |
drm/tilcdc: add encoder slave (v2)
Add output panel driver for i2c encoder slaves.
v1: original
v2: add DT bindings docs, and minor updates for review comments
Signed-off-by: Rob Clark <robdclark@gmail.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Tested-by: Koen Kooi <koen@dominion.thruhere.net>
Diffstat (limited to 'drivers/gpu')
-rw-r--r-- | drivers/gpu/drm/tilcdc/Makefile | 1 | ||||
-rw-r--r-- | drivers/gpu/drm/tilcdc/tilcdc_drv.c | 5 | ||||
-rw-r--r-- | drivers/gpu/drm/tilcdc/tilcdc_slave.c | 376 | ||||
-rw-r--r-- | drivers/gpu/drm/tilcdc/tilcdc_slave.h | 26 |
4 files changed, 407 insertions, 1 deletions
diff --git a/drivers/gpu/drm/tilcdc/Makefile b/drivers/gpu/drm/tilcdc/Makefile index 1359cc29cd81..aa9097edbaf8 100644 --- a/drivers/gpu/drm/tilcdc/Makefile +++ b/drivers/gpu/drm/tilcdc/Makefile | |||
@@ -3,6 +3,7 @@ ccflags-y := -Iinclude/drm -Werror | |||
3 | tilcdc-y := \ | 3 | tilcdc-y := \ |
4 | tilcdc_crtc.o \ | 4 | tilcdc_crtc.o \ |
5 | tilcdc_tfp410.o \ | 5 | tilcdc_tfp410.o \ |
6 | tilcdc_slave.o \ | ||
6 | tilcdc_drv.o | 7 | tilcdc_drv.o |
7 | 8 | ||
8 | obj-$(CONFIG_DRM_TILCDC) += tilcdc.o | 9 | obj-$(CONFIG_DRM_TILCDC) += tilcdc.o |
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_drv.c b/drivers/gpu/drm/tilcdc/tilcdc_drv.c index f6defbfaaffb..25f3add2a754 100644 --- a/drivers/gpu/drm/tilcdc/tilcdc_drv.c +++ b/drivers/gpu/drm/tilcdc/tilcdc_drv.c | |||
@@ -20,6 +20,7 @@ | |||
20 | #include "tilcdc_drv.h" | 20 | #include "tilcdc_drv.h" |
21 | #include "tilcdc_regs.h" | 21 | #include "tilcdc_regs.h" |
22 | #include "tilcdc_tfp410.h" | 22 | #include "tilcdc_tfp410.h" |
23 | #include "tilcdc_slave.h" | ||
23 | 24 | ||
24 | #include "drm_fb_helper.h" | 25 | #include "drm_fb_helper.h" |
25 | 26 | ||
@@ -587,6 +588,7 @@ static int __init tilcdc_drm_init(void) | |||
587 | { | 588 | { |
588 | DBG("init"); | 589 | DBG("init"); |
589 | tilcdc_tfp410_init(); | 590 | tilcdc_tfp410_init(); |
591 | tilcdc_slave_init(); | ||
590 | return platform_driver_register(&tilcdc_platform_driver); | 592 | return platform_driver_register(&tilcdc_platform_driver); |
591 | } | 593 | } |
592 | 594 | ||
@@ -594,10 +596,11 @@ static void __exit tilcdc_drm_fini(void) | |||
594 | { | 596 | { |
595 | DBG("fini"); | 597 | DBG("fini"); |
596 | tilcdc_tfp410_fini(); | 598 | tilcdc_tfp410_fini(); |
599 | tilcdc_slave_fini(); | ||
597 | platform_driver_unregister(&tilcdc_platform_driver); | 600 | platform_driver_unregister(&tilcdc_platform_driver); |
598 | } | 601 | } |
599 | 602 | ||
600 | module_init(tilcdc_drm_init); | 603 | late_initcall(tilcdc_drm_init); |
601 | module_exit(tilcdc_drm_fini); | 604 | module_exit(tilcdc_drm_fini); |
602 | 605 | ||
603 | MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); | 606 | MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); |
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_slave.c b/drivers/gpu/drm/tilcdc/tilcdc_slave.c new file mode 100644 index 000000000000..568dc1c08e6c --- /dev/null +++ b/drivers/gpu/drm/tilcdc/tilcdc_slave.c | |||
@@ -0,0 +1,376 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2012 Texas Instruments | ||
3 | * Author: Rob Clark <robdclark@gmail.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/i2c.h> | ||
19 | #include <linux/of_i2c.h> | ||
20 | #include <linux/pinctrl/pinmux.h> | ||
21 | #include <linux/pinctrl/consumer.h> | ||
22 | #include <drm/drm_encoder_slave.h> | ||
23 | |||
24 | #include "tilcdc_drv.h" | ||
25 | |||
26 | struct slave_module { | ||
27 | struct tilcdc_module base; | ||
28 | struct i2c_adapter *i2c; | ||
29 | }; | ||
30 | #define to_slave_module(x) container_of(x, struct slave_module, base) | ||
31 | |||
32 | static const struct tilcdc_panel_info slave_info = { | ||
33 | .bpp = 16, | ||
34 | .ac_bias = 255, | ||
35 | .ac_bias_intrpt = 0, | ||
36 | .dma_burst_sz = 16, | ||
37 | .fdd = 0x80, | ||
38 | .tft_alt_mode = 0, | ||
39 | .sync_edge = 0, | ||
40 | .sync_ctrl = 1, | ||
41 | .raster_order = 0, | ||
42 | }; | ||
43 | |||
44 | |||
45 | /* | ||
46 | * Encoder: | ||
47 | */ | ||
48 | |||
49 | struct slave_encoder { | ||
50 | struct drm_encoder_slave base; | ||
51 | struct slave_module *mod; | ||
52 | }; | ||
53 | #define to_slave_encoder(x) container_of(to_encoder_slave(x), struct slave_encoder, base) | ||
54 | |||
55 | static inline struct drm_encoder_slave_funcs * | ||
56 | get_slave_funcs(struct drm_encoder *enc) | ||
57 | { | ||
58 | return to_encoder_slave(enc)->slave_funcs; | ||
59 | } | ||
60 | |||
61 | static void slave_encoder_destroy(struct drm_encoder *encoder) | ||
62 | { | ||
63 | struct slave_encoder *slave_encoder = to_slave_encoder(encoder); | ||
64 | if (get_slave_funcs(encoder)) | ||
65 | get_slave_funcs(encoder)->destroy(encoder); | ||
66 | drm_encoder_cleanup(encoder); | ||
67 | kfree(slave_encoder); | ||
68 | } | ||
69 | |||
70 | static void slave_encoder_prepare(struct drm_encoder *encoder) | ||
71 | { | ||
72 | drm_i2c_encoder_prepare(encoder); | ||
73 | tilcdc_crtc_set_panel_info(encoder->crtc, &slave_info); | ||
74 | } | ||
75 | |||
76 | static const struct drm_encoder_funcs slave_encoder_funcs = { | ||
77 | .destroy = slave_encoder_destroy, | ||
78 | }; | ||
79 | |||
80 | static const struct drm_encoder_helper_funcs slave_encoder_helper_funcs = { | ||
81 | .dpms = drm_i2c_encoder_dpms, | ||
82 | .mode_fixup = drm_i2c_encoder_mode_fixup, | ||
83 | .prepare = slave_encoder_prepare, | ||
84 | .commit = drm_i2c_encoder_commit, | ||
85 | .mode_set = drm_i2c_encoder_mode_set, | ||
86 | .save = drm_i2c_encoder_save, | ||
87 | .restore = drm_i2c_encoder_restore, | ||
88 | }; | ||
89 | |||
90 | static const struct i2c_board_info info = { | ||
91 | I2C_BOARD_INFO("tda998x", 0x70) | ||
92 | }; | ||
93 | |||
94 | static struct drm_encoder *slave_encoder_create(struct drm_device *dev, | ||
95 | struct slave_module *mod) | ||
96 | { | ||
97 | struct slave_encoder *slave_encoder; | ||
98 | struct drm_encoder *encoder; | ||
99 | int ret; | ||
100 | |||
101 | slave_encoder = kzalloc(sizeof(*slave_encoder), GFP_KERNEL); | ||
102 | if (!slave_encoder) { | ||
103 | dev_err(dev->dev, "allocation failed\n"); | ||
104 | return NULL; | ||
105 | } | ||
106 | |||
107 | slave_encoder->mod = mod; | ||
108 | |||
109 | encoder = &slave_encoder->base.base; | ||
110 | encoder->possible_crtcs = 1; | ||
111 | |||
112 | ret = drm_encoder_init(dev, encoder, &slave_encoder_funcs, | ||
113 | DRM_MODE_ENCODER_TMDS); | ||
114 | if (ret) | ||
115 | goto fail; | ||
116 | |||
117 | drm_encoder_helper_add(encoder, &slave_encoder_helper_funcs); | ||
118 | |||
119 | ret = drm_i2c_encoder_init(dev, to_encoder_slave(encoder), mod->i2c, &info); | ||
120 | if (ret) | ||
121 | goto fail; | ||
122 | |||
123 | return encoder; | ||
124 | |||
125 | fail: | ||
126 | slave_encoder_destroy(encoder); | ||
127 | return NULL; | ||
128 | } | ||
129 | |||
130 | /* | ||
131 | * Connector: | ||
132 | */ | ||
133 | |||
134 | struct slave_connector { | ||
135 | struct drm_connector base; | ||
136 | |||
137 | struct drm_encoder *encoder; /* our connected encoder */ | ||
138 | struct slave_module *mod; | ||
139 | }; | ||
140 | #define to_slave_connector(x) container_of(x, struct slave_connector, base) | ||
141 | |||
142 | static void slave_connector_destroy(struct drm_connector *connector) | ||
143 | { | ||
144 | struct slave_connector *slave_connector = to_slave_connector(connector); | ||
145 | drm_connector_cleanup(connector); | ||
146 | kfree(slave_connector); | ||
147 | } | ||
148 | |||
149 | static enum drm_connector_status slave_connector_detect( | ||
150 | struct drm_connector *connector, | ||
151 | bool force) | ||
152 | { | ||
153 | struct drm_encoder *encoder = to_slave_connector(connector)->encoder; | ||
154 | return get_slave_funcs(encoder)->detect(encoder, connector); | ||
155 | } | ||
156 | |||
157 | static int slave_connector_get_modes(struct drm_connector *connector) | ||
158 | { | ||
159 | struct drm_encoder *encoder = to_slave_connector(connector)->encoder; | ||
160 | return get_slave_funcs(encoder)->get_modes(encoder, connector); | ||
161 | } | ||
162 | |||
163 | static int slave_connector_mode_valid(struct drm_connector *connector, | ||
164 | struct drm_display_mode *mode) | ||
165 | { | ||
166 | struct drm_encoder *encoder = to_slave_connector(connector)->encoder; | ||
167 | struct tilcdc_drm_private *priv = connector->dev->dev_private; | ||
168 | int ret; | ||
169 | |||
170 | ret = tilcdc_crtc_mode_valid(priv->crtc, mode); | ||
171 | if (ret != MODE_OK) | ||
172 | return ret; | ||
173 | |||
174 | return get_slave_funcs(encoder)->mode_valid(encoder, mode); | ||
175 | } | ||
176 | |||
177 | static struct drm_encoder *slave_connector_best_encoder( | ||
178 | struct drm_connector *connector) | ||
179 | { | ||
180 | struct slave_connector *slave_connector = to_slave_connector(connector); | ||
181 | return slave_connector->encoder; | ||
182 | } | ||
183 | |||
184 | static int slave_connector_set_property(struct drm_connector *connector, | ||
185 | struct drm_property *property, uint64_t value) | ||
186 | { | ||
187 | struct drm_encoder *encoder = to_slave_connector(connector)->encoder; | ||
188 | return get_slave_funcs(encoder)->set_property(encoder, | ||
189 | connector, property, value); | ||
190 | } | ||
191 | |||
192 | static const struct drm_connector_funcs slave_connector_funcs = { | ||
193 | .destroy = slave_connector_destroy, | ||
194 | .dpms = drm_helper_connector_dpms, | ||
195 | .detect = slave_connector_detect, | ||
196 | .fill_modes = drm_helper_probe_single_connector_modes, | ||
197 | .set_property = slave_connector_set_property, | ||
198 | }; | ||
199 | |||
200 | static const struct drm_connector_helper_funcs slave_connector_helper_funcs = { | ||
201 | .get_modes = slave_connector_get_modes, | ||
202 | .mode_valid = slave_connector_mode_valid, | ||
203 | .best_encoder = slave_connector_best_encoder, | ||
204 | }; | ||
205 | |||
206 | static struct drm_connector *slave_connector_create(struct drm_device *dev, | ||
207 | struct slave_module *mod, struct drm_encoder *encoder) | ||
208 | { | ||
209 | struct slave_connector *slave_connector; | ||
210 | struct drm_connector *connector; | ||
211 | int ret; | ||
212 | |||
213 | slave_connector = kzalloc(sizeof(*slave_connector), GFP_KERNEL); | ||
214 | if (!slave_connector) { | ||
215 | dev_err(dev->dev, "allocation failed\n"); | ||
216 | return NULL; | ||
217 | } | ||
218 | |||
219 | slave_connector->encoder = encoder; | ||
220 | slave_connector->mod = mod; | ||
221 | |||
222 | connector = &slave_connector->base; | ||
223 | |||
224 | drm_connector_init(dev, connector, &slave_connector_funcs, | ||
225 | DRM_MODE_CONNECTOR_HDMIA); | ||
226 | drm_connector_helper_add(connector, &slave_connector_helper_funcs); | ||
227 | |||
228 | connector->polled = DRM_CONNECTOR_POLL_CONNECT | | ||
229 | DRM_CONNECTOR_POLL_DISCONNECT; | ||
230 | |||
231 | connector->interlace_allowed = 0; | ||
232 | connector->doublescan_allowed = 0; | ||
233 | |||
234 | get_slave_funcs(encoder)->create_resources(encoder, connector); | ||
235 | |||
236 | ret = drm_mode_connector_attach_encoder(connector, encoder); | ||
237 | if (ret) | ||
238 | goto fail; | ||
239 | |||
240 | drm_sysfs_connector_add(connector); | ||
241 | |||
242 | return connector; | ||
243 | |||
244 | fail: | ||
245 | slave_connector_destroy(connector); | ||
246 | return NULL; | ||
247 | } | ||
248 | |||
249 | /* | ||
250 | * Module: | ||
251 | */ | ||
252 | |||
253 | static int slave_modeset_init(struct tilcdc_module *mod, struct drm_device *dev) | ||
254 | { | ||
255 | struct slave_module *slave_mod = to_slave_module(mod); | ||
256 | struct tilcdc_drm_private *priv = dev->dev_private; | ||
257 | struct drm_encoder *encoder; | ||
258 | struct drm_connector *connector; | ||
259 | |||
260 | encoder = slave_encoder_create(dev, slave_mod); | ||
261 | if (!encoder) | ||
262 | return -ENOMEM; | ||
263 | |||
264 | connector = slave_connector_create(dev, slave_mod, encoder); | ||
265 | if (!connector) | ||
266 | return -ENOMEM; | ||
267 | |||
268 | priv->encoders[priv->num_encoders++] = encoder; | ||
269 | priv->connectors[priv->num_connectors++] = connector; | ||
270 | |||
271 | return 0; | ||
272 | } | ||
273 | |||
274 | static void slave_destroy(struct tilcdc_module *mod) | ||
275 | { | ||
276 | struct slave_module *slave_mod = to_slave_module(mod); | ||
277 | |||
278 | tilcdc_module_cleanup(mod); | ||
279 | kfree(slave_mod); | ||
280 | } | ||
281 | |||
282 | static const struct tilcdc_module_ops slave_module_ops = { | ||
283 | .modeset_init = slave_modeset_init, | ||
284 | .destroy = slave_destroy, | ||
285 | }; | ||
286 | |||
287 | /* | ||
288 | * Device: | ||
289 | */ | ||
290 | |||
291 | static struct of_device_id slave_of_match[]; | ||
292 | |||
293 | static int slave_probe(struct platform_device *pdev) | ||
294 | { | ||
295 | struct device_node *node = pdev->dev.of_node; | ||
296 | struct device_node *i2c_node; | ||
297 | struct slave_module *slave_mod; | ||
298 | struct tilcdc_module *mod; | ||
299 | struct pinctrl *pinctrl; | ||
300 | uint32_t i2c_phandle; | ||
301 | int ret = -EINVAL; | ||
302 | |||
303 | /* bail out early if no DT data: */ | ||
304 | if (!node) { | ||
305 | dev_err(&pdev->dev, "device-tree data is missing\n"); | ||
306 | return -ENXIO; | ||
307 | } | ||
308 | |||
309 | slave_mod = kzalloc(sizeof(*slave_mod), GFP_KERNEL); | ||
310 | if (!slave_mod) | ||
311 | return -ENOMEM; | ||
312 | |||
313 | mod = &slave_mod->base; | ||
314 | |||
315 | tilcdc_module_init(mod, "slave", &slave_module_ops); | ||
316 | |||
317 | pinctrl = devm_pinctrl_get_select_default(&pdev->dev); | ||
318 | if (IS_ERR(pinctrl)) | ||
319 | dev_warn(&pdev->dev, "pins are not configured\n"); | ||
320 | |||
321 | if (of_property_read_u32(node, "i2c", &i2c_phandle)) { | ||
322 | dev_err(&pdev->dev, "could not get i2c bus phandle\n"); | ||
323 | goto fail; | ||
324 | } | ||
325 | |||
326 | i2c_node = of_find_node_by_phandle(i2c_phandle); | ||
327 | if (!i2c_node) { | ||
328 | dev_err(&pdev->dev, "could not get i2c bus node\n"); | ||
329 | goto fail; | ||
330 | } | ||
331 | |||
332 | slave_mod->i2c = of_find_i2c_adapter_by_node(i2c_node); | ||
333 | if (!slave_mod->i2c) { | ||
334 | dev_err(&pdev->dev, "could not get i2c\n"); | ||
335 | goto fail; | ||
336 | } | ||
337 | |||
338 | of_node_put(i2c_node); | ||
339 | |||
340 | return 0; | ||
341 | |||
342 | fail: | ||
343 | slave_destroy(mod); | ||
344 | return ret; | ||
345 | } | ||
346 | |||
347 | static int slave_remove(struct platform_device *pdev) | ||
348 | { | ||
349 | return 0; | ||
350 | } | ||
351 | |||
352 | static struct of_device_id slave_of_match[] = { | ||
353 | { .compatible = "ti,tilcdc,slave", }, | ||
354 | { }, | ||
355 | }; | ||
356 | MODULE_DEVICE_TABLE(of, slave_of_match); | ||
357 | |||
358 | struct platform_driver slave_driver = { | ||
359 | .probe = slave_probe, | ||
360 | .remove = slave_remove, | ||
361 | .driver = { | ||
362 | .owner = THIS_MODULE, | ||
363 | .name = "slave", | ||
364 | .of_match_table = slave_of_match, | ||
365 | }, | ||
366 | }; | ||
367 | |||
368 | int __init tilcdc_slave_init(void) | ||
369 | { | ||
370 | return platform_driver_register(&slave_driver); | ||
371 | } | ||
372 | |||
373 | void __exit tilcdc_slave_fini(void) | ||
374 | { | ||
375 | platform_driver_unregister(&slave_driver); | ||
376 | } | ||
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_slave.h b/drivers/gpu/drm/tilcdc/tilcdc_slave.h new file mode 100644 index 000000000000..2f8504848320 --- /dev/null +++ b/drivers/gpu/drm/tilcdc/tilcdc_slave.h | |||
@@ -0,0 +1,26 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2012 Texas Instruments | ||
3 | * Author: Rob Clark <robdclark@gmail.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 | #ifndef __TILCDC_SLAVE_H__ | ||
19 | #define __TILCDC_SLAVE_H__ | ||
20 | |||
21 | /* sub-module for i2c slave encoder output */ | ||
22 | |||
23 | int tilcdc_slave_init(void); | ||
24 | void tilcdc_slave_fini(void); | ||
25 | |||
26 | #endif /* __TILCDC_SLAVE_H__ */ | ||