amd_nb.c 7.3 KB
Newer Older
1 2 3 4
/*
 * Shared support code for AMD K8 northbridges and derivates.
 * Copyright 2006 Andi Kleen, SUSE Labs. Subject to GPLv2.
 */
5 6 7

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

8
#include <linux/types.h>
9
#include <linux/slab.h>
10 11 12 13
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/spinlock.h>
14
#include <asm/amd_nb.h>
15 16 17

static u32 *flush_words;

18
const struct pci_device_id amd_nb_misc_ids[] = {
19 20
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB_MISC) },
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_10H_NB_MISC) },
B
Borislav Petkov 已提交
21
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F3) },
22
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_M10H_F3) },
23
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_M30H_NB_F3) },
24
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_16H_NB_F3) },
25 26
	{}
};
27
EXPORT_SYMBOL(amd_nb_misc_ids);
28

J
Jan Beulich 已提交
29
static const struct pci_device_id amd_nb_link_ids[] = {
30
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F4) },
31
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_M30H_NB_F4) },
32
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_16H_NB_F4) },
33 34 35
	{}
};

36 37 38 39 40 41 42
const struct amd_nb_bus_dev_range amd_nb_bus_dev_ranges[] __initconst = {
	{ 0x00, 0x18, 0x20 },
	{ 0xff, 0x00, 0x20 },
	{ 0xfe, 0x00, 0x20 },
	{ }
};

43 44
struct amd_northbridge_info amd_northbridges;
EXPORT_SYMBOL(amd_northbridges);
45

46
static struct pci_dev *next_northbridge(struct pci_dev *dev,
47
					const struct pci_device_id *ids)
48 49 50 51 52
{
	do {
		dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev);
		if (!dev)
			break;
53
	} while (!pci_match_id(ids, dev));
54 55 56
	return dev;
}

57
int amd_cache_northbridges(void)
58
{
59
	u16 i = 0;
60
	struct amd_northbridge *nb;
61
	struct pci_dev *misc, *link;
62

63
	if (amd_nb_num())
64 65
		return 0;

66 67 68
	misc = NULL;
	while ((misc = next_northbridge(misc, amd_nb_misc_ids)) != NULL)
		i++;
69

70 71
	if (i == 0)
		return 0;
72

73 74
	nb = kzalloc(i * sizeof(struct amd_northbridge), GFP_KERNEL);
	if (!nb)
75 76
		return -ENOMEM;

77 78
	amd_northbridges.nb = nb;
	amd_northbridges.num = i;
79

80
	link = misc = NULL;
81 82 83
	for (i = 0; i != amd_nb_num(); i++) {
		node_to_amd_nb(i)->misc = misc =
			next_northbridge(misc, amd_nb_misc_ids);
84 85
		node_to_amd_nb(i)->link = link =
			next_northbridge(link, amd_nb_link_ids);
86
	}
87

88
	/* GART present only on Fam15h upto model 0fh */
89
	if (boot_cpu_data.x86 == 0xf || boot_cpu_data.x86 == 0x10 ||
90
	    (boot_cpu_data.x86 == 0x15 && boot_cpu_data.x86_model < 0x10))
91
		amd_northbridges.flags |= AMD_NB_GART;
92

93 94 95 96 97 98
	/*
	 * Check for L3 cache presence.
	 */
	if (!cpuid_edx(0x80000006))
		return 0;

99 100 101 102 103 104 105 106 107 108
	/*
	 * Some CPU families support L3 Cache Index Disable. There are some
	 * limitations because of E382 and E388 on family 0x10.
	 */
	if (boot_cpu_data.x86 == 0x10 &&
	    boot_cpu_data.x86_model >= 0x8 &&
	    (boot_cpu_data.x86_model > 0x9 ||
	     boot_cpu_data.x86_mask >= 0x1))
		amd_northbridges.flags |= AMD_NB_L3_INDEX_DISABLE;

109 110 111
	if (boot_cpu_data.x86 == 0x15)
		amd_northbridges.flags |= AMD_NB_L3_INDEX_DISABLE;

112 113 114 115
	/* L3 cache partitioning is supported on family 0x15 */
	if (boot_cpu_data.x86 == 0x15)
		amd_northbridges.flags |= AMD_NB_L3_PARTITIONING;

116 117
	return 0;
}
118
EXPORT_SYMBOL_GPL(amd_cache_northbridges);
119

120 121 122 123 124
/*
 * Ignores subdevice/subvendor but as far as I can figure out
 * they're useless anyways
 */
bool __init early_is_amd_nb(u32 device)
125
{
126
	const struct pci_device_id *id;
127
	u32 vendor = device & 0xffff;
128

129
	device >>= 16;
130
	for (id = amd_nb_misc_ids; id->vendor; id++)
131
		if (vendor == id->vendor && device == id->device)
132 133
			return true;
	return false;
134 135
}

136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
struct resource *amd_get_mmconfig_range(struct resource *res)
{
	u32 address;
	u64 base, msr;
	unsigned segn_busn_bits;

	if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
		return NULL;

	/* assume all cpus from fam10h have mmconfig */
        if (boot_cpu_data.x86 < 0x10)
		return NULL;

	address = MSR_FAM10H_MMIO_CONF_BASE;
	rdmsrl(address, msr);

