[linux-2.6-block.git] / arch / x86 / kernel / early-quirks.c

/* Various workarounds for chipset bugs.
   This code runs very early and can't use the regular PCI subsystem
   The entries are keyed to PCI bridges which usually identify chipsets
   uniquely.
   This is only for whole classes of chipsets with specific problems which
   need early invasive action (e.g. before the timers are initialized).
   Most PCI device specific workarounds can be done later and should be
   in standard PCI quirks
   Mainboard specific bugs should be handled by DMI entries.
   CPU specific bugs in setup.c */

#include <linux/pci.h>
#include <linux/acpi.h>
#include <linux/pci_ids.h>
#include <asm/pci-direct.h>
#include <asm/dma.h>
#include <asm/io_apic.h>
#include <asm/apic.h>
#include <asm/iommu.h>
#include <asm/gart.h>

static void __init fix_hypertransport_config(int num, int slot, int func)
{
	u32 htcfg;
	/*
	 * we found a hypertransport bus
	 * make sure that we are broadcasting
	 * interrupts to all cpus on the ht bus
	 * if we're using extended apic ids
	 */
	htcfg = read_pci_config(num, slot, func, 0x68);
	if (htcfg & (1 << 18)) {
		printk(KERN_INFO "Detected use of extended apic ids "
				 "on hypertransport bus\n");
		if ((htcfg & (1 << 17)) == 0) {
			printk(KERN_INFO "Enabling hypertransport extended "
					 "apic interrupt broadcast\n");
			printk(KERN_INFO "Note this is a bios bug, "
					 "please contact your hw vendor\n");
			htcfg |= (1 << 17);
			write_pci_config(num, slot, func, 0x68, htcfg);
		}
	}


}

static void __init via_bugs(int  num, int slot, int func)
{
#ifdef CONFIG_GART_IOMMU
	if ((max_pfn > MAX_DMA32_PFN ||  force_iommu) &&
	    !gart_iommu_aperture_allowed) {
		printk(KERN_INFO
		       "Looks like a VIA chipset. Disabling IOMMU."
		       " Override with iommu=allowed\n");
		gart_iommu_aperture_disabled = 1;
	}
#endif
}

#ifdef CONFIG_ACPI
#ifdef CONFIG_X86_IO_APIC

static int __init nvidia_hpet_check(struct acpi_table_header *header)
{
	return 0;
}
#endif /* CONFIG_X86_IO_APIC */
#endif /* CONFIG_ACPI */

static void __init nvidia_bugs(int num, int slot, int func)
{
#ifdef CONFIG_ACPI
#ifdef CONFIG_X86_IO_APIC
	/*
	 * All timer overrides on Nvidia are
	 * wrong unless HPET is enabled.
	 * Unfortunately that's not true on many Asus boards.
	 * We don't know yet how to detect this automatically, but
	 * at least allow a command line override.
	 */
	if (acpi_use_timer_override)
		return;

	if (acpi_table_parse(ACPI_SIG_HPET, nvidia_hpet_check)) {
		acpi_skip_timer_override = 1;
		printk(KERN_INFO "Nvidia board "
		       "detected. Ignoring ACPI "
		       "timer override.\n");
		printk(KERN_INFO "If you got timer trouble "
			"try acpi_use_timer_override\n");
	}
#endif
#endif
	/* RED-PEN skip them on mptables too? */

}

#if defined(CONFIG_ACPI) && defined(CONFIG_X86_IO_APIC)
static u32 __init ati_ixp4x0_rev(int num, int slot, int func)
{
	u32 d;
	u8  b;

	b = read_pci_config_byte(num, slot, func, 0xac);
	b &= ~(1<<5);
	write_pci_config_byte(num, slot, func, 0xac, b);

	d = read_pci_config(num, slot, func, 0x70);
	d |= 1<<8;
	write_pci_config(num, slot, func, 0x70, d);

	d = read_pci_config(num, slot, func, 0x8);
	d &= 0xff;
	return d;
}

