root/arch/i386/pci/pci_addr_fixup.c

DEFINITIONS

1. pci_addr_fixup
2. pciaddr_resource_reserve
3. pciaddr_resource_reserve_disabled
4. pciaddr_resource_allocate
5. pciaddr_resource_manage
6. pciaddr_do_resource_allocate
7. pciaddr_do_resource_reserve
8. pciaddr_do_resource_reserve_disabled
9. pciaddr_ioaddr
10. pciaddr_print_devid
11. pciaddr_device_is_agp
12. pciaddr_search

    1 /*      $OpenBSD: pci_addr_fixup.c,v 1.21 2007/02/20 21:15:01 tom Exp $ */
    2 /*      $NetBSD: pci_addr_fixup.c,v 1.7 2000/08/03 20:10:45 nathanw Exp $       */
    4 /*-
    5  * Copyright (c) 2000 UCHIYAMA Yasushi.  All rights reserved.
    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  * 3. The name of the author may not be used to endorse or promote products
   16  *    derived from this software without specific prior written permission.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   28  */
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/malloc.h>
   33 #include <sys/kernel.h>
   34 #include <sys/device.h>
   35 #include <sys/extent.h>
   37 #include <uvm/uvm_extern.h>
   39 #include <machine/bus.h>
   41 #include <dev/pci/pcireg.h>
   42 #include <dev/pci/pcivar.h>
   43 #include <dev/pci/pcidevs.h>
   45 #include <i386/pci/pcibiosvar.h>
   47 typedef int (*pciaddr_resource_manage_func_t)(struct pcibios_softc *, pci_chipset_tag_t, pcitag_t, int,
   48         struct extent *, int, bus_addr_t *, bus_size_t);
   49 void    pciaddr_resource_manage(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t, pciaddr_resource_manage_func_t);
   51 void    pciaddr_resource_reserve(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t);
   53 void    pciaddr_resource_reserve_disabled(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t);
   55 int     pciaddr_do_resource_reserve(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t, int, struct extent *, int,
bus_addr_t *, bus_size_t);
   58 int     pciaddr_do_resource_reserve_disabled(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t, int, struct extent *, int, u_long *,
bus_size_t);
   61 void    pciaddr_resource_allocate(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t);
   63 int     pciaddr_do_resource_allocate(struct pcibios_softc *,
pci_chipset_tag_t, pcitag_t, int, struct extent *, int, bus_addr_t *,
bus_size_t);
bus_addr_t pciaddr_ioaddr(u_int32_t);
   67 void    pciaddr_print_devid(pci_chipset_tag_t, pcitag_t);
   69 int     pciaddr_device_is_agp(pci_chipset_tag_t, pcitag_t);
   71 #define PCIADDR_MEM_START       0x0
   72 #define PCIADDR_MEM_END         0xffffffff
   73 #define PCIADDR_PORT_START      0x0
   74 #define PCIADDR_PORT_END        0xffff
   76 /* for ISA devices */
   77 #define PCIADDR_ISAPORT_RESERVE 0x5800 /* empirical value */
   78 #define PCIADDR_ISAMEM_RESERVE  (16 * 1024 * 1024)
   80 void
