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

/*
 * IOAPIC/IOxAPIC/IOSAPIC driver
 *
 * Copyright (C) 2009 Fujitsu Limited.
 * (c) Copyright 2009 Hewlett-Packard Development Company, L.P.
 *
 * 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.
 */

/*
 * This driver manages PCI I/O APICs added by hotplug after boot.  We try to
 * claim all I/O APIC PCI devices, but those present at boot were registered
 * when we parsed the ACPI MADT, so we'll fail when we try to re-register
 * them.
 */

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

struct ioapic {
	acpi_handle	handle;
	u32		gsi_base;
};

static int ioapic_probe(struct pci_dev *dev, const struct pci_device_id *ent)
{
	acpi_handle handle;
	acpi_status status;
	unsigned long long gsb;
	struct ioapic *ioapic;
	int ret;
	char *type;
	struct resource *res;

	handle = ACPI_HANDLE(&dev->dev);
	if (!handle)
		return -EINVAL;

	status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb);
	if (ACPI_FAILURE(status))
		return -EINVAL;

	/*
	 * The previous code in acpiphp evaluated _MAT if _GSB failed, but
	 * ACPI spec 4.0 sec 6.2.2 requires _GSB for hot-pluggable I/O APICs.
	 */

	ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL);
	if (!ioapic)
		return -ENOMEM;

	ioapic->handle = handle;
	ioapic->gsi_base = (u32) gsb;

	if (dev->class == PCI_CLASS_SYSTEM_PIC_IOAPIC)
		type = "IOAPIC";
	else
		type = "IOxAPIC";

	ret = pci_enable_device(dev);
	if (ret < 0)
		goto exit_free;

	pci_set_master(dev);

	if (pci_request_region(dev, 0, type))
		goto exit_disable;

	res = &dev->resource[0];
	if (acpi_register_ioapic(ioapic->handle, res->start, ioapic->gsi_base))
		goto exit_release;

	pci_set_drvdata(dev, ioapic);
	dev_info(&dev->dev, "%s at %pR, GSI %u\n", type, res, ioapic->gsi_base);
	return 0;

exit_release:
	pci_release_region(dev, 0);
exit_disable:
	pci_disable_device(dev);
exit_free:
	kfree(ioapic);
	return -ENODEV;
}

static void ioapic_remove(struct pci_dev *dev)
{
	struct ioapic *ioapic = pci_get_drvdata(dev);

	acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base);
	pci_release_region(dev, 0);
	pci_disable_device(dev);
	kfree(ioapic);
}


static const struct pci_device_id ioapic_devices[] = {
	{ PCI_DEVICE_CLASS(PCI_CLASS_SYSTEM_PIC_IOAPIC, ~0) },
	{ PCI_DEVICE_CLASS(PCI_CLASS_SYSTEM_PIC_IOXAPIC, ~0) },
	{ }
};
MODULE_DEVICE_TABLE(pci, ioapic_devices);

static struct pci_driver ioapic_driver = {
	.name		= "ioapic",
	.id_table	= ioapic_devices,
	.probe		= ioapic_probe,
	.remove		= ioapic_remove,
};

static int __init ioapic_init(void)
{
	return pci_register_driver(&ioapic_driver);
}
module_init(ioapic_init);

MODULE_LICENSE("GPL");
Commit	Line	Data
204d49a5 BH	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	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	/*
	13	* This driver manages PCI I/O APICs added by hotplug after boot. We try to
	14	* claim all I/O APIC PCI devices, but those present at boot were registered
	15	* when we parsed the ACPI MADT, so we'll fail when we try to re-register
	16	* them.
	17	*/
	18
	19	#include <linux/pci.h>
b95a7bd7	20	#include <linux/module.h>
204d49a5	21	#include <linux/acpi.h>
5a0e3ad6	22	#include <linux/slab.h>
204d49a5 BH	23
	24	struct ioapic {
	25	acpi_handle handle;
	26	u32 gsi_base;
	27	};
	28
15856ad5	29	static int ioapic_probe(struct pci_dev dev, const struct pci_device_id ent)
204d49a5 BH	30	{
	31	acpi_handle handle;
	32	acpi_status status;
	33	unsigned long long gsb;
	34	struct ioapic *ioapic;
204d49a5 BH	35	int ret;
204d49a5 BH	36	char *type;
e1944c6b	37	struct resource *res;
204d49a5	38
3a83f992	39	handle = ACPI_HANDLE(&dev->dev);
204d49a5 BH	40	if (!handle)
	41	return -EINVAL;
	42
	43	status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb);
	44	if (ACPI_FAILURE(status))
	45	return -EINVAL;
	46
	47	/*
	48	* The previous code in acpiphp evaluated _MAT if _GSB failed, but
	49	* ACPI spec 4.0 sec 6.2.2 requires _GSB for hot-pluggable I/O APICs.
	50	*/
	51
	52	ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL);
	53	if (!ioapic)
	54	return -ENOMEM;
	55
	56	ioapic->handle = handle;
	57	ioapic->gsi_base = (u32) gsb;
	58
	59	if (dev->class == PCI_CLASS_SYSTEM_PIC_IOAPIC)
	60	type = "IOAPIC";
	61	else
	62	type = "IOxAPIC";
	63
	64	ret = pci_enable_device(dev);
	65	if (ret < 0)
	66	goto exit_free;
	67
	68	pci_set_master(dev);
	69
	70	if (pci_request_region(dev, 0, type))
	71	goto exit_disable;
	72
e1944c6b BH	73	res = &dev->resource[0];
e1944c6b BH	74	if (acpi_register_ioapic(ioapic->handle, res->start, ioapic->gsi_base))
204d49a5 BH	75	goto exit_release;
	76
	77	pci_set_drvdata(dev, ioapic);
e1944c6b	78	dev_info(&dev->dev, "%s at %pR, GSI %u\n", type, res, ioapic->gsi_base);
204d49a5 BH	79	return 0;
	80
	81	exit_release:
	82	pci_release_region(dev, 0);
	83	exit_disable:
	84	pci_disable_device(dev);
	85	exit_free:
	86	kfree(ioapic);
	87	return -ENODEV;
	88	}
	89
15856ad5	90	static void ioapic_remove(struct pci_dev *dev)
204d49a5 BH	91	{
	92	struct ioapic *ioapic = pci_get_drvdata(dev);
	93
	94	acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base);
	95	pci_release_region(dev, 0);
	96	pci_disable_device(dev);
	97	kfree(ioapic);
	98	}
	99
	100
9baa3c34	101	static const struct pci_device_id ioapic_devices[] = {
b95a7bd7 JB	102	{ PCI_DEVICE_CLASS(PCI_CLASS_SYSTEM_PIC_IOAPIC, ~0) },
b95a7bd7 JB	103	{ PCI_DEVICE_CLASS(PCI_CLASS_SYSTEM_PIC_IOXAPIC, ~0) },
204d49a5 BH	104	{ }
204d49a5 BH	105	};
b95a7bd7	106	MODULE_DEVICE_TABLE(pci, ioapic_devices);
204d49a5 BH	107
	108	static struct pci_driver ioapic_driver = {
	109	.name = "ioapic",
	110	.id_table = ioapic_devices,
	111	.probe = ioapic_probe,
15856ad5	112	.remove = ioapic_remove,
204d49a5 BH	113	};
204d49a5 BH	114
77410439 YL	115	static int __init ioapic_init(void)
	116	{
	117	return pci_register_driver(&ioapic_driver);
	118	}
	119	module_init(ioapic_init);
eba48cd0 AC	120
eba48cd0 AC	121	MODULE_LICENSE("GPL");