arch/x86/include/asm/es7000/apic.h

   1 #ifndef __ASM_ES7000_APIC_H
   2 #define __ASM_ES7000_APIC_H
   3
   4 #define xapic_phys_to_log_apicid(cpu) per_cpu(x86_bios_cpu_apicid, cpu)
   5 #define esr_disable (1)
   6
   7 static inline int apic_id_registered(void)
   8 {
   9                 return (1);
  10 }
  11
  12 static inline cpumask_t target_cpus_cluster(void)
  13 {
  14         return CPU_MASK_ALL;
  15 }
  16
  17 static inline cpumask_t target_cpus(void)
  18 {
  19         return cpumask_of_cpu(smp_processor_id());
  20 }
  21
  22 #define APIC_DFR_VALUE_CLUSTER          (APIC_DFR_CLUSTER)
  23 #define INT_DELIVERY_MODE_CLUSTER       (dest_LowestPrio)
  24 #define INT_DEST_MODE_CLUSTER           (1) /* logical delivery broadcast to all procs */
  25 #define NO_BALANCE_IRQ_CLUSTER          (1)
  26
  27 #define APIC_DFR_VALUE          (APIC_DFR_FLAT)
  28 #define INT_DELIVERY_MODE       (dest_Fixed)
  29 #define INT_DEST_MODE           (0)    /* phys delivery to target procs */
  30 #define NO_BALANCE_IRQ          (0)
  31 #undef  APIC_DEST_LOGICAL
  32 #define APIC_DEST_LOGICAL       0x0
  33
  34 static inline unsigned long check_apicid_used(physid_mask_t bitmap, int apicid)
  35 {
  36         return 0;
  37 }
  38 static inline unsigned long check_apicid_present(int bit)
  39 {
  40         return physid_isset(bit, phys_cpu_present_map);
  41 }
  42
  43 #define apicid_cluster(apicid) (apicid & 0xF0)
  44
  45 static inline unsigned long calculate_ldr(int cpu)
  46 {
  47         unsigned long id;
  48         id = xapic_phys_to_log_apicid(cpu);
  49         return (SET_APIC_LOGICAL_ID(id));
  50 }
  51
  52 /*
  53  * Set up the logical destination ID.
  54  *
  55  * Intel recommends to set DFR, LdR and TPR before enabling
  56  * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
  57  * document number 292116).  So here it goes...
  58  */
  59 static inline void init_apic_ldr_cluster(void)
  60 {
  61         unsigned long val;
  62         int cpu = smp_processor_id();
  63
  64         apic_write(APIC_DFR, APIC_DFR_VALUE_CLUSTER);
  65         val = calculate_ldr(cpu);
  66         apic_write(APIC_LDR, val);
  67 }
  68
  69 static inline void init_apic_ldr(void)
  70 {
  71         unsigned long val;
  72         int cpu = smp_processor_id();
  73
  74         apic_write(APIC_DFR, APIC_DFR_VALUE);
  75         val = calculate_ldr(cpu);
  76         apic_write(APIC_LDR, val);
  77 }
  78
  79 extern int apic_version [MAX_APICS];
  80 static inline void setup_apic_routing(void)
  81 {
  82         int apic = per_cpu(x86_bios_cpu_apicid, smp_processor_id());
  83         printk("Enabling APIC mode:  %s.  Using %d I/O APICs, target cpus %lx\n",
  84                 (apic_version[apic] == 0x14) ?
  85                 "Physical Cluster" : "Logical Cluster", nr_ioapics, cpus_addr(target_cpus())[0]);
  86 }
  87
  88 static inline int multi_timer_check(int apic, int irq)
  89 {
  90         return 0;
  91 }
  92
  93 static inline int apicid_to_node(int logical_apicid)
  94 {
  95         return 0;
  96 }
  97
  98
  99 static inline int cpu_present_to_apicid(int mps_cpu)
 100 {
 101         if (!mps_cpu)
 102                 return boot_cpu_physical_apicid;
 103         else if (mps_cpu < NR_CPUS)
 104                 return (int) per_cpu(x86_bios_cpu_apicid, mps_cpu);
 105         else
 106                 return BAD_APICID;
 107 }
 108
 109 static inline physid_mask_t apicid_to_cpu_present(int phys_apicid)
 110 {
 111         static int id = 0;
 112         physid_mask_t mask;
 113         mask = physid_mask_of_physid(id);
 114         ++id;
 115         return mask;
 116 }
 117
 118 extern u8 cpu_2_logical_apicid[];
 119 /* Mapping from cpu number to logical apicid */
 120 static inline int cpu_to_logical_apicid(int cpu)
 121 {
 122 #ifdef CONFIG_SMP
 123        if (cpu >= NR_CPUS)
 124                return BAD_APICID;
 125        return (int)cpu_2_logical_apicid[cpu];
 126 #else
 127         return logical_smp_processor_id();
 128 #endif
 129 }
 130
 131 static inline physid_mask_t ioapic_phys_id_map(physid_mask_t phys_map)
 132 {
 133         /* For clustered we don't have a good way to do this yet - hack */
 134         return physids_promote(0xff);
 135 }
 136
 137
 138 static inline void setup_portio_remap(void)
 139 {
 140 }
 141
 142 extern unsigned int boot_cpu_physical_apicid;
 143 static inline int check_phys_apicid_present(int cpu_physical_apicid)
 144 {
 145         boot_cpu_physical_apicid = read_apic_id();
 146         return (1);
 147 }
 148
 149 static inline unsigned int cpu_mask_to_apicid_cluster(cpumask_t cpumask)
 150 {
 151         int num_bits_set;
 152         int cpus_found = 0;
 153         int cpu;
 154         int apicid;
 155
 156         num_bits_set = cpus_weight(cpumask);
 157         /* Return id to all */
 158         if (num_bits_set == NR_CPUS)
 159                 return 0xFF;
 160         /*
 161          * The cpus in the mask must all be on the apic cluster.  If are not
 162          * on the same apicid cluster return default value of TARGET_CPUS.
 163          */
 164         cpu = first_cpu(cpumask);
 165         apicid = cpu_to_logical_apicid(cpu);
 166         while (cpus_found < num_bits_set) {
 167                 if (cpu_isset(cpu, cpumask)) {
 168                         int new_apicid = cpu_to_logical_apicid(cpu);
 169                         if (apicid_cluster(apicid) !=
 170                                         apicid_cluster(new_apicid)){
 171                                 printk ("%s: Not a valid mask!\n", __func__);
 172                                 return 0xFF;
 173                         }
 174                         apicid = new_apicid;
 175                         cpus_found++;
 176                 }
 177                 cpu++;
 178         }
 179         return apicid;
 180 }
 181
 182 static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
 183 {
 184         int num_bits_set;
 185         int cpus_found = 0;
 186         int cpu;
 187         int apicid;
 188
 189         num_bits_set = cpus_weight(cpumask);
 190         /* Return id to all */
 191         if (num_bits_set == NR_CPUS)
 192                 return cpu_to_logical_apicid(0);
 193         /*
 194          * The cpus in the mask must all be on the apic cluster.  If are not
 195          * on the same apicid cluster return default value of TARGET_CPUS.
 196          */
 197         cpu = first_cpu(cpumask);
 198         apicid = cpu_to_logical_apicid(cpu);
 199         while (cpus_found < num_bits_set) {
 200                 if (cpu_isset(cpu, cpumask)) {
 201                         int new_apicid = cpu_to_logical_apicid(cpu);
 202                         if (apicid_cluster(apicid) !=
 203                                         apicid_cluster(new_apicid)){
 204                                 printk ("%s: Not a valid mask!\n", __func__);
 205                                 return cpu_to_logical_apicid(0);
 206                         }
 207                         apicid = new_apicid;
 208                         cpus_found++;
 209                 }
 210                 cpu++;
 211         }
 212         return apicid;
 213 }
 214
 215 static inline u32 phys_pkg_id(u32 cpuid_apic, int index_msb)
 216 {
 217         return cpuid_apic >> index_msb;
 218 }
 219
 220 #endif /* __ASM_ES7000_APIC_H */