[linux-block.git] / drivers / acpi / ioapic.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * IOAPIC/IOxAPIC/IOSAPIC driver
 *
 * Copyright (C) 2009 Fujitsu Limited.
 * (c) Copyright 2009 Hewlett-Packard Development Company, L.P.
 *
 * Copyright (C) 2014 Intel Corporation
 *
 * 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>
#include "internal.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;

	/*
	 * We might assign this to 'res' later, make sure all pointers are
	 * cleared before the resource is added to the global list
	 */
	memset(&win, 0, sizeof(win));

	res->flags = 0;
	if (acpi_dev_filter_resource_type(acpi_res, IORESOURCE_MEM))
		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, *pci_res = NULL, *crs_res;
	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;
		pci_res = &dev->resource[0];
		ioapic->pdev = dev;
	} else {
		pci_dev_put(dev);
		dev = NULL;
	}

	crs_res = &ioapic->res;
	acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, crs_res);
	crs_res->name = type;
	crs_res->flags |= IORESOURCE_BUSY;
	if (crs_res->flags == 0) {
		acpi_handle_warn(handle, "failed to get resource\n");
		goto exit_release;
	} else if (insert_resource(&iomem_resource, crs_res)) {
		acpi_handle_warn(handle, "failed to insert resource\n");
		goto exit_release;
	}

	/* try pci resource first, then "_CRS" resource */
	res = pci_res;
	if (!res || !res->flags)
		res = crs_res;

	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);
	if (ioapic->res.flags && ioapic->res.parent)
		release_resource(&ioapic->res);
exit_disable:
	if (dev)
		pci_disable_device(dev);
exit_put:
	pci_dev_put(dev);
	kfree(ioapic);
exit:
	mutex_unlock(&ioapic_list_lock);
	*(acpi_status *)rv = AE_ERROR;
	return AE_OK;
}

int acpi_ioapic_add(acpi_handle root_handle)
{
	acpi_status status, retval = AE_OK;

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root_handle,
				     UINT_MAX, handle_ioapic_add, NULL,
				     root_handle, (void **)&retval);

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

void pci_ioapic_remove(struct acpi_pci_root *root)
{
	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 (ioapic->pdev) {
			pci_release_region(ioapic->pdev, 0);
			pci_disable_device(ioapic->pdev);
			pci_dev_put(ioapic->pdev);
		}
	}
	mutex_unlock(&ioapic_list_lock);
}

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