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 } 252