pci_addr_fixup(struct pcibios_softc *sc, pci_chipset_tag_t pc, int maxbus)
   82 {
   83         extern paddr_t avail_end;
   84         const char *verbose_header = 
   85                 "[%s]-----------------------\n"
   86                 "  device vendor product\n"
   87                 "  register space address    size\n"
   88                 "--------------------------------------------\n";
   89         const char *verbose_footer = 
   90                 "--------------------------[%3d devices bogus]\n";
   92         const struct {
bus_addr_t start;
bus_size_t size;
   95                 char *name;
   96         } system_reserve [] = {
   97                 { 0xfec00000, 0x100000, "I/O APIC" },
   98                 { 0xfee00000, 0x100000, "Local APIC" },
   99                 { 0xfffe0000, 0x20000, "BIOS PROM" },
  100                 { 0, 0, 0 }, /* terminator */
  101         }, *srp;
paddr_t start;
  103         int error;
sc->extent_mem = extent_create("PCI I/O memory space",
PCIADDR_MEM_START, PCIADDR_MEM_END, M_DEVBUF, 0, 0, EX_NOWAIT);
KASSERT(sc->extent_mem);
sc->extent_port = extent_create("PCI I/O port space",
PCIADDR_PORT_START, PCIADDR_PORT_END, M_DEVBUF, 0, 0, EX_NOWAIT);
KASSERT(sc->extent_port);
  112         /* 
  113          * 1. check & reserve system BIOS setting.
  114          */
PCIBIOS_PRINTV((verbose_header, "System BIOS Setting"));
pci_device_foreach(sc, pc, maxbus, pciaddr_resource_reserve);
pci_device_foreach(sc, pc, maxbus, pciaddr_resource_reserve_disabled);
PCIBIOS_PRINTV((verbose_footer, sc->nbogus));
  120         /* 
  121          * 2. reserve non-PCI area.
  122          */
  123         for (srp = system_reserve; srp->size; srp++) {
error = extent_alloc_region(sc->extent_mem, srp->start,
srp->size, EX_NOWAIT| EX_MALLOCOK); 
  126                 if (error != 0)
printf("WARNING: can't reserve area for %s.\n",
srp->name);
  129         }
  131         /* 
  132          * 3. determine allocation space 
  133          */
start = round_page(avail_end + 1);
  135         if (start < PCIADDR_ISAMEM_RESERVE)
start = PCIADDR_ISAMEM_RESERVE;
sc->mem_alloc_start = (start + 0x100000 + 1) & ~(0x100000 - 1);
sc->port_alloc_start = PCIADDR_ISAPORT_RESERVE;
PCIBIOS_PRINTV((" Physical memory end: 0x%08x\n PCI memory mapped I/O "
  140             "space start: 0x%08x\n", avail_end, sc->mem_alloc_start));
  142         /* 
  143          * 4. do fixup 
  144          */
PCIBIOS_PRINTV((verbose_header, "PCIBIOS fixup stage"));
sc->nbogus = 0;
pci_device_foreach(sc, pc, maxbus, pciaddr_resource_allocate);
PCIBIOS_PRINTV((verbose_footer, sc->nbogus));
  150 }
  152 void
pciaddr_resource_reserve(struct pcibios_softc *sc, pci_chipset_tag_t pc,
pcitag_t tag)
  155 {
  156         if (pcibios_flags & PCIBIOS_VERBOSE)
pciaddr_print_devid(pc, tag);
pciaddr_resource_manage(sc, pc, tag, pciaddr_do_resource_reserve);
  159 }
  161 void
pciaddr_resource_reserve_disabled(struct pcibios_softc *sc,
pci_chipset_tag_t pc, pcitag_t tag)
  164 {
  165         if (pcibios_flags & PCIBIOS_VERBOSE)
pciaddr_print_devid(pc, tag);
pciaddr_resource_manage(sc, pc, tag,
pciaddr_do_resource_reserve_disabled);
  169 }
  171 void
pciaddr_resource_allocate(struct pcibios_softc *sc, pci_chipset_tag_t pc,
pcitag_t tag)
  174 {
  175         if (pcibios_flags & PCIBIOS_VERBOSE)
pciaddr_print_devid(pc, tag);
pciaddr_resource_manage(sc, pc, tag, pciaddr_do_resource_allocate);
  178 }
  180 void
