if (c->x86 >= 0x6)
                                c->x86_model += ((tfms >> 16) & 0xF) << 4;
                        c->x86_mask = tfms & 15;
+                       c->initial_apicid = (ebx >> 24) & 0xFF;
 #ifdef CONFIG_X86_HT
-                       c->apicid = phys_pkg_id((ebx >> 24) & 0xFF, 0);
+                       c->apicid = phys_pkg_id(c->initial_apicid, 0);
+                       c->phys_proc_id = c->initial_apicid;
 #else
-                       c->apicid = (ebx >> 24) & 0xFF;
+                       c->apicid = c->initial_apicid;
 #endif
                        if (test_cpu_cap(c, X86_FEATURE_CLFLSH))
                                c->x86_clflush_size = ((ebx >> 8) & 0xff) * 8;
                init_scattered_cpuid_features(c);
        }
 
-#ifdef CONFIG_X86_HT
-       c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
-#endif
 }
 
 static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
                }
 
                index_msb = get_count_order(smp_num_siblings);
-               c->phys_proc_id = phys_pkg_id((ebx >> 24) & 0xFF, index_msb);
+               c->phys_proc_id = phys_pkg_id(c->initial_apicid, index_msb);
 
                printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
                       c->phys_proc_id);
 
                core_bits = get_count_order(c->x86_max_cores);
 
-               c->cpu_core_id = phys_pkg_id((ebx >> 24) & 0xFF, index_msb) &
+               c->cpu_core_id = phys_pkg_id(c->initial_apicid, index_msb) &
                                               ((1 << core_bits) - 1);
 
                if (c->x86_max_cores > 1)
 
                           cpus_weight(per_cpu(cpu_core_map, cpu)));
                seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
                seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
+               seq_printf(m, "apicid\t\t: %d\n", c->apicid);
+               seq_printf(m, "initial apicid\t: %d\n", c->initial_apicid);
        }
 #endif
 }
                seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
                seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
                seq_printf(m, "apicid\t\t: %d\n", c->apicid);
+               seq_printf(m, "initial apicid\t: %d\n", c->initial_apicid);
        }
 #endif
 }
 
        bits = c->x86_coreid_bits;
 
        /* Low order bits define the core id (index of core in socket) */
-       c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
-       /* Convert the APIC ID into the socket ID */
-       c->phys_proc_id = (c->apicid - boot_cpu_id) >> bits;
+       c->cpu_core_id = c->initial_apicid & ((1 << bits)-1);
+       /* Convert the initial APIC ID into the socket ID */
+       c->phys_proc_id = c->initial_apicid >> bits;
 
 #ifdef CONFIG_NUMA
        node = c->phys_proc_id;
                   If that doesn't result in a usable node fall back to the
                   path for the previous case.  */
 
-               int ht_nodeid = apicid - boot_cpu_id;
+               int ht_nodeid = c->initial_apicid;
 
                if (ht_nodeid >= 0 &&
                    apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
                c->x86 = 4;
        }
 
+       c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xff;
 #ifdef CONFIG_SMP
-       c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
+       c->phys_proc_id = c->initial_apicid;
 #endif
        /* AMD-defined flags: level 0x80000001 */
        xlvl = cpuid_eax(0x80000000);
 
        /* cpuid returned max cores value: */
        u16                      x86_max_cores;
        u16                     apicid;
+       u16                     initial_apicid;
        u16                     x86_clflush_size;
 #ifdef CONFIG_SMP
        /* number of cores as seen by the OS: */