drivers/acpi/ioapic.c

   1 /*
   2  * IOAPIC/IOxAPIC/IOSAPIC driver
   3  *
   4  * Copyright (C) 2009 Fujitsu Limited.
   5  * (c) Copyright 2009 Hewlett-Packard Development Company, L.P.
   6  *
   7  * Copyright (C) 2014 Intel Corporation
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  * Based on original drivers/pci/ioapic.c
  14  *      Yinghai Lu <yinghai@kernel.org>
  15  *      Jiang Liu <jiang.liu@intel.com>
  16  */
  17
  18 /*
  19  * This driver manages I/O APICs added by hotplug after boot.
  20  * We try to claim all I/O APIC devices, but those present at boot were
  21  * registered when we parsed the ACPI MADT.
  22  */
  23
  24 #define pr_fmt(fmt) "ACPI: IOAPIC: " fmt
  25
  26 #include <linux/slab.h>
  27 #include <linux/acpi.h>
  28 #include <linux/pci.h>
  29 #include <acpi/acpi.h>
  30
  31 struct acpi_pci_ioapic {
  32         acpi_handle     root_handle;
  33         acpi_handle     handle;
  34         u32             gsi_base;
  35         struct resource res;
  36         struct pci_dev  *pdev;
  37         struct list_head list;
  38 };
  39
  40 static LIST_HEAD(ioapic_list);
  41 static DEFINE_MUTEX(ioapic_list_lock);
  42
  43 static acpi_status setup_res(struct acpi_resource *acpi_res, void *data)
  44 {
  45         struct resource *res = data;
  46         struct resource_win win;
  47
  48         /*
  49          * We might assign this to 'res' later, make sure all pointers are
  50          * cleared before the resource is added to the global list
  51          */
  52         memset(&win, 0, sizeof(win));
  53
  54         res->flags = 0;
  55         if (acpi_dev_filter_resource_type(acpi_res, IORESOURCE_MEM))
  56                 return AE_OK;
  57
  58         if (!acpi_dev_resource_memory(acpi_res, res)) {
  59                 if (acpi_dev_resource_address_space(acpi_res, &win) ||
  60                     acpi_dev_resource_ext_address_space(acpi_res, &win))
  61                         *res = win.res;
  62         }
  63         if ((res->flags & IORESOURCE_PREFETCH) ||
  64             (res->flags & IORESOURCE_DISABLED))
  65                 res->flags = 0;
  66
  67         return AE_CTRL_TERMINATE;
  68 }
  69
  70 static bool acpi_is_ioapic(acpi_handle handle, char **type)
  71 {
  72         acpi_status status;
  73         struct acpi_device_info *info;
  74         char *hid = NULL;
  75         bool match = false;
  76
  77         if (!acpi_has_method(handle, "_GSB"))
  78                 return false;
  79
  80         status = acpi_get_object_info(handle, &info);
  81         if (ACPI_SUCCESS(status)) {
  82                 if (info->valid & ACPI_VALID_HID)
  83                         hid = info->hardware_id.string;
  84                 if (hid) {
  85                         if (strcmp(hid, "ACPI0009") == 0) {
  86                                 *type = "IOxAPIC";
  87                                 match = true;
  88                         } else if (strcmp(hid, "ACPI000A") == 0) {
  89                                 *type = "IOAPIC";
  90                                 match = true;
  91                         }
  92                 }
  93                 kfree(info);
  94         }
  95
  96         return match;
  97 }
  98
  99 static acpi_status handle_ioapic_add(acpi_handle handle, u32 lvl,
 100                                      void *context, void **rv)
 101 {
 102         acpi_status status;
 103         unsigned long long gsi_base;
 104         struct acpi_pci_ioapic *ioapic;
 105         struct pci_dev *dev = NULL;
 106         struct resource *res = NULL, *pci_res = NULL, *crs_res;
 107         char *type = NULL;
 108
 109         if (!acpi_is_ioapic(handle, &type))
 110                 return AE_OK;
 111
 112         mutex_lock(&ioapic_list_lock);
 113         list_for_each_entry(ioapic, &ioapic_list, list)
 114                 if (ioapic->handle == handle) {
 115                         mutex_unlock(&ioapic_list_lock);
 116                         return AE_OK;
 117                 }
 118
 119         status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsi_base);
 120         if (ACPI_FAILURE(status)) {
 121                 acpi_handle_warn(handle, "failed to evaluate _GSB method\n");
 122                 goto exit;
 123         }
 124
 125         ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL);
 126         if (!ioapic) {
 127                 pr_err("cannot allocate memory for new IOAPIC\n");
 128                 goto exit;
 129         } else {
 130                 ioapic->root_handle = (acpi_handle)context;
 131                 ioapic->handle = handle;
 132                 ioapic->gsi_base = (u32)gsi_base;
 133                 INIT_LIST_HEAD(&ioapic->list);
 134         }
 135
 136         if (acpi_ioapic_registered(handle, (u32)gsi_base))
 137                 goto done;
 138
 139         dev = acpi_get_pci_dev(handle);
 140         if (dev && pci_resource_len(dev, 0)) {
 141                 if (pci_enable_device(dev) < 0)
 142                         goto exit_put;
 143                 pci_set_master(dev);
 144                 if (pci_request_region(dev, 0, type))
 145                         goto exit_disable;
 146                 pci_res = &dev->resource[0];
 147                 ioapic->pdev = dev;
 148         } else {
 149                 pci_dev_put(dev);
 150                 dev = NULL;
 151         }
 152
 153         crs_res = &ioapic->res;
 154         acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, crs_res);
 155         crs_res->name = type;
 156         crs_res->flags |= IORESOURCE_BUSY;
 157         if (crs_res->flags == 0) {
 158                 acpi_handle_warn(handle, "failed to get resource\n");
 159                 goto exit_release;
 160         } else if (insert_resource(&iomem_resource, crs_res)) {
 161                 acpi_handle_warn(handle, "failed to insert resource\n");
 162                 goto exit_release;
 163         }
 164
 165         /* try pci resource first, then "_CRS" resource */
 166         res = pci_res;
 167         if (!res || !res->flags)
 168                 res = crs_res;
 169
 170         if (acpi_register_ioapic(handle, res->start, (u32)gsi_base)) {
 171                 acpi_handle_warn(handle, "failed to register IOAPIC\n");
 172                 goto exit_release;
 173         }
 174 done:
 175         list_add(&ioapic->list, &ioapic_list);
 176         mutex_unlock(&ioapic_list_lock);
 177
 178         if (dev)
 179                 dev_info(&dev->dev, "%s at %pR, GSI %u\n",
 180                          type, res, (u32)gsi_base);
 181         else
 182                 acpi_handle_info(handle, "%s at %pR, GSI %u\n",
 183                                  type, res, (u32)gsi_base);
 184
 185         return AE_OK;
 186
 187 exit_release:
 188         if (dev)
 189                 pci_release_region(dev, 0);
 190         if (ioapic->res.flags && ioapic->res.parent)
 191                 release_resource(&ioapic->res);
 192 exit_disable:
 193         if (dev)
 194                 pci_disable_device(dev);
 195 exit_put:
 196         pci_dev_put(dev);
 197         kfree(ioapic);
 198 exit:
 199         mutex_unlock(&ioapic_list_lock);
 200         *(acpi_status *)rv = AE_ERROR;
 201         return AE_OK;
 202 }
 203
 204 int acpi_ioapic_add(acpi_handle root_handle)
 205 {
 206         acpi_status status, retval = AE_OK;
 207
 208         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root_handle,
 209                                      UINT_MAX, handle_ioapic_add, NULL,
 210                                      root_handle, (void **)&retval);
 211
 212         return ACPI_SUCCESS(status) && ACPI_SUCCESS(retval) ? 0 : -ENODEV;
 213 }
 214
 215 void pci_ioapic_remove(struct acpi_pci_root *root)
 216 {
 217         struct acpi_pci_ioapic *ioapic, *tmp;
 218
 219         mutex_lock(&ioapic_list_lock);
 220         list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
 221                 if (root->device->handle != ioapic->root_handle)
 222                         continue;
 223                 if (ioapic->pdev) {
 224                         pci_release_region(ioapic->pdev, 0);
 225                         pci_disable_device(ioapic->pdev);
 226                         pci_dev_put(ioapic->pdev);
 227                 }
 228         }
 229         mutex_unlock(&ioapic_list_lock);
 230 }
 231
 232 int acpi_ioapic_remove(struct acpi_pci_root *root)
 233 {
 234         int retval = 0;
 235         struct acpi_pci_ioapic *ioapic, *tmp;
 236
 237         mutex_lock(&ioapic_list_lock);
 238         list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
 239                 if (root->device->handle != ioapic->root_handle)
 240                         continue;
 241                 if (acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base))
 242                         retval = -EBUSY;
 243                 if (ioapic->res.flags && ioapic->res.parent)
 244                         release_resource(&ioapic->res);
 245                 list_del(&ioapic->list);
 246                 kfree(ioapic);
 247         }
 248         mutex_unlock(&ioapic_list_lock);
 249
 250         return retval;
 251 }