pciaddr_resource_manage(struct pcibios_softc *sc, pci_chipset_tag_t pc,
pcitag_t tag, pciaddr_resource_manage_func_t func)
  183 {
  184         struct extent *ex;
pcireg_t val, mask;
bus_addr_t addr;
bus_size_t size;
  188         int error, mapreg, type, reg_start, reg_end, width;
val = pci_conf_read(pc, tag, PCI_BHLC_REG);
  191         switch (PCI_HDRTYPE_TYPE(val)) {
  192         default:
printf("WARNING: unknown PCI device header 0x%x.\n",
PCI_HDRTYPE_TYPE(val));
sc->nbogus++;
  196                 return;
  197         case 0: 
reg_start = PCI_MAPREG_START;
reg_end   = PCI_MAPREG_END;
  200                 break;
  201         case 1: /* PCI-PCI bridge */
reg_start = PCI_MAPREG_START;
reg_end   = PCI_MAPREG_PPB_END;
  204                 break;
  205         case 2: /* PCI-CardBus bridge */
reg_start = PCI_MAPREG_START;
reg_end   = PCI_MAPREG_PCB_END;
  208                 break;
  209         }
error = 0;
  212         for (mapreg = reg_start; mapreg < reg_end; mapreg += width) {
  213                 /* inquire PCI device bus space requirement */
val = pci_conf_read(pc, tag, mapreg);
pci_conf_write(pc, tag, mapreg, ~0);
mask = pci_conf_read(pc, tag, mapreg);
pci_conf_write(pc, tag, mapreg, val);
type = PCI_MAPREG_TYPE(val);
width = 4;
  222                 if (type == PCI_MAPREG_TYPE_MEM) {
  223                         if (PCI_MAPREG_MEM_TYPE(val) == 
PCI_MAPREG_MEM_TYPE_64BIT) {
  225                                 /* XXX We could examine the upper 32 bits
  226                                  * XXX of the BAR here, but we are totally 
  227                                  * XXX unprepared to handle a non-zero value, 
  228                                  * XXX either here or anywhere else in 
  229                                  * XXX i386-land. 
  230                                  * XXX So just arrange to not look at the
  231                                  * XXX upper 32 bits, lest we misinterpret
  232                                  * XXX it as a 32-bit BAR set to zero. 
  233                                  */
width = 8;
  235                         }
addr = PCI_MAPREG_MEM_ADDR(val);
size = PCI_MAPREG_MEM_SIZE(mask);
ex = sc->extent_mem;
  239                 } else {
  240                         /* XXX some devices give 32bit value */
addr = PCI_MAPREG_IO_ADDR(val) & PCIADDR_PORT_END;
size = PCI_MAPREG_IO_SIZE(mask);
ex = sc->extent_port;
  244                 }
  246                 if (!size) /* unused register */
  247                         continue;
  249                 /* reservation/allocation phase */
error += (*func) (sc, pc, tag, mapreg, ex, type, &addr, size);
PCIBIOS_PRINTV(("\t%02xh %s 0x%08x 0x%08x\n", 
mapreg, type ? "port" : "mem ", 
  254                                 (unsigned int)addr, (unsigned int)size));
  255         }
  257         if (error)
sc->nbogus++;
PCIBIOS_PRINTV(("\t\t[%s]\n", error ? "NG" : "OK"));
  261 }
  263 int
pciaddr_do_resource_allocate(struct pcibios_softc *sc, pci_chipset_tag_t pc,
pcitag_t tag, int mapreg, struct extent *ex, int type, bus_addr_t *addr,
bus_size_t size)
  267 {
bus_addr_t start;
  269         int error;
  271         if (*addr) /* no need to allocate */
  272                 return (0);
  274         /* XXX Don't allocate if device is AGP device to avoid conflict. */
  275         if (pciaddr_device_is_agp(pc, tag)) 
  276                 return (0);
start = (type == PCI_MAPREG_TYPE_MEM ? sc->mem_alloc_start
  279                 : sc->port_alloc_start);
  280         if (start < ex->ex_start || start + size - 1 >= ex->ex_end) {
PCIBIOS_PRINTV(("No available resources. fixup failed\n"));
  282                 return (1);
  283         }
error = extent_alloc_subregion(ex, start, ex->ex_end, size, size, 0, 0,
EX_FAST|EX_NOWAIT|EX_MALLOCOK, addr);
  286         if (error) {
PCIBIOS_PRINTV(("No available resources. fixup failed\n"));
  288                 return (1);
  289         }
  291         /* write new address to PCI device configuration header */
pci_conf_write(pc, tag, mapreg, *addr);
  293         /* check */
  294         if (pcibios_flags & PCIBIOS_VERBOSE) {
printf("pci_addr_fixup: ");
pciaddr_print_devid(pc, tag);
  297         }
  299         if (pciaddr_ioaddr(pci_conf_read(pc, tag, mapreg)) != *addr) {
pci_conf_write(pc, tag, mapreg, 0); /* clear */
PCIBIOS_PRINTV(("fixup failed. (new address=%#x)\n", *addr));
  302                 return (1);
  303         }
PCIBIOS_PRINTV(("new address 0x%08x\n", *addr));
  306         return (0);
  307 }
  309 int
pciaddr_do_resource_reserve(struct pcibios_softc *sc, pci_chipset_tag_t pc,
pcitag_t tag, int mapreg, struct extent *ex, int type, bus_addr_t *addr,
bus_size_t size)
  313 {
pcireg_t val;
  315         int error;
  317         if (*addr == 0)
  318                 return (0);
val = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
  321         if (type == PCI_MAPREG_TYPE_MEM &&
  322             (val & PCI_COMMAND_MEM_ENABLE) != PCI_COMMAND_MEM_ENABLE)
  323                 return (0);
  324         if (type == PCI_MAPREG_TYPE_IO &&
  325             (val & PCI_COMMAND_IO_ENABLE) != PCI_COMMAND_IO_ENABLE)
  326                 return (0);
error = extent_alloc_region(ex, *addr, size, EX_NOWAIT | EX_MALLOCOK);
  329         if (error) {
PCIBIOS_PRINTV(("Resource conflict.\n"));
pci_conf_write(pc, tag, mapreg, 0); /* clear */
  332                 return (1);
  333         }
  335         return (0);
  336 }
  338 int
