Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * This file contains work-arounds for x86 and x86_64 platform bugs.
4 : : */
5 : : #include <linux/dmi.h>
6 : : #include <linux/pci.h>
7 : : #include <linux/irq.h>
8 : :
9 : : #include <asm/hpet.h>
10 : : #include <asm/setup.h>
11 : :
12 : : #if defined(CONFIG_X86_IO_APIC) && defined(CONFIG_SMP) && defined(CONFIG_PCI)
13 : :
14 : 0 : static void quirk_intel_irqbalance(struct pci_dev *dev)
15 : : {
16 : 0 : u8 config;
17 : 0 : u16 word;
18 : :
19 : : /* BIOS may enable hardware IRQ balancing for
20 : : * E7520/E7320/E7525(revision ID 0x9 and below)
21 : : * based platforms.
22 : : * Disable SW irqbalance/affinity on those platforms.
23 : : */
24 [ # # ]: 0 : if (dev->revision > 0x9)
25 : 0 : return;
26 : :
27 : : /* enable access to config space*/
28 : 0 : pci_read_config_byte(dev, 0xf4, &config);
29 : 0 : pci_write_config_byte(dev, 0xf4, config|0x2);
30 : :
31 : : /*
32 : : * read xTPR register. We may not have a pci_dev for device 8
33 : : * because it might be hidden until the above write.
34 : : */
35 : 0 : pci_bus_read_config_word(dev->bus, PCI_DEVFN(8, 0), 0x4c, &word);
36 : :
37 [ # # ]: 0 : if (!(word & (1 << 13))) {
38 : 0 : dev_info(&dev->dev, "Intel E7520/7320/7525 detected; "
39 : : "disabling irq balancing and affinity\n");
40 : 0 : noirqdebug_setup("");
41 : : #ifdef CONFIG_PROC_FS
42 : 0 : no_irq_affinity = 1;
43 : : #endif
44 : : }
45 : :
46 : : /* put back the original value for config space*/
47 [ # # ]: 0 : if (!(config & 0x2))
48 : 0 : pci_write_config_byte(dev, 0xf4, config);
49 : : }
50 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7320_MCH,
51 : : quirk_intel_irqbalance);
52 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7525_MCH,
53 : : quirk_intel_irqbalance);
54 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7520_MCH,
55 : : quirk_intel_irqbalance);
56 : : #endif
57 : :
58 : : #if defined(CONFIG_HPET_TIMER)
59 : : unsigned long force_hpet_address;
60 : :
61 : : static enum {
62 : : NONE_FORCE_HPET_RESUME,
63 : : OLD_ICH_FORCE_HPET_RESUME,
64 : : ICH_FORCE_HPET_RESUME,
65 : : VT8237_FORCE_HPET_RESUME,
66 : : NVIDIA_FORCE_HPET_RESUME,
67 : : ATI_FORCE_HPET_RESUME,
68 : : } force_hpet_resume_type;
69 : :
70 : : static void __iomem *rcba_base;
71 : :
72 : 0 : static void ich_force_hpet_resume(void)
73 : : {
74 : 0 : u32 val;
75 : :
76 [ # # ]: 0 : if (!force_hpet_address)
77 : : return;
78 : :
79 [ # # ]: 0 : BUG_ON(rcba_base == NULL);
80 : :
81 : : /* read the Function Disable register, dword mode only */
82 : 0 : val = readl(rcba_base + 0x3404);
83 [ # # ]: 0 : if (!(val & 0x80)) {
84 : : /* HPET disabled in HPTC. Trying to enable */
85 : 0 : writel(val | 0x80, rcba_base + 0x3404);
86 : : }
87 : :
88 : 0 : val = readl(rcba_base + 0x3404);
89 [ # # ]: 0 : if (!(val & 0x80))
90 : 0 : BUG();
91 : : else
92 : 0 : printk(KERN_DEBUG "Force enabled HPET at resume\n");
93 : : }
94 : :
95 : 0 : static void ich_force_enable_hpet(struct pci_dev *dev)
96 : : {
97 : 0 : u32 val;
98 : 0 : u32 uninitialized_var(rcba);
99 : 0 : int err = 0;
100 : :
101 [ # # # # ]: 0 : if (hpet_address || force_hpet_address)
102 : 0 : return;
103 : :
104 : 0 : pci_read_config_dword(dev, 0xF0, &rcba);
105 : 0 : rcba &= 0xFFFFC000;
106 [ # # ]: 0 : if (rcba == 0) {
107 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "RCBA disabled; "
108 : : "cannot force enable HPET\n");
109 : 0 : return;
110 : : }
111 : :
112 : : /* use bits 31:14, 16 kB aligned */
113 : 0 : rcba_base = ioremap(rcba, 0x4000);
114 [ # # ]: 0 : if (rcba_base == NULL) {
115 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "ioremap failed; "
116 : : "cannot force enable HPET\n");
117 : 0 : return;
118 : : }
119 : :
120 : : /* read the Function Disable register, dword mode only */
121 : 0 : val = readl(rcba_base + 0x3404);
122 : :
123 [ # # ]: 0 : if (val & 0x80) {
124 : : /* HPET is enabled in HPTC. Just not reported by BIOS */
125 : 0 : val = val & 0x3;
126 : 0 : force_hpet_address = 0xFED00000 | (val << 12);
127 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
128 : : "0x%lx\n", force_hpet_address);
129 : 0 : iounmap(rcba_base);
130 : 0 : return;
131 : : }
132 : :
133 : : /* HPET disabled in HPTC. Trying to enable */
134 : 0 : writel(val | 0x80, rcba_base + 0x3404);
135 : :
136 : 0 : val = readl(rcba_base + 0x3404);
137 [ # # ]: 0 : if (!(val & 0x80)) {
138 : : err = 1;
139 : : } else {
140 : 0 : val = val & 0x3;
141 : 0 : force_hpet_address = 0xFED00000 | (val << 12);
142 : : }
143 : :
144 : 0 : if (err) {
145 : 0 : force_hpet_address = 0;
146 : 0 : iounmap(rcba_base);
147 : 0 : dev_printk(KERN_DEBUG, &dev->dev,
148 : : "Failed to force enable HPET\n");
149 : : } else {
150 : 0 : force_hpet_resume_type = ICH_FORCE_HPET_RESUME;
151 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
152 : : "0x%lx\n", force_hpet_address);
153 : : }
154 : : }
155 : :
156 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_0,
157 : : ich_force_enable_hpet);
158 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0,
159 : : ich_force_enable_hpet);
160 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1,
161 : : ich_force_enable_hpet);
162 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0,
163 : : ich_force_enable_hpet);
164 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_1,
165 : : ich_force_enable_hpet);
166 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_31,
167 : : ich_force_enable_hpet);
168 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_1,
169 : : ich_force_enable_hpet);
170 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_4,
171 : : ich_force_enable_hpet);
172 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_7,
173 : : ich_force_enable_hpet);
174 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x3a16, /* ICH10 */
175 : : ich_force_enable_hpet);
176 : :
177 : : static struct pci_dev *cached_dev;
178 : :
179 : 0 : static void hpet_print_force_info(void)
180 : : {
181 : 0 : printk(KERN_INFO "HPET not enabled in BIOS. "
182 : : "You might try hpet=force boot option\n");
183 : 0 : }
184 : :
185 : 0 : static void old_ich_force_hpet_resume(void)
186 : : {
187 : 0 : u32 val;
188 : 0 : u32 uninitialized_var(gen_cntl);
189 : :
190 [ # # # # ]: 0 : if (!force_hpet_address || !cached_dev)
191 : 0 : return;
192 : :
193 : 0 : pci_read_config_dword(cached_dev, 0xD0, &gen_cntl);
194 : 0 : gen_cntl &= (~(0x7 << 15));
195 : 0 : gen_cntl |= (0x4 << 15);
196 : :
197 : 0 : pci_write_config_dword(cached_dev, 0xD0, gen_cntl);
198 : 0 : pci_read_config_dword(cached_dev, 0xD0, &gen_cntl);
199 : 0 : val = gen_cntl >> 15;
200 : 0 : val &= 0x7;
201 [ # # ]: 0 : if (val == 0x4)
202 : 0 : printk(KERN_DEBUG "Force enabled HPET at resume\n");
203 : : else
204 : 0 : BUG();
205 : : }
206 : :
207 : 0 : static void old_ich_force_enable_hpet(struct pci_dev *dev)
208 : : {
209 : 0 : u32 val;
210 : 0 : u32 uninitialized_var(gen_cntl);
211 : :
212 [ # # # # ]: 0 : if (hpet_address || force_hpet_address)
213 : 0 : return;
214 : :
215 : 0 : pci_read_config_dword(dev, 0xD0, &gen_cntl);
216 : : /*
217 : : * Bit 17 is HPET enable bit.
218 : : * Bit 16:15 control the HPET base address.
219 : : */
220 : 0 : val = gen_cntl >> 15;
221 : 0 : val &= 0x7;
222 [ # # ]: 0 : if (val & 0x4) {
223 : 0 : val &= 0x3;
224 : 0 : force_hpet_address = 0xFED00000 | (val << 12);
225 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "HPET at 0x%lx\n",
226 : : force_hpet_address);
227 : 0 : return;
228 : : }
229 : :
230 : : /*
231 : : * HPET is disabled. Trying enabling at FED00000 and check
232 : : * whether it sticks
233 : : */
234 : 0 : gen_cntl &= (~(0x7 << 15));
235 : 0 : gen_cntl |= (0x4 << 15);
236 : 0 : pci_write_config_dword(dev, 0xD0, gen_cntl);
237 : :
238 : 0 : pci_read_config_dword(dev, 0xD0, &gen_cntl);
239 : :
240 : 0 : val = gen_cntl >> 15;
241 : 0 : val &= 0x7;
242 [ # # ]: 0 : if (val & 0x4) {
243 : : /* HPET is enabled in HPTC. Just not reported by BIOS */
244 : 0 : val &= 0x3;
245 : 0 : force_hpet_address = 0xFED00000 | (val << 12);
246 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
247 : : "0x%lx\n", force_hpet_address);
248 : 0 : cached_dev = dev;
249 : 0 : force_hpet_resume_type = OLD_ICH_FORCE_HPET_RESUME;
250 : 0 : return;
251 : : }
252 : :
253 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Failed to force enable HPET\n");
254 : : }
255 : :
256 : : /*
257 : : * Undocumented chipset features. Make sure that the user enforced
258 : : * this.
259 : : */
260 : 0 : static void old_ich_force_enable_hpet_user(struct pci_dev *dev)
261 : : {
262 [ # # ]: 0 : if (hpet_force_user)
263 : 0 : old_ich_force_enable_hpet(dev);
264 : 0 : }
265 : :
266 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1,
267 : : old_ich_force_enable_hpet_user);
268 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0,
269 : : old_ich_force_enable_hpet_user);
270 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12,
271 : : old_ich_force_enable_hpet_user);
272 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0,
273 : : old_ich_force_enable_hpet_user);
274 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12,
275 : : old_ich_force_enable_hpet_user);
276 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0,
277 : : old_ich_force_enable_hpet);
278 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_12,
279 : : old_ich_force_enable_hpet);
280 : :
281 : :
282 : 0 : static void vt8237_force_hpet_resume(void)
283 : : {
284 : 0 : u32 val;
285 : :
286 [ # # # # ]: 0 : if (!force_hpet_address || !cached_dev)
287 : 0 : return;
288 : :
289 : 0 : val = 0xfed00000 | 0x80;
290 : 0 : pci_write_config_dword(cached_dev, 0x68, val);
291 : :
292 : 0 : pci_read_config_dword(cached_dev, 0x68, &val);
293 [ # # ]: 0 : if (val & 0x80)
294 : 0 : printk(KERN_DEBUG "Force enabled HPET at resume\n");
295 : : else
296 : 0 : BUG();
297 : : }
298 : :
299 : 0 : static void vt8237_force_enable_hpet(struct pci_dev *dev)
300 : : {
301 : 0 : u32 uninitialized_var(val);
302 : :
303 [ # # # # ]: 0 : if (hpet_address || force_hpet_address)
304 : 0 : return;
305 : :
306 [ # # ]: 0 : if (!hpet_force_user) {
307 : 0 : hpet_print_force_info();
308 : 0 : return;
309 : : }
310 : :
311 : 0 : pci_read_config_dword(dev, 0x68, &val);
312 : : /*
313 : : * Bit 7 is HPET enable bit.
314 : : * Bit 31:10 is HPET base address (contrary to what datasheet claims)
315 : : */
316 [ # # ]: 0 : if (val & 0x80) {
317 : 0 : force_hpet_address = (val & ~0x3ff);
318 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "HPET at 0x%lx\n",
319 : : force_hpet_address);
320 : 0 : return;
321 : : }
322 : :
323 : : /*
324 : : * HPET is disabled. Trying enabling at FED00000 and check
325 : : * whether it sticks
326 : : */
327 : 0 : val = 0xfed00000 | 0x80;
328 : 0 : pci_write_config_dword(dev, 0x68, val);
329 : :
330 : 0 : pci_read_config_dword(dev, 0x68, &val);
331 [ # # ]: 0 : if (val & 0x80) {
332 : 0 : force_hpet_address = (val & ~0x3ff);
333 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
334 : : "0x%lx\n", force_hpet_address);
335 : 0 : cached_dev = dev;
336 : 0 : force_hpet_resume_type = VT8237_FORCE_HPET_RESUME;
337 : 0 : return;
338 : : }
339 : :
340 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Failed to force enable HPET\n");
341 : : }
342 : :
343 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235,
344 : : vt8237_force_enable_hpet);
345 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237,
346 : : vt8237_force_enable_hpet);
347 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700,
348 : : vt8237_force_enable_hpet);
349 : :
350 : 0 : static void ati_force_hpet_resume(void)
351 : : {
352 : 0 : pci_write_config_dword(cached_dev, 0x14, 0xfed00000);
353 : 0 : printk(KERN_DEBUG "Force enabled HPET at resume\n");
354 : 0 : }
355 : :
356 : 0 : static u32 ati_ixp4x0_rev(struct pci_dev *dev)
357 : : {
358 : 0 : int err = 0;
359 : 0 : u32 d = 0;
360 : 0 : u8 b = 0;
361 : :
362 : 0 : err = pci_read_config_byte(dev, 0xac, &b);
363 : 0 : b &= ~(1<<5);
364 : 0 : err |= pci_write_config_byte(dev, 0xac, b);
365 : 0 : err |= pci_read_config_dword(dev, 0x70, &d);
366 : 0 : d |= 1<<8;
367 : 0 : err |= pci_write_config_dword(dev, 0x70, d);
368 : 0 : err |= pci_read_config_dword(dev, 0x8, &d);
369 : 0 : d &= 0xff;
370 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "SB4X0 revision 0x%x\n", d);
371 : :
372 [ # # ]: 0 : WARN_ON_ONCE(err);
373 : :
374 : 0 : return d;
375 : : }
376 : :
377 : 0 : static void ati_force_enable_hpet(struct pci_dev *dev)
378 : : {
379 : 0 : u32 d, val;
380 : 0 : u8 b;
381 : :
382 [ # # # # ]: 0 : if (hpet_address || force_hpet_address)
383 : 0 : return;
384 : :
385 [ # # ]: 0 : if (!hpet_force_user) {
386 : 0 : hpet_print_force_info();
387 : 0 : return;
388 : : }
389 : :
390 : 0 : d = ati_ixp4x0_rev(dev);
391 [ # # ]: 0 : if (d < 0x82)
392 : : return;
393 : :
394 : : /* base address */
395 : 0 : pci_write_config_dword(dev, 0x14, 0xfed00000);
396 : 0 : pci_read_config_dword(dev, 0x14, &val);
397 : :
398 : : /* enable interrupt */
399 : 0 : outb(0x72, 0xcd6); b = inb(0xcd7);
400 : 0 : b |= 0x1;
401 : 0 : outb(0x72, 0xcd6); outb(b, 0xcd7);
402 : 0 : outb(0x72, 0xcd6); b = inb(0xcd7);
403 [ # # ]: 0 : if (!(b & 0x1))
404 : : return;
405 : 0 : pci_read_config_dword(dev, 0x64, &d);
406 : 0 : d |= (1<<10);
407 : 0 : pci_write_config_dword(dev, 0x64, d);
408 : 0 : pci_read_config_dword(dev, 0x64, &d);
409 [ # # ]: 0 : if (!(d & (1<<10)))
410 : : return;
411 : :
412 : 0 : force_hpet_address = val;
413 : 0 : force_hpet_resume_type = ATI_FORCE_HPET_RESUME;
414 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at 0x%lx\n",
415 : : force_hpet_address);
416 : 0 : cached_dev = dev;
417 : : }
418 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_SMBUS,
419 : : ati_force_enable_hpet);
420 : :
421 : : /*
422 : : * Undocumented chipset feature taken from LinuxBIOS.
423 : : */
424 : 0 : static void nvidia_force_hpet_resume(void)
425 : : {
426 : 0 : pci_write_config_dword(cached_dev, 0x44, 0xfed00001);
427 : 0 : printk(KERN_DEBUG "Force enabled HPET at resume\n");
428 : 0 : }
429 : :
430 : 0 : static void nvidia_force_enable_hpet(struct pci_dev *dev)
431 : : {
432 : 0 : u32 uninitialized_var(val);
433 : :
434 [ # # # # ]: 0 : if (hpet_address || force_hpet_address)
435 : 0 : return;
436 : :
437 [ # # ]: 0 : if (!hpet_force_user) {
438 : 0 : hpet_print_force_info();
439 : 0 : return;
440 : : }
441 : :
442 : 0 : pci_write_config_dword(dev, 0x44, 0xfed00001);
443 : 0 : pci_read_config_dword(dev, 0x44, &val);
444 : 0 : force_hpet_address = val & 0xfffffffe;
445 : 0 : force_hpet_resume_type = NVIDIA_FORCE_HPET_RESUME;
446 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at 0x%lx\n",
447 : : force_hpet_address);
448 : 0 : cached_dev = dev;
449 : : }
450 : :
451 : : /* ISA Bridges */
452 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0050,
453 : : nvidia_force_enable_hpet);
454 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0051,
455 : : nvidia_force_enable_hpet);
456 : :
457 : : /* LPC bridges */
458 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0260,
459 : : nvidia_force_enable_hpet);
460 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0360,
461 : : nvidia_force_enable_hpet);
462 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0361,
463 : : nvidia_force_enable_hpet);
464 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0362,
465 : : nvidia_force_enable_hpet);
466 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0363,
467 : : nvidia_force_enable_hpet);
468 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0364,
469 : : nvidia_force_enable_hpet);
470 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0365,
471 : : nvidia_force_enable_hpet);
472 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0366,
473 : : nvidia_force_enable_hpet);
474 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0367,
475 : : nvidia_force_enable_hpet);
476 : :
477 : 0 : void force_hpet_resume(void)
478 : : {
479 [ # # # # : 0 : switch (force_hpet_resume_type) {
# # ]
480 : 0 : case ICH_FORCE_HPET_RESUME:
481 : 0 : ich_force_hpet_resume();
482 : 0 : return;
483 : 0 : case OLD_ICH_FORCE_HPET_RESUME:
484 : 0 : old_ich_force_hpet_resume();
485 : 0 : return;
486 : 0 : case VT8237_FORCE_HPET_RESUME:
487 : 0 : vt8237_force_hpet_resume();
488 : 0 : return;
489 : 0 : case NVIDIA_FORCE_HPET_RESUME:
490 : 0 : nvidia_force_hpet_resume();
491 : 0 : return;
492 : 0 : case ATI_FORCE_HPET_RESUME:
493 : 0 : ati_force_hpet_resume();
494 : 0 : return;
495 : : default:
496 : : break;
497 : : }
498 : : }
499 : :
500 : : /*
501 : : * According to the datasheet e6xx systems have the HPET hardwired to
502 : : * 0xfed00000
503 : : */
504 : 0 : static void e6xx_force_enable_hpet(struct pci_dev *dev)
505 : : {
506 [ # # # # ]: 0 : if (hpet_address || force_hpet_address)
507 : : return;
508 : :
509 : 0 : force_hpet_address = 0xFED00000;
510 : 0 : force_hpet_resume_type = NONE_FORCE_HPET_RESUME;
511 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
512 : : "0x%lx\n", force_hpet_address);
513 : : }
514 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E6XX_CU,
515 : : e6xx_force_enable_hpet);
516 : :
517 : : /*
518 : : * HPET MSI on some boards (ATI SB700/SB800) has side effect on
519 : : * floppy DMA. Disable HPET MSI on such platforms.
520 : : * See erratum #27 (Misinterpreted MSI Requests May Result in
521 : : * Corrupted LPC DMA Data) in AMD Publication #46837,
522 : : * "SB700 Family Product Errata", Rev. 1.0, March 2010.
523 : : */
524 : 0 : static void force_disable_hpet_msi(struct pci_dev *unused)
525 : : {
526 : 0 : hpet_msi_disable = true;
527 : 0 : }
528 : :
529 : : DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS,
530 : : force_disable_hpet_msi);
531 : :
532 : : #endif
533 : :
534 : : #if defined(CONFIG_PCI) && defined(CONFIG_NUMA)
535 : : /* Set correct numa_node information for AMD NB functions */
536 : 0 : static void quirk_amd_nb_node(struct pci_dev *dev)
537 : : {
538 : 0 : struct pci_dev *nb_ht;
539 : 0 : unsigned int devfn;
540 : 0 : u32 node;
541 : 0 : u32 val;
542 : :
543 : 0 : devfn = PCI_DEVFN(PCI_SLOT(dev->devfn), 0);
544 : 0 : nb_ht = pci_get_slot(dev->bus, devfn);
545 [ # # ]: 0 : if (!nb_ht)
546 : 0 : return;
547 : :
548 : 0 : pci_read_config_dword(nb_ht, 0x60, &val);
549 : 0 : node = pcibus_to_node(dev->bus) | (val & 7);
550 : : /*
551 : : * Some hardware may return an invalid node ID,
552 : : * so check it first:
553 : : */
554 [ # # ]: 0 : if (node_online(node))
555 : 0 : set_dev_node(&dev->dev, node);
556 : 0 : pci_dev_put(nb_ht);
557 : : }
558 : :
559 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB,
560 : : quirk_amd_nb_node);
561 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP,
562 : : quirk_amd_nb_node);
563 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
564 : : quirk_amd_nb_node);
565 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB_MISC,
566 : : quirk_amd_nb_node);
567 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_10H_NB_HT,
568 : : quirk_amd_nb_node);
569 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_10H_NB_MAP,
570 : : quirk_amd_nb_node);
571 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_10H_NB_DRAM,
572 : : quirk_amd_nb_node);
573 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_10H_NB_MISC,
574 : : quirk_amd_nb_node);
575 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_10H_NB_LINK,
576 : : quirk_amd_nb_node);
577 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F0,
578 : : quirk_amd_nb_node);
579 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F1,
580 : : quirk_amd_nb_node);
581 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F2,
582 : : quirk_amd_nb_node);
583 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F3,
584 : : quirk_amd_nb_node);
585 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F4,
586 : : quirk_amd_nb_node);
587 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F5,
588 : : quirk_amd_nb_node);
589 : :
590 : : #endif
591 : :
592 : : #ifdef CONFIG_PCI
593 : : /*
594 : : * Processor does not ensure DRAM scrub read/write sequence
595 : : * is atomic wrt accesses to CC6 save state area. Therefore
596 : : * if a concurrent scrub read/write access is to same address
597 : : * the entry may appear as if it is not written. This quirk
598 : : * applies to Fam16h models 00h-0Fh
599 : : *
600 : : * See "Revision Guide" for AMD F16h models 00h-0fh,
601 : : * document 51810 rev. 3.04, Nov 2013
602 : : */
603 : 0 : static void amd_disable_seq_and_redirect_scrub(struct pci_dev *dev)
604 : : {
605 : 0 : u32 val;
606 : :
607 : : /*
608 : : * Suggested workaround:
609 : : * set D18F3x58[4:0] = 00h and set D18F3x5C[0] = 0b
610 : : */
611 : 0 : pci_read_config_dword(dev, 0x58, &val);
612 [ # # ]: 0 : if (val & 0x1F) {
613 : 0 : val &= ~(0x1F);
614 : 0 : pci_write_config_dword(dev, 0x58, val);
615 : : }
616 : :
617 : 0 : pci_read_config_dword(dev, 0x5C, &val);
618 [ # # ]: 0 : if (val & BIT(0)) {
619 : 0 : val &= ~BIT(0);
620 : 0 : pci_write_config_dword(dev, 0x5c, val);
621 : : }
622 : 0 : }
623 : :
624 : : DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_16H_NB_F3,
625 : : amd_disable_seq_and_redirect_scrub);
626 : :
627 : : #if defined(CONFIG_X86_64) && defined(CONFIG_X86_MCE)
628 : : #include <linux/jump_label.h>
629 : : #include <asm/string_64.h>
630 : :
631 : : /* Ivy Bridge, Haswell, Broadwell */
632 : 0 : static void quirk_intel_brickland_xeon_ras_cap(struct pci_dev *pdev)
633 : : {
634 : 0 : u32 capid0;
635 : :
636 : 0 : pci_read_config_dword(pdev, 0x84, &capid0);
637 : :
638 [ # # ]: 0 : if (capid0 & 0x10)
639 : 0 : static_branch_inc(&mcsafe_key);
640 : 0 : }
641 : :
642 : : /* Skylake */
643 : 0 : static void quirk_intel_purley_xeon_ras_cap(struct pci_dev *pdev)
644 : : {
645 : 0 : u32 capid0, capid5;
646 : :
647 : 0 : pci_read_config_dword(pdev, 0x84, &capid0);
648 : 0 : pci_read_config_dword(pdev, 0x98, &capid5);
649 : :
650 : : /*
651 : : * CAPID0{7:6} indicate whether this is an advanced RAS SKU
652 : : * CAPID5{8:5} indicate that various NVDIMM usage modes are
653 : : * enabled, so memory machine check recovery is also enabled.
654 : : */
655 [ # # # # ]: 0 : if ((capid0 & 0xc0) == 0xc0 || (capid5 & 0x1e0))
656 : 0 : static_branch_inc(&mcsafe_key);
657 : :
658 : 0 : }
659 : : DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x0ec3, quirk_intel_brickland_xeon_ras_cap);
660 : : DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x2fc0, quirk_intel_brickland_xeon_ras_cap);
661 : : DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fc0, quirk_intel_brickland_xeon_ras_cap);
662 : : DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x2083, quirk_intel_purley_xeon_ras_cap);
663 : : #endif
664 : : #endif
665 : :
666 : : bool x86_apple_machine;
667 : : EXPORT_SYMBOL(x86_apple_machine);
668 : :
669 : 3 : void __init early_platform_quirks(void)
670 : : {
671 [ + - - + ]: 6 : x86_apple_machine = dmi_match(DMI_SYS_VENDOR, "Apple Inc.") ||
672 : 3 : dmi_match(DMI_SYS_VENDOR, "Apple Computer, Inc.");
673 : 3 : }
|
