1/* $NetBSD: sunxi_dwhdmi.c,v 1.11 2021/12/19 11:01:10 riastradh Exp $ */
2
3/*-
4 * Copyright (c) 2019 Jared D. McNeill <jmcneill@invisible.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__KERNEL_RCSID(0, "$NetBSD: sunxi_dwhdmi.c,v 1.11 2021/12/19 11:01:10 riastradh Exp $");
31
32#include <sys/param.h>
33#include <sys/bus.h>
34#include <sys/conf.h>
35#include <sys/device.h>
36#include <sys/intr.h>
37#include <sys/kernel.h>
38#include <sys/systm.h>
39
40#include <dev/fdt/fdt_port.h>
41#include <dev/fdt/fdtvar.h>
42
43#include <dev/ic/dw_hdmi.h>
44
45#include <arm/sunxi/sunxi_hdmiphy.h>
46
47#include <drm/drm_drv.h>
48
49enum {
50	DWHDMI_PORT_INPUT = 0,
51	DWHDMI_PORT_OUTPUT = 1,
52};
53
54static const struct device_compatible_entry compat_data[] = {
55	{ .compat = "allwinner,sun8i-h3-dw-hdmi" },
56	{ .compat = "allwinner,sun50i-a64-dw-hdmi" },
57	DEVICE_COMPAT_EOL
58};
59
60struct sunxi_dwhdmi_softc {
61	struct dwhdmi_softc	sc_base;
62	int			sc_phandle;
63	struct fdtbus_phy	*sc_phy;
64	struct fdtbus_regulator	*sc_regulator;
65	struct clk		*sc_clk;
66
67	struct fdt_device_ports	sc_ports;
68	struct drm_display_mode	sc_curmode;
69};
70
71#define	to_sunxi_dwhdmi_softc(x)	container_of(x, struct sunxi_dwhdmi_softc, sc_base)
72
73static int
74sunxi_dwhdmi_ep_activate(device_t dev, struct fdt_endpoint *ep, bool activate)
75{
76	struct sunxi_dwhdmi_softc * const sc = device_private(dev);
77	struct fdt_endpoint *in_ep = fdt_endpoint_remote(ep);
78	struct fdt_endpoint *out_ep, *out_rep;
79	struct drm_encoder *encoder;
80	struct drm_bridge *bridge;
81	int error;
82
83	if (!activate)
84		return EINVAL;
85
86	if (fdt_endpoint_port_index(ep) != DWHDMI_PORT_INPUT)
87		return EINVAL;
88
89	switch (fdt_endpoint_type(in_ep)) {
90	case EP_DRM_ENCODER:
91		encoder = fdt_endpoint_get_data(in_ep);
92		break;
93	case EP_DRM_BRIDGE:
94		bridge = fdt_endpoint_get_data(in_ep);
95		encoder = bridge->encoder;
96		break;
97	default:
98		encoder = NULL;
99		break;
100	}
101
102	if (encoder == NULL)
103		return EINVAL;
104
105	if (sc->sc_regulator != NULL) {
106		error = fdtbus_regulator_enable(sc->sc_regulator);
107		if (error != 0) {
108			device_printf(dev, "couldn't enable supply\n");
109			return error;
110		}
111	}
112
113	error = dwhdmi_bind(&sc->sc_base, encoder);
114	if (error != 0)
115		return error;
116
117	out_ep = fdt_endpoint_get_from_index(&sc->sc_ports, DWHDMI_PORT_OUTPUT, 0);
118	if (out_ep != NULL) {
119		/* Ignore downstream connectors, we have our own. */
120		out_rep = fdt_endpoint_remote(out_ep);
121		if (out_rep != NULL && fdt_endpoint_type(out_rep) == EP_DRM_CONNECTOR)
122			return 0;
123
124		error = fdt_endpoint_activate(out_ep, activate);
125		if (error != 0)
126			return error;
127	}
128
129	return 0;
130}
131
132static void *
133sunxi_dwhdmi_ep_get_data(device_t dev, struct fdt_endpoint *ep)
134{
135	struct sunxi_dwhdmi_softc * const sc = device_private(dev);
136
137	return &sc->sc_base.sc_bridge;
138}
139
140static enum drm_connector_status
141sunxi_dwhdmi_detect(struct dwhdmi_softc *dsc, bool force)
142{
143	struct sunxi_dwhdmi_softc * const sc = to_sunxi_dwhdmi_softc(dsc);
144
145	KASSERT(sc->sc_phy != NULL);
146
147	if (sunxi_hdmiphy_detect(sc->sc_phy, force))
148		return connector_status_connected;
149	else
150		return connector_status_disconnected;
151}
152
153static void
154sunxi_dwhdmi_enable(struct dwhdmi_softc *dsc)
155{
156	struct sunxi_dwhdmi_softc * const sc = to_sunxi_dwhdmi_softc(dsc);
157	int error;
158
159	KASSERT(sc->sc_phy != NULL);
160
161	error = fdtbus_phy_enable(sc->sc_phy, true);
162	if (error != 0) {
163		device_printf(dsc->sc_dev, "failed to enable phy: %d\n", error);
164		return;
165	}
166
167	error = sunxi_hdmiphy_config(sc->sc_phy, &sc->sc_curmode);
168	if (error != 0)
169		device_printf(dsc->sc_dev, "failed to configure phy: %d\n", error);
170}
171
172static void
173sunxi_dwhdmi_disable(struct dwhdmi_softc *dsc)
174{
175	struct sunxi_dwhdmi_softc * const sc = to_sunxi_dwhdmi_softc(dsc);
176	int error;
177
178	KASSERT(sc->sc_phy != NULL);
179
180	error = fdtbus_phy_enable(sc->sc_phy, false);
181	if (error != 0)
182		device_printf(dsc->sc_dev, "failed to disable phy\n");
183}
184
185static void
186sunxi_dwhdmi_mode_set(struct dwhdmi_softc *dsc,
187    const struct drm_display_mode *mode,
188    const struct drm_display_mode *adjusted_mode)
189{
190	struct sunxi_dwhdmi_softc * const sc = to_sunxi_dwhdmi_softc(dsc);
191	int error;
192
193	if (sc->sc_clk != NULL) {
194		error = clk_set_rate(sc->sc_clk, adjusted_mode->clock * 1000);
195		if (error != 0)
196			device_printf(sc->sc_base.sc_dev,
197			    "couldn't set pixel clock to %u Hz: %d\n",
198			    adjusted_mode->clock * 1000, error);
199	}
200
201	sc->sc_curmode = *adjusted_mode;
202}
203
204static audio_dai_tag_t
205sunxi_dwhdmi_dai_get_tag(device_t dev, const void *data, size_t len)
206{
207	struct sunxi_dwhdmi_softc * const sc = device_private(dev);
208
209	if (len != 4)
210		return NULL;
211
212	return &sc->sc_base.sc_dai;
213}
214
215static struct fdtbus_dai_controller_func sunxi_dwhdmi_dai_funcs = {
216	.get_tag = sunxi_dwhdmi_dai_get_tag
217};
218
219static int
220sunxi_dwhdmi_match(device_t parent, cfdata_t cf, void *aux)
221{
222	struct fdt_attach_args * const faa = aux;
223
224	return of_compatible_match(faa->faa_phandle, compat_data);
225}
226
227static void
228sunxi_dwhdmi_attach(device_t parent, device_t self, void *aux)
229{
230	struct sunxi_dwhdmi_softc * const sc = device_private(self);
231	struct fdt_attach_args * const faa = aux;
232	prop_dictionary_t prop = device_properties(self);
233	const int phandle = faa->faa_phandle;
234	struct clk *clk_iahb, *clk_isfr, *clk_tmds;
235	struct fdtbus_reset *rst;
236	bool is_disabled;
237	bus_addr_t addr;
238	bus_size_t size;
239
240	if (prop_dictionary_get_bool(prop, "disabled", &is_disabled) && is_disabled) {
241		aprint_naive("\n");
242		aprint_normal(": HDMI TX (disabled)\n");
243		return;
244	}
245
246	if (fdtbus_get_reg(phandle, 0, &addr, &size) != 0) {
247		aprint_error(": couldn't get registers\n");
248		return;
249	}
250
251	clk_iahb = fdtbus_clock_get(phandle, "iahb");
252	if (clk_iahb == NULL || clk_enable(clk_iahb) != 0) {
253		aprint_error(": couldn't enable iahb clock\n");
254		return;
255	}
256
257	clk_isfr = fdtbus_clock_get(phandle, "isfr");
258	if (clk_isfr == NULL || clk_enable(clk_isfr) != 0) {
259		aprint_error(": couldn't enable isfr clock\n");
260		return;
261	}
262
263	clk_tmds = fdtbus_clock_get(phandle, "tmds");
264	if (clk_tmds == NULL || clk_enable(clk_tmds) != 0) {
265		aprint_error(": couldn't enable tmds clock\n");
266		return;
267	}
268
269	sc->sc_base.sc_dev = self;
270	sc->sc_base.sc_reg_width = 1;
271	sc->sc_base.sc_bst = faa->faa_bst;
272	if (bus_space_map(sc->sc_base.sc_bst, addr, size, 0, &sc->sc_base.sc_bsh) != 0) {
273		aprint_error(": couldn't map registers\n");
274		return;
275	}
276	sc->sc_base.sc_detect = sunxi_dwhdmi_detect;
277	sc->sc_base.sc_enable = sunxi_dwhdmi_enable;
278	sc->sc_base.sc_disable = sunxi_dwhdmi_disable;
279	sc->sc_base.sc_mode_set = sunxi_dwhdmi_mode_set;
280	sc->sc_base.sc_scl_hcnt = 0xd8;
281	sc->sc_base.sc_scl_lcnt = 0xfe;
282	sc->sc_phandle = faa->faa_phandle;
283	sc->sc_clk = clk_tmds;
284
285	aprint_naive("\n");
286	aprint_normal(": HDMI TX\n");
287
288	sc->sc_regulator = fdtbus_regulator_acquire(sc->sc_phandle, "hvcc-supply");
289
290	sc->sc_phy = fdtbus_phy_get(sc->sc_phandle, "hdmi-phy");
291	if (sc->sc_phy == NULL)
292		sc->sc_phy = fdtbus_phy_get(sc->sc_phandle, "phy");
293	if (sc->sc_phy == NULL) {
294		device_printf(self, "couldn't find PHY\n");
295		return;
296	}
297
298	rst = fdtbus_reset_get(phandle, "ctrl");
299	if (rst == NULL || fdtbus_reset_deassert(rst) != 0) {
300		aprint_error_dev(self, "couldn't de-assert reset\n");
301		return;
302	}
303
304	sunxi_hdmiphy_init(sc->sc_phy);
305
306	if (dwhdmi_attach(&sc->sc_base) != 0) {
307		aprint_error_dev(self, "failed to attach driver\n");
308		return;
309	}
310
311	sc->sc_ports.dp_ep_activate = sunxi_dwhdmi_ep_activate;
312	sc->sc_ports.dp_ep_get_data = sunxi_dwhdmi_ep_get_data;
313	fdt_ports_register(&sc->sc_ports, self, phandle, EP_DRM_BRIDGE);
314
315	fdtbus_register_dai_controller(self, phandle, &sunxi_dwhdmi_dai_funcs);
316}
317
318CFATTACH_DECL_NEW(sunxi_dwhdmi, sizeof(struct sunxi_dwhdmi_softc),
319	sunxi_dwhdmi_match, sunxi_dwhdmi_attach, NULL, NULL);
320