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