static void __init ati_bugs(int num, int slot, int func)
{
	u32 d;
	u8  b;

	if (acpi_use_timer_override)
		return;

	d = ati_ixp4x0_rev(num, slot, func);
	if (d  < 0x82)
		acpi_skip_timer_override = 1;
	else {
		/* check for IRQ0 interrupt swap */
		outb(0x72, 0xcd6); b = inb(0xcd7);
		if (!(b & 0x2))
			acpi_skip_timer_override = 1;
	}

	if (acpi_skip_timer_override) {
		printk(KERN_INFO "SB4X0 revision 0x%x\n", d);
		printk(KERN_INFO "Ignoring ACPI timer override.\n");
		printk(KERN_INFO "If you got timer trouble "
		       "try acpi_use_timer_override\n");
	}
}

static u32 __init ati_sbx00_rev(int num, int slot, int func)
{
	u32 old, d;

	d = read_pci_config(num, slot, func, 0x70);
	old = d;
	d &= ~(1<<8);
	write_pci_config(num, slot, func, 0x70, d);
	d = read_pci_config(num, slot, func, 0x8);
	d &= 0xff;
	write_pci_config(num, slot, func, 0x70, old);

	return d;
}

static void __init ati_bugs_contd(int num, int slot, int func)
{
	u32 d, rev;

	if (acpi_use_timer_override)
		return;

	rev = ati_sbx00_rev(num, slot, func);
	if (rev > 0x13)
		return;

	/* check for IRQ0 interrupt swap */
	d = read_pci_config(num, slot, func, 0x64);
	if (!(d & (1<<14)))
		acpi_skip_timer_override = 1;

	if (acpi_skip_timer_override) {
		printk(KERN_INFO "SB600 revision 0x%x\n", rev);
		printk(KERN_INFO "Ignoring ACPI timer override.\n");
		printk(KERN_INFO "If you got timer trouble "
		       "try acpi_use_timer_override\n");
	}
}
#else
static void __init ati_bugs(int num, int slot, int func)
{
}

static void __init ati_bugs_contd(int num, int slot, int func)
{
}
#endif

#define QFLAG_APPLY_ONCE 	0x1
#define QFLAG_APPLIED		0x2
#define QFLAG_DONE		(QFLAG_APPLY_ONCE|QFLAG_APPLIED)
struct chipset {
	u32 vendor;
	u32 device;
	u32 class;
	u32 class_mask;
	u32 flags;
	void (*f)(int num, int slot, int func);
};

/*
 * Only works for devices on the root bus. If you add any devices
 * not on bus 0 readd another loop level in early_quirks(). But
 * be careful because at least the Nvidia quirk here relies on
 * only matching on bus 0.
 */
static struct chipset early_qrk[] __initdata = {
	{ PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
	  PCI_CLASS_BRIDGE_PCI, PCI_ANY_ID, QFLAG_APPLY_ONCE, nvidia_bugs },
	{ PCI_VENDOR_ID_VIA, PCI_ANY_ID,
	  PCI_CLASS_BRIDGE_PCI, PCI_ANY_ID, QFLAG_APPLY_ONCE, via_bugs },
	{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB,
	  PCI_CLASS_BRIDGE_HOST, PCI_ANY_ID, 0, fix_hypertransport_config },
	{ PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_SMBUS,
	  PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_bugs },
	{ PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS,
	  PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_bugs_contd },
	{}
};

/**
 * check_dev_quirk - apply early quirks to a given PCI device
 * @num: bus number
 * @slot: slot number
 * @func: PCI function
 *
 * Check the vendor & device ID against the early quirks table.
 *
 * If the device is single function, let early_quirks() know so we don't
 * poke at this device again.
 */
static int __init check_dev_quirk(int num, int slot, int func)
{
	u16 class;
	u16 vendor;
	u16 device;
	u8 type;
	int i;

	class = read_pci_config_16(num, slot, func, PCI_CLASS_DEVICE);

	if (class == 0xffff)
		return -1; /* no class, treat as single function */

	vendor = read_pci_config_16(num, slot, func, PCI_VENDOR_ID);

	device = read_pci_config_16(num, slot, func, PCI_DEVICE_ID);

	for (i = 0; early_qrk[i].f != NULL; i++) {
		if (((early_qrk[i].vendor == PCI_ANY_ID) ||
			(early_qrk[i].vendor == vendor)) &&
			((early_qrk[i].device == PCI_ANY_ID) ||
			(early_qrk[i].device == device)) &&
			(!((early_qrk[i].class ^ class) &
			    early_qrk[i].class_mask))) {
				if ((early_qrk[i].flags &
				     QFLAG_DONE) != QFLAG_DONE)
					early_qrk[i].f(num, slot, func);
				early_qrk[i].flags |= QFLAG_APPLIED;
			}
	}

	type = read_pci_config_byte(num, slot, func,
				    PCI_HEADER_TYPE);
	if (!(type & 0x80))
		return -1;

	return 0;
}

