[deliverable/linux.git] / drivers / acpi / ioapic.c

/*
 * IOAPIC/IOxAPIC/IOSAPIC driver
 *
 * Copyright (C) 2009 Fujitsu Limited.
 * (c) Copyright 2009 Hewlett-Packard Development Company, L.P.
 *
 * Copyright (C) 2014 Intel Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Based on original drivers/pci/ioapic.c
 *	Yinghai Lu <yinghai@kernel.org>
 *	Jiang Liu <jiang.liu@intel.com>
 */

/*
 * This driver manages I/O APICs added by hotplug after boot.
 * We try to claim all I/O APIC devices, but those present at boot were
 * registered when we parsed the ACPI MADT.
 */

#define pr_fmt(fmt) "ACPI : IOAPIC: " fmt

#include <linux/slab.h>
#include <linux/acpi.h>
#include <linux/pci.h>
#include <acpi/acpi.h>

struct acpi_pci_ioapic {
	acpi_handle	root_handle;
	acpi_handle	handle;
	u32		gsi_base;
	struct resource	res;
	struct pci_dev	*pdev;
	struct list_head list;
};

static LIST_HEAD(ioapic_list);
static DEFINE_MUTEX(ioapic_list_lock);

static acpi_status setup_res(struct acpi_resource *acpi_res, void *data)
{
	struct resource *res = data;
	struct resource_win win;

	res->flags = 0;
	if (acpi_dev_filter_resource_type(acpi_res, IORESOURCE_MEM) == 0)
		return AE_OK;

	if (!acpi_dev_resource_memory(acpi_res, res)) {
		if (acpi_dev_resource_address_space(acpi_res, &win) ||
		    acpi_dev_resource_ext_address_space(acpi_res, &win))
			*res = win.res;
	}
	if ((res->flags & IORESOURCE_PREFETCH) ||
	    (res->flags & IORESOURCE_DISABLED))
		res->flags = 0;

	return AE_CTRL_TERMINATE;
}

static bool acpi_is_ioapic(acpi_handle handle, char **type)
{
	acpi_status status;
	struct acpi_device_info *info;
	char *hid = NULL;
	bool match = false;

	if (!acpi_has_method(handle, "_GSB"))
		return false;

	status = acpi_get_object_info(handle, &info);
	if (ACPI_SUCCESS(status)) {
		if (info->valid & ACPI_VALID_HID)
			hid = info->hardware_id.string;
		if (hid) {
			if (strcmp(hid, "ACPI0009") == 0) {
				*type = "IOxAPIC";
				match = true;
			} else if (strcmp(hid, "ACPI000A") == 0) {
				*type = "IOAPIC";
				match = true;
			}
		}
		kfree(info);
	}

	return match;
}

static acpi_status handle_ioapic_add(acpi_handle handle, u32 lvl,
				     void *context, void **rv)
{
	acpi_status status;
	unsigned long long gsi_base;
	struct acpi_pci_ioapic *ioapic;
	struct pci_dev *dev = NULL;
	struct resource *res = NULL;
	char *type = NULL;

	if (!acpi_is_ioapic(handle, &type))
		return AE_OK;

	mutex_lock(&ioapic_list_lock);
	list_for_each_entry(ioapic, &ioapic_list, list)
		if (ioapic->handle == handle) {
			mutex_unlock(&ioapic_list_lock);
			return AE_OK;
		}

	status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsi_base);
	if (ACPI_FAILURE(status)) {
		acpi_handle_warn(handle, "failed to evaluate _GSB method\n");
		goto exit;
	}

	ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL);
	if (!ioapic) {
		pr_err("cannot allocate memory for new IOAPIC\n");
		goto exit;
	} else {
		ioapic->root_handle = (acpi_handle)context;
		ioapic->handle = handle;
		ioapic->gsi_base = (u32)gsi_base;
		INIT_LIST_HEAD(&ioapic->list);
	}

	if (acpi_ioapic_registered(handle, (u32)gsi_base))
		goto done;

	dev = acpi_get_pci_dev(handle);
	if (dev && pci_resource_len(dev, 0)) {
		if (pci_enable_device(dev) < 0)
			goto exit_put;
		pci_set_master(dev);
		if (pci_request_region(dev, 0, type))
			goto exit_disable;
		res = &dev->resource[0];
		ioapic->pdev = dev;
	} else {
		pci_dev_put(dev);
		dev = NULL;

		res = &ioapic->res;
		acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, res);
		if (res->flags == 0) {
			acpi_handle_warn(handle, "failed to get resource\n");
			goto exit_free;
		} else if (request_resource(&iomem_resource, res)) {
			acpi_handle_warn(handle, "failed to insert resource\n");
			goto exit_free;
		}
	}

	if (acpi_register_ioapic(handle, res->start, (u32)gsi_base)) {
		acpi_handle_warn(handle, "failed to register IOAPIC\n");
		goto exit_release;
	}
