]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - arch/x86/include/asm/apic.h
Merge branch 'linus' into x86/apic
[karo-tx-linux.git] / arch / x86 / include / asm / apic.h
1 #ifndef _ASM_X86_APIC_H
2 #define _ASM_X86_APIC_H
3
4 #include <linux/cpumask.h>
5 #include <linux/pm.h>
6
7 #include <asm/alternative.h>
8 #include <asm/cpufeature.h>
9 #include <asm/processor.h>
10 #include <asm/apicdef.h>
11 #include <linux/atomic.h>
12 #include <asm/fixmap.h>
13 #include <asm/mpspec.h>
14 #include <asm/msr.h>
15 #include <asm/idle.h>
16
17 #define ARCH_APICTIMER_STOPS_ON_C3      1
18
19 /*
20  * Debugging macros
21  */
22 #define APIC_QUIET   0
23 #define APIC_VERBOSE 1
24 #define APIC_DEBUG   2
25
26 /*
27  * Define the default level of output to be very little
28  * This can be turned up by using apic=verbose for more
29  * information and apic=debug for _lots_ of information.
30  * apic_verbosity is defined in apic.c
31  */
32 #define apic_printk(v, s, a...) do {       \
33                 if ((v) <= apic_verbosity) \
34                         printk(s, ##a);    \
35         } while (0)
36
37
38 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86_32)
39 extern void generic_apic_probe(void);
40 #else
41 static inline void generic_apic_probe(void)
42 {
43 }
44 #endif
45
46 #ifdef CONFIG_X86_LOCAL_APIC
47
48 extern unsigned int apic_verbosity;
49 extern int local_apic_timer_c2_ok;
50
51 extern int disable_apic;
52 extern unsigned int lapic_timer_frequency;
53
54 #ifdef CONFIG_SMP
55 extern void __inquire_remote_apic(int apicid);
56 #else /* CONFIG_SMP */
57 static inline void __inquire_remote_apic(int apicid)
58 {
59 }
60 #endif /* CONFIG_SMP */
61
62 static inline void default_inquire_remote_apic(int apicid)
63 {
64         if (apic_verbosity >= APIC_DEBUG)
65                 __inquire_remote_apic(apicid);
66 }
67
68 /*
69  * With 82489DX we can't rely on apic feature bit
70  * retrieved via cpuid but still have to deal with
71  * such an apic chip so we assume that SMP configuration
72  * is found from MP table (64bit case uses ACPI mostly
73  * which set smp presence flag as well so we are safe
74  * to use this helper too).
75  */
76 static inline bool apic_from_smp_config(void)
77 {
78         return smp_found_config && !disable_apic;
79 }
80
81 /*
82  * Basic functions accessing APICs.
83  */
84 #ifdef CONFIG_PARAVIRT
85 #include <asm/paravirt.h>
86 #endif
87
88 extern int setup_profiling_timer(unsigned int);
89
90 static inline void native_apic_mem_write(u32 reg, u32 v)
91 {
92         volatile u32 *addr = (volatile u32 *)(APIC_BASE + reg);
93
94         alternative_io("movl %0, %P1", "xchgl %0, %P1", X86_BUG_11AP,
95                        ASM_OUTPUT2("=r" (v), "=m" (*addr)),
96                        ASM_OUTPUT2("0" (v), "m" (*addr)));
97 }
98
99 static inline u32 native_apic_mem_read(u32 reg)
100 {
101         return *((volatile u32 *)(APIC_BASE + reg));
102 }
103
104 extern void native_apic_wait_icr_idle(void);
105 extern u32 native_safe_apic_wait_icr_idle(void);
106 extern void native_apic_icr_write(u32 low, u32 id);
107 extern u64 native_apic_icr_read(void);
108
109 static inline bool apic_is_x2apic_enabled(void)
110 {
111         u64 msr;
112
113         if (rdmsrl_safe(MSR_IA32_APICBASE, &msr))
114                 return false;
115         return msr & X2APIC_ENABLE;
116 }
117
118 extern void enable_IR_x2apic(void);
119
120 extern int get_physical_broadcast(void);
121
122 extern int lapic_get_maxlvt(void);
123 extern void clear_local_APIC(void);
124 extern void disconnect_bsp_APIC(int virt_wire_setup);
125 extern void disable_local_APIC(void);
126 extern void lapic_shutdown(void);
127 extern void sync_Arb_IDs(void);
128 extern void init_bsp_APIC(void);
129 extern void setup_local_APIC(void);
130 extern void init_apic_mappings(void);
131 void register_lapic_address(unsigned long address);
132 extern void setup_boot_APIC_clock(void);
133 extern void setup_secondary_APIC_clock(void);
134 extern int APIC_init_uniprocessor(void);
135
136 #ifdef CONFIG_X86_64
137 static inline int apic_force_enable(unsigned long addr)
138 {
139         return -1;
140 }
141 #else
142 extern int apic_force_enable(unsigned long addr);
143 #endif
144
145 extern int apic_bsp_setup(bool upmode);
146 extern void apic_ap_setup(void);
147
148 /*
149  * On 32bit this is mach-xxx local
150  */
151 #ifdef CONFIG_X86_64
152 extern int apic_is_clustered_box(void);
153 #else
154 static inline int apic_is_clustered_box(void)
155 {
156         return 0;
157 }
158 #endif
159
160 extern int setup_APIC_eilvt(u8 lvt_off, u8 vector, u8 msg_type, u8 mask);
161
162 #else /* !CONFIG_X86_LOCAL_APIC */
163 static inline void lapic_shutdown(void) { }
164 #define local_apic_timer_c2_ok          1
165 static inline void init_apic_mappings(void) { }
166 static inline void disable_local_APIC(void) { }
167 # define setup_boot_APIC_clock x86_init_noop
168 # define setup_secondary_APIC_clock x86_init_noop
169 #endif /* !CONFIG_X86_LOCAL_APIC */
170
171 #ifdef CONFIG_X86_X2APIC
172 /*
173  * Make previous memory operations globally visible before
174  * sending the IPI through x2apic wrmsr. We need a serializing instruction or
175  * mfence for this.
176  */
177 static inline void x2apic_wrmsr_fence(void)
178 {
179         asm volatile("mfence" : : : "memory");
180 }
181
182 static inline void native_apic_msr_write(u32 reg, u32 v)
183 {
184         if (reg == APIC_DFR || reg == APIC_ID || reg == APIC_LDR ||
185             reg == APIC_LVR)
186                 return;
187
188         wrmsr(APIC_BASE_MSR + (reg >> 4), v, 0);
189 }
190
191 static inline void native_apic_msr_eoi_write(u32 reg, u32 v)
192 {
193         wrmsr(APIC_BASE_MSR + (APIC_EOI >> 4), APIC_EOI_ACK, 0);
194 }
195
196 static inline u32 native_apic_msr_read(u32 reg)
197 {
198         u64 msr;
199
200         if (reg == APIC_DFR)
201                 return -1;
202
203         rdmsrl(APIC_BASE_MSR + (reg >> 4), msr);
204         return (u32)msr;
205 }
206
207 static inline void native_x2apic_wait_icr_idle(void)
208 {
209         /* no need to wait for icr idle in x2apic */
210         return;
211 }
212
213 static inline u32 native_safe_x2apic_wait_icr_idle(void)
214 {
215         /* no need to wait for icr idle in x2apic */
216         return 0;
217 }
218
219 static inline void native_x2apic_icr_write(u32 low, u32 id)
220 {
221         wrmsrl(APIC_BASE_MSR + (APIC_ICR >> 4), ((__u64) id) << 32 | low);
222 }
223
224 static inline u64 native_x2apic_icr_read(void)
225 {
226         unsigned long val;
227
228         rdmsrl(APIC_BASE_MSR + (APIC_ICR >> 4), val);
229         return val;
230 }
231
232 extern int x2apic_mode;
233 extern int x2apic_phys;
234 extern void __init check_x2apic(void);
235 extern void x2apic_setup(void);
236 static inline int x2apic_enabled(void)
237 {
238         return cpu_has_x2apic && apic_is_x2apic_enabled();
239 }
240
241 #define x2apic_supported()      (cpu_has_x2apic)
242 #else /* !CONFIG_X86_X2APIC */
243 static inline void check_x2apic(void) { }
244 static inline void x2apic_setup(void) { }
245 static inline int x2apic_enabled(void) { return 0; }
246
247 #define x2apic_mode             (0)
248 #define x2apic_supported()      (0)
249 #endif /* !CONFIG_X86_X2APIC */
250
251 #ifdef CONFIG_X86_64
252 #define SET_APIC_ID(x)          (apic->set_apic_id(x))
253 #else
254
255 #endif
256
257 /*
258  * Copyright 2004 James Cleverdon, IBM.
259  * Subject to the GNU Public License, v.2
260  *
261  * Generic APIC sub-arch data struct.
262  *
263  * Hacked for x86-64 by James Cleverdon from i386 architecture code by
264  * Martin Bligh, Andi Kleen, James Bottomley, John Stultz, and
265  * James Cleverdon.
266  */
267 struct apic {
268         char *name;
269
270         int (*probe)(void);
271         int (*acpi_madt_oem_check)(char *oem_id, char *oem_table_id);
272         int (*apic_id_valid)(int apicid);
273         int (*apic_id_registered)(void);
274
275         u32 irq_delivery_mode;
276         u32 irq_dest_mode;
277
278         const struct cpumask *(*target_cpus)(void);
279
280         int disable_esr;
281
282         int dest_logical;
283         unsigned long (*check_apicid_used)(physid_mask_t *map, int apicid);
284
285         void (*vector_allocation_domain)(int cpu, struct cpumask *retmask,
286                                          const struct cpumask *mask);
287         void (*init_apic_ldr)(void);
288
289         void (*ioapic_phys_id_map)(physid_mask_t *phys_map, physid_mask_t *retmap);
290
291         void (*setup_apic_routing)(void);
292         int (*cpu_present_to_apicid)(int mps_cpu);
293         void (*apicid_to_cpu_present)(int phys_apicid, physid_mask_t *retmap);
294         int (*check_phys_apicid_present)(int phys_apicid);
295         int (*phys_pkg_id)(int cpuid_apic, int index_msb);
296
297         unsigned int (*get_apic_id)(unsigned long x);
298         unsigned long (*set_apic_id)(unsigned int id);
299         unsigned long apic_id_mask;
300
301         int (*cpu_mask_to_apicid_and)(const struct cpumask *cpumask,
302                                       const struct cpumask *andmask,
303                                       unsigned int *apicid);
304
305         /* ipi */
306         void (*send_IPI)(int cpu, int vector);
307         void (*send_IPI_mask)(const struct cpumask *mask, int vector);
308         void (*send_IPI_mask_allbutself)(const struct cpumask *mask,
309                                          int vector);
310         void (*send_IPI_allbutself)(int vector);
311         void (*send_IPI_all)(int vector);
312         void (*send_IPI_self)(int vector);
313
314         /* wakeup_secondary_cpu */
315         int (*wakeup_secondary_cpu)(int apicid, unsigned long start_eip);
316
317         void (*inquire_remote_apic)(int apicid);
318
319         /* apic ops */
320         u32 (*read)(u32 reg);
321         void (*write)(u32 reg, u32 v);
322         /*
323          * ->eoi_write() has the same signature as ->write().
324          *
325          * Drivers can support both ->eoi_write() and ->write() by passing the same
326          * callback value. Kernel can override ->eoi_write() and fall back
327          * on write for EOI.
328          */
329         void (*eoi_write)(u32 reg, u32 v);
330         u64 (*icr_read)(void);
331         void (*icr_write)(u32 low, u32 high);
332         void (*wait_icr_idle)(void);
333         u32 (*safe_wait_icr_idle)(void);
334
335 #ifdef CONFIG_X86_32
336         /*
337          * Called very early during boot from get_smp_config().  It should
338          * return the logical apicid.  x86_[bios]_cpu_to_apicid is
339          * initialized before this function is called.
340          *
341          * If logical apicid can't be determined that early, the function
342          * may return BAD_APICID.  Logical apicid will be configured after
343          * init_apic_ldr() while bringing up CPUs.  Note that NUMA affinity
344          * won't be applied properly during early boot in this case.
345          */
346         int (*x86_32_early_logical_apicid)(int cpu);
347 #endif
348 };
349
350 /*
351  * Pointer to the local APIC driver in use on this system (there's
352  * always just one such driver in use - the kernel decides via an
353  * early probing process which one it picks - and then sticks to it):
354  */
355 extern struct apic *apic;
356
357 /*
358  * APIC drivers are probed based on how they are listed in the .apicdrivers
359  * section. So the order is important and enforced by the ordering
360  * of different apic driver files in the Makefile.
361  *
362  * For the files having two apic drivers, we use apic_drivers()
363  * to enforce the order with in them.
364  */
365 #define apic_driver(sym)                                        \
366         static const struct apic *__apicdrivers_##sym __used            \
367         __aligned(sizeof(struct apic *))                        \
368         __section(.apicdrivers) = { &sym }
369
370 #define apic_drivers(sym1, sym2)                                        \
371         static struct apic *__apicdrivers_##sym1##sym2[2] __used        \
372         __aligned(sizeof(struct apic *))                                \
373         __section(.apicdrivers) = { &sym1, &sym2 }
374
375 extern struct apic *__apicdrivers[], *__apicdrivers_end[];
376
377 /*
378  * APIC functionality to boot other CPUs - only used on SMP:
379  */
380 #ifdef CONFIG_SMP
381 extern int wakeup_secondary_cpu_via_nmi(int apicid, unsigned long start_eip);
382 #endif
383
384 #ifdef CONFIG_X86_LOCAL_APIC
385
386 static inline u32 apic_read(u32 reg)
387 {
388         return apic->read(reg);
389 }
390
391 static inline void apic_write(u32 reg, u32 val)
392 {
393         apic->write(reg, val);
394 }
395
396 static inline void apic_eoi(void)
397 {
398         apic->eoi_write(APIC_EOI, APIC_EOI_ACK);
399 }
400
401 static inline u64 apic_icr_read(void)
402 {
403         return apic->icr_read();
404 }
405
406 static inline void apic_icr_write(u32 low, u32 high)
407 {
408         apic->icr_write(low, high);
409 }
410
411 static inline void apic_wait_icr_idle(void)
412 {
413         apic->wait_icr_idle();
414 }
415
416 static inline u32 safe_apic_wait_icr_idle(void)
417 {
418         return apic->safe_wait_icr_idle();
419 }
420
421 extern void __init apic_set_eoi_write(void (*eoi_write)(u32 reg, u32 v));
422
423 #else /* CONFIG_X86_LOCAL_APIC */
424
425 static inline u32 apic_read(u32 reg) { return 0; }
426 static inline void apic_write(u32 reg, u32 val) { }
427 static inline void apic_eoi(void) { }
428 static inline u64 apic_icr_read(void) { return 0; }
429 static inline void apic_icr_write(u32 low, u32 high) { }
430 static inline void apic_wait_icr_idle(void) { }
431 static inline u32 safe_apic_wait_icr_idle(void) { return 0; }
432 static inline void apic_set_eoi_write(void (*eoi_write)(u32 reg, u32 v)) {}
433
434 #endif /* CONFIG_X86_LOCAL_APIC */
435
436 static inline void ack_APIC_irq(void)
437 {
438         /*
439          * ack_APIC_irq() actually gets compiled as a single instruction
440          * ... yummie.
441          */
442         apic_eoi();
443 }
444
445 static inline unsigned default_get_apic_id(unsigned long x)
446 {
447         unsigned int ver = GET_APIC_VERSION(apic_read(APIC_LVR));
448
449         if (APIC_XAPIC(ver) || boot_cpu_has(X86_FEATURE_EXTD_APICID))
450                 return (x >> 24) & 0xFF;
451         else
452                 return (x >> 24) & 0x0F;
453 }
454
455 /*
456  * Warm reset vector position:
457  */
458 #define TRAMPOLINE_PHYS_LOW             0x467
459 #define TRAMPOLINE_PHYS_HIGH            0x469
460
461 #ifdef CONFIG_X86_64
462 extern void apic_send_IPI_self(int vector);
463
464 DECLARE_PER_CPU(int, x2apic_extra_bits);
465
466 extern int default_cpu_present_to_apicid(int mps_cpu);
467 extern int default_check_phys_apicid_present(int phys_apicid);
468 #endif
469
470 extern void generic_bigsmp_probe(void);
471
472
473 #ifdef CONFIG_X86_LOCAL_APIC
474
475 #include <asm/smp.h>
476
477 #define APIC_DFR_VALUE  (APIC_DFR_FLAT)
478
479 static inline const struct cpumask *default_target_cpus(void)
480 {
481 #ifdef CONFIG_SMP
482         return cpu_online_mask;
483 #else
484         return cpumask_of(0);
485 #endif
486 }
487
488 static inline const struct cpumask *online_target_cpus(void)
489 {
490         return cpu_online_mask;
491 }
492
493 DECLARE_EARLY_PER_CPU_READ_MOSTLY(u16, x86_bios_cpu_apicid);
494
495
496 static inline unsigned int read_apic_id(void)
497 {
498         unsigned int reg;
499
500         reg = apic_read(APIC_ID);
501
502         return apic->get_apic_id(reg);
503 }
504
505 static inline int default_apic_id_valid(int apicid)
506 {
507         return (apicid < 255);
508 }
509
510 extern int default_acpi_madt_oem_check(char *, char *);
511
512 extern void default_setup_apic_routing(void);
513
514 extern struct apic apic_noop;
515
516 #ifdef CONFIG_X86_32
517
518 static inline int noop_x86_32_early_logical_apicid(int cpu)
519 {
520         return BAD_APICID;
521 }
522
523 /*
524  * Set up the logical destination ID.
525  *
526  * Intel recommends to set DFR, LDR and TPR before enabling
527  * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
528  * document number 292116).  So here it goes...
529  */
530 extern void default_init_apic_ldr(void);
531
532 static inline int default_apic_id_registered(void)
533 {
534         return physid_isset(read_apic_id(), phys_cpu_present_map);
535 }
536
537 static inline int default_phys_pkg_id(int cpuid_apic, int index_msb)
538 {
539         return cpuid_apic >> index_msb;
540 }
541
542 #endif
543
544 static inline int
545 flat_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
546                             const struct cpumask *andmask,
547                             unsigned int *apicid)
548 {
549         unsigned long cpu_mask = cpumask_bits(cpumask)[0] &
550                                  cpumask_bits(andmask)[0] &
551                                  cpumask_bits(cpu_online_mask)[0] &
552                                  APIC_ALL_CPUS;
553
554         if (likely(cpu_mask)) {
555                 *apicid = (unsigned int)cpu_mask;
556                 return 0;
557         } else {
558                 return -EINVAL;
559         }
560 }
561
562 extern int
563 default_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
564                                const struct cpumask *andmask,
565                                unsigned int *apicid);
566
567 static inline void
568 flat_vector_allocation_domain(int cpu, struct cpumask *retmask,
569                               const struct cpumask *mask)
570 {
571         /* Careful. Some cpus do not strictly honor the set of cpus
572          * specified in the interrupt destination when using lowest
573          * priority interrupt delivery mode.
574          *
575          * In particular there was a hyperthreading cpu observed to
576          * deliver interrupts to the wrong hyperthread when only one
577          * hyperthread was specified in the interrupt desitination.
578          */
579         cpumask_clear(retmask);
580         cpumask_bits(retmask)[0] = APIC_ALL_CPUS;
581 }
582
583 static inline void
584 default_vector_allocation_domain(int cpu, struct cpumask *retmask,
585                                  const struct cpumask *mask)
586 {
587         cpumask_copy(retmask, cpumask_of(cpu));
588 }
589
590 static inline unsigned long default_check_apicid_used(physid_mask_t *map, int apicid)
591 {
592         return physid_isset(apicid, *map);
593 }
594
595 static inline void default_ioapic_phys_id_map(physid_mask_t *phys_map, physid_mask_t *retmap)
596 {
597         *retmap = *phys_map;
598 }
599
600 static inline int __default_cpu_present_to_apicid(int mps_cpu)
601 {
602         if (mps_cpu < nr_cpu_ids && cpu_present(mps_cpu))
603                 return (int)per_cpu(x86_bios_cpu_apicid, mps_cpu);
604         else
605                 return BAD_APICID;
606 }
607
608 static inline int
609 __default_check_phys_apicid_present(int phys_apicid)
610 {
611         return physid_isset(phys_apicid, phys_cpu_present_map);
612 }
613
614 #ifdef CONFIG_X86_32
615 static inline int default_cpu_present_to_apicid(int mps_cpu)
616 {
617         return __default_cpu_present_to_apicid(mps_cpu);
618 }
619
620 static inline int
621 default_check_phys_apicid_present(int phys_apicid)
622 {
623         return __default_check_phys_apicid_present(phys_apicid);
624 }
625 #else
626 extern int default_cpu_present_to_apicid(int mps_cpu);
627 extern int default_check_phys_apicid_present(int phys_apicid);
628 #endif
629
630 #endif /* CONFIG_X86_LOCAL_APIC */
631 extern void irq_enter(void);
632 extern void irq_exit(void);
633
634 static inline void entering_irq(void)
635 {
636         irq_enter();
637         exit_idle();
638 }
639
640 static inline void entering_ack_irq(void)
641 {
642         ack_APIC_irq();
643         entering_irq();
644 }
645
646 static inline void ipi_entering_ack_irq(void)
647 {
648         ack_APIC_irq();
649         irq_enter();
650 }
651
652 static inline void exiting_irq(void)
653 {
654         irq_exit();
655 }
656
657 static inline void exiting_ack_irq(void)
658 {
659         irq_exit();
660         /* Ack only at the end to avoid potential reentry */
661         ack_APIC_irq();
662 }
663
664 extern void ioapic_zap_locks(void);
665
666 #endif /* _ASM_X86_APIC_H */