Merge from vendor branch DHCP:
[dragonfly.git] / sys / dev / pccard / cardbus / cardbus.c
1 /*
2  * Copyright (c) 2000,2001 Jonathan Chen.
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  *    without modification, immediately at the beginning of the file.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in
13  *    the documentation and/or other materials provided with the
14  *    distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * $FreeBSD: src/sys/dev/cardbus/cardbus.c,v 1.28 2002/11/27 17:30:41 imp Exp $
29  * $DragonFly: src/sys/dev/pccard/cardbus/cardbus.c,v 1.2 2004/02/21 06:37:06 dillon Exp $
30  */
31
32 /*
33  * Cardbus Bus Driver
34  *
35  * much of the bus code was stolen directly from sys/pci/pci.c
36  *   (Copyright (c) 1997, Stefan Esser <se@freebsd.org>)
37  *
38  * Written by Jonathan Chen <jon@freebsd.org>
39  */
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/malloc.h>
44 #include <sys/kernel.h>
45 #include <sys/sysctl.h>
46
47 #include <sys/bus.h>
48 #include <machine/bus.h>
49 #include <sys/rman.h>
50 #include <machine/resource.h>
51
52 #include <sys/pciio.h>
53 #include <bus/pci/pcivar.h>
54 #include <bus/pci/pcireg.h>
55
56 #include <dev/pccard/cardbus/cardbusreg.h>
57 #include <dev/pccard/cardbus/cardbusvar.h>
58 #include <dev/pccard/cardbus/cardbus_cis.h>
59 #include <bus/pccard/pccardvar.h>
60
61 #include "power_if.h"
62 #include "pcib_if.h"
63
64 /* sysctl vars */
65 SYSCTL_NODE(_hw, OID_AUTO, cardbus, CTLFLAG_RD, 0, "CardBus parameters");
66
67 int    cardbus_debug = 0;
68 TUNABLE_INT("hw.cardbus.debug", &cardbus_debug);
69 SYSCTL_INT(_hw_cardbus, OID_AUTO, debug, CTLFLAG_RW,
70     &cardbus_debug, 0,
71   "CardBus debug");
72
73 int    cardbus_cis_debug = 0;
74 TUNABLE_INT("hw.cardbus.cis_debug", &cardbus_cis_debug);
75 SYSCTL_INT(_hw_cardbus, OID_AUTO, cis_debug, CTLFLAG_RW,
76     &cardbus_cis_debug, 0,
77   "CardBus CIS debug");
78
79 #define DPRINTF(a) if (cardbus_debug) printf a
80 #define DEVPRINTF(x) if (cardbus_debug) device_printf x
81
82
83 static struct resource  *cardbus_alloc_resource(device_t cbdev, device_t child,
84                     int type, int *rid, u_long start, u_long end, u_long count,
85                     u_int flags);
86 static int      cardbus_attach(device_t cbdev);
87 static int      cardbus_attach_card(device_t cbdev);
88 static int      cardbus_child_location_str(device_t cbdev, device_t child,
89                     char *, size_t len);
90 static int      cardbus_child_pnpinfo_str(device_t cbdev, device_t child,
91                     char *, size_t len);
92 static __inline void cardbus_clear_command_bit(device_t cbdev, device_t child,
93                     u_int16_t bit);
94 static void     cardbus_delete_resource(device_t cbdev, device_t child,
95                     int type, int rid);
96 static void     cardbus_delete_resource_method(device_t cbdev, device_t child,
97                     int type, int rid);
98 static int      cardbus_detach(device_t cbdev);
99 static int      cardbus_detach_card(device_t cbdev);
100 static void     cardbus_device_setup_regs(device_t brdev, int b, int s, int f,
101                     pcicfgregs *cfg);
102 static void     cardbus_disable_busmaster_method(device_t cbdev, device_t child);
103 static void     cardbus_disable_io_method(device_t cbdev, device_t child,
104                     int space);
105 static void     cardbus_driver_added(device_t cbdev, driver_t *driver);
106 static void     cardbus_enable_busmaster_method(device_t cbdev, device_t child);
107 static void     cardbus_enable_io_method(device_t cbdev, device_t child,
108                     int space);
109 static int      cardbus_freecfg(struct cardbus_devinfo *dinfo);
110 static int      cardbus_get_powerstate_method(device_t cbdev, device_t child);
111 static int      cardbus_get_resource(device_t cbdev, device_t child, int type,
112                     int rid, u_long *startp, u_long *countp);
113 static int      cardbus_get_resource_method(device_t cbdev, device_t child,
114                     int type, int rid, u_long *startp, u_long *countp);
115 static void     cardbus_hdrtypedata(device_t brdev, int b, int s, int f,
116                     pcicfgregs *cfg);
117 static int      cardbus_print_child(device_t cbdev, device_t child);
118 static int      cardbus_print_resources(struct resource_list *rl,
119                     const char *name, int type, const char *format);
120 static void     cardbus_print_verbose(struct cardbus_devinfo *dinfo);
121 static int      cardbus_probe(device_t cbdev);
122 static void     cardbus_probe_nomatch(device_t cbdev, device_t child);
123 static struct cardbus_devinfo   *cardbus_read_device(device_t brdev, int b,
124                     int s, int f);
125 static void     cardbus_read_extcap(device_t cbdev, pcicfgregs *cfg);
126 static u_int32_t cardbus_read_config_method(device_t cbdev,
127                     device_t child, int reg, int width);
128 static int      cardbus_read_ivar(device_t cbdev, device_t child, int which,
129                     u_long *result);
130 static void     cardbus_release_all_resources(device_t cbdev,
131                     struct cardbus_devinfo *dinfo);
132 static int      cardbus_release_resource(device_t cbdev, device_t child,
133                     int type, int rid, struct resource *r);
134 static __inline void cardbus_set_command_bit(device_t cbdev, device_t child,
135                     u_int16_t bit);
136 static int      cardbus_set_powerstate_method(device_t cbdev, device_t child,
137                     int state);
138 static int      cardbus_set_resource(device_t cbdev, device_t child, int type,
139                     int rid, u_long start, u_long count, struct resource *res);
140 static int      cardbus_set_resource_method(device_t cbdev, device_t child,
141                     int type, int rid, u_long start, u_long count);
142 static int      cardbus_setup_intr(device_t cbdev, device_t child,
143                     struct resource *irq, int flags, driver_intr_t *intr,
144                     void *arg, void **cookiep);
145 static int      cardbus_teardown_intr(device_t cbdev, device_t child,
146                     struct resource *irq, void *cookie);
147 static void     cardbus_write_config_method(device_t cbdev, device_t child,
148                     int reg, u_int32_t val, int width);
149 static int      cardbus_write_ivar(device_t cbdev, device_t child, int which,
150                     uintptr_t value);
151
152 /************************************************************************/
153 /* Probe/Attach                                                         */
154 /************************************************************************/
155
156 static int
157 cardbus_probe(device_t cbdev)
158 {
159         device_set_desc(cbdev, "CardBus bus");
160         return 0;
161 }
162
163 static int
164 cardbus_attach(device_t cbdev)
165 {
166         return 0;
167 }
168
169 static int
170 cardbus_detach(device_t cbdev)
171 {
172         cardbus_detach_card(cbdev);
173         return 0;
174 }
175
176 static int
177 cardbus_suspend(device_t self)
178 {
179         cardbus_detach_card(self);
180         return (0);
181 }
182
183 static int
184 cardbus_resume(device_t self)
185 {
186         return (0);
187 }
188
189 /************************************************************************/
190 /* Attach/Detach card                                                   */
191 /************************************************************************/
192
193 static void
194 cardbus_device_setup_regs(device_t brdev, int b, int s, int f, pcicfgregs *cfg)
195 {
196         PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_INTLINE,
197             pci_get_irq(device_get_parent(brdev)), 1);
198         cfg->intline = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_INTLINE, 1);
199
200         PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_CACHELNSZ, 0x08, 1);
201         cfg->cachelnsz = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_CACHELNSZ, 1);
202
203         PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_LATTIMER, 0xa8, 1);
204         cfg->lattimer = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_LATTIMER, 1);
205
206         PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_MINGNT, 0x14, 1);
207         cfg->mingnt = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_MINGNT, 1);
208
209         PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_MAXLAT, 0x14, 1);
210         cfg->maxlat = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_MAXLAT, 1);
211 }
212
213 static int
214 cardbus_attach_card(device_t cbdev)
215 {
216         device_t brdev = device_get_parent(cbdev);
217         int cardattached = 0;
218         static int curr_bus_number = 2; /* XXX EVILE BAD (see below) */
219         int bus, slot, func;
220
221         cardbus_detach_card(cbdev); /* detach existing cards */
222
223         POWER_ENABLE_SOCKET(brdev, cbdev);
224         bus = pcib_get_bus(cbdev);
225         if (bus == 0) {
226                 /*
227                  * XXX EVILE BAD XXX
228                  * Not all BIOSes initialize the secondary bus number properly,
229                  * so if the default is bad, we just put one in and hope it
230                  * works.
231                  */
232                 bus = curr_bus_number;
233                 pci_write_config(brdev, PCIR_SECBUS_2, curr_bus_number, 1);
234                 pci_write_config(brdev, PCIR_SUBBUS_2, curr_bus_number + 2, 1);
235                 curr_bus_number += 3;
236         }
237         /* For each function, set it up and try to attach a driver to it */
238         for (slot = 0; slot <= CARDBUS_SLOTMAX; slot++) {
239                 int cardbusfunchigh = 0;
240                 for (func = 0; func <= cardbusfunchigh; func++) {
241                         struct cardbus_devinfo *dinfo =
242                             cardbus_read_device(brdev, bus, slot, func);
243
244                         if (dinfo == NULL)
245                                 continue;
246                         if (dinfo->pci.cfg.mfdev)
247                                 cardbusfunchigh = CARDBUS_FUNCMAX;
248
249                         cardbus_device_setup_regs(brdev, bus, slot, func,
250                             &dinfo->pci.cfg);
251                         cardbus_print_verbose(dinfo);
252                         dinfo->pci.cfg.dev = device_add_child(cbdev, NULL, -1);
253                         if (!dinfo->pci.cfg.dev) {
254                                 DEVPRINTF((cbdev, "Cannot add child!\n"));
255                                 cardbus_freecfg(dinfo);
256                                 continue;
257                         }
258                         resource_list_init(&dinfo->pci.resources);
259                         device_set_ivars(dinfo->pci.cfg.dev, dinfo);
260                         cardbus_do_cis(cbdev, dinfo->pci.cfg.dev);
261                         if (device_probe_and_attach(dinfo->pci.cfg.dev) != 0)
262                                 cardbus_release_all_resources(cbdev, dinfo);
263                         else
264                                 cardattached++;
265                 }
266         }
267
268         if (cardattached > 0)
269                 return (0);
270         POWER_DISABLE_SOCKET(brdev, cbdev);
271         return (ENOENT);
272 }
273
274 static int
275 cardbus_detach_card(device_t cbdev)
276 {
277         int numdevs;
278         device_t *devlist;
279         int tmp;
280         int err = 0;
281
282         device_get_children(cbdev, &devlist, &numdevs);
283
284         if (numdevs == 0) {
285                 free(devlist, M_TEMP);
286                 return (ENOENT);
287         }
288
289         for (tmp = 0; tmp < numdevs; tmp++) {
290                 struct cardbus_devinfo *dinfo = device_get_ivars(devlist[tmp]);
291                 int status = device_get_state(devlist[tmp]);
292
293                 if (dinfo->pci.cfg.dev != devlist[tmp])
294                         device_printf(cbdev, "devinfo dev mismatch\n");
295                 if (status == DS_ATTACHED || status == DS_BUSY)
296                         device_detach(devlist[tmp]);
297                 cardbus_release_all_resources(cbdev, dinfo);
298                 device_delete_child(cbdev, devlist[tmp]);
299                 cardbus_freecfg(dinfo);
300         }
301         POWER_DISABLE_SOCKET(device_get_parent(cbdev), cbdev);
302         free(devlist, M_TEMP);
303         return (err);
304 }
305
306 static void
307 cardbus_driver_added(device_t cbdev, driver_t *driver)
308 {
309         int numdevs;
310         device_t *devlist;
311         int tmp;
312         struct cardbus_devinfo *dinfo;
313
314         device_get_children(cbdev, &devlist, &numdevs);
315
316         DEVICE_IDENTIFY(driver, cbdev);
317         POWER_ENABLE_SOCKET(device_get_parent(cbdev), cbdev);
318         for (tmp = 0; tmp < numdevs; tmp++) {
319                 if (device_get_state(devlist[tmp]) == DS_NOTPRESENT) {
320                         dinfo = device_get_ivars(devlist[tmp]);
321 #ifdef notyet
322                         cardbus_device_setup_regs(brdev, bus, slot, func,
323                             &dinfo->pci.cfg);
324 #endif
325                         cardbus_print_verbose(dinfo);
326                         resource_list_init(&dinfo->pci.resources);
327                         cardbus_do_cis(cbdev, dinfo->pci.cfg.dev);
328                         if (device_probe_and_attach(dinfo->pci.cfg.dev) != 0) {
329                                 cardbus_release_all_resources(cbdev, dinfo);
330                         }
331                 }
332         }
333
334         free(devlist, M_TEMP);
335 }
336
337 /************************************************************************/
338 /* PCI-Like config reading (copied from pci.c                           */
339 /************************************************************************/
340
341 /* read configuration header into pcicfgrect structure */
342
343 static void
344 cardbus_read_extcap(device_t cbdev, pcicfgregs *cfg)
345 {
346 #define REG(n, w) PCIB_READ_CONFIG(cbdev, cfg->bus, cfg->slot, cfg->func, n, w)
347         int ptr, nextptr, ptrptr;
348
349         switch (cfg->hdrtype) {
350         case 0:
351                 ptrptr = 0x34;
352                 break;
353         case 2:
354                 ptrptr = 0x14;
355                 break;
356         default:
357                 return;         /* no extended capabilities support */
358         }
359         nextptr = REG(ptrptr, 1);       /* sanity check? */
360
361         /*
362          * Read capability entries.
363          */
364         while (nextptr != 0) {
365                 /* Sanity check */
366                 if (nextptr > 255) {
367                         printf("illegal PCI extended capability offset %d\n",
368                             nextptr);
369                         return;
370                 }
371                 /* Find the next entry */
372                 ptr = nextptr;
373                 nextptr = REG(ptr + 1, 1);
374
375                 /* Process this entry */
376                 switch (REG(ptr, 1)) {
377                 case 0x01:              /* PCI power management */
378                         if (cfg->pp_cap == 0) {
379                                 cfg->pp_cap = REG(ptr + PCIR_POWER_CAP, 2);
380                                 cfg->pp_status = ptr + PCIR_POWER_STATUS;
381                                 cfg->pp_pmcsr = ptr + PCIR_POWER_PMCSR;
382                                 if ((nextptr - ptr) > PCIR_POWER_DATA)
383                                         cfg->pp_data = ptr + PCIR_POWER_DATA;
384                         }
385                         break;
386                 default:
387                         break;
388                 }
389         }
390 #undef  REG
391 }
392
393 /* extract header type specific config data */
394
395 static void
396 cardbus_hdrtypedata(device_t brdev, int b, int s, int f, pcicfgregs *cfg)
397 {
398 #define REG(n, w)       PCIB_READ_CONFIG(brdev, b, s, f, n, w)
399         switch (cfg->hdrtype) {
400         case 0:
401                 cfg->subvendor  = REG(PCIR_SUBVEND_0, 2);
402                 cfg->subdevice  = REG(PCIR_SUBDEV_0, 2);
403                 cfg->nummaps    = PCI_MAXMAPS_0;
404                 break;
405         case 1:
406                 cfg->subvendor  = REG(PCIR_SUBVEND_1, 2);
407                 cfg->subdevice  = REG(PCIR_SUBDEV_1, 2);
408                 cfg->nummaps    = PCI_MAXMAPS_1;
409                 break;
410         case 2:
411                 cfg->subvendor  = REG(PCIR_SUBVEND_2, 2);
412                 cfg->subdevice  = REG(PCIR_SUBDEV_2, 2);
413                 cfg->nummaps    = PCI_MAXMAPS_2;
414                 break;
415         }
416 #undef  REG
417 }
418
419 static struct cardbus_devinfo *
420 cardbus_read_device(device_t brdev, int b, int s, int f)
421 {
422 #define REG(n, w)       PCIB_READ_CONFIG(brdev, b, s, f, n, w)
423         pcicfgregs *cfg = NULL;
424         struct cardbus_devinfo *devlist_entry = NULL;
425
426         if (REG(PCIR_DEVVENDOR, 4) != 0xffffffff) {
427                 devlist_entry = malloc(sizeof(struct cardbus_devinfo),
428                     M_DEVBUF, M_WAITOK | M_ZERO);
429                 if (devlist_entry == NULL)
430                         return (NULL);
431
432                 cfg = &devlist_entry->pci.cfg;
433
434                 cfg->bus                = b;
435                 cfg->slot               = s;
436                 cfg->func               = f;
437                 cfg->vendor             = REG(PCIR_VENDOR, 2);
438                 cfg->device             = REG(PCIR_DEVICE, 2);
439                 cfg->cmdreg             = REG(PCIR_COMMAND, 2);
440                 cfg->statreg            = REG(PCIR_STATUS, 2);
441                 cfg->baseclass          = REG(PCIR_CLASS, 1);
442                 cfg->subclass           = REG(PCIR_SUBCLASS, 1);
443                 cfg->progif             = REG(PCIR_PROGIF, 1);
444                 cfg->revid              = REG(PCIR_REVID, 1);
445                 cfg->hdrtype            = REG(PCIR_HDRTYPE, 1);
446                 cfg->cachelnsz          = REG(PCIR_CACHELNSZ, 1);
447                 cfg->lattimer           = REG(PCIR_LATTIMER, 1);
448                 cfg->intpin             = REG(PCIR_INTPIN, 1);
449                 cfg->intline            = REG(PCIR_INTLINE, 1);
450
451                 cfg->mingnt             = REG(PCIR_MINGNT, 1);
452                 cfg->maxlat             = REG(PCIR_MAXLAT, 1);
453
454                 cfg->mfdev              = (cfg->hdrtype & PCIM_MFDEV) != 0;
455                 cfg->hdrtype            &= ~PCIM_MFDEV;
456
457                 cardbus_hdrtypedata(brdev, b, s, f, cfg);
458
459                 if (REG(PCIR_STATUS, 2) & PCIM_STATUS_CAPPRESENT)
460                         cardbus_read_extcap(brdev, cfg);
461
462                 devlist_entry->pci.conf.pc_sel.pc_bus = cfg->bus;
463                 devlist_entry->pci.conf.pc_sel.pc_dev = cfg->slot;
464                 devlist_entry->pci.conf.pc_sel.pc_func = cfg->func;
465                 devlist_entry->pci.conf.pc_hdr = cfg->hdrtype;
466
467                 devlist_entry->pci.conf.pc_subvendor = cfg->subvendor;
468                 devlist_entry->pci.conf.pc_subdevice = cfg->subdevice;
469                 devlist_entry->pci.conf.pc_vendor = cfg->vendor;
470                 devlist_entry->pci.conf.pc_device = cfg->device;
471
472                 devlist_entry->pci.conf.pc_class = cfg->baseclass;
473                 devlist_entry->pci.conf.pc_subclass = cfg->subclass;
474                 devlist_entry->pci.conf.pc_progif = cfg->progif;
475                 devlist_entry->pci.conf.pc_revid = cfg->revid;
476         }
477         return (devlist_entry);
478 #undef  REG
479 }
480
481 /* free pcicfgregs structure and all depending data structures */
482
483 static int
484 cardbus_freecfg(struct cardbus_devinfo *dinfo)
485 {
486         free(dinfo, M_DEVBUF);
487
488         return (0);
489 }
490
491 static void
492 cardbus_print_verbose(struct cardbus_devinfo *dinfo)
493 {
494         if (bootverbose || cardbus_debug > 0)
495         {
496                 pcicfgregs *cfg = &dinfo->pci.cfg;
497
498                 printf("found->\tvendor=0x%04x, dev=0x%04x, revid=0x%02x\n",
499                     cfg->vendor, cfg->device, cfg->revid);
500                 printf("\tclass=%02x-%02x-%02x, hdrtype=0x%02x, mfdev=%d\n",
501                     cfg->baseclass, cfg->subclass, cfg->progif,
502                     cfg->hdrtype, cfg->mfdev);
503                 printf("\tcmdreg=0x%04x, statreg=0x%04x, "
504                     "cachelnsz=%d (dwords)\n",
505                     cfg->cmdreg, cfg->statreg, cfg->cachelnsz);
506                 printf("\tlattimer=0x%02x (%d ns), mingnt=0x%02x (%d ns), "
507                     "maxlat=0x%02x (%d ns)\n",
508                     cfg->lattimer, cfg->lattimer * 30,
509                     cfg->mingnt, cfg->mingnt * 250, cfg->maxlat,
510                     cfg->maxlat * 250);
511                 if (cfg->intpin > 0)
512                         printf("\tintpin=%c, irq=%d\n",
513                             cfg->intpin + 'a' - 1, cfg->intline);
514         }
515 }
516
517 /************************************************************************/
518 /* Resources                                                            */
519 /************************************************************************/
520
521 static int
522 cardbus_set_resource(device_t cbdev, device_t child, int type, int rid,
523     u_long start, u_long count, struct resource *res)
524 {
525         struct cardbus_devinfo *dinfo;
526         struct resource_list *rl;
527         struct resource_list_entry *rle;
528
529         if (device_get_parent(child) != cbdev)
530                 return ENOENT;
531
532         dinfo = device_get_ivars(child);
533         rl = &dinfo->pci.resources;
534         rle = resource_list_find(rl, type, rid);
535         if (rle == NULL) {
536                 resource_list_add(rl, type, rid, start, start + count - 1,
537                     count);
538                 if (res != NULL) {
539                         rle = resource_list_find(rl, type, rid);
540                         rle->res = res;
541                 }
542         } else {
543                 if (rle->res == NULL) {
544                 } else if (rle->res->r_dev == cbdev &&
545                     (!(rman_get_flags(rle->res) & RF_ACTIVE))) {
546                         int f;
547                         f = rman_get_flags(rle->res);
548                         bus_release_resource(cbdev, type, rid, res);
549                         rle->res = bus_alloc_resource(cbdev, type, &rid,
550                             start, start + count - 1,
551                             count, f);
552                 } else {
553                         device_printf(cbdev, "set_resource: resource busy\n");
554                         return EBUSY;
555                 }
556                 rle->start = start;
557                 rle->end = start + count - 1;
558                 rle->count = count;
559                 if (res != NULL)
560                         rle->res = res;
561         }
562         if (device_get_parent(child) == cbdev)
563                 pci_write_config(child, rid, start, 4);
564         return 0;
565 }
566
567 static int
568 cardbus_get_resource(device_t cbdev, device_t child, int type, int rid,
569     u_long *startp, u_long *countp)
570 {
571         struct cardbus_devinfo *dinfo;
572         struct resource_list *rl;
573         struct resource_list_entry *rle;
574
575         if (device_get_parent(child) != cbdev)
576                 return ENOENT;
577
578         dinfo = device_get_ivars(child);
579         rl = &dinfo->pci.resources;
580         rle = resource_list_find(rl, type, rid);
581         if (!rle)
582                 return ENOENT;
583         if (startp)
584                 *startp = rle->start;
585         if (countp)
586                 *countp = rle->count;
587         return 0;
588 }
589
590 static void
591 cardbus_delete_resource(device_t cbdev, device_t child, int type, int rid)
592 {
593         struct cardbus_devinfo *dinfo;
594         struct resource_list *rl;
595         struct resource_list_entry *rle;
596
597         if (device_get_parent(child) != cbdev)
598                 return;
599
600         dinfo = device_get_ivars(child);
601         rl = &dinfo->pci.resources;
602         rle = resource_list_find(rl, type, rid);
603         if (rle) {
604                 if (rle->res) {
605                         if (rle->res->r_dev != cbdev ||
606                             rman_get_flags(rle->res) & RF_ACTIVE) {
607                                 device_printf(cbdev, "delete_resource: "
608                                     "Resource still owned by child, oops. "
609                                     "(type=%d, rid=%d, addr=%lx)\n",
610                                     rle->type, rle->rid,
611                                     rman_get_start(rle->res));
612                                 return;
613                         }
614                         bus_release_resource(cbdev, type, rid, rle->res);
615                 }
616                 resource_list_delete(rl, type, rid);
617         }
618         if (device_get_parent(child) == cbdev)
619                 pci_write_config(child, rid, 0, 4);
620 }
621
622 static int
623 cardbus_set_resource_method(device_t cbdev, device_t child, int type, int rid,
624     u_long start, u_long count)
625 {
626         int ret;
627         ret = cardbus_set_resource(cbdev, child, type, rid, start, count, NULL);
628         if (ret != 0)
629                 return ret;
630         return BUS_SET_RESOURCE(device_get_parent(cbdev), child, type, rid,
631             start, count);
632 }
633
634 static int
635 cardbus_get_resource_method(device_t cbdev, device_t child, int type, int rid,
636     u_long *startp, u_long *countp)
637 {
638         int ret;
639         ret = cardbus_get_resource(cbdev, child, type, rid, startp, countp);
640         if (ret != 0)
641                 return ret;
642         return BUS_GET_RESOURCE(device_get_parent(cbdev), child, type, rid,
643             startp, countp);
644 }
645
646 static void
647 cardbus_delete_resource_method(device_t cbdev, device_t child,
648     int type, int rid)
649 {
650         cardbus_delete_resource(cbdev, child, type, rid);
651         BUS_DELETE_RESOURCE(device_get_parent(cbdev), child, type, rid);
652 }
653
654 static void
655 cardbus_release_all_resources(device_t cbdev, struct cardbus_devinfo *dinfo)
656 {
657         struct resource_list_entry *rle;
658
659         /* Free all allocated resources */
660         SLIST_FOREACH(rle, &dinfo->pci.resources, link) {
661                 if (rle->res) {
662                         if (rle->res->r_dev != cbdev)
663                                 device_printf(cbdev, "release_all_resource: "
664                                     "Resource still owned by child, oops. "
665                                     "(type=%d, rid=%d, addr=%lx)\n",
666                                     rle->type, rle->rid,
667                                     rman_get_start(rle->res));
668                         BUS_RELEASE_RESOURCE(device_get_parent(cbdev),
669                             rle->res->r_dev,
670                             rle->type, rle->rid,
671                             rle->res);
672                         rle->res = NULL;
673                         /*
674                          * zero out config so the card won't acknowledge
675                          * access to the space anymore
676                          */
677                         pci_write_config(dinfo->pci.cfg.dev, rle->rid, 0, 4);
678                 }
679         }
680         resource_list_free(&dinfo->pci.resources);
681 }
682
683 static struct resource *
684 cardbus_alloc_resource(device_t cbdev, device_t child, int type,
685     int *rid, u_long start, u_long end, u_long count, u_int flags)
686 {
687         struct cardbus_devinfo *dinfo;
688         struct resource_list_entry *rle = 0;
689         int passthrough = (device_get_parent(child) != cbdev);
690
691         if (passthrough) {
692                 return (BUS_ALLOC_RESOURCE(device_get_parent(cbdev), child,
693                     type, rid, start, end, count, flags));
694         }
695
696         dinfo = device_get_ivars(child);
697         rle = resource_list_find(&dinfo->pci.resources, type, *rid);
698
699         if (!rle)
700                 return NULL;            /* no resource of that type/rid */
701
702         if (!rle->res) {
703                 device_printf(cbdev, "WARNING: Resource not reserved by bus\n");
704                 return NULL;
705         } else {
706                 /* Release the cardbus hold on the resource */
707                 if (rle->res->r_dev != cbdev)
708                         return NULL;
709                 bus_release_resource(cbdev, type, *rid, rle->res);
710                 rle->res = NULL;
711                 switch (type) {
712                 case SYS_RES_IOPORT:
713                 case SYS_RES_MEMORY:
714                         if (!(flags & RF_ALIGNMENT_MASK))
715                                 flags |= rman_make_alignment_flags(rle->count);
716                         break;
717                 case SYS_RES_IRQ:
718                         flags |= RF_SHAREABLE;
719                         break;
720                 }
721                 /* Allocate the resource to the child */
722                 return resource_list_alloc(&dinfo->pci.resources, cbdev, child,
723                     type, rid, rle->start, rle->end, rle->count, flags);
724         }
725 }
726
727 static int
728 cardbus_release_resource(device_t cbdev, device_t child, int type, int rid,
729     struct resource *r)
730 {
731         struct cardbus_devinfo *dinfo;
732         int passthrough = (device_get_parent(child) != cbdev);
733         struct resource_list_entry *rle = 0;
734         int flags;
735         int ret;
736
737         if (passthrough) {
738                 return BUS_RELEASE_RESOURCE(device_get_parent(cbdev), child,
739                     type, rid, r);
740         }
741
742         dinfo = device_get_ivars(child);
743         /*
744          * According to the PCI 2.2 spec, devices may share an address
745          * decoder between memory mapped ROM access and memory
746          * mapped register access.  To be safe, disable ROM access
747          * whenever it is released.
748          */
749         if (rid == CARDBUS_ROM_REG) {
750                 uint32_t rom_reg;
751
752                 rom_reg = pci_read_config(child, rid, 4);
753                 rom_reg &= ~CARDBUS_ROM_ENABLE;
754                 pci_write_config(child, rid, rom_reg, 4);
755         }
756
757         rle = resource_list_find(&dinfo->pci.resources, type, rid);
758
759         if (!rle) {
760                 device_printf(cbdev, "Allocated resource not found\n");
761                 return ENOENT;
762         }
763         if (!rle->res) {
764                 device_printf(cbdev, "Allocated resource not recorded\n");
765                 return ENOENT;
766         }
767
768         ret = BUS_RELEASE_RESOURCE(device_get_parent(cbdev), child,
769             type, rid, r);
770         switch (type) {
771         case SYS_RES_IOPORT:
772         case SYS_RES_MEMORY:
773                 flags = rman_make_alignment_flags(rle->count);
774                 break;
775         case SYS_RES_IRQ:
776                 flags = RF_SHAREABLE;
777                 break;
778         default:
779                 flags = 0;
780         }
781         /* Restore cardbus hold on the resource */
782         rle->res = bus_alloc_resource(cbdev, type, &rid,
783             rle->start, rle->end, rle->count, flags);
784         if (rle->res == NULL)
785                 device_printf(cbdev, "release_resource: "
786                     "unable to reacquire resource\n");
787         return ret;
788 }
789
790 static int
791 cardbus_setup_intr(device_t cbdev, device_t child, struct resource *irq,
792     int flags, driver_intr_t *intr, void *arg, void **cookiep)
793 {
794         int ret;
795         device_t cdev;
796         struct cardbus_devinfo *dinfo;
797
798         ret = bus_generic_setup_intr(cbdev, child, irq, flags, intr, arg,
799             cookiep);
800         if (ret != 0)
801                 return ret;
802
803         for (cdev = child; cbdev != device_get_parent(cdev);
804             cdev = device_get_parent(cdev))
805                 /* NOTHING */;
806         dinfo = device_get_ivars(cdev);
807
808         return 0;
809 }
810
811 static int
812 cardbus_teardown_intr(device_t cbdev, device_t child, struct resource *irq,
813     void *cookie)
814 {
815         int ret;
816         device_t cdev;
817         struct cardbus_devinfo *dinfo;
818
819         ret = bus_generic_teardown_intr(cbdev, child, irq, cookie);
820         if (ret != 0)
821                 return ret;
822
823         for (cdev = child; cbdev != device_get_parent(cdev);
824             cdev = device_get_parent(cdev))
825                 /* NOTHING */;
826         dinfo = device_get_ivars(cdev);
827
828         return (0);
829 }
830
831
832 /************************************************************************/
833 /* Other Bus Methods                                                    */
834 /************************************************************************/
835
836 static int
837 cardbus_print_resources(struct resource_list *rl, const char *name,
838     int type, const char *format)
839 {
840         struct resource_list_entry *rle;
841         int printed, retval;
842
843         printed = 0;
844         retval = 0;
845         /* Yes, this is kinda cheating */
846         SLIST_FOREACH(rle, rl, link) {
847                 if (rle->type == type) {
848                         if (printed == 0)
849                                 retval += printf(" %s ", name);
850                         else if (printed > 0)
851                                 retval += printf(",");
852                         printed++;
853                         retval += printf(format, rle->start);
854                         if (rle->count > 1) {
855                                 retval += printf("-");
856                                 retval += printf(format, rle->start +
857                                     rle->count - 1);
858                         }
859                 }
860         }
861         return retval;
862 }
863
864 static int
865 cardbus_print_child(device_t cbdev, device_t child)
866 {
867         struct cardbus_devinfo *dinfo;
868         struct resource_list *rl;
869         pcicfgregs *cfg;
870         int retval = 0;
871
872         dinfo = device_get_ivars(child);
873         cfg = &dinfo->pci.cfg;
874         rl = &dinfo->pci.resources;
875
876         retval += bus_print_child_header(cbdev, child);
877
878         retval += cardbus_print_resources(rl, "port", SYS_RES_IOPORT, "%#lx");
879         retval += cardbus_print_resources(rl, "mem", SYS_RES_MEMORY, "%#lx");
880         retval += cardbus_print_resources(rl, "irq", SYS_RES_IRQ, "%ld");
881         if (device_get_flags(cbdev))
882                 retval += printf(" flags %#x", device_get_flags(cbdev));
883
884         retval += printf(" at device %d.%d", pci_get_slot(child),
885             pci_get_function(child));
886
887         retval += bus_print_child_footer(cbdev, child);
888
889         return (retval);
890 }
891
892 static void
893 cardbus_probe_nomatch(device_t cbdev, device_t child)
894 {
895         struct cardbus_devinfo *dinfo;
896         pcicfgregs *cfg;
897
898         dinfo = device_get_ivars(child);
899         cfg = &dinfo->pci.cfg;
900         device_printf(cbdev, "<unknown card>");
901         printf(" (vendor=0x%04x, dev=0x%04x)", cfg->vendor, cfg->device);
902         printf(" at %d.%d", pci_get_slot(child), pci_get_function(child));
903         if (cfg->intpin > 0 && cfg->intline != 255) {
904                 printf(" irq %d", cfg->intline);
905         }
906         printf("\n");
907
908         return;
909 }
910
911 static int
912 cardbus_child_location_str(device_t cbdev, device_t child, char *buf,
913     size_t buflen)
914 {
915         struct cardbus_devinfo *dinfo;
916         pcicfgregs *cfg;
917
918         dinfo = device_get_ivars(child);
919         cfg = &dinfo->pci.cfg;
920         snprintf(buf, buflen, "slot=%d function=%d", pci_get_slot(child),
921             pci_get_function(child));
922         return (0);
923 }
924
925 static int
926 cardbus_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
927     size_t buflen)
928 {
929         struct cardbus_devinfo *dinfo;
930         pcicfgregs *cfg;
931
932         dinfo = device_get_ivars(child);
933         cfg = &dinfo->pci.cfg;
934         snprintf(buf, buflen, "vendor=0x%04x device=0x%04x subvendor=0x%04x "
935             "subdevice=0x%04x", cfg->vendor, cfg->device, cfg->subvendor,
936             cfg->subdevice);
937         return (0);
938 }
939
940 static int
941 cardbus_read_ivar(device_t cbdev, device_t child, int which, u_long *result)
942 {
943         struct cardbus_devinfo *dinfo;
944         pcicfgregs *cfg;
945
946         dinfo = device_get_ivars(child);
947         cfg = &dinfo->pci.cfg;
948
949         switch (which) {
950         case PCI_IVAR_ETHADDR:
951                 /*
952                  * The generic accessor doesn't deal with failure, so
953                  * we set the return value, then return an error.
954                  */
955                 if ((dinfo->fepresent & (1 << TPL_FUNCE_LAN_NID)) == 0) {
956                         *((u_int8_t **) result) = NULL;
957                         return (EINVAL);
958                 }
959                 *((u_int8_t **) result) = dinfo->funce.lan.nid;
960                 break;
961         case PCI_IVAR_SUBVENDOR:
962                 *result = cfg->subvendor;
963                 break;
964         case PCI_IVAR_SUBDEVICE:
965                 *result = cfg->subdevice;
966                 break;
967         case PCI_IVAR_VENDOR:
968                 *result = cfg->vendor;
969                 break;
970         case PCI_IVAR_DEVICE:
971                 *result = cfg->device;
972                 break;
973         case PCI_IVAR_DEVID:
974                 *result = (cfg->device << 16) | cfg->vendor;
975                 break;
976         case PCI_IVAR_CLASS:
977                 *result = cfg->baseclass;
978                 break;
979         case PCI_IVAR_SUBCLASS:
980                 *result = cfg->subclass;
981                 break;
982         case PCI_IVAR_PROGIF:
983                 *result = cfg->progif;
984                 break;
985         case PCI_IVAR_REVID:
986                 *result = cfg->revid;
987                 break;
988         case PCI_IVAR_INTPIN:
989                 *result = cfg->intpin;
990                 break;
991         case PCI_IVAR_IRQ:
992                 *result = cfg->intline;
993                 break;
994         case PCI_IVAR_BUS:
995                 *result = cfg->bus;
996                 break;
997         case PCI_IVAR_SLOT:
998                 *result = cfg->slot;
999                 break;
1000         case PCI_IVAR_FUNCTION:
1001                 *result = cfg->func;
1002                 break;
1003         default:
1004                 return ENOENT;
1005         }
1006         return 0;
1007 }
1008
1009 static int
1010 cardbus_write_ivar(device_t cbdev, device_t child, int which, uintptr_t value)
1011 {
1012         struct cardbus_devinfo *dinfo;
1013         pcicfgregs *cfg;
1014
1015         dinfo = device_get_ivars(child);
1016         cfg = &dinfo->pci.cfg;
1017
1018         switch (which) {
1019         case PCI_IVAR_ETHADDR:
1020         case PCI_IVAR_SUBVENDOR:
1021         case PCI_IVAR_SUBDEVICE:
1022         case PCI_IVAR_VENDOR:
1023         case PCI_IVAR_DEVICE:
1024         case PCI_IVAR_DEVID:
1025         case PCI_IVAR_CLASS:
1026         case PCI_IVAR_SUBCLASS:
1027         case PCI_IVAR_PROGIF:
1028         case PCI_IVAR_REVID:
1029         case PCI_IVAR_INTPIN:
1030         case PCI_IVAR_IRQ:
1031         case PCI_IVAR_BUS:
1032         case PCI_IVAR_SLOT:
1033         case PCI_IVAR_FUNCTION:
1034                 return EINVAL;  /* disallow for now */
1035         default:
1036                 return ENOENT;
1037         }
1038         return 0;
1039 }
1040
1041 /************************************************************************/
1042 /* Compatibility with PCI bus (XXX: Do we need this?)                   */
1043 /************************************************************************/
1044
1045 /*
1046  * PCI power manangement
1047  */
1048 static int
1049 cardbus_set_powerstate_method(device_t cbdev, device_t child, int state)
1050 {
1051         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1052         pcicfgregs *cfg = &dinfo->pci.cfg;
1053         u_int16_t status;
1054         int result;
1055
1056         if (cfg->pp_cap != 0) {
1057                 status = PCI_READ_CONFIG(cbdev, child, cfg->pp_status, 2)
1058                     & ~PCIM_PSTAT_DMASK;
1059                 result = 0;
1060                 switch (state) {
1061                 case PCI_POWERSTATE_D0:
1062                         status |= PCIM_PSTAT_D0;
1063                         break;
1064                 case PCI_POWERSTATE_D1:
1065                         if (cfg->pp_cap & PCIM_PCAP_D1SUPP) {
1066                                 status |= PCIM_PSTAT_D1;
1067                         } else {
1068                                 result = EOPNOTSUPP;
1069                         }
1070                         break;
1071                 case PCI_POWERSTATE_D2:
1072                         if (cfg->pp_cap & PCIM_PCAP_D2SUPP) {
1073                                 status |= PCIM_PSTAT_D2;
1074                         } else {
1075                                 result = EOPNOTSUPP;
1076                         }
1077                         break;
1078                 case PCI_POWERSTATE_D3:
1079                         status |= PCIM_PSTAT_D3;
1080                         break;
1081                 default:
1082                         result = EINVAL;
1083                 }
1084                 if (result == 0)
1085                         PCI_WRITE_CONFIG(cbdev, child, cfg->pp_status,
1086                             status, 2);
1087         } else {
1088                 result = ENXIO;
1089         }
1090         return (result);
1091 }
1092
1093 static int
1094 cardbus_get_powerstate_method(device_t cbdev, device_t child)
1095 {
1096         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1097         pcicfgregs *cfg = &dinfo->pci.cfg;
1098         u_int16_t status;
1099         int result;
1100
1101         if (cfg->pp_cap != 0) {
1102                 status = PCI_READ_CONFIG(cbdev, child, cfg->pp_status, 2);
1103                 switch (status & PCIM_PSTAT_DMASK) {
1104                 case PCIM_PSTAT_D0:
1105                         result = PCI_POWERSTATE_D0;
1106                         break;
1107                 case PCIM_PSTAT_D1:
1108                         result = PCI_POWERSTATE_D1;
1109                         break;
1110                 case PCIM_PSTAT_D2:
1111                         result = PCI_POWERSTATE_D2;
1112                         break;
1113                 case PCIM_PSTAT_D3:
1114                         result = PCI_POWERSTATE_D3;
1115                         break;
1116                 default:
1117                         result = PCI_POWERSTATE_UNKNOWN;
1118                         break;
1119                 }
1120         } else {
1121                 /* No support, device is always at D0 */
1122                 result = PCI_POWERSTATE_D0;
1123         }
1124         return (result);
1125 }
1126
1127 static u_int32_t
1128 cardbus_read_config_method(device_t cbdev, device_t child, int reg, int width)
1129 {
1130         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1131         pcicfgregs *cfg = &dinfo->pci.cfg;
1132
1133         return PCIB_READ_CONFIG(device_get_parent(cbdev),
1134             cfg->bus, cfg->slot, cfg->func, reg, width);
1135 }
1136
1137 static void
1138 cardbus_write_config_method(device_t cbdev, device_t child, int reg,
1139     u_int32_t val, int width)
1140 {
1141         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1142         pcicfgregs *cfg = &dinfo->pci.cfg;
1143
1144         PCIB_WRITE_CONFIG(device_get_parent(cbdev),
1145             cfg->bus, cfg->slot, cfg->func, reg, val, width);
1146 }
1147
1148 static __inline void
1149 cardbus_set_command_bit(device_t cbdev, device_t child, u_int16_t bit)
1150 {
1151         u_int16_t command;
1152
1153         command = PCI_READ_CONFIG(cbdev, child, PCIR_COMMAND, 2);
1154         command |= bit;
1155         PCI_WRITE_CONFIG(cbdev, child, PCIR_COMMAND, command, 2);
1156 }
1157
1158 static __inline void
1159 cardbus_clear_command_bit(device_t cbdev, device_t child, u_int16_t bit)
1160 {
1161         u_int16_t command;
1162
1163         command = PCI_READ_CONFIG(cbdev, child, PCIR_COMMAND, 2);
1164         command &= ~bit;
1165         PCI_WRITE_CONFIG(cbdev, child, PCIR_COMMAND, command, 2);
1166 }
1167
1168 static void
1169 cardbus_enable_busmaster_method(device_t cbdev, device_t child)
1170 {
1171         cardbus_set_command_bit(cbdev, child, PCIM_CMD_BUSMASTEREN);
1172 }
1173
1174 static void
1175 cardbus_disable_busmaster_method(device_t cbdev, device_t child)
1176 {
1177         cardbus_clear_command_bit(cbdev, child, PCIM_CMD_BUSMASTEREN);
1178 }
1179
1180 static void
1181 cardbus_enable_io_method(device_t cbdev, device_t child, int space)
1182 {
1183         switch (space) {
1184         case SYS_RES_IOPORT:
1185                 cardbus_set_command_bit(cbdev, child, PCIM_CMD_PORTEN);
1186                 break;
1187         case SYS_RES_MEMORY:
1188                 cardbus_set_command_bit(cbdev, child, PCIM_CMD_MEMEN);
1189                 break;
1190         }
1191 }
1192
1193 static void
1194 cardbus_disable_io_method(device_t cbdev, device_t child, int space)
1195 {
1196         switch (space) {
1197         case SYS_RES_IOPORT:
1198                 cardbus_clear_command_bit(cbdev, child, PCIM_CMD_PORTEN);
1199                 break;
1200         case SYS_RES_MEMORY:
1201                 cardbus_clear_command_bit(cbdev, child, PCIM_CMD_MEMEN);
1202                 break;
1203         }
1204 }
1205
1206 static device_method_t cardbus_methods[] = {
1207         /* Device interface */
1208         DEVMETHOD(device_probe,         cardbus_probe),
1209         DEVMETHOD(device_attach,        cardbus_attach),
1210         DEVMETHOD(device_detach,        cardbus_detach),
1211         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
1212         DEVMETHOD(device_suspend,       cardbus_suspend),
1213         DEVMETHOD(device_resume,        cardbus_resume),
1214
1215         /* Bus interface */
1216         DEVMETHOD(bus_print_child,      cardbus_print_child),
1217         DEVMETHOD(bus_probe_nomatch,    cardbus_probe_nomatch),
1218         DEVMETHOD(bus_read_ivar,        cardbus_read_ivar),
1219         DEVMETHOD(bus_write_ivar,       cardbus_write_ivar),
1220         DEVMETHOD(bus_driver_added,     cardbus_driver_added),
1221         DEVMETHOD(bus_alloc_resource,   cardbus_alloc_resource),
1222         DEVMETHOD(bus_release_resource, cardbus_release_resource),
1223         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1224         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1225         DEVMETHOD(bus_setup_intr,       cardbus_setup_intr),
1226         DEVMETHOD(bus_teardown_intr,    cardbus_teardown_intr),
1227
1228         DEVMETHOD(bus_set_resource,     cardbus_set_resource_method),
1229         DEVMETHOD(bus_get_resource,     cardbus_get_resource_method),
1230         DEVMETHOD(bus_delete_resource,  cardbus_delete_resource_method),
1231         DEVMETHOD(bus_child_pnpinfo_str, cardbus_child_pnpinfo_str),
1232         DEVMETHOD(bus_child_location_str, cardbus_child_location_str),
1233
1234         /* Card Interface */
1235         DEVMETHOD(card_attach_card,     cardbus_attach_card),
1236         DEVMETHOD(card_detach_card,     cardbus_detach_card),
1237         DEVMETHOD(card_cis_read,        cardbus_cis_read),
1238         DEVMETHOD(card_cis_free,        cardbus_cis_free),
1239
1240         /* Cardbus/PCI interface */
1241         DEVMETHOD(pci_read_config,      cardbus_read_config_method),
1242         DEVMETHOD(pci_write_config,     cardbus_write_config_method),
1243         DEVMETHOD(pci_enable_busmaster, cardbus_enable_busmaster_method),
1244         DEVMETHOD(pci_disable_busmaster, cardbus_disable_busmaster_method),
1245         DEVMETHOD(pci_enable_io,        cardbus_enable_io_method),
1246         DEVMETHOD(pci_disable_io,       cardbus_disable_io_method),
1247         DEVMETHOD(pci_get_powerstate,   cardbus_get_powerstate_method),
1248         DEVMETHOD(pci_set_powerstate,   cardbus_set_powerstate_method),
1249
1250         {0,0}
1251 };
1252
1253 static driver_t cardbus_driver = {
1254         "cardbus",
1255         cardbus_methods,
1256         0 /* no softc */
1257 };
1258
1259 static devclass_t cardbus_devclass;
1260
1261 DRIVER_MODULE(cardbus, cbb, cardbus_driver, cardbus_devclass, 0, 0);
1262 MODULE_VERSION(cardbus, 1);
1263 MODULE_DEPEND(cardbus, exca, 1, 1, 1);
1264 /*
1265 MODULE_DEPEND(cardbus, pccbb, 1, 1, 1);
1266 */