void __init early_quirks(void)
{
	int slot, func;

	if (!early_pci_allowed())
		return;

	/* Poor man's PCI discovery */
	/* Only scan the root bus */
	for (slot = 0; slot < 32; slot++)
		for (func = 0; func < 8; func++) {
			/* Only probe function 0 on single fn devices */
			if (check_dev_quirk(0, slot, func))
				break;
		}
}
Commit	Line	Data
dfa4698c AK	1	/* Various workarounds for chipset bugs.
	2	This code runs very early and can't use the regular PCI subsystem
	3	The entries are keyed to PCI bridges which usually identify chipsets
	4	uniquely.
	5	This is only for whole classes of chipsets with specific problems which
	6	need early invasive action (e.g. before the timers are initialized).
	7	Most PCI device specific workarounds can be done later and should be
	8	in standard PCI quirks
	9	Mainboard specific bugs should be handled by DMI entries.
	10	CPU specific bugs in setup.c */
	11
	12	#include <linux/pci.h>
	13	#include <linux/acpi.h>
	14	#include <linux/pci_ids.h>
	15	#include <asm/pci-direct.h>
dfa4698c	16	#include <asm/dma.h>
54ef3400 AK	17	#include <asm/io_apic.h>
54ef3400 AK	18	#include <asm/apic.h>
46a7fa27	19	#include <asm/iommu.h>
1d9b16d1	20	#include <asm/gart.h>
dfa4698c	21
c6b48324 NH	22	static void __init fix_hypertransport_config(int num, int slot, int func)
	23	{
	24	u32 htcfg;
	25	/*
	26	* we found a hypertransport bus
	27	* make sure that we are broadcasting
	28	* interrupts to all cpus on the ht bus
	29	* if we're using extended apic ids
	30	*/
	31	htcfg = read_pci_config(num, slot, func, 0x68);
	32	if (htcfg & (1 << 18)) {
7bcbc78d NH	33	printk(KERN_INFO "Detected use of extended apic ids "
7bcbc78d NH	34	"on hypertransport bus\n");
c6b48324	35	if ((htcfg & (1 << 17)) == 0) {
7bcbc78d NH	36	printk(KERN_INFO "Enabling hypertransport extended "
	37	"apic interrupt broadcast\n");
	38	printk(KERN_INFO "Note this is a bios bug, "
	39	"please contact your hw vendor\n");
c6b48324 NH	40	htcfg \|= (1 << 17);
	41	write_pci_config(num, slot, func, 0x68, htcfg);
	42	}
	43	}
	44
	45
	46	}
	47
	48	static void __init via_bugs(int num, int slot, int func)
dfa4698c	49	{
966396d3	50	#ifdef CONFIG_GART_IOMMU
c987d12f	51	if ((max_pfn > MAX_DMA32_PFN \|\| force_iommu) &&
0440d4c0	52	!gart_iommu_aperture_allowed) {
dfa4698c	53	printk(KERN_INFO
54ef3400 AK	54	"Looks like a VIA chipset. Disabling IOMMU."
54ef3400 AK	55	" Override with iommu=allowed\n");
0440d4c0	56	gart_iommu_aperture_disabled = 1;
dfa4698c AK	57	}
	58	#endif
	59	}
	60
	61	#ifdef CONFIG_ACPI
