[mirror_ubuntu-focal-kernel.git] / arch / x86 / pci / acpi.c

#include <linux/pci.h>
#include <linux/acpi.h>
#include <linux/init.h>
#include <linux/irq.h>
#include <linux/dmi.h>
#include <asm/numa.h>
#include "pci.h"

static int __devinit can_skip_ioresource_align(const struct dmi_system_id *d)
{
	pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
	printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
	return 0;
}

static struct dmi_system_id acpi_pciprobe_dmi_table[] __devinitdata = {
/*
 * Systems where PCI IO resource ISA alignment can be skipped
 * when the ISA enable bit in the bridge control is not set
 */
	{
		.callback = can_skip_ioresource_align,
		.ident = "IBM System x3800",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
		},
	},
	{
		.callback = can_skip_ioresource_align,
		.ident = "IBM System x3850",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
		},
	},
	{
		.callback = can_skip_ioresource_align,
		.ident = "IBM System x3950",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
			DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
		},
	},
	{}
};

struct pci_root_info {
	char *name;
	unsigned int res_num;
	struct resource *res;
	struct pci_bus *bus;
	int busnum;
};

static acpi_status
resource_to_addr(struct acpi_resource *resource,
			struct acpi_resource_address64 *addr)
{
	acpi_status status;

	status = acpi_resource_to_address64(resource, addr);
	if (ACPI_SUCCESS(status) &&
	    (addr->resource_type == ACPI_MEMORY_RANGE ||
	    addr->resource_type == ACPI_IO_RANGE) &&
	    addr->address_length > 0 &&
	    addr->producer_consumer == ACPI_PRODUCER) {
		return AE_OK;
	}
	return AE_ERROR;
}

static acpi_status
count_resource(struct acpi_resource *acpi_res, void *data)
{
	struct pci_root_info *info = data;
	struct acpi_resource_address64 addr;
	acpi_status status;

	if (info->res_num >= PCI_BUS_NUM_RESOURCES)
		return AE_OK;

	status = resource_to_addr(acpi_res, &addr);
	if (ACPI_SUCCESS(status))
		info->res_num++;
	return AE_OK;
}

static acpi_status
setup_resource(struct acpi_resource *acpi_res, void *data)
{
	struct pci_root_info *info = data;
	struct resource *res;
	struct acpi_resource_address64 addr;
	acpi_status status;
	unsigned long flags;
	struct resource *root;

	if (info->res_num >= PCI_BUS_NUM_RESOURCES)
		return AE_OK;

	status = resource_to_addr(acpi_res, &addr);
	if (!ACPI_SUCCESS(status))
		return AE_OK;

	if (addr.resource_type == ACPI_MEMORY_RANGE) {
		root = &iomem_resource;
		flags = IORESOURCE_MEM;
		if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
			flags |= IORESOURCE_PREFETCH;
	} else if (addr.resource_type == ACPI_IO_RANGE) {
		root = &ioport_resource;
		flags = IORESOURCE_IO;
	} else
		return AE_OK;

	res = &info->res[info->res_num];
	res->name = info->name;
	res->flags = flags;
	res->start = addr.minimum + addr.translation_offset;
	res->end = res->start + addr.address_length - 1;
	res->child = NULL;

	if (insert_resource(root, res)) {
		printk(KERN_ERR "PCI: Failed to allocate 0x%lx-0x%lx "
			"from %s for %s\n", (unsigned long) res->start,
			(unsigned long) res->end, root->name, info->name);
	} else {
		info->bus->resource[info->res_num] = res;
		info->res_num++;
	}
	return AE_OK;
}

static void
adjust_transparent_bridge_resources(struct pci_bus *bus)
{
	struct pci_dev *dev;

	list_for_each_entry(dev, &bus->devices, bus_list) {
		int i;
		u16 class = dev->class >> 8;

		if (class == PCI_CLASS_BRIDGE_PCI && dev->transparent) {
			for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
				dev->subordinate->resource[i] =
						dev->bus->resource[i - 3];
		}
	}
}

static void
get_current_resources(struct acpi_device *device, int busnum,
			struct pci_bus *bus)
{
	struct pci_root_info info;
	size_t size;

