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 *
puc_get_bar(struct puc_softc * sc,int rid)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
puc_intr(void * arg)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
puc_bfe_attach(device_t dev)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, DEVICE_UNIT_ANY);
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 device_delete_children(dev);
377 for (idx = 0; idx < sc->sc_nports; idx++) {
378 port = &sc->sc_port[idx];
379 if (port->p_rres != NULL)
380 rman_release_resource(port->p_rres);
381 if (port->p_ires != NULL)
382 rman_release_resource(port->p_ires);
383 }
384 for (idx = 0; idx < PUC_PCI_BARS; idx++) {
385 bar = &sc->sc_bar[idx];
386 if (bar->b_res != NULL)
387 bus_release_resource(sc->sc_dev, bar->b_type,
388 bar->b_rid, bar->b_res);
389 }
390 rman_fini(&sc->sc_irq);
391 free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC);
392 rman_fini(&sc->sc_iomem);
393 free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC);
394 rman_fini(&sc->sc_ioport);
395 free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC);
396 free(sc->sc_port, M_PUC);
397 return (error);
398 }
399
400 int
puc_bfe_detach(device_t dev)401 puc_bfe_detach(device_t dev)
402 {
403 struct puc_bar *bar;
404 struct puc_port *port;
405 struct puc_softc *sc;
406 int error, idx;
407
408 sc = device_get_softc(dev);
409
410 /* Detach our children. */
411 error = bus_generic_detach(dev);
412 if (error != 0)
413 return (error);
414
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 (port->p_rres != NULL)
420 rman_release_resource(port->p_rres);
421 if (port->p_ires != NULL)
422 rman_release_resource(port->p_ires);
423 }
424
425 if (sc->sc_serdevs != 0UL)
426 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie);
427 bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, sc->sc_ires);
428
429 for (idx = 0; idx < PUC_PCI_BARS; idx++) {
430 bar = &sc->sc_bar[idx];
431 if (bar->b_res != NULL)
432 bus_release_resource(sc->sc_dev, bar->b_type,
433 bar->b_rid, bar->b_res);
434 }
435
436 rman_fini(&sc->sc_irq);
437 free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC);
438 rman_fini(&sc->sc_iomem);
439 free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC);
440 rman_fini(&sc->sc_ioport);
441 free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC);
442 free(sc->sc_port, M_PUC);
443 return (0);
444 }
445
446 int
puc_bfe_probe(device_t dev,const struct puc_cfg * cfg)447 puc_bfe_probe(device_t dev, const struct puc_cfg *cfg)
448 {
449 struct puc_softc *sc;
450 intptr_t res;
451 int error;
452
453 sc = device_get_softc(dev);
454 sc->sc_dev = dev;
455 sc->sc_cfg = cfg;
456
457 /* We don't attach to single-port serial cards. */
458 if (cfg->ports == PUC_PORT_1S || cfg->ports == PUC_PORT_1P)
459 return (EDOOFUS);
460 error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res);
461 if (error)
462 return (error);
463 error = puc_config(sc, PUC_CFG_GET_DESC, 0, &res);
464 if (error)
465 return (error);
466 if (res != 0)
467 device_set_desc(dev, (const char *)res);
468 return (BUS_PROBE_DEFAULT);
469 }
470
471 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)472 puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid,
473 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
474 {
475 struct puc_port *port;
476 struct resource *res;
477 device_t assigned, originator;
478 int error;
479
480 /* Get our immediate child. */
481 originator = child;
482 while (child != NULL && device_get_parent(child) != dev)
483 child = device_get_parent(child);
484 if (child == NULL)
485 return (NULL);
486
487 port = device_get_ivars(child);
488 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
489
490 if (rid == NULL || *rid != 0)
491 return (NULL);
492
493 /* We only support default allocations. */
494 if (!RMAN_IS_DEFAULT_RANGE(start, end))
495 return (NULL);
496
497 if (type == port->p_bar->b_type)
498 res = port->p_rres;
499 else if (type == SYS_RES_IRQ)
500 res = port->p_ires;
501 else
502 return (NULL);
503
504 if (res == NULL)
505 return (NULL);
506
507 assigned = rman_get_device(res);
508 if (assigned == NULL) /* Not allocated */
509 rman_set_device(res, originator);
510 else if (assigned != originator)
511 return (NULL);
512
513 if (flags & RF_ACTIVE) {
514 error = rman_activate_resource(res);
515 if (error) {
516 if (assigned == NULL)
517 rman_set_device(res, NULL);
518 return (NULL);
519 }
520 }
521
522 return (res);
523 }
524
525 int
puc_bus_release_resource(device_t dev,device_t child,struct resource * res)526 puc_bus_release_resource(device_t dev, device_t child, struct resource *res)
527 {
528 struct puc_port *port;
529 device_t originator;
530
531 /* Get our immediate child. */
532 originator = child;
533 while (child != NULL && device_get_parent(child) != dev)
534 child = device_get_parent(child);
535 if (child == NULL)
536 return (EINVAL);
537
538 port = device_get_ivars(child);
539 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
540
541 if (res == NULL)
542 return (EINVAL);
543
544 if (res == port->p_ires) {
545 if (port->p_hasintr)
546 return (EBUSY);
547 } else if (res != port->p_rres)
548 return (EINVAL);
549
550 if (rman_get_device(res) != originator)
551 return (ENXIO);
552 if (rman_get_flags(res) & RF_ACTIVE)
553 rman_deactivate_resource(res);
554 rman_set_device(res, NULL);
555 return (0);
556 }
557
558 int
puc_bus_get_resource(device_t dev,device_t child,int type,int rid,rman_res_t * startp,rman_res_t * countp)559 puc_bus_get_resource(device_t dev, device_t child, int type, int rid,
560 rman_res_t *startp, rman_res_t *countp)
561 {
562 struct puc_port *port;
563 struct resource *res;
564 rman_res_t start;
565
566 /* Get our immediate child. */
567 while (child != NULL && device_get_parent(child) != dev)
568 child = device_get_parent(child);
569 if (child == NULL)
570 return (EINVAL);
571
572 port = device_get_ivars(child);
573 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
574
575 if (type == port->p_bar->b_type)
576 res = port->p_rres;
577 else if (type == SYS_RES_IRQ)
578 res = port->p_ires;
579 else
580 return (ENXIO);
581
582 if (rid != 0 || res == NULL)
583 return (ENXIO);
584
585 start = rman_get_start(res);
586 if (startp != NULL)
587 *startp = start;
588 if (countp != NULL)
589 *countp = rman_get_end(res) - start + 1;
590 return (0);
591 }
592
593 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)594 puc_bus_setup_intr(device_t dev, device_t child, struct resource *res,
595 int flags, driver_filter_t *filt, void (*ihand)(void *), void *arg, void **cookiep)
596 {
597 struct puc_port *port;
598 struct puc_softc *sc;
599 device_t originator;
600 int i, isrc, serdev;
601
602 sc = device_get_softc(dev);
603
604 /* Get our immediate child. */
605 originator = child;
606 while (child != NULL && device_get_parent(child) != dev)
607 child = device_get_parent(child);
608 if (child == NULL)
609 return (EINVAL);
610
611 port = device_get_ivars(child);
612 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
613
614 if (cookiep == NULL || res != port->p_ires)
615 return (EINVAL);
616 /* We demand that serdev devices use filter_only interrupts. */
617 if (port->p_type == PUC_TYPE_SERIAL && ihand != NULL)
618 return (ENXIO);
619 if (rman_get_device(port->p_ires) != originator)
620 return (ENXIO);
621
622 /*
623 * Have non-serdev ports handled by the bus implementation. It
624 * supports multiple handlers for a single interrupt as it is,
625 * so we wouldn't add value if we did it ourselves.
626 */
627 serdev = 0;
628 if (port->p_type == PUC_TYPE_SERIAL) {
629 i = 0, isrc = SER_INT_OVERRUN;
630 while (i < PUC_ISRCCNT) {
631 port->p_ihsrc[i] = SERDEV_IHAND(originator, isrc);
632 if (port->p_ihsrc[i] != NULL)
633 serdev = 1;
634 i++, isrc <<= 1;
635 }
636 }
637 if (!serdev)
638 return (BUS_SETUP_INTR(device_get_parent(dev), originator,
639 sc->sc_ires, flags, filt, ihand, arg, cookiep));
640
641 sc->sc_serdevs |= 1UL << (port->p_nr - 1);
642
643 port->p_hasintr = 1;
644 port->p_iharg = arg;
645
646 *cookiep = port;
647 return (0);
648 }
649
650 int
puc_bus_teardown_intr(device_t dev,device_t child,struct resource * res,void * cookie)651 puc_bus_teardown_intr(device_t dev, device_t child, struct resource *res,
652 void *cookie)
653 {
654 struct puc_port *port;
655 struct puc_softc *sc;
656 device_t originator;
657 int i;
658
659 sc = device_get_softc(dev);
660
661 /* Get our immediate child. */
662 originator = child;
663 while (child != NULL && device_get_parent(child) != dev)
664 child = device_get_parent(child);
665 if (child == NULL)
666 return (EINVAL);
667
668 port = device_get_ivars(child);
669 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
670
671 if (res != port->p_ires)
672 return (EINVAL);
673 if (rman_get_device(port->p_ires) != originator)
674 return (ENXIO);
675
676 if (!port->p_hasintr)
677 return (BUS_TEARDOWN_INTR(device_get_parent(dev), originator,
678 sc->sc_ires, cookie));
679
680 if (cookie != port)
681 return (EINVAL);
682
683 port->p_hasintr = 0;
684 port->p_iharg = NULL;
685
686 for (i = 0; i < PUC_ISRCCNT; i++)
687 port->p_ihsrc[i] = NULL;
688
689 return (0);
690 }
691
692 int
puc_bus_read_ivar(device_t dev,device_t child,int index,uintptr_t * result)693 puc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
694 {
695 struct puc_port *port;
696
697 /* Get our immediate child. */
698 while (child != NULL && device_get_parent(child) != dev)
699 child = device_get_parent(child);
700 if (child == NULL)
701 return (EINVAL);
702
703 port = device_get_ivars(child);
704 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
705
706 if (result == NULL)
707 return (EINVAL);
708
709 switch(index) {
710 case PUC_IVAR_CLOCK:
711 *result = port->p_rclk;
712 break;
713 case PUC_IVAR_TYPE:
714 *result = port->p_type;
715 break;
716 default:
717 return (ENOENT);
718 }
719 return (0);
720 }
721
722 int
puc_bus_print_child(device_t dev,device_t child)723 puc_bus_print_child(device_t dev, device_t child)
724 {
725 struct puc_port *port;
726 int retval;
727
728 port = device_get_ivars(child);
729 retval = 0;
730
731 retval += bus_print_child_header(dev, child);
732 retval += printf(" at port %d", port->p_nr);
733 retval += bus_print_child_footer(dev, child);
734
735 return (retval);
736 }
737
738 int
puc_bus_child_location(device_t dev,device_t child,struct sbuf * sb)739 puc_bus_child_location(device_t dev, device_t child, struct sbuf *sb)
740 {
741 struct puc_port *port;
742
743 port = device_get_ivars(child);
744 sbuf_printf(sb, "port=%d", port->p_nr);
745 return (0);
746 }
747
748 int
puc_bus_child_pnpinfo(device_t dev,device_t child,struct sbuf * sb)749 puc_bus_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb)
750 {
751 struct puc_port *port;
752
753 port = device_get_ivars(child);
754 sbuf_printf(sb, "type=%d", port->p_type);
755 return (0);
756 }
757