03d0d20e	62	#ifdef CONFIG_X86_IO_APIC
dfa4698c	63
15a58ed1	64	static int __init nvidia_hpet_check(struct acpi_table_header *header)
dfa4698c	65	{
dfa4698c AK	66	return 0;
dfa4698c AK	67	}
03d0d20e JG	68	#endif /* CONFIG_X86_IO_APIC */
03d0d20e JG	69	#endif /* CONFIG_ACPI */
dfa4698c	70
c6b48324	71	static void __init nvidia_bugs(int num, int slot, int func)
dfa4698c AK	72	{
dfa4698c AK	73	#ifdef CONFIG_ACPI
54ef3400	74	#ifdef CONFIG_X86_IO_APIC
dfa4698c AK	75	/*
	76	* All timer overrides on Nvidia are
	77	* wrong unless HPET is enabled.
fa18f477 AK	78	* Unfortunately that's not true on many Asus boards.
	79	* We don't know yet how to detect this automatically, but
	80	* at least allow a command line override.
dfa4698c	81	*/
fa18f477 AK	82	if (acpi_use_timer_override)
	83	return;
	84
fe699336	85	if (acpi_table_parse(ACPI_SIG_HPET, nvidia_hpet_check)) {
dfa4698c AK	86	acpi_skip_timer_override = 1;
	87	printk(KERN_INFO "Nvidia board "
	88	"detected. Ignoring ACPI "
	89	"timer override.\n");
fa18f477 AK	90	printk(KERN_INFO "If you got timer trouble "
fa18f477 AK	91	"try acpi_use_timer_override\n");
dfa4698c	92	}
54ef3400	93	#endif
dfa4698c AK	94	#endif
	95	/* RED-PEN skip them on mptables too? */
	96
	97	}
	98
26adcfbf AH	99	#if defined(CONFIG_ACPI) && defined(CONFIG_X86_IO_APIC)
26adcfbf AH	100	static u32 __init ati_ixp4x0_rev(int num, int slot, int func)
33fb0e4e AH	101	{
	102	u32 d;
	103	u8 b;
	104
	105	b = read_pci_config_byte(num, slot, func, 0xac);
	106	b &= ~(1<<5);
	107	write_pci_config_byte(num, slot, func, 0xac, b);
	108
	109	d = read_pci_config(num, slot, func, 0x70);
	110	d \|= 1<<8;
	111	write_pci_config(num, slot, func, 0x70, d);
	112
	113	d = read_pci_config(num, slot, func, 0x8);
	114	d &= 0xff;
	115	return d;
	116	}
	117
	118	static void __init ati_bugs(int num, int slot, int func)
	119	{
33fb0e4e AH	120	u32 d;
	121	u8 b;
	122
	123	if (acpi_use_timer_override)
	124	return;
	125
	126	d = ati_ixp4x0_rev(num, slot, func);
	127	if (d < 0x82)
	128	acpi_skip_timer_override = 1;
	129	else {
	130	/* check for IRQ0 interrupt swap */
	131	outb(0x72, 0xcd6); b = inb(0xcd7);
	132	if (!(b & 0x2))
	133	acpi_skip_timer_override = 1;
	134	}
	135
	136	if (acpi_skip_timer_override) {
	137	printk(KERN_INFO "SB4X0 revision 0x%x\n", d);
	138	printk(KERN_INFO "Ignoring ACPI timer override.\n");
	139	printk(KERN_INFO "If you got timer trouble "
	140	"try acpi_use_timer_override\n");
	141	}
33fb0e4e AH	142	}
33fb0e4e AH	143
26adcfbf AH	144	static u32 __init ati_sbx00_rev(int num, int slot, int func)
	145	{
	146	u32 old, d;
	147
	148	d = read_pci_config(num, slot, func, 0x70);
	149	old = d;
	150	d &= ~(1<<8);
	151	write_pci_config(num, slot, func, 0x70, d);
	152	d = read_pci_config(num, slot, func, 0x8);
	153	d &= 0xff;
	154	write_pci_config(num, slot, func, 0x70, old);
	155
	156	return d;
	157	}
	158
	159	static void __init ati_bugs_contd(int num, int slot, int func)
	160	{
	161	u32 d, rev;
	162
	163	if (acpi_use_timer_override)
	164	return;
	165
	166	rev = ati_sbx00_rev(num, slot, func);
	167	if (rev > 0x13)
	168	return;
	169
	170	/* check for IRQ0 interrupt swap */
	171	d = read_pci_config(num, slot, func, 0x64);
	172	if (!(d & (1<<14)))
	173	acpi_skip_timer_override = 1;
	174
	175	if (acpi_skip_timer_override) {
	176	printk(KERN_INFO "SB600 revision 0x%x\n", rev);
	177	printk(KERN_INFO "Ignoring ACPI timer override.\n");
	178	printk(KERN_INFO "If you got timer trouble "
	179	"try acpi_use_timer_override\n");
	180	}
	181	}
	182	#else
	183	static void __init ati_bugs(int num, int slot, int func)
	184	{
	185	}
	186
	187	static void __init ati_bugs_contd(int num, int slot, int func)
	188	{
	189	}
	190	#endif
	191
