xref: /freebsd/sys/dev/puc/puc.c (revision 59c8e88e72633afbc47a4ace0d2170d00d51f7dc)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2006 Marcel Moolenaar
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  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following 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/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
32 #include <sys/bus.h>
33 #include <sys/conf.h>
34 #include <sys/malloc.h>
35 #include <sys/mutex.h>
36 #include <sys/sbuf.h>
37 #include <sys/sysctl.h>
38 
39 #include <machine/bus.h>
40 #include <machine/resource.h>
41 #include <sys/rman.h>
42 
43 #include <dev/pci/pcireg.h>
44 #include <dev/pci/pcivar.h>
45 
46 #include <dev/puc/puc_bus.h>
47 #include <dev/puc/puc_cfg.h>
48 #include <dev/puc/puc_bfe.h>
49 
50 #define	PUC_ISRCCNT	5
51 
52 struct puc_port {
53 	struct puc_bar	*p_bar;
54 	struct resource *p_rres;
55 	struct resource *p_ires;
56 	device_t	p_dev;
57 	int		p_nr;
58 	int		p_type;
59 	int		p_rclk;
60 
61 	bool		p_hasintr:1;
62 
63 	serdev_intr_t	*p_ihsrc[PUC_ISRCCNT];
64 	void		*p_iharg;
65 
66 	int		p_ipend;
67 };
68 
69 const char puc_driver_name[] = "puc";
70 
71 static MALLOC_DEFINE(M_PUC, "PUC", "PUC driver");
72 
73 SYSCTL_NODE(_hw, OID_AUTO, puc, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
74     "puc(4) driver configuration");
75 
76 struct puc_bar *
77 puc_get_bar(struct puc_softc *sc, int rid)
78 {
79 	struct puc_bar *bar;
80 	struct rman *rm;
81 	rman_res_t end, start;
82 	int error, i;
83 
84 	/* Find the BAR entry with the given RID. */
85 	i = 0;
86 	while (i < PUC_PCI_BARS && sc->sc_bar[i].b_rid != rid)
87 		i++;
88 	if (i < PUC_PCI_BARS)
89 		return (&sc->sc_bar[i]);
90 
91 	/* Not found. If we're looking for an unused entry, return NULL. */
92 	if (rid == -1)
93 		return (NULL);
94 
95 	/* Get an unused entry for us to fill.  */
96 	bar = puc_get_bar(sc, -1);
97 	if (bar == NULL)
98 		return (NULL);
99 	bar->b_rid = rid;
100 	bar->b_type = SYS_RES_IOPORT;
101 	bar->b_res = bus_alloc_resource_any(sc->sc_dev, bar->b_type,
102 	    &bar->b_rid, RF_ACTIVE);
103 	if (bar->b_res == NULL) {
104 		bar->b_rid = rid;
105 		bar->b_type = SYS_RES_MEMORY;
106 		bar->b_res = bus_alloc_resource_any(sc->sc_dev, bar->b_type,
107 		    &bar->b_rid, RF_ACTIVE);
108 		if (bar->b_res == NULL) {
109 			bar->b_rid = -1;
110 			return (NULL);
111 		}
112 	}
113 
114 	/* Update our managed space. */
115 	rm = (bar->b_type == SYS_RES_IOPORT) ? &sc->sc_ioport : &sc->sc_iomem;
116 	start = rman_get_start(bar->b_res);
117 	end = rman_get_end(bar->b_res);
118 	error = rman_manage_region(rm, start, end);
119 	if (error) {
120 		bus_release_resource(sc->sc_dev, bar->b_type, bar->b_rid,
121 		    bar->b_res);
122 		bar->b_res = NULL;
123 		bar->b_rid = -1;
124 		bar = NULL;
125 	}
126 
127 	return (bar);
128 }
129 
130 static int
131 puc_intr(void *arg)
132 {
133 	struct puc_port *port;
134 	struct puc_softc *sc = arg;
135 	u_long ds, dev, devs;
136 	int i, idx, ipend, isrc, nints;
137 	uint8_t ilr;
138 
139 	nints = 0;
140 	while (1) {
141 		/*
142 		 * Obtain the set of devices with pending interrupts.
143 		 */
144 		devs = sc->sc_serdevs;
145 		if (sc->sc_ilr == PUC_ILR_DIGI) {
146 			idx = 0;
147 			while (devs & (0xfful << idx)) {
148 				ilr = ~bus_read_1(sc->sc_port[idx].p_rres, 7);
149 				devs &= ~0ul ^ ((u_long)ilr << idx);
150 				idx += 8;
151 			}
152 		} else if (sc->sc_ilr == PUC_ILR_QUATECH) {
153 			/*
154 			 * Don't trust the value if it's the same as the option
155 			 * register. It may mean that the ILR is not active and
156 			 * we're reading the option register instead. This may
157 			 * lead to false positives on 8-port boards.
158 			 */
159 			ilr = bus_read_1(sc->sc_port[0].p_rres, 7);
160 			if (ilr != (sc->sc_cfg_data & 0xff))
161 				devs &= (u_long)ilr;
162 		}
163 		if (devs == 0UL)
164 			break;
165 
166 		/*
167 		 * Obtain the set of interrupt sources from those devices
168 		 * that have pending interrupts.
169 		 */
170 		ipend = 0;
171 		idx = 0, dev = 1UL;
172 		ds = devs;
173 		while (ds != 0UL) {
174 			while ((ds & dev) == 0UL)
175 				idx++, dev <<= 1;
176 			ds &= ~dev;
177 			port = &sc->sc_port[idx];
178 			port->p_ipend = SERDEV_IPEND(port->p_dev);
179 			ipend |= port->p_ipend;
180 		}
181 		if (ipend == 0)
182 			break;
183 
184 		i = 0, isrc = SER_INT_OVERRUN;
185 		while (ipend) {
186 			while (i < PUC_ISRCCNT && !(ipend & isrc))
187 				i++, isrc <<= 1;
188 			KASSERT(i < PUC_ISRCCNT, ("%s", __func__));
189 			ipend &= ~isrc;
190 			idx = 0, dev = 1UL;
191 			ds = devs;
192 			while (ds != 0UL) {
193 				while ((ds & dev) == 0UL)
194 					idx++, dev <<= 1;
195 				ds &= ~dev;
196 				port = &sc->sc_port[idx];
197 				if (!(port->p_ipend & isrc))
198 					continue;
199 				if (port->p_ihsrc[i] != NULL)
200 					(*port->p_ihsrc[i])(port->p_iharg);
201 				nints++;
202 			}
203 		}
204 	}
205 
206 	return ((nints > 0) ? FILTER_HANDLED : FILTER_STRAY);
207 }
208 
209 int
210 puc_bfe_attach(device_t dev)
211 {
212 	char buffer[64];
213 	struct puc_bar *bar;
214 	struct puc_port *port;
215 	struct puc_softc *sc;
216 	struct rman *rm;
217 	intptr_t res;
218 	bus_addr_t ofs, start;
219 	bus_size_t size;
220 	bus_space_handle_t bsh;
221 	bus_space_tag_t bst;
222 	int error, idx;
223 
224 	sc = device_get_softc(dev);
225 
226 	for (idx = 0; idx < PUC_PCI_BARS; idx++)
227 		sc->sc_bar[idx].b_rid = -1;
228 
229 	do {
230 		sc->sc_ioport.rm_type = RMAN_ARRAY;
231 		error = rman_init(&sc->sc_ioport);
232 		if (!error) {
233 			sc->sc_iomem.rm_type = RMAN_ARRAY;
234 			error = rman_init(&sc->sc_iomem);
235 			if (!error) {
236 				sc->sc_irq.rm_type = RMAN_ARRAY;
237 				error = rman_init(&sc->sc_irq);
238 				if (!error)
239 					break;
240 				rman_fini(&sc->sc_iomem);
241 			}
242 			rman_fini(&sc->sc_ioport);
243 		}
244 		return (error);
245 	} while (0);
246 
247 	snprintf(buffer, sizeof(buffer), "%s I/O port mapping",
248 	    device_get_nameunit(dev));
249 	sc->sc_ioport.rm_descr = strdup(buffer, M_PUC);
250 	snprintf(buffer, sizeof(buffer), "%s I/O memory mapping",
251 	    device_get_nameunit(dev));
252 	sc->sc_iomem.rm_descr = strdup(buffer, M_PUC);
253 	snprintf(buffer, sizeof(buffer), "%s port numbers",
254 	    device_get_nameunit(dev));
255 	sc->sc_irq.rm_descr = strdup(buffer, M_PUC);
256 
257 	error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res);
258 	KASSERT(error == 0, ("%s %d", __func__, __LINE__));
259 	sc->sc_nports = (int)res;
260 	sc->sc_port = malloc(sc->sc_nports * sizeof(struct puc_port),
261 	    M_PUC, M_WAITOK|M_ZERO);
262 
263 	error = rman_manage_region(&sc->sc_irq, 1, sc->sc_nports);
264 	if (error)
265 		goto fail;
266 
267 	error = puc_config(sc, PUC_CFG_SETUP, 0, &res);
268 	if (error)
269 		goto fail;
270 
271 	for (idx = 0; idx < sc->sc_nports; idx++) {
272 		port = &sc->sc_port[idx];
273 		port->p_nr = idx + 1;
274 		error = puc_config(sc, PUC_CFG_GET_TYPE, idx, &res);
275 		if (error)
276 			goto fail;
277 		port->p_type = res;
278 		error = puc_config(sc, PUC_CFG_GET_RID, idx, &res);
279 		if (error)
280 			goto fail;
281 		bar = puc_get_bar(sc, res);
282 		if (bar == NULL) {
283 			error = ENXIO;
284 			goto fail;
285 		}
286 		port->p_bar = bar;
287 		start = rman_get_start(bar->b_res);
288 		error = puc_config(sc, PUC_CFG_GET_OFS, idx, &res);
289 		if (error)
290 			goto fail;
291 		ofs = res;
292 		error = puc_config(sc, PUC_CFG_GET_LEN, idx, &res);
293 		if (error)
294 			goto fail;
295 		size = res;
296 		rm = (bar->b_type == SYS_RES_IOPORT)
297 		    ? &sc->sc_ioport: &sc->sc_iomem;
298 		port->p_rres = rman_reserve_resource(rm, start + ofs,
299 		    start + ofs + size - 1, size, 0, NULL);
300 		if (port->p_rres != NULL) {
301 			bsh = rman_get_bushandle(bar->b_res);
302 			bst = rman_get_bustag(bar->b_res);
303 			bus_space_subregion(bst, bsh, ofs, size, &bsh);
304 			rman_set_bushandle(port->p_rres, bsh);
305 			rman_set_bustag(port->p_rres, bst);
306 		}
307 		port->p_ires = rman_reserve_resource(&sc->sc_irq, port->p_nr,
308 		    port->p_nr, 1, 0, NULL);
309 		if (port->p_ires == NULL) {
310 			error = ENXIO;
311 			goto fail;
312 		}
313 		error = puc_config(sc, PUC_CFG_GET_CLOCK, idx, &res);
314 		if (error)
315 			goto fail;
316 		port->p_rclk = res;
317 
318 		port->p_dev = device_add_child(dev, NULL, -1);
319 		if (port->p_dev != NULL)
320 			device_set_ivars(port->p_dev, (void *)port);
321 	}
322 
323 	error = puc_config(sc, PUC_CFG_GET_ILR, 0, &res);
324 	if (error)
325 		goto fail;
326 	sc->sc_ilr = res;
327 	if (bootverbose && sc->sc_ilr != 0)
328 		device_printf(dev, "using interrupt latch register\n");
329 
330 	sc->sc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->sc_irid,
331 	    RF_ACTIVE|RF_SHAREABLE);
332 	if (sc->sc_ires != NULL) {
333 		error = bus_setup_intr(dev, sc->sc_ires,
334 		    INTR_TYPE_TTY, puc_intr, NULL, sc, &sc->sc_icookie);
335 		if (error)
336 			error = bus_setup_intr(dev, sc->sc_ires,
337 			    INTR_TYPE_TTY | INTR_MPSAFE, NULL,
338 			    (driver_intr_t *)puc_intr, sc, &sc->sc_icookie);
339 		else
340 			sc->sc_fastintr = 1;
341 
342 		if (error) {
343 			device_printf(dev, "could not activate interrupt\n");
344 			bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid,
345 			    sc->sc_ires);
346 			sc->sc_ires = NULL;
347 		}
348 	}
349 	if (sc->sc_ires == NULL) {
350 		/* XXX no interrupt resource. Force polled mode. */
351 		sc->sc_polled = 1;
352 	}
353 
354 	/* Probe and attach our children. */
355 	for (idx = 0; idx < sc->sc_nports; idx++) {
356 		port = &sc->sc_port[idx];
357 		if (port->p_dev == NULL)
358 			continue;
359 		error = device_probe_and_attach(port->p_dev);
360 		if (error) {
361 			device_delete_child(dev, port->p_dev);
362 			port->p_dev = NULL;
363 		}
364 	}
365 
366 	/*
367 	 * If there are no serdev devices, then our interrupt handler
368 	 * will do nothing. Tear it down.
369 	 */
370 	if (sc->sc_serdevs == 0UL)
371 		bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie);
372 
373 	return (0);
374 
375 fail:
376 	for (idx = 0; idx < sc->sc_nports; idx++) {
377 		port = &sc->sc_port[idx];
378 		if (port->p_dev != NULL)
379 			device_delete_child(dev, port->p_dev);
380 		if (port->p_rres != NULL)
381 			rman_release_resource(port->p_rres);
382 		if (port->p_ires != NULL)
383 			rman_release_resource(port->p_ires);
384 	}
385 	for (idx = 0; idx < PUC_PCI_BARS; idx++) {
386 		bar = &sc->sc_bar[idx];
387 		if (bar->b_res != NULL)
388 			bus_release_resource(sc->sc_dev, bar->b_type,
389 			    bar->b_rid, bar->b_res);
390 	}
391 	rman_fini(&sc->sc_irq);
392 	free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC);
393 	rman_fini(&sc->sc_iomem);
394 	free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC);
395 	rman_fini(&sc->sc_ioport);
396 	free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC);
397 	free(sc->sc_port, M_PUC);
398 	return (error);
399 }
400 
401 int
402 puc_bfe_detach(device_t dev)
403 {
404 	struct puc_bar *bar;
405 	struct puc_port *port;
406 	struct puc_softc *sc;
407 	int error, idx;
408 
409 	sc = device_get_softc(dev);
410 
411 	/* Detach our children. */
412 	error = 0;
413 	for (idx = 0; idx < sc->sc_nports; idx++) {
414 		port = &sc->sc_port[idx];
415 		if (port->p_dev == NULL)
416 			continue;
417 		if (device_delete_child(dev, port->p_dev) == 0) {
418 			if (port->p_rres != NULL)
419 				rman_release_resource(port->p_rres);
420 			if (port->p_ires != NULL)
421 				rman_release_resource(port->p_ires);
422 		} else
423 			error = ENXIO;
424 	}
425 	if (error)
426 		return (error);
427 
428 	if (sc->sc_serdevs != 0UL)
429 		bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie);
430 	bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, sc->sc_ires);
431 
432 	for (idx = 0; idx < PUC_PCI_BARS; idx++) {
433 		bar = &sc->sc_bar[idx];
434 		if (bar->b_res != NULL)
435 			bus_release_resource(sc->sc_dev, bar->b_type,
436 			    bar->b_rid, bar->b_res);
437 	}
438 
439 	rman_fini(&sc->sc_irq);
440 	free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC);
441 	rman_fini(&sc->sc_iomem);
442 	free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC);
443 	rman_fini(&sc->sc_ioport);
444 	free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC);
445 	free(sc->sc_port, M_PUC);
446 	return (0);
447 }
448 
449 int
450 puc_bfe_probe(device_t dev, const struct puc_cfg *cfg)
451 {
452 	struct puc_softc *sc;
453 	intptr_t res;
454 	int error;
455 
456 	sc = device_get_softc(dev);
457 	sc->sc_dev = dev;
458 	sc->sc_cfg = cfg;
459 
460 	/* We don't attach to single-port serial cards. */
461 	if (cfg->ports == PUC_PORT_1S || cfg->ports == PUC_PORT_1P)
462 		return (EDOOFUS);
463 	error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res);
464 	if (error)
465 		return (error);
466 	error = puc_config(sc, PUC_CFG_GET_DESC, 0, &res);
467 	if (error)
468 		return (error);
469 	if (res != 0)
470 		device_set_desc(dev, (const char *)res);
471 	return (BUS_PROBE_DEFAULT);
472 }
473 
474 struct resource *
475 puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid,
476     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
477 {
478 	struct puc_port *port;
479 	struct resource *res;
480 	device_t assigned, originator;
481 	int error;
482 
483 	/* Get our immediate child. */
484 	originator = child;
485 	while (child != NULL && device_get_parent(child) != dev)
486 		child = device_get_parent(child);
487 	if (child == NULL)
488 		return (NULL);
489 
490 	port = device_get_ivars(child);
491 	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
492 
493 	if (rid == NULL || *rid != 0)
494 		return (NULL);
495 
496 	/* We only support default allocations. */
497 	if (!RMAN_IS_DEFAULT_RANGE(start, end))
498 		return (NULL);
499 
500 	if (type == port->p_bar->b_type)
501 		res = port->p_rres;
502 	else if (type == SYS_RES_IRQ)
503 		res = port->p_ires;
504 	else
505 		return (NULL);
506 
507 	if (res == NULL)
508 		return (NULL);
509 
510 	assigned = rman_get_device(res);
511 	if (assigned == NULL)	/* Not allocated */
512 		rman_set_device(res, originator);
513 	else if (assigned != originator)
514 		return (NULL);
515 
516 	if (flags & RF_ACTIVE) {
517 		error = rman_activate_resource(res);
518 		if (error) {
519 			if (assigned == NULL)
520 				rman_set_device(res, NULL);
521 			return (NULL);
522 		}
523 	}
524 
525 	return (res);
526 }
527 
528 int
529 puc_bus_release_resource(device_t dev, device_t child, int type, int rid,
530     struct resource *res)
531 {
532 	struct puc_port *port;
533 	device_t originator;
534 
535 	/* Get our immediate child. */
536 	originator = child;
537 	while (child != NULL && device_get_parent(child) != dev)
538 		child = device_get_parent(child);
539 	if (child == NULL)
540 		return (EINVAL);
541 
542 	port = device_get_ivars(child);
543 	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
544 
545 	if (rid != 0 || res == NULL)
546 		return (EINVAL);
547 
548 	if (type == port->p_bar->b_type) {
549 		if (res != port->p_rres)
550 			return (EINVAL);
551 	} else if (type == SYS_RES_IRQ) {
552 		if (res != port->p_ires)
553 			return (EINVAL);
554 		if (port->p_hasintr)
555 			return (EBUSY);
556 	} else
557 		return (EINVAL);
558 
559 	if (rman_get_device(res) != originator)
560 		return (ENXIO);
561 	if (rman_get_flags(res) & RF_ACTIVE)
562 		rman_deactivate_resource(res);
563 	rman_set_device(res, NULL);
564 	return (0);
565 }
566 
567 int
568 puc_bus_get_resource(device_t dev, device_t child, int type, int rid,
569     rman_res_t *startp, rman_res_t *countp)
570 {
571 	struct puc_port *port;
572 	struct resource *res;
573 	rman_res_t start;
574 
575 	/* Get our immediate child. */
576 	while (child != NULL && device_get_parent(child) != dev)
577 		child = device_get_parent(child);
578 	if (child == NULL)
579 		return (EINVAL);
580 
581 	port = device_get_ivars(child);
582 	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
583 
584 	if (type == port->p_bar->b_type)
585 		res = port->p_rres;
586 	else if (type == SYS_RES_IRQ)
587 		res = port->p_ires;
588 	else
589 		return (ENXIO);
590 
591 	if (rid != 0 || res == NULL)
592 		return (ENXIO);
593 
594 	start = rman_get_start(res);
595 	if (startp != NULL)
596 		*startp = start;
597 	if (countp != NULL)
598 		*countp = rman_get_end(res) - start + 1;
599 	return (0);
600 }
601 
602 int
603 puc_bus_setup_intr(device_t dev, device_t child, struct resource *res,
604     int flags, driver_filter_t *filt, void (*ihand)(void *), void *arg, void **cookiep)
605 {
606 	struct puc_port *port;
607 	struct puc_softc *sc;
608 	device_t originator;
609 	int i, isrc, serdev;
610 
611 	sc = device_get_softc(dev);
612 
613 	/* Get our immediate child. */
614 	originator = child;
615 	while (child != NULL && device_get_parent(child) != dev)
616 		child = device_get_parent(child);
617 	if (child == NULL)
618 		return (EINVAL);
619 
620 	port = device_get_ivars(child);
621 	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
622 
623 	if (cookiep == NULL || res != port->p_ires)
624 		return (EINVAL);
625 	/* We demand that serdev devices use filter_only interrupts. */
626 	if (port->p_type == PUC_TYPE_SERIAL && ihand != NULL)
627 		return (ENXIO);
628 	if (rman_get_device(port->p_ires) != originator)
629 		return (ENXIO);
630 
631 	/*
632 	 * Have non-serdev ports handled by the bus implementation. It
633 	 * supports multiple handlers for a single interrupt as it is,
634 	 * so we wouldn't add value if we did it ourselves.
635 	 */
636 	serdev = 0;
637 	if (port->p_type == PUC_TYPE_SERIAL) {
638 		i = 0, isrc = SER_INT_OVERRUN;
639 		while (i < PUC_ISRCCNT) {
640 			port->p_ihsrc[i] = SERDEV_IHAND(originator, isrc);
641 			if (port->p_ihsrc[i] != NULL)
642 				serdev = 1;
643 			i++, isrc <<= 1;
644 		}
645 	}
646 	if (!serdev)
647 		return (BUS_SETUP_INTR(device_get_parent(dev), originator,
648 		    sc->sc_ires, flags, filt, ihand, arg, cookiep));
649 
650 	sc->sc_serdevs |= 1UL << (port->p_nr - 1);
651 
652 	port->p_hasintr = 1;
653 	port->p_iharg = arg;
654 
655 	*cookiep = port;
656 	return (0);
657 }
658 
659 int
660 puc_bus_teardown_intr(device_t dev, device_t child, struct resource *res,
661     void *cookie)
662 {
663 	struct puc_port *port;
664 	struct puc_softc *sc;
665 	device_t originator;
666 	int i;
667 
668 	sc = device_get_softc(dev);
669 
670 	/* Get our immediate child. */
671 	originator = child;
672 	while (child != NULL && device_get_parent(child) != dev)
673 		child = device_get_parent(child);
674 	if (child == NULL)
675 		return (EINVAL);
676 
677 	port = device_get_ivars(child);
678 	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
679 
680 	if (res != port->p_ires)
681 		return (EINVAL);
682 	if (rman_get_device(port->p_ires) != originator)
683 		return (ENXIO);
684 
685 	if (!port->p_hasintr)
686 		return (BUS_TEARDOWN_INTR(device_get_parent(dev), originator,
687 		    sc->sc_ires, cookie));
688 
689 	if (cookie != port)
690 		return (EINVAL);
691 
692 	port->p_hasintr = 0;
693 	port->p_iharg = NULL;
694 
695 	for (i = 0; i < PUC_ISRCCNT; i++)
696 		port->p_ihsrc[i] = NULL;
697 
698 	return (0);
699 }
700 
701 int
702 puc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
703 {
704 	struct puc_port *port;
705 
706 	/* Get our immediate child. */
707 	while (child != NULL && device_get_parent(child) != dev)
708 		child = device_get_parent(child);
709 	if (child == NULL)
710 		return (EINVAL);
711 
712 	port = device_get_ivars(child);
713 	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
714 
715 	if (result == NULL)
716 		return (EINVAL);
717 
718 	switch(index) {
719 	case PUC_IVAR_CLOCK:
720 		*result = port->p_rclk;
721 		break;
722 	case PUC_IVAR_TYPE:
723 		*result = port->p_type;
724 		break;
725 	default:
726 		return (ENOENT);
727 	}
728 	return (0);
729 }
730 
731 int
732 puc_bus_print_child(device_t dev, device_t child)
733 {
734 	struct puc_port *port;
735 	int retval;
736 
737 	port = device_get_ivars(child);
738 	retval = 0;
739 
740 	retval += bus_print_child_header(dev, child);
741 	retval += printf(" at port %d", port->p_nr);
742 	retval += bus_print_child_footer(dev, child);
743 
744 	return (retval);
745 }
746 
747 int
748 puc_bus_child_location(device_t dev, device_t child, struct sbuf *sb)
749 {
750 	struct puc_port *port;
751 
752 	port = device_get_ivars(child);
753 	sbuf_printf(sb, "port=%d", port->p_nr);
754 	return (0);
755 }
756 
757 int
758 puc_bus_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb)
759 {
760 	struct puc_port *port;
761 
762 	port = device_get_ivars(child);
763 	sbuf_printf(sb, "type=%d", port->p_type);
764 	return (0);
765 }
766