done:
	list_add(&ioapic->list, &ioapic_list);
	mutex_unlock(&ioapic_list_lock);

	if (dev)
		dev_info(&dev->dev, "%s at %pR, GSI %u\n",
			 type, res, (u32)gsi_base);
	else
		acpi_handle_info(handle, "%s at %pR, GSI %u\n",
				 type, res, (u32)gsi_base);

	return AE_OK;

exit_release:
	if (dev)
		pci_release_region(dev, 0);
	else
		release_resource(res);
exit_disable:
	if (dev)
		pci_disable_device(dev);
exit_put:
	pci_dev_put(dev);
exit_free:
	kfree(ioapic);
exit:
	mutex_unlock(&ioapic_list_lock);
	*(acpi_status *)rv = AE_ERROR;
	return AE_OK;
}

int acpi_ioapic_add(struct acpi_pci_root *root)
{
	acpi_status status, retval = AE_OK;

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root->device->handle,
				     UINT_MAX, handle_ioapic_add, NULL,
				     root->device->handle, (void **)&retval);

	return ACPI_SUCCESS(status) && ACPI_SUCCESS(retval) ? 0 : -ENODEV;
}

int acpi_ioapic_remove(struct acpi_pci_root *root)
{
	int retval = 0;
	struct acpi_pci_ioapic *ioapic, *tmp;

	mutex_lock(&ioapic_list_lock);
	list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
		if (root->device->handle != ioapic->root_handle)
			continue;

		if (acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base))
			retval = -EBUSY;

		if (ioapic->pdev) {
			pci_release_region(ioapic->pdev, 0);
			pci_disable_device(ioapic->pdev);
			pci_dev_put(ioapic->pdev);
		} else if (ioapic->res.flags && ioapic->res.parent) {
			release_resource(&ioapic->res);
		}
		list_del(&ioapic->list);
		kfree(ioapic);
	}
	mutex_unlock(&ioapic_list_lock);

	return retval;
}
Commit	Line	Data
c183619b JL	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) == 0)
	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;
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	res = &dev->resource[0];
141	ioapic->pdev = dev;
142	} else {
143	pci_dev_put(dev);
144	dev = NULL;
145
146	res = &ioapic->res;
147	acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, res);
148	if (res->flags == 0) {
149	acpi_handle_warn(handle, "failed to get resource\n");
150	goto exit_free;
151	} else if (request_resource(&iomem_resource, res)) {
152	acpi_handle_warn(handle, "failed to insert resource\n");
153	goto exit_free;
154	}
155	}
156
157	if (acpi_register_ioapic(handle, res->start, (u32)gsi_base)) {
158	acpi_handle_warn(handle, "failed to register IOAPIC\n");
159	goto exit_release;
160	}
161	done:
162	list_add(&ioapic->list, &ioapic_list);
163	mutex_unlock(&ioapic_list_lock);
164
165	if (dev)
166	dev_info(&dev->dev, "%s at %pR, GSI %u\n",
167	type, res, (u32)gsi_base);
168	else
169	acpi_handle_info(handle, "%s at %pR, GSI %u\n",
170	type, res, (u32)gsi_base);
171
172	return AE_OK;
173
174	exit_release:
175	if (dev)
176	pci_release_region(dev, 0);
177	else
178	release_resource(res);
179	exit_disable:
180	if (dev)
181	pci_disable_device(dev);
182	exit_put:
183	pci_dev_put(dev);
184	exit_free:
185	kfree(ioapic);
186	exit:
187	mutex_unlock(&ioapic_list_lock);
188	(acpi_status )rv = AE_ERROR;
189	return AE_OK;
190	}
191
192	int acpi_ioapic_add(struct acpi_pci_root *root)
193	{
194	acpi_status status, retval = AE_OK;
195
196	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root->device->handle,
197	UINT_MAX, handle_ioapic_add, NULL,
198	root->device->handle, (void **)&retval);
199
200	return ACPI_SUCCESS(status) && ACPI_SUCCESS(retval) ? 0 : -ENODEV;
201	}
202
203	int acpi_ioapic_remove(struct acpi_pci_root *root)
204	{
205	int retval = 0;
206	struct acpi_pci_ioapic ioapic, tmp;
207
208	mutex_lock(&ioapic_list_lock);
209	list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
210	if (root->device->handle != ioapic->root_handle)
211	continue;
212
213	if (acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base))
214	retval = -EBUSY;
215
216	if (ioapic->pdev) {
217	pci_release_region(ioapic->pdev, 0);
218	pci_disable_device(ioapic->pdev);
219	pci_dev_put(ioapic->pdev);
220	} else if (ioapic->res.flags && ioapic->res.parent) {
221	release_resource(&ioapic->res);
222	}
223	list_del(&ioapic->list);
224	kfree(ioapic);
225	}
226	mutex_unlock(&ioapic_list_lock);
227
228	return retval;
229	}