c6b48324 NH	192	#define QFLAG_APPLY_ONCE 0x1
	193	#define QFLAG_APPLIED 0x2
	194	#define QFLAG_DONE (QFLAG_APPLY_ONCE\|QFLAG_APPLIED)
dfa4698c	195	struct chipset {
c6b48324 NH	196	u32 vendor;
	197	u32 device;
	198	u32 class;
	199	u32 class_mask;
	200	u32 flags;
	201	void (*f)(int num, int slot, int func);
dfa4698c AK	202	};
dfa4698c AK	203
8659c406 AK	204	/*
	205	* Only works for devices on the root bus. If you add any devices
	206	* not on bus 0 readd another loop level in early_quirks(). But
	207	* be careful because at least the Nvidia quirk here relies on
	208	* only matching on bus 0.
	209	*/
c993c735	210	static struct chipset early_qrk[] __initdata = {
c6b48324 NH	211	{ PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
	212	PCI_CLASS_BRIDGE_PCI, PCI_ANY_ID, QFLAG_APPLY_ONCE, nvidia_bugs },
	213	{ PCI_VENDOR_ID_VIA, PCI_ANY_ID,
	214	PCI_CLASS_BRIDGE_PCI, PCI_ANY_ID, QFLAG_APPLY_ONCE, via_bugs },
c6b48324 NH	215	{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB,
c6b48324 NH	216	PCI_CLASS_BRIDGE_HOST, PCI_ANY_ID, 0, fix_hypertransport_config },
33fb0e4e AH	217	{ PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_SMBUS,
33fb0e4e AH	218	PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_bugs },
26adcfbf AH	219	{ PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS,
26adcfbf AH	220	PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_bugs_contd },
dfa4698c AK	221	{}
	222	};
	223
15650a2f JB	224	/**
	225	* check_dev_quirk - apply early quirks to a given PCI device
	226	* @num: bus number
	227	* @slot: slot number
	228	* @func: PCI function
	229	*
	230	* Check the vendor & device ID against the early quirks table.
	231	*
	232	* If the device is single function, let early_quirks() know so we don't
	233	* poke at this device again.
	234	*/
	235	static int __init check_dev_quirk(int num, int slot, int func)
7bcbc78d NH	236	{
	237	u16 class;
	238	u16 vendor;
	239	u16 device;
	240	u8 type;
	241	int i;
	242
	243	class = read_pci_config_16(num, slot, func, PCI_CLASS_DEVICE);
	244
	245	if (class == 0xffff)
15650a2f	246	return -1; /* no class, treat as single function */
7bcbc78d NH	247
	248	vendor = read_pci_config_16(num, slot, func, PCI_VENDOR_ID);
	249
	250	device = read_pci_config_16(num, slot, func, PCI_DEVICE_ID);
	251
	252	for (i = 0; early_qrk[i].f != NULL; i++) {
	253	if (((early_qrk[i].vendor == PCI_ANY_ID) \|\|
	254	(early_qrk[i].vendor == vendor)) &&
	255	((early_qrk[i].device == PCI_ANY_ID) \|\|
	256	(early_qrk[i].device == device)) &&
	257	(!((early_qrk[i].class ^ class) &
	258	early_qrk[i].class_mask))) {
	259	if ((early_qrk[i].flags &
	260	QFLAG_DONE) != QFLAG_DONE)
	261	early_qrk[i].f(num, slot, func);
	262	early_qrk[i].flags \|= QFLAG_APPLIED;
	263	}
	264	}
	265
	266	type = read_pci_config_byte(num, slot, func,
	267	PCI_HEADER_TYPE);
	268	if (!(type & 0x80))
15650a2f JB	269	return -1;
	270
	271	return 0;
7bcbc78d NH	272	}
7bcbc78d NH	273
dfa4698c AK	274	void __init early_quirks(void)
dfa4698c AK	275	{
8659c406	276	int slot, func;
0637a70a AK	277
	278	if (!early_pci_allowed())
	279	return;
	280
dfa4698c	281	/* Poor man's PCI discovery */
8659c406 AK	282	/* Only scan the root bus */
	283	for (slot = 0; slot < 32; slot++)
	284	for (func = 0; func < 8; func++) {
	285	/* Only probe function 0 on single fn devices */
	286	if (check_dev_quirk(0, slot, func))
	287	break;
	288	}
dfa4698c	289	}