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 | |
Ingo Molnar | a5c4329 | 2009-01-28 06:50:47 +0100 | [diff] [blame] | 40 | static inline void summit_init_apic_ldr(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Ingo Molnar | 7ed248d | 2009-01-28 03:43:47 +0100 | [diff] [blame] | 67 | static inline int summit_apic_id_registered(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | { |
| 69 | return 1; |
| 70 | } |
| 71 | |
Ingo Molnar | 72ce016 | 2009-01-28 06:50:47 +0100 | [diff] [blame] | 72 | static inline void summit_setup_apic_routing(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | { |
| 74 | printk("Enabling APIC mode: Summit. Using %d I/O APICs\n", |
| 75 | nr_ioapics); |
| 76 | } |
| 77 | |
| 78 | static inline int apicid_to_node(int logical_apicid) |
| 79 | { |
Andi Kleen | 38b5b03 | 2006-11-28 20:12:59 +0100 | [diff] [blame] | 80 | #ifdef CONFIG_SMP |
Keith Mannthey | 78b656b | 2006-10-03 18:25:52 -0700 | [diff] [blame] | 81 | return apicid_2_node[hard_smp_processor_id()]; |
Andi Kleen | 38b5b03 | 2006-11-28 20:12:59 +0100 | [diff] [blame] | 82 | #else |
| 83 | return 0; |
| 84 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | /* Mapping from cpu number to logical apicid */ |
| 88 | static inline int cpu_to_logical_apicid(int cpu) |
| 89 | { |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 90 | #ifdef CONFIG_SMP |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 91 | if (cpu >= nr_cpu_ids) |
| 92 | return BAD_APICID; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | return (int)cpu_2_logical_apicid[cpu]; |
Andi Kleen | 874c4fe | 2006-09-26 10:52:26 +0200 | [diff] [blame] | 94 | #else |
| 95 | return logical_smp_processor_id(); |
| 96 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | static inline int cpu_present_to_apicid(int mps_cpu) |
| 100 | { |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 101 | if (mps_cpu < nr_cpu_ids) |
Glauber de Oliveira Costa | cbe879f | 2008-03-19 14:25:19 -0300 | [diff] [blame] | 102 | return (int)per_cpu(x86_bios_cpu_apicid, mps_cpu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | else |
| 104 | return BAD_APICID; |
| 105 | } |
| 106 | |
Ingo Molnar | d190cb8 | 2009-01-28 06:50:47 +0100 | [diff] [blame] | 107 | static inline physid_mask_t |
| 108 | summit_ioapic_phys_id_map(physid_mask_t phys_id_map) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | { |
| 110 | /* For clustered we don't have a good way to do this yet - hack */ |
| 111 | return physids_promote(0x0F); |
| 112 | } |
| 113 | |
| 114 | static inline physid_mask_t apicid_to_cpu_present(int apicid) |
| 115 | { |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 116 | return physid_mask_of_physid(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | } |
| 118 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | static inline void setup_portio_remap(void) |
| 120 | { |
| 121 | } |
| 122 | |
| 123 | static inline int check_phys_apicid_present(int boot_cpu_physical_apicid) |
| 124 | { |
| 125 | return 1; |
| 126 | } |
| 127 | |
| 128 | static inline void enable_apic_mode(void) |
| 129 | { |
| 130 | } |
| 131 | |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 132 | static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | { |
| 134 | int num_bits_set; |
| 135 | int cpus_found = 0; |
| 136 | int cpu; |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 137 | int apicid; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 139 | num_bits_set = cpus_weight(*cpumask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | /* Return id to all */ |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 141 | if (num_bits_set >= nr_cpu_ids) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | return (int) 0xFF; |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 143 | /* |
| 144 | * 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] | 145 | * on the same apicid cluster return default value of target_cpus(): |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | */ |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 147 | cpu = first_cpu(*cpumask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | apicid = cpu_to_logical_apicid(cpu); |
| 149 | while (cpus_found < num_bits_set) { |
Mike Travis | e798673 | 2008-12-16 17:33:52 -0800 | [diff] [blame] | 150 | if (cpu_isset(cpu, *cpumask)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | int new_apicid = cpu_to_logical_apicid(cpu); |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 152 | if (apicid_cluster(apicid) != |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | apicid_cluster(new_apicid)){ |
Harvey Harrison | d5c003b | 2008-10-15 22:01:24 -0700 | [diff] [blame] | 154 | printk ("%s: Not a valid mask!\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | return 0xFF; |
| 156 | } |
| 157 | apicid = apicid | new_apicid; |
| 158 | cpus_found++; |
| 159 | } |
| 160 | cpu++; |
| 161 | } |
| 162 | return apicid; |
| 163 | } |
| 164 | |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 165 | 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] | 166 | const struct cpumask *andmask) |
Mike Travis | 95d313c | 2008-12-16 17:33:54 -0800 | [diff] [blame] | 167 | { |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 168 | int apicid = cpu_to_logical_apicid(0); |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 169 | cpumask_var_t cpumask; |
| 170 | |
| 171 | if (!alloc_cpumask_var(&cpumask, GFP_ATOMIC)) |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 172 | return apicid; |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 173 | |
| 174 | cpumask_and(cpumask, inmask, andmask); |
| 175 | cpumask_and(cpumask, cpumask, cpu_online_mask); |
Mike Travis | 9628937 | 2008-12-31 18:08:46 -0800 | [diff] [blame] | 176 | apicid = cpu_mask_to_apicid(cpumask); |
Mike Travis | 95d313c | 2008-12-16 17:33:54 -0800 | [diff] [blame] | 177 | |
Mike Travis | a775a38 | 2008-12-17 15:21:39 -0800 | [diff] [blame] | 178 | free_cpumask_var(cpumask); |
Mike Travis | 95d313c | 2008-12-16 17:33:54 -0800 | [diff] [blame] | 179 | return apicid; |
| 180 | } |
| 181 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | /* cpuid returns the value latched in the HW at reset, not the APIC ID |
| 183 | * register's value. For any box whose BIOS changes APIC IDs, like |
| 184 | * clustered APIC systems, we must use hard_smp_processor_id. |
| 185 | * |
| 186 | * See Intel's IA-32 SW Dev's Manual Vol2 under CPUID. |
| 187 | */ |
| 188 | static inline u32 phys_pkg_id(u32 cpuid_apic, int index_msb) |
| 189 | { |
| 190 | return hard_smp_processor_id() >> index_msb; |
| 191 | } |
| 192 | |
Yinghai Lu | e8c48ef | 2008-07-25 02:17:44 -0700 | [diff] [blame] | 193 | #endif /* __ASM_SUMMIT_APIC_H */ |