arch/i386/pci/mmconfig.c

   1 /*
   2  * Copyright (C) 2004 Matthew Wilcox <matthew@wil.cx>
   3  * Copyright (C) 2004 Intel Corp.
   4  *
   5  * This code is released under the GNU General Public License version 2.
   6  */
   7
   8 /*
   9  * mmconfig.c - Low-level direct PCI config space access via MMCONFIG
  10  */
  11
  12 #include <linux/pci.h>
  13 #include <linux/init.h>
  14 #include <linux/acpi.h>
  15 #include <asm/e820.h>
  16 #include "pci.h"
  17
  18 /* aperture is up to 256MB but BIOS may reserve less */
  19 #define MMCONFIG_APER_MIN       (2 * 1024*1024)
  20 #define MMCONFIG_APER_MAX       (256 * 1024*1024)
  21
  22 /* Assume systems with more busses have correct MCFG */
  23 #define MAX_CHECK_BUS 16
  24
  25 #define mmcfg_virt_addr ((void __iomem *) fix_to_virt(FIX_PCIE_MCFG))
  26
  27 /* The base address of the last MMCONFIG device accessed */
  28 static u32 mmcfg_last_accessed_device;
  29
  30 static DECLARE_BITMAP(fallback_slots, MAX_CHECK_BUS*32);
  31
  32 /*
  33  * Functions for accessing PCI configuration space with MMCONFIG accesses
  34  */
  35 static u32 get_base_addr(unsigned int seg, int bus, unsigned devfn)
  36 {
  37         int cfg_num = -1;
  38         struct acpi_table_mcfg_config *cfg;
  39
  40         if (seg == 0 && bus < MAX_CHECK_BUS &&
  41             test_bit(PCI_SLOT(devfn) + 32*bus, fallback_slots))
  42                 return 0;
  43
  44         while (1) {
  45                 ++cfg_num;
  46                 if (cfg_num >= pci_mmcfg_config_num) {
  47                         break;
  48                 }
  49                 cfg = &pci_mmcfg_config[cfg_num];
  50                 if (cfg->pci_segment_group_number != seg)
  51                         continue;
  52                 if ((cfg->start_bus_number <= bus) &&
  53                     (cfg->end_bus_number >= bus))
  54                         return cfg->base_address;
  55         }
  56
  57         /* Handle more broken MCFG tables on Asus etc.
  58            They only contain a single entry for bus 0-0. Assume
  59            this applies to all busses. */
  60         cfg = &pci_mmcfg_config[0];
  61         if (pci_mmcfg_config_num == 1 &&
  62                 cfg->pci_segment_group_number == 0 &&
  63                 (cfg->start_bus_number | cfg->end_bus_number) == 0)
  64                 return cfg->base_address;
  65
  66         /* Fall back to type 0 */
  67         return 0;
  68 }
  69
  70 static inline void pci_exp_set_dev_base(unsigned int base, int bus, int devfn)
  71 {
  72         u32 dev_base = base | (bus << 20) | (devfn << 12);
  73         if (dev_base != mmcfg_last_accessed_device) {
  74                 mmcfg_last_accessed_device = dev_base;
  75                 set_fixmap_nocache(FIX_PCIE_MCFG, dev_base);
  76         }
  77 }
  78
  79 static int pci_mmcfg_read(unsigned int seg, unsigned int bus,
  80                           unsigned int devfn, int reg, int len, u32 *value)
  81 {
  82         unsigned long flags;
  83         u32 base;
  84
  85         if ((bus > 255) || (devfn > 255) || (reg > 4095)) {
  86                 *value = -1;
  87                 return -EINVAL;
  88         }
  89
  90         base = get_base_addr(seg, bus, devfn);
  91         if (!base)
  92                 return pci_conf1_read(seg,bus,devfn,reg,len,value);
  93
  94         spin_lock_irqsave(&pci_config_lock, flags);
  95
  96         pci_exp_set_dev_base(base, bus, devfn);
  97
  98         switch (len) {
  99         case 1:
 100                 *value = readb(mmcfg_virt_addr + reg);
 101                 break;
 102         case 2:
 103                 *value = readw(mmcfg_virt_addr + reg);
 104                 break;
 105         case 4:
 106                 *value = readl(mmcfg_virt_addr + reg);
 107                 break;
 108         }
 109
 110         spin_unlock_irqrestore(&pci_config_lock, flags);
 111
 112         return 0;
 113 }
 114
 115 static int pci_mmcfg_write(unsigned int seg, unsigned int bus,
 116                            unsigned int devfn, int reg, int len, u32 value)
 117 {
 118         unsigned long flags;
 119         u32 base;
 120
 121         if ((bus > 255) || (devfn > 255) || (reg > 4095))
 122                 return -EINVAL;
 123
 124         base = get_base_addr(seg, bus, devfn);
 125         if (!base)
 126                 return pci_conf1_write(seg,bus,devfn,reg,len,value);
 127
 128         spin_lock_irqsave(&pci_config_lock, flags);
 129
 130         pci_exp_set_dev_base(base, bus, devfn);
 131
 132         switch (len) {
 133         case 1:
 134                 writeb(value, mmcfg_virt_addr + reg);
 135                 break;
 136         case 2:
 137                 writew(value, mmcfg_virt_addr + reg);
 138                 break;
 139         case 4:
 140                 writel(value, mmcfg_virt_addr + reg);
 141                 break;
 142         }
 143
 144         spin_unlock_irqrestore(&pci_config_lock, flags);
 145
 146         return 0;
 147 }
 148
 149 static struct pci_raw_ops pci_mmcfg = {
 150         .read =         pci_mmcfg_read,
 151         .write =        pci_mmcfg_write,
 152 };
 153
 154
 155 static __init void pci_mmcfg_insert_resources(void)
 156 {
 157 #define PCI_MMCFG_RESOURCE_NAME_LEN 19
 158         int i;
 159         struct resource *res;
 160         char *names;
 161         unsigned num_buses;
 162
 163         res = kcalloc(PCI_MMCFG_RESOURCE_NAME_LEN + sizeof(*res),
 164                         pci_mmcfg_config_num, GFP_KERNEL);
 165
 166         if (!res) {
 167                 printk(KERN_ERR "PCI: Unable to allocate MMCONFIG resources\n");
 168                 return;
 169         }
 170
 171         names = (void *)&res[pci_mmcfg_config_num];
 172         for (i = 0; i < pci_mmcfg_config_num; i++, res++) {
 173                 num_buses = pci_mmcfg_config[i].end_bus_number -
 174                     pci_mmcfg_config[i].start_bus_number + 1;
 175                 res->name = names;
 176                 snprintf(names, PCI_MMCFG_RESOURCE_NAME_LEN, "PCI MMCONFIG %u",
 177                         pci_mmcfg_config[i].pci_segment_group_number);
 178                 res->start = pci_mmcfg_config[i].base_address;
 179                 res->end = res->start + (num_buses << 20) - 1;
 180                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 181                 insert_resource(&iomem_resource, res);
 182                 names += PCI_MMCFG_RESOURCE_NAME_LEN;
 183         }
 184 }
 185
 186 /* K8 systems have some devices (typically in the builtin northbridge)
 187    that are only accessible using type1
 188    Normally this can be expressed in the MCFG by not listing them
 189    and assigning suitable _SEGs, but this isn't implemented in some BIOS.
 190    Instead try to discover all devices on bus 0 that are unreachable using MM
 191    and fallback for them. */
 192 static __init void unreachable_devices(void)
 193 {
 194         int i, k;
 195         unsigned long flags;
 196
 197         for (k = 0; k < MAX_CHECK_BUS; k++) {
 198                 for (i = 0; i < 32; i++) {
 199                         u32 val1;
 200                         u32 addr;
 201
 202                         pci_conf1_read(0, k, PCI_DEVFN(i, 0), 0, 4, &val1);
 203                         if (val1 == 0xffffffff)
 204                                 continue;
 205
 206                         /* Locking probably not needed, but safer */
 207                         spin_lock_irqsave(&pci_config_lock, flags);
 208                         addr = get_base_addr(0, k, PCI_DEVFN(i, 0));
 209                         if (addr != 0)
 210                                 pci_exp_set_dev_base(addr, k, PCI_DEVFN(i, 0));
 211                         if (addr == 0 ||
 212                             readl((u32 __iomem *)mmcfg_virt_addr) != val1) {
 213                                 set_bit(i + 32*k, fallback_slots);
 214                                 printk(KERN_NOTICE
 215                         "PCI: No mmconfig possible on %x:%x\n", k, i);
 216                         }
 217                         spin_unlock_irqrestore(&pci_config_lock, flags);
 218                 }
 219         }
 220 }
 221
 222
 223
 224 void __init pci_mmcfg_init(int type)
 225 {
 226         if ((pci_probe & PCI_PROBE_MMCONF) == 0)
 227                 return;
 228
 229         acpi_table_parse(ACPI_MCFG, acpi_parse_mcfg);
 230         if ((pci_mmcfg_config_num == 0) ||
 231             (pci_mmcfg_config == NULL) ||
 232             (pci_mmcfg_config[0].base_address == 0))
 233                 return;
 234
 235         /* Only do this check when type 1 works. If it doesn't work
 236            assume we run on a Mac and always use MCFG */
 237         if (type == 1 && !e820_all_mapped(pci_mmcfg_config[0].base_address,
 238                         pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
 239                         E820_RESERVED)) {
 240                 printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
 241                                 pci_mmcfg_config[0].base_address);
 242                 printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
 243                 return;
 244         }
 245
 246         printk(KERN_INFO "PCI: Using MMCONFIG\n");
 247         raw_pci_ops = &pci_mmcfg;
 248         pci_probe = (pci_probe & ~PCI_PROBE_MASK) | PCI_PROBE_MMCONF;
 249
 250         unreachable_devices();
 251         pci_mmcfg_insert_resources();
 252 }