1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2002-2004 M. Warner Losh. 5 * Copyright (c) 2000-2001 Jonathan Chen. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 */ 30 31 /*- 32 * Copyright (c) 1998, 1999 and 2000 33 * HAYAKAWA Koichi. All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 3. All advertising materials mentioning features or use of this software 44 * must display the following acknowledgement: 45 * This product includes software developed by HAYAKAWA Koichi. 46 * 4. The name of the author may not be used to endorse or promote products 47 * derived from this software without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 50 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 51 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 52 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 53 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 54 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 55 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 56 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 57 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 58 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 59 */ 60 61 /* 62 * Driver for PCI to CardBus Bridge chips 63 * and PCI to PCMCIA Bridge chips 64 * and ISA to PCMCIA host adapters 65 * and C Bus to PCMCIA host adapters 66 * 67 * References: 68 * TI Datasheets: 69 * http://www-s.ti.com/cgi-bin/sc/generic2.cgi?family=PCI+CARDBUS+CONTROLLERS 70 * 71 * Written by Jonathan Chen <jon@freebsd.org> 72 * The author would like to acknowledge: 73 * * HAYAKAWA Koichi: Author of the NetBSD code for the same thing 74 * * Warner Losh: Newbus/newcard guru and author of the pccard side of things 75 * * YAMAMOTO Shigeru: Author of another FreeBSD cardbus driver 76 * * David Cross: Author of the initial ugly hack for a specific cardbus card 77 */ 78 79 #include <sys/cdefs.h> 80 __FBSDID("$FreeBSD$"); 81 82 #include <sys/param.h> 83 #include <sys/bus.h> 84 #include <sys/condvar.h> 85 #include <sys/errno.h> 86 #include <sys/kernel.h> 87 #include <sys/module.h> 88 #include <sys/kthread.h> 89 #include <sys/interrupt.h> 90 #include <sys/lock.h> 91 #include <sys/malloc.h> 92 #include <sys/mutex.h> 93 #include <sys/proc.h> 94 #include <sys/rman.h> 95 #include <sys/sysctl.h> 96 #include <sys/systm.h> 97 #include <machine/bus.h> 98 #include <machine/resource.h> 99 100 #include <dev/pci/pcireg.h> 101 #include <dev/pci/pcivar.h> 102 #include <dev/pci/pcib_private.h> 103 104 #include <dev/pccard/pccardreg.h> 105 #include <dev/pccard/pccardvar.h> 106 107 #include <dev/exca/excareg.h> 108 #include <dev/exca/excavar.h> 109 110 #include <dev/pccbb/pccbbreg.h> 111 #include <dev/pccbb/pccbbvar.h> 112 113 #include "power_if.h" 114 #include "card_if.h" 115 #include "pcib_if.h" 116 117 #define DPRINTF(x) do { if (cbb_debug) printf x; } while (0) 118 #define DEVPRINTF(x) do { if (cbb_debug) device_printf x; } while (0) 119 120 #define PCI_MASK_CONFIG(DEV,REG,MASK,SIZE) \ 121 pci_write_config(DEV, REG, pci_read_config(DEV, REG, SIZE) MASK, SIZE) 122 #define PCI_MASK2_CONFIG(DEV,REG,MASK1,MASK2,SIZE) \ 123 pci_write_config(DEV, REG, ( \ 124 pci_read_config(DEV, REG, SIZE) MASK1) MASK2, SIZE) 125 126 #define CBB_CARD_PRESENT(s) ((s & CBB_STATE_CD) == 0) 127 128 #define CBB_START_MEM 0x88000000 129 #define CBB_START_32_IO 0x1000 130 #define CBB_START_16_IO 0x100 131 132 devclass_t cbb_devclass; 133 134 /* sysctl vars */ 135 static SYSCTL_NODE(_hw, OID_AUTO, cbb, CTLFLAG_RD, 0, "CBB parameters"); 136 137 /* There's no way to say TUNEABLE_LONG to get the right types */ 138 u_long cbb_start_mem = CBB_START_MEM; 139 SYSCTL_ULONG(_hw_cbb, OID_AUTO, start_memory, CTLFLAG_RWTUN, 140 &cbb_start_mem, CBB_START_MEM, 141 "Starting address for memory allocations"); 142 143 u_long cbb_start_16_io = CBB_START_16_IO; 144 SYSCTL_ULONG(_hw_cbb, OID_AUTO, start_16_io, CTLFLAG_RWTUN, 145 &cbb_start_16_io, CBB_START_16_IO, 146 "Starting ioport for 16-bit cards"); 147 148 u_long cbb_start_32_io = CBB_START_32_IO; 149 SYSCTL_ULONG(_hw_cbb, OID_AUTO, start_32_io, CTLFLAG_RWTUN, 150 &cbb_start_32_io, CBB_START_32_IO, 151 "Starting ioport for 32-bit cards"); 152 153 int cbb_debug = 0; 154 SYSCTL_INT(_hw_cbb, OID_AUTO, debug, CTLFLAG_RWTUN, &cbb_debug, 0, 155 "Verbose cardbus bridge debugging"); 156 157 static void cbb_insert(struct cbb_softc *sc); 158 static void cbb_removal(struct cbb_softc *sc); 159 static uint32_t cbb_detect_voltage(device_t brdev); 160 static int cbb_cardbus_reset_power(device_t brdev, device_t child, int on); 161 static int cbb_cardbus_io_open(device_t brdev, int win, uint32_t start, 162 uint32_t end); 163 static int cbb_cardbus_mem_open(device_t brdev, int win, 164 uint32_t start, uint32_t end); 165 static void cbb_cardbus_auto_open(struct cbb_softc *sc, int type); 166 static int cbb_cardbus_activate_resource(device_t brdev, device_t child, 167 int type, int rid, struct resource *res); 168 static int cbb_cardbus_deactivate_resource(device_t brdev, 169 device_t child, int type, int rid, struct resource *res); 170 static struct resource *cbb_cardbus_alloc_resource(device_t brdev, 171 device_t child, int type, int *rid, rman_res_t start, 172 rman_res_t end, rman_res_t count, u_int flags); 173 static int cbb_cardbus_release_resource(device_t brdev, device_t child, 174 int type, int rid, struct resource *res); 175 static int cbb_cardbus_power_enable_socket(device_t brdev, 176 device_t child); 177 static int cbb_cardbus_power_disable_socket(device_t brdev, 178 device_t child); 179 static int cbb_func_filt(void *arg); 180 static void cbb_func_intr(void *arg); 181 182 static void 183 cbb_remove_res(struct cbb_softc *sc, struct resource *res) 184 { 185 struct cbb_reslist *rle; 186 187 SLIST_FOREACH(rle, &sc->rl, link) { 188 if (rle->res == res) { 189 SLIST_REMOVE(&sc->rl, rle, cbb_reslist, link); 190 free(rle, M_DEVBUF); 191 return; 192 } 193 } 194 } 195 196 static struct resource * 197 cbb_find_res(struct cbb_softc *sc, int type, int rid) 198 { 199 struct cbb_reslist *rle; 200 201 SLIST_FOREACH(rle, &sc->rl, link) 202 if (SYS_RES_MEMORY == rle->type && rid == rle->rid) 203 return (rle->res); 204 return (NULL); 205 } 206 207 static void 208 cbb_insert_res(struct cbb_softc *sc, struct resource *res, int type, 209 int rid) 210 { 211 struct cbb_reslist *rle; 212 213 /* 214 * Need to record allocated resource so we can iterate through 215 * it later. 216 */ 217 rle = malloc(sizeof(struct cbb_reslist), M_DEVBUF, M_NOWAIT); 218 if (rle == NULL) 219 panic("cbb_cardbus_alloc_resource: can't record entry!"); 220 rle->res = res; 221 rle->type = type; 222 rle->rid = rid; 223 SLIST_INSERT_HEAD(&sc->rl, rle, link); 224 } 225 226 static void 227 cbb_destroy_res(struct cbb_softc *sc) 228 { 229 struct cbb_reslist *rle; 230 231 while ((rle = SLIST_FIRST(&sc->rl)) != NULL) { 232 device_printf(sc->dev, "Danger Will Robinson: Resource " 233 "left allocated! This is a bug... " 234 "(rid=%x, type=%d, addr=%jx)\n", rle->rid, rle->type, 235 rman_get_start(rle->res)); 236 SLIST_REMOVE_HEAD(&sc->rl, link); 237 free(rle, M_DEVBUF); 238 } 239 } 240 241 /* 242 * Disable function interrupts by telling the bridge to generate IRQ1 243 * interrupts. These interrupts aren't really generated by the chip, since 244 * IRQ1 is reserved. Some chipsets assert INTA# inappropriately during 245 * initialization, so this helps to work around the problem. 246 * 247 * XXX We can't do this workaround for all chipsets, because this 248 * XXX causes interference with the keyboard because somechipsets will 249 * XXX actually signal IRQ1 over their serial interrupt connections to 250 * XXX the south bridge. Disable it it for now. 251 */ 252 void 253 cbb_disable_func_intr(struct cbb_softc *sc) 254 { 255 #if 0 256 uint8_t reg; 257 258 reg = (exca_getb(&sc->exca[0], EXCA_INTR) & ~EXCA_INTR_IRQ_MASK) | 259 EXCA_INTR_IRQ_RESERVED1; 260 exca_putb(&sc->exca[0], EXCA_INTR, reg); 261 #endif 262 } 263 264 /* 265 * Enable function interrupts. We turn on function interrupts when the card 266 * requests an interrupt. The PCMCIA standard says that we should set 267 * the lower 4 bits to 0 to route via PCI. Note: we call this for both 268 * CardBus and R2 (PC Card) cases, but it should have no effect on CardBus 269 * cards. 270 */ 271 static void 272 cbb_enable_func_intr(struct cbb_softc *sc) 273 { 274 uint8_t reg; 275 276 reg = (exca_getb(&sc->exca[0], EXCA_INTR) & ~EXCA_INTR_IRQ_MASK) | 277 EXCA_INTR_IRQ_NONE; 278 exca_putb(&sc->exca[0], EXCA_INTR, reg); 279 } 280 281 int 282 cbb_detach(device_t brdev) 283 { 284 struct cbb_softc *sc = device_get_softc(brdev); 285 device_t *devlist; 286 int tmp, tries, error, numdevs; 287 288 /* 289 * Before we delete the children (which we have to do because 290 * attach doesn't check for children busses correctly), we have 291 * to detach the children. Even if we didn't need to delete the 292 * children, we have to detach them. 293 */ 294 error = bus_generic_detach(brdev); 295 if (error != 0) 296 return (error); 297 298 /* 299 * Since the attach routine doesn't search for children before it 300 * attaches them to this device, we must delete them here in order 301 * for the kldload/unload case to work. If we failed to do that, then 302 * we'd get duplicate devices when cbb.ko was reloaded. 303 */ 304 tries = 10; 305 do { 306 error = device_get_children(brdev, &devlist, &numdevs); 307 if (error == 0) 308 break; 309 /* 310 * Try hard to cope with low memory. 311 */ 312 if (error == ENOMEM) { 313 pause("cbbnomem", 1); 314 continue; 315 } 316 } while (tries-- > 0); 317 for (tmp = 0; tmp < numdevs; tmp++) 318 device_delete_child(brdev, devlist[tmp]); 319 free(devlist, M_TEMP); 320 321 /* Turn off the interrupts */ 322 cbb_set(sc, CBB_SOCKET_MASK, 0); 323 324 /* reset 16-bit pcmcia bus */ 325 exca_clrb(&sc->exca[0], EXCA_INTR, EXCA_INTR_RESET); 326 327 /* turn off power */ 328 cbb_power(brdev, CARD_OFF); 329 330 /* Ack the interrupt */ 331 cbb_set(sc, CBB_SOCKET_EVENT, 0xffffffff); 332 333 /* 334 * Wait for the thread to die. kproc_exit will do a wakeup 335 * on the event thread's struct proc * so that we know it is 336 * safe to proceed. IF the thread is running, set the please 337 * die flag and wait for it to comply. Since the wakeup on 338 * the event thread happens only in kproc_exit, we don't 339 * need to loop here. 340 */ 341 bus_teardown_intr(brdev, sc->irq_res, sc->intrhand); 342 mtx_lock(&sc->mtx); 343 sc->flags |= CBB_KTHREAD_DONE; 344 while (sc->flags & CBB_KTHREAD_RUNNING) { 345 DEVPRINTF((sc->dev, "Waiting for thread to die\n")); 346 wakeup(&sc->intrhand); 347 msleep(sc->event_thread, &sc->mtx, PWAIT, "cbbun", 0); 348 } 349 mtx_unlock(&sc->mtx); 350 351 bus_release_resource(brdev, SYS_RES_IRQ, 0, sc->irq_res); 352 bus_release_resource(brdev, SYS_RES_MEMORY, CBBR_SOCKBASE, 353 sc->base_res); 354 mtx_destroy(&sc->mtx); 355 return (0); 356 } 357 358 int 359 cbb_setup_intr(device_t dev, device_t child, struct resource *irq, 360 int flags, driver_filter_t *filt, driver_intr_t *intr, void *arg, 361 void **cookiep) 362 { 363 struct cbb_intrhand *ih; 364 struct cbb_softc *sc = device_get_softc(dev); 365 int err; 366 367 if (filt == NULL && intr == NULL) 368 return (EINVAL); 369 ih = malloc(sizeof(struct cbb_intrhand), M_DEVBUF, M_NOWAIT); 370 if (ih == NULL) 371 return (ENOMEM); 372 *cookiep = ih; 373 ih->filt = filt; 374 ih->intr = intr; 375 ih->arg = arg; 376 ih->sc = sc; 377 /* 378 * XXX need to turn on ISA interrupts, if we ever support them, but 379 * XXX for now that's all we need to do. 380 */ 381 err = BUS_SETUP_INTR(device_get_parent(dev), child, irq, flags, 382 filt ? cbb_func_filt : NULL, intr ? cbb_func_intr : NULL, ih, 383 &ih->cookie); 384 if (err != 0) { 385 free(ih, M_DEVBUF); 386 return (err); 387 } 388 cbb_enable_func_intr(sc); 389 sc->cardok = 1; 390 return 0; 391 } 392 393 int 394 cbb_teardown_intr(device_t dev, device_t child, struct resource *irq, 395 void *cookie) 396 { 397 struct cbb_intrhand *ih; 398 int err; 399 400 /* XXX Need to do different things for ISA interrupts. */ 401 ih = (struct cbb_intrhand *) cookie; 402 err = BUS_TEARDOWN_INTR(device_get_parent(dev), child, irq, 403 ih->cookie); 404 if (err != 0) 405 return (err); 406 free(ih, M_DEVBUF); 407 return (0); 408 } 409 410 411 void 412 cbb_driver_added(device_t brdev, driver_t *driver) 413 { 414 struct cbb_softc *sc = device_get_softc(brdev); 415 device_t *devlist; 416 device_t dev; 417 int tmp; 418 int numdevs; 419 int wake = 0; 420 421 DEVICE_IDENTIFY(driver, brdev); 422 tmp = device_get_children(brdev, &devlist, &numdevs); 423 if (tmp != 0) { 424 device_printf(brdev, "Cannot get children list, no reprobe\n"); 425 return; 426 } 427 for (tmp = 0; tmp < numdevs; tmp++) { 428 dev = devlist[tmp]; 429 if (device_get_state(dev) == DS_NOTPRESENT && 430 device_probe_and_attach(dev) == 0) 431 wake++; 432 } 433 free(devlist, M_TEMP); 434 435 if (wake > 0) 436 wakeup(&sc->intrhand); 437 } 438 439 void 440 cbb_child_detached(device_t brdev, device_t child) 441 { 442 struct cbb_softc *sc = device_get_softc(brdev); 443 444 /* I'm not sure we even need this */ 445 if (child != sc->cbdev && child != sc->exca[0].pccarddev) 446 device_printf(brdev, "Unknown child detached: %s\n", 447 device_get_nameunit(child)); 448 } 449 450 /************************************************************************/ 451 /* Kthreads */ 452 /************************************************************************/ 453 454 void 455 cbb_event_thread(void *arg) 456 { 457 struct cbb_softc *sc = arg; 458 uint32_t status; 459 int err; 460 int not_a_card = 0; 461 462 /* 463 * We need to act as a power sequencer on startup. Delay 2s/channel 464 * to ensure the other channels have had a chance to come up. We likely 465 * should add a lock that's shared on a per-slot basis so that only 466 * one power event can happen per slot at a time. 467 */ 468 pause("cbbstart", hz * device_get_unit(sc->dev) * 2); 469 mtx_lock(&sc->mtx); 470 sc->flags |= CBB_KTHREAD_RUNNING; 471 while ((sc->flags & CBB_KTHREAD_DONE) == 0) { 472 mtx_unlock(&sc->mtx); 473 status = cbb_get(sc, CBB_SOCKET_STATE); 474 DPRINTF(("Status is 0x%x\n", status)); 475 if (!CBB_CARD_PRESENT(status)) { 476 not_a_card = 0; /* We know card type */ 477 cbb_removal(sc); 478 } else if (status & CBB_STATE_NOT_A_CARD) { 479 /* 480 * Up to 10 times, try to rescan the card when we see 481 * NOT_A_CARD. 10 is somehwat arbitrary. When this 482 * pathology hits, there's a ~40% chance each try will 483 * fail. 10 tries takes about 5s and results in a 484 * 99.99% certainty of the results. 485 */ 486 if (not_a_card++ < 10) { 487 DEVPRINTF((sc->dev, 488 "Not a card bit set, rescanning\n")); 489 cbb_setb(sc, CBB_SOCKET_FORCE, CBB_FORCE_CV_TEST); 490 } else { 491 device_printf(sc->dev, 492 "Can't determine card type\n"); 493 } 494 } else { 495 not_a_card = 0; /* We know card type */ 496 cbb_insert(sc); 497 } 498 499 /* 500 * First time through we need to tell mountroot that we're 501 * done. 502 */ 503 if (sc->sc_root_token) { 504 root_mount_rel(sc->sc_root_token); 505 sc->sc_root_token = NULL; 506 } 507 508 /* 509 * Wait until it has been 250ms since the last time we 510 * get an interrupt. We handle the rest of the interrupt 511 * at the top of the loop. Although we clear the bit in the 512 * ISR, we signal sc->cv from the detach path after we've 513 * set the CBB_KTHREAD_DONE bit, so we can't do a simple 514 * 250ms sleep here. 515 * 516 * In our ISR, we turn off the card changed interrupt. Turn 517 * them back on here before we wait for them to happen. We 518 * turn them on/off so that we can tolerate a large latency 519 * between the time we signal cbb_event_thread and it gets 520 * a chance to run. 521 */ 522 mtx_lock(&sc->mtx); 523 cbb_setb(sc, CBB_SOCKET_MASK, CBB_SOCKET_MASK_CD | CBB_SOCKET_MASK_CSTS); 524 msleep(&sc->intrhand, &sc->mtx, 0, "-", 0); 525 err = 0; 526 while (err != EWOULDBLOCK && 527 (sc->flags & CBB_KTHREAD_DONE) == 0) 528 err = msleep(&sc->intrhand, &sc->mtx, 0, "-", hz / 5); 529 } 530 DEVPRINTF((sc->dev, "Thread terminating\n")); 531 sc->flags &= ~CBB_KTHREAD_RUNNING; 532 mtx_unlock(&sc->mtx); 533 kproc_exit(0); 534 } 535 536 /************************************************************************/ 537 /* Insert/removal */ 538 /************************************************************************/ 539 540 static void 541 cbb_insert(struct cbb_softc *sc) 542 { 543 uint32_t sockevent, sockstate; 544 545 sockevent = cbb_get(sc, CBB_SOCKET_EVENT); 546 sockstate = cbb_get(sc, CBB_SOCKET_STATE); 547 548 DEVPRINTF((sc->dev, "card inserted: event=0x%08x, state=%08x\n", 549 sockevent, sockstate)); 550 551 if (sockstate & CBB_STATE_R2_CARD) { 552 if (device_is_attached(sc->exca[0].pccarddev)) { 553 sc->flags |= CBB_16BIT_CARD; 554 exca_insert(&sc->exca[0]); 555 } else { 556 device_printf(sc->dev, 557 "16-bit card inserted, but no pccard bus.\n"); 558 } 559 } else if (sockstate & CBB_STATE_CB_CARD) { 560 if (device_is_attached(sc->cbdev)) { 561 sc->flags &= ~CBB_16BIT_CARD; 562 CARD_ATTACH_CARD(sc->cbdev); 563 } else { 564 device_printf(sc->dev, 565 "CardBus card inserted, but no cardbus bus.\n"); 566 } 567 } else { 568 /* 569 * We should power the card down, and try again a couple of 570 * times if this happens. XXX 571 */ 572 device_printf(sc->dev, "Unsupported card type detected\n"); 573 } 574 } 575 576 static void 577 cbb_removal(struct cbb_softc *sc) 578 { 579 sc->cardok = 0; 580 if (sc->flags & CBB_16BIT_CARD) { 581 exca_removal(&sc->exca[0]); 582 } else { 583 if (device_is_attached(sc->cbdev)) 584 CARD_DETACH_CARD(sc->cbdev); 585 } 586 cbb_destroy_res(sc); 587 } 588 589 /************************************************************************/ 590 /* Interrupt Handler */ 591 /************************************************************************/ 592 593 static int 594 cbb_func_filt(void *arg) 595 { 596 struct cbb_intrhand *ih = (struct cbb_intrhand *)arg; 597 struct cbb_softc *sc = ih->sc; 598 599 /* 600 * Make sure that the card is really there. 601 */ 602 if (!sc->cardok) 603 return (FILTER_STRAY); 604 if (!CBB_CARD_PRESENT(cbb_get(sc, CBB_SOCKET_STATE))) { 605 sc->cardok = 0; 606 return (FILTER_HANDLED); 607 } 608 609 /* 610 * nb: don't have to check for giant or not, since that's done in the 611 * ISR dispatch and one can't hold Giant in a filter anyway... 612 */ 613 return ((*ih->filt)(ih->arg)); 614 } 615 616 static void 617 cbb_func_intr(void *arg) 618 { 619 struct cbb_intrhand *ih = (struct cbb_intrhand *)arg; 620 struct cbb_softc *sc = ih->sc; 621 622 /* 623 * While this check may seem redundant, it helps close a race 624 * condition. If the card is ejected after the filter runs, but 625 * before this ISR can be scheduled, then we need to do the same 626 * filtering to prevent the card's ISR from being called. One could 627 * argue that the card's ISR should be able to cope, but experience 628 * has shown they can't always. This mitigates the problem by making 629 * the race quite a bit smaller. Properly written client ISRs should 630 * cope with the card going away in the middle of the ISR. We assume 631 * that drivers that are sophisticated enough to use filters don't 632 * need our protection. This also allows us to ensure they *ARE* 633 * called if their filter said they needed to be called. 634 */ 635 if (ih->filt == NULL) { 636 if (!sc->cardok) 637 return; 638 if (!CBB_CARD_PRESENT(cbb_get(sc, CBB_SOCKET_STATE))) { 639 sc->cardok = 0; 640 return; 641 } 642 } 643 644 /* 645 * Call the registered ithread interrupt handler. This entire routine 646 * will be called with Giant if this isn't an MP safe driver, or not 647 * if it is. Either way, we don't have to worry. 648 */ 649 ih->intr(ih->arg); 650 } 651 652 /************************************************************************/ 653 /* Generic Power functions */ 654 /************************************************************************/ 655 656 static uint32_t 657 cbb_detect_voltage(device_t brdev) 658 { 659 struct cbb_softc *sc = device_get_softc(brdev); 660 uint32_t psr; 661 uint32_t vol = CARD_UKN_CARD; 662 663 psr = cbb_get(sc, CBB_SOCKET_STATE); 664 665 if (psr & CBB_STATE_5VCARD && psr & CBB_STATE_5VSOCK) 666 vol |= CARD_5V_CARD; 667 if (psr & CBB_STATE_3VCARD && psr & CBB_STATE_3VSOCK) 668 vol |= CARD_3V_CARD; 669 if (psr & CBB_STATE_XVCARD && psr & CBB_STATE_XVSOCK) 670 vol |= CARD_XV_CARD; 671 if (psr & CBB_STATE_YVCARD && psr & CBB_STATE_YVSOCK) 672 vol |= CARD_YV_CARD; 673 674 return (vol); 675 } 676 677 static uint8_t 678 cbb_o2micro_power_hack(struct cbb_softc *sc) 679 { 680 uint8_t reg; 681 682 /* 683 * Issue #2: INT# not qualified with IRQ Routing Bit. An 684 * unexpected PCI INT# may be generated during PC Card 685 * initialization even with the IRQ Routing Bit Set with some 686 * PC Cards. 687 * 688 * This is a two part issue. The first part is that some of 689 * our older controllers have an issue in which the slot's PCI 690 * INT# is NOT qualified by the IRQ routing bit (PCI reg. 3Eh 691 * bit 7). Regardless of the IRQ routing bit, if NO ISA IRQ 692 * is selected (ExCA register 03h bits 3:0, of the slot, are 693 * cleared) we will generate INT# if IREQ# is asserted. The 694 * second part is because some PC Cards prematurally assert 695 * IREQ# before the ExCA registers are fully programmed. This 696 * in turn asserts INT# because ExCA register 03h bits 3:0 697 * (ISA IRQ Select) are not yet programmed. 698 * 699 * The fix for this issue, which will work for any controller 700 * (old or new), is to set ExCA register 03h bits 3:0 = 0001b 701 * (select IRQ1), of the slot, before turning on slot power. 702 * Selecting IRQ1 will result in INT# NOT being asserted 703 * (because IRQ1 is selected), and IRQ1 won't be asserted 704 * because our controllers don't generate IRQ1. 705 * 706 * Other, non O2Micro controllers will generate irq 1 in some 707 * situations, so we can't do this hack for everybody. Reports of 708 * keyboard controller's interrupts being suppressed occurred when 709 * we did this. 710 */ 711 reg = exca_getb(&sc->exca[0], EXCA_INTR); 712 exca_putb(&sc->exca[0], EXCA_INTR, (reg & 0xf0) | 1); 713 return (reg); 714 } 715 716 /* 717 * Restore the damage that cbb_o2micro_power_hack does to EXCA_INTR so 718 * we don't have an interrupt storm on power on. This has the effect of 719 * disabling card status change interrupts for the duration of poweron. 720 */ 721 static void 722 cbb_o2micro_power_hack2(struct cbb_softc *sc, uint8_t reg) 723 { 724 exca_putb(&sc->exca[0], EXCA_INTR, reg); 725 } 726 727 int 728 cbb_power(device_t brdev, int volts) 729 { 730 uint32_t status, sock_ctrl, reg_ctrl, mask; 731 struct cbb_softc *sc = device_get_softc(brdev); 732 int cnt, sane; 733 int retval = 0; 734 int on = 0; 735 uint8_t reg = 0; 736 737 sock_ctrl = cbb_get(sc, CBB_SOCKET_CONTROL); 738 739 sock_ctrl &= ~CBB_SOCKET_CTRL_VCCMASK; 740 switch (volts & CARD_VCCMASK) { 741 case 5: 742 sock_ctrl |= CBB_SOCKET_CTRL_VCC_5V; 743 on++; 744 break; 745 case 3: 746 sock_ctrl |= CBB_SOCKET_CTRL_VCC_3V; 747 on++; 748 break; 749 case XV: 750 sock_ctrl |= CBB_SOCKET_CTRL_VCC_XV; 751 on++; 752 break; 753 case YV: 754 sock_ctrl |= CBB_SOCKET_CTRL_VCC_YV; 755 on++; 756 break; 757 case 0: 758 break; 759 default: 760 return (0); /* power NEVER changed */ 761 } 762 763 /* VPP == VCC */ 764 sock_ctrl &= ~CBB_SOCKET_CTRL_VPPMASK; 765 sock_ctrl |= ((sock_ctrl >> 4) & 0x07); 766 767 if (cbb_get(sc, CBB_SOCKET_CONTROL) == sock_ctrl) 768 return (1); /* no change necessary */ 769 DEVPRINTF((sc->dev, "cbb_power: %dV\n", volts)); 770 if (volts != 0 && sc->chipset == CB_O2MICRO) 771 reg = cbb_o2micro_power_hack(sc); 772 773 /* 774 * We have to mask the card change detect interrupt while we're 775 * messing with the power. It is allowed to bounce while we're 776 * messing with power as things settle down. In addition, we mask off 777 * the card's function interrupt by routing it via the ISA bus. This 778 * bit generally only affects 16-bit cards. Some bridges allow one to 779 * set another bit to have it also affect 32-bit cards. Since 32-bit 780 * cards are required to be better behaved, we don't bother to get 781 * into those bridge specific features. 782 * 783 * XXX I wonder if we need to enable the READY bit interrupt in the 784 * EXCA CSC register for 16-bit cards, and disable the CD bit? 785 */ 786 mask = cbb_get(sc, CBB_SOCKET_MASK); 787 mask |= CBB_SOCKET_MASK_POWER; 788 mask &= ~CBB_SOCKET_MASK_CD; 789 cbb_set(sc, CBB_SOCKET_MASK, mask); 790 PCI_MASK_CONFIG(brdev, CBBR_BRIDGECTRL, 791 |CBBM_BRIDGECTRL_INTR_IREQ_ISA_EN, 2); 792 cbb_set(sc, CBB_SOCKET_CONTROL, sock_ctrl); 793 if (on) { 794 mtx_lock(&sc->mtx); 795 cnt = sc->powerintr; 796 /* 797 * We have a shortish timeout of 500ms here. Some bridges do 798 * not generate a POWER_CYCLE event for 16-bit cards. In 799 * those cases, we have to cope the best we can, and having 800 * only a short delay is better than the alternatives. Others 801 * raise the power cycle a smidge before it is really ready. 802 * We deal with those below. 803 */ 804 sane = 10; 805 while (!(cbb_get(sc, CBB_SOCKET_STATE) & CBB_STATE_POWER_CYCLE) && 806 cnt == sc->powerintr && sane-- > 0) 807 msleep(&sc->powerintr, &sc->mtx, 0, "-", hz / 20); 808 mtx_unlock(&sc->mtx); 809 810 /* 811 * Relax for 100ms. Some bridges appear to assert this signal 812 * right away, but before the card has stabilized. Other 813 * cards need need more time to cope up reliabily. 814 * Experiments with troublesome setups show this to be a 815 * "cheap" way to enhance reliabilty. We need not do this for 816 * "off" since we don't touch the card after we turn it off. 817 */ 818 pause("cbbPwr", min(hz / 10, 1)); 819 820 /* 821 * The TOPIC95B requires a little bit extra time to get its 822 * act together, so delay for an additional 100ms. Also as 823 * documented below, it doesn't seem to set the POWER_CYCLE 824 * bit, so don't whine if it never came on. 825 */ 826 if (sc->chipset == CB_TOPIC95) 827 pause("cbb95B", hz / 10); 828 else if (sane <= 0) 829 device_printf(sc->dev, "power timeout, doom?\n"); 830 } 831 832 /* 833 * After the power is good, we can turn off the power interrupt. 834 * However, the PC Card standard says that we must delay turning the 835 * CD bit back on for a bit to allow for bouncyness on power down 836 * (recall that we don't wait above for a power down, since we don't 837 * get an interrupt for that). We're called either from the suspend 838 * code in which case we don't want to turn card change on again, or 839 * we're called from the card insertion code, in which case the cbb 840 * thread will turn it on for us before it waits to be woken by a 841 * change event. 842 * 843 * NB: Topic95B doesn't set the power cycle bit. we assume that 844 * both it and the TOPIC95 behave the same. 845 */ 846 cbb_clrb(sc, CBB_SOCKET_MASK, CBB_SOCKET_MASK_POWER); 847 status = cbb_get(sc, CBB_SOCKET_STATE); 848 if (on && sc->chipset != CB_TOPIC95) { 849 if ((status & CBB_STATE_POWER_CYCLE) == 0) 850 device_printf(sc->dev, "Power not on?\n"); 851 } 852 if (status & CBB_STATE_BAD_VCC_REQ) { 853 device_printf(sc->dev, "Bad Vcc requested\n"); 854 /* 855 * Turn off the power, and try again. Retrigger other 856 * active interrupts via force register. From NetBSD 857 * PR 36652, coded by me to description there. 858 */ 859 sock_ctrl &= ~CBB_SOCKET_CTRL_VCCMASK; 860 sock_ctrl &= ~CBB_SOCKET_CTRL_VPPMASK; 861 cbb_set(sc, CBB_SOCKET_CONTROL, sock_ctrl); 862 status &= ~CBB_STATE_BAD_VCC_REQ; 863 status &= ~CBB_STATE_DATA_LOST; 864 status |= CBB_FORCE_CV_TEST; 865 cbb_set(sc, CBB_SOCKET_FORCE, status); 866 goto done; 867 } 868 if (sc->chipset == CB_TOPIC97) { 869 reg_ctrl = pci_read_config(sc->dev, TOPIC_REG_CTRL, 4); 870 reg_ctrl &= ~TOPIC97_REG_CTRL_TESTMODE; 871 if (on) 872 reg_ctrl |= TOPIC97_REG_CTRL_CLKRUN_ENA; 873 else 874 reg_ctrl &= ~TOPIC97_REG_CTRL_CLKRUN_ENA; 875 pci_write_config(sc->dev, TOPIC_REG_CTRL, reg_ctrl, 4); 876 } 877 PCI_MASK_CONFIG(brdev, CBBR_BRIDGECTRL, 878 & ~CBBM_BRIDGECTRL_INTR_IREQ_ISA_EN, 2); 879 retval = 1; 880 done:; 881 if (volts != 0 && sc->chipset == CB_O2MICRO) 882 cbb_o2micro_power_hack2(sc, reg); 883 return (retval); 884 } 885 886 static int 887 cbb_current_voltage(device_t brdev) 888 { 889 struct cbb_softc *sc = device_get_softc(brdev); 890 uint32_t ctrl; 891 892 ctrl = cbb_get(sc, CBB_SOCKET_CONTROL); 893 switch (ctrl & CBB_SOCKET_CTRL_VCCMASK) { 894 case CBB_SOCKET_CTRL_VCC_5V: 895 return CARD_5V_CARD; 896 case CBB_SOCKET_CTRL_VCC_3V: 897 return CARD_3V_CARD; 898 case CBB_SOCKET_CTRL_VCC_XV: 899 return CARD_XV_CARD; 900 case CBB_SOCKET_CTRL_VCC_YV: 901 return CARD_YV_CARD; 902 } 903 return 0; 904 } 905 906 /* 907 * detect the voltage for the card, and set it. Since the power 908 * used is the square of the voltage, lower voltages is a big win 909 * and what Windows does (and what Microsoft prefers). The MS paper 910 * also talks about preferring the CIS entry as well, but that has 911 * to be done elsewhere. We also optimize power sequencing here 912 * and don't change things if we're already powered up at a supported 913 * voltage. 914 * 915 * In addition, we power up with OE disabled. We'll set it later 916 * in the power up sequence. 917 */ 918 static int 919 cbb_do_power(device_t brdev) 920 { 921 struct cbb_softc *sc = device_get_softc(brdev); 922 uint32_t voltage, curpwr; 923 uint32_t status; 924 925 /* Don't enable OE (output enable) until power stable */ 926 exca_clrb(&sc->exca[0], EXCA_PWRCTL, EXCA_PWRCTL_OE); 927 928 voltage = cbb_detect_voltage(brdev); 929 curpwr = cbb_current_voltage(brdev); 930 status = cbb_get(sc, CBB_SOCKET_STATE); 931 if ((status & CBB_STATE_POWER_CYCLE) && (voltage & curpwr)) 932 return 0; 933 /* Prefer lowest voltage supported */ 934 cbb_power(brdev, CARD_OFF); 935 if (voltage & CARD_YV_CARD) 936 cbb_power(brdev, CARD_VCC(YV)); 937 else if (voltage & CARD_XV_CARD) 938 cbb_power(brdev, CARD_VCC(XV)); 939 else if (voltage & CARD_3V_CARD) 940 cbb_power(brdev, CARD_VCC(3)); 941 else if (voltage & CARD_5V_CARD) 942 cbb_power(brdev, CARD_VCC(5)); 943 else { 944 device_printf(brdev, "Unknown card voltage\n"); 945 return (ENXIO); 946 } 947 return (0); 948 } 949 950 /************************************************************************/ 951 /* CardBus power functions */ 952 /************************************************************************/ 953 954 static int 955 cbb_cardbus_reset_power(device_t brdev, device_t child, int on) 956 { 957 struct cbb_softc *sc = device_get_softc(brdev); 958 uint32_t b, h; 959 int delay, count, zero_seen, func; 960 961 /* 962 * Asserting reset for 20ms is necessary for most bridges. For some 963 * reason, the Ricoh RF5C47x bridges need it asserted for 400ms. The 964 * root cause of this is unknown, and NetBSD does the same thing. 965 */ 966 delay = sc->chipset == CB_RF5C47X ? 400 : 20; 967 PCI_MASK_CONFIG(brdev, CBBR_BRIDGECTRL, |CBBM_BRIDGECTRL_RESET, 2); 968 pause("cbbP3", hz * delay / 1000); 969 970 /* 971 * If a card exists and we're turning it on, take it out of reset. 972 * After clearing reset, wait up to 1.1s for the first configuration 973 * register (vendor/product) configuration register of device 0.0 to 974 * become != 0xffffffff. The PCMCIA PC Card Host System Specification 975 * says that when powering up the card, the PCI Spec v2.1 must be 976 * followed. In PCI spec v2.2 Table 4-6, Trhfa (Reset High to first 977 * Config Access) is at most 2^25 clocks, or just over 1s. Section 978 * 2.2.1 states any card not ready to participate in bus transactions 979 * must tristate its outputs. Therefore, any access to its 980 * configuration registers must be ignored. In that state, the config 981 * reg will read 0xffffffff. Section 6.2.1 states a vendor id of 982 * 0xffff is invalid, so this can never match a real card. Print a 983 * warning if it never returns a real id. The PCMCIA PC Card 984 * Electrical Spec Section 5.2.7.1 implies only device 0 is present on 985 * a cardbus bus, so that's the only register we check here. 986 */ 987 if (on && CBB_CARD_PRESENT(cbb_get(sc, CBB_SOCKET_STATE))) { 988 PCI_MASK_CONFIG(brdev, CBBR_BRIDGECTRL, 989 &~CBBM_BRIDGECTRL_RESET, 2); 990 b = pcib_get_bus(child); 991 count = 1100 / 20; 992 do { 993 pause("cbbP4", hz * 2 / 100); 994 } while (PCIB_READ_CONFIG(brdev, b, 0, 0, PCIR_DEVVENDOR, 4) == 995 0xfffffffful && --count >= 0); 996 if (count < 0) 997 device_printf(brdev, "Warning: Bus reset timeout\n"); 998 999 /* 1000 * Some cards (so far just an atheros card I have) seem to 1001 * come out of reset in a funky state. They report they are 1002 * multi-function cards, but have nonsense for some of the 1003 * higher functions. So if the card claims to be MFDEV, and 1004 * any of the higher functions' ID is 0, then we've hit the 1005 * bug and we'll try again. 1006 */ 1007 h = PCIB_READ_CONFIG(brdev, b, 0, 0, PCIR_HDRTYPE, 1); 1008 if ((h & PCIM_MFDEV) == 0) 1009 return 0; 1010 zero_seen = 0; 1011 for (func = 1; func < 8; func++) { 1012 h = PCIB_READ_CONFIG(brdev, b, 0, func, 1013 PCIR_DEVVENDOR, 4); 1014 if (h == 0) 1015 zero_seen++; 1016 } 1017 if (!zero_seen) 1018 return 0; 1019 return (EINVAL); 1020 } 1021 return 0; 1022 } 1023 1024 static int 1025 cbb_cardbus_power_disable_socket(device_t brdev, device_t child) 1026 { 1027 cbb_power(brdev, CARD_OFF); 1028 cbb_cardbus_reset_power(brdev, child, 0); 1029 return (0); 1030 } 1031 1032 static int 1033 cbb_cardbus_power_enable_socket(device_t brdev, device_t child) 1034 { 1035 struct cbb_softc *sc = device_get_softc(brdev); 1036 int err, count; 1037 1038 if (!CBB_CARD_PRESENT(cbb_get(sc, CBB_SOCKET_STATE))) 1039 return (ENODEV); 1040 1041 count = 10; 1042 do { 1043 err = cbb_do_power(brdev); 1044 if (err) 1045 return (err); 1046 err = cbb_cardbus_reset_power(brdev, child, 1); 1047 if (err) { 1048 device_printf(brdev, "Reset failed, trying again.\n"); 1049 cbb_cardbus_power_disable_socket(brdev, child); 1050 pause("cbbErr1", hz / 10); /* wait 100ms */ 1051 } 1052 } while (err != 0 && count-- > 0); 1053 return (0); 1054 } 1055 1056 /************************************************************************/ 1057 /* CardBus Resource */ 1058 /************************************************************************/ 1059 1060 static void 1061 cbb_activate_window(device_t brdev, int type) 1062 { 1063 1064 PCI_ENABLE_IO(device_get_parent(brdev), brdev, type); 1065 } 1066 1067 static int 1068 cbb_cardbus_io_open(device_t brdev, int win, uint32_t start, uint32_t end) 1069 { 1070 int basereg; 1071 int limitreg; 1072 1073 if ((win < 0) || (win > 1)) { 1074 DEVPRINTF((brdev, 1075 "cbb_cardbus_io_open: window out of range %d\n", win)); 1076 return (EINVAL); 1077 } 1078 1079 basereg = win * 8 + CBBR_IOBASE0; 1080 limitreg = win * 8 + CBBR_IOLIMIT0; 1081 1082 pci_write_config(brdev, basereg, start, 4); 1083 pci_write_config(brdev, limitreg, end, 4); 1084 cbb_activate_window(brdev, SYS_RES_IOPORT); 1085 return (0); 1086 } 1087 1088 static int 1089 cbb_cardbus_mem_open(device_t brdev, int win, uint32_t start, uint32_t end) 1090 { 1091 int basereg; 1092 int limitreg; 1093 1094 if ((win < 0) || (win > 1)) { 1095 DEVPRINTF((brdev, 1096 "cbb_cardbus_mem_open: window out of range %d\n", win)); 1097 return (EINVAL); 1098 } 1099 1100 basereg = win * 8 + CBBR_MEMBASE0; 1101 limitreg = win * 8 + CBBR_MEMLIMIT0; 1102 1103 pci_write_config(brdev, basereg, start, 4); 1104 pci_write_config(brdev, limitreg, end, 4); 1105 cbb_activate_window(brdev, SYS_RES_MEMORY); 1106 return (0); 1107 } 1108 1109 #define START_NONE 0xffffffff 1110 #define END_NONE 0 1111 1112 static void 1113 cbb_cardbus_auto_open(struct cbb_softc *sc, int type) 1114 { 1115 uint32_t starts[2]; 1116 uint32_t ends[2]; 1117 struct cbb_reslist *rle; 1118 int align, i; 1119 uint32_t reg; 1120 1121 starts[0] = starts[1] = START_NONE; 1122 ends[0] = ends[1] = END_NONE; 1123 1124 if (type == SYS_RES_MEMORY) 1125 align = CBB_MEMALIGN; 1126 else if (type == SYS_RES_IOPORT) 1127 align = CBB_IOALIGN; 1128 else 1129 align = 1; 1130 1131 SLIST_FOREACH(rle, &sc->rl, link) { 1132 if (rle->type != type) 1133 continue; 1134 if (rle->res == NULL) 1135 continue; 1136 if (!(rman_get_flags(rle->res) & RF_ACTIVE)) 1137 continue; 1138 if (rman_get_flags(rle->res) & RF_PREFETCHABLE) 1139 i = 1; 1140 else 1141 i = 0; 1142 if (rman_get_start(rle->res) < starts[i]) 1143 starts[i] = rman_get_start(rle->res); 1144 if (rman_get_end(rle->res) > ends[i]) 1145 ends[i] = rman_get_end(rle->res); 1146 } 1147 for (i = 0; i < 2; i++) { 1148 if (starts[i] == START_NONE) 1149 continue; 1150 starts[i] &= ~(align - 1); 1151 ends[i] = roundup2(ends[i], align) - 1; 1152 } 1153 if (starts[0] != START_NONE && starts[1] != START_NONE) { 1154 if (starts[0] < starts[1]) { 1155 if (ends[0] > starts[1]) { 1156 device_printf(sc->dev, "Overlapping ranges" 1157 " for prefetch and non-prefetch memory\n"); 1158 return; 1159 } 1160 } else { 1161 if (ends[1] > starts[0]) { 1162 device_printf(sc->dev, "Overlapping ranges" 1163 " for prefetch and non-prefetch memory\n"); 1164 return; 1165 } 1166 } 1167 } 1168 1169 if (type == SYS_RES_MEMORY) { 1170 cbb_cardbus_mem_open(sc->dev, 0, starts[0], ends[0]); 1171 cbb_cardbus_mem_open(sc->dev, 1, starts[1], ends[1]); 1172 reg = pci_read_config(sc->dev, CBBR_BRIDGECTRL, 2); 1173 reg &= ~(CBBM_BRIDGECTRL_PREFETCH_0 | 1174 CBBM_BRIDGECTRL_PREFETCH_1); 1175 if (starts[1] != START_NONE) 1176 reg |= CBBM_BRIDGECTRL_PREFETCH_1; 1177 pci_write_config(sc->dev, CBBR_BRIDGECTRL, reg, 2); 1178 if (bootverbose) { 1179 device_printf(sc->dev, "Opening memory:\n"); 1180 if (starts[0] != START_NONE) 1181 device_printf(sc->dev, "Normal: %#x-%#x\n", 1182 starts[0], ends[0]); 1183 if (starts[1] != START_NONE) 1184 device_printf(sc->dev, "Prefetch: %#x-%#x\n", 1185 starts[1], ends[1]); 1186 } 1187 } else if (type == SYS_RES_IOPORT) { 1188 cbb_cardbus_io_open(sc->dev, 0, starts[0], ends[0]); 1189 cbb_cardbus_io_open(sc->dev, 1, starts[1], ends[1]); 1190 if (bootverbose && starts[0] != START_NONE) 1191 device_printf(sc->dev, "Opening I/O: %#x-%#x\n", 1192 starts[0], ends[0]); 1193 } 1194 } 1195 1196 static int 1197 cbb_cardbus_activate_resource(device_t brdev, device_t child, int type, 1198 int rid, struct resource *res) 1199 { 1200 int ret; 1201 1202 ret = BUS_ACTIVATE_RESOURCE(device_get_parent(brdev), child, 1203 type, rid, res); 1204 if (ret != 0) 1205 return (ret); 1206 cbb_cardbus_auto_open(device_get_softc(brdev), type); 1207 return (0); 1208 } 1209 1210 static int 1211 cbb_cardbus_deactivate_resource(device_t brdev, device_t child, int type, 1212 int rid, struct resource *res) 1213 { 1214 int ret; 1215 1216 ret = BUS_DEACTIVATE_RESOURCE(device_get_parent(brdev), child, 1217 type, rid, res); 1218 if (ret != 0) 1219 return (ret); 1220 cbb_cardbus_auto_open(device_get_softc(brdev), type); 1221 return (0); 1222 } 1223 1224 static struct resource * 1225 cbb_cardbus_alloc_resource(device_t brdev, device_t child, int type, 1226 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 1227 { 1228 struct cbb_softc *sc = device_get_softc(brdev); 1229 int tmp; 1230 struct resource *res; 1231 rman_res_t align; 1232 1233 switch (type) { 1234 case SYS_RES_IRQ: 1235 tmp = rman_get_start(sc->irq_res); 1236 if (start > tmp || end < tmp || count != 1) { 1237 device_printf(child, "requested interrupt %jd-%jd," 1238 "count = %jd not supported by cbb\n", 1239 start, end, count); 1240 return (NULL); 1241 } 1242 start = end = tmp; 1243 flags |= RF_SHAREABLE; 1244 break; 1245 case SYS_RES_IOPORT: 1246 if (start <= cbb_start_32_io) 1247 start = cbb_start_32_io; 1248 if (end < start) 1249 end = start; 1250 if (count > (1 << RF_ALIGNMENT(flags))) 1251 flags = (flags & ~RF_ALIGNMENT_MASK) | 1252 rman_make_alignment_flags(count); 1253 break; 1254 case SYS_RES_MEMORY: 1255 if (start <= cbb_start_mem) 1256 start = cbb_start_mem; 1257 if (end < start) 1258 end = start; 1259 if (count < CBB_MEMALIGN) 1260 align = CBB_MEMALIGN; 1261 else 1262 align = count; 1263 if (align > (1 << RF_ALIGNMENT(flags))) 1264 flags = (flags & ~RF_ALIGNMENT_MASK) | 1265 rman_make_alignment_flags(align); 1266 break; 1267 } 1268 res = BUS_ALLOC_RESOURCE(device_get_parent(brdev), child, type, rid, 1269 start, end, count, flags & ~RF_ACTIVE); 1270 if (res == NULL) { 1271 printf("cbb alloc res fail type %d rid %x\n", type, *rid); 1272 return (NULL); 1273 } 1274 cbb_insert_res(sc, res, type, *rid); 1275 if (flags & RF_ACTIVE) 1276 if (bus_activate_resource(child, type, *rid, res) != 0) { 1277 bus_release_resource(child, type, *rid, res); 1278 return (NULL); 1279 } 1280 1281 return (res); 1282 } 1283 1284 static int 1285 cbb_cardbus_release_resource(device_t brdev, device_t child, int type, 1286 int rid, struct resource *res) 1287 { 1288 struct cbb_softc *sc = device_get_softc(brdev); 1289 int error; 1290 1291 if (rman_get_flags(res) & RF_ACTIVE) { 1292 error = bus_deactivate_resource(child, type, rid, res); 1293 if (error != 0) 1294 return (error); 1295 } 1296 cbb_remove_res(sc, res); 1297 return (BUS_RELEASE_RESOURCE(device_get_parent(brdev), child, 1298 type, rid, res)); 1299 } 1300 1301 /************************************************************************/ 1302 /* PC Card Power Functions */ 1303 /************************************************************************/ 1304 1305 static int 1306 cbb_pcic_power_enable_socket(device_t brdev, device_t child) 1307 { 1308 struct cbb_softc *sc = device_get_softc(brdev); 1309 int err; 1310 1311 DPRINTF(("cbb_pcic_socket_enable:\n")); 1312 1313 /* power down/up the socket to reset */ 1314 err = cbb_do_power(brdev); 1315 if (err) 1316 return (err); 1317 exca_reset(&sc->exca[0], child); 1318 1319 return (0); 1320 } 1321 1322 static int 1323 cbb_pcic_power_disable_socket(device_t brdev, device_t child) 1324 { 1325 struct cbb_softc *sc = device_get_softc(brdev); 1326 1327 DPRINTF(("cbb_pcic_socket_disable\n")); 1328 1329 /* Turn off the card's interrupt and leave it in reset, wait 10ms */ 1330 exca_putb(&sc->exca[0], EXCA_INTR, 0); 1331 pause("cbbP1", hz / 100); 1332 1333 /* power down the socket */ 1334 cbb_power(brdev, CARD_OFF); 1335 exca_putb(&sc->exca[0], EXCA_PWRCTL, 0); 1336 1337 /* wait 300ms until power fails (Tpf). */ 1338 pause("cbbP2", hz * 300 / 1000); 1339 1340 /* enable CSC interrupts */ 1341 exca_putb(&sc->exca[0], EXCA_INTR, EXCA_INTR_ENABLE); 1342 return (0); 1343 } 1344 1345 /************************************************************************/ 1346 /* POWER methods */ 1347 /************************************************************************/ 1348 1349 int 1350 cbb_power_enable_socket(device_t brdev, device_t child) 1351 { 1352 struct cbb_softc *sc = device_get_softc(brdev); 1353 1354 if (sc->flags & CBB_16BIT_CARD) 1355 return (cbb_pcic_power_enable_socket(brdev, child)); 1356 return (cbb_cardbus_power_enable_socket(brdev, child)); 1357 } 1358 1359 int 1360 cbb_power_disable_socket(device_t brdev, device_t child) 1361 { 1362 struct cbb_softc *sc = device_get_softc(brdev); 1363 if (sc->flags & CBB_16BIT_CARD) 1364 return (cbb_pcic_power_disable_socket(brdev, child)); 1365 return (cbb_cardbus_power_disable_socket(brdev, child)); 1366 } 1367 1368 static int 1369 cbb_pcic_activate_resource(device_t brdev, device_t child, int type, int rid, 1370 struct resource *res) 1371 { 1372 struct cbb_softc *sc = device_get_softc(brdev); 1373 int error; 1374 1375 error = exca_activate_resource(&sc->exca[0], child, type, rid, res); 1376 if (error == 0) 1377 cbb_activate_window(brdev, type); 1378 return (error); 1379 } 1380 1381 static int 1382 cbb_pcic_deactivate_resource(device_t brdev, device_t child, int type, 1383 int rid, struct resource *res) 1384 { 1385 struct cbb_softc *sc = device_get_softc(brdev); 1386 return (exca_deactivate_resource(&sc->exca[0], child, type, rid, res)); 1387 } 1388 1389 static struct resource * 1390 cbb_pcic_alloc_resource(device_t brdev, device_t child, int type, int *rid, 1391 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 1392 { 1393 struct resource *res = NULL; 1394 struct cbb_softc *sc = device_get_softc(brdev); 1395 int align; 1396 int tmp; 1397 1398 switch (type) { 1399 case SYS_RES_MEMORY: 1400 if (start < cbb_start_mem) 1401 start = cbb_start_mem; 1402 if (end < start) 1403 end = start; 1404 if (count < CBB_MEMALIGN) 1405 align = CBB_MEMALIGN; 1406 else 1407 align = count; 1408 if (align > (1 << RF_ALIGNMENT(flags))) 1409 flags = (flags & ~RF_ALIGNMENT_MASK) | 1410 rman_make_alignment_flags(align); 1411 break; 1412 case SYS_RES_IOPORT: 1413 if (start < cbb_start_16_io) 1414 start = cbb_start_16_io; 1415 if (end < start) 1416 end = start; 1417 break; 1418 case SYS_RES_IRQ: 1419 tmp = rman_get_start(sc->irq_res); 1420 if (start > tmp || end < tmp || count != 1) { 1421 device_printf(child, "requested interrupt %jd-%jd," 1422 "count = %jd not supported by cbb\n", 1423 start, end, count); 1424 return (NULL); 1425 } 1426 flags |= RF_SHAREABLE; 1427 start = end = rman_get_start(sc->irq_res); 1428 break; 1429 } 1430 res = BUS_ALLOC_RESOURCE(device_get_parent(brdev), child, type, rid, 1431 start, end, count, flags & ~RF_ACTIVE); 1432 if (res == NULL) 1433 return (NULL); 1434 cbb_insert_res(sc, res, type, *rid); 1435 if (flags & RF_ACTIVE) { 1436 if (bus_activate_resource(child, type, *rid, res) != 0) { 1437 bus_release_resource(child, type, *rid, res); 1438 return (NULL); 1439 } 1440 } 1441 1442 return (res); 1443 } 1444 1445 static int 1446 cbb_pcic_release_resource(device_t brdev, device_t child, int type, 1447 int rid, struct resource *res) 1448 { 1449 struct cbb_softc *sc = device_get_softc(brdev); 1450 int error; 1451 1452 if (rman_get_flags(res) & RF_ACTIVE) { 1453 error = bus_deactivate_resource(child, type, rid, res); 1454 if (error != 0) 1455 return (error); 1456 } 1457 cbb_remove_res(sc, res); 1458 return (BUS_RELEASE_RESOURCE(device_get_parent(brdev), child, 1459 type, rid, res)); 1460 } 1461 1462 /************************************************************************/ 1463 /* PC Card methods */ 1464 /************************************************************************/ 1465 1466 int 1467 cbb_pcic_set_res_flags(device_t brdev, device_t child, int type, int rid, 1468 u_long flags) 1469 { 1470 struct cbb_softc *sc = device_get_softc(brdev); 1471 struct resource *res; 1472 1473 if (type != SYS_RES_MEMORY) 1474 return (EINVAL); 1475 res = cbb_find_res(sc, type, rid); 1476 if (res == NULL) { 1477 device_printf(brdev, 1478 "set_res_flags: specified rid not found\n"); 1479 return (ENOENT); 1480 } 1481 return (exca_mem_set_flags(&sc->exca[0], res, flags)); 1482 } 1483 1484 int 1485 cbb_pcic_set_memory_offset(device_t brdev, device_t child, int rid, 1486 uint32_t cardaddr, uint32_t *deltap) 1487 { 1488 struct cbb_softc *sc = device_get_softc(brdev); 1489 struct resource *res; 1490 1491 res = cbb_find_res(sc, SYS_RES_MEMORY, rid); 1492 if (res == NULL) { 1493 device_printf(brdev, 1494 "set_memory_offset: specified rid not found\n"); 1495 return (ENOENT); 1496 } 1497 return (exca_mem_set_offset(&sc->exca[0], res, cardaddr, deltap)); 1498 } 1499 1500 /************************************************************************/ 1501 /* BUS Methods */ 1502 /************************************************************************/ 1503 1504 1505 int 1506 cbb_activate_resource(device_t brdev, device_t child, int type, int rid, 1507 struct resource *r) 1508 { 1509 struct cbb_softc *sc = device_get_softc(brdev); 1510 1511 if (sc->flags & CBB_16BIT_CARD) 1512 return (cbb_pcic_activate_resource(brdev, child, type, rid, r)); 1513 else 1514 return (cbb_cardbus_activate_resource(brdev, child, type, rid, 1515 r)); 1516 } 1517 1518 int 1519 cbb_deactivate_resource(device_t brdev, device_t child, int type, 1520 int rid, struct resource *r) 1521 { 1522 struct cbb_softc *sc = device_get_softc(brdev); 1523 1524 if (sc->flags & CBB_16BIT_CARD) 1525 return (cbb_pcic_deactivate_resource(brdev, child, type, 1526 rid, r)); 1527 else 1528 return (cbb_cardbus_deactivate_resource(brdev, child, type, 1529 rid, r)); 1530 } 1531 1532 struct resource * 1533 cbb_alloc_resource(device_t brdev, device_t child, int type, int *rid, 1534 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 1535 { 1536 struct cbb_softc *sc = device_get_softc(brdev); 1537 1538 if (sc->flags & CBB_16BIT_CARD) 1539 return (cbb_pcic_alloc_resource(brdev, child, type, rid, 1540 start, end, count, flags)); 1541 else 1542 return (cbb_cardbus_alloc_resource(brdev, child, type, rid, 1543 start, end, count, flags)); 1544 } 1545 1546 int 1547 cbb_release_resource(device_t brdev, device_t child, int type, int rid, 1548 struct resource *r) 1549 { 1550 struct cbb_softc *sc = device_get_softc(brdev); 1551 1552 if (sc->flags & CBB_16BIT_CARD) 1553 return (cbb_pcic_release_resource(brdev, child, type, 1554 rid, r)); 1555 else 1556 return (cbb_cardbus_release_resource(brdev, child, type, 1557 rid, r)); 1558 } 1559 1560 int 1561 cbb_read_ivar(device_t brdev, device_t child, int which, uintptr_t *result) 1562 { 1563 struct cbb_softc *sc = device_get_softc(brdev); 1564 1565 switch (which) { 1566 case PCIB_IVAR_DOMAIN: 1567 *result = sc->domain; 1568 return (0); 1569 case PCIB_IVAR_BUS: 1570 *result = sc->bus.sec; 1571 return (0); 1572 } 1573 return (ENOENT); 1574 } 1575 1576 int 1577 cbb_write_ivar(device_t brdev, device_t child, int which, uintptr_t value) 1578 { 1579 1580 switch (which) { 1581 case PCIB_IVAR_DOMAIN: 1582 return (EINVAL); 1583 case PCIB_IVAR_BUS: 1584 return (EINVAL); 1585 } 1586 return (ENOENT); 1587 } 1588 1589 int 1590 cbb_child_present(device_t parent, device_t child) 1591 { 1592 struct cbb_softc *sc = (struct cbb_softc *)device_get_softc(parent); 1593 uint32_t sockstate; 1594 1595 sockstate = cbb_get(sc, CBB_SOCKET_STATE); 1596 return (CBB_CARD_PRESENT(sockstate) && sc->cardok); 1597 } 1598