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
 31struct 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
 40static LIST_HEAD(ioapic_list);
 41static DEFINE_MUTEX(ioapic_list_lock);
 42
 43static 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
 70static 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
 99static 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	}
174done:
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
187exit_release:
188	if (dev)
189		pci_release_region(dev, 0);
190	if (ioapic->res.flags && ioapic->res.parent)
191		release_resource(&ioapic->res);
192exit_disable:
193	if (dev)
194		pci_disable_device(dev);
195exit_put:
196	pci_dev_put(dev);
197	kfree(ioapic);
198exit:
199	mutex_unlock(&ioapic_list_lock);
200	*(acpi_status *)rv = AE_ERROR;
201	return AE_OK;
202}
203
204int 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
215void 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
232int 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}