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.3 2005/02/04 02:52:18 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=[%s]%02x-%02x-%02x, hdrtype=0x%02x, mfdev=%d\n",
 501                     pci_class_to_string(cfg->baseclass),
 502                     cfg->baseclass, cfg->subclass, cfg->progif,
 503                     cfg->hdrtype, cfg->mfdev);
 504                 printf("\tcmdreg=0x%04x, statreg=0x%04x, "
 505                     "cachelnsz=%d (dwords)\n",
 506                     cfg->cmdreg, cfg->statreg, cfg->cachelnsz);
 507                 printf("\tlattimer=0x%02x (%d ns), mingnt=0x%02x (%d ns), "
 508                     "maxlat=0x%02x (%d ns)\n",
 509                     cfg->lattimer, cfg->lattimer * 30,
 510                     cfg->mingnt, cfg->mingnt * 250, cfg->maxlat,
 511                     cfg->maxlat * 250);
 512                 if (cfg->intpin > 0)
 513                         printf("\tintpin=%c, irq=%d\n",
 514                             cfg->intpin + 'a' - 1, cfg->intline);
 515         }
 516 }
 517
 518 /************************************************************************/
 519 /* Resources                                                            */
 520 /************************************************************************/
 521
 522 static int
 523 cardbus_set_resource(device_t cbdev, device_t child, int type, int rid,
 524     u_long start, u_long count, struct resource *res)
 525 {
 526         struct cardbus_devinfo *dinfo;
 527         struct resource_list *rl;
 528         struct resource_list_entry *rle;
 529
 530         if (device_get_parent(child) != cbdev)
 531                 return ENOENT;
 532
 533         dinfo = device_get_ivars(child);
 534         rl = &dinfo->pci.resources;
 535         rle = resource_list_find(rl, type, rid);
 536         if (rle == NULL) {
 537                 resource_list_add(rl, type, rid, start, start + count - 1,
 538                     count);
 539                 if (res != NULL) {
 540                         rle = resource_list_find(rl, type, rid);
 541                         rle->res = res;
 542                 }
 543         } else {
 544                 if (rle->res == NULL) {
 545                 } else if (rle->res->r_dev == cbdev &&
 546                     (!(rman_get_flags(rle->res) & RF_ACTIVE))) {
 547                         int f;
 548                         f = rman_get_flags(rle->res);
 549                         bus_release_resource(cbdev, type, rid, res);
 550                         rle->res = bus_alloc_resource(cbdev, type, &rid,
 551                             start, start + count - 1,
 552                             count, f);
 553                 } else {
 554                         device_printf(cbdev, "set_resource: resource busy\n");
 555                         return EBUSY;
 556                 }
 557                 rle->start = start;
 558                 rle->end = start + count - 1;
 559                 rle->count = count;
 560                 if (res != NULL)
 561                         rle->res = res;
 562         }
 563         if (device_get_parent(child) == cbdev)
 564                 pci_write_config(child, rid, start, 4);
 565         return 0;
 566 }
 567
 568 static int
 569 cardbus_get_resource(device_t cbdev, device_t child, int type, int rid,
 570     u_long *startp, u_long *countp)
 571 {
 572         struct cardbus_devinfo *dinfo;
 573         struct resource_list *rl;
 574         struct resource_list_entry *rle;
 575
 576         if (device_get_parent(child) != cbdev)
 577                 return ENOENT;
 578
 579         dinfo = device_get_ivars(child);
 580         rl = &dinfo->pci.resources;
 581         rle = resource_list_find(rl, type, rid);
 582         if (!rle)
 583                 return ENOENT;
 584         if (startp)
 585                 *startp = rle->start;
 586         if (countp)
 587                 *countp = rle->count;
 588         return 0;
 589 }
 590
 591 static void
 592 cardbus_delete_resource(device_t cbdev, device_t child, int type, int rid)
 593 {
 594         struct cardbus_devinfo *dinfo;
 595         struct resource_list *rl;
 596         struct resource_list_entry *rle;
 597
 598         if (device_get_parent(child) != cbdev)
 599                 return;
 600
 601         dinfo = device_get_ivars(child);
 602         rl = &dinfo->pci.resources;
 603         rle = resource_list_find(rl, type, rid);
 604         if (rle) {
 605                 if (rle->res) {
 606                         if (rle->res->r_dev != cbdev ||
 607                             rman_get_flags(rle->res) & RF_ACTIVE) {
 608                                 device_printf(cbdev, "delete_resource: "
 609                                     "Resource still owned by child, oops. "
 610                                     "(type=%d, rid=%d, addr=%lx)\n",
 611                                     rle->type, rle->rid,
 612                                     rman_get_start(rle->res));
 613                                 return;
 614                         }
 615                         bus_release_resource(cbdev, type, rid, rle->res);
 616                 }
 617                 resource_list_delete(rl, type, rid);
 618         }
 619         if (device_get_parent(child) == cbdev)
 620                 pci_write_config(child, rid, 0, 4);
 621 }
 622
 623 static int
 624 cardbus_set_resource_method(device_t cbdev, device_t child, int type, int rid,
 625     u_long start, u_long count)
 626 {
 627         int ret;
 628         ret = cardbus_set_resource(cbdev, child, type, rid, start, count, NULL);
 629         if (ret != 0)
 630                 return ret;
 631         return BUS_SET_RESOURCE(device_get_parent(cbdev), child, type, rid,
 632             start, count);
 633 }
 634
 635 static int
 636 cardbus_get_resource_method(device_t cbdev, device_t child, int type, int rid,
 637     u_long *startp, u_long *countp)
 638 {
 639         int ret;
 640         ret = cardbus_get_resource(cbdev, child, type, rid, startp, countp);
 641         if (ret != 0)
 642                 return ret;
 643         return BUS_GET_RESOURCE(device_get_parent(cbdev), child, type, rid,
 644             startp, countp);
 645 }
 646
 647 static void
 648 cardbus_delete_resource_method(device_t cbdev, device_t child,
 649     int type, int rid)
 650 {
 651         cardbus_delete_resource(cbdev, child, type, rid);
 652         BUS_DELETE_RESOURCE(device_get_parent(cbdev), child, type, rid);
 653 }
 654
 655 static void
 656 cardbus_release_all_resources(device_t cbdev, struct cardbus_devinfo *dinfo)
 657 {
 658         struct resource_list_entry *rle;
 659
 660         /* Free all allocated resources */
 661         SLIST_FOREACH(rle, &dinfo->pci.resources, link) {
 662                 if (rle->res) {
 663                         if (rle->res->r_dev != cbdev)
 664                                 device_printf(cbdev, "release_all_resource: "
 665                                     "Resource still owned by child, oops. "
 666                                     "(type=%d, rid=%d, addr=%lx)\n",
 667                                     rle->type, rle->rid,
 668                                     rman_get_start(rle->res));
 669                         BUS_RELEASE_RESOURCE(device_get_parent(cbdev),
 670                             rle->res->r_dev,
 671                             rle->type, rle->rid,
 672                             rle->res);
 673                         rle->res = NULL;
 674                         /*
 675                          * zero out config so the card won't acknowledge
 676                          * access to the space anymore
 677                          */
 678                         pci_write_config(dinfo->pci.cfg.dev, rle->rid, 0, 4);
 679                 }
 680         }
 681         resource_list_free(&dinfo->pci.resources);
 682 }
 683
 684 static struct resource *
 685 cardbus_alloc_resource(device_t cbdev, device_t child, int type,
 686     int *rid, u_long start, u_long end, u_long count, u_int flags)
 687 {
 688         struct cardbus_devinfo *dinfo;
 689         struct resource_list_entry *rle = 0;
 690         int passthrough = (device_get_parent(child) != cbdev);
 691
 692         if (passthrough) {
 693                 return (BUS_ALLOC_RESOURCE(device_get_parent(cbdev), child,
 694                     type, rid, start, end, count, flags));
 695         }
 696
 697         dinfo = device_get_ivars(child);
 698         rle = resource_list_find(&dinfo->pci.resources, type, *rid);
 699
 700         if (!rle)
 701                 return NULL;            /* no resource of that type/rid */
 702
 703         if (!rle->res) {
 704                 device_printf(cbdev, "WARNING: Resource not reserved by bus\n");
 705                 return NULL;
 706         } else {
 707                 /* Release the cardbus hold on the resource */
 708                 if (rle->res->r_dev != cbdev)
 709                         return NULL;
 710                 bus_release_resource(cbdev, type, *rid, rle->res);
 711                 rle->res = NULL;
 712                 switch (type) {
 713                 case SYS_RES_IOPORT:
 714                 case SYS_RES_MEMORY:
 715                         if (!(flags & RF_ALIGNMENT_MASK))
 716                                 flags |= rman_make_alignment_flags(rle->count);
 717                         break;
 718                 case SYS_RES_IRQ:
 719                         flags |= RF_SHAREABLE;
 720                         break;
 721                 }
 722                 /* Allocate the resource to the child */
 723                 return resource_list_alloc(&dinfo->pci.resources, cbdev, child,
 724                     type, rid, rle->start, rle->end, rle->count, flags);
 725         }
 726 }
 727
 728 static int
 729 cardbus_release_resource(device_t cbdev, device_t child, int type, int rid,
 730     struct resource *r)
 731 {
 732         struct cardbus_devinfo *dinfo;
 733         int passthrough = (device_get_parent(child) != cbdev);
 734         struct resource_list_entry *rle = 0;
 735         int flags;
 736         int ret;
 737
 738         if (passthrough) {
 739                 return BUS_RELEASE_RESOURCE(device_get_parent(cbdev), child,
 740                     type, rid, r);
 741         }
 742
 743         dinfo = device_get_ivars(child);
 744         /*
 745          * According to the PCI 2.2 spec, devices may share an address
 746          * decoder between memory mapped ROM access and memory
 747          * mapped register access.  To be safe, disable ROM access
 748          * whenever it is released.
 749          */
 750         if (rid == CARDBUS_ROM_REG) {
 751                 uint32_t rom_reg;
 752
 753                 rom_reg = pci_read_config(child, rid, 4);
 754                 rom_reg &= ~CARDBUS_ROM_ENABLE;
 755                 pci_write_config(child, rid, rom_reg, 4);
 756         }
 757
 758         rle = resource_list_find(&dinfo->pci.resources, type, rid);
 759
 760         if (!rle) {
 761                 device_printf(cbdev, "Allocated resource not found\n");
 762                 return ENOENT;
 763         }
 764         if (!rle->res) {
 765                 device_printf(cbdev, "Allocated resource not recorded\n");
 766                 return ENOENT;
 767         }
 768
 769         ret = BUS_RELEASE_RESOURCE(device_get_parent(cbdev), child,
 770             type, rid, r);
 771         switch (type) {
 772         case SYS_RES_IOPORT:
 773         case SYS_RES_MEMORY:
 774                 flags = rman_make_alignment_flags(rle->count);
 775                 break;
 776         case SYS_RES_IRQ:
 777                 flags = RF_SHAREABLE;
 778                 break;
 779         default:
 780                 flags = 0;
 781         }
 782         /* Restore cardbus hold on the resource */
 783         rle->res = bus_alloc_resource(cbdev, type, &rid,
 784             rle->start, rle->end, rle->count, flags);
 785         if (rle->res == NULL)
 786                 device_printf(cbdev, "release_resource: "
 787                     "unable to reacquire resource\n");
 788         return ret;
 789 }
 790
 791 static int
 792 cardbus_setup_intr(device_t cbdev, device_t child, struct resource *irq,
 793     int flags, driver_intr_t *intr, void *arg, void **cookiep)
 794 {
 795         int ret;
 796         device_t cdev;
 797         struct cardbus_devinfo *dinfo;
 798
 799         ret = bus_generic_setup_intr(cbdev, child, irq, flags, intr, arg,
 800             cookiep);
 801         if (ret != 0)
 802                 return ret;
 803
 804         for (cdev = child; cbdev != device_get_parent(cdev);
 805             cdev = device_get_parent(cdev))
 806                 /* NOTHING */;
 807         dinfo = device_get_ivars(cdev);
 808
 809         return 0;
 810 }
 811
 812 static int
 813 cardbus_teardown_intr(device_t cbdev, device_t child, struct resource *irq,
 814     void *cookie)
 815 {
 816         int ret;
 817         device_t cdev;
 818         struct cardbus_devinfo *dinfo;
 819
 820         ret = bus_generic_teardown_intr(cbdev, child, irq, cookie);
 821         if (ret != 0)
 822                 return ret;
 823
 824         for (cdev = child; cbdev != device_get_parent(cdev);
 825             cdev = device_get_parent(cdev))
 826                 /* NOTHING */;
 827         dinfo = device_get_ivars(cdev);
 828
 829         return (0);
 830 }
 831
 832
 833 /************************************************************************/
 834 /* Other Bus Methods                                                    */
 835 /************************************************************************/
 836
 837 static int
 838 cardbus_print_resources(struct resource_list *rl, const char *name,
 839     int type, const char *format)
 840 {
 841         struct resource_list_entry *rle;
 842         int printed, retval;
 843
 844         printed = 0;
 845         retval = 0;
 846         /* Yes, this is kinda cheating */
 847         SLIST_FOREACH(rle, rl, link) {
 848                 if (rle->type == type) {
 849                         if (printed == 0)
 850                                 retval += printf(" %s ", name);
 851                         else if (printed > 0)
 852                                 retval += printf(",");
 853                         printed++;
 854                         retval += printf(format, rle->start);
 855                         if (rle->count > 1) {
 856                                 retval += printf("-");
 857                                 retval += printf(format, rle->start +
 858                                     rle->count - 1);
 859                         }
 860                 }
 861         }
 862         return retval;
 863 }
 864
 865 static int
 866 cardbus_print_child(device_t cbdev, device_t child)
 867 {
 868         struct cardbus_devinfo *dinfo;
 869         struct resource_list *rl;
 870         pcicfgregs *cfg;
 871         int retval = 0;
 872
 873         dinfo = device_get_ivars(child);
 874         cfg = &dinfo->pci.cfg;
 875         rl = &dinfo->pci.resources;
 876
 877         retval += bus_print_child_header(cbdev, child);
 878
 879         retval += cardbus_print_resources(rl, "port", SYS_RES_IOPORT, "%#lx");
 880         retval += cardbus_print_resources(rl, "mem", SYS_RES_MEMORY, "%#lx");
 881         retval += cardbus_print_resources(rl, "irq", SYS_RES_IRQ, "%ld");
 882         if (device_get_flags(cbdev))
 883                 retval += printf(" flags %#x", device_get_flags(cbdev));
 884
 885         retval += printf(" at device %d.%d", pci_get_slot(child),
 886             pci_get_function(child));
 887
 888         retval += bus_print_child_footer(cbdev, child);
 889
 890         return (retval);
 891 }
 892
 893 static void
 894 cardbus_probe_nomatch(device_t cbdev, device_t child)
 895 {
 896         struct cardbus_devinfo *dinfo;
 897         pcicfgregs *cfg;
 898
 899         dinfo = device_get_ivars(child);
 900         cfg = &dinfo->pci.cfg;
 901         device_printf(cbdev, "<unknown card>");
 902         printf(" (vendor=0x%04x, dev=0x%04x)", cfg->vendor, cfg->device);
 903         printf(" at %d.%d", pci_get_slot(child), pci_get_function(child));
 904         if (cfg->intpin > 0 && cfg->intline != 255) {
 905                 printf(" irq %d", cfg->intline);
 906         }
 907         printf("\n");
 908
 909         return;
 910 }
 911
 912 static int
 913 cardbus_child_location_str(device_t cbdev, device_t child, char *buf,
 914     size_t buflen)
 915 {
 916         struct cardbus_devinfo *dinfo;
 917         pcicfgregs *cfg;
 918
 919         dinfo = device_get_ivars(child);
 920         cfg = &dinfo->pci.cfg;
 921         snprintf(buf, buflen, "slot=%d function=%d", pci_get_slot(child),
 922             pci_get_function(child));
 923         return (0);
 924 }
 925
 926 static int
 927 cardbus_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
 928     size_t buflen)
 929 {
 930         struct cardbus_devinfo *dinfo;
 931         pcicfgregs *cfg;
 932
 933         dinfo = device_get_ivars(child);
 934         cfg = &dinfo->pci.cfg;
 935         snprintf(buf, buflen, "vendor=0x%04x device=0x%04x subvendor=0x%04x "
 936             "subdevice=0x%04x", cfg->vendor, cfg->device, cfg->subvendor,
 937             cfg->subdevice);
 938         return (0);
 939 }
 940
 941 static int
 942 cardbus_read_ivar(device_t cbdev, device_t child, int which, u_long *result)
 943 {
 944         struct cardbus_devinfo *dinfo;
 945         pcicfgregs *cfg;
 946
 947         dinfo = device_get_ivars(child);
 948         cfg = &dinfo->pci.cfg;
 949
 950         switch (which) {
 951         case PCI_IVAR_ETHADDR:
 952                 /*
 953                  * The generic accessor doesn't deal with failure, so
 954                  * we set the return value, then return an error.
 955                  */
 956                 if ((dinfo->fepresent & (1 << TPL_FUNCE_LAN_NID)) == 0) {
 957                         *((u_int8_t **) result) = NULL;
 958                         return (EINVAL);
 959                 }
 960                 *((u_int8_t **) result) = dinfo->funce.lan.nid;
 961                 break;
 962         case PCI_IVAR_SUBVENDOR:
 963                 *result = cfg->subvendor;
 964                 break;
 965         case PCI_IVAR_SUBDEVICE:
 966                 *result = cfg->subdevice;
 967                 break;
 968         case PCI_IVAR_VENDOR:
 969                 *result = cfg->vendor;
 970                 break;
 971         case PCI_IVAR_DEVICE:
 972                 *result = cfg->device;
 973                 break;
 974         case PCI_IVAR_DEVID:
 975                 *result = (cfg->device << 16) | cfg->vendor;
 976                 break;
 977         case PCI_IVAR_CLASS:
 978                 *result = cfg->baseclass;
 979                 break;
 980         case PCI_IVAR_SUBCLASS:
 981                 *result = cfg->subclass;
 982                 break;
 983         case PCI_IVAR_PROGIF:
 984                 *result = cfg->progif;
 985                 break;
 986         case PCI_IVAR_REVID:
 987                 *result = cfg->revid;
 988                 break;
 989         case PCI_IVAR_INTPIN:
 990                 *result = cfg->intpin;
 991                 break;
 992         case PCI_IVAR_IRQ:
 993                 *result = cfg->intline;
 994                 break;
 995         case PCI_IVAR_BUS:
 996                 *result = cfg->bus;
 997                 break;
 998         case PCI_IVAR_SLOT:
 999                 *result = cfg->slot;
1000                 break;
1001         case PCI_IVAR_FUNCTION:
1002                 *result = cfg->func;
1003                 break;
1004         default:
1005                 return ENOENT;
1006         }
1007         return 0;
1008 }
1009
1010 static int
1011 cardbus_write_ivar(device_t cbdev, device_t child, int which, uintptr_t value)
1012 {
1013         struct cardbus_devinfo *dinfo;
1014         pcicfgregs *cfg;
1015
1016         dinfo = device_get_ivars(child);
1017         cfg = &dinfo->pci.cfg;
1018
1019         switch (which) {
1020         case PCI_IVAR_ETHADDR:
1021         case PCI_IVAR_SUBVENDOR:
1022         case PCI_IVAR_SUBDEVICE:
1023         case PCI_IVAR_VENDOR:
1024         case PCI_IVAR_DEVICE:
1025         case PCI_IVAR_DEVID:
1026         case PCI_IVAR_CLASS:
1027         case PCI_IVAR_SUBCLASS:
1028         case PCI_IVAR_PROGIF:
1029         case PCI_IVAR_REVID:
1030         case PCI_IVAR_INTPIN:
1031         case PCI_IVAR_IRQ:
1032         case PCI_IVAR_BUS:
1033         case PCI_IVAR_SLOT:
1034         case PCI_IVAR_FUNCTION:
1035                 return EINVAL;  /* disallow for now */
1036         default:
1037                 return ENOENT;
1038         }
1039         return 0;
1040 }
1041
1042 /************************************************************************/
1043 /* Compatibility with PCI bus (XXX: Do we need this?)                   */
1044 /************************************************************************/
1045
1046 /*
1047  * PCI power manangement
1048  */
1049 static int
1050 cardbus_set_powerstate_method(device_t cbdev, device_t child, int state)
1051 {
1052         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1053         pcicfgregs *cfg = &dinfo->pci.cfg;
1054         u_int16_t status;
1055         int result;
1056
1057         if (cfg->pp_cap != 0) {
1058                 status = PCI_READ_CONFIG(cbdev, child, cfg->pp_status, 2)
1059                     & ~PCIM_PSTAT_DMASK;
1060                 result = 0;
1061                 switch (state) {
1062                 case PCI_POWERSTATE_D0:
1063                         status |= PCIM_PSTAT_D0;
1064                         break;
1065                 case PCI_POWERSTATE_D1:
1066                         if (cfg->pp_cap & PCIM_PCAP_D1SUPP) {
1067                                 status |= PCIM_PSTAT_D1;
1068                         } else {
1069                                 result = EOPNOTSUPP;
1070                         }
1071                         break;
1072                 case PCI_POWERSTATE_D2:
1073                         if (cfg->pp_cap & PCIM_PCAP_D2SUPP) {
1074                                 status |= PCIM_PSTAT_D2;
1075                         } else {
1076                                 result = EOPNOTSUPP;
1077                         }
1078                         break;
1079                 case PCI_POWERSTATE_D3:
1080                         status |= PCIM_PSTAT_D3;
1081                         break;
1082                 default:
1083                         result = EINVAL;
1084                 }
1085                 if (result == 0)
1086                         PCI_WRITE_CONFIG(cbdev, child, cfg->pp_status,
1087                             status, 2);
1088         } else {
1089                 result = ENXIO;
1090         }
1091         return (result);
1092 }
1093
1094 static int
1095 cardbus_get_powerstate_method(device_t cbdev, device_t child)
1096 {
1097         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1098         pcicfgregs *cfg = &dinfo->pci.cfg;
1099         u_int16_t status;
1100         int result;
1101
1102         if (cfg->pp_cap != 0) {
1103                 status = PCI_READ_CONFIG(cbdev, child, cfg->pp_status, 2);
1104                 switch (status & PCIM_PSTAT_DMASK) {
1105                 case PCIM_PSTAT_D0:
1106                         result = PCI_POWERSTATE_D0;
1107                         break;
1108                 case PCIM_PSTAT_D1:
1109                         result = PCI_POWERSTATE_D1;
1110                         break;
1111                 case PCIM_PSTAT_D2:
1112                         result = PCI_POWERSTATE_D2;
1113                         break;
1114                 case PCIM_PSTAT_D3:
1115                         result = PCI_POWERSTATE_D3;
1116                         break;
1117                 default:
1118                         result = PCI_POWERSTATE_UNKNOWN;
1119                         break;
1120                 }
1121         } else {
1122                 /* No support, device is always at D0 */
1123                 result = PCI_POWERSTATE_D0;
1124         }
1125         return (result);
1126 }
1127
1128 static u_int32_t
1129 cardbus_read_config_method(device_t cbdev, device_t child, int reg, int width)
1130 {
1131         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1132         pcicfgregs *cfg = &dinfo->pci.cfg;
1133
1134         return PCIB_READ_CONFIG(device_get_parent(cbdev),
1135             cfg->bus, cfg->slot, cfg->func, reg, width);
1136 }
1137
1138 static void
1139 cardbus_write_config_method(device_t cbdev, device_t child, int reg,
1140     u_int32_t val, int width)
1141 {
1142         struct cardbus_devinfo *dinfo = device_get_ivars(child);
1143         pcicfgregs *cfg = &dinfo->pci.cfg;
1144
1145         PCIB_WRITE_CONFIG(device_get_parent(cbdev),
1146             cfg->bus, cfg->slot, cfg->func, reg, val, width);
1147 }
1148
1149 static __inline void
1150 cardbus_set_command_bit(device_t cbdev, device_t child, u_int16_t bit)
1151 {
1152         u_int16_t command;
1153
1154         command = PCI_READ_CONFIG(cbdev, child, PCIR_COMMAND, 2);
1155         command |= bit;
1156         PCI_WRITE_CONFIG(cbdev, child, PCIR_COMMAND, command, 2);
1157 }
1158
1159 static __inline void
1160 cardbus_clear_command_bit(device_t cbdev, device_t child, u_int16_t bit)
1161 {
1162         u_int16_t command;
1163
1164         command = PCI_READ_CONFIG(cbdev, child, PCIR_COMMAND, 2);
1165         command &= ~bit;
1166         PCI_WRITE_CONFIG(cbdev, child, PCIR_COMMAND, command, 2);
1167 }
1168
1169 static void
1170 cardbus_enable_busmaster_method(device_t cbdev, device_t child)
1171 {
1172         cardbus_set_command_bit(cbdev, child, PCIM_CMD_BUSMASTEREN);
1173 }
1174
1175 static void
1176 cardbus_disable_busmaster_method(device_t cbdev, device_t child)
1177 {
1178         cardbus_clear_command_bit(cbdev, child, PCIM_CMD_BUSMASTEREN);
1179 }
1180
1181 static void
1182 cardbus_enable_io_method(device_t cbdev, device_t child, int space)
1183 {
1184         switch (space) {
1185         case SYS_RES_IOPORT:
1186                 cardbus_set_command_bit(cbdev, child, PCIM_CMD_PORTEN);
1187                 break;
1188         case SYS_RES_MEMORY:
1189                 cardbus_set_command_bit(cbdev, child, PCIM_CMD_MEMEN);
1190                 break;
1191         }
1192 }
1193
1194 static void
1195 cardbus_disable_io_method(device_t cbdev, device_t child, int space)
1196 {
1197         switch (space) {
1198         case SYS_RES_IOPORT:
1199                 cardbus_clear_command_bit(cbdev, child, PCIM_CMD_PORTEN);
1200                 break;
1201         case SYS_RES_MEMORY:
1202                 cardbus_clear_command_bit(cbdev, child, PCIM_CMD_MEMEN);
1203                 break;
1204         }
1205 }
1206
1207 static device_method_t cardbus_methods[] = {
1208         /* Device interface */
1209         DEVMETHOD(device_probe,         cardbus_probe),
1210         DEVMETHOD(device_attach,        cardbus_attach),
1211         DEVMETHOD(device_detach,        cardbus_detach),
1212         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
1213         DEVMETHOD(device_suspend,       cardbus_suspend),
1214         DEVMETHOD(device_resume,        cardbus_resume),
1215
1216         /* Bus interface */
1217         DEVMETHOD(bus_print_child,      cardbus_print_child),
1218         DEVMETHOD(bus_probe_nomatch,    cardbus_probe_nomatch),
1219         DEVMETHOD(bus_read_ivar,        cardbus_read_ivar),
1220         DEVMETHOD(bus_write_ivar,       cardbus_write_ivar),
1221         DEVMETHOD(bus_driver_added,     cardbus_driver_added),
1222         DEVMETHOD(bus_alloc_resource,   cardbus_alloc_resource),
1223         DEVMETHOD(bus_release_resource, cardbus_release_resource),
1224         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1225         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1226         DEVMETHOD(bus_setup_intr,       cardbus_setup_intr),
1227         DEVMETHOD(bus_teardown_intr,    cardbus_teardown_intr),
1228
1229         DEVMETHOD(bus_set_resource,     cardbus_set_resource_method),
1230         DEVMETHOD(bus_get_resource,     cardbus_get_resource_method),
1231         DEVMETHOD(bus_delete_resource,  cardbus_delete_resource_method),
1232         DEVMETHOD(bus_child_pnpinfo_str, cardbus_child_pnpinfo_str),
1233         DEVMETHOD(bus_child_location_str, cardbus_child_location_str),
1234
1235         /* Card Interface */
1236         DEVMETHOD(card_attach_card,     cardbus_attach_card),
1237         DEVMETHOD(card_detach_card,     cardbus_detach_card),
1238         DEVMETHOD(card_cis_read,        cardbus_cis_read),
1239         DEVMETHOD(card_cis_free,        cardbus_cis_free),
1240
1241         /* Cardbus/PCI interface */
1242         DEVMETHOD(pci_read_config,      cardbus_read_config_method),
1243         DEVMETHOD(pci_write_config,     cardbus_write_config_method),
1244         DEVMETHOD(pci_enable_busmaster, cardbus_enable_busmaster_method),
1245         DEVMETHOD(pci_disable_busmaster, cardbus_disable_busmaster_method),
1246         DEVMETHOD(pci_enable_io,        cardbus_enable_io_method),
1247         DEVMETHOD(pci_disable_io,       cardbus_disable_io_method),
1248         DEVMETHOD(pci_get_powerstate,   cardbus_get_powerstate_method),
1249         DEVMETHOD(pci_set_powerstate,   cardbus_set_powerstate_method),
1250
1251         {0,0}
1252 };
1253
1254 static driver_t cardbus_driver = {
1255         "cardbus",
1256         cardbus_methods,
1257         0 /* no softc */
1258 };
1259
1260 static devclass_t cardbus_devclass;
1261
1262 DRIVER_MODULE(cardbus, cbb, cardbus_driver, cardbus_devclass, 0, 0);
1263 MODULE_VERSION(cardbus, 1);
1264 MODULE_DEPEND(cardbus, exca, 1, 1, 1);
1265 /*
1266 MODULE_DEPEND(cardbus, pccbb, 1, 1, 1);
1267 */