Annotation of sys/dev/cardbus/cardbus_map.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: cardbus_map.c,v 1.7 2006/07/31 11:06:27 mickey Exp $ */
! 2: /* $NetBSD: cardbus_map.c,v 1.10 2000/03/07 00:31:46 mycroft Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1999 and 2000
! 6: * HAYAKAWA Koichi. 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: * 3. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed by HAYAKAWA Koichi.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission.
! 21: *
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 33: * POSSIBILITY OF SUCH DAMAGE.
! 34: */
! 35:
! 36:
! 37: #include <sys/param.h>
! 38: #include <sys/systm.h>
! 39: #include <sys/device.h>
! 40:
! 41: #include <machine/bus.h>
! 42:
! 43: #include <dev/cardbus/cardbusvar.h>
! 44:
! 45: #include <dev/pci/pcireg.h> /* XXX */
! 46:
! 47: #if defined DEBUG && !defined CARDBUS_MAP_DEBUG
! 48: #define CARDBUS_MAP_DEBUG
! 49: #endif
! 50:
! 51: #if defined CARDBUS_MAP_DEBUG
! 52: #define STATIC
! 53: #define DPRINTF(a) printf a
! 54: #else
! 55: #define STATIC static
! 56: #define DPRINTF(a)
! 57: #endif
! 58:
! 59:
! 60: static int cardbus_io_find(cardbus_chipset_tag_t, cardbus_function_tag_t,
! 61: cardbustag_t, int, cardbusreg_t, bus_addr_t *, bus_size_t *,
! 62: int *);
! 63: static int cardbus_mem_find(cardbus_chipset_tag_t, cardbus_function_tag_t,
! 64: cardbustag_t, int, cardbusreg_t, bus_addr_t *, bus_size_t *,
! 65: int *);
! 66:
! 67: int
! 68: cardbus_mapreg_probe(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf,
! 69: cardbustag_t tag, int reg, pcireg_t *typep)
! 70: {
! 71: pcireg_t address, mask;
! 72: int s;
! 73:
! 74: s = splhigh();
! 75: address = cardbus_conf_read(cc, cf, tag, reg);
! 76: cardbus_conf_write(cc, cf, tag, reg, 0xffffffff);
! 77: mask = cardbus_conf_read(cc, cf, tag, reg);
! 78: cardbus_conf_write(cc, cf, tag, reg, address);
! 79: splx(s);
! 80:
! 81: if (mask == 0) /* unimplemented mapping register */
! 82: return (0);
! 83:
! 84: if (typep)
! 85: *typep = _PCI_MAPREG_TYPEBITS(address);
! 86: return (1);
! 87: }
! 88:
! 89: /*
! 90: * static int cardbus_io_find(cardbus_chipset_tag_t cc,
! 91: * cardbus_function_tag_t cf, cardbustag_t tag,
! 92: * int reg, cardbusreg_t type, bus_addr_t *basep,
! 93: * bus_size_t *sizep, int *flagsp)
! 94: * This code is stolen from sys/dev/pci_map.c.
! 95: */
! 96: static int
! 97: cardbus_io_find(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf,
! 98: cardbustag_t tag, int reg, cardbusreg_t type, bus_addr_t *basep,
! 99: bus_size_t *sizep, int *flagsp)
! 100: {
! 101: cardbusreg_t address, mask;
! 102: int s;
! 103:
! 104: /* EXT ROM is able to map on memory space ONLY. */
! 105: if (reg == CARDBUS_ROM_REG)
! 106: return (1);
! 107:
! 108: if (reg < PCI_MAPREG_START || reg >= PCI_MAPREG_END || (reg & 3)) {
! 109: panic("cardbus_io_find: bad request");
! 110: }
! 111:
! 112: /*
! 113: * Section 6.2.5.1, `Address Maps', tells us that:
! 114: *
! 115: * 1) The builtin software should have already mapped the device in a
! 116: * reasonable way.
! 117: *
! 118: * 2) A device which wants 2^n bytes of memory will hardwire the bottom
! 119: * n bits of the address to 0. As recommended, we write all 1s and see
! 120: * what we get back.
! 121: */
! 122: s = splhigh();
! 123: address = cardbus_conf_read(cc, cf, tag, reg);
! 124: cardbus_conf_write(cc, cf, tag, reg, 0xffffffff);
! 125: mask = cardbus_conf_read(cc, cf, tag, reg);
! 126: cardbus_conf_write(cc, cf, tag, reg, address);
! 127: splx(s);
! 128:
! 129: if (PCI_MAPREG_TYPE(address) != PCI_MAPREG_TYPE_IO) {
! 130: printf("cardbus_io_find: expected type i/o, found mem\n");
! 131: return (1);
! 132: }
! 133:
! 134: if (PCI_MAPREG_IO_SIZE(mask) == 0) {
! 135: printf("cardbus_io_find: void region\n");
! 136: return (1);
! 137: }
! 138:
! 139: if (basep != 0)
! 140: *basep = PCI_MAPREG_IO_ADDR(address);
! 141: if (sizep != 0)
! 142: *sizep = PCI_MAPREG_IO_SIZE(mask);
! 143: if (flagsp != 0)
! 144: *flagsp = 0;
! 145:
! 146: return (0);
! 147: }
! 148:
! 149: /*
! 150: * static int cardbus_mem_find(cardbus_chipset_tag_t cc,
! 151: * cardbus_function_tag_t cf, cardbustag_t tag,
! 152: * int reg, cardbusreg_t type, bus_addr_t *basep,
! 153: * bus_size_t *sizep, int *flagsp)
! 154: * This code is stolen from sys/dev/pci_map.c.
! 155: */
! 156: static int
! 157: cardbus_mem_find(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf,
! 158: cardbustag_t tag, int reg, cardbusreg_t type, bus_addr_t *basep,
! 159: bus_size_t *sizep, int *flagsp)
! 160: {
! 161: cardbusreg_t address, mask;
! 162: int s;
! 163:
! 164: if (reg != CARDBUS_ROM_REG &&
! 165: (reg < PCI_MAPREG_START || reg >= PCI_MAPREG_END || (reg & 3))) {
! 166: panic("cardbus_mem_find: bad request");
! 167: }
! 168:
! 169: /*
! 170: * Section 6.2.5.1, `Address Maps', tells us that:
! 171: *
! 172: * 1) The builtin software should have already mapped the device in a
! 173: * reasonable way.
! 174: *
! 175: * 2) A device which wants 2^n bytes of memory will hardwire the bottom
! 176: * n bits of the address to 0. As recommended, we write all 1s and see
! 177: * what we get back.
! 178: */
! 179: s = splhigh();
! 180: address = cardbus_conf_read(cc, cf, tag, reg);
! 181: cardbus_conf_write(cc, cf, tag, reg, 0xffffffff);
! 182: mask = cardbus_conf_read(cc, cf, tag, reg);
! 183: cardbus_conf_write(cc, cf, tag, reg, address);
! 184: splx(s);
! 185:
! 186: if (reg != CARDBUS_ROM_REG) {
! 187: /* memory space BAR */
! 188:
! 189: if (PCI_MAPREG_TYPE(address) != PCI_MAPREG_TYPE_MEM) {
! 190: printf("cardbus_mem_find: expected type mem, "
! 191: "found i/o\n");
! 192: return (1);
! 193: }
! 194: if (PCI_MAPREG_MEM_TYPE(address) != PCI_MAPREG_MEM_TYPE(type)) {
! 195: printf("cardbus_mem_find: expected mem type %08x, "
! 196: "found %08x\n", PCI_MAPREG_MEM_TYPE(type),
! 197: PCI_MAPREG_MEM_TYPE(address));
! 198: return (1);
! 199: }
! 200: }
! 201:
! 202: if (PCI_MAPREG_MEM_SIZE(mask) == 0) {
! 203: printf("cardbus_mem_find: void region\n");
! 204: return (1);
! 205: }
! 206:
! 207: switch (PCI_MAPREG_MEM_TYPE(address)) {
! 208: case PCI_MAPREG_MEM_TYPE_32BIT:
! 209: case PCI_MAPREG_MEM_TYPE_32BIT_1M:
! 210: break;
! 211: case PCI_MAPREG_MEM_TYPE_64BIT:
! 212: printf("cardbus_mem_find: 64-bit memory mapping register\n");
! 213: return (1);
! 214: default:
! 215: printf("cardbus_mem_find: reserved mapping register type\n");
! 216: return (1);
! 217: }
! 218:
! 219: if (basep != 0)
! 220: *basep = PCI_MAPREG_MEM_ADDR(address);
! 221: if (sizep != 0)
! 222: *sizep = PCI_MAPREG_MEM_SIZE(mask);
! 223: if (flagsp != 0) {
! 224: *flagsp =
! 225: #ifdef BUS_SPACE_MAP_PREFETCHABLE
! 226: PCI_MAPREG_MEM_PREFETCHABLE(address) ?
! 227: BUS_SPACE_MAP_PREFETCHABLE :
! 228: #endif
! 229: 0;
! 230: }
! 231:
! 232: return (0);
! 233: }
! 234:
! 235: /*
! 236: * int cardbus_mapreg_map(struct cardbus_softc *, int, int, cardbusreg_t,
! 237: * int bus_space_tag_t *, bus_space_handle_t *,
! 238: * bus_addr_t *, bus_size_t *)
! 239: * This function maps bus-space on the value of Base Address
! 240: * Register (BAR) indexed by the argument `reg' (the second argument).
! 241: * When the value of the BAR is not valid, such as 0x00000000, a new
! 242: * address should be allocated for the BAR and new address values is
! 243: * written on the BAR.
! 244: */
! 245: int
! 246: cardbus_mapreg_map(struct cardbus_softc *sc, int func, int reg,
! 247: cardbusreg_t type, int busflags, bus_space_tag_t *tagp,
! 248: bus_space_handle_t *handlep, bus_addr_t *basep, bus_size_t *sizep)
! 249: {
! 250: cardbus_chipset_tag_t cc = sc->sc_cc;
! 251: cardbus_function_tag_t cf = sc->sc_cf;
! 252: bus_space_tag_t bustag;
! 253: rbus_tag_t rbustag;
! 254: bus_space_handle_t handle;
! 255: bus_addr_t base;
! 256: bus_size_t size;
! 257: int flags;
! 258: int status = 0;
! 259:
! 260: cardbustag_t tag = cardbus_make_tag(cc, cf, sc->sc_bus,
! 261: sc->sc_device, func);
! 262:
! 263: DPRINTF(("cardbus_mapreg_map called: %s %x\n", sc->sc_dev.dv_xname,
! 264: type));
! 265:
! 266: if (PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_IO) {
! 267: if (cardbus_io_find(cc, cf, tag, reg, type, &base, &size,
! 268: &flags))
! 269: status = 1;
! 270: bustag = sc->sc_iot;
! 271: rbustag = sc->sc_rbus_iot;
! 272: } else {
! 273: if (cardbus_mem_find(cc, cf, tag, reg, type, &base, &size,
! 274: &flags))
! 275: status = 1;
! 276: bustag = sc->sc_memt;
! 277: rbustag = sc->sc_rbus_memt;
! 278: }
! 279: if (status == 0) {
! 280: bus_addr_t mask = size - 1;
! 281: if (base != 0)
! 282: mask = 0xffffffff;
! 283: if ((*cf->cardbus_space_alloc)(cc, rbustag, base, size, mask,
! 284: size, busflags | flags, &base, &handle)) {
! 285: panic("io alloc");
! 286: }
! 287: }
! 288: cardbus_conf_write(cc, cf, tag, reg, base);
! 289:
! 290: DPRINTF(("cardbus_mapreg_map: physaddr %lx\n", (unsigned long)base));
! 291:
! 292: if (tagp != 0)
! 293: *tagp = bustag;
! 294: if (handlep != 0)
! 295: *handlep = handle;
! 296: if (basep != 0)
! 297: *basep = base;
! 298: if (sizep != 0)
! 299: *sizep = size;
! 300: cardbus_free_tag(cc, cf, tag);
! 301:
! 302: return (0);
! 303: }
! 304:
! 305: /*
! 306: * int cardbus_mapreg_unmap(struct cardbus_softc *sc, int func, int reg,
! 307: * bus_space_tag_t tag, bus_space_handle_t handle,
! 308: * bus_size_t size)
! 309: *
! 310: * This function releases bus-space region and close memory or io
! 311: * window on the bridge.
! 312: *
! 313: * Arguments:
! 314: * struct cardbus_softc *sc; the pointer to the device structure of cardbus.
! 315: * int func; the number of function on the device.
! 316: * int reg; the offset of BAR register.
! 317: */
! 318: int
! 319: cardbus_mapreg_unmap(struct cardbus_softc *sc, int func, int reg,
! 320: bus_space_tag_t tag, bus_space_handle_t handle, bus_size_t size)
! 321: {
! 322: cardbus_chipset_tag_t cc = sc->sc_cc;
! 323: cardbus_function_tag_t cf = sc->sc_cf;
! 324: int st = 1;
! 325: cardbustag_t cardbustag;
! 326: rbus_tag_t rbustag;
! 327:
! 328: if (sc->sc_iot == tag) {
! 329: /* bus space is io space */
! 330: DPRINTF(("%s: unmap i/o space\n", sc->sc_dev.dv_xname));
! 331: rbustag = sc->sc_rbus_iot;
! 332: } else if (sc->sc_memt == tag) {
! 333: /* bus space is memory space */
! 334: DPRINTF(("%s: unmap mem space\n", sc->sc_dev.dv_xname));
! 335: rbustag = sc->sc_rbus_memt;
! 336: } else
! 337: return (1);
! 338:
! 339: cardbustag = cardbus_make_tag(cc, cf, sc->sc_bus, sc->sc_device, func);
! 340:
! 341: cardbus_conf_write(cc, cf, cardbustag, reg, 0);
! 342:
! 343: (*cf->cardbus_space_free)(cc, rbustag, handle, size);
! 344:
! 345: cardbus_free_tag(cc, cf, cardbustag);
! 346:
! 347: return (st);
! 348: }
! 349:
! 350: /*
! 351: * int cardbus_save_bar(cardbus_devfunc_t);
! 352: *
! 353: * This function saves the Base Address Registers at the CardBus
! 354: * function denoted by the argument.
! 355: */
! 356: int
! 357: cardbus_save_bar(cardbus_devfunc_t ct)
! 358: {
! 359: cardbustag_t tag = Cardbus_make_tag(ct);
! 360: cardbus_chipset_tag_t cc = ct->ct_cc;
! 361: cardbus_function_tag_t cf = ct->ct_cf;
! 362:
! 363: ct->ct_bar[0] = cardbus_conf_read(cc, cf, tag, CARDBUS_BASE0_REG);
! 364: ct->ct_bar[1] = cardbus_conf_read(cc, cf, tag, CARDBUS_BASE1_REG);
! 365: ct->ct_bar[2] = cardbus_conf_read(cc, cf, tag, CARDBUS_BASE2_REG);
! 366: ct->ct_bar[3] = cardbus_conf_read(cc, cf, tag, CARDBUS_BASE3_REG);
! 367: ct->ct_bar[4] = cardbus_conf_read(cc, cf, tag, CARDBUS_BASE4_REG);
! 368: ct->ct_bar[5] = cardbus_conf_read(cc, cf, tag, CARDBUS_BASE5_REG);
! 369:
! 370: DPRINTF(("cardbus_save_bar: %x %x\n", ct->ct_bar[0], ct->ct_bar[1]));
! 371:
! 372: Cardbus_free_tag(ct, tag);
! 373:
! 374: return (0);
! 375: }
! 376:
! 377: /*
! 378: * int cardbus_restore_bar(cardbus_devfunc_t);
! 379: *
! 380: * This function saves the Base Address Registers at the CardBus
! 381: * function denoted by the argument.
! 382: */
! 383: int
! 384: cardbus_restore_bar(cardbus_devfunc_t ct)
! 385: {
! 386: cardbustag_t tag = Cardbus_make_tag(ct);
! 387: cardbus_chipset_tag_t cc = ct->ct_cc;
! 388: cardbus_function_tag_t cf = ct->ct_cf;
! 389:
! 390: cardbus_conf_write(cc, cf, tag, CARDBUS_BASE0_REG, ct->ct_bar[0]);
! 391: cardbus_conf_write(cc, cf, tag, CARDBUS_BASE1_REG, ct->ct_bar[1]);
! 392: cardbus_conf_write(cc, cf, tag, CARDBUS_BASE2_REG, ct->ct_bar[2]);
! 393: cardbus_conf_write(cc, cf, tag, CARDBUS_BASE3_REG, ct->ct_bar[3]);
! 394: cardbus_conf_write(cc, cf, tag, CARDBUS_BASE4_REG, ct->ct_bar[4]);
! 395: cardbus_conf_write(cc, cf, tag, CARDBUS_BASE5_REG, ct->ct_bar[5]);
! 396:
! 397: Cardbus_free_tag(ct, tag);
! 398:
! 399: return (0);
! 400: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cardbus_map.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / cardbus