Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 1 | #ifndef __ASM_SUMMIT_APIC_H |
| 2 | #define __ASM_SUMMIT_APIC_H |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | #include <asm/smp.h> |
Mike Travis | 4d9f943 | 2009-01-05 17:09:41 -0800 | [diff] [blame] | 5 | #include <linux/gfp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | /* In clustered mode, the high nibble of APIC ID is a cluster number. |
| 8 | * The low nibble is a 4-bit bitmap. */ |
| 9 | #define XAPIC_DEST_CPUS_SHIFT 4 |
| 10 | #define XAPIC_DEST_CPUS_MASK ((1u << XAPIC_DEST_CPUS_SHIFT) - 1) |
| 11 | #define XAPIC_DEST_CLUSTER_MASK (XAPIC_DEST_CPUS_MASK << XAPIC_DEST_CPUS_SHIFT) |
| 12 | |
| 13 | #define APIC_DFR_VALUE (APIC_DFR_CLUSTER) |
| 14 | |
Ingo Molnar | 0a9cc20 | 2009-01-28 04:30:40 +0100 | [diff] [blame] | 15 | static inline const cpumask_t *summit_target_cpus(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | { |
| 17 | /* CPU_MASK_ALL (0xff) has undefined behaviour with |
| 18 | * dest_LowestPrio mode logical clustered apic interrupt routing |
| 19 | * Just start on cpu 0. IRQ balancing will spread load |
| 20 | */ |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 21 | return &cpumask_of_cpu(0); |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 22 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | |
Ingo Molnar | d1d7cae | 2009-01-28 05:41:42 +0100 | [diff] [blame] | 24 | static inline unsigned long |
| 25 | summit_check_apicid_used(physid_mask_t bitmap, int apicid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | { |
| 27 | return 0; |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 28 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
| 30 | /* we don't use the phys_cpu_present_map to indicate apicid presence */ |
Ingo Molnar | d1d7cae | 2009-01-28 05:41:42 +0100 | [diff] [blame] | 31 | static inline unsigned long summit_check_apicid_present(int bit) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | { |
| 33 | return 1; |
| 34 | } |
| 35 | |
| 36 | #define apicid_cluster(apicid) ((apicid) & XAPIC_DEST_CLUSTER_MASK) |
| 37 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | extern u8 cpu_2_logical_apicid[]; |
| 39 | |
| 40 | static inline void init_apic_ldr(void) |
| 41 | { |
| 42 | unsigned long val, id; |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 43 | int count = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | u8 my_id = (u8)hard_smp_processor_id(); |
| 45 | u8 my_cluster = (u8)apicid_cluster(my_id); |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 46 | #ifdef CONFIG_SMP |
| 47 | u8 lid; |
| 48 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | |
| 50 | /* Create logical APIC IDs by counting CPUs already in cluster. */ |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 51 | for (count = 0, i = nr_cpu_ids; --i >= 0; ) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | lid = cpu_2_logical_apicid[i]; |
| 53 | if (lid != BAD_APICID && apicid_cluster(lid) == my_cluster) |
| 54 | ++count; |
| 55 | } |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 56 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | /* We only have a 4 wide bitmap in cluster mode. If a deranged |
| 58 | * BIOS puts 5 CPUs in one APIC cluster, we're hosed. */ |
| 59 | BUG_ON(count >= XAPIC_DEST_CPUS_SHIFT); |
| 60 | id = my_cluster | (1UL << count); |
Maciej W. Rozycki | 593f4a7 | 2008-07-16 19:15:30 +0100 | [diff] [blame] | 61 | apic_write(APIC_DFR, APIC_DFR_VALUE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | val = apic_read(APIC_LDR) & ~APIC_LDR_MASK; |
| 63 | val |= SET_APIC_LOGICAL_ID(id); |
Maciej W. Rozycki | 593f4a7 | 2008-07-16 19:15:30 +0100 | [diff] [blame] | 64 | apic_write(APIC_LDR, val); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | static inline int multi_timer_check(int apic, int irq) |
| 68 | { |
| 69 | return 0; |
| 70 | } |
| 71 | |
Ingo Molnar | 7ed248d | 2009-01-28 03:43:47 +0100 | [diff] [blame] | 72 | static inline int summit_apic_id_registered(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | { |
| 74 | return 1; |
| 75 | } |
| 76 | |
Ingo Molnar | 3c43f03 | 2007-05-02 19:27:04 +0200 | [diff] [blame] | 77 | static inline void setup_apic_routing(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | { |
| 79 | printk("Enabling APIC mode: Summit. Using %d I/O APICs\n", |
| 80 | nr_ioapics); |
| 81 | } |
| 82 | |
| 83 | static inline int apicid_to_node(int logical_apicid) |
| 84 | { |
Andi Kleen | 38b5b03 | 2006-11-28 20:12:59 +0100 | [diff] [blame] | 85 | #ifdef CONFIG_SMP |
Keith Mannthey | 78b656b | 2006-10-03 18:25:52 -0700 | [diff] [blame] | 86 | return apicid_2_node[hard_smp_processor_id()]; |
Andi Kleen | 38b5b03 | 2006-11-28 20:12:59 +0100 | [diff] [blame] | 87 | #else |
| 88 | return 0; |
| 89 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | /* Mapping from cpu number to logical apicid */ |
| 93 | static inline int cpu_to_logical_apicid(int cpu) |
| 94 | { |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 95 | #ifdef CONFIG_SMP |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 96 | if (cpu >= nr_cpu_ids) |
| 97 | return BAD_APICID; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | return (int)cpu_2_logical_apicid[cpu]; |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 99 | #else |
| 100 | return logical_smp_processor_id(); |
| 101 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | static inline int cpu_present_to_apicid(int mps_cpu) |
| 105 | { |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 106 | if (mps_cpu < nr_cpu_ids) |
Glauber de Oliveira Costa | cbe879f | 2008-03-19 14:25:19 -0300 | [diff] [blame] | 107 | return (int)per_cpu(x86_bios_cpu_apicid, mps_cpu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | else |
| 109 | return BAD_APICID; |
| 110 | } |
| 111 | |
| 112 | static inline physid_mask_t ioapic_phys_id_map(physid_mask_t phys_id_map) |
| 113 | { |
| 114 | /* For clustered we don't have a good way to do this yet - hack */ |
| 115 | return physids_promote(0x0F); |
| 116 | } |
| 117 | |
| 118 | static inline physid_mask_t apicid_to_cpu_present(int apicid) |
| 119 | { |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 120 | return physid_mask_of_physid(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | } |
| 122 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | static inline void setup_portio_remap(void) |
| 124 | { |
| 125 | } |
| 126 | |
| 127 | static inline int check_phys_apicid_present(int boot_cpu_physical_apicid) |
| 128 | { |
| 129 | return 1; |
| 130 | } |
| 131 | |
| 132 | static inline void enable_apic_mode(void) |
| 133 | { |
| 134 | } |
| 135 | |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 136 | static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | { |
| 138 | int num_bits_set; |
| 139 | int cpus_found = 0; |
| 140 | int cpu; |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 141 | int apicid; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 143 | num_bits_set = cpus_weight(*cpumask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | /* Return id to all */ |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 145 | if (num_bits_set >= nr_cpu_ids) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | return (int) 0xFF; |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 147 | /* |
| 148 | * The cpus in the mask must all be on the apic cluster. If are not |
Ingo Molnar | fe402e1 | 2009-01-28 04:32:51 +0100 | [diff] [blame] | 149 | * on the same apicid cluster return default value of target_cpus(): |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | */ |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 151 | cpu = first_cpu(*cpumask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | apicid = cpu_to_logical_apicid(cpu); |
| 153 | while (cpus_found < num_bits_set) { |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 154 | if (cpu_isset(cpu, *cpumask)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | int new_apicid = cpu_to_logical_apicid(cpu); |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 156 | if (apicid_cluster(apicid) != |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | apicid_cluster(new_apicid)){ |
Harvey Harrison | d5c003b | 2008-10-15 22:01:24 -0700 | [diff] [blame] | 158 | printk ("%s: Not a valid mask!\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | return 0xFF; |
| 160 | } |
| 161 | apicid = apicid | new_apicid; |
| 162 | cpus_found++; |
| 163 | } |
| 164 | cpu++; |
| 165 | } |
| 166 | return apicid; |
| 167 | } |
| 168 | |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 169 | static inline unsigned int cpu_mask_to_apicid_and(const struct cpumask *inmask, |
Mike Travis | 6eeb7c5 | 2008-12-16 17:33:55 -0800 | [diff] [blame] | 170 | const struct cpumask *andmask) |
Mike Travis | 95d313c | 2008-12-16 17:33:54 -0800 | [diff] [blame] | 171 | { |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 172 | int apicid = cpu_to_logical_apicid(0); |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 173 | cpumask_var_t cpumask; |
| 174 | |
| 175 | if (!alloc_cpumask_var(&cpumask, GFP_ATOMIC)) |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 176 | return apicid; |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 177 | |
| 178 | cpumask_and(cpumask, inmask, andmask); |
| 179 | cpumask_and(cpumask, cpumask, cpu_online_mask); |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 180 | apicid = cpu_mask_to_apicid(cpumask); |
Mike Travis | 95d313c | 2008-12-16 17:33:54 -0800 | [diff] [blame] | 181 | |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 182 | free_cpumask_var(cpumask); |
Mike Travis | 95d313c | 2008-12-16 17:33:54 -0800 | [diff] [blame] | 183 | return apicid; |
| 184 | } |
| 185 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | /* cpuid returns the value latched in the HW at reset, not the APIC ID |
| 187 | * register's value. For any box whose BIOS changes APIC IDs, like |
| 188 | * clustered APIC systems, we must use hard_smp_processor_id. |
| 189 | * |
| 190 | * See Intel's IA-32 SW Dev's Manual Vol2 under CPUID. |
| 191 | */ |
| 192 | static inline u32 phys_pkg_id(u32 cpuid_apic, int index_msb) |
| 193 | { |
| 194 | return hard_smp_processor_id() >> index_msb; |
| 195 | } |
| 196 | |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 197 | #endif /* __ASM_SUMMIT_APIC_H */ |