	info.bus = bus;
	info.res_num = 0;
	acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
				&info);
	if (!info.res_num)
		return;

	size = sizeof(*info.res) * info.res_num;
	info.res = kmalloc(size, GFP_KERNEL);
	if (!info.res)
		goto res_alloc_fail;

	info.name = kmalloc(12, GFP_KERNEL);
	if (!info.name)
		goto name_alloc_fail;
	sprintf(info.name, "PCI Bus #%02x", busnum);

	info.res_num = 0;
	acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
				&info);
	if (info.res_num)
		adjust_transparent_bridge_resources(bus);

	return;

name_alloc_fail:
	kfree(info.res);
res_alloc_fail:
	return;
}

struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
{
	struct pci_bus *bus;
	struct pci_sysdata *sd;
	int pxm;

	dmi_check_system(acpi_pciprobe_dmi_table);

	if (domain && !pci_domains_supported) {
		printk(KERN_WARNING "PCI: Multiple domains not supported "
		       "(dom %d, bus %d)\n", domain, busnum);
		return NULL;
	}

	/* Allocate per-root-bus (not per bus) arch-specific data.
	 * TODO: leak; this memory is never freed.
	 * It's arguable whether it's worth the trouble to care.
	 */
	sd = kzalloc(sizeof(*sd), GFP_KERNEL);
	if (!sd) {
		printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
		return NULL;
	}

	sd->domain = domain;
	sd->node = -1;

	pxm = acpi_get_pxm(device->handle);
#ifdef CONFIG_ACPI_NUMA
	if (pxm >= 0)
		sd->node = pxm_to_node(pxm);
#endif

	bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
	if (!bus)
		kfree(sd);

#ifdef CONFIG_ACPI_NUMA
	if (bus != NULL) {
		if (pxm >= 0) {
			printk("bus %d -> pxm %d -> node %d\n",
				busnum, pxm, sd->node);
		}
	}
#endif

	if (bus && (pci_probe & PCI_USE__CRS))
		get_current_resources(device, busnum, bus);
	
	return bus;
}

extern int pci_routeirq;
static int __init pci_acpi_init(void)
{
	struct pci_dev *dev = NULL;

	if (pcibios_scanned)
		return 0;

	if (acpi_noirq)
		return 0;

	printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
	acpi_irq_penalty_init();
	pcibios_scanned++;
	pcibios_enable_irq = acpi_pci_irq_enable;
	pcibios_disable_irq = acpi_pci_irq_disable;

	if (pci_routeirq) {
		/*
		 * PCI IRQ routing is set up by pci_enable_device(), but we
		 * also do it here in case there are still broken drivers that
		 * don't use pci_enable_device().
		 */
		printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
		for_each_pci_dev(dev)
			acpi_pci_irq_enable(dev);
	} else
		printk(KERN_INFO "PCI: If a device doesn't work, try \"pci=routeirq\".  If it helps, post a report\n");

#ifdef CONFIG_X86_IO_APIC
	if (acpi_ioapic)
		print_IO_APIC();
#endif

	return 0;
}
subsys_initcall(pci_acpi_init);
Commit	Line	Data
1da177e4 LT	1	#include <linux/pci.h>
	2	#include <linux/acpi.h>
	3	#include <linux/init.h>
b33fa1f3	4	#include <linux/irq.h>
036fff4c	5	#include <linux/dmi.h>
69e1a33f	6	#include <asm/numa.h>
1da177e4 LT	7	#include "pci.h"
1da177e4 LT	8
752097ce	9	static int __devinit can_skip_ioresource_align(const struct dmi_system_id *d)
036fff4c GH	10	{
	11	pci_probe \|= PCI_CAN_SKIP_ISA_ALIGN;
	12	printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
	13	return 0;
	14	}
	15
55b8d50c	16	static struct dmi_system_id acpi_pciprobe_dmi_table[] __devinitdata = {
036fff4c GH	17	/*
	18	* Systems where PCI IO resource ISA alignment can be skipped
	19	* when the ISA enable bit in the bridge control is not set
	20	*/
	21	{
	22	.callback = can_skip_ioresource_align,
	23	.ident = "IBM System x3800",
	24	.matches = {
	25	DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
	26	DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
	27	},
	28	},
	29	{
	30	.callback = can_skip_ioresource_align,
	31	.ident = "IBM System x3850",
	32	.matches = {
	33	DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
	34	DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
	35	},
	36	},
	37	{
	38	.callback = can_skip_ioresource_align,
	39	.ident = "IBM System x3950",
	40	.matches = {
	41	DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
	42	DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
	43	},
	44	},
	45	{}
	46	};
	47
