[linux-2.6-block.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,
			int domain, 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(16, GFP_KERNEL);
	if (!info.name)
		goto name_alloc_fail;
	sprintf(info.name, "PCI Bus %04x:%02x", domain, 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
	/*
	 * Maybe the desired pci bus has been already scanned. In such case
	 * it is unnecessary to scan the pci bus with the given domain,busnum.
	 */
	bus = pci_find_bus(domain, busnum);
	if (bus) {
		/*
		 * If the desired bus exits, the content of bus->sysdata will
		 * be replaced by sd.
		 */
		memcpy(bus->sysdata, sd, sizeof(*sd));
		kfree(sd);
	} else
		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, pxm_to_node(pxm));
		}
	}
#endif

	if (bus && (pci_probe & PCI_USE__CRS))
		get_current_resources(device, busnum, domain, 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,
cb3576fa	154	int domain, struct pci_bus *bus)
62f420f8 GH	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
cb3576fa	171	info.name = kmalloc(16, GFP_KERNEL);
62f420f8 GH	172	if (!info.name)
62f420f8 GH	173	goto name_alloc_fail;
cb3576fa	174	sprintf(info.name, "PCI Bus %04x:%02x", domain, busnum);
62f420f8 GH	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
b87e81e5	222	/*
	223	* Maybe the desired pci bus has been already scanned. In such case
	224	* it is unnecessary to scan the pci bus with the given domain,busnum.
	225	*/
	226	bus = pci_find_bus(domain, busnum);
	227	if (bus) {
	228	/*
	229	* If the desired bus exits, the content of bus->sysdata will
	230	* be replaced by sd.
	231	*/
	232	memcpy(bus->sysdata, sd, sizeof(*sd));
	233	kfree(sd);
	234	} else
	235	bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
08f1c192	236
08f1c192 MBY	237	if (!bus)
	238	kfree(sd);
	239
69e1a33f AK	240	#ifdef CONFIG_ACPI_NUMA
69e1a33f AK	241	if (bus != NULL) {
69e1a33f	242	if (pxm >= 0) {
08f1c192	243	printk("bus %d -> pxm %d -> node %d\n",
b87e81e5	244	busnum, pxm, pxm_to_node(pxm));
69e1a33f AK	245	}
	246	}
	247	#endif
62f420f8 GH	248
62f420f8 GH	249	if (bus && (pci_probe & PCI_USE__CRS))
cb3576fa	250	get_current_resources(device, busnum, domain, bus);
69e1a33f AK	251
69e1a33f AK	252	return bus;
1da177e4 LT	253	}
	254
	255	extern int pci_routeirq;
	256	static int __init pci_acpi_init(void)
	257	{
	258	struct pci_dev *dev = NULL;
	259
	260	if (pcibios_scanned)
	261	return 0;
	262
	263	if (acpi_noirq)
	264	return 0;
	265
	266	printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
	267	acpi_irq_penalty_init();
	268	pcibios_scanned++;
	269	pcibios_enable_irq = acpi_pci_irq_enable;
87bec66b	270	pcibios_disable_irq = acpi_pci_irq_disable;
1da177e4 LT	271
	272	if (pci_routeirq) {
	273	/*
	274	* PCI IRQ routing is set up by pci_enable_device(), but we
	275	* also do it here in case there are still broken drivers that
	276	* don't use pci_enable_device().
	277	*/
	278	printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
fb37fb96	279	for_each_pci_dev(dev)
1da177e4 LT	280	acpi_pci_irq_enable(dev);
	281	} else
	282	printk(KERN_INFO "PCI: If a device doesn't work, try \"pci=routeirq\". If it helps, post a report\n");
	283
	284	#ifdef CONFIG_X86_IO_APIC
	285	if (acpi_ioapic)
	286	print_IO_APIC();
	287	#endif
	288
	289	return 0;
	290	}
	291	subsys_initcall(pci_acpi_init);