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