[go: nahoru, domu]
1/*
2 * Copyright (C) 2012 Avionic Design GmbH
3 * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 */
9
10#include <linux/of_gpio.h>
11
12#include <drm/drm_panel.h>
13#include "drm.h"
14
15static int tegra_connector_get_modes(struct drm_connector *connector)
16{
17	struct tegra_output *output = connector_to_output(connector);
18	struct edid *edid = NULL;
19	int err = 0;
20
21	/*
22	 * If the panel provides one or more modes, use them exclusively and
23	 * ignore any other means of obtaining a mode.
24	 */
25	if (output->panel) {
26		err = output->panel->funcs->get_modes(output->panel);
27		if (err > 0)
28			return err;
29	}
30
31	if (output->edid)
32		edid = kmemdup(output->edid, sizeof(*edid), GFP_KERNEL);
33	else if (output->ddc)
34		edid = drm_get_edid(connector, output->ddc);
35
36	drm_mode_connector_update_edid_property(connector, edid);
37
38	if (edid) {
39		err = drm_add_edid_modes(connector, edid);
40		kfree(edid);
41	}
42
43	return err;
44}
45
46static int tegra_connector_mode_valid(struct drm_connector *connector,
47				      struct drm_display_mode *mode)
48{
49	struct tegra_output *output = connector_to_output(connector);
50	enum drm_mode_status status = MODE_OK;
51	int err;
52
53	err = tegra_output_check_mode(output, mode, &status);
54	if (err < 0)
55		return MODE_ERROR;
56
57	return status;
58}
59
60static struct drm_encoder *
61tegra_connector_best_encoder(struct drm_connector *connector)
62{
63	struct tegra_output *output = connector_to_output(connector);
64
65	return &output->encoder;
66}
67
68static const struct drm_connector_helper_funcs connector_helper_funcs = {
69	.get_modes = tegra_connector_get_modes,
70	.mode_valid = tegra_connector_mode_valid,
71	.best_encoder = tegra_connector_best_encoder,
72};
73
74static enum drm_connector_status
75tegra_connector_detect(struct drm_connector *connector, bool force)
76{
77	struct tegra_output *output = connector_to_output(connector);
78	enum drm_connector_status status = connector_status_unknown;
79
80	if (output->ops->detect)
81		return output->ops->detect(output);
82
83	if (gpio_is_valid(output->hpd_gpio)) {
84		if (gpio_get_value(output->hpd_gpio) == 0)
85			status = connector_status_disconnected;
86		else
87			status = connector_status_connected;
88	} else {
89		if (!output->panel)
90			status = connector_status_disconnected;
91		else
92			status = connector_status_connected;
93
94		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
95			status = connector_status_connected;
96	}
97
98	return status;
99}
100
101static void drm_connector_clear(struct drm_connector *connector)
102{
103	memset(connector, 0, sizeof(*connector));
104}
105
106static void tegra_connector_destroy(struct drm_connector *connector)
107{
108	drm_connector_unregister(connector);
109	drm_connector_cleanup(connector);
110	drm_connector_clear(connector);
111}
112
113static const struct drm_connector_funcs connector_funcs = {
114	.dpms = drm_helper_connector_dpms,
115	.detect = tegra_connector_detect,
116	.fill_modes = drm_helper_probe_single_connector_modes,
117	.destroy = tegra_connector_destroy,
118};
119
120static void drm_encoder_clear(struct drm_encoder *encoder)
121{
122	memset(encoder, 0, sizeof(*encoder));
123}
124
125static void tegra_encoder_destroy(struct drm_encoder *encoder)
126{
127	drm_encoder_cleanup(encoder);
128	drm_encoder_clear(encoder);
129}
130
131static const struct drm_encoder_funcs encoder_funcs = {
132	.destroy = tegra_encoder_destroy,
133};
134
135static void tegra_encoder_dpms(struct drm_encoder *encoder, int mode)
136{
137	struct tegra_output *output = encoder_to_output(encoder);
138	struct drm_panel *panel = output->panel;
139
140	if (mode != DRM_MODE_DPMS_ON) {
141		drm_panel_disable(panel);
142		tegra_output_disable(output);
143		drm_panel_unprepare(panel);
144	} else {
145		drm_panel_prepare(panel);
146		tegra_output_enable(output);
147		drm_panel_enable(panel);
148	}
149}
150
151static bool tegra_encoder_mode_fixup(struct drm_encoder *encoder,
152				     const struct drm_display_mode *mode,
153				     struct drm_display_mode *adjusted)
154{
155	return true;
156}
157
158static void tegra_encoder_prepare(struct drm_encoder *encoder)
159{
160}
161
162static void tegra_encoder_commit(struct drm_encoder *encoder)
163{
164}
165
166static void tegra_encoder_mode_set(struct drm_encoder *encoder,
167				   struct drm_display_mode *mode,
168				   struct drm_display_mode *adjusted)
169{
170	struct tegra_output *output = encoder_to_output(encoder);
171	int err;
172
173	err = tegra_output_enable(output);
174	if (err < 0)
175		dev_err(encoder->dev->dev, "tegra_output_enable(): %d\n", err);
176}
177
178static const struct drm_encoder_helper_funcs encoder_helper_funcs = {
179	.dpms = tegra_encoder_dpms,
180	.mode_fixup = tegra_encoder_mode_fixup,
181	.prepare = tegra_encoder_prepare,
182	.commit = tegra_encoder_commit,
183	.mode_set = tegra_encoder_mode_set,
184};
185
186static irqreturn_t hpd_irq(int irq, void *data)
187{
188	struct tegra_output *output = data;
189
190	drm_helper_hpd_irq_event(output->connector.dev);
191
192	return IRQ_HANDLED;
193}
194
195int tegra_output_probe(struct tegra_output *output)
196{
197	struct device_node *ddc, *panel;
198	enum of_gpio_flags flags;
199	int err, size;
200
201	if (!output->of_node)
202		output->of_node = output->dev->of_node;
203
204	panel = of_parse_phandle(output->of_node, "nvidia,panel", 0);
205	if (panel) {
206		output->panel = of_drm_find_panel(panel);
207		if (!output->panel)
208			return -EPROBE_DEFER;
209
210		of_node_put(panel);
211	}
212
213	output->edid = of_get_property(output->of_node, "nvidia,edid", &size);
214
215	ddc = of_parse_phandle(output->of_node, "nvidia,ddc-i2c-bus", 0);
216	if (ddc) {
217		output->ddc = of_find_i2c_adapter_by_node(ddc);
218		if (!output->ddc) {
219			err = -EPROBE_DEFER;
220			of_node_put(ddc);
221			return err;
222		}
223
224		of_node_put(ddc);
225	}
226
227	output->hpd_gpio = of_get_named_gpio_flags(output->of_node,
228						   "nvidia,hpd-gpio", 0,
229						   &flags);
230	if (gpio_is_valid(output->hpd_gpio)) {
231		unsigned long flags;
232
233		err = gpio_request_one(output->hpd_gpio, GPIOF_DIR_IN,
234				       "HDMI hotplug detect");
235		if (err < 0) {
236			dev_err(output->dev, "gpio_request_one(): %d\n", err);
237			return err;
238		}
239
240		err = gpio_to_irq(output->hpd_gpio);
241		if (err < 0) {
242			dev_err(output->dev, "gpio_to_irq(): %d\n", err);
243			gpio_free(output->hpd_gpio);
244			return err;
245		}
246
247		output->hpd_irq = err;
248
249		flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
250			IRQF_ONESHOT;
251
252		err = request_threaded_irq(output->hpd_irq, NULL, hpd_irq,
253					   flags, "hpd", output);
254		if (err < 0) {
255			dev_err(output->dev, "failed to request IRQ#%u: %d\n",
256				output->hpd_irq, err);
257			gpio_free(output->hpd_gpio);
258			return err;
259		}
260
261		output->connector.polled = DRM_CONNECTOR_POLL_HPD;
262	}
263
264	return 0;
265}
266
267int tegra_output_remove(struct tegra_output *output)
268{
269	if (gpio_is_valid(output->hpd_gpio)) {
270		free_irq(output->hpd_irq, output);
271		gpio_free(output->hpd_gpio);
272	}
273
274	if (output->ddc)
275		put_device(&output->ddc->dev);
276
277	return 0;
278}
279
280int tegra_output_init(struct drm_device *drm, struct tegra_output *output)
281{
282	int connector, encoder;
283
284	switch (output->type) {
285	case TEGRA_OUTPUT_RGB:
286		connector = DRM_MODE_CONNECTOR_LVDS;
287		encoder = DRM_MODE_ENCODER_LVDS;
288		break;
289
290	case TEGRA_OUTPUT_HDMI:
291		connector = DRM_MODE_CONNECTOR_HDMIA;
292		encoder = DRM_MODE_ENCODER_TMDS;
293		break;
294
295	case TEGRA_OUTPUT_DSI:
296		connector = DRM_MODE_CONNECTOR_DSI;
297		encoder = DRM_MODE_ENCODER_DSI;
298		break;
299
300	case TEGRA_OUTPUT_EDP:
301		connector = DRM_MODE_CONNECTOR_eDP;
302		encoder = DRM_MODE_ENCODER_TMDS;
303		break;
304
305	default:
306		connector = DRM_MODE_CONNECTOR_Unknown;
307		encoder = DRM_MODE_ENCODER_NONE;
308		break;
309	}
310
311	drm_connector_init(drm, &output->connector, &connector_funcs,
312			   connector);
313	drm_connector_helper_add(&output->connector, &connector_helper_funcs);
314	output->connector.dpms = DRM_MODE_DPMS_OFF;
315
316	if (output->panel)
317		drm_panel_attach(output->panel, &output->connector);
318
319	drm_encoder_init(drm, &output->encoder, &encoder_funcs, encoder);
320	drm_encoder_helper_add(&output->encoder, &encoder_helper_funcs);
321
322	drm_mode_connector_attach_encoder(&output->connector, &output->encoder);
323	drm_connector_register(&output->connector);
324
325	output->encoder.possible_crtcs = 0x3;
326
327	return 0;
328}
329
330int tegra_output_exit(struct tegra_output *output)
331{
332	return 0;
333}
334