xref: /freebsd/sys/isa/isa_common.c (revision 1670a1c2a47d10ecccd001970b859caf93cd3b6e)
1 /*-
2  * Copyright (c) 1999 Doug Rabson
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  * Modifications for Intel architecture by Garrett A. Wollman.
28  * Copyright 1998 Massachusetts Institute of Technology
29  *
30  * Permission to use, copy, modify, and distribute this software and
31  * its documentation for any purpose and without fee is hereby
32  * granted, provided that both the above copyright notice and this
33  * permission notice appear in all copies, that both the above
34  * copyright notice and this permission notice appear in all
35  * supporting documentation, and that the name of M.I.T. not be used
36  * in advertising or publicity pertaining to distribution of the
37  * software without specific, written prior permission.  M.I.T. makes
38  * no representations about the suitability of this software for any
39  * purpose.  It is provided "as is" without express or implied
40  * warranty.
41  *
42  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
43  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
44  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
45  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
46  * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
47  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
48  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
49  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
50  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
51  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
52  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  */
55 
56 /*
57  * Parts of the ISA bus implementation common to all architectures.
58  */
59 
60 #include <sys/cdefs.h>
61 __FBSDID("$FreeBSD$");
62 
63 #include "opt_isa.h"
64 
65 #include <sys/param.h>
66 #include <sys/systm.h>
67 #include <sys/kernel.h>
68 #include <sys/bus.h>
69 #include <sys/malloc.h>
70 #include <sys/module.h>
71 #include <machine/bus.h>
72 #include <sys/rman.h>
73 
74 #include <machine/resource.h>
75 
76 #include <isa/isavar.h>
77 #include <isa/isa_common.h>
78 
79 static int	isa_print_child(device_t bus, device_t dev);
80 
81 static MALLOC_DEFINE(M_ISADEV, "isadev", "ISA device");
82 
83 static int isa_running;
84 
85 /*
86  * At 'probe' time, we add all the devices which we know about to the
87  * bus.  The generic attach routine will probe and attach them if they
88  * are alive.
89  */
90 static int
91 isa_probe(device_t dev)
92 {
93 	device_set_desc(dev, "ISA bus");
94 	isa_init(dev);		/* Allow machdep code to initialise */
95 	return (0);
96 }
97 
98 extern device_t isa_bus_device;
99 
100 static int
101 isa_attach(device_t dev)
102 {
103 	/*
104 	 * Arrange for isa_probe_children(dev) to be called later. XXX
105 	 */
106 	isa_bus_device = dev;
107 	return (0);
108 }
109 
110 /*
111  * Find a working set of memory regions for a child using the ranges
112  * in *config  and return the regions in *result. Returns non-zero if
113  * a set of ranges was found.
114  */
115 static int
116 isa_find_memory(device_t child, struct isa_config *config,
117     struct isa_config *result)
118 {
119 	int success, i;
120 	struct resource *res[ISA_NMEM];
121 
122 	/*
123 	 * First clear out any existing resource definitions.
124 	 */
125 	for (i = 0; i < ISA_NMEM; i++) {
126 		bus_delete_resource(child, SYS_RES_MEMORY, i);
127 		res[i] = NULL;
128 	}
129 
130 	success = 1;
131 	result->ic_nmem = config->ic_nmem;
132 	for (i = 0; i < config->ic_nmem; i++) {
133 		uint32_t start, end, size, align;
134 
135 		size = config->ic_mem[i].ir_size;
136 
137 		/* the PnP device may have a null resource as filler */
138 		if (size == 0) {
139 			result->ic_mem[i].ir_start = 0;
140 			result->ic_mem[i].ir_end = 0;
141 			result->ic_mem[i].ir_size = 0;
142 			result->ic_mem[i].ir_align = 0;
143 			continue;
144 		}
145 
146 		for (start = config->ic_mem[i].ir_start,
147 			     end = config->ic_mem[i].ir_end,
148 			     align = config->ic_mem[i].ir_align;
149 		     start + size - 1 <= end && start + size > start;
150 		     start += MAX(align, 1)) {
151 			bus_set_resource(child, SYS_RES_MEMORY, i,
152 					 start, size);
153 			res[i] = bus_alloc_resource(child,
154 			    SYS_RES_MEMORY, &i, 0, ~0, 1,
155 			    rman_make_alignment_flags(align) /* !RF_ACTIVE */);
156 			if (res[i]) {
157 				result->ic_mem[i].ir_start = start;
158 				result->ic_mem[i].ir_end = start + size - 1;
159 				result->ic_mem[i].ir_size = size;
160 				result->ic_mem[i].ir_align = align;
161 				break;
162 			}
163 		}
164 
165 		/*
166 		 * If we didn't find a place for memory range i, then
167 		 * give up now.
168 		 */
169 		if (!res[i]) {
170 			success = 0;
171 			break;
172 		}
173 	}
174 
175 	for (i = 0; i < ISA_NMEM; i++) {
176 		if (res[i])
177 			bus_release_resource(child, SYS_RES_MEMORY,
178 					     i, res[i]);
179 	}
180 
181 	return (success);
182 }
183 
184 /*
185  * Find a working set of port regions for a child using the ranges
186  * in *config  and return the regions in *result. Returns non-zero if
187  * a set of ranges was found.
188  */
189 static int
190 isa_find_port(device_t child, struct isa_config *config,
191     struct isa_config *result)
192 {
193 	int success, i;
194 	struct resource *res[ISA_NPORT];
195 
196 	/*
197 	 * First clear out any existing resource definitions.
198 	 */
199 	for (i = 0; i < ISA_NPORT; i++) {
200 		bus_delete_resource(child, SYS_RES_IOPORT, i);
201 		res[i] = NULL;
202 	}
203 
204 	success = 1;
205 	result->ic_nport = config->ic_nport;
206 	for (i = 0; i < config->ic_nport; i++) {
207 		uint32_t start, end, size, align;
208 
209 		size = config->ic_port[i].ir_size;
210 
211 		/* the PnP device may have a null resource as filler */
212 		if (size == 0) {
213 			result->ic_port[i].ir_start = 0;
214 			result->ic_port[i].ir_end = 0;
215 			result->ic_port[i].ir_size = 0;
216 			result->ic_port[i].ir_align = 0;
217 			continue;
218 		}
219 
220 		for (start = config->ic_port[i].ir_start,
221 			     end = config->ic_port[i].ir_end,
222 			     align = config->ic_port[i].ir_align;
223 		     start + size - 1 <= end;
224 		     start += align) {
225 			bus_set_resource(child, SYS_RES_IOPORT, i,
226 					 start, size);
227 			res[i] = bus_alloc_resource(child,
228 			    SYS_RES_IOPORT, &i, 0, ~0, 1,
229 			    rman_make_alignment_flags(align) /* !RF_ACTIVE */);
230 			if (res[i]) {
231 				result->ic_port[i].ir_start = start;
232 				result->ic_port[i].ir_end = start + size - 1;
233 				result->ic_port[i].ir_size = size;
234 				result->ic_port[i].ir_align = align;
235 				break;
236 			}
237 		}
238 
239 		/*
240 		 * If we didn't find a place for port range i, then
241 		 * give up now.
242 		 */
243 		if (!res[i]) {
244 			success = 0;
245 			break;
246 		}
247 	}
248 
249 	for (i = 0; i < ISA_NPORT; i++) {
250 		if (res[i])
251 			bus_release_resource(child, SYS_RES_IOPORT,
252 					     i, res[i]);
253 	}
254 
255 	return success;
256 }
257 
258 /*
259  * Return the index of the first bit in the mask (or -1 if mask is empty.
260  */
261 static int
262 find_first_bit(uint32_t mask)
263 {
264 	return (ffs(mask) - 1);
265 }
266 
267 /*
268  * Return the index of the next bit in the mask, or -1 if there are no more.
269  */
270 static int
271 find_next_bit(uint32_t mask, int bit)
272 {
273 	bit++;
274 	while (bit < 32 && !(mask & (1 << bit)))
275 		bit++;
276 	if (bit != 32)
277 		return (bit);
278 	return (-1);
279 }
280 
281 /*
282  * Find a working set of irqs for a child using the masks in *config
283  * and return the regions in *result. Returns non-zero if a set of
284  * irqs was found.
285  */
286 static int
287 isa_find_irq(device_t child, struct isa_config *config,
288     struct isa_config *result)
289 {
290 	int success, i;
291 	struct resource *res[ISA_NIRQ];
292 
293 	/*
294 	 * First clear out any existing resource definitions.
295 	 */
296 	for (i = 0; i < ISA_NIRQ; i++) {
297 		bus_delete_resource(child, SYS_RES_IRQ, i);
298 		res[i] = NULL;
299 	}
300 
301 	success = 1;
302 	result->ic_nirq = config->ic_nirq;
303 	for (i = 0; i < config->ic_nirq; i++) {
304 		uint32_t mask = config->ic_irqmask[i];
305 		int irq;
306 
307 		/* the PnP device may have a null resource as filler */
308 		if (mask == 0) {
309 			result->ic_irqmask[i] = 0;
310 			continue;
311 		}
312 
313 		for (irq = find_first_bit(mask);
314 		     irq != -1;
315 		     irq = find_next_bit(mask, irq)) {
316 			bus_set_resource(child, SYS_RES_IRQ, i,
317 					 irq, 1);
318 			res[i] = bus_alloc_resource_any(child,
319 							SYS_RES_IRQ, &i,
320 							0 /* !RF_ACTIVE */ );
321 			if (res[i]) {
322 				result->ic_irqmask[i] = (1 << irq);
323 				break;
324 			}
325 		}
326 
327 		/*
328 		 * If we didn't find a place for irq range i, then
329 		 * give up now.
330 		 */
331 		if (!res[i]) {
332 			success = 0;
333 			break;
334 		}
335 	}
336 
337 	for (i = 0; i < ISA_NIRQ; i++) {
338 		if (res[i])
339 			bus_release_resource(child, SYS_RES_IRQ,
340 					     i, res[i]);
341 	}
342 
343 	return (success);
344 }
345 
346 /*
347  * Find a working set of drqs for a child using the masks in *config
348  * and return the regions in *result. Returns non-zero if a set of
349  * drqs was found.
350  */
351 static int
352 isa_find_drq(device_t child, struct isa_config *config,
353     struct isa_config *result)
354 {
355 	int success, i;
356 	struct resource *res[ISA_NDRQ];
357 
358 	/*
359 	 * First clear out any existing resource definitions.
360 	 */
361 	for (i = 0; i < ISA_NDRQ; i++) {
362 		bus_delete_resource(child, SYS_RES_DRQ, i);
363 		res[i] = NULL;
364 	}
365 
366 	success = 1;
367 	result->ic_ndrq = config->ic_ndrq;
368 	for (i = 0; i < config->ic_ndrq; i++) {
369 		uint32_t mask = config->ic_drqmask[i];
370 		int drq;
371 
372 		/* the PnP device may have a null resource as filler */
373 		if (mask == 0) {
374 			result->ic_drqmask[i] = 0;
375 			continue;
376 		}
377 
378 		for (drq = find_first_bit(mask);
379 		     drq != -1;
380 		     drq = find_next_bit(mask, drq)) {
381 			bus_set_resource(child, SYS_RES_DRQ, i,
382 					 drq, 1);
383 			res[i] = bus_alloc_resource_any(child,
384 							SYS_RES_DRQ, &i,
385 							0 /* !RF_ACTIVE */);
386 			if (res[i]) {
387 				result->ic_drqmask[i] = (1 << drq);
388 				break;
389 			}
390 		}
391 
392 		/*
393 		 * If we didn't find a place for drq range i, then
394 		 * give up now.
395 		 */
396 		if (!res[i]) {
397 			success = 0;
398 			break;
399 		}
400 	}
401 
402 	for (i = 0; i < ISA_NDRQ; i++) {
403 		if (res[i])
404 			bus_release_resource(child, SYS_RES_DRQ,
405 					     i, res[i]);
406 	}
407 
408 	return (success);
409 }
410 
411 /*
412  * Attempt to find a working set of resources for a device. Return
413  * non-zero if a working configuration is found.
414  */
415 static int
416 isa_assign_resources(device_t child)
417 {
418 	struct isa_device *idev = DEVTOISA(child);
419 	struct isa_config_entry *ice;
420 	struct isa_config *cfg;
421 	const char *reason;
422 
423 	reason = "Empty ISA id_configs";
424 	cfg = malloc(sizeof(struct isa_config), M_TEMP, M_NOWAIT|M_ZERO);
425 	if (cfg == NULL)
426 		return(0);
427 	TAILQ_FOREACH(ice, &idev->id_configs, ice_link) {
428 		reason = "memory";
429 		if (!isa_find_memory(child, &ice->ice_config, cfg))
430 			continue;
431 		reason = "port";
432 		if (!isa_find_port(child, &ice->ice_config, cfg))
433 			continue;
434 		reason = "irq";
435 		if (!isa_find_irq(child, &ice->ice_config, cfg))
436 			continue;
437 		reason = "drq";
438 		if (!isa_find_drq(child, &ice->ice_config, cfg))
439 			continue;
440 
441 		/*
442 		 * A working configuration was found enable the device
443 		 * with this configuration.
444 		 */
445 		reason = "no callback";
446 		if (idev->id_config_cb) {
447 			idev->id_config_cb(idev->id_config_arg,
448 					   cfg, 1);
449 			free(cfg, M_TEMP);
450 			return (1);
451 		}
452 	}
453 
454 	/*
455 	 * Disable the device.
456 	 */
457 	bus_print_child_header(device_get_parent(child), child);
458 	printf(" can't assign resources (%s)\n", reason);
459 	if (bootverbose)
460 		isa_print_child(device_get_parent(child), child);
461 	bzero(cfg, sizeof (*cfg));
462 	if (idev->id_config_cb)
463 		idev->id_config_cb(idev->id_config_arg, cfg, 0);
464 	device_disable(child);
465 
466 	free(cfg, M_TEMP);
467 	return (0);
468 }
469 
470 /*
471  * Claim any unallocated resources to keep other devices from using
472  * them.
473  */
474 static void
475 isa_claim_resources(device_t dev, device_t child)
476 {
477 	struct isa_device *idev = DEVTOISA(child);
478 	struct resource_list *rl = &idev->id_resources;
479 	struct resource_list_entry *rle;
480 	int rid;
481 
482 	STAILQ_FOREACH(rle, rl, link) {
483 		if (!rle->res) {
484 			rid = rle->rid;
485 			resource_list_alloc(rl, dev, child, rle->type, &rid,
486 			    0ul, ~0ul, 1, 0);
487 		}
488 	}
489 }
490 
491 /*
492  * Called after other devices have initialised to probe for isa devices.
493  */
494 void
495 isa_probe_children(device_t dev)
496 {
497 	struct isa_device *idev;
498 	device_t *children, child;
499 	struct isa_config *cfg;
500 	int nchildren, i;
501 
502 	/*
503 	 * Create all the non-hinted children by calling drivers'
504 	 * identify methods.
505 	 */
506 	bus_generic_probe(dev);
507 
508 	if (device_get_children(dev, &children, &nchildren))
509 		return;
510 
511 	/*
512 	 * First disable all pnp devices so that they don't get
513 	 * matched by legacy probes.
514 	 */
515 	if (bootverbose)
516 		printf("isa_probe_children: disabling PnP devices\n");
517 
518 	cfg = malloc(sizeof(*cfg), M_TEMP, M_NOWAIT|M_ZERO);
519 	if (cfg == NULL) {
520 		free(children, M_TEMP);
521 		return;
522 	}
523 
524 	for (i = 0; i < nchildren; i++) {
525 		idev = DEVTOISA(children[i]);
526 
527 		bzero(cfg, sizeof(*cfg));
528 		if (idev->id_config_cb)
529 			idev->id_config_cb(idev->id_config_arg, cfg, 0);
530 	}
531 
532 	free(cfg, M_TEMP);
533 
534 	/*
535 	 * Next, probe all the PnP BIOS devices so they can subsume any
536 	 * hints.
537 	 */
538 	for (i = 0; i < nchildren; i++) {
539 		child = children[i];
540 		idev = DEVTOISA(child);
541 
542 		if (idev->id_order > ISA_ORDER_PNPBIOS)
543 			continue;
544 		if (!TAILQ_EMPTY(&idev->id_configs) &&
545 		    !isa_assign_resources(child))
546 			continue;
547 
548 		if (device_probe_and_attach(child) == 0)
549 			isa_claim_resources(dev, child);
550 	}
551 	free(children, M_TEMP);
552 
553 	/*
554 	 * Next, enumerate hinted devices and probe all non-pnp devices so
555 	 * that they claim their resources first.
556 	 */
557 	bus_enumerate_hinted_children(dev);
558 	if (device_get_children(dev, &children, &nchildren))
559 		return;
560 	if (bootverbose)
561 		printf("isa_probe_children: probing non-PnP devices\n");
562 	for (i = 0; i < nchildren; i++) {
563 		child = children[i];
564 		idev = DEVTOISA(child);
565 
566 		if (device_is_attached(child) ||
567 		    !TAILQ_EMPTY(&idev->id_configs))
568 			continue;
569 
570 		device_probe_and_attach(child);
571 	}
572 
573 	/*
574 	 * Finally assign resource to pnp devices and probe them.
575 	 */
576 	if (bootverbose)
577 		printf("isa_probe_children: probing PnP devices\n");
578 	for (i = 0; i < nchildren; i++) {
579 		child = children[i];
580 		idev = DEVTOISA(child);
581 
582 		if (device_is_attached(child) || TAILQ_EMPTY(&idev->id_configs))
583 			continue;
584 
585 		if (isa_assign_resources(child)) {
586 			device_probe_and_attach(child);
587 			isa_claim_resources(dev, child);
588 		}
589 	}
590 
591 	free(children, M_TEMP);
592 
593 	isa_running = 1;
594 }
595 
596 /*
597  * Add a new child with default ivars.
598  */
599 static device_t
600 isa_add_child(device_t dev, int order, const char *name, int unit)
601 {
602 	device_t child;
603 	struct	isa_device *idev;
604 
605 	child = device_add_child_ordered(dev, order, name, unit);
606 	if (child == NULL)
607 		return (child);
608 
609 	idev = malloc(sizeof(struct isa_device), M_ISADEV, M_NOWAIT | M_ZERO);
610 	if (!idev)
611 		return (0);
612 
613 	resource_list_init(&idev->id_resources);
614 	TAILQ_INIT(&idev->id_configs);
615 	idev->id_order = order;
616 
617 	device_set_ivars(child, idev);
618 
619 	return (child);
620 }
621 
622 static int
623 isa_print_all_resources(device_t dev)
624 {
625 	struct	isa_device *idev = DEVTOISA(dev);
626 	struct resource_list *rl = &idev->id_resources;
627 	int retval = 0;
628 
629 	if (STAILQ_FIRST(rl) || device_get_flags(dev))
630 		retval += printf(" at");
631 
632 	retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx");
633 	retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx");
634 	retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");
635 	retval += resource_list_print_type(rl, "drq", SYS_RES_DRQ, "%ld");
636 	if (device_get_flags(dev))
637 		retval += printf(" flags %#x", device_get_flags(dev));
638 #ifdef ISAPNP
639 	if (idev->id_vendorid)
640 		retval += printf(" pnpid %s", pnp_eisaformat(idev->id_vendorid));
641 #endif
642 
643 	return (retval);
644 }
645 
646 static int
647 isa_print_child(device_t bus, device_t dev)
648 {
649 	int retval = 0;
650 
651 	retval += bus_print_child_header(bus, dev);
652 	retval += isa_print_all_resources(dev);
653 	retval += bus_print_child_footer(bus, dev);
654 
655 	return (retval);
656 }
657 
658 static void
659 isa_probe_nomatch(device_t dev, device_t child)
660 {
661 	if (bootverbose) {
662 		bus_print_child_header(dev, child);
663 		printf(" failed to probe");
664 		isa_print_all_resources(child);
665 		bus_print_child_footer(dev, child);
666 	}
667 
668 	return;
669 }
670 
671 static int
672 isa_read_ivar(device_t bus, device_t dev, int index, uintptr_t * result)
673 {
674 	struct isa_device* idev = DEVTOISA(dev);
675 	struct resource_list *rl = &idev->id_resources;
676 	struct resource_list_entry *rle;
677 
678 	switch (index) {
679 	case ISA_IVAR_PORT_0:
680 		rle = resource_list_find(rl, SYS_RES_IOPORT, 0);
681 		if (rle)
682 			*result = rle->start;
683 		else
684 			*result = -1;
685 		break;
686 
687 	case ISA_IVAR_PORT_1:
688 		rle = resource_list_find(rl, SYS_RES_IOPORT, 1);
689 		if (rle)
690 			*result = rle->start;
691 		else
692 			*result = -1;
693 		break;
694 
695 	case ISA_IVAR_PORTSIZE_0:
696 		rle = resource_list_find(rl, SYS_RES_IOPORT, 0);
697 		if (rle)
698 			*result = rle->count;
699 		else
700 			*result = 0;
701 		break;
702 
703 	case ISA_IVAR_PORTSIZE_1:
704 		rle = resource_list_find(rl, SYS_RES_IOPORT, 1);
705 		if (rle)
706 			*result = rle->count;
707 		else
708 			*result = 0;
709 		break;
710 
711 	case ISA_IVAR_MADDR_0:
712 		rle = resource_list_find(rl, SYS_RES_MEMORY, 0);
713 		if (rle)
714 			*result = rle->start;
715 		else
716 			*result = -1;
717 		break;
718 
719 	case ISA_IVAR_MADDR_1:
720 		rle = resource_list_find(rl, SYS_RES_MEMORY, 1);
721 		if (rle)
722 			*result = rle->start;
723 		else
724 			*result = -1;
725 		break;
726 
727 	case ISA_IVAR_MEMSIZE_0:
728 		rle = resource_list_find(rl, SYS_RES_MEMORY, 0);
729 		if (rle)
730 			*result = rle->count;
731 		else
732 			*result = 0;
733 		break;
734 
735 	case ISA_IVAR_MEMSIZE_1:
736 		rle = resource_list_find(rl, SYS_RES_MEMORY, 1);
737 		if (rle)
738 			*result = rle->count;
739 		else
740 			*result = 0;
741 		break;
742 
743 	case ISA_IVAR_IRQ_0:
744 		rle = resource_list_find(rl, SYS_RES_IRQ, 0);
745 		if (rle)
746 			*result = rle->start;
747 		else
748 			*result = -1;
749 		break;
750 
751 	case ISA_IVAR_IRQ_1:
752 		rle = resource_list_find(rl, SYS_RES_IRQ, 1);
753 		if (rle)
754 			*result = rle->start;
755 		else
756 			*result = -1;
757 		break;
758 
759 	case ISA_IVAR_DRQ_0:
760 		rle = resource_list_find(rl, SYS_RES_DRQ, 0);
761 		if (rle)
762 			*result = rle->start;
763 		else
764 			*result = -1;
765 		break;
766 
767 	case ISA_IVAR_DRQ_1:
768 		rle = resource_list_find(rl, SYS_RES_DRQ, 1);
769 		if (rle)
770 			*result = rle->start;
771 		else
772 			*result = -1;
773 		break;
774 
775 	case ISA_IVAR_VENDORID:
776 		*result = idev->id_vendorid;
777 		break;
778 
779 	case ISA_IVAR_SERIAL:
780 		*result = idev->id_serial;
781 		break;
782 
783 	case ISA_IVAR_LOGICALID:
784 		*result = idev->id_logicalid;
785 		break;
786 
787 	case ISA_IVAR_COMPATID:
788 		*result = idev->id_compatid;
789 		break;
790 
791 	case ISA_IVAR_CONFIGATTR:
792 		*result = idev->id_config_attr;
793 		break;
794 
795 	case ISA_IVAR_PNP_CSN:
796 		*result = idev->id_pnp_csn;
797 		break;
798 
799 	case ISA_IVAR_PNP_LDN:
800 		*result = idev->id_pnp_ldn;
801 		break;
802 
803 	case ISA_IVAR_PNPBIOS_HANDLE:
804 		*result = idev->id_pnpbios_handle;
805 		break;
806 
807 	default:
808 		return (ENOENT);
809 	}
810 
811 	return (0);
812 }
813 
814 static int
815 isa_write_ivar(device_t bus, device_t dev, int index, uintptr_t value)
816 {
817 	struct isa_device* idev = DEVTOISA(dev);
818 
819 	switch (index) {
820 	case ISA_IVAR_PORT_0:
821 	case ISA_IVAR_PORT_1:
822 	case ISA_IVAR_PORTSIZE_0:
823 	case ISA_IVAR_PORTSIZE_1:
824 	case ISA_IVAR_MADDR_0:
825 	case ISA_IVAR_MADDR_1:
826 	case ISA_IVAR_MEMSIZE_0:
827 	case ISA_IVAR_MEMSIZE_1:
828 	case ISA_IVAR_IRQ_0:
829 	case ISA_IVAR_IRQ_1:
830 	case ISA_IVAR_DRQ_0:
831 	case ISA_IVAR_DRQ_1:
832 		return (EINVAL);
833 
834 	case ISA_IVAR_VENDORID:
835 		idev->id_vendorid = value;
836 		break;
837 
838 	case ISA_IVAR_SERIAL:
839 		idev->id_serial = value;
840 		break;
841 
842 	case ISA_IVAR_LOGICALID:
843 		idev->id_logicalid = value;
844 		break;
845 
846 	case ISA_IVAR_COMPATID:
847 		idev->id_compatid = value;
848 		break;
849 
850 	case ISA_IVAR_CONFIGATTR:
851 		idev->id_config_attr = value;
852 		break;
853 
854 	default:
855 		return (ENOENT);
856 	}
857 
858 	return (0);
859 }
860 
861 /*
862  * Free any resources which the driver missed or which we were holding for
863  * it (see isa_probe_children).
864  */
865 static void
866 isa_child_detached(device_t dev, device_t child)
867 {
868 	struct isa_device* idev = DEVTOISA(child);
869 
870 	if (TAILQ_FIRST(&idev->id_configs))
871 		isa_claim_resources(dev, child);
872 }
873 
874 static void
875 isa_driver_added(device_t dev, driver_t *driver)
876 {
877 	device_t *children;
878 	int nchildren, i;
879 
880 	/*
881 	 * Don't do anything if drivers are dynamically
882 	 * added during autoconfiguration (cf. ymf724).
883 	 * since that would end up calling identify
884 	 * twice.
885 	 */
886 	if (!isa_running)
887 		return;
888 
889 	DEVICE_IDENTIFY(driver, dev);
890 	if (device_get_children(dev, &children, &nchildren))
891 		return;
892 
893 	for (i = 0; i < nchildren; i++) {
894 		device_t child = children[i];
895 		struct isa_device *idev = DEVTOISA(child);
896 		struct resource_list *rl = &idev->id_resources;
897 		struct resource_list_entry *rle;
898 
899 		if (device_get_state(child) != DS_NOTPRESENT)
900 			continue;
901 		if (!device_is_enabled(child))
902 			continue;
903 
904 		/*
905 		 * Free resources which we were holding on behalf of
906 		 * the device.
907 		 */
908 		STAILQ_FOREACH(rle, &idev->id_resources, link) {
909 			if (rle->res)
910 				resource_list_release(rl, dev, child,
911 						      rle->type,
912 						      rle->rid,
913 						      rle->res);
914 		}
915 
916 		if (TAILQ_FIRST(&idev->id_configs))
917 			if (!isa_assign_resources(child))
918 				continue;
919 
920 		device_probe_and_attach(child);
921 
922 		if (TAILQ_FIRST(&idev->id_configs))
923 			isa_claim_resources(dev, child);
924 	}
925 
926 	free(children, M_TEMP);
927 }
928 
929 static int
930 isa_set_resource(device_t dev, device_t child, int type, int rid,
931     u_long start, u_long count)
932 {
933 	struct isa_device* idev = DEVTOISA(child);
934 	struct resource_list *rl = &idev->id_resources;
935 
936 	if (type != SYS_RES_IOPORT && type != SYS_RES_MEMORY
937 	    && type != SYS_RES_IRQ && type != SYS_RES_DRQ)
938 		return (EINVAL);
939 	if (rid < 0)
940 		return (EINVAL);
941 	if (type == SYS_RES_IOPORT && rid >= ISA_NPORT)
942 		return (EINVAL);
943 	if (type == SYS_RES_MEMORY && rid >= ISA_NMEM)
944 		return (EINVAL);
945 	if (type == SYS_RES_IRQ && rid >= ISA_NIRQ)
946 		return (EINVAL);
947 	if (type == SYS_RES_DRQ && rid >= ISA_NDRQ)
948 		return (EINVAL);
949 
950 	resource_list_add(rl, type, rid, start, start + count - 1, count);
951 
952 	return (0);
953 }
954 
955 static struct resource_list *
956 isa_get_resource_list (device_t dev, device_t child)
957 {
958 	struct isa_device* idev = DEVTOISA(child);
959 	struct resource_list *rl = &idev->id_resources;
960 
961 	if (!rl)
962 		return (NULL);
963 
964 	return (rl);
965 }
966 
967 static int
968 isa_add_config(device_t dev, device_t child, int priority,
969     struct isa_config *config)
970 {
971 	struct isa_device* idev = DEVTOISA(child);
972 	struct isa_config_entry *newice, *ice;
973 
974 	newice = malloc(sizeof *ice, M_DEVBUF, M_NOWAIT);
975 	if (!newice)
976 		return (ENOMEM);
977 
978 	newice->ice_priority = priority;
979 	newice->ice_config = *config;
980 
981 	TAILQ_FOREACH(ice, &idev->id_configs, ice_link) {
982 		if (ice->ice_priority > priority)
983 			break;
984 	}
985 	if (ice)
986 		TAILQ_INSERT_BEFORE(ice, newice, ice_link);
987 	else
988 		TAILQ_INSERT_TAIL(&idev->id_configs, newice, ice_link);
989 
990 	return (0);
991 }
992 
993 static void
994 isa_set_config_callback(device_t dev, device_t child, isa_config_cb *fn,
995     void *arg)
996 {
997 	struct isa_device* idev = DEVTOISA(child);
998 
999 	idev->id_config_cb = fn;
1000 	idev->id_config_arg = arg;
1001 }
1002 
1003 static int
1004 isa_pnp_probe(device_t dev, device_t child, struct isa_pnp_id *ids)
1005 {
1006 	struct isa_device* idev = DEVTOISA(child);
1007 
1008 	if (!idev->id_vendorid)
1009 		return (ENOENT);
1010 
1011 	while (ids && ids->ip_id) {
1012 		/*
1013 		 * Really ought to support >1 compat id per device.
1014 		 */
1015 		if (idev->id_logicalid == ids->ip_id
1016 		    || idev->id_compatid == ids->ip_id) {
1017 			if (ids->ip_desc)
1018 				device_set_desc(child, ids->ip_desc);
1019 			return (0);
1020 		}
1021 		ids++;
1022 	}
1023 
1024 	return (ENXIO);
1025 }
1026 
1027 static int
1028 isa_child_pnpinfo_str(device_t bus, device_t child, char *buf,
1029     size_t buflen)
1030 {
1031 #ifdef ISAPNP
1032 	struct isa_device *idev = DEVTOISA(child);
1033 
1034 	if (idev->id_vendorid)
1035 		snprintf(buf, buflen, "pnpid=%s",
1036 		    pnp_eisaformat(idev->id_vendorid));
1037 #endif
1038 	return (0);
1039 }
1040 
1041 static int
1042 isa_child_location_str(device_t bus, device_t child, char *buf,
1043     size_t buflen)
1044 {
1045 #if 0
1046 	/* id_pnphandle isn't there yet */
1047 	struct isa_device *idev = DEVTOISA(child);
1048 
1049 	if (idev->id_vendorid)
1050 		snprintf(buf, buflen, "pnphandle=%d", idev->id_pnphandle);
1051 #endif
1052 	/* Nothing here yet */
1053 	*buf = '\0';
1054 	return (0);
1055 }
1056 
1057 static device_method_t isa_methods[] = {
1058 	/* Device interface */
1059 	DEVMETHOD(device_probe,		isa_probe),
1060 	DEVMETHOD(device_attach,	isa_attach),
1061 	DEVMETHOD(device_detach,	bus_generic_detach),
1062 	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
1063 	DEVMETHOD(device_suspend,	bus_generic_suspend),
1064 	DEVMETHOD(device_resume,	bus_generic_resume),
1065 
1066 	/* Bus interface */
1067 	DEVMETHOD(bus_add_child,	isa_add_child),
1068 	DEVMETHOD(bus_print_child,	isa_print_child),
1069 	DEVMETHOD(bus_probe_nomatch,	isa_probe_nomatch),
1070 	DEVMETHOD(bus_read_ivar,	isa_read_ivar),
1071 	DEVMETHOD(bus_write_ivar,	isa_write_ivar),
1072 	DEVMETHOD(bus_child_detached,	isa_child_detached),
1073 	DEVMETHOD(bus_driver_added,	isa_driver_added),
1074 	DEVMETHOD(bus_setup_intr,	isa_setup_intr),
1075 	DEVMETHOD(bus_teardown_intr,	isa_teardown_intr),
1076 
1077 	DEVMETHOD(bus_get_resource_list,isa_get_resource_list),
1078 	DEVMETHOD(bus_alloc_resource,	isa_alloc_resource),
1079 	DEVMETHOD(bus_release_resource,	isa_release_resource),
1080 	DEVMETHOD(bus_set_resource,	isa_set_resource),
1081 	DEVMETHOD(bus_get_resource,	bus_generic_rl_get_resource),
1082 	DEVMETHOD(bus_delete_resource,	bus_generic_rl_delete_resource),
1083 	DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1084 	DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1085 	DEVMETHOD(bus_child_pnpinfo_str, isa_child_pnpinfo_str),
1086 	DEVMETHOD(bus_child_location_str, isa_child_location_str),
1087 	DEVMETHOD(bus_hinted_child,	isa_hinted_child),
1088 	DEVMETHOD(bus_hint_device_unit,	isa_hint_device_unit),
1089 
1090 	/* ISA interface */
1091 	DEVMETHOD(isa_add_config,	isa_add_config),
1092 	DEVMETHOD(isa_set_config_callback, isa_set_config_callback),
1093 	DEVMETHOD(isa_pnp_probe,	isa_pnp_probe),
1094 
1095 	{ 0, 0 }
1096 };
1097 
1098 DEFINE_CLASS_0(isa, isa_driver, isa_methods, 0);
1099 
1100 devclass_t isa_devclass;
1101 
1102 /*
1103  * ISA can be attached to a PCI-ISA bridge, or other locations on some
1104  * platforms.
1105  */
1106 DRIVER_MODULE(isa, isab, isa_driver, isa_devclass, 0, 0);
1107 DRIVER_MODULE(isa, eisab, isa_driver, isa_devclass, 0, 0);
1108 MODULE_VERSION(isa, 1);
1109 
1110 /*
1111  * Code common to ISA bridges.
1112  */
1113 
1114 devclass_t isab_devclass;
1115 
1116 int
1117 isab_attach(device_t dev)
1118 {
1119 	device_t child;
1120 
1121 	child = device_add_child(dev, "isa", 0);
1122 	if (child != NULL)
1123 		return (bus_generic_attach(dev));
1124 	return (ENXIO);
1125 }
1126