1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2000-2001 Jonathan Chen All rights reserved. 5 * Copyright (c) 2002-2004 M. Warner Losh <imp@FreeBSD.org> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the 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 20 * FOR 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 */ 29 30 /*- 31 * Copyright (c) 1998, 1999 and 2000 32 * HAYAKAWA Koichi. All rights reserved. 33 * 34 * Redistribution and use in source and binary forms, with or without 35 * modification, are permitted provided that the following conditions 36 * are met: 37 * 1. Redistributions of source code must retain the above copyright 38 * notice, this list of conditions and the following disclaimer. 39 * 2. Redistributions in binary form must reproduce the above copyright 40 * notice, this list of conditions and the following disclaimer in the 41 * documentation and/or other materials provided with the distribution. 42 * 3. All advertising materials mentioning features or use of this software 43 * must display the following acknowledgement: 44 * This product includes software developed by HAYAKAWA Koichi. 45 * 4. The name of the author may not be used to endorse or promote products 46 * derived from this software without specific prior written permission. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 49 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 50 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 51 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 52 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 53 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 54 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 55 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 56 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 57 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 58 */ 59 60 /* 61 * Driver for PCI to CardBus Bridge chips 62 * and PCI to PCMCIA Bridge chips 63 * and ISA to PCMCIA host adapters 64 * and C Bus to PCMCIA host adapters 65 * 66 * References: 67 * TI Datasheets: 68 * http://www-s.ti.com/cgi-bin/sc/generic2.cgi?family=PCI+CARDBUS+CONTROLLERS 69 * 70 * Written by Jonathan Chen <jon@freebsd.org> 71 * The author would like to acknowledge: 72 * * HAYAKAWA Koichi: Author of the NetBSD code for the same thing 73 * * Warner Losh: Newbus/newcard guru and author of the pccard side of things 74 * * YAMAMOTO Shigeru: Author of another FreeBSD cardbus driver 75 * * David Cross: Author of the initial ugly hack for a specific cardbus card 76 */ 77 78 #include <sys/cdefs.h> 79 __FBSDID("$FreeBSD$"); 80 81 #include <sys/param.h> 82 #include <sys/bus.h> 83 #include <sys/condvar.h> 84 #include <sys/errno.h> 85 #include <sys/kernel.h> 86 #include <sys/module.h> 87 #include <sys/kthread.h> 88 #include <sys/lock.h> 89 #include <sys/malloc.h> 90 #include <sys/mutex.h> 91 #include <sys/proc.h> 92 #include <sys/rman.h> 93 #include <sys/sysctl.h> 94 #include <sys/systm.h> 95 #include <machine/bus.h> 96 #include <machine/resource.h> 97 98 #include <dev/pci/pcireg.h> 99 #include <dev/pci/pcivar.h> 100 #include <dev/pci/pcib_private.h> 101 102 #include <dev/pccard/pccardreg.h> 103 #include <dev/pccard/pccardvar.h> 104 105 #include <dev/exca/excareg.h> 106 #include <dev/exca/excavar.h> 107 108 #include <dev/pccbb/pccbbreg.h> 109 #include <dev/pccbb/pccbbvar.h> 110 111 #include "power_if.h" 112 #include "card_if.h" 113 #include "pcib_if.h" 114 115 #define DPRINTF(x) do { if (cbb_debug) printf x; } while (0) 116 #define DEVPRINTF(x) do { if (cbb_debug) device_printf x; } while (0) 117 118 #define PCI_MASK_CONFIG(DEV,REG,MASK,SIZE) \ 119 pci_write_config(DEV, REG, pci_read_config(DEV, REG, SIZE) MASK, SIZE) 120 #define PCI_MASK2_CONFIG(DEV,REG,MASK1,MASK2,SIZE) \ 121 pci_write_config(DEV, REG, ( \ 122 pci_read_config(DEV, REG, SIZE) MASK1) MASK2, SIZE) 123 124 #define CBB_CARD_PRESENT(s) ((s & CBB_STATE_CD) == 0) 125 126 #define CBB_START_MEM 0x88000000 127 #define CBB_START_32_IO 0x1000 128 #define CBB_START_16_IO 0x100 129 130 devclass_t cbb_devclass; 131 132 /* sysctl vars */ 133 static SYSCTL_NODE(_hw, OID_AUTO, cbb, CTLFLAG_RD, 0, "CBB parameters"); 134 135 /* There's no way to say TUNEABLE_LONG to get the right types */ 136 u_long cbb_start_mem = CBB_START_MEM; 137 SYSCTL_ULONG(_hw_cbb, OID_AUTO, start_memory, CTLFLAG_RWTUN, 138 &cbb_start_mem, CBB_START_MEM, 139 "Starting address for memory allocations"); 140 141 u_long cbb_start_16_io = CBB_START_16_IO; 142 SYSCTL_ULONG(_hw_cbb, OID_AUTO, start_16_io, CTLFLAG_RWTUN, 143 &cbb_start_16_io, CBB_START_16_IO, 144 "Starting ioport for 16-bit cards"); 145 146 u_long cbb_start_32_io = CBB_START_32_IO; 147 SYSCTL_ULONG(_hw_cbb, OID_AUTO, start_32_io, CTLFLAG_RWTUN, 148 &cbb_start_32_io, CBB_START_32_IO, 149 "Starting ioport for 32-bit cards"); 150 151 int cbb_debug = 0; 152 SYSCTL_INT(_hw_cbb, OID_AUTO, debug, CTLFLAG_RWTUN, &cbb_debug, 0, 153 "Verbose cardbus bridge debugging"); 154 155 static void cbb_insert(struct cbb_softc *sc); 156 static void cbb_removal(struct cbb_softc *sc); 157 static uint32_t cbb_detect_voltage(device_t brdev); 158 static int cbb_cardbus_reset_power(device_t brdev, device_t child, int on); 159 static int cbb_cardbus_io_open(device_t brdev, int win, uint32_t start, 160 uint32_t end); 161 static int cbb_cardbus_mem_open(device_t brdev, int win, 162 uint32_t start, uint32_t end); 163 static void cbb_cardbus_auto_open(struct cbb_softc *sc, int type); 164 static int cbb_cardbus_activate_resource(device_t brdev, device_t child, 165 int type, int rid, struct resource *res); 166 static int cbb_cardbus_deactivate_resource(device_t brdev, 167 device_t child, int type, int rid, struct resource *res); 168 static struct resource *cbb_cardbus_alloc_resource(device_t brdev, 169 device_t child, int type, int *rid, rman_res_t start, 170 rman_res_t end, rman_res_t count, u_int flags); 171 static int cbb_cardbus_release_resource(device_t brdev, device_t child, 172 int type, int rid, struct resource *res); 173 static int cbb_cardbus_power_enable_socket(device_t brdev, 174 device_t child); 175 static int cbb_cardbus_power_disable_socket(device_t brdev, 176 device_t child); 177 static int cbb_func_filt(void *arg); 178 static void cbb_func_intr(void *arg); 179 180 static void 181 cbb_remove_res(struct cbb_softc *sc, struct resource *res) 182 { 183 struct cbb_reslist *rle; 184 185 SLIST_FOREACH(rle, &sc->rl, link) { 186 if (rle->res == res) { 187 SLIST_REMOVE(&sc->rl, rle, cbb_reslist, link); 188 free(rle, M_DEVBUF); 189 return; 190 } 191 } 192 } 193 194 static struct resource * 195 cbb_find_res(struct cbb_softc *sc, int type, int rid) 196 { 197 struct cbb_reslist *rle; 198 199 SLIST_FOREACH(rle, &sc->rl, link) 200 if (SYS_RES_MEMORY == rle->type && rid == rle->rid) 201 return (rle->res); 202 return (NULL); 203 } 204 205 static void 206 cbb_insert_res(struct cbb_softc *sc, struct resource *res, int type, 207 int rid) 208 { 209 struct cbb_reslist *rle; 210 211 /* 212 * Need to record allocated resource so we can iterate through 213 * it later. 214 */ 215 rle = malloc(sizeof(struct cbb_reslist), M_DEVBUF, M_NOWAIT); 216 if (rle == NULL) 217 panic("cbb_cardbus_alloc_resource: can't record entry!"); 218 rle->res = res; 219 rle->type = type; 220 rle->rid = rid; 221 SLIST_INSERT_HEAD(&sc->rl, rle, link); 222 } 223 224 static void 225 cbb_destroy_res(struct cbb_softc *sc) 226 { 227 struct cbb_reslist *rle; 228 229 while ((rle = SLIST_FIRST(&sc->rl)) != NULL) { 230 device_printf(sc->dev, "Danger Will Robinson: Resource " 231 "left allocated! This is a bug... " 232 "(rid=%x, type=%d, addr=%jx)\n", rle->rid, rle->type, 233 rman_get_start(rle->res)); 234 SLIST_REMOVE_HEAD(&sc->rl, link); 235 free(rle, M_DEVBUF); 236 } 237 } 238 239 /* 240 * Disable function interrupts by telling the bridge to generate IRQ1 241 * interrupts. These interrupts aren't really generated by the chip, since 242 * IRQ1 is reserved. Some chipsets assert INTA# inappropriately during 243 * initialization, so this helps to work around the problem. 244 * 245 * XXX We can't do this workaround for all chipsets, because this 246 * XXX causes interference with the keyboard because somechipsets will 247 * XXX actually signal IRQ1 over their serial interrupt connections to 248 * XXX the south bridge. Disable it it for now. 249 */ 250 void 251 cbb_disable_func_intr(struct cbb_softc *sc) 252 { 253 #if 0 254 uint8_t reg; 255 256 reg = (exca_getb(&sc->exca[0], EXCA_INTR) & ~EXCA_INTR_IRQ_MASK) | 257 EXCA_INTR_IRQ_RESERVED1; 258 exca_putb(&sc->exca[0], EXCA_INTR, reg); 259 #endif 260 } 261 262 /* 263 * Enable function interrupts. We turn on function interrupts when the card 264 * requests an interrupt. The PCMCIA standard says that we should set 265 * the lower 4 bits to 0 to route via PCI. Note: we call this for both 266 * CardBus and R2 (PC Card) cases, but it should have no effect on CardBus 267 * cards. 268 */ 269 static void 270 cbb_enable_func_intr(struct cbb_softc *sc) 271 { 272 uint8_t reg; 273 274 reg = (exca_getb(&sc->exca[0], EXCA_INTR) & ~EXCA_INTR_IRQ_MASK) | 275 EXCA_INTR_IRQ_NONE; 276 exca_putb(&sc->exca[0], EXCA_INTR, reg); 277 PCI_MASK_CONFIG(sc->dev, CBBR_BRIDGECTRL, 278 & ~CBBM_BRIDGECTRL_INTR_IREQ_ISA_EN, 2); 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 retval = 1; 878 done:; 879 if (volts != 0 && sc->chipset == CB_O2MICRO) 880 cbb_o2micro_power_hack2(sc, reg); 881 return (retval); 882 } 883 884 static int 885 cbb_current_voltage(device_t brdev) 886 { 887 struct cbb_softc *sc = device_get_softc(brdev); 888 uint32_t ctrl; 889 890 ctrl = cbb_get(sc, CBB_SOCKET_CONTROL); 891 switch (ctrl & CBB_SOCKET_CTRL_VCCMASK) { 892 case CBB_SOCKET_CTRL_VCC_5V: 893 return CARD_5V_CARD; 894 case CBB_SOCKET_CTRL_VCC_3V: 895 return CARD_3V_CARD; 896 case CBB_SOCKET_CTRL_VCC_XV: 897 return CARD_XV_CARD; 898 case CBB_SOCKET_CTRL_VCC_YV: 899 return CARD_YV_CARD; 900 } 901 return 0; 902 } 903 904 /* 905 * detect the voltage for the card, and set it. Since the power 906 * used is the square of the voltage, lower voltages is a big win 907 * and what Windows does (and what Microsoft prefers). The MS paper 908 * also talks about preferring the CIS entry as well, but that has 909 * to be done elsewhere. We also optimize power sequencing here 910 * and don't change things if we're already powered up at a supported 911 * voltage. 912 * 913 * In addition, we power up with OE disabled. We'll set it later 914 * in the power up sequence. 915 */ 916 static int 917 cbb_do_power(device_t brdev) 918 { 919 struct cbb_softc *sc = device_get_softc(brdev); 920 uint32_t voltage, curpwr; 921 uint32_t status; 922 923 /* Don't enable OE (output enable) until power stable */ 924 exca_clrb(&sc->exca[0], EXCA_PWRCTL, EXCA_PWRCTL_OE); 925 926 voltage = cbb_detect_voltage(brdev); 927 curpwr = cbb_current_voltage(brdev); 928 status = cbb_get(sc, CBB_SOCKET_STATE); 929 if ((status & CBB_STATE_POWER_CYCLE) && (voltage & curpwr)) 930 return 0; 931 /* Prefer lowest voltage supported */ 932 cbb_power(brdev, CARD_OFF); 933 if (voltage & CARD_YV_CARD) 934 cbb_power(brdev, CARD_VCC(YV)); 935 else if (voltage & CARD_XV_CARD) 936 cbb_power(brdev, CARD_VCC(XV)); 937 else if (voltage & CARD_3V_CARD) 938 cbb_power(brdev, CARD_VCC(3)); 939 else if (voltage & CARD_5V_CARD) 940 cbb_power(brdev, CARD_VCC(5)); 941 else { 942 device_printf(brdev, "Unknown card voltage\n"); 943 return (ENXIO); 944 } 945 return (0); 946 } 947 948 /************************************************************************/ 949 /* CardBus power functions */ 950 /************************************************************************/ 951 952 static int 953 cbb_cardbus_reset_power(device_t brdev, device_t child, int on) 954 { 955 struct cbb_softc *sc = device_get_softc(brdev); 956 uint32_t b, h; 957 int delay, count, zero_seen, func; 958 959 /* 960 * Asserting reset for 20ms is necessary for most bridges. For some 961 * reason, the Ricoh RF5C47x bridges need it asserted for 400ms. The 962 * root cause of this is unknown, and NetBSD does the same thing. 963 */ 964 delay = sc->chipset == CB_RF5C47X ? 400 : 20; 965 PCI_MASK_CONFIG(brdev, CBBR_BRIDGECTRL, |CBBM_BRIDGECTRL_RESET, 2); 966 pause("cbbP3", hz * delay / 1000); 967 968 /* 969 * If a card exists and we're turning it on, take it out of reset. 970 * After clearing reset, wait up to 1.1s for the first configuration 971 * register (vendor/product) configuration register of device 0.0 to 972 * become != 0xffffffff. The PCMCIA PC Card Host System Specification 973 * says that when powering up the card, the PCI Spec v2.1 must be 974 * followed. In PCI spec v2.2 Table 4-6, Trhfa (Reset High to first 975 * Config Access) is at most 2^25 clocks, or just over 1s. Section 976 * 2.2.1 states any card not ready to participate in bus transactions 977 * must tristate its outputs. Therefore, any access to its 978 * configuration registers must be ignored. In that state, the config 979 * reg will read 0xffffffff. Section 6.2.1 states a vendor id of 980 * 0xffff is invalid, so this can never match a real card. Print a 981 * warning if it never returns a real id. The PCMCIA PC Card 982 * Electrical Spec Section 5.2.7.1 implies only device 0 is present on 983 * a cardbus bus, so that's the only register we check here. 984 */ 985 if (on && CBB_CARD_PRESENT(cbb_get(sc, CBB_SOCKET_STATE))) { 986 PCI_MASK_CONFIG(brdev, CBBR_BRIDGECTRL, 987 &~CBBM_BRIDGECTRL_RESET, 2); 988 b = pcib_get_bus(child); 989 count = 1100 / 20; 990 do { 991 pause("cbbP4", hz * 2 / 100); 992 } while (PCIB_READ_CONFIG(brdev, b, 0, 0, PCIR_DEVVENDOR, 4) == 993 0xfffffffful && --count >= 0); 994 if (count < 0) 995 device_printf(brdev, "Warning: Bus reset timeout\n"); 996 997 /* 998 * Some cards (so far just an atheros card I have) seem to 999 * come out of reset in a funky state. They report they are 1000 * multi-function cards, but have nonsense for some of the 1001 * higher functions. So if the card claims to be MFDEV, and 1002 * any of the higher functions' ID is 0, then we've hit the 1003 * bug and we'll try again. 1004 */ 1005 h = PCIB_READ_CONFIG(brdev, b, 0, 0, PCIR_HDRTYPE, 1); 1006 if ((h & PCIM_MFDEV) == 0) 1007 return 0; 1008 zero_seen = 0; 1009 for (func = 1; func < 8; func++) { 1010 h = PCIB_READ_CONFIG(brdev, b, 0, func, 1011 PCIR_DEVVENDOR, 4); 1012 if (h == 0) 1013 zero_seen++; 1014 } 1015 if (!zero_seen) 1016 return 0; 1017 return (EINVAL); 1018 } 1019 return 0; 1020 } 1021 1022 static int 1023 cbb_cardbus_power_disable_socket(device_t brdev, device_t child) 1024 { 1025 cbb_power(brdev, CARD_OFF); 1026 cbb_cardbus_reset_power(brdev, child, 0); 1027 return (0); 1028 } 1029 1030 static int 1031 cbb_cardbus_power_enable_socket(device_t brdev, device_t child) 1032 { 1033 struct cbb_softc *sc = device_get_softc(brdev); 1034 int err, count; 1035 1036 if (!CBB_CARD_PRESENT(cbb_get(sc, CBB_SOCKET_STATE))) 1037 return (ENODEV); 1038 1039 count = 10; 1040 do { 1041 err = cbb_do_power(brdev); 1042 if (err) 1043 return (err); 1044 err = cbb_cardbus_reset_power(brdev, child, 1); 1045 if (err) { 1046 device_printf(brdev, "Reset failed, trying again.\n"); 1047 cbb_cardbus_power_disable_socket(brdev, child); 1048 pause("cbbErr1", hz / 10); /* wait 100ms */ 1049 } 1050 } while (err != 0 && count-- > 0); 1051 return (0); 1052 } 1053 1054 /************************************************************************/ 1055 /* CardBus Resource */ 1056 /************************************************************************/ 1057 1058 static void 1059 cbb_activate_window(device_t brdev, int type) 1060 { 1061 1062 PCI_ENABLE_IO(device_get_parent(brdev), brdev, type); 1063 } 1064 1065 static int 1066 cbb_cardbus_io_open(device_t brdev, int win, uint32_t start, uint32_t end) 1067 { 1068 int basereg; 1069 int limitreg; 1070 1071 if ((win < 0) || (win > 1)) { 1072 DEVPRINTF((brdev, 1073 "cbb_cardbus_io_open: window out of range %d\n", win)); 1074 return (EINVAL); 1075 } 1076 1077 basereg = win * 8 + CBBR_IOBASE0; 1078 limitreg = win * 8 + CBBR_IOLIMIT0; 1079 1080 pci_write_config(brdev, basereg, start, 4); 1081 pci_write_config(brdev, limitreg, end, 4); 1082 cbb_activate_window(brdev, SYS_RES_IOPORT); 1083 return (0); 1084 } 1085 1086 static int 1087 cbb_cardbus_mem_open(device_t brdev, int win, uint32_t start, uint32_t end) 1088 { 1089 int basereg; 1090 int limitreg; 1091 1092 if ((win < 0) || (win > 1)) { 1093 DEVPRINTF((brdev, 1094 "cbb_cardbus_mem_open: window out of range %d\n", win)); 1095 return (EINVAL); 1096 } 1097 1098 basereg = win * 8 + CBBR_MEMBASE0; 1099 limitreg = win * 8 + CBBR_MEMLIMIT0; 1100 1101 pci_write_config(brdev, basereg, start, 4); 1102 pci_write_config(brdev, limitreg, end, 4); 1103 cbb_activate_window(brdev, SYS_RES_MEMORY); 1104 return (0); 1105 } 1106 1107 #define START_NONE 0xffffffff 1108 #define END_NONE 0 1109 1110 static void 1111 cbb_cardbus_auto_open(struct cbb_softc *sc, int type) 1112 { 1113 uint32_t starts[2]; 1114 uint32_t ends[2]; 1115 struct cbb_reslist *rle; 1116 int align, i; 1117 uint32_t reg; 1118 1119 starts[0] = starts[1] = START_NONE; 1120 ends[0] = ends[1] = END_NONE; 1121 1122 if (type == SYS_RES_MEMORY) 1123 align = CBB_MEMALIGN; 1124 else if (type == SYS_RES_IOPORT) 1125 align = CBB_IOALIGN; 1126 else 1127 align = 1; 1128 1129 SLIST_FOREACH(rle, &sc->rl, link) { 1130 if (rle->type != type) 1131 continue; 1132 if (rle->res == NULL) 1133 continue; 1134 if (!(rman_get_flags(rle->res) & RF_ACTIVE)) 1135 continue; 1136 if (rman_get_flags(rle->res) & RF_PREFETCHABLE) 1137 i = 1; 1138 else 1139 i = 0; 1140 if (rman_get_start(rle->res) < starts[i]) 1141 starts[i] = rman_get_start(rle->res); 1142 if (rman_get_end(rle->res) > ends[i]) 1143 ends[i] = rman_get_end(rle->res); 1144 } 1145 for (i = 0; i < 2; i++) { 1146 if (starts[i] == START_NONE) 1147 continue; 1148 starts[i] &= ~(align - 1); 1149 ends[i] = roundup2(ends[i], align) - 1; 1150 } 1151 if (starts[0] != START_NONE && starts[1] != START_NONE) { 1152 if (starts[0] < starts[1]) { 1153 if (ends[0] > starts[1]) { 1154 device_printf(sc->dev, "Overlapping ranges" 1155 " for prefetch and non-prefetch memory\n"); 1156 return; 1157 } 1158 } else { 1159 if (ends[1] > starts[0]) { 1160 device_printf(sc->dev, "Overlapping ranges" 1161 " for prefetch and non-prefetch memory\n"); 1162 return; 1163 } 1164 } 1165 } 1166 1167 if (type == SYS_RES_MEMORY) { 1168 cbb_cardbus_mem_open(sc->dev, 0, starts[0], ends[0]); 1169 cbb_cardbus_mem_open(sc->dev, 1, starts[1], ends[1]); 1170 reg = pci_read_config(sc->dev, CBBR_BRIDGECTRL, 2); 1171 reg &= ~(CBBM_BRIDGECTRL_PREFETCH_0 | 1172 CBBM_BRIDGECTRL_PREFETCH_1); 1173 if (starts[1] != START_NONE) 1174 reg |= CBBM_BRIDGECTRL_PREFETCH_1; 1175 pci_write_config(sc->dev, CBBR_BRIDGECTRL, reg, 2); 1176 if (bootverbose) { 1177 device_printf(sc->dev, "Opening memory:\n"); 1178 if (starts[0] != START_NONE) 1179 device_printf(sc->dev, "Normal: %#x-%#x\n", 1180 starts[0], ends[0]); 1181 if (starts[1] != START_NONE) 1182 device_printf(sc->dev, "Prefetch: %#x-%#x\n", 1183 starts[1], ends[1]); 1184 } 1185 } else if (type == SYS_RES_IOPORT) { 1186 cbb_cardbus_io_open(sc->dev, 0, starts[0], ends[0]); 1187 cbb_cardbus_io_open(sc->dev, 1, starts[1], ends[1]); 1188 if (bootverbose && starts[0] != START_NONE) 1189 device_printf(sc->dev, "Opening I/O: %#x-%#x\n", 1190 starts[0], ends[0]); 1191 } 1192 } 1193 1194 static int 1195 cbb_cardbus_activate_resource(device_t brdev, device_t child, int type, 1196 int rid, struct resource *res) 1197 { 1198 int ret; 1199 1200 ret = BUS_ACTIVATE_RESOURCE(device_get_parent(brdev), child, 1201 type, rid, res); 1202 if (ret != 0) 1203 return (ret); 1204 cbb_cardbus_auto_open(device_get_softc(brdev), type); 1205 return (0); 1206 } 1207 1208 static int 1209 cbb_cardbus_deactivate_resource(device_t brdev, device_t child, int type, 1210 int rid, struct resource *res) 1211 { 1212 int ret; 1213 1214 ret = BUS_DEACTIVATE_RESOURCE(device_get_parent(brdev), child, 1215 type, rid, res); 1216 if (ret != 0) 1217 return (ret); 1218 cbb_cardbus_auto_open(device_get_softc(brdev), type); 1219 return (0); 1220 } 1221 1222 static struct resource * 1223 cbb_cardbus_alloc_resource(device_t brdev, device_t child, int type, 1224 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 1225 { 1226 struct cbb_softc *sc = device_get_softc(brdev); 1227 int tmp; 1228 struct resource *res; 1229 rman_res_t align; 1230 1231 switch (type) { 1232 case SYS_RES_IRQ: 1233 tmp = rman_get_start(sc->irq_res); 1234 if (start > tmp || end < tmp || count != 1) { 1235 device_printf(child, "requested interrupt %jd-%jd," 1236 "count = %jd not supported by cbb\n", 1237 start, end, count); 1238 return (NULL); 1239 } 1240 start = end = tmp; 1241 flags |= RF_SHAREABLE; 1242 break; 1243 case SYS_RES_IOPORT: 1244 if (start <= cbb_start_32_io) 1245 start = cbb_start_32_io; 1246 if (end < start) 1247 end = start; 1248 if (count > (1 << RF_ALIGNMENT(flags))) 1249 flags = (flags & ~RF_ALIGNMENT_MASK) | 1250 rman_make_alignment_flags(count); 1251 break; 1252 case SYS_RES_MEMORY: 1253 if (start <= cbb_start_mem) 1254 start = cbb_start_mem; 1255 if (end < start) 1256 end = start; 1257 if (count < CBB_MEMALIGN) 1258 align = CBB_MEMALIGN; 1259 else 1260 align = count; 1261 if (align > (1 << RF_ALIGNMENT(flags))) 1262 flags = (flags & ~RF_ALIGNMENT_MASK) | 1263 rman_make_alignment_flags(align); 1264 break; 1265 } 1266 res = BUS_ALLOC_RESOURCE(device_get_parent(brdev), child, type, rid, 1267 start, end, count, flags & ~RF_ACTIVE); 1268 if (res == NULL) { 1269 printf("cbb alloc res fail type %d rid %x\n", type, *rid); 1270 return (NULL); 1271 } 1272 cbb_insert_res(sc, res, type, *rid); 1273 if (flags & RF_ACTIVE) 1274 if (bus_activate_resource(child, type, *rid, res) != 0) { 1275 bus_release_resource(child, type, *rid, res); 1276 return (NULL); 1277 } 1278 1279 return (res); 1280 } 1281 1282 static int 1283 cbb_cardbus_release_resource(device_t brdev, device_t child, int type, 1284 int rid, struct resource *res) 1285 { 1286 struct cbb_softc *sc = device_get_softc(brdev); 1287 int error; 1288 1289 if (rman_get_flags(res) & RF_ACTIVE) { 1290 error = bus_deactivate_resource(child, type, rid, res); 1291 if (error != 0) 1292 return (error); 1293 } 1294 cbb_remove_res(sc, res); 1295 return (BUS_RELEASE_RESOURCE(device_get_parent(brdev), child, 1296 type, rid, res)); 1297 } 1298 1299 /************************************************************************/ 1300 /* PC Card Power Functions */ 1301 /************************************************************************/ 1302 1303 static int 1304 cbb_pcic_power_enable_socket(device_t brdev, device_t child) 1305 { 1306 struct cbb_softc *sc = device_get_softc(brdev); 1307 int err; 1308 1309 DPRINTF(("cbb_pcic_socket_enable:\n")); 1310 1311 /* power down/up the socket to reset */ 1312 err = cbb_do_power(brdev); 1313 if (err) 1314 return (err); 1315 exca_reset(&sc->exca[0], child); 1316 1317 return (0); 1318 } 1319 1320 static int 1321 cbb_pcic_power_disable_socket(device_t brdev, device_t child) 1322 { 1323 struct cbb_softc *sc = device_get_softc(brdev); 1324 1325 DPRINTF(("cbb_pcic_socket_disable\n")); 1326 1327 /* Turn off the card's interrupt and leave it in reset, wait 10ms */ 1328 exca_putb(&sc->exca[0], EXCA_INTR, 0); 1329 pause("cbbP1", hz / 100); 1330 1331 /* power down the socket */ 1332 cbb_power(brdev, CARD_OFF); 1333 exca_putb(&sc->exca[0], EXCA_PWRCTL, 0); 1334 1335 /* wait 300ms until power fails (Tpf). */ 1336 pause("cbbP2", hz * 300 / 1000); 1337 1338 /* enable CSC interrupts */ 1339 exca_putb(&sc->exca[0], EXCA_INTR, EXCA_INTR_ENABLE); 1340 return (0); 1341 } 1342 1343 /************************************************************************/ 1344 /* POWER methods */ 1345 /************************************************************************/ 1346 1347 int 1348 cbb_power_enable_socket(device_t brdev, device_t child) 1349 { 1350 struct cbb_softc *sc = device_get_softc(brdev); 1351 1352 if (sc->flags & CBB_16BIT_CARD) 1353 return (cbb_pcic_power_enable_socket(brdev, child)); 1354 return (cbb_cardbus_power_enable_socket(brdev, child)); 1355 } 1356 1357 int 1358 cbb_power_disable_socket(device_t brdev, device_t child) 1359 { 1360 struct cbb_softc *sc = device_get_softc(brdev); 1361 if (sc->flags & CBB_16BIT_CARD) 1362 return (cbb_pcic_power_disable_socket(brdev, child)); 1363 return (cbb_cardbus_power_disable_socket(brdev, child)); 1364 } 1365 1366 static int 1367 cbb_pcic_activate_resource(device_t brdev, device_t child, int type, int rid, 1368 struct resource *res) 1369 { 1370 struct cbb_softc *sc = device_get_softc(brdev); 1371 int error; 1372 1373 error = exca_activate_resource(&sc->exca[0], child, type, rid, res); 1374 if (error == 0) 1375 cbb_activate_window(brdev, type); 1376 return (error); 1377 } 1378 1379 static int 1380 cbb_pcic_deactivate_resource(device_t brdev, device_t child, int type, 1381 int rid, struct resource *res) 1382 { 1383 struct cbb_softc *sc = device_get_softc(brdev); 1384 return (exca_deactivate_resource(&sc->exca[0], child, type, rid, res)); 1385 } 1386 1387 static struct resource * 1388 cbb_pcic_alloc_resource(device_t brdev, device_t child, int type, int *rid, 1389 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 1390 { 1391 struct resource *res = NULL; 1392 struct cbb_softc *sc = device_get_softc(brdev); 1393 int align; 1394 int tmp; 1395 1396 switch (type) { 1397 case SYS_RES_MEMORY: 1398 if (start < cbb_start_mem) 1399 start = cbb_start_mem; 1400 if (end < start) 1401 end = start; 1402 if (count < CBB_MEMALIGN) 1403 align = CBB_MEMALIGN; 1404 else 1405 align = count; 1406 if (align > (1 << RF_ALIGNMENT(flags))) 1407 flags = (flags & ~RF_ALIGNMENT_MASK) | 1408 rman_make_alignment_flags(align); 1409 break; 1410 case SYS_RES_IOPORT: 1411 if (start < cbb_start_16_io) 1412 start = cbb_start_16_io; 1413 if (end < start) 1414 end = start; 1415 break; 1416 case SYS_RES_IRQ: 1417 tmp = rman_get_start(sc->irq_res); 1418 if (start > tmp || end < tmp || count != 1) { 1419 device_printf(child, "requested interrupt %jd-%jd," 1420 "count = %jd not supported by cbb\n", 1421 start, end, count); 1422 return (NULL); 1423 } 1424 flags |= RF_SHAREABLE; 1425 start = end = rman_get_start(sc->irq_res); 1426 break; 1427 } 1428 res = BUS_ALLOC_RESOURCE(device_get_parent(brdev), child, type, rid, 1429 start, end, count, flags & ~RF_ACTIVE); 1430 if (res == NULL) 1431 return (NULL); 1432 cbb_insert_res(sc, res, type, *rid); 1433 if (flags & RF_ACTIVE) { 1434 if (bus_activate_resource(child, type, *rid, res) != 0) { 1435 bus_release_resource(child, type, *rid, res); 1436 return (NULL); 1437 } 1438 } 1439 1440 return (res); 1441 } 1442 1443 static int 1444 cbb_pcic_release_resource(device_t brdev, device_t child, int type, 1445 int rid, struct resource *res) 1446 { 1447 struct cbb_softc *sc = device_get_softc(brdev); 1448 int error; 1449 1450 if (rman_get_flags(res) & RF_ACTIVE) { 1451 error = bus_deactivate_resource(child, type, rid, res); 1452 if (error != 0) 1453 return (error); 1454 } 1455 cbb_remove_res(sc, res); 1456 return (BUS_RELEASE_RESOURCE(device_get_parent(brdev), child, 1457 type, rid, res)); 1458 } 1459 1460 /************************************************************************/ 1461 /* PC Card methods */ 1462 /************************************************************************/ 1463 1464 int 1465 cbb_pcic_set_res_flags(device_t brdev, device_t child, int type, int rid, 1466 u_long flags) 1467 { 1468 struct cbb_softc *sc = device_get_softc(brdev); 1469 struct resource *res; 1470 1471 if (type != SYS_RES_MEMORY) 1472 return (EINVAL); 1473 res = cbb_find_res(sc, type, rid); 1474 if (res == NULL) { 1475 device_printf(brdev, 1476 "set_res_flags: specified rid not found\n"); 1477 return (ENOENT); 1478 } 1479 return (exca_mem_set_flags(&sc->exca[0], res, flags)); 1480 } 1481 1482 int 1483 cbb_pcic_set_memory_offset(device_t brdev, device_t child, int rid, 1484 uint32_t cardaddr, uint32_t *deltap) 1485 { 1486 struct cbb_softc *sc = device_get_softc(brdev); 1487 struct resource *res; 1488 1489 res = cbb_find_res(sc, SYS_RES_MEMORY, rid); 1490 if (res == NULL) { 1491 device_printf(brdev, 1492 "set_memory_offset: specified rid not found\n"); 1493 return (ENOENT); 1494 } 1495 return (exca_mem_set_offset(&sc->exca[0], res, cardaddr, deltap)); 1496 } 1497 1498 /************************************************************************/ 1499 /* BUS Methods */ 1500 /************************************************************************/ 1501 1502 1503 int 1504 cbb_activate_resource(device_t brdev, device_t child, int type, int rid, 1505 struct resource *r) 1506 { 1507 struct cbb_softc *sc = device_get_softc(brdev); 1508 1509 if (sc->flags & CBB_16BIT_CARD) 1510 return (cbb_pcic_activate_resource(brdev, child, type, rid, r)); 1511 else 1512 return (cbb_cardbus_activate_resource(brdev, child, type, rid, 1513 r)); 1514 } 1515 1516 int 1517 cbb_deactivate_resource(device_t brdev, device_t child, int type, 1518 int rid, struct resource *r) 1519 { 1520 struct cbb_softc *sc = device_get_softc(brdev); 1521 1522 if (sc->flags & CBB_16BIT_CARD) 1523 return (cbb_pcic_deactivate_resource(brdev, child, type, 1524 rid, r)); 1525 else 1526 return (cbb_cardbus_deactivate_resource(brdev, child, type, 1527 rid, r)); 1528 } 1529 1530 struct resource * 1531 cbb_alloc_resource(device_t brdev, device_t child, int type, int *rid, 1532 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 1533 { 1534 struct cbb_softc *sc = device_get_softc(brdev); 1535 1536 if (sc->flags & CBB_16BIT_CARD) 1537 return (cbb_pcic_alloc_resource(brdev, child, type, rid, 1538 start, end, count, flags)); 1539 else 1540 return (cbb_cardbus_alloc_resource(brdev, child, type, rid, 1541 start, end, count, flags)); 1542 } 1543 1544 int 1545 cbb_release_resource(device_t brdev, device_t child, int type, int rid, 1546 struct resource *r) 1547 { 1548 struct cbb_softc *sc = device_get_softc(brdev); 1549 1550 if (sc->flags & CBB_16BIT_CARD) 1551 return (cbb_pcic_release_resource(brdev, child, type, 1552 rid, r)); 1553 else 1554 return (cbb_cardbus_release_resource(brdev, child, type, 1555 rid, r)); 1556 } 1557 1558 int 1559 cbb_read_ivar(device_t brdev, device_t child, int which, uintptr_t *result) 1560 { 1561 struct cbb_softc *sc = device_get_softc(brdev); 1562 1563 switch (which) { 1564 case PCIB_IVAR_DOMAIN: 1565 *result = sc->domain; 1566 return (0); 1567 case PCIB_IVAR_BUS: 1568 *result = sc->bus.sec; 1569 return (0); 1570 } 1571 return (ENOENT); 1572 } 1573 1574 int 1575 cbb_write_ivar(device_t brdev, device_t child, int which, uintptr_t value) 1576 { 1577 1578 switch (which) { 1579 case PCIB_IVAR_DOMAIN: 1580 return (EINVAL); 1581 case PCIB_IVAR_BUS: 1582 return (EINVAL); 1583 } 1584 return (ENOENT); 1585 } 1586 1587 int 1588 cbb_child_present(device_t parent, device_t child) 1589 { 1590 struct cbb_softc *sc = (struct cbb_softc *)device_get_softc(parent); 1591 uint32_t sockstate; 1592 1593 sockstate = cbb_get(sc, CBB_SOCKET_STATE); 1594 return (CBB_CARD_PRESENT(sockstate) && sc->cardok); 1595 } 1596