1/*-
2 * Copyright (c) 2006 Marius Strobl <marius@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: releng/10.3/sys/dev/le/lebuffer_sbus.c 225931 2011-10-02 23:22:38Z marius $");
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/bus.h>
33#include <sys/kernel.h>
34#include <sys/module.h>
35#include <sys/resource.h>
36#include <sys/rman.h>
37
38#include <dev/ofw/ofw_bus.h>
39#include <dev/ofw/ofw_bus_subr.h>
40#include <dev/ofw/openfirm.h>
41
42#include <machine/bus.h>
43#include <machine/bus_common.h>
44#include <machine/resource.h>
45
46#include <sparc64/sbus/ofw_sbus.h>
47#include <sparc64/sbus/sbusreg.h>
48#include <sparc64/sbus/sbusvar.h>
49
50struct lebuffer_devinfo {
51	struct ofw_bus_devinfo	ldi_obdinfo;
52	struct resource_list	ldi_rl;
53};
54
55static devclass_t lebuffer_devclass;
56
57static device_probe_t lebuffer_probe;
58static device_attach_t lebuffer_attach;
59static device_detach_t lebuffer_detach;
60static bus_print_child_t lebuffer_print_child;
61static bus_probe_nomatch_t lebuffer_probe_nomatch;
62static bus_get_resource_list_t lebuffer_get_resource_list;
63static ofw_bus_get_devinfo_t lebuffer_get_devinfo;
64
65static struct lebuffer_devinfo *lebuffer_setup_dinfo(device_t, phandle_t);
66static void lebuffer_destroy_dinfo(struct lebuffer_devinfo *);
67static int lebuffer_print_res(struct lebuffer_devinfo *);
68
69static device_method_t lebuffer_methods[] = {
70	/* Device interface */
71	DEVMETHOD(device_probe,		lebuffer_probe),
72	DEVMETHOD(device_attach,	lebuffer_attach),
73	DEVMETHOD(device_detach,	lebuffer_detach),
74	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
75	DEVMETHOD(device_suspend,	bus_generic_suspend),
76	DEVMETHOD(device_resume,	bus_generic_resume),
77
78	/* Bus interface */
79	DEVMETHOD(bus_print_child,	lebuffer_print_child),
80	DEVMETHOD(bus_probe_nomatch,	lebuffer_probe_nomatch),
81	DEVMETHOD(bus_setup_intr,	bus_generic_setup_intr),
82	DEVMETHOD(bus_teardown_intr,	bus_generic_teardown_intr),
83	DEVMETHOD(bus_alloc_resource,	bus_generic_rl_alloc_resource),
84	DEVMETHOD(bus_adjust_resource,	bus_generic_adjust_resource),
85	DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource),
86	DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
87	DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
88	DEVMETHOD(bus_get_resource_list, lebuffer_get_resource_list),
89	DEVMETHOD(bus_get_resource,	bus_generic_rl_get_resource),
90
91	/* ofw_bus interface */
92	DEVMETHOD(ofw_bus_get_devinfo,	lebuffer_get_devinfo),
93	DEVMETHOD(ofw_bus_get_compat,	ofw_bus_gen_get_compat),
94	DEVMETHOD(ofw_bus_get_model,	ofw_bus_gen_get_model),
95	DEVMETHOD(ofw_bus_get_name,	ofw_bus_gen_get_name),
96	DEVMETHOD(ofw_bus_get_node,	ofw_bus_gen_get_node),
97	DEVMETHOD(ofw_bus_get_type,	ofw_bus_gen_get_type),
98
99	{ 0, 0 }
100};
101
102DEFINE_CLASS_0(lebuffer, lebuffer_driver, lebuffer_methods, 1);
103DRIVER_MODULE(lebuffer, sbus, lebuffer_driver, lebuffer_devclass, 0, 0);
104MODULE_DEPEND(lebuffer, sbus, 1, 1, 1);
105MODULE_VERSION(lebuffer, 1);
106
107static int
108lebuffer_probe(device_t dev)
109{
110	const char *name;
111
112	name = ofw_bus_get_name(dev);
113	if (strcmp(name, "lebuffer") == 0) {
114		device_set_desc_copy(dev, name);
115		return (0);
116	}
117	return (ENXIO);
118}
119
120static int
121lebuffer_attach(device_t dev)
122{
123	struct lebuffer_devinfo *ldi;
124	device_t cdev;
125	phandle_t child;
126	int children;
127
128	children = 0;
129	for (child = OF_child(ofw_bus_get_node(dev)); child != 0;
130	    child = OF_peer(child)) {
131		if ((ldi = lebuffer_setup_dinfo(dev, child)) == NULL)
132			continue;
133		if (children != 0) {
134			device_printf(dev,
135			    "<%s>: only one child per buffer supported\n",
136			    ldi->ldi_obdinfo.obd_name);
137			lebuffer_destroy_dinfo(ldi);
138			continue;
139		}
140		if ((cdev = device_add_child(dev, NULL, -1)) == NULL) {
141			device_printf(dev, "<%s>: device_add_child failed\n",
142			    ldi->ldi_obdinfo.obd_name);
143			lebuffer_destroy_dinfo(ldi);
144			continue;
145		}
146		device_set_ivars(cdev, ldi);
147		children++;
148	}
149	return (bus_generic_attach(dev));
150}
151
152static int
153lebuffer_detach(device_t dev)
154{
155	device_t *children;
156	int i, nchildren;
157
158	bus_generic_detach(dev);
159	if (device_get_children(dev, &children, &nchildren) == 0) {
160		for (i = 0; i < nchildren; i++) {
161			lebuffer_destroy_dinfo(device_get_ivars(children[i]));
162			device_delete_child(dev, children[i]);
163		}
164		free(children, M_TEMP);
165	}
166	return (0);
167}
168
169static struct lebuffer_devinfo *
170lebuffer_setup_dinfo(device_t dev, phandle_t node)
171{
172	struct lebuffer_devinfo *ldi;
173	struct sbus_regs *reg;
174	uint32_t base, iv, *intr;
175	int i, nreg, nintr, slot, rslot;
176
177	ldi = malloc(sizeof(*ldi), M_DEVBUF, M_WAITOK | M_ZERO);
178	if (ofw_bus_gen_setup_devinfo(&ldi->ldi_obdinfo, node) != 0) {
179		free(ldi, M_DEVBUF);
180		return (NULL);
181	}
182	resource_list_init(&ldi->ldi_rl);
183	slot = -1;
184	nreg = OF_getprop_alloc(node, "reg", sizeof(*reg), (void **)&reg);
185	if (nreg == -1) {
186		device_printf(dev, "<%s>: incomplete\n",
187		    ldi->ldi_obdinfo.obd_name);
188		goto fail;
189	}
190	for (i = 0; i < nreg; i++) {
191		base = reg[i].sbr_offset;
192		if (SBUS_ABS(base)) {
193			rslot = SBUS_ABS_TO_SLOT(base);
194			base = SBUS_ABS_TO_OFFSET(base);
195		} else
196			rslot = reg[i].sbr_slot;
197		if (slot != -1 && slot != rslot) {
198			device_printf(dev, "<%s>: multiple slots\n",
199			    ldi->ldi_obdinfo.obd_name);
200			free(reg, M_OFWPROP);
201			goto fail;
202		}
203		slot = rslot;
204
205		resource_list_add(&ldi->ldi_rl, SYS_RES_MEMORY, i, base,
206		    base + reg[i].sbr_size, reg[i].sbr_size);
207	}
208	free(reg, M_OFWPROP);
209	if (slot != sbus_get_slot(dev)) {
210		device_printf(dev, "<%s>: parent and child slot do not match\n",
211		    ldi->ldi_obdinfo.obd_name);
212		goto fail;
213	}
214
215	/*
216	 * The `interrupts' property contains the SBus interrupt level.
217	 */
218	nintr = OF_getprop_alloc(node, "interrupts", sizeof(*intr),
219	    (void **)&intr);
220	if (nintr != -1) {
221		for (i = 0; i < nintr; i++) {
222			iv = intr[i];
223			/*
224			 * SBus card devices need the slot number encoded into
225			 * the vector as this is generally not done.
226			 */
227			if ((iv & INTMAP_OBIO_MASK) == 0)
228				iv |= slot << 3;
229			/* Set the IGN as appropriate. */
230			iv |= sbus_get_ign(dev) << INTMAP_IGN_SHIFT;
231			resource_list_add(&ldi->ldi_rl, SYS_RES_IRQ, i,
232			    iv, iv, 1);
233		}
234		free(intr, M_OFWPROP);
235	}
236	return (ldi);
237
238 fail:
239	lebuffer_destroy_dinfo(ldi);
240	return (NULL);
241}
242
243static void
244lebuffer_destroy_dinfo(struct lebuffer_devinfo *dinfo)
245{
246
247	resource_list_free(&dinfo->ldi_rl);
248	ofw_bus_gen_destroy_devinfo(&dinfo->ldi_obdinfo);
249	free(dinfo, M_DEVBUF);
250}
251
252static int
253lebuffer_print_child(device_t dev, device_t child)
254{
255	int rv;
256
257	rv = bus_print_child_header(dev, child);
258	rv += lebuffer_print_res(device_get_ivars(child));
259	rv += bus_print_child_footer(dev, child);
260	return (rv);
261}
262
263static void
264lebuffer_probe_nomatch(device_t dev, device_t child)
265{
266	const char *type;
267
268	device_printf(dev, "<%s>", ofw_bus_get_name(child));
269	lebuffer_print_res(device_get_ivars(child));
270	type = ofw_bus_get_type(child);
271	printf(" type %s (no driver attached)\n",
272	    type != NULL ? type : "unknown");
273}
274
275static struct resource_list *
276lebuffer_get_resource_list(device_t dev, device_t child)
277{
278	struct lebuffer_devinfo *ldi;
279
280	ldi = device_get_ivars(child);
281	return (&ldi->ldi_rl);
282}
283
284static const struct ofw_bus_devinfo *
285lebuffer_get_devinfo(device_t bus, device_t child)
286{
287	struct lebuffer_devinfo *ldi;
288
289	ldi = device_get_ivars(child);
290	return (&ldi->ldi_obdinfo);
291}
292
293static int
294lebuffer_print_res(struct lebuffer_devinfo *ldi)
295{
296	int rv;
297
298	rv = 0;
299	rv += resource_list_print_type(&ldi->ldi_rl, "mem", SYS_RES_MEMORY,
300	    "%#lx");
301	rv += resource_list_print_type(&ldi->ldi_rl, "irq", SYS_RES_IRQ, "%ld");
302	return (rv);
303}
304