ofw_gpiobus.c revision 266105 
1/*-
2 * Copyright (c) 2009, Nathan Whitehorn <nwhitehorn@FreeBSD.org>
3 * Copyright (c) 2013, Luiz Otavio O Souza <loos@FreeBSD.org>
4 * Copyright (c) 2013 The FreeBSD Foundation
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 unmodified, this list of conditions, and the following
12 *    disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: stable/10/sys/dev/gpio/ofw_gpiobus.c 266105 2014-05-15 01:27:53Z loos $");
31
32#include <sys/param.h>
33#include <sys/bus.h>
34#include <sys/gpio.h>
35#include <sys/kernel.h>
36#include <sys/libkern.h>
37#include <sys/lock.h>
38#include <sys/module.h>
39#include <sys/mutex.h>
40
41#include <dev/gpio/gpiobusvar.h>
42#include <dev/ofw/ofw_bus.h>
43#include <dev/ofw/openfirm.h>
44
45#include <machine/resource.h>
46
47#include "gpio_if.h"
48#include "gpiobus_if.h"
49
50struct ofw_gpiobus_devinfo {
51	struct gpiobus_ivar	opd_dinfo;
52	struct ofw_bus_devinfo	opd_obdinfo;
53};
54
55static int ofw_gpiobus_parse_gpios(struct gpiobus_softc *,
56    struct gpiobus_ivar *, phandle_t);
57static struct ofw_gpiobus_devinfo *ofw_gpiobus_setup_devinfo(device_t,
58    phandle_t);
59static void ofw_gpiobus_destroy_devinfo(struct ofw_gpiobus_devinfo *);
60
61device_t
62ofw_gpiobus_add_fdt_child(device_t bus, phandle_t child)
63{
64	struct ofw_gpiobus_devinfo *dinfo;
65	device_t childdev;
66
67	/*
68	 * Set up the GPIO child and OFW bus layer devinfo and add it to bus.
69	 */
70	dinfo = ofw_gpiobus_setup_devinfo(bus, child);
71	if (dinfo == NULL)
72		return (NULL);
73	childdev = device_add_child(bus, NULL, -1);
74	if (childdev == NULL) {
75		device_printf(bus, "could not add child: %s\n",
76		    dinfo->opd_obdinfo.obd_name);
77		ofw_gpiobus_destroy_devinfo(dinfo);
78		return (NULL);
79	}
80	device_set_ivars(childdev, dinfo);
81
82	return (childdev);
83}
84
85static int
86ofw_gpiobus_parse_gpios(struct gpiobus_softc *sc, struct gpiobus_ivar *dinfo,
87	phandle_t child)
88{
89	int i, len;
90	pcell_t *gpios;
91	phandle_t gpio;
92
93	/* Retrieve the gpios property. */
94	if ((len = OF_getproplen(child, "gpios")) < 0)
95		return (EINVAL);
96	gpios = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
97	if (gpios == NULL)
98		return (ENOMEM);
99	if (OF_getencprop(child, "gpios", gpios, len) < 0) {
100		free(gpios, M_DEVBUF);
101		return (EINVAL);
102	}
103
104	/*
105	 * Each 'gpios' entry must contain 4 pcells.
106	 * The first one is the GPIO controller phandler.
107	 * Then the last three are the GPIO pin, the GPIO pin direction and
108	 * the GPIO pin flags.
109	 */
110	if ((len / sizeof(pcell_t)) % 4) {
111		free(gpios, M_DEVBUF);
112		return (EINVAL);
113	}
114	dinfo->npins = len / (sizeof(pcell_t) * 4);
115	dinfo->pins = malloc(sizeof(uint32_t) * dinfo->npins, M_DEVBUF,
116	    M_NOWAIT | M_ZERO);
117	if (dinfo->pins == NULL) {
118		free(gpios, M_DEVBUF);
119		return (ENOMEM);
120	}
121
122	for (i = 0; i < dinfo->npins; i++) {
123
124		/* Verify if we're attaching to the correct gpio controller. */
125		gpio = OF_xref_phandle(gpios[i * 4 + 0]);
126		if (!OF_hasprop(gpio, "gpio-controller") ||
127		    gpio != ofw_bus_get_node(sc->sc_dev)) {
128			free(dinfo->pins, M_DEVBUF);
129			free(gpios, M_DEVBUF);
130			return (EINVAL);
131		}
132
133		/* Get the GPIO pin number. */
134		dinfo->pins[i] = gpios[i * 4 + 1];
135		/* gpios[i * 4 + 2] - GPIO pin direction */
136		/* gpios[i * 4 + 3] - GPIO pin flags */
137
138		if (dinfo->pins[i] > sc->sc_npins) {
139			device_printf(sc->sc_busdev,
140			    "invalid pin %d, max: %d\n",
141			    dinfo->pins[i], sc->sc_npins - 1);
142			free(dinfo->pins, M_DEVBUF);
143			free(gpios, M_DEVBUF);
144			return (EINVAL);
145		}
146
147		/*
148		 * Mark pin as mapped and give warning if it's already mapped.
149		 */
150		if (sc->sc_pins_mapped[dinfo->pins[i]]) {
151			device_printf(sc->sc_busdev,
152			    "warning: pin %d is already mapped\n",
153			    dinfo->pins[i]);
154			free(dinfo->pins, M_DEVBUF);
155			free(gpios, M_DEVBUF);
156			return (EINVAL);
157		}
158		sc->sc_pins_mapped[dinfo->pins[i]] = 1;
159	}
160
161	free(gpios, M_DEVBUF);
162
163	return (0);
164}
165
166static struct ofw_gpiobus_devinfo *
167ofw_gpiobus_setup_devinfo(device_t dev, phandle_t node)
168{
169	struct gpiobus_softc *sc;
170	struct ofw_gpiobus_devinfo *dinfo;
171
172	sc = device_get_softc(dev);
173	dinfo = malloc(sizeof(*dinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
174	if (dinfo == NULL)
175		return (NULL);
176	if (ofw_bus_gen_setup_devinfo(&dinfo->opd_obdinfo, node) != 0) {
177		free(dinfo, M_DEVBUF);
178		return (NULL);
179	}
180
181	/* Parse the gpios property for the child. */
182	if (ofw_gpiobus_parse_gpios(sc, &dinfo->opd_dinfo, node) != 0) {
183		ofw_bus_gen_destroy_devinfo(&dinfo->opd_obdinfo);
184		free(dinfo, M_DEVBUF);
185		return (NULL);
186	}
187
188	return (dinfo);
189}
190
191static void
192ofw_gpiobus_destroy_devinfo(struct ofw_gpiobus_devinfo *dinfo)
193{
194
195	ofw_bus_gen_destroy_devinfo(&dinfo->opd_obdinfo);
196	free(dinfo, M_DEVBUF);
197}
198
199static int
200ofw_gpiobus_probe(device_t dev)
201{
202
203	if (ofw_bus_get_node(dev) == -1)
204		return (ENXIO);
205	device_set_desc(dev, "OFW GPIO bus");
206
207	return (0);
208}
209
210static int
211ofw_gpiobus_attach(device_t dev)
212{
213	struct gpiobus_softc *sc;
214	phandle_t child;
215
216	sc = GPIOBUS_SOFTC(dev);
217	sc->sc_busdev = dev;
218	sc->sc_dev = device_get_parent(dev);
219
220	/* Read the pin max. value */
221	if (GPIO_PIN_MAX(sc->sc_dev, &sc->sc_npins) != 0)
222		return (ENXIO);
223
224	KASSERT(sc->sc_npins != 0, ("GPIO device with no pins"));
225
226	/*
227	 * Increase to get number of pins.
228	 */
229	sc->sc_npins++;
230
231	sc->sc_pins_mapped = malloc(sizeof(int) * sc->sc_npins, M_DEVBUF,
232	    M_NOWAIT | M_ZERO);
233
234	if (!sc->sc_pins_mapped)
235		return (ENOMEM);
236
237	/* Init the bus lock. */
238	GPIOBUS_LOCK_INIT(sc);
239
240	bus_generic_probe(dev);
241	bus_enumerate_hinted_children(dev);
242
243	/*
244	 * Attach the children represented in the device tree.
245	 */
246	for (child = OF_child(ofw_bus_get_node(dev)); child != 0;
247	    child = OF_peer(child))
248		if (ofw_gpiobus_add_fdt_child(dev, child) == NULL)
249			continue;
250
251	return (bus_generic_attach(dev));
252}
253
254static device_t
255ofw_gpiobus_add_child(device_t dev, u_int order, const char *name, int unit)
256{
257	device_t child;
258	struct ofw_gpiobus_devinfo *devi;
259
260	child = device_add_child_ordered(dev, order, name, unit);
261	if (child == NULL)
262		return (child);
263	devi = malloc(sizeof(struct ofw_gpiobus_devinfo), M_DEVBUF,
264	    M_NOWAIT | M_ZERO);
265	if (devi == NULL) {
266		device_delete_child(dev, child);
267		return (0);
268	}
269
270	/*
271	 * NULL all the OFW-related parts of the ivars for non-OFW
272	 * children.
273	 */
274	devi->opd_obdinfo.obd_node = -1;
275	devi->opd_obdinfo.obd_name = NULL;
276	devi->opd_obdinfo.obd_compat = NULL;
277	devi->opd_obdinfo.obd_type = NULL;
278	devi->opd_obdinfo.obd_model = NULL;
279
280	device_set_ivars(child, devi);
281
282	return (child);
283}
284
285static int
286ofw_gpiobus_print_child(device_t dev, device_t child)
287{
288	struct ofw_gpiobus_devinfo *devi;
289	int retval = 0;
290
291	devi = device_get_ivars(child);
292	retval += bus_print_child_header(dev, child);
293	retval += printf(" at pin(s) ");
294	gpiobus_print_pins(&devi->opd_dinfo);
295	retval += bus_print_child_footer(dev, child);
296
297	return (retval);
298}
299
300static const struct ofw_bus_devinfo *
301ofw_gpiobus_get_devinfo(device_t bus, device_t dev)
302{
303	struct ofw_gpiobus_devinfo *dinfo;
304
305	dinfo = device_get_ivars(dev);
306
307	return (&dinfo->opd_obdinfo);
308}
309
310static device_method_t ofw_gpiobus_methods[] = {
311	/* Device interface */
312	DEVMETHOD(device_probe,		ofw_gpiobus_probe),
313	DEVMETHOD(device_attach,	ofw_gpiobus_attach),
314
315	/* Bus interface */
316	DEVMETHOD(bus_child_pnpinfo_str,	ofw_bus_gen_child_pnpinfo_str),
317	DEVMETHOD(bus_print_child,	ofw_gpiobus_print_child),
318	DEVMETHOD(bus_add_child,	ofw_gpiobus_add_child),
319
320	/* ofw_bus interface */
321	DEVMETHOD(ofw_bus_get_devinfo,	ofw_gpiobus_get_devinfo),
322	DEVMETHOD(ofw_bus_get_compat,	ofw_bus_gen_get_compat),
323	DEVMETHOD(ofw_bus_get_model,	ofw_bus_gen_get_model),
324	DEVMETHOD(ofw_bus_get_name,	ofw_bus_gen_get_name),
325	DEVMETHOD(ofw_bus_get_node,	ofw_bus_gen_get_node),
326	DEVMETHOD(ofw_bus_get_type,	ofw_bus_gen_get_type),
327
328	DEVMETHOD_END
329};
330
331static devclass_t ofwgpiobus_devclass;
332
333DEFINE_CLASS_1(gpiobus, ofw_gpiobus_driver, ofw_gpiobus_methods,
334    sizeof(struct gpiobus_softc), gpiobus_driver);
335DRIVER_MODULE(ofw_gpiobus, gpio, ofw_gpiobus_driver, ofwgpiobus_devclass, 0, 0);
336MODULE_VERSION(ofw_gpiobus, 1);
337MODULE_DEPEND(ofw_gpiobus, gpiobus, 1, 1, 1);
338