1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright 2008 by Nathan Whitehorn. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD$
28 */
29
30/*
31 * Driver for MacIO GPIO controller
32 */
33
34#include <sys/param.h>
35#include <sys/systm.h>
36#include <sys/kernel.h>
37#include <sys/malloc.h>
38#include <sys/module.h>
39#include <sys/bus.h>
40#include <sys/rman.h>
41
42#include <vm/vm.h>
43#include <vm/pmap.h>
44
45#include <machine/bus.h>
46#include <machine/intr_machdep.h>
47#include <machine/resource.h>
48#include <machine/vmparam.h>
49
50#include <dev/ofw/ofw_bus.h>
51#include <dev/ofw/ofw_bus_subr.h>
52#include <dev/ofw/openfirm.h>
53
54#include <powerpc/powermac/macgpiovar.h>
55
56/*
57 * Macgpio softc
58 */
59struct macgpio_softc {
60	phandle_t	sc_node;
61	struct resource	*sc_gpios;
62	int		sc_gpios_rid;
63	uint32_t	sc_saved_gpio_levels[2];
64	uint32_t	sc_saved_gpios[GPIO_COUNT];
65	uint32_t	sc_saved_extint_gpios[GPIO_EXTINT_COUNT];
66};
67
68static MALLOC_DEFINE(M_MACGPIO, "macgpio", "macgpio device information");
69
70static int	macgpio_probe(device_t);
71static int	macgpio_attach(device_t);
72static int	macgpio_print_child(device_t dev, device_t child);
73static void	macgpio_probe_nomatch(device_t, device_t);
74static struct resource *macgpio_alloc_resource(device_t, device_t, int, int *,
75		    rman_res_t, rman_res_t, rman_res_t, u_int);
76static int	macgpio_activate_resource(device_t, device_t, int, int,
77		    struct resource *);
78static int	macgpio_deactivate_resource(device_t, device_t, int, int,
79		    struct resource *);
80static ofw_bus_get_devinfo_t macgpio_get_devinfo;
81static int	macgpio_suspend(device_t dev);
82static int	macgpio_resume(device_t dev);
83
84/*
85 * Bus interface definition
86 */
87static device_method_t macgpio_methods[] = {
88	/* Device interface */
89	DEVMETHOD(device_probe,         macgpio_probe),
90	DEVMETHOD(device_attach,        macgpio_attach),
91	DEVMETHOD(device_detach,        bus_generic_detach),
92	DEVMETHOD(device_shutdown,      bus_generic_shutdown),
93	DEVMETHOD(device_suspend,       macgpio_suspend),
94	DEVMETHOD(device_resume,        macgpio_resume),
95
96	/* Bus interface */
97	DEVMETHOD(bus_print_child,      macgpio_print_child),
98	DEVMETHOD(bus_probe_nomatch,    macgpio_probe_nomatch),
99	DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
100	DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
101
102        DEVMETHOD(bus_alloc_resource,   macgpio_alloc_resource),
103        DEVMETHOD(bus_activate_resource, macgpio_activate_resource),
104        DEVMETHOD(bus_deactivate_resource, macgpio_deactivate_resource),
105        DEVMETHOD(bus_release_resource, bus_generic_release_resource),
106
107	DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
108
109	/* ofw_bus interface */
110	DEVMETHOD(ofw_bus_get_devinfo,	macgpio_get_devinfo),
111	DEVMETHOD(ofw_bus_get_compat,	ofw_bus_gen_get_compat),
112	DEVMETHOD(ofw_bus_get_model,	ofw_bus_gen_get_model),
113	DEVMETHOD(ofw_bus_get_name,	ofw_bus_gen_get_name),
114	DEVMETHOD(ofw_bus_get_node,	ofw_bus_gen_get_node),
115	DEVMETHOD(ofw_bus_get_type,	ofw_bus_gen_get_type),
116
117	{ 0, 0 }
118};
119
120static driver_t macgpio_pci_driver = {
121        "macgpio",
122        macgpio_methods,
123	sizeof(struct macgpio_softc)
124};
125
126devclass_t macgpio_devclass;
127
128DRIVER_MODULE(macgpio, macio, macgpio_pci_driver, macgpio_devclass, 0, 0);
129
130struct macgpio_devinfo {
131	struct ofw_bus_devinfo mdi_obdinfo;
132	struct resource_list mdi_resources;
133
134	int gpio_num;
135};
136
137static int
138macgpio_probe(device_t dev)
139{
140	const char *name;
141
142	name = ofw_bus_get_name(dev);
143	if (name && strcmp(name, "gpio") == 0) {
144		device_set_desc(dev, "MacIO GPIO Controller");
145		return (0);
146	}
147
148        return (ENXIO);
149}
150
151/*
152 * Scan Open Firmware child nodes, and attach these as children
153 * of the macgpio bus
154 */
155static int
156macgpio_attach(device_t dev)
157{
158	struct macgpio_softc *sc;
159        struct macgpio_devinfo *dinfo;
160        phandle_t root, child, iparent;
161        device_t cdev;
162	uint32_t irq;
163
164	sc = device_get_softc(dev);
165	root = sc->sc_node = ofw_bus_get_node(dev);
166
167	sc->sc_gpios = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
168	    &sc->sc_gpios_rid, RF_ACTIVE);
169
170	/*
171	 * Iterate through the sub-devices
172	 */
173	for (child = OF_child(root); child != 0; child = OF_peer(child)) {
174		dinfo = malloc(sizeof(*dinfo), M_MACGPIO, M_WAITOK | M_ZERO);
175		if (ofw_bus_gen_setup_devinfo(&dinfo->mdi_obdinfo, child) !=
176		    0) {
177			free(dinfo, M_MACGPIO);
178			continue;
179		}
180
181		if (OF_getencprop(child, "reg", &dinfo->gpio_num,
182		    sizeof(dinfo->gpio_num)) != sizeof(dinfo->gpio_num)) {
183			/*
184			 * Some early GPIO controllers don't provide GPIO
185			 * numbers for GPIOs designed only to provide
186			 * interrupt resources.  We should still allow these
187			 * to attach, but with caution.
188			 */
189
190			dinfo->gpio_num = -1;
191		}
192
193		resource_list_init(&dinfo->mdi_resources);
194
195		if (OF_getencprop(child, "interrupts", &irq, sizeof(irq)) ==
196		    sizeof(irq)) {
197			OF_searchencprop(child, "interrupt-parent", &iparent,
198			    sizeof(iparent));
199			resource_list_add(&dinfo->mdi_resources, SYS_RES_IRQ,
200			    0, MAP_IRQ(iparent, irq), MAP_IRQ(iparent, irq),
201			    1);
202		}
203
204		/* Fix messed-up offsets */
205		if (dinfo->gpio_num > 0x50)
206			dinfo->gpio_num -= 0x50;
207
208		cdev = device_add_child(dev, NULL, -1);
209		if (cdev == NULL) {
210			device_printf(dev, "<%s>: device_add_child failed\n",
211			    dinfo->mdi_obdinfo.obd_name);
212			ofw_bus_gen_destroy_devinfo(&dinfo->mdi_obdinfo);
213			free(dinfo, M_MACGPIO);
214			continue;
215		}
216		device_set_ivars(cdev, dinfo);
217	}
218
219	return (bus_generic_attach(dev));
220}
221
222
223static int
224macgpio_print_child(device_t dev, device_t child)
225{
226        struct macgpio_devinfo *dinfo;
227        int retval = 0;
228
229        dinfo = device_get_ivars(child);
230
231        retval += bus_print_child_header(dev, child);
232
233	if (dinfo->gpio_num >= GPIO_BASE)
234		printf(" gpio %d", dinfo->gpio_num - GPIO_BASE);
235	else if (dinfo->gpio_num >= GPIO_EXTINT_BASE)
236		printf(" extint-gpio %d", dinfo->gpio_num - GPIO_EXTINT_BASE);
237	else if (dinfo->gpio_num >= 0)
238		printf(" addr 0x%02x", dinfo->gpio_num); /* should not happen */
239
240	resource_list_print_type(&dinfo->mdi_resources, "irq", SYS_RES_IRQ,
241	    "%jd");
242        retval += bus_print_child_footer(dev, child);
243
244        return (retval);
245}
246
247
248static void
249macgpio_probe_nomatch(device_t dev, device_t child)
250{
251        struct macgpio_devinfo *dinfo;
252	const char *type;
253
254	if (bootverbose) {
255		dinfo = device_get_ivars(child);
256
257		if ((type = ofw_bus_get_type(child)) == NULL)
258			type = "(unknown)";
259		device_printf(dev, "<%s, %s>", type, ofw_bus_get_name(child));
260		if (dinfo->gpio_num >= 0)
261			printf(" gpio %d",dinfo->gpio_num);
262		resource_list_print_type(&dinfo->mdi_resources, "irq",
263		    SYS_RES_IRQ, "%jd");
264		printf(" (no driver attached)\n");
265	}
266}
267
268
269static struct resource *
270macgpio_alloc_resource(device_t bus, device_t child, int type, int *rid,
271		     rman_res_t start, rman_res_t end, rman_res_t count,
272		     u_int flags)
273{
274	struct macgpio_devinfo *dinfo;
275
276	dinfo = device_get_ivars(child);
277
278	if (type != SYS_RES_IRQ)
279		return (NULL);
280
281	return (resource_list_alloc(&dinfo->mdi_resources, bus, child, type,
282	    rid, start, end, count, flags));
283}
284
285static int
286macgpio_activate_resource(device_t bus, device_t child, int type, int rid,
287			   struct resource *res)
288{
289	struct macgpio_softc *sc;
290	struct macgpio_devinfo *dinfo;
291	u_char val;
292
293	sc = device_get_softc(bus);
294	dinfo = device_get_ivars(child);
295
296	if (type != SYS_RES_IRQ)
297		return ENXIO;
298
299	if (dinfo->gpio_num >= 0) {
300		val = bus_read_1(sc->sc_gpios,dinfo->gpio_num);
301		val |= 0x80;
302		bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
303	}
304
305	return (bus_activate_resource(bus, type, rid, res));
306}
307
308
309static int
310macgpio_deactivate_resource(device_t bus, device_t child, int type, int rid,
311			  struct resource *res)
312{
313	struct macgpio_softc *sc;
314	struct macgpio_devinfo *dinfo;
315	u_char val;
316
317	sc = device_get_softc(bus);
318	dinfo = device_get_ivars(child);
319
320	if (type != SYS_RES_IRQ)
321		return ENXIO;
322
323	if (dinfo->gpio_num >= 0) {
324		val = bus_read_1(sc->sc_gpios,dinfo->gpio_num);
325		val &= ~0x80;
326		bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
327	}
328
329	return (bus_deactivate_resource(bus, type, rid, res));
330}
331
332uint8_t
333macgpio_read(device_t dev)
334{
335	struct macgpio_softc *sc;
336	struct macgpio_devinfo *dinfo;
337
338	sc = device_get_softc(device_get_parent(dev));
339	dinfo = device_get_ivars(dev);
340
341	if (dinfo->gpio_num < 0)
342		return (0);
343
344	return (bus_read_1(sc->sc_gpios,dinfo->gpio_num));
345}
346
347void
348macgpio_write(device_t dev, uint8_t val)
349{
350	struct macgpio_softc *sc;
351	struct macgpio_devinfo *dinfo;
352
353	sc = device_get_softc(device_get_parent(dev));
354	dinfo = device_get_ivars(dev);
355
356	if (dinfo->gpio_num < 0)
357		return;
358
359	bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
360}
361
362static const struct ofw_bus_devinfo *
363macgpio_get_devinfo(device_t dev, device_t child)
364{
365	struct macgpio_devinfo *dinfo;
366
367	dinfo = device_get_ivars(child);
368	return (&dinfo->mdi_obdinfo);
369}
370
371static int
372macgpio_suspend(device_t dev)
373{
374	struct macgpio_softc *sc;
375	int i;
376
377	sc = device_get_softc(dev);
378	sc->sc_saved_gpio_levels[0] = bus_read_4(sc->sc_gpios, GPIO_LEVELS_0);
379	sc->sc_saved_gpio_levels[1] = bus_read_4(sc->sc_gpios, GPIO_LEVELS_1);
380
381	for (i = 0; i < GPIO_COUNT; i++)
382		sc->sc_saved_gpios[i] = bus_read_1(sc->sc_gpios, GPIO_BASE + i);
383	for (i = 0; i < GPIO_EXTINT_COUNT; i++)
384		sc->sc_saved_extint_gpios[i] = bus_read_1(sc->sc_gpios, GPIO_EXTINT_BASE + i);
385
386	return (0);
387}
388
389static int
390macgpio_resume(device_t dev)
391{
392	struct macgpio_softc *sc;
393	int i;
394
395	sc = device_get_softc(dev);
396	bus_write_4(sc->sc_gpios, GPIO_LEVELS_0, sc->sc_saved_gpio_levels[0]);
397	bus_write_4(sc->sc_gpios, GPIO_LEVELS_1, sc->sc_saved_gpio_levels[1]);
398
399	for (i = 0; i < GPIO_COUNT; i++)
400		bus_write_1(sc->sc_gpios, GPIO_BASE + i, sc->sc_saved_gpios[i]);
401	for (i = 0; i < GPIO_EXTINT_COUNT; i++)
402		bus_write_1(sc->sc_gpios, GPIO_EXTINT_BASE + i, sc->sc_saved_extint_gpios[i]);
403
404	return (0);
405}
406