Remove all remaining SPL code. Replace the mtd_cpl field in the machine
[dragonfly.git] / sys / bus / pci / pci_compat.c
1 /*
2  * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
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 unmodified, this list of conditions, and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/pci/pci_compat.c,v 1.35.2.1 2001/10/14 21:14:14 luigi Exp $
27  * $DragonFly: src/sys/bus/pci/pci_compat.c,v 1.9 2005/06/16 21:12:25 dillon Exp $
28  *
29  */
30
31 #include "opt_bus.h"
32
33 /* for compatibility to FreeBSD-2.2 and 3.x versions of PCI code */
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/malloc.h>
38 #include <sys/module.h>
39
40 #include <vm/vm.h>
41 #include <vm/pmap.h>
42
43 #include <sys/bus.h>
44 #include <machine/bus.h>
45 #include <sys/rman.h>
46 #include <machine/resource.h>
47 #include <sys/interrupt.h>
48
49 #include <sys/pciio.h>
50 #include "pcireg.h"
51 #include "pcivar.h"
52
53 #ifdef APIC_IO
54 #include <machine/smp.h>
55 #endif
56
57 struct pci_compat_driver {
58         driver_t driver;
59         struct pci_device *dvp;
60 };
61
62 /* ------------------------------------------------------------------------- */
63
64 u_long
65 pci_conf_read(pcici_t cfg, u_long reg)
66 {
67         return (pci_read_config(cfg->dev, reg, 4));
68 }
69
70 void
71 pci_conf_write(pcici_t cfg, u_long reg, u_long data)
72 {
73         pci_write_config(cfg->dev, reg, data, 4);
74 }
75
76 int
77 pci_map_port(pcici_t cfg, u_long reg, pci_port_t* pa)
78 {
79         int rid;
80         struct resource *res;
81
82         rid = reg;
83         res = bus_alloc_resource(cfg->dev, SYS_RES_IOPORT, &rid,
84                                  0, ~0, 1, RF_ACTIVE);
85         if (res) {
86                 *pa = rman_get_start(res);
87                 return (1);
88         }
89         return (0);
90 }
91
92 int
93 pci_map_mem(pcici_t cfg, u_long reg, vm_offset_t* va, vm_offset_t* pa)
94 {
95         int rid;
96         struct resource *res;
97
98         rid = reg;
99         res = bus_alloc_resource(cfg->dev, SYS_RES_MEMORY, &rid,
100                                  0, ~0, 1, RF_ACTIVE);
101         if (res) {
102                 *pa = rman_get_start(res);
103                 *va = (vm_offset_t) rman_get_virtual(res);
104                 return (1);
105         }
106         return (0);
107 }
108
109 int
110 pci_map_int(pcici_t cfg, pci_inthand_t *handler, void *arg)
111 {
112         return (pci_map_int_right(cfg, handler, arg, 0));
113 }
114
115 int
116 pci_map_int_right(pcici_t cfg, pci_inthand_t *handler, void *arg, u_int intflags)
117 {
118         int error;
119 #ifdef APIC_IO
120         int nextpin, muxcnt;
121 #endif
122         if (cfg->intpin != 0) {
123                 int irq = cfg->intline;
124                 int rid = 0;
125                 struct resource *res;
126                 int flags = 0;
127                 int resflags = RF_SHAREABLE|RF_ACTIVE;
128                 void *ih;
129
130                 if (intflags & INTR_FAST)
131                         flags |= INTR_FAST;
132                 if (intflags & INTR_EXCL)
133                         resflags &= ~RF_SHAREABLE;
134
135                 res = bus_alloc_resource(cfg->dev, SYS_RES_IRQ, &rid,
136                                          irq, irq, 1, resflags);
137                 if (!res) {
138                         printf("pci_map_int: can't allocate interrupt\n");
139                         return 0;
140                 }
141
142                 /*
143                  * This is ugly. Translate the mask into an interrupt type.
144                  */
145
146                 error = BUS_SETUP_INTR(device_get_parent(cfg->dev), cfg->dev,
147                                        res, flags, handler, arg, &ih, NULL);
148                 if (error != 0)
149                         return 0;
150
151 #ifdef NEW_BUS_PCI
152                 /*
153                  * XXX this apic stuff looks totally busted.  It should
154                  * move to the nexus code which actually registers the
155                  * interrupt.
156                  */
157 #endif
158
159 #ifdef APIC_IO
160                 nextpin = next_apic_irq(irq);
161                 
162                 if (nextpin < 0)
163                         return 1;
164
165                 /* 
166                  * Attempt handling of some broken mp tables.
167                  *
168                  * It's OK to yell (since the mp tables are broken).
169                  * 
170                  * Hanging in the boot is not OK
171                  */
172
173                 muxcnt = 2;
174                 nextpin = next_apic_irq(nextpin);
175                 while (muxcnt < 5 && nextpin >= 0) {
176                         muxcnt++;
177                         nextpin = next_apic_irq(nextpin);
178                 }
179                 if (muxcnt >= 5) {
180                         printf("bogus MP table, more than 4 IO APIC pins connected to the same PCI device or ISA/EISA interrupt\n");
181                         return 0;
182                 }
183                 
184                 printf("bogus MP table, %d IO APIC pins connected to the same PCI device or ISA/EISA interrupt\n", muxcnt);
185
186                 nextpin = next_apic_irq(irq);
187                 while (nextpin >= 0) {
188                         rid = 0;
189                         res = bus_alloc_resource(cfg->dev, SYS_RES_IRQ, &rid,
190                                                  nextpin, nextpin, 1,
191                                                  resflags);
192                         if (!res) {
193                                 printf("pci_map_int: can't allocate extra interrupt\n");
194                                 return 0;
195                         }
196                         error = BUS_SETUP_INTR(device_get_parent(cfg->dev),
197                                                cfg->dev, res, flags,
198                                                handler, arg, &ih, NULL);
199                         if (error != 0) {
200                                 printf("pci_map_int: BUS_SETUP_INTR failed\n");
201                                 return 0;
202                         }
203                         printf("Registered extra interrupt handler for int %d (in addition to int %d)\n", nextpin, irq);
204                         nextpin = next_apic_irq(nextpin);
205                 }
206 #endif
207         }
208         return (1);
209 }
210
211 int
212 pci_unmap_int(pcici_t cfg)
213 {
214         return (0); /* not supported, yet, since cfg doesn't know about idesc */
215 }
216
217 pcici_t
218 pci_get_parent_from_tag(pcici_t tag)
219 {
220         return (pcici_t)pci_devlist_get_parent(tag);
221 }
222
223 int
224 pci_get_bus_from_tag(pcici_t tag)
225 {
226         return tag->bus;
227 }
228
229 /*
230  * A simple driver to wrap the old pci driver mechanism for back-compat.
231  */
232
233 static int
234 pci_compat_probe(device_t dev)
235 {
236         struct pci_device *dvp;
237         struct pci_devinfo *dinfo;
238         pcicfgregs *cfg;
239         const char *name;
240         int error;
241         
242         dinfo = device_get_ivars(dev);
243         cfg = &dinfo->cfg;
244         dvp = ((struct pci_compat_driver *)device_get_driver(dev))->dvp;
245
246         /*
247          * Do the wrapped probe.
248          */
249         error = ENXIO;
250         if (dvp && dvp->pd_probe) {
251                 name = dvp->pd_probe(cfg, (cfg->device << 16) + cfg->vendor);
252                 if (name) {
253                         device_set_desc_copy(dev, name);
254                         /* Allow newbus drivers to match "better" */
255                         error = -200;
256                 }
257         }
258
259         return error;
260 }
261
262 static int
263 pci_compat_attach(device_t dev)
264 {
265         struct pci_device *dvp;
266         struct pci_devinfo *dinfo;
267         pcicfgregs *cfg;
268         int unit;
269
270         dinfo = device_get_ivars(dev);
271         cfg = &dinfo->cfg;
272         dvp = ((struct pci_compat_driver *)device_get_driver(dev))->dvp;
273
274         unit = device_get_unit(dev);
275         if (unit > *dvp->pd_count)
276                 *dvp->pd_count = unit;
277         if (dvp->pd_attach)
278                 dvp->pd_attach(cfg, unit);
279         device_printf(dev, "driver is using old-style compatability shims\n");
280         return 0;
281 }
282
283 static device_method_t pci_compat_methods[] = {
284         /* Device interface */
285         DEVMETHOD(device_probe,         pci_compat_probe),
286         DEVMETHOD(device_attach,        pci_compat_attach),
287
288         { 0, 0 }
289 };
290
291 /*
292  * Create a new style driver around each old pci driver.
293  */
294 int
295 compat_pci_handler(module_t mod, int type, void *data)
296 {
297         struct pci_device *dvp = (struct pci_device *)data;
298         struct pci_compat_driver *driver;
299         devclass_t pci_devclass = devclass_find("pci");
300
301         switch (type) {
302         case MOD_LOAD:
303                 driver = malloc(sizeof(struct pci_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
304                 driver->driver.name = dvp->pd_name;
305                 driver->driver.methods = pci_compat_methods;
306                 driver->driver.size = sizeof(struct pci_devinfo *);
307                 driver->dvp = dvp;
308                 devclass_add_driver(pci_devclass, (driver_t *)driver);
309                 break;
310         case MOD_UNLOAD:
311                 printf("%s: module unload not supported!\n", dvp->pd_name);
312                 return EOPNOTSUPP;
313         default:
314                 break;
315         }
316         return 0;
317 }