Make nexus understand the new INTR_ flags, mainly INTR_ENTROPY.
[dragonfly.git] / sys / platform / pc32 / i386 / nexus.c
1 /*
2  * Copyright 1998 Massachusetts Institute of Technology
3  *
4  * Permission to use, copy, modify, and distribute this software and
5  * its documentation for any purpose and without fee is hereby
6  * granted, provided that both the above copyright notice and this
7  * permission notice appear in all copies, that both the above
8  * copyright notice and this permission notice appear in all
9  * supporting documentation, and that the name of M.I.T. not be used
10  * in advertising or publicity pertaining to distribution of the
11  * software without specific, written prior permission.  M.I.T. makes
12  * no representations about the suitability of this software for any
13  * purpose.  It is provided "as is" without express or implied
14  * warranty.
15  * 
16  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
17  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
18  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
20  * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $FreeBSD: src/sys/i386/i386/nexus.c,v 1.26.2.10 2003/02/22 13:16:45 imp Exp $
30  * $DragonFly: src/sys/platform/pc32/i386/nexus.c,v 1.9 2004/02/23 21:23:42 dillon Exp $
31  */
32
33 /*
34  * This code implements a `root nexus' for Intel Architecture
35  * machines.  The function of the root nexus is to serve as an
36  * attachment point for both processors and buses, and to manage
37  * resources which are common to all of them.  In particular,
38  * this code implements the core resource managers for interrupt
39  * requests, DMA requests (which rightfully should be a part of the
40  * ISA code but it's easier to do it here for now), I/O port addresses,
41  * and I/O memory address space.
42  */
43
44 #include "use_mca.h"
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/bus.h>
49 #include <sys/kernel.h>
50 #include <sys/malloc.h>
51 #include <sys/module.h>
52 #include <machine/bus.h>
53 #include <sys/rman.h>
54
55 #include <machine/vmparam.h>
56 #include <vm/vm.h>
57 #include <vm/pmap.h>
58 #include <machine/pmap.h>
59
60 #include <machine/nexusvar.h>
61 #include <machine/resource.h>
62 #ifdef APIC_IO
63 #include <machine/smp.h>
64 #include <machine/mpapic.h>
65 #endif
66
67 #include <bus/isa/isavar.h>
68 #ifdef PC98
69 #include <pc98/pc98/pc98.h>
70 #else
71 #include <bus/isa/i386/isa.h>
72 #endif
73 #include <i386/isa/intr_machdep.h>
74
75 static MALLOC_DEFINE(M_NEXUSDEV, "nexusdev", "Nexus device");
76 struct nexus_device {
77         struct resource_list    nx_resources;
78         int                     nx_pcibus;
79 };
80
81 #define DEVTONX(dev)    ((struct nexus_device *)device_get_ivars(dev))
82
83 static struct rman irq_rman, drq_rman, port_rman, mem_rman;
84
85 static  int nexus_probe(device_t);
86 static  int nexus_attach(device_t);
87 static  int nexus_print_all_resources(device_t dev);
88 static  int nexus_print_child(device_t, device_t);
89 static device_t nexus_add_child(device_t bus, int order, const char *name,
90                                 int unit);
91 static  struct resource *nexus_alloc_resource(device_t, device_t, int, int *,
92                                               u_long, u_long, u_long, u_int);
93 static  int nexus_read_ivar(device_t, device_t, int, uintptr_t *);
94 static  int nexus_write_ivar(device_t, device_t, int, uintptr_t);
95 static  int nexus_activate_resource(device_t, device_t, int, int,
96                                     struct resource *);
97 static  int nexus_deactivate_resource(device_t, device_t, int, int,
98                                       struct resource *);
99 static  int nexus_release_resource(device_t, device_t, int, int,
100                                    struct resource *);
101 static  int nexus_setup_intr(device_t, device_t, struct resource *, int flags,
102                              void (*)(void *), void *, void **);
103 static  int nexus_teardown_intr(device_t, device_t, struct resource *,
104                                 void *);
105 static  int nexus_set_resource(device_t, device_t, int, int, u_long, u_long);
106 static  int nexus_get_resource(device_t, device_t, int, int, u_long *, u_long *);
107 static void nexus_delete_resource(device_t, device_t, int, int);
108
109 static device_method_t nexus_methods[] = {
110         /* Device interface */
111         DEVMETHOD(device_probe,         nexus_probe),
112         DEVMETHOD(device_attach,        nexus_attach),
113         DEVMETHOD(device_detach,        bus_generic_detach),
114         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
115         DEVMETHOD(device_suspend,       bus_generic_suspend),
116         DEVMETHOD(device_resume,        bus_generic_resume),
117
118         /* Bus interface */
119         DEVMETHOD(bus_print_child,      nexus_print_child),
120         DEVMETHOD(bus_add_child,        nexus_add_child),
121         DEVMETHOD(bus_read_ivar,        nexus_read_ivar),
122         DEVMETHOD(bus_write_ivar,       nexus_write_ivar),
123         DEVMETHOD(bus_alloc_resource,   nexus_alloc_resource),
124         DEVMETHOD(bus_release_resource, nexus_release_resource),
125         DEVMETHOD(bus_activate_resource, nexus_activate_resource),
126         DEVMETHOD(bus_deactivate_resource, nexus_deactivate_resource),
127         DEVMETHOD(bus_setup_intr,       nexus_setup_intr),
128         DEVMETHOD(bus_teardown_intr,    nexus_teardown_intr),
129         DEVMETHOD(bus_set_resource,     nexus_set_resource),
130         DEVMETHOD(bus_get_resource,     nexus_get_resource),
131         DEVMETHOD(bus_delete_resource,  nexus_delete_resource),
132
133         { 0, 0 }
134 };
135
136 static driver_t nexus_driver = {
137         "nexus",
138         nexus_methods,
139         1,                      /* no softc */
140 };
141 static devclass_t nexus_devclass;
142
143 DRIVER_MODULE(nexus, root, nexus_driver, nexus_devclass, 0, 0);
144
145 static int
146 nexus_probe(device_t dev)
147 {
148
149         device_quiet(dev);      /* suppress attach message for neatness */
150
151         /*
152          * IRQ's are on the mainboard on old systems, but on the ISA part
153          * of PCI->ISA bridges.  There would be multiple sets of IRQs on
154          * multi-ISA-bus systems.  PCI interrupts are routed to the ISA
155          * component, so in a way, PCI can be a partial child of an ISA bus(!).
156          * APIC interrupts are global though.
157          * In the non-APIC case, disallow the use of IRQ 2.
158          */
159         irq_rman.rm_start = 0;
160         irq_rman.rm_type = RMAN_ARRAY;
161         irq_rman.rm_descr = "Interrupt request lines";
162 #ifdef APIC_IO
163         irq_rman.rm_end = APIC_INTMAPSIZE - 1;
164         if (rman_init(&irq_rman)
165             || rman_manage_region(&irq_rman,
166                                   irq_rman.rm_start, irq_rman.rm_end))
167                 panic("nexus_probe irq_rman");
168 #else
169         irq_rman.rm_end = 15;
170 #ifdef PC98
171         if (rman_init(&irq_rman)
172             || rman_manage_region(&irq_rman,
173                                   irq_rman.rm_start, irq_rman.rm_end))
174                 panic("nexus_probe irq_rman");
175 #else
176         if (rman_init(&irq_rman)
177             || rman_manage_region(&irq_rman, irq_rman.rm_start, 1)
178             || rman_manage_region(&irq_rman, 3, irq_rman.rm_end))
179                 panic("nexus_probe irq_rman");
180 #endif /* PC98 */
181 #endif
182
183         /*
184          * ISA DMA on PCI systems is implemented in the ISA part of each
185          * PCI->ISA bridge and the channels can be duplicated if there are
186          * multiple bridges.  (eg: laptops with docking stations)
187          */
188         drq_rman.rm_start = 0;
189 #ifdef PC98
190         drq_rman.rm_end = 3;
191 #else
192         drq_rman.rm_end = 7;
193 #endif
194         drq_rman.rm_type = RMAN_ARRAY;
195         drq_rman.rm_descr = "DMA request lines";
196         /* XXX drq 0 not available on some machines */
197         if (rman_init(&drq_rman)
198             || rman_manage_region(&drq_rman,
199                                   drq_rman.rm_start, drq_rman.rm_end))
200                 panic("nexus_probe drq_rman");
201
202         /*
203          * However, IO ports and Memory truely are global at this level,
204          * as are APIC interrupts (however many IO APICS there turn out
205          * to be on large systems..)
206          */
207         port_rman.rm_start = 0;
208         port_rman.rm_end = 0xffff;
209         port_rman.rm_type = RMAN_ARRAY;
210         port_rman.rm_descr = "I/O ports";
211         if (rman_init(&port_rman)
212             || rman_manage_region(&port_rman, 0, 0xffff))
213                 panic("nexus_probe port_rman");
214
215         mem_rman.rm_start = 0;
216         mem_rman.rm_end = ~0u;
217         mem_rman.rm_type = RMAN_ARRAY;
218         mem_rman.rm_descr = "I/O memory addresses";
219         if (rman_init(&mem_rman)
220             || rman_manage_region(&mem_rman, 0, ~0))
221                 panic("nexus_probe mem_rman");
222
223         return bus_generic_probe(dev);
224 }
225
226 static int
227 nexus_attach(device_t dev)
228 {
229         device_t        child;
230
231         /*
232          * First, deal with the children we know about already
233          */
234         bus_generic_attach(dev);
235         /*
236          * And if we didn't see EISA or ISA on a pci bridge, create some
237          * connection points now so they show up "on motherboard".
238          */
239         if (!devclass_get_device(devclass_find("eisa"), 0)) {
240                 child = BUS_ADD_CHILD(dev, 0, "eisa", 0);
241                 if (child == NULL)
242                         panic("nexus_attach eisa");
243                 device_probe_and_attach(child);
244         }
245 #if NMCA > 0
246         if (!devclass_get_device(devclass_find("mca"), 0)) {
247                 child = BUS_ADD_CHILD(dev, 0, "mca", 0);
248                 if (child == NULL)
249                         panic("nexus_probe mca");
250                 device_probe_and_attach(child);
251         }
252 #endif
253         if (!devclass_get_device(devclass_find("isa"), 0)) {
254                 child = BUS_ADD_CHILD(dev, 0, "isa", 0);
255                 if (child == NULL)
256                         panic("nexus_attach isa");
257                 device_probe_and_attach(child);
258         }
259
260         return 0;
261 }
262
263 static int
264 nexus_print_all_resources(device_t dev)
265 {
266         struct  nexus_device *ndev = DEVTONX(dev);
267         struct resource_list *rl = &ndev->nx_resources;
268         int retval = 0;
269
270         if (SLIST_FIRST(rl) || ndev->nx_pcibus != -1)
271                 retval += printf(" at");
272         
273         retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx");
274         retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx");
275         retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");
276
277         return retval;
278 }
279
280 static int
281 nexus_print_child(device_t bus, device_t child)
282 {
283         struct  nexus_device *ndev = DEVTONX(child);
284         int retval = 0;
285
286         retval += bus_print_child_header(bus, child);
287         retval += nexus_print_all_resources(child);
288         if (ndev->nx_pcibus != -1)
289                 retval += printf(" pcibus %d", ndev->nx_pcibus);
290         retval += printf(" on motherboard\n");
291
292         return (retval);
293 }
294
295 static device_t
296 nexus_add_child(device_t bus, int order, const char *name, int unit)
297 {
298         device_t                child;
299         struct nexus_device     *ndev;
300
301         ndev = malloc(sizeof(struct nexus_device), M_NEXUSDEV, M_NOWAIT|M_ZERO);
302         if (!ndev)
303                 return(0);
304         resource_list_init(&ndev->nx_resources);
305         ndev->nx_pcibus = -1;
306
307         child = device_add_child_ordered(bus, order, name, unit); 
308
309         /* should we free this in nexus_child_detached? */
310         device_set_ivars(child, ndev);
311
312         return(child);
313 }
314
315 static int
316 nexus_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
317 {
318         struct nexus_device *ndev = DEVTONX(child);
319         
320         switch (which) {
321         case NEXUS_IVAR_PCIBUS:
322                 *result = ndev->nx_pcibus;
323                 break;
324         default:
325                 return ENOENT;
326         }
327         return 0;
328 }
329
330 static int
331 nexus_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
332 {
333         struct nexus_device *ndev = DEVTONX(child);
334         
335         switch (which) {
336         case NEXUS_IVAR_PCIBUS:
337                 ndev->nx_pcibus = value;
338                 break;
339         default:
340                 return ENOENT;
341         }
342         return 0;
343 }
344
345 /*
346  * Allocate a resource on behalf of child.  NB: child is usually going to be a
347  * child of one of our descendants, not a direct child of nexus0.
348  * (Exceptions include npx.)
349  */
350 static struct resource *
351 nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,
352                      u_long start, u_long end, u_long count, u_int flags)
353 {
354         struct nexus_device *ndev = DEVTONX(child);
355         struct  resource *rv;
356         struct resource_list_entry *rle;
357         struct  rman *rm;
358         int needactivate = flags & RF_ACTIVE;
359
360         /*
361          * If this is an allocation of the "default" range for a given RID, and
362          * we know what the resources for this device are (ie. they aren't maintained
363          * by a child bus), then work out the start/end values.
364          */
365         if ((start == 0UL) && (end == ~0UL) && (count == 1)) {
366                 if (ndev == NULL)
367                         return(NULL);
368                 rle = resource_list_find(&ndev->nx_resources, type, *rid);
369                 if (rle == NULL)
370                         return(NULL);
371                 start = rle->start;
372                 end = rle->end;
373                 count = rle->count;
374         }
375
376         flags &= ~RF_ACTIVE;
377
378         switch (type) {
379         case SYS_RES_IRQ:
380                 rm = &irq_rman;
381                 break;
382
383         case SYS_RES_DRQ:
384                 rm = &drq_rman;
385                 break;
386
387         case SYS_RES_IOPORT:
388                 rm = &port_rman;
389                 break;
390
391         case SYS_RES_MEMORY:
392                 rm = &mem_rman;
393                 break;
394
395         default:
396                 return 0;
397         }
398
399         rv = rman_reserve_resource(rm, start, end, count, flags, child);
400         if (rv == 0)
401                 return 0;
402
403         if (type == SYS_RES_MEMORY) {
404                 rman_set_bustag(rv, I386_BUS_SPACE_MEM);
405         } else if (type == SYS_RES_IOPORT) {
406                 rman_set_bustag(rv, I386_BUS_SPACE_IO);
407 #ifndef PC98
408                 rman_set_bushandle(rv, rv->r_start);
409 #endif
410         }
411
412 #ifdef PC98
413         if ((type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) &&
414             i386_bus_space_handle_alloc(rv->r_bustag, rv->r_start, count,
415                                         &rv->r_bushandle) != 0) {
416                 rman_release_resource(rv);
417                 return 0;
418         }
419 #endif
420
421         if (needactivate) {
422                 if (bus_activate_resource(child, type, *rid, rv)) {
423 #ifdef PC98
424                         if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
425                                 i386_bus_space_handle_free(rv->r_bustag,
426                                   rv->r_bushandle, rv->r_bushandle->bsh_sz);
427                         }
428 #endif
429                         rman_release_resource(rv);
430                         return 0;
431                 }
432         }
433         
434         return rv;
435 }
436
437 static int
438 nexus_activate_resource(device_t bus, device_t child, int type, int rid,
439                         struct resource *r)
440 {
441         /*
442          * If this is a memory resource, map it into the kernel.
443          */
444         if (rman_get_bustag(r) == I386_BUS_SPACE_MEM) {
445                 caddr_t vaddr = 0;
446
447                 if (rman_get_end(r) < 1024 * 1024) {
448                         /*
449                          * The first 1Mb is mapped at KERNBASE.
450                          */
451                         vaddr = (caddr_t)(uintptr_t)(KERNBASE + rman_get_start(r));
452                 } else {
453                         u_int32_t paddr;
454                         u_int32_t psize;
455                         u_int32_t poffs;
456
457                         paddr = rman_get_start(r);
458                         psize = rman_get_size(r);
459
460                         poffs = paddr - trunc_page(paddr);
461                         vaddr = (caddr_t) pmap_mapdev(paddr-poffs, psize+poffs) + poffs;
462                 }
463                 rman_set_virtual(r, vaddr);
464 #ifdef PC98
465                 /* PC-98: the type of bus_space_handle_t is the structure. */
466                 r->r_bushandle->bsh_base = (bus_addr_t) vaddr;
467 #else
468                 /* IBM-PC: the type of bus_space_handle_t is u_int */
469                 rman_set_bushandle(r, (bus_space_handle_t) vaddr);
470 #endif
471         }
472         return (rman_activate_resource(r));
473 }
474
475 static int
476 nexus_deactivate_resource(device_t bus, device_t child, int type, int rid,
477                           struct resource *r)
478 {
479         /*
480          * If this is a memory resource, unmap it.
481          */
482         if ((rman_get_bustag(r) == I386_BUS_SPACE_MEM) &&
483             (rman_get_end(r) >= 1024 * 1024)) {
484                 u_int32_t psize;
485
486                 psize = rman_get_size(r);
487                 pmap_unmapdev((vm_offset_t)rman_get_virtual(r), psize);
488         }
489                 
490         return (rman_deactivate_resource(r));
491 }
492
493 static int
494 nexus_release_resource(device_t bus, device_t child, int type, int rid,
495                        struct resource *r)
496 {
497         if (rman_get_flags(r) & RF_ACTIVE) {
498                 int error = bus_deactivate_resource(child, type, rid, r);
499                 if (error)
500                         return error;
501         }
502 #ifdef PC98
503         if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
504                 i386_bus_space_handle_free(r->r_bustag, r->r_bushandle,
505                                            r->r_bushandle->bsh_sz);
506         }
507 #endif
508         return (rman_release_resource(r));
509 }
510
511 /*
512  * Currently this uses the really grody interface from kern/kern_intr.c
513  * (which really doesn't belong in kern/anything.c).  Eventually, all of
514  * the code in kern_intr.c and machdep_intr.c should get moved here, since
515  * this is going to be the official interface.
516  */
517 static int
518 nexus_setup_intr(device_t bus, device_t child, struct resource *irq,
519                  int flags, void (*ihand)(void *), void *arg, void **cookiep)
520 {
521         intrmask_t      *mask;
522         driver_t        *driver;
523         int     error, icflags;
524
525         /* somebody tried to setup an irq that failed to allocate! */
526         if (irq == NULL)
527                 panic("nexus_setup_intr: NULL irq resource!");
528
529         *cookiep = 0;
530         if (irq->r_flags & RF_SHAREABLE)
531                 icflags = 0;
532         else
533                 icflags = INTR_EXCL;
534
535         driver = device_get_driver(child);
536         switch (flags & INTR_TYPE_MASK) {
537         case INTR_TYPE_AV:
538         case INTR_TYPE_TTY:
539                 mask = &tty_imask;
540                 break;
541         case INTR_TYPE_BIO:
542                 mask = &bio_imask;
543                 break;
544         case INTR_TYPE_NET:
545                 mask = &net_imask;
546                 break;
547         case INTR_TYPE_CAM:
548                 mask = &cam_imask;
549                 break;
550         case INTR_TYPE_CLK:
551                 mask = 0;
552                 printf("nexus: Warning: do not know what imask to use for INTR_TYPE_CLK\n");
553                 break;
554         case INTR_TYPE_MISC:
555                 mask = 0;
556                 break;
557         default:
558                 panic("still using grody create_intr interface");
559         }
560         if (flags & INTR_FAST)
561                 icflags |= INTR_FAST;
562
563         /*
564          * We depend here on rman_activate_resource() being idempotent.
565          */
566         error = rman_activate_resource(irq);
567         if (error)
568                 return (error);
569
570         *cookiep = inthand_add(device_get_nameunit(child), irq->r_start,
571             ihand, arg, mask, icflags);
572         if (*cookiep == NULL)
573                 error = EINVAL; /* XXX ??? */
574
575         return (error);
576 }
577
578 static int
579 nexus_teardown_intr(device_t dev, device_t child, struct resource *r, void *ih)
580 {
581         return (inthand_remove(ih));
582 }
583
584 static int
585 nexus_set_resource(device_t dev, device_t child, int type, int rid, u_long start, u_long count)
586 {
587         struct nexus_device     *ndev = DEVTONX(child);
588         struct resource_list    *rl = &ndev->nx_resources;
589
590         /* XXX this should return a success/failure indicator */
591         resource_list_add(rl, type, rid, start, start + count - 1, count);
592         return(0);
593 }
594
595 static int
596 nexus_get_resource(device_t dev, device_t child, int type, int rid, u_long *startp, u_long *countp)
597 {
598         struct nexus_device     *ndev = DEVTONX(child);
599         struct resource_list    *rl = &ndev->nx_resources;
600         struct resource_list_entry *rle;
601
602         rle = resource_list_find(rl, type, rid);
603         device_printf(child, "type %d  rid %d  startp %p  countp %p - got %p\n",
604                       type, rid, startp, countp, rle);
605         if (!rle)
606                 return(ENOENT);
607         if (startp)
608                 *startp = rle->start;
609         if (countp)
610                 *countp = rle->count;
611         return(0);
612 }
613
614 static void
615 nexus_delete_resource(device_t dev, device_t child, int type, int rid)
616 {
617         struct nexus_device     *ndev = DEVTONX(child);
618         struct resource_list    *rl = &ndev->nx_resources;
619
620         resource_list_delete(rl, type, rid);
621 }
622
623 /*
624  * Placeholder which claims PnP 'devices' which describe system
625  * resources.
626  */
627 static struct isa_pnp_id sysresource_ids[] = {
628         { 0x010cd041 /* PNP0c01 */, "System Memory" },
629         { 0x020cd041 /* PNP0c02 */, "System Resource" },
630         { 0 }
631 };
632
633 static int
634 sysresource_probe(device_t dev)
635 {
636         int     result;
637
638         if ((result = ISA_PNP_PROBE(device_get_parent(dev), dev, sysresource_ids)) >= 0) {
639                 device_quiet(dev);
640         }
641         return (result);
642 }
643
644 static int
645 sysresource_attach(device_t dev)
646 {
647         return (0);
648 }
649
650 static device_method_t sysresource_methods[] = {
651         /* Device interface */
652         DEVMETHOD(device_probe,         sysresource_probe),
653         DEVMETHOD(device_attach,        sysresource_attach),
654         DEVMETHOD(device_detach,        bus_generic_detach),
655         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
656         DEVMETHOD(device_suspend,       bus_generic_suspend),
657         DEVMETHOD(device_resume,        bus_generic_resume),
658         { 0, 0 }
659 };
660
661 static driver_t sysresource_driver = {
662         "sysresource",
663         sysresource_methods,
664         1,              /* no softc */
665 };
666
667 static devclass_t sysresource_devclass;
668
669 DRIVER_MODULE(sysresource, isa, sysresource_driver, sysresource_devclass, 0, 0);