	/* mmconfig is not enabled */
	if (!(msr & FAM10H_MMIO_CONF_ENABLE))
		return NULL;

	base = msr & (FAM10H_MMIO_CONF_BASE_MASK<<FAM10H_MMIO_CONF_BASE_SHIFT);

	segn_busn_bits = (msr >> FAM10H_MMIO_CONF_BUSRANGE_SHIFT) &
			 FAM10H_MMIO_CONF_BUSRANGE_MASK;

	res->flags = IORESOURCE_MEM;
	res->start = base;
	res->end = base + (1ULL<<(segn_busn_bits + 20)) - 1;
	return res;
}

167 168 169 170
int amd_get_subcaches(int cpu)
{
	struct pci_dev *link = node_to_amd_nb(amd_get_nb_id(cpu))->link;
	unsigned int mask;
171
	int cuid;
172 173 174 175 176 177 178 179 180 181

	if (!amd_nb_has_feature(AMD_NB_L3_PARTITIONING))
		return 0;

	pci_read_config_dword(link, 0x1d4, &mask);

	cuid = cpu_data(cpu).compute_unit_id;
	return (mask >> (4 * cuid)) & 0xf;
}

182
int amd_set_subcaches(int cpu, unsigned long mask)
183 184 185 186
{
	static unsigned int reset, ban;
	struct amd_northbridge *nb = node_to_amd_nb(amd_get_nb_id(cpu));
	unsigned int reg;
187
	int cuid;
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221

	if (!amd_nb_has_feature(AMD_NB_L3_PARTITIONING) || mask > 0xf)
		return -EINVAL;

	/* if necessary, collect reset state of L3 partitioning and BAN mode */
	if (reset == 0) {
		pci_read_config_dword(nb->link, 0x1d4, &reset);
		pci_read_config_dword(nb->misc, 0x1b8, &ban);
		ban &= 0x180000;
	}

	/* deactivate BAN mode if any subcaches are to be disabled */
	if (mask != 0xf) {
		pci_read_config_dword(nb->misc, 0x1b8, &reg);
		pci_write_config_dword(nb->misc, 0x1b8, reg & ~0x180000);
	}

	cuid = cpu_data(cpu).compute_unit_id;
	mask <<= 4 * cuid;
	mask |= (0xf ^ (1 << cuid)) << 26;

	pci_write_config_dword(nb->link, 0x1d4, mask);

	/* reset BAN mode if L3 partitioning returned to reset state */
	pci_read_config_dword(nb->link, 0x1d4, &reg);
	if (reg == reset) {
		pci_read_config_dword(nb->misc, 0x1b8, &reg);
		reg &= ~0x180000;
		pci_write_config_dword(nb->misc, 0x1b8, reg | ban);
	}

	return 0;
}

222
static int amd_cache_gart(void)
223
{
224
	u16 i;
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241

       if (!amd_nb_has_feature(AMD_NB_GART))
               return 0;

       flush_words = kmalloc(amd_nb_num() * sizeof(u32), GFP_KERNEL);
       if (!flush_words) {
               amd_northbridges.flags &= ~AMD_NB_GART;
               return -ENOMEM;
       }

       for (i = 0; i != amd_nb_num(); i++)
               pci_read_config_dword(node_to_amd_nb(i)->misc, 0x9c,
                                     &flush_words[i]);

       return 0;
}

242
void amd_flush_garts(void)
243 244 245 246 247
{
	int flushed, i;
	unsigned long flags;
	static DEFINE_SPINLOCK(gart_lock);

248
	if (!amd_nb_has_feature(AMD_NB_GART))
249 250
		return;

251 252 253 254 255 256
	/* Avoid races between AGP and IOMMU. In theory it's not needed
	   but I'm not sure if the hardware won't lose flush requests
	   when another is pending. This whole thing is so expensive anyways
	   that it doesn't matter to serialize more. -AK */
	spin_lock_irqsave(&gart_lock, flags);
	flushed = 0;
257 258 259
	for (i = 0; i < amd_nb_num(); i++) {
		pci_write_config_dword(node_to_amd_nb(i)->misc, 0x9c,
				       flush_words[i] | 1);
260 261
		flushed++;
	}
262
	for (i = 0; i < amd_nb_num(); i++) {
263 264 265
		u32 w;
		/* Make sure the hardware actually executed the flush*/
		for (;;) {
266
			pci_read_config_dword(node_to_amd_nb(i)->misc,
267 268 269 270 271 272 273 274
					      0x9c, &w);
			if (!(w & 1))
				break;
			cpu_relax();
		}
	}
	spin_unlock_irqrestore(&gart_lock, flags);
	if (!flushed)
275
		pr_notice("nothing to flush?\n");
276
}
277
EXPORT_SYMBOL_GPL(amd_flush_garts);
278

279
static __init int init_amd_nbs(void)
280 281 282
{
	int err = 0;

283
	err = amd_cache_northbridges();
284 285

	if (err < 0)
286
		pr_notice("Cannot enumerate AMD northbridges\n");
287

288
	if (amd_cache_gart() < 0)
289
		pr_notice("Cannot initialize GART flush words, GART support disabled\n");
290

291 292 293 294
	return err;
}

/* This has to go after the PCI subsystem */
295
fs_initcall(init_amd_nbs);