/* $NetBSD: cardbus_map.c,v 1.36 2010/03/15 19:48:31 dyoung Exp $ */ /* * Copyright (c) 1999 and 2000 * HAYAKAWA Koichi. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: cardbus_map.c,v 1.36 2010/03/15 19:48:31 dyoung Exp $"); #include #include #include #include #include #include /* XXX */ #if defined DEBUG && !defined CARDBUS_MAP_DEBUG #define CARDBUS_MAP_DEBUG #endif #if defined CARDBUS_MAP_DEBUG #define STATIC #define DPRINTF(a) printf a #else #define STATIC static #define DPRINTF(a) #endif static int cardbus_io_find(cardbus_chipset_tag_t, cardbus_function_tag_t, pcitag_t, int, pcireg_t, bus_addr_t *, bus_size_t *, int *); static int cardbus_mem_find(cardbus_chipset_tag_t, cardbus_function_tag_t, pcitag_t, int, pcireg_t, bus_addr_t *, bus_size_t *, int *); /* * static int cardbus_io_find(cardbus_chipset_tag_t cc, * cardbus_function_tag_t cf, pcitag_t tag, * int reg, pcireg_t type, bus_addr_t *basep, * bus_size_t *sizep, int *flagsp) * This code is stolen from sys/dev/pci_map.c. */ static int cardbus_io_find( cardbus_chipset_tag_t cc, cardbus_function_tag_t cf, pcitag_t tag, int reg, pcireg_t type, bus_addr_t *basep, bus_size_t *sizep, int *flagsp) { pcireg_t address, mask; int s; /* EXT ROM is able to map on memory space ONLY. */ if (reg == CARDBUS_ROM_REG) { return 1; } if(reg < PCI_MAPREG_START || reg >= PCI_MAPREG_END || (reg & 3)) { panic("cardbus_io_find: bad request"); } /* * Section 6.2.5.1, `Address Maps', tells us that: * * 1) The builtin software should have already mapped the device in a * reasonable way. * * 2) A device which wants 2^n bytes of memory will hardwire the bottom * n bits of the address to 0. As recommended, we write all 1s and see * what we get back. */ s = splhigh(); address = cardbus_conf_read(cc, cf, tag, reg); cardbus_conf_write(cc, cf, tag, reg, 0xffffffff); mask = cardbus_conf_read(cc, cf, tag, reg); cardbus_conf_write(cc, cf, tag, reg, address); splx(s); if (PCI_MAPREG_TYPE(address) != PCI_MAPREG_TYPE_IO) { printf("cardbus_io_find: expected type i/o, found mem\n"); return 1; } if (PCI_MAPREG_IO_SIZE(mask) == 0) { printf("cardbus_io_find: void region\n"); return 1; } if (basep != 0) { *basep = PCI_MAPREG_IO_ADDR(address); } if (sizep != 0) { *sizep = PCI_MAPREG_IO_SIZE(mask); } if (flagsp != 0) { *flagsp = 0; } return 0; } /* * static int cardbus_mem_find(cardbus_chipset_tag_t cc, * cardbus_function_tag_t cf, pcitag_t tag, * int reg, pcireg_t type, bus_addr_t *basep, * bus_size_t *sizep, int *flagsp) * This code is stolen from sys/dev/pci_map.c. */ static int cardbus_mem_find(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf, pcitag_t tag, int reg, pcireg_t type, bus_addr_t *basep, bus_size_t *sizep, int *flagsp) { pcireg_t address, mask; int s; if (reg != CARDBUS_ROM_REG && (reg < PCI_MAPREG_START || reg >= PCI_MAPREG_END || (reg & 3))) { panic("cardbus_mem_find: bad request"); } /* * Section 6.2.5.1, `Address Maps', tells us that: * * 1) The builtin software should have already mapped the device in a * reasonable way. * * 2) A device which wants 2^n bytes of memory will hardwire the bottom * n bits of the address to 0. As recommended, we write all 1s and see * what we get back. */ s = splhigh(); address = cardbus_conf_read(cc, cf, tag, reg); cardbus_conf_write(cc, cf, tag, reg, 0xffffffff); mask = cardbus_conf_read(cc, cf, tag, reg); cardbus_conf_write(cc, cf, tag, reg, address); splx(s); if (reg != CARDBUS_ROM_REG) { /* memory space BAR */ if (PCI_MAPREG_TYPE(address) != PCI_MAPREG_TYPE_MEM) { printf("cardbus_mem_find: expected type mem, found i/o\n"); return 1; } if (PCI_MAPREG_MEM_TYPE(address) != PCI_MAPREG_MEM_TYPE(type)) { printf("cardbus_mem_find: expected mem type %08x, found %08x\n", PCI_MAPREG_MEM_TYPE(type), PCI_MAPREG_MEM_TYPE(address)); return 1; } } if (PCI_MAPREG_MEM_SIZE(mask) == 0) { printf("cardbus_mem_find: void region\n"); return 1; } switch (PCI_MAPREG_MEM_TYPE(address)) { case PCI_MAPREG_MEM_TYPE_32BIT: case PCI_MAPREG_MEM_TYPE_32BIT_1M: break; case PCI_MAPREG_MEM_TYPE_64BIT: printf("cardbus_mem_find: 64-bit memory mapping register\n"); return 1; default: printf("cardbus_mem_find: reserved mapping register type\n"); return 1; } if (basep != 0) { *basep = PCI_MAPREG_MEM_ADDR(address); } if (sizep != 0) { *sizep = PCI_MAPREG_MEM_SIZE(mask); } if (flagsp != 0) { *flagsp = PCI_MAPREG_MEM_PREFETCHABLE(address) ? BUS_SPACE_MAP_PREFETCHABLE : 0; } return 0; } /* * int cardbus_mapreg_map(struct cardbus_softc *, int, int, pcireg_t, * int bus_space_tag_t *, bus_space_handle_t *, * bus_addr_t *, bus_size_t *) * This function maps bus-space on the value of Base Address * Register (BAR) indexed by the argument `reg' (the second argument). * When the value of the BAR is not valid, such as 0x00000000, a new * address should be allocated for the BAR and new address values is * written on the BAR. */ int cardbus_mapreg_map(struct cardbus_softc *sc, int func, int reg, pcireg_t type, int busflags, bus_space_tag_t *tagp, bus_space_handle_t *handlep, bus_addr_t *basep, bus_size_t *sizep) { cardbus_chipset_tag_t cc = sc->sc_cc; cardbus_function_tag_t cf = sc->sc_cf; bus_space_tag_t bustag; rbus_tag_t rbustag; bus_space_handle_t handle; bus_addr_t base; bus_size_t size; int flags; int status = 0; pcitag_t tag; size = 0; /* XXX gcc */ flags = 0; /* XXX gcc */ tag = cardbus_make_tag(cc, cf, sc->sc_bus, func); DPRINTF(("cardbus_mapreg_map called: %s %x\n", device_xname(sc->sc_dev), type)); if (PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_IO) { if (cardbus_io_find(cc, cf, tag, reg, type, &base, &size, &flags)) { status = 1; } bustag = sc->sc_iot; rbustag = sc->sc_rbus_iot; } else { if (cardbus_mem_find(cc, cf, tag, reg, type, &base, &size, &flags)){ status = 1; } bustag = sc->sc_memt; rbustag = sc->sc_rbus_memt; } if (status == 0) { bus_addr_t mask = size - 1; if (base != 0) { mask = 0xffffffff; } if ((*cf->cardbus_space_alloc)(cc, rbustag, base, size, mask, size, busflags | flags, &base, &handle)) { panic("io alloc"); } } cardbus_conf_write(cc, cf, tag, reg, base); DPRINTF(("cardbus_mapreg_map: physaddr %lx\n", (unsigned long)base)); if (tagp != 0) { *tagp = bustag; } if (handlep != 0) { *handlep = handle; } if (basep != 0) { *basep = base; } if (sizep != 0) { *sizep = size; } return 0; } /* * int cardbus_mapreg_unmap(struct cardbus_softc *sc, int func, int reg, * bus_space_tag_t tag, bus_space_handle_t handle, * bus_size_t size) * * This function releases bus-space region and close memory or io * window on the bridge. * * Arguments: * struct cardbus_softc *sc; the pointer to the device structure of cardbus. * int func; the number of function on the device. * int reg; the offset of BAR register. */ int cardbus_mapreg_unmap(struct cardbus_softc *sc, int func, int reg, bus_space_tag_t tag, bus_space_handle_t handle, bus_size_t size) { cardbus_chipset_tag_t cc = sc->sc_cc; cardbus_function_tag_t cf = sc->sc_cf; int st = 1; pcitag_t cardbustag; rbus_tag_t rbustag; if (sc->sc_iot == tag) { /* bus space is io space */ DPRINTF(("%s: unmap i/o space\n", device_xname(sc->sc_dev))); rbustag = sc->sc_rbus_iot; } else if (sc->sc_memt == tag) { /* bus space is memory space */ DPRINTF(("%s: unmap mem space\n", device_xname(sc->sc_dev))); rbustag = sc->sc_rbus_memt; } else { return 1; } cardbustag = cardbus_make_tag(cc, cf, sc->sc_bus, func); cardbus_conf_write(cc, cf, cardbustag, reg, 0); (*cf->cardbus_space_free)(cc, rbustag, handle, size); return st; }