pciaddr_do_resource_reserve_disabled(struct pcibios_softc *sc,
pci_chipset_tag_t pc, pcitag_t tag, int mapreg, struct extent *ex, int type,
u_long *addr, bus_size_t size)
  342 {
pcireg_t val;
  344         int error;
  346         if (*addr == 0)
  347                 return (0);
val = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
  350         if (type == PCI_MAPREG_TYPE_MEM &&
  351             (val & PCI_COMMAND_MEM_ENABLE) == PCI_COMMAND_MEM_ENABLE)
  352                 return (0);
  353         if (type == PCI_MAPREG_TYPE_IO &&
  354             (val & PCI_COMMAND_IO_ENABLE) == PCI_COMMAND_IO_ENABLE)
  355                 return (0);
PCIBIOS_PRINTV(("disabled %s space at addr 0x%x size 0x%x\n",
type == PCI_MAPREG_TYPE_MEM ? "mem" : "io", *addr, size));
error = extent_alloc_region(ex, *addr, size, EX_NOWAIT | EX_MALLOCOK);
  361         if (error) {
PCIBIOS_PRINTV(("Resource conflict.\n"));
pci_conf_write(pc, tag, mapreg, 0); /* clear */
  364                 return (1);
  365         }
  367         return (0);
  368 }
bus_addr_t
pciaddr_ioaddr(u_int32_t val)
  372 {
  373         return ((PCI_MAPREG_TYPE(val) == PCI_MAPREG_TYPE_MEM)
  374                 ? PCI_MAPREG_MEM_ADDR(val)
  375                 : (PCI_MAPREG_IO_ADDR(val) & PCIADDR_PORT_END));
  376 }
  378 void
pciaddr_print_devid(pci_chipset_tag_t pc, pcitag_t tag)
  380 {
  381         int bus, device, function;      
pcireg_t id;
id = pci_conf_read(pc, tag, PCI_ID_REG);
pci_decompose_tag(pc, tag, &bus, &device, &function);
printf("%03d:%02d:%d %04x:%04x\n", bus, device, function, 
PCI_VENDOR(id), PCI_PRODUCT(id));
  388 }
  390 int
pciaddr_device_is_agp(pci_chipset_tag_t pc, pcitag_t tag)
  392 {
pcireg_t class, status, rval;
  394         int off;
  396         /* Check AGP device. */
class = pci_conf_read(pc, tag, PCI_CLASS_REG);
  398         if (PCI_CLASS(class) == PCI_CLASS_DISPLAY) {
status = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
  400                 if (status & PCI_STATUS_CAPLIST_SUPPORT) {
rval = pci_conf_read(pc, tag, PCI_CAPLISTPTR_REG);
  402                         for (off = PCI_CAPLIST_PTR(rval);
off != 0;
off = PCI_CAPLIST_NEXT(rval) ) {
rval = pci_conf_read(pc, tag, off);
  406                                 if (PCI_CAPLIST_CAP(rval) == PCI_CAP_AGP) 
  407                                         return (1);
  408                         }
  409                 }
  410         }
  411         return (0);
  412 }
  415 struct extent *
pciaddr_search(int mem_port, bus_addr_t *startp, bus_size_t size)
  417 {
  418         extern struct cfdriver pcibios_cd;
  419         struct pcibios_softc *sc;
sc = (struct pcibios_softc *)device_lookup(&pcibios_cd, 0);
  422         if (sc && !(pcibios_flags & PCIBIOS_ADDR_FIXUP)) {
  423                 struct extent_region *rp;
  424                 struct extent *ex = mem_port? sc->extent_mem : sc->extent_port;
  426                 /* Search the PCI I/O memory space extent for free
  427                  * space that will accommodate size.  Remember that the
  428                  * extent stores allocated space and we're searching
  429                  * for the gaps.
  430                  *
  431                  * If we're at the end or the gap between this region
  432                  * and the next region big enough, then we're done
  433                  */
  434                 for (rp = LIST_FIRST(&ex->ex_regions);
rp && *startp + size > rp->er_start;
rp = LIST_NEXT(rp, er_link)) {
bus_addr_t new_start;
new_start = (rp->er_end - 1 + size) & ~(size - 1);
  440                         if (new_start > *startp)
  441                                 *startp = new_start;
  442                 }
  444                 return (ex);
  445         }
  447         return (NULL);
  448 }