62f420f8 GH	48	struct pci_root_info {
	49	char *name;
	50	unsigned int res_num;
	51	struct resource *res;
	52	struct pci_bus *bus;
	53	int busnum;
	54	};
	55
	56	static acpi_status
	57	resource_to_addr(struct acpi_resource *resource,
	58	struct acpi_resource_address64 *addr)
	59	{
	60	acpi_status status;
	61
	62	status = acpi_resource_to_address64(resource, addr);
	63	if (ACPI_SUCCESS(status) &&
	64	(addr->resource_type == ACPI_MEMORY_RANGE \|\|
	65	addr->resource_type == ACPI_IO_RANGE) &&
	66	addr->address_length > 0 &&
	67	addr->producer_consumer == ACPI_PRODUCER) {
	68	return AE_OK;
	69	}
	70	return AE_ERROR;
	71	}
	72
	73	static acpi_status
	74	count_resource(struct acpi_resource acpi_res, void data)
	75	{
	76	struct pci_root_info *info = data;
	77	struct acpi_resource_address64 addr;
	78	acpi_status status;
	79
3d9befd2 YL	80	if (info->res_num >= PCI_BUS_NUM_RESOURCES)
	81	return AE_OK;
	82
62f420f8 GH	83	status = resource_to_addr(acpi_res, &addr);
	84	if (ACPI_SUCCESS(status))
	85	info->res_num++;
	86	return AE_OK;
	87	}
	88
	89	static acpi_status
	90	setup_resource(struct acpi_resource acpi_res, void data)
	91	{
	92	struct pci_root_info *info = data;
	93	struct resource *res;
	94	struct acpi_resource_address64 addr;
	95	acpi_status status;
	96	unsigned long flags;
	97	struct resource *root;
	98
3d9befd2 YL	99	if (info->res_num >= PCI_BUS_NUM_RESOURCES)
	100	return AE_OK;
	101
62f420f8 GH	102	status = resource_to_addr(acpi_res, &addr);
	103	if (!ACPI_SUCCESS(status))
	104	return AE_OK;
	105
	106	if (addr.resource_type == ACPI_MEMORY_RANGE) {
	107	root = &iomem_resource;
	108	flags = IORESOURCE_MEM;
	109	if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
	110	flags \|= IORESOURCE_PREFETCH;
	111	} else if (addr.resource_type == ACPI_IO_RANGE) {
	112	root = &ioport_resource;
	113	flags = IORESOURCE_IO;
	114	} else
	115	return AE_OK;
	116
	117	res = &info->res[info->res_num];
	118	res->name = info->name;
	119	res->flags = flags;
	120	res->start = addr.minimum + addr.translation_offset;
	121	res->end = res->start + addr.address_length - 1;
	122	res->child = NULL;
	123
	124	if (insert_resource(root, res)) {
	125	printk(KERN_ERR "PCI: Failed to allocate 0x%lx-0x%lx "
	126	"from %s for %s\n", (unsigned long) res->start,
	127	(unsigned long) res->end, root->name, info->name);
	128	} else {
	129	info->bus->resource[info->res_num] = res;
	130	info->res_num++;
	131	}
	132	return AE_OK;
	133	}
	134
	135	static void
	136	adjust_transparent_bridge_resources(struct pci_bus *bus)
	137	{
	138	struct pci_dev *dev;
	139
	140	list_for_each_entry(dev, &bus->devices, bus_list) {
	141	int i;
	142	u16 class = dev->class >> 8;
	143
	144	if (class == PCI_CLASS_BRIDGE_PCI && dev->transparent) {
	145	for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
	146	dev->subordinate->resource[i] =
	147	dev->bus->resource[i - 3];
	148	}
	149	}
	150	}
	151
	152	static void
	153	get_current_resources(struct acpi_device *device, int busnum,
	154	struct pci_bus *bus)
	155	{
	156	struct pci_root_info info;
	157	size_t size;
	158
	159	info.bus = bus;
	160	info.res_num = 0;
	161	acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
	162	&info);
	163	if (!info.res_num)
	164	return;
	165
