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 res->flags = 0; 49 if (acpi_dev_filter_resource_type(acpi_res, IORESOURCE_MEM)) 50 return AE_OK; 51 52 if (!acpi_dev_resource_memory(acpi_res, res)) { 53 if (acpi_dev_resource_address_space(acpi_res, &win) || 54 acpi_dev_resource_ext_address_space(acpi_res, &win)) 55 *res = win.res; 56 } 57 if ((res->flags & IORESOURCE_PREFETCH) || 58 (res->flags & IORESOURCE_DISABLED)) 59 res->flags = 0; 60 61 return AE_CTRL_TERMINATE; 62 } 63 64 static bool acpi_is_ioapic(acpi_handle handle, char **type) 65 { 66 acpi_status status; 67 struct acpi_device_info *info; 68 char *hid = NULL; 69 bool match = false; 70 71 if (!acpi_has_method(handle, "_GSB")) 72 return false; 73 74 status = acpi_get_object_info(handle, &info); 75 if (ACPI_SUCCESS(status)) { 76 if (info->valid & ACPI_VALID_HID) 77 hid = info->hardware_id.string; 78 if (hid) { 79 if (strcmp(hid, "ACPI0009") == 0) { 80 *type = "IOxAPIC"; 81 match = true; 82 } else if (strcmp(hid, "ACPI000A") == 0) { 83 *type = "IOAPIC"; 84 match = true; 85 } 86 } 87 kfree(info); 88 } 89 90 return match; 91 } 92 93 static acpi_status handle_ioapic_add(acpi_handle handle, u32 lvl, 94 void *context, void **rv) 95 { 96 acpi_status status; 97 unsigned long long gsi_base; 98 struct acpi_pci_ioapic *ioapic; 99 struct pci_dev *dev = NULL; 100 struct resource *res = NULL, *pci_res = NULL, *crs_res; 101 char *type = NULL; 102 103 if (!acpi_is_ioapic(handle, &type)) 104 return AE_OK; 105 106 mutex_lock(&ioapic_list_lock); 107 list_for_each_entry(ioapic, &ioapic_list, list) 108 if (ioapic->handle == handle) { 109 mutex_unlock(&ioapic_list_lock); 110 return AE_OK; 111 } 112 113 status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsi_base); 114 if (ACPI_FAILURE(status)) { 115 acpi_handle_warn(handle, "failed to evaluate _GSB method\n"); 116 goto exit; 117 } 118 119 ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL); 120 if (!ioapic) { 121 pr_err("cannot allocate memory for new IOAPIC\n"); 122 goto exit; 123 } else { 124 ioapic->root_handle = (acpi_handle)context; 125 ioapic->handle = handle; 126 ioapic->gsi_base = (u32)gsi_base; 127 INIT_LIST_HEAD(&ioapic->list); 128 } 129 130 if (acpi_ioapic_registered(handle, (u32)gsi_base)) 131 goto done; 132 133 dev = acpi_get_pci_dev(handle); 134 if (dev && pci_resource_len(dev, 0)) { 135 if (pci_enable_device(dev) < 0) 136 goto exit_put; 137 pci_set_master(dev); 138 if (pci_request_region(dev, 0, type)) 139 goto exit_disable; 140 pci_res = &dev->resource[0]; 141 ioapic->pdev = dev; 142 } else { 143 pci_dev_put(dev); 144 dev = NULL; 145 } 146 147 crs_res = &ioapic->res; 148 acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, crs_res); 149 crs_res->name = type; 150 crs_res->flags |= IORESOURCE_BUSY; 151 if (crs_res->flags == 0) { 152 acpi_handle_warn(handle, "failed to get resource\n"); 153 goto exit_release; 154 } else if (insert_resource(&iomem_resource, crs_res)) { 155 acpi_handle_warn(handle, "failed to insert resource\n"); 156 goto exit_release; 157 } 158 159 /* try pci resource first, then "_CRS" resource */ 160 res = pci_res; 161 if (!res || !res->flags) 162 res = crs_res; 163 164 if (acpi_register_ioapic(handle, res->start, (u32)gsi_base)) { 165 acpi_handle_warn(handle, "failed to register IOAPIC\n"); 166 goto exit_release; 167 } 168 done: 169 list_add(&ioapic->list, &ioapic_list); 170 mutex_unlock(&ioapic_list_lock); 171 172 if (dev) 173 dev_info(&dev->dev, "%s at %pR, GSI %u\n", 174 type, res, (u32)gsi_base); 175 else 176 acpi_handle_info(handle, "%s at %pR, GSI %u\n", 177 type, res, (u32)gsi_base); 178 179 return AE_OK; 180 181 exit_release: 182 if (dev) 183 pci_release_region(dev, 0); 184 if (ioapic->res.flags && ioapic->res.parent) 185 release_resource(&ioapic->res); 186 exit_disable: 187 if (dev) 188 pci_disable_device(dev); 189 exit_put: 190 pci_dev_put(dev); 191 kfree(ioapic); 192 exit: 193 mutex_unlock(&ioapic_list_lock); 194 *(acpi_status *)rv = AE_ERROR; 195 return AE_OK; 196 } 197 198 int acpi_ioapic_add(acpi_handle root_handle) 199 { 200 acpi_status status, retval = AE_OK; 201 202 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root_handle, 203 UINT_MAX, handle_ioapic_add, NULL, 204 root_handle, (void **)&retval); 205 206 return ACPI_SUCCESS(status) && ACPI_SUCCESS(retval) ? 0 : -ENODEV; 207 } 208 209 int acpi_ioapic_remove(struct acpi_pci_root *root) 210 { 211 int retval = 0; 212 struct acpi_pci_ioapic *ioapic, *tmp; 213 214 mutex_lock(&ioapic_list_lock); 215 list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) { 216 if (root->device->handle != ioapic->root_handle) 217 continue; 218 219 if (acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base)) 220 retval = -EBUSY; 221 222 if (ioapic->pdev) { 223 pci_release_region(ioapic->pdev, 0); 224 pci_disable_device(ioapic->pdev); 225 pci_dev_put(ioapic->pdev); 226 } 227 if (ioapic->res.flags && ioapic->res.parent) 228 release_resource(&ioapic->res); 229 list_del(&ioapic->list); 230 kfree(ioapic); 231 } 232 mutex_unlock(&ioapic_list_lock); 233 234 return retval; 235 } 236