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 <drm/drm_atomic_helper.h>
 11#include <drm/drm_panel.h>
 12#include "drm.h"
 13
 14int tegra_output_connector_get_modes(struct drm_connector *connector)
 15{
 16	struct tegra_output *output = connector_to_output(connector);
 17	struct edid *edid = NULL;
 18	int err = 0;
 19
 20	/*
 21	 * If the panel provides one or more modes, use them exclusively and
 22	 * ignore any other means of obtaining a mode.
 23	 */
 24	if (output->panel) {
 25		err = output->panel->funcs->get_modes(output->panel);
 26		if (err > 0)
 27			return err;
 28	}
 29
 30	if (output->edid)
 31		edid = kmemdup(output->edid, sizeof(*edid), GFP_KERNEL);
 32	else if (output->ddc)
 33		edid = drm_get_edid(connector, output->ddc);
 34
 35	drm_mode_connector_update_edid_property(connector, edid);
 36
 37	if (edid) {
 38		err = drm_add_edid_modes(connector, edid);
 39		drm_edid_to_eld(connector, edid);
 40		kfree(edid);
 41	}
 42
 43	return err;
 44}
 45
 46enum drm_connector_status
 47tegra_output_connector_detect(struct drm_connector *connector, bool force)
 48{
 49	struct tegra_output *output = connector_to_output(connector);
 50	enum drm_connector_status status = connector_status_unknown;
 51
 52	if (gpio_is_valid(output->hpd_gpio)) {
 53		if (output->hpd_gpio_flags & OF_GPIO_ACTIVE_LOW) {
 54			if (gpio_get_value(output->hpd_gpio) != 0)
 55				status = connector_status_disconnected;
 56			else
 57				status = connector_status_connected;
 58		} else {
 59			if (gpio_get_value(output->hpd_gpio) == 0)
 60				status = connector_status_disconnected;
 61			else
 62				status = connector_status_connected;
 63		}
 64	} else {
 65		if (!output->panel)
 66			status = connector_status_disconnected;
 67		else
 68			status = connector_status_connected;
 69	}
 70
 71	return status;
 72}
 73
 74void tegra_output_connector_destroy(struct drm_connector *connector)
 75{
 76	drm_connector_unregister(connector);
 77	drm_connector_cleanup(connector);
 78}
 79
 80void tegra_output_encoder_destroy(struct drm_encoder *encoder)
 81{
 82	drm_encoder_cleanup(encoder);
 83}
 84
 85static irqreturn_t hpd_irq(int irq, void *data)
 86{
 87	struct tegra_output *output = data;
 88
 89	if (output->connector.dev)
 90		drm_helper_hpd_irq_event(output->connector.dev);
 91
 92	return IRQ_HANDLED;
 93}
 94
 95int tegra_output_probe(struct tegra_output *output)
 96{
 97	struct device_node *ddc, *panel;
 98	int err, size;
 99
100	if (!output->of_node)
101		output->of_node = output->dev->of_node;
102
103	panel = of_parse_phandle(output->of_node, "nvidia,panel", 0);
104	if (panel) {
105		output->panel = of_drm_find_panel(panel);
106		if (!output->panel)
107			return -EPROBE_DEFER;
108
109		of_node_put(panel);
110	}
111
112	output->edid = of_get_property(output->of_node, "nvidia,edid", &size);
113
114	ddc = of_parse_phandle(output->of_node, "nvidia,ddc-i2c-bus", 0);
115	if (ddc) {
116		output->ddc = of_find_i2c_adapter_by_node(ddc);
117		if (!output->ddc) {
118			err = -EPROBE_DEFER;
119			of_node_put(ddc);
120			return err;
121		}
122
123		of_node_put(ddc);
124	}
125
126	output->hpd_gpio = of_get_named_gpio_flags(output->of_node,
127						   "nvidia,hpd-gpio", 0,
128						   &output->hpd_gpio_flags);
129	if (gpio_is_valid(output->hpd_gpio)) {
130		unsigned long flags;
131
132		err = gpio_request_one(output->hpd_gpio, GPIOF_DIR_IN,
133				       "HDMI hotplug detect");
134		if (err < 0) {
135			dev_err(output->dev, "gpio_request_one(): %d\n", err);
136			return err;
137		}
138
139		err = gpio_to_irq(output->hpd_gpio);
140		if (err < 0) {
141			dev_err(output->dev, "gpio_to_irq(): %d\n", err);
142			gpio_free(output->hpd_gpio);
143			return err;
144		}
145
146		output->hpd_irq = err;
147
148		flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
149			IRQF_ONESHOT;
150
151		err = request_threaded_irq(output->hpd_irq, NULL, hpd_irq,
152					   flags, "hpd", output);
153		if (err < 0) {
154			dev_err(output->dev, "failed to request IRQ#%u: %d\n",
155				output->hpd_irq, err);
156			gpio_free(output->hpd_gpio);
157			return err;
158		}
159
160		output->connector.polled = DRM_CONNECTOR_POLL_HPD;
161
162		/*
163		 * Disable the interrupt until the connector has been
164		 * initialized to avoid a race in the hotplug interrupt
165		 * handler.
166		 */
167		disable_irq(output->hpd_irq);
168	}
169
170	return 0;
171}
172
173void tegra_output_remove(struct tegra_output *output)
174{
175	if (gpio_is_valid(output->hpd_gpio)) {
176		free_irq(output->hpd_irq, output);
177		gpio_free(output->hpd_gpio);
178	}
179
180	if (output->ddc)
181		put_device(&output->ddc->dev);
182}
183
184int tegra_output_init(struct drm_device *drm, struct tegra_output *output)
185{
186	int err;
187
188	if (output->panel) {
189		err = drm_panel_attach(output->panel, &output->connector);
190		if (err < 0)
191			return err;
192	}
193
194	/*
195	 * The connector is now registered and ready to receive hotplug events
196	 * so the hotplug interrupt can be enabled.
197	 */
198	if (gpio_is_valid(output->hpd_gpio))
199		enable_irq(output->hpd_irq);
200
201	return 0;
202}
203
204void tegra_output_exit(struct tegra_output *output)
205{
206	/*
207	 * The connector is going away, so the interrupt must be disabled to
208	 * prevent the hotplug interrupt handler from potentially crashing.
209	 */
210	if (gpio_is_valid(output->hpd_gpio))
211		disable_irq(output->hpd_irq);
212
213	if (output->panel)
214		drm_panel_detach(output->panel);
215}