166	size = sizeof(info.res) info.res_num;
167	info.res = kmalloc(size, GFP_KERNEL);
168	if (!info.res)
169	goto res_alloc_fail;
170
171	info.name = kmalloc(12, GFP_KERNEL);
172	if (!info.name)
173	goto name_alloc_fail;
174	sprintf(info.name, "PCI Bus #%02x", busnum);
175
176	info.res_num = 0;
177	acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
178	&info);
179	if (info.res_num)
180	adjust_transparent_bridge_resources(bus);
181
182	return;
183
184	name_alloc_fail:
185	kfree(info.res);
186	res_alloc_fail:
187	return;
188	}
189
1da177e4 LT	190	struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
1da177e4 LT	191	{
69e1a33f	192	struct pci_bus *bus;
08f1c192 MBY	193	struct pci_sysdata *sd;
	194	int pxm;
	195
036fff4c GH	196	dmi_check_system(acpi_pciprobe_dmi_table);
036fff4c GH	197
a79e4198 JG	198	if (domain && !pci_domains_supported) {
	199	printk(KERN_WARNING "PCI: Multiple domains not supported "
	200	"(dom %d, bus %d)\n", domain, busnum);
	201	return NULL;
	202	}
	203
08f1c192 MBY	204	/* Allocate per-root-bus (not per bus) arch-specific data.
	205	* TODO: leak; this memory is never freed.
	206	* It's arguable whether it's worth the trouble to care.
	207	*/
	208	sd = kzalloc(sizeof(*sd), GFP_KERNEL);
	209	if (!sd) {
	210	printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
	211	return NULL;
	212	}
69e1a33f	213
a79e4198	214	sd->domain = domain;
08f1c192 MBY	215	sd->node = -1;
	216
	217	pxm = acpi_get_pxm(device->handle);
	218	#ifdef CONFIG_ACPI_NUMA
	219	if (pxm >= 0)
	220	sd->node = pxm_to_node(pxm);
	221	#endif
	222
	223	bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
	224	if (!bus)
	225	kfree(sd);
	226
69e1a33f AK	227	#ifdef CONFIG_ACPI_NUMA
69e1a33f AK	228	if (bus != NULL) {
69e1a33f	229	if (pxm >= 0) {
08f1c192 MBY	230	printk("bus %d -> pxm %d -> node %d\n",
08f1c192 MBY	231	busnum, pxm, sd->node);
69e1a33f AK	232	}
	233	}
	234	#endif
62f420f8 GH	235
	236	if (bus && (pci_probe & PCI_USE__CRS))
	237	get_current_resources(device, busnum, bus);
69e1a33f AK	238
69e1a33f AK	239	return bus;
1da177e4 LT	240	}
	241
	242	extern int pci_routeirq;
	243	static int __init pci_acpi_init(void)
	244	{
	245	struct pci_dev *dev = NULL;
	246
	247	if (pcibios_scanned)
	248	return 0;
	249
	250	if (acpi_noirq)
	251	return 0;
	252
	253	printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
	254	acpi_irq_penalty_init();
	255	pcibios_scanned++;
	256	pcibios_enable_irq = acpi_pci_irq_enable;
87bec66b	257	pcibios_disable_irq = acpi_pci_irq_disable;
1da177e4 LT	258
	259	if (pci_routeirq) {
	260	/*
	261	* PCI IRQ routing is set up by pci_enable_device(), but we
	262	* also do it here in case there are still broken drivers that
	263	* don't use pci_enable_device().
	264	*/
	265	printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
fb37fb96	266	for_each_pci_dev(dev)
1da177e4 LT	267	acpi_pci_irq_enable(dev);
	268	} else
	269	printk(KERN_INFO "PCI: If a device doesn't work, try \"pci=routeirq\". If it helps, post a report\n");
	270
	271	#ifdef CONFIG_X86_IO_APIC
	272	if (acpi_ioapic)
	273	print_IO_APIC();
	274	#endif
	275
	276	return 0;
	277	}
	278	subsys_initcall(pci_acpi_init);