Remove all remaining SPL code. Replace the mtd_cpl field in the machine
[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.17 2005/06/16 21:12:44 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 <sys/param.h>
45 #include <sys/systm.h>
46 #include <sys/bus.h>
47 #include <sys/kernel.h>
48 #include <sys/malloc.h>
49 #include <sys/module.h>
50 #include <machine/bus.h>
51 #include <sys/rman.h>
52
53 #include <machine/vmparam.h>
54 #include <vm/vm.h>
55 #include <vm/pmap.h>
56 #include <machine/pmap.h>
57
58 #include <machine/nexusvar.h>
59 #include <machine/resource.h>
60 #ifdef APIC_IO
61 #include <machine/smp.h>
62 #include <machine/mpapic.h>
63 #endif
64
65 #include <bus/isa/isavar.h>
66 #include <bus/isa/i386/isa.h>
67 #include <i386/isa/intr_machdep.h>
68
69 static MALLOC_DEFINE(M_NEXUSDEV, "nexusdev", "Nexus device");
70 struct nexus_device {
71         struct resource_list    nx_resources;
72         int                     nx_pcibus;
73 };
74
75 #define DEVTONX(dev)    ((struct nexus_device *)device_get_ivars(dev))
76
77 static struct rman irq_rman, drq_rman, port_rman, mem_rman;
78
79 static void nexus_identify(driver_t *, device_t);
80 static  int nexus_probe(device_t);
81 static  int nexus_attach(device_t);
82 static  int nexus_print_all_resources(device_t dev);
83 static  int nexus_print_child(device_t, device_t);
84 static device_t nexus_add_child(device_t bus, int order, const char *name,
85                                 int unit);
86 static  struct resource *nexus_alloc_resource(device_t, device_t, int, int *,
87                                               u_long, u_long, u_long, u_int);
88 static  int nexus_read_ivar(device_t, device_t, int, uintptr_t *);
89 static  int nexus_write_ivar(device_t, device_t, int, uintptr_t);
90 static  int nexus_activate_resource(device_t, device_t, int, int,
91                                     struct resource *);
92 static  int nexus_deactivate_resource(device_t, device_t, int, int,
93                                       struct resource *);
94 static  int nexus_release_resource(device_t, device_t, int, int,
95                                    struct resource *);
96 static  int nexus_setup_intr(device_t, device_t, struct resource *, int flags,
97                              void (*)(void *), void *, 
98                              void **, lwkt_serialize_t);
99 static  int nexus_teardown_intr(device_t, device_t, struct resource *,
100                                 void *);
101 static  int nexus_set_resource(device_t, device_t, int, int, u_long, u_long);
102 static  int nexus_get_resource(device_t, device_t, int, int, u_long *, u_long *);
103 static void nexus_delete_resource(device_t, device_t, int, int);
104
105 static device_method_t nexus_methods[] = {
106         /* Device interface */
107         DEVMETHOD(device_identify,      nexus_identify),
108         DEVMETHOD(device_probe,         nexus_probe),
109         DEVMETHOD(device_attach,        nexus_attach),
110         DEVMETHOD(device_detach,        bus_generic_detach),
111         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
112         DEVMETHOD(device_suspend,       bus_generic_suspend),
113         DEVMETHOD(device_resume,        bus_generic_resume),
114
115         /* Bus interface */
116         DEVMETHOD(bus_print_child,      nexus_print_child),
117         DEVMETHOD(bus_add_child,        nexus_add_child),
118         DEVMETHOD(bus_read_ivar,        nexus_read_ivar),
119         DEVMETHOD(bus_write_ivar,       nexus_write_ivar),
120         DEVMETHOD(bus_alloc_resource,   nexus_alloc_resource),
121         DEVMETHOD(bus_release_resource, nexus_release_resource),
122         DEVMETHOD(bus_activate_resource, nexus_activate_resource),
123         DEVMETHOD(bus_deactivate_resource, nexus_deactivate_resource),
124         DEVMETHOD(bus_setup_intr,       nexus_setup_intr),
125         DEVMETHOD(bus_teardown_intr,    nexus_teardown_intr),
126         DEVMETHOD(bus_set_resource,     nexus_set_resource),
127         DEVMETHOD(bus_get_resource,     nexus_get_resource),
128         DEVMETHOD(bus_delete_resource,  nexus_delete_resource),
129
130         { 0, 0 }
131 };
132
133 static driver_t nexus_driver = {
134         "nexus",
135         nexus_methods,
136         1,                      /* no softc */
137 };
138 static devclass_t nexus_devclass;
139
140 DRIVER_MODULE(nexus, root, nexus_driver, nexus_devclass, 0, 0);
141
142 static void
143 nexus_identify(driver_t *driver, device_t parent)
144 {
145         /*
146          * Add child device with order of 1 so it gets probed
147          * after ACPI (which is at order 0.
148          */
149         if (BUS_ADD_CHILD(parent, 1, "legacy", 0) == NULL)
150                 panic("legacy: could not attach");
151 }
152
153 static int
154 nexus_probe(device_t dev)
155 {
156 #if 0   /* FUTURE */
157         device_t acpi;
158 #endif
159
160 #if 0   /* FUTURE */
161         /*
162          * Fail to probe if ACPI is ok.
163          */
164         acpi = devclass_get_device(devclass_find("acpi"), 0);
165         if (acpi != NULL && device_is_alive(acpi))
166                 return(ENXIO);
167 #endif
168
169         device_quiet(dev);      /* suppress attach message for neatness */
170
171         /*
172          * IRQ's are on the mainboard on old systems, but on the ISA part
173          * of PCI->ISA bridges.  There would be multiple sets of IRQs on
174          * multi-ISA-bus systems.  PCI interrupts are routed to the ISA
175          * component, so in a way, PCI can be a partial child of an ISA bus(!).
176          * APIC interrupts are global though.
177          * In the non-APIC case, disallow the use of IRQ 2.
178          */
179         irq_rman.rm_start = 0;
180         irq_rman.rm_type = RMAN_ARRAY;
181         irq_rman.rm_descr = "Interrupt request lines";
182 #ifdef APIC_IO
183         irq_rman.rm_end = APIC_INTMAPSIZE - 1;
184         if (rman_init(&irq_rman)
185             || rman_manage_region(&irq_rman,
186                                   irq_rman.rm_start, irq_rman.rm_end))
187                 panic("nexus_probe irq_rman");
188 #else
189         irq_rman.rm_end = 15;
190         if (rman_init(&irq_rman)
191             || rman_manage_region(&irq_rman, irq_rman.rm_start, 1)
192             || rman_manage_region(&irq_rman, 3, irq_rman.rm_end))
193                 panic("nexus_probe irq_rman");
194 #endif
195
196         /*
197          * ISA DMA on PCI systems is implemented in the ISA part of each
198          * PCI->ISA bridge and the channels can be duplicated if there are
199          * multiple bridges.  (eg: laptops with docking stations)
200          */
201         drq_rman.rm_start = 0;
202         drq_rman.rm_end = 7;
203         drq_rman.rm_type = RMAN_ARRAY;
204         drq_rman.rm_descr = "DMA request lines";
205         /* XXX drq 0 not available on some machines */
206         if (rman_init(&drq_rman)
207             || rman_manage_region(&drq_rman,
208                                   drq_rman.rm_start, drq_rman.rm_end))
209                 panic("nexus_probe drq_rman");
210
211         /*
212          * However, IO ports and Memory truely are global at this level,
213          * as are APIC interrupts (however many IO APICS there turn out
214          * to be on large systems..)
215          */
216         port_rman.rm_start = 0;
217         port_rman.rm_end = 0xffff;
218         port_rman.rm_type = RMAN_ARRAY;
219         port_rman.rm_descr = "I/O ports";
220         if (rman_init(&port_rman)
221             || rman_manage_region(&port_rman, 0, 0xffff))
222                 panic("nexus_probe port_rman");
223
224         mem_rman.rm_start = 0;
225         mem_rman.rm_end = ~0u;
226         mem_rman.rm_type = RMAN_ARRAY;
227         mem_rman.rm_descr = "I/O memory addresses";
228         if (rman_init(&mem_rman)
229             || rman_manage_region(&mem_rman, 0, ~0))
230                 panic("nexus_probe mem_rman");
231
232         return bus_generic_probe(dev);
233 }
234
235 static int
236 nexus_attach(device_t dev)
237 {
238         device_t        child;
239
240         /*
241          * First, let our child driver's identify any child devices that
242          * they can find.  Once that is done attach any devices that we
243          * found.
244          */
245 #if 0 /* FUTURE */
246         bus_generic_probe(dev);
247 #endif
248         bus_generic_attach(dev);
249
250         /*
251          * And if we didn't see EISA or ISA on a pci bridge, create some
252          * connection points now so they show up "on motherboard".
253          */
254         if (!devclass_get_device(devclass_find("eisa"), 0)) {
255                 child = BUS_ADD_CHILD(dev, 0, "eisa", 0);
256                 if (child == NULL)
257                         panic("nexus_attach eisa");
258                 device_probe_and_attach(child);
259         }
260         if (!devclass_get_device(devclass_find("isa"), 0)) {
261                 child = BUS_ADD_CHILD(dev, 0, "isa", 0);
262                 if (child == NULL)
263                         panic("nexus_attach isa");
264                 device_probe_and_attach(child);
265         }
266
267         return 0;
268 }
269
270 static int
271 nexus_print_all_resources(device_t dev)
272 {
273         struct  nexus_device *ndev = DEVTONX(dev);
274         struct resource_list *rl = &ndev->nx_resources;
275         int retval = 0;
276
277         if (SLIST_FIRST(rl) || ndev->nx_pcibus != -1)
278                 retval += printf(" at");
279         
280         retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx");
281         retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx");
282         retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");
283
284         return retval;
285 }
286
287 static int
288 nexus_print_child(device_t bus, device_t child)
289 {
290         struct  nexus_device *ndev = DEVTONX(child);
291         int retval = 0;
292
293         retval += bus_print_child_header(bus, child);
294         retval += nexus_print_all_resources(child);
295         if (ndev->nx_pcibus != -1)
296                 retval += printf(" pcibus %d", ndev->nx_pcibus);
297         retval += printf(" on motherboard\n");
298
299         return (retval);
300 }
301
302 static device_t
303 nexus_add_child(device_t bus, int order, const char *name, int unit)
304 {
305         device_t                child;
306         struct nexus_device     *ndev;
307
308         ndev = malloc(sizeof(struct nexus_device), M_NEXUSDEV, M_INTWAIT|M_ZERO);
309         if (!ndev)
310                 return(0);
311         resource_list_init(&ndev->nx_resources);
312         ndev->nx_pcibus = -1;
313
314         child = device_add_child_ordered(bus, order, name, unit); 
315
316         /* should we free this in nexus_child_detached? */
317         device_set_ivars(child, ndev);
318
319         return(child);
320 }
321
322 static int
323 nexus_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
324 {
325         struct nexus_device *ndev = DEVTONX(child);
326         
327         switch (which) {
328         case NEXUS_IVAR_PCIBUS:
329                 *result = ndev->nx_pcibus;
330                 break;
331         default:
332                 return ENOENT;
333         }
334         return 0;
335 }
336
337 static int
338 nexus_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
339 {
340         struct nexus_device *ndev = DEVTONX(child);
341         
342         switch (which) {
343         case NEXUS_IVAR_PCIBUS:
344                 ndev->nx_pcibus = value;
345                 break;
346         default:
347                 return ENOENT;
348         }
349         return 0;
350 }
351
352 /*
353  * Allocate a resource on behalf of child.  NB: child is usually going to be a
354  * child of one of our descendants, not a direct child of nexus0.
355  * (Exceptions include npx.)
356  */
357 static struct resource *
358 nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,
359                      u_long start, u_long end, u_long count, u_int flags)
360 {
361         struct nexus_device *ndev = DEVTONX(child);
362         struct  resource *rv;
363         struct resource_list_entry *rle;
364         struct  rman *rm;
365         int needactivate = flags & RF_ACTIVE;
366
367         /*
368          * If this is an allocation of the "default" range for a given RID, and
369          * we know what the resources for this device are (ie. they aren't maintained
370          * by a child bus), then work out the start/end values.
371          */
372         if ((start == 0UL) && (end == ~0UL) && (count == 1)) {
373                 if (ndev == NULL)
374                         return(NULL);
375                 rle = resource_list_find(&ndev->nx_resources, type, *rid);
376                 if (rle == NULL)
377                         return(NULL);
378                 start = rle->start;
379                 end = rle->end;
380                 count = rle->count;
381         }
382
383         flags &= ~RF_ACTIVE;
384
385         switch (type) {
386         case SYS_RES_IRQ:
387                 rm = &irq_rman;
388                 break;
389
390         case SYS_RES_DRQ:
391                 rm = &drq_rman;
392                 break;
393
394         case SYS_RES_IOPORT:
395                 rm = &port_rman;
396                 break;
397
398         case SYS_RES_MEMORY:
399                 rm = &mem_rman;
400                 break;
401
402         default:
403                 return 0;
404         }
405
406         rv = rman_reserve_resource(rm, start, end, count, flags, child);
407         if (rv == 0)
408                 return 0;
409
410         if (type == SYS_RES_MEMORY) {
411                 rman_set_bustag(rv, I386_BUS_SPACE_MEM);
412         } else if (type == SYS_RES_IOPORT) {
413                 rman_set_bustag(rv, I386_BUS_SPACE_IO);
414                 rman_set_bushandle(rv, rv->r_start);
415         }
416
417         if (needactivate) {
418                 if (bus_activate_resource(child, type, *rid, rv)) {
419                         rman_release_resource(rv);
420                         return 0;
421                 }
422         }
423         
424         return rv;
425 }
426
427 static int
428 nexus_activate_resource(device_t bus, device_t child, int type, int rid,
429                         struct resource *r)
430 {
431         /*
432          * If this is a memory resource, map it into the kernel.
433          */
434         if (rman_get_bustag(r) == I386_BUS_SPACE_MEM) {
435                 caddr_t vaddr = 0;
436
437                 if (rman_get_end(r) < 1024 * 1024) {
438                         /*
439                          * The first 1Mb is mapped at KERNBASE.
440                          */
441                         vaddr = (caddr_t)(uintptr_t)(KERNBASE + rman_get_start(r));
442                 } else {
443                         u_int32_t paddr;
444                         u_int32_t psize;
445                         u_int32_t poffs;
446
447                         paddr = rman_get_start(r);
448                         psize = rman_get_size(r);
449
450                         poffs = paddr - trunc_page(paddr);
451                         vaddr = (caddr_t) pmap_mapdev(paddr-poffs, psize+poffs) + poffs;
452                 }
453                 rman_set_virtual(r, vaddr);
454                 /* IBM-PC: the type of bus_space_handle_t is u_int */
455                 rman_set_bushandle(r, (bus_space_handle_t) vaddr);
456         }
457         return (rman_activate_resource(r));
458 }
459
460 static int
461 nexus_deactivate_resource(device_t bus, device_t child, int type, int rid,
462                           struct resource *r)
463 {
464         /*
465          * If this is a memory resource, unmap it.
466          */
467         if ((rman_get_bustag(r) == I386_BUS_SPACE_MEM) &&
468             (rman_get_end(r) >= 1024 * 1024)) {
469                 u_int32_t psize;
470
471                 psize = rman_get_size(r);
472                 pmap_unmapdev((vm_offset_t)rman_get_virtual(r), psize);
473         }
474                 
475         return (rman_deactivate_resource(r));
476 }
477
478 static int
479 nexus_release_resource(device_t bus, device_t child, int type, int rid,
480                        struct resource *r)
481 {
482         if (rman_get_flags(r) & RF_ACTIVE) {
483                 int error = bus_deactivate_resource(child, type, rid, r);
484                 if (error)
485                         return error;
486         }
487         return (rman_release_resource(r));
488 }
489
490 /*
491  * Currently this uses the really grody interface from kern/kern_intr.c
492  * (which really doesn't belong in kern/anything.c).  Eventually, all of
493  * the code in kern_intr.c and machdep_intr.c should get moved here, since
494  * this is going to be the official interface.
495  */
496 static int
497 nexus_setup_intr(device_t bus, device_t child, struct resource *irq,
498                  int flags, void (*ihand)(void *), void *arg,
499                  void **cookiep, lwkt_serialize_t serializer)
500 {
501         driver_t        *driver;
502         int     error, icflags;
503
504         /* somebody tried to setup an irq that failed to allocate! */
505         if (irq == NULL)
506                 panic("nexus_setup_intr: NULL irq resource!");
507
508         *cookiep = 0;
509         if (irq->r_flags & RF_SHAREABLE)
510                 icflags = 0;
511         else
512                 icflags = INTR_EXCL;
513
514         driver = device_get_driver(child);
515
516         if (flags & INTR_FAST)
517                 icflags |= INTR_FAST;
518
519         /*
520          * We depend here on rman_activate_resource() being idempotent.
521          */
522         error = rman_activate_resource(irq);
523         if (error)
524                 return (error);
525
526         *cookiep = inthand_add(device_get_nameunit(child), irq->r_start,
527             ihand, arg, icflags, serializer);
528         if (*cookiep == NULL)
529                 error = EINVAL; /* XXX ??? */
530
531         return (error);
532 }
533
534 static int
535 nexus_teardown_intr(device_t dev, device_t child, struct resource *r, void *ih)
536 {
537         return (inthand_remove(ih));
538 }
539
540 static int
541 nexus_set_resource(device_t dev, device_t child, int type, int rid, u_long start, u_long count)
542 {
543         struct nexus_device     *ndev = DEVTONX(child);
544         struct resource_list    *rl = &ndev->nx_resources;
545
546         /* XXX this should return a success/failure indicator */
547         resource_list_add(rl, type, rid, start, start + count - 1, count);
548         return(0);
549 }
550
551 static int
552 nexus_get_resource(device_t dev, device_t child, int type, int rid, u_long *startp, u_long *countp)
553 {
554         struct nexus_device     *ndev = DEVTONX(child);
555         struct resource_list    *rl = &ndev->nx_resources;
556         struct resource_list_entry *rle;
557
558         rle = resource_list_find(rl, type, rid);
559         device_printf(child, "type %d  rid %d  startp %p  countp %p - got %p\n",
560                       type, rid, startp, countp, rle);
561         if (!rle)
562                 return(ENOENT);
563         if (startp)
564                 *startp = rle->start;
565         if (countp)
566                 *countp = rle->count;
567         return(0);
568 }
569
570 static void
571 nexus_delete_resource(device_t dev, device_t child, int type, int rid)
572 {
573         struct nexus_device     *ndev = DEVTONX(child);
574         struct resource_list    *rl = &ndev->nx_resources;
575
576         resource_list_delete(rl, type, rid);
577 }
578
579 /*
580  * Placeholder which claims PnP 'devices' which describe system
581  * resources.
582  */
583 static struct isa_pnp_id sysresource_ids[] = {
584         { 0x010cd041 /* PNP0c01 */, "System Memory" },
585         { 0x020cd041 /* PNP0c02 */, "System Resource" },
586         { 0 }
587 };
588
589 static int
590 sysresource_probe(device_t dev)
591 {
592         int     result;
593
594         if ((result = ISA_PNP_PROBE(device_get_parent(dev), dev, sysresource_ids)) >= 0) {
595                 device_quiet(dev);
596         }
597         return (result);
598 }
599
600 static int
601 sysresource_attach(device_t dev)
602 {
603         return (0);
604 }
605
606 static device_method_t sysresource_methods[] = {
607         /* Device interface */
608         DEVMETHOD(device_probe,         sysresource_probe),
609         DEVMETHOD(device_attach,        sysresource_attach),
610         DEVMETHOD(device_detach,        bus_generic_detach),
611         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
612         DEVMETHOD(device_suspend,       bus_generic_suspend),
613         DEVMETHOD(device_resume,        bus_generic_resume),
614         { 0, 0 }
615 };
616
617 static driver_t sysresource_driver = {
618         "sysresource",
619         sysresource_methods,
620         1,              /* no softc */
621 };
622
623 static devclass_t sysresource_devclass;
624
625 DRIVER_MODULE(sysresource, isa, sysresource_driver, sysresource_devclass, 0, 0);