LXR linux/arch/x86/pci/acpi.c

   1// SPDX-License-Identifier: GPL-2.0
   2#include <linux/pci.h>
   3#include <linux/acpi.h>
   4#include <linux/init.h>
   5#include <linux/irq.h>
   6#include <linux/dmi.h>
   7#include <linux/slab.h>
   8#include <linux/pci-acpi.h>
   9#include <asm/numa.h>
  10#include <asm/pci_x86.h>
  11
  12struct pci_root_info {
  13        struct acpi_pci_root_info common;
  14        struct pci_sysdata sd;
  15#ifdef  CONFIG_PCI_MMCONFIG
  16        bool mcfg_added;
  17        u8 start_bus;
  18        u8 end_bus;
  19#endif
  20};
  21
  22static bool pci_use_crs = true;
  23static bool pci_ignore_seg = false;
  24
  25static int __init set_use_crs(const struct dmi_system_id *id)
  26{
  27        pci_use_crs = true;
  28        return 0;
  29}
  30
  31static int __init set_nouse_crs(const struct dmi_system_id *id)
  32{
  33        pci_use_crs = false;
  34        return 0;
  35}
  36
  37static int __init set_ignore_seg(const struct dmi_system_id *id)
  38{
  39        printk(KERN_INFO "PCI: %s detected: ignoring ACPI _SEG\n", id->ident);
  40        pci_ignore_seg = true;
  41        return 0;
  42}
  43
  44static const struct dmi_system_id pci_crs_quirks[] __initconst = {
  45        /* http://bugzilla.kernel.org/show_bug.cgi?id=14183 */
  46        {
  47                .callback = set_use_crs,
  48                .ident = "IBM System x3800",
  49                .matches = {
  50                        DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
  51                        DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
  52                },
  53        },
  54        /* https://bugzilla.kernel.org/show_bug.cgi?id=16007 */
  55        /* 2006 AMD HT/VIA system with two host bridges */
  56        {
  57                .callback = set_use_crs,
  58                .ident = "ASRock ALiveSATA2-GLAN",
  59                .matches = {
  60                        DMI_MATCH(DMI_PRODUCT_NAME, "ALiveSATA2-GLAN"),
  61                },
  62        },
  63        /* https://bugzilla.kernel.org/show_bug.cgi?id=30552 */
  64        /* 2006 AMD HT/VIA system with two host bridges */
  65        {
  66                .callback = set_use_crs,
  67                .ident = "ASUS M2V-MX SE",
  68                .matches = {
  69                        DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
  70                        DMI_MATCH(DMI_BOARD_NAME, "M2V-MX SE"),
  71                        DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
  72                },
  73        },
  74        /* https://bugzilla.kernel.org/show_bug.cgi?id=42619 */
  75        {
  76                .callback = set_use_crs,
  77                .ident = "MSI MS-7253",
  78                .matches = {
  79                        DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
  80                        DMI_MATCH(DMI_BOARD_NAME, "MS-7253"),
  81                        DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
  82                },
  83        },
  84        /* https://bugs.launchpad.net/ubuntu/+source/alsa-driver/+bug/931368 */
  85        /* https://bugs.launchpad.net/ubuntu/+source/alsa-driver/+bug/1033299 */
  86        {
  87                .callback = set_use_crs,
  88                .ident = "Foxconn K8M890-8237A",
  89                .matches = {
  90                        DMI_MATCH(DMI_BOARD_VENDOR, "Foxconn"),
  91                        DMI_MATCH(DMI_BOARD_NAME, "K8M890-8237A"),
  92                        DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
  93                },
  94        },
  95
  96        /* Now for the blacklist.. */
  97
  98        /* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */
  99        {
 100                .callback = set_nouse_crs,
 101                .ident = "Dell Studio 1557",
 102                .matches = {
 103                        DMI_MATCH(DMI_BOARD_VENDOR, "Dell Inc."),
 104                        DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1557"),
 105                        DMI_MATCH(DMI_BIOS_VERSION, "A09"),
 106                },
 107        },
 108        /* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */
 109        {
 110                .callback = set_nouse_crs,
 111                .ident = "Thinkpad SL510",
 112                .matches = {
 113                        DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
 114                        DMI_MATCH(DMI_BOARD_NAME, "2847DFG"),
 115                        DMI_MATCH(DMI_BIOS_VERSION, "6JET85WW (1.43 )"),
 116                },
 117        },
 118        /* https://bugzilla.kernel.org/show_bug.cgi?id=42606 */
 119        {
 120                .callback = set_nouse_crs,
 121                .ident = "Supermicro X8DTH",
 122                .matches = {
 123                        DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
 124                        DMI_MATCH(DMI_PRODUCT_NAME, "X8DTH-i/6/iF/6F"),
 125                        DMI_MATCH(DMI_BIOS_VERSION, "2.0a"),
 126                },
 127        },
 128
 129        /* https://bugzilla.kernel.org/show_bug.cgi?id=15362 */
 130        {
 131                .callback = set_ignore_seg,
 132                .ident = "HP xw9300",
 133                .matches = {
 134                        DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 135                        DMI_MATCH(DMI_PRODUCT_NAME, "HP xw9300 Workstation"),
 136                },
 137        },
 138        {}
 139};
 140
 141void __init pci_acpi_crs_quirks(void)
 142{
 143        int year = dmi_get_bios_year();
 144
 145        if (year >= 0 && year < 2008 && iomem_resource.end <= 0xffffffff)
 146                pci_use_crs = false;
 147
 148        dmi_check_system(pci_crs_quirks);
 149
 150        /*
 151         * If the user specifies "pci=use_crs" or "pci=nocrs" explicitly, that
 152         * takes precedence over anything we figured out above.
 153         */
 154        if (pci_probe & PCI_ROOT_NO_CRS)
 155                pci_use_crs = false;
 156        else if (pci_probe & PCI_USE__CRS)
 157                pci_use_crs = true;
 158
 159        printk(KERN_INFO "PCI: %s host bridge windows from ACPI; "
 160               "if necessary, use \"pci=%s\" and report a bug\n",
 161               pci_use_crs ? "Using" : "Ignoring",
 162               pci_use_crs ? "nocrs" : "use_crs");
 163}
 164
 165#ifdef  CONFIG_PCI_MMCONFIG
 166static int check_segment(u16 seg, struct device *dev, char *estr)
 167{
 168        if (seg) {
 169                dev_err(dev,
 170                        "%s can't access PCI configuration "
 171                        "space under this host bridge.\n",
 172                        estr);
 173                return -EIO;
 174        }
 175
 176        /*
 177         * Failure in adding MMCFG information is not fatal,
 178         * just can't access extended configuration space of
 179         * devices under this host bridge.
 180         */
 181        dev_warn(dev,
 182                 "%s can't access extended PCI configuration "
 183                 "space under this bridge.\n",
 184                 estr);
 185
 186        return 0;
 187}
 188
 189static int setup_mcfg_map(struct acpi_pci_root_info *ci)
 190{
 191        int result, seg;
 192        struct pci_root_info *info;
 193        struct acpi_pci_root *root = ci->root;
 194        struct device *dev = &ci->bridge->dev;
 195
 196        info = container_of(ci, struct pci_root_info, common);
 197        info->start_bus = (u8)root->secondary.start;
 198        info->end_bus = (u8)root->secondary.end;
 199        info->mcfg_added = false;
 200        seg = info->sd.domain;
 201
 202        /* return success if MMCFG is not in use */
 203        if (raw_pci_ext_ops && raw_pci_ext_ops != &pci_mmcfg)
 204                return 0;
 205
 206        if (!(pci_probe & PCI_PROBE_MMCONF))
 207                return check_segment(seg, dev, "MMCONFIG is disabled,");
 208
 209        result = pci_mmconfig_insert(dev, seg, info->start_bus, info->end_bus,
 210                                     root->mcfg_addr);
 211        if (result == 0) {
 212                /* enable MMCFG if it hasn't been enabled yet */
 213                if (raw_pci_ext_ops == NULL)
 214                        raw_pci_ext_ops = &pci_mmcfg;
 215                info->mcfg_added = true;
 216        } else if (result != -EEXIST)
 217                return check_segment(seg, dev,
 218                         "fail to add MMCONFIG information,");
 219
 220        return 0;
 221}
 222
 223static void teardown_mcfg_map(struct acpi_pci_root_info *ci)
 224{
 225        struct pci_root_info *info;
 226
 227        info = container_of(ci, struct pci_root_info, common);
 228        if (info->mcfg_added) {
 229                pci_mmconfig_delete(info->sd.domain,
 230                                    info->start_bus, info->end_bus);
 231                info->mcfg_added = false;
 232        }
 233}
 234#else
 235static int setup_mcfg_map(struct acpi_pci_root_info *ci)
 236{
 237        return 0;
 238}
 239
 240static void teardown_mcfg_map(struct acpi_pci_root_info *ci)
 241{
 242}
 243#endif
 244
 245static int pci_acpi_root_get_node(struct acpi_pci_root *root)
 246{
 247        int busnum = root->secondary.start;
 248        struct acpi_device *device = root->device;
 249        int node = acpi_get_node(device->handle);
 250
 251        if (node == NUMA_NO_NODE) {
 252                node = x86_pci_root_bus_node(busnum);
 253                if (node != 0 && node != NUMA_NO_NODE)
 254                        dev_info(&device->dev, FW_BUG "no _PXM; falling back to node %d from hardware (may be inconsistent with ACPI node numbers)\n",
 255                                node);
 256        }
 257        if (node != NUMA_NO_NODE && !node_online(node))
 258                node = NUMA_NO_NODE;
 259
 260        return node;
 261}
 262
 263static int pci_acpi_root_init_info(struct acpi_pci_root_info *ci)
 264{
 265        return setup_mcfg_map(ci);
 266}
 267
 268static void pci_acpi_root_release_info(struct acpi_pci_root_info *ci)
 269{
 270        teardown_mcfg_map(ci);
 271        kfree(container_of(ci, struct pci_root_info, common));
 272}
 273
 274/*
 275 * An IO port or MMIO resource assigned to a PCI host bridge may be
 276 * consumed by the host bridge itself or available to its child
 277 * bus/devices. The ACPI specification defines a bit (Producer/Consumer)
 278 * to tell whether the resource is consumed by the host bridge itself,
 279 * but firmware hasn't used that bit consistently, so we can't rely on it.
 280 *
 281 * On x86 and IA64 platforms, all IO port and MMIO resources are assumed
 282 * to be available to child bus/devices except one special case:
 283 *     IO port [0xCF8-0xCFF] is consumed by the host bridge itself
 284 *     to access PCI configuration space.
 285 *
 286 * So explicitly filter out PCI CFG IO ports[0xCF8-0xCFF].
 287 */
 288static bool resource_is_pcicfg_ioport(struct resource *res)
 289{
 290        return (res->flags & IORESOURCE_IO) &&
 291                res->start == 0xCF8 && res->end == 0xCFF;
 292}
 293
 294static int pci_acpi_root_prepare_resources(struct acpi_pci_root_info *ci)
 295{
 296        struct acpi_device *device = ci->bridge;
 297        int busnum = ci->root->secondary.start;
 298        struct resource_entry *entry, *tmp;
 299        int status;
 300
 301        status = acpi_pci_probe_root_resources(ci);
 302        if (pci_use_crs) {
 303                resource_list_for_each_entry_safe(entry, tmp, &ci->resources)
 304                        if (resource_is_pcicfg_ioport(entry->res))
 305                                resource_list_destroy_entry(entry);
 306                return status;
 307        }
 308
 309        resource_list_for_each_entry_safe(entry, tmp, &ci->resources) {
 310                dev_printk(KERN_DEBUG, &device->dev,
 311                           "host bridge window %pR (ignored)\n", entry->res);
 312                resource_list_destroy_entry(entry);
 313        }
 314        x86_pci_root_bus_resources(busnum, &ci->resources);
 315
 316        return 0;
 317}
 318
 319static struct acpi_pci_root_ops acpi_pci_root_ops = {
 320        .pci_ops = &pci_root_ops,
 321        .init_info = pci_acpi_root_init_info,
 322        .release_info = pci_acpi_root_release_info,
 323        .prepare_resources = pci_acpi_root_prepare_resources,
 324};
 325
 326struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
 327{
 328        int domain = root->segment;
 329        int busnum = root->secondary.start;
 330        int node = pci_acpi_root_get_node(root);
 331        struct pci_bus *bus;
 332
 333        if (pci_ignore_seg)
 334                root->segment = domain = 0;
 335
 336        if (domain && !pci_domains_supported) {
 337                printk(KERN_WARNING "pci_bus %04x:%02x: "
 338                       "ignored (multiple domains not supported)\n",
 339                       domain, busnum);
 340                return NULL;
 341        }
 342
 343        bus = pci_find_bus(domain, busnum);
 344        if (bus) {
 345                /*
 346                 * If the desired bus has been scanned already, replace
 347                 * its bus->sysdata.
 348                 */
 349                struct pci_sysdata sd = {
 350                        .domain = domain,
 351                        .node = node,
 352                        .companion = root->device
 353                };
 354
 355                memcpy(bus->sysdata, &sd, sizeof(sd));
 356        } else {
 357                struct pci_root_info *info;
 358
 359                info = kzalloc(sizeof(*info), GFP_KERNEL);
 360                if (!info)
 361                        dev_err(&root->device->dev,
 362                                "pci_bus %04x:%02x: ignored (out of memory)\n",
 363                                domain, busnum);
 364                else {
 365                        info->sd.domain = domain;
 366                        info->sd.node = node;
 367                        info->sd.companion = root->device;
 368                        bus = acpi_pci_root_create(root, &acpi_pci_root_ops,
 369                                                   &info->common, &info->sd);
 370                }
 371        }
 372
 373        /* After the PCI-E bus has been walked and all devices discovered,
 374         * configure any settings of the fabric that might be necessary.
 375         */
 376        if (bus) {
 377                struct pci_bus *child;
 378                list_for_each_entry(child, &bus->children, node)
 379                        pcie_bus_configure_settings(child);
 380        }
 381
 382        return bus;
 383}
 384
 385int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
 386{
 387        /*
 388         * We pass NULL as parent to pci_create_root_bus(), so if it is not NULL
 389         * here, pci_create_root_bus() has been called by someone else and
 390         * sysdata is likely to be different from what we expect.  Let it go in
 391         * that case.
 392         */
 393        if (!bridge->dev.parent) {
 394                struct pci_sysdata *sd = bridge->bus->sysdata;
 395                ACPI_COMPANION_SET(&bridge->dev, sd->companion);
 396        }
 397        return 0;
 398}
 399
 400int __init pci_acpi_init(void)
 401{
 402        struct pci_dev *dev = NULL;
 403
 404        if (acpi_noirq)
 405                return -ENODEV;
 406
 407        printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
 408        acpi_irq_penalty_init();
 409        pcibios_enable_irq = acpi_pci_irq_enable;
 410        pcibios_disable_irq = acpi_pci_irq_disable;
 411        x86_init.pci.init_irq = x86_init_noop;
 412
 413        if (pci_routeirq) {
 414                /*
 415                 * PCI IRQ routing is set up by pci_enable_device(), but we
 416                 * also do it here in case there are still broken drivers that
 417                 * don't use pci_enable_device().
 418                 */
 419                printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
 420                for_each_pci_dev(dev)
 421                        acpi_pci_irq_enable(dev);
 422        }
 423
 424        return 0;
 425}
 426