arch/x86/kernel/cpu/intel_cacheinfo.c

   1 /*
   2  *      Routines to indentify caches on Intel CPU.
   3  *
   4  *      Changes:
   5  *      Venkatesh Pallipadi     : Adding cache identification through cpuid(4)
   6  *      Ashok Raj <ashok.raj@intel.com>: Work with CPU hotplug infrastructure.
   7  *      Andi Kleen / Andreas Herrmann   : CPUID4 emulation on AMD.
   8  */
   9
  10 #include <linux/init.h>
  11 #include <linux/slab.h>
  12 #include <linux/device.h>
  13 #include <linux/compiler.h>
  14 #include <linux/cpu.h>
  15 #include <linux/sched.h>
  16 #include <linux/pci.h>
  17
  18 #include <asm/processor.h>
  19 #include <linux/smp.h>
  20 #include <asm/k8.h>
  21 #include <asm/smp.h>
  22
  23 #define LVL_1_INST      1
  24 #define LVL_1_DATA      2
  25 #define LVL_2           3
  26 #define LVL_3           4
  27 #define LVL_TRACE       5
  28
  29 struct _cache_table {
  30         unsigned char descriptor;
  31         char cache_type;
  32         short size;
  33 };
  34
  35 #define MB(x)   ((x) * 1024)
  36
  37 /* All the cache descriptor types we care about (no TLB or
  38    trace cache entries) */
  39
  40 static const struct _cache_table __cpuinitconst cache_table[] =
  41 {
  42         { 0x06, LVL_1_INST, 8 },        /* 4-way set assoc, 32 byte line size */
  43         { 0x08, LVL_1_INST, 16 },       /* 4-way set assoc, 32 byte line size */
  44         { 0x09, LVL_1_INST, 32 },       /* 4-way set assoc, 64 byte line size */
  45         { 0x0a, LVL_1_DATA, 8 },        /* 2 way set assoc, 32 byte line size */
  46         { 0x0c, LVL_1_DATA, 16 },       /* 4-way set assoc, 32 byte line size */
  47         { 0x0d, LVL_1_DATA, 16 },       /* 4-way set assoc, 64 byte line size */
  48         { 0x21, LVL_2,      256 },      /* 8-way set assoc, 64 byte line size */
  49         { 0x22, LVL_3,      512 },      /* 4-way set assoc, sectored cache, 64 byte line size */
  50         { 0x23, LVL_3,      MB(1) },    /* 8-way set assoc, sectored cache, 64 byte line size */
  51         { 0x25, LVL_3,      MB(2) },    /* 8-way set assoc, sectored cache, 64 byte line size */
  52         { 0x29, LVL_3,      MB(4) },    /* 8-way set assoc, sectored cache, 64 byte line size */
  53         { 0x2c, LVL_1_DATA, 32 },       /* 8-way set assoc, 64 byte line size */
  54         { 0x30, LVL_1_INST, 32 },       /* 8-way set assoc, 64 byte line size */
  55         { 0x39, LVL_2,      128 },      /* 4-way set assoc, sectored cache, 64 byte line size */
  56         { 0x3a, LVL_2,      192 },      /* 6-way set assoc, sectored cache, 64 byte line size */
  57         { 0x3b, LVL_2,      128 },      /* 2-way set assoc, sectored cache, 64 byte line size */
  58         { 0x3c, LVL_2,      256 },      /* 4-way set assoc, sectored cache, 64 byte line size */
  59         { 0x3d, LVL_2,      384 },      /* 6-way set assoc, sectored cache, 64 byte line size */
  60         { 0x3e, LVL_2,      512 },      /* 4-way set assoc, sectored cache, 64 byte line size */
  61         { 0x3f, LVL_2,      256 },      /* 2-way set assoc, 64 byte line size */
  62         { 0x41, LVL_2,      128 },      /* 4-way set assoc, 32 byte line size */
  63         { 0x42, LVL_2,      256 },      /* 4-way set assoc, 32 byte line size */
  64         { 0x43, LVL_2,      512 },      /* 4-way set assoc, 32 byte line size */
  65         { 0x44, LVL_2,      MB(1) },    /* 4-way set assoc, 32 byte line size */
  66         { 0x45, LVL_2,      MB(2) },    /* 4-way set assoc, 32 byte line size */
  67         { 0x46, LVL_3,      MB(4) },    /* 4-way set assoc, 64 byte line size */
  68         { 0x47, LVL_3,      MB(8) },    /* 8-way set assoc, 64 byte line size */
  69         { 0x49, LVL_3,      MB(4) },    /* 16-way set assoc, 64 byte line size */
  70         { 0x4a, LVL_3,      MB(6) },    /* 12-way set assoc, 64 byte line size */
  71         { 0x4b, LVL_3,      MB(8) },    /* 16-way set assoc, 64 byte line size */
  72         { 0x4c, LVL_3,      MB(12) },   /* 12-way set assoc, 64 byte line size */
  73         { 0x4d, LVL_3,      MB(16) },   /* 16-way set assoc, 64 byte line size */
  74         { 0x4e, LVL_2,      MB(6) },    /* 24-way set assoc, 64 byte line size */
  75         { 0x60, LVL_1_DATA, 16 },       /* 8-way set assoc, sectored cache, 64 byte line size */
  76         { 0x66, LVL_1_DATA, 8 },        /* 4-way set assoc, sectored cache, 64 byte line size */
  77         { 0x67, LVL_1_DATA, 16 },       /* 4-way set assoc, sectored cache, 64 byte line size */
  78         { 0x68, LVL_1_DATA, 32 },       /* 4-way set assoc, sectored cache, 64 byte line size */
  79         { 0x70, LVL_TRACE,  12 },       /* 8-way set assoc */
  80         { 0x71, LVL_TRACE,  16 },       /* 8-way set assoc */
  81         { 0x72, LVL_TRACE,  32 },       /* 8-way set assoc */
  82         { 0x73, LVL_TRACE,  64 },       /* 8-way set assoc */
  83         { 0x78, LVL_2,      MB(1) },    /* 4-way set assoc, 64 byte line size */
  84         { 0x79, LVL_2,      128 },      /* 8-way set assoc, sectored cache, 64 byte line size */
  85         { 0x7a, LVL_2,      256 },      /* 8-way set assoc, sectored cache, 64 byte line size */
  86         { 0x7b, LVL_2,      512 },      /* 8-way set assoc, sectored cache, 64 byte line size */
  87         { 0x7c, LVL_2,      MB(1) },    /* 8-way set assoc, sectored cache, 64 byte line size */
  88         { 0x7d, LVL_2,      MB(2) },    /* 8-way set assoc, 64 byte line size */
  89         { 0x7f, LVL_2,      512 },      /* 2-way set assoc, 64 byte line size */
  90         { 0x82, LVL_2,      256 },      /* 8-way set assoc, 32 byte line size */
  91         { 0x83, LVL_2,      512 },      /* 8-way set assoc, 32 byte line size */
  92         { 0x84, LVL_2,      MB(1) },    /* 8-way set assoc, 32 byte line size */
  93         { 0x85, LVL_2,      MB(2) },    /* 8-way set assoc, 32 byte line size */
  94         { 0x86, LVL_2,      512 },      /* 4-way set assoc, 64 byte line size */
  95         { 0x87, LVL_2,      MB(1) },    /* 8-way set assoc, 64 byte line size */
  96         { 0xd0, LVL_3,      512 },      /* 4-way set assoc, 64 byte line size */
  97         { 0xd1, LVL_3,      MB(1) },    /* 4-way set assoc, 64 byte line size */
  98         { 0xd2, LVL_3,      MB(2) },    /* 4-way set assoc, 64 byte line size */
  99         { 0xd6, LVL_3,      MB(1) },    /* 8-way set assoc, 64 byte line size */
 100         { 0xd7, LVL_3,      MB(2) },    /* 8-way set assoc, 64 byte line size */
 101         { 0xd8, LVL_3,      MB(4) },    /* 12-way set assoc, 64 byte line size */
 102         { 0xdc, LVL_3,      MB(2) },    /* 12-way set assoc, 64 byte line size */
 103         { 0xdd, LVL_3,      MB(4) },    /* 12-way set assoc, 64 byte line size */
 104         { 0xde, LVL_3,      MB(8) },    /* 12-way set assoc, 64 byte line size */
 105         { 0xe2, LVL_3,      MB(2) },    /* 16-way set assoc, 64 byte line size */
 106         { 0xe3, LVL_3,      MB(4) },    /* 16-way set assoc, 64 byte line size */
 107         { 0xe4, LVL_3,      MB(8) },    /* 16-way set assoc, 64 byte line size */
 108         { 0xea, LVL_3,      MB(12) },   /* 24-way set assoc, 64 byte line size */
 109         { 0xeb, LVL_3,      MB(18) },   /* 24-way set assoc, 64 byte line size */
 110         { 0xec, LVL_3,      MB(24) },   /* 24-way set assoc, 64 byte line size */
 111         { 0x00, 0, 0}
 112 };
 113
 114
 115 enum _cache_type {
 116         CACHE_TYPE_NULL = 0,
 117         CACHE_TYPE_DATA = 1,
 118         CACHE_TYPE_INST = 2,
 119         CACHE_TYPE_UNIFIED = 3
 120 };
 121
 122 union _cpuid4_leaf_eax {
 123         struct {
 124                 enum _cache_type        type:5;
 125                 unsigned int            level:3;
 126                 unsigned int            is_self_initializing:1;
 127                 unsigned int            is_fully_associative:1;
 128                 unsigned int            reserved:4;
 129                 unsigned int            num_threads_sharing:12;
 130                 unsigned int            num_cores_on_die:6;
 131         } split;
 132         u32 full;
 133 };
 134
 135 union _cpuid4_leaf_ebx {
 136         struct {
 137                 unsigned int            coherency_line_size:12;
 138                 unsigned int            physical_line_partition:10;
 139                 unsigned int            ways_of_associativity:10;
 140         } split;
 141         u32 full;
 142 };
 143
 144 union _cpuid4_leaf_ecx {
 145         struct {
 146                 unsigned int            number_of_sets:32;
 147         } split;
 148         u32 full;
 149 };
 150
 151 struct _cpuid4_info {
 152         union _cpuid4_leaf_eax eax;
 153         union _cpuid4_leaf_ebx ebx;
 154         union _cpuid4_leaf_ecx ecx;
 155         unsigned long size;
 156         bool can_disable;
 157         unsigned int l3_indices;
 158         DECLARE_BITMAP(shared_cpu_map, NR_CPUS);
 159 };
 160
 161 /* subset of above _cpuid4_info w/o shared_cpu_map */
 162 struct _cpuid4_info_regs {
 163         union _cpuid4_leaf_eax eax;
 164         union _cpuid4_leaf_ebx ebx;
 165         union _cpuid4_leaf_ecx ecx;
 166         unsigned long size;
 167         bool can_disable;
 168         unsigned int l3_indices;
 169 };
 170
 171 unsigned short                  num_cache_leaves;
 172
 173 /* AMD doesn't have CPUID4. Emulate it here to report the same
 174    information to the user.  This makes some assumptions about the machine:
 175    L2 not shared, no SMT etc. that is currently true on AMD CPUs.
 176
 177    In theory the TLBs could be reported as fake type (they are in "dummy").
 178    Maybe later */
 179 union l1_cache {
 180         struct {
 181                 unsigned line_size:8;
 182                 unsigned lines_per_tag:8;
 183                 unsigned assoc:8;
 184                 unsigned size_in_kb:8;
 185         };
 186         unsigned val;
 187 };
 188
 189 union l2_cache {
 190         struct {
 191                 unsigned line_size:8;
 192                 unsigned lines_per_tag:4;
 193                 unsigned assoc:4;
 194                 unsigned size_in_kb:16;
 195         };
 196         unsigned val;
 197 };
 198
 199 union l3_cache {
 200         struct {
 201                 unsigned line_size:8;
 202                 unsigned lines_per_tag:4;
 203                 unsigned assoc:4;
 204                 unsigned res:2;
 205                 unsigned size_encoded:14;
 206         };
 207         unsigned val;
 208 };
 209
 210 static const unsigned short __cpuinitconst assocs[] = {
 211         [1] = 1,
 212         [2] = 2,
 213         [4] = 4,
 214         [6] = 8,
 215         [8] = 16,
 216         [0xa] = 32,
 217         [0xb] = 48,
 218         [0xc] = 64,
 219         [0xd] = 96,
 220         [0xe] = 128,
 221         [0xf] = 0xffff /* fully associative - no way to show this currently */
 222 };
 223
 224 static const unsigned char __cpuinitconst levels[] = { 1, 1, 2, 3 };
 225 static const unsigned char __cpuinitconst types[] = { 1, 2, 3, 3 };
 226
 227 static void __cpuinit
 228 amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax,
 229                      union _cpuid4_leaf_ebx *ebx,
 230                      union _cpuid4_leaf_ecx *ecx)
 231 {
 232         unsigned dummy;
 233         unsigned line_size, lines_per_tag, assoc, size_in_kb;
 234         union l1_cache l1i, l1d;
 235         union l2_cache l2;
 236         union l3_cache l3;
 237         union l1_cache *l1 = &l1d;
 238
 239         eax->full = 0;
 240         ebx->full = 0;
 241         ecx->full = 0;
 242
 243         cpuid(0x80000005, &dummy, &dummy, &l1d.val, &l1i.val);
 244         cpuid(0x80000006, &dummy, &dummy, &l2.val, &l3.val);
 245
 246         switch (leaf) {
 247         case 1:
 248                 l1 = &l1i;
 249         case 0:
 250                 if (!l1->val)
 251                         return;
 252                 assoc = assocs[l1->assoc];
 253                 line_size = l1->line_size;
 254                 lines_per_tag = l1->lines_per_tag;
 255                 size_in_kb = l1->size_in_kb;
 256                 break;
 257         case 2:
 258                 if (!l2.val)
 259                         return;
 260                 assoc = assocs[l2.assoc];
 261                 line_size = l2.line_size;
 262                 lines_per_tag = l2.lines_per_tag;
 263                 /* cpu_data has errata corrections for K7 applied */
 264                 size_in_kb = current_cpu_data.x86_cache_size;
 265                 break;
 266         case 3:
 267                 if (!l3.val)
 268                         return;
 269                 assoc = assocs[l3.assoc];
 270                 line_size = l3.line_size;
 271                 lines_per_tag = l3.lines_per_tag;
 272                 size_in_kb = l3.size_encoded * 512;
 273                 if (boot_cpu_has(X86_FEATURE_AMD_DCM)) {
 274                         size_in_kb = size_in_kb >> 1;
 275                         assoc = assoc >> 1;
 276                 }
 277                 break;
 278         default:
 279                 return;
 280         }
 281
 282         eax->split.is_self_initializing = 1;
 283         eax->split.type = types[leaf];
 284         eax->split.level = levels[leaf];
 285         eax->split.num_threads_sharing = 0;
 286         eax->split.num_cores_on_die = current_cpu_data.x86_max_cores - 1;
 287
 288
 289         if (assoc == 0xffff)
 290                 eax->split.is_fully_associative = 1;
 291         ebx->split.coherency_line_size = line_size - 1;
 292         ebx->split.ways_of_associativity = assoc - 1;
 293         ebx->split.physical_line_partition = lines_per_tag - 1;
 294         ecx->split.number_of_sets = (size_in_kb * 1024) / line_size /
 295                 (ebx->split.ways_of_associativity + 1) - 1;
 296 }
 297
 298 struct _cache_attr {
 299         struct attribute attr;
 300         ssize_t (*show)(struct _cpuid4_info *, char *);
 301         ssize_t (*store)(struct _cpuid4_info *, const char *, size_t count);
 302 };
 303
 304 #ifdef CONFIG_CPU_SUP_AMD
 305 static unsigned int __cpuinit amd_calc_l3_indices(void)
 306 {
 307         /*
 308          * We're called over smp_call_function_single() and therefore
 309          * are on the correct cpu.
 310          */
 311         int cpu = smp_processor_id();
 312         int node = cpu_to_node(cpu);
 313         struct pci_dev *dev = node_to_k8_nb_misc(node);
 314         unsigned int sc0, sc1, sc2, sc3;
 315         u32 val = 0;
 316
 317         pci_read_config_dword(dev, 0x1C4, &val);
 318
 319         /* calculate subcache sizes */
 320         sc0 = !(val & BIT(0));
 321         sc1 = !(val & BIT(4));
 322         sc2 = !(val & BIT(8))  + !(val & BIT(9));
 323         sc3 = !(val & BIT(12)) + !(val & BIT(13));
 324
 325         return (max(max(max(sc0, sc1), sc2), sc3) << 10) - 1;
 326 }
 327
 328 static void __cpuinit
 329 amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf)
 330 {
 331         if (index < 3)
 332                 return;
 333
 334         if (boot_cpu_data.x86 == 0x11)
 335                 return;
 336
 337         /* see errata #382 and #388 */
 338         if ((boot_cpu_data.x86 == 0x10) &&
 339             ((boot_cpu_data.x86_model < 0x8) ||
 340              (boot_cpu_data.x86_mask  < 0x1)))
 341                 return;
 342
 343         /* not in virtualized environments */
 344         if (num_k8_northbridges == 0)
 345                 return;
 346
 347         this_leaf->can_disable = true;
 348         this_leaf->l3_indices  = amd_calc_l3_indices();
 349 }
 350
 351 static ssize_t show_cache_disable(struct _cpuid4_info *this_leaf, char *buf,
 352                                   unsigned int index)
 353 {
 354         int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map));
 355         int node = amd_get_nb_id(cpu);
 356         struct pci_dev *dev = node_to_k8_nb_misc(node);
 357         unsigned int reg = 0;
 358
 359         if (!this_leaf->can_disable)
 360                 return -EINVAL;
 361
 362         if (!dev)
 363                 return -EINVAL;
 364
 365         pci_read_config_dword(dev, 0x1BC + index * 4, &reg);
 366         return sprintf(buf, "0x%08x\n", reg);
 367 }
 368
 369 #define SHOW_CACHE_DISABLE(index)                                       \
 370 static ssize_t                                                          \
 371 show_cache_disable_##index(struct _cpuid4_info *this_leaf, char *buf)   \
 372 {                                                                       \
 373         return show_cache_disable(this_leaf, buf, index);               \
 374 }
 375 SHOW_CACHE_DISABLE(0)
 376 SHOW_CACHE_DISABLE(1)
 377
 378 static ssize_t store_cache_disable(struct _cpuid4_info *this_leaf,
 379         const char *buf, size_t count, unsigned int index)
 380 {
 381         int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map));
 382         int node = amd_get_nb_id(cpu);
 383         struct pci_dev *dev = node_to_k8_nb_misc(node);
 384         unsigned long val = 0;
 385
 386 #define SUBCACHE_MASK   (3UL << 20)
 387 #define SUBCACHE_INDEX  0xfff
 388
 389         if (!this_leaf->can_disable)
 390                 return -EINVAL;
 391
 392         if (!capable(CAP_SYS_ADMIN))
 393                 return -EPERM;
 394
 395         if (!dev)
 396                 return -EINVAL;
 397
 398         if (strict_strtoul(buf, 10, &val) < 0)
 399                 return -EINVAL;
 400
 401         /* do not allow writes outside of allowed bits */
 402         if ((val & ~(SUBCACHE_MASK | SUBCACHE_INDEX)) ||
 403             ((val & SUBCACHE_INDEX) > this_leaf->l3_indices))
 404                 return -EINVAL;
 405
 406         val |= BIT(30);
 407         pci_write_config_dword(dev, 0x1BC + index * 4, val);
 408         /*
 409          * We need to WBINVD on a core on the node containing the L3 cache which
 410          * indices we disable therefore a simple wbinvd() is not sufficient.
 411          */
 412         wbinvd_on_cpu(cpu);
 413         pci_write_config_dword(dev, 0x1BC + index * 4, val | BIT(31));
 414         return count;
 415 }
 416
 417 #define STORE_CACHE_DISABLE(index)                                      \
 418 static ssize_t                                                          \
 419 store_cache_disable_##index(struct _cpuid4_info *this_leaf,             \
 420                             const char *buf, size_t count)              \
 421 {                                                                       \
 422         return store_cache_disable(this_leaf, buf, count, index);       \
 423 }
 424 STORE_CACHE_DISABLE(0)
 425 STORE_CACHE_DISABLE(1)
 426
 427 static struct _cache_attr cache_disable_0 = __ATTR(cache_disable_0, 0644,
 428                 show_cache_disable_0, store_cache_disable_0);
 429 static struct _cache_attr cache_disable_1 = __ATTR(cache_disable_1, 0644,
 430                 show_cache_disable_1, store_cache_disable_1);
 431
 432 #else   /* CONFIG_CPU_SUP_AMD */
 433 static void __cpuinit
 434 amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf)
 435 {
 436 };
 437 #endif /* CONFIG_CPU_SUP_AMD */
 438
 439 static int
 440 __cpuinit cpuid4_cache_lookup_regs(int index,
 441                                    struct _cpuid4_info_regs *this_leaf)
 442 {
 443         union _cpuid4_leaf_eax  eax;
 444         union _cpuid4_leaf_ebx  ebx;
 445         union _cpuid4_leaf_ecx  ecx;
 446         unsigned                edx;
 447
 448         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) {
 449                 amd_cpuid4(index, &eax, &ebx, &ecx);
 450                 if (boot_cpu_data.x86 >= 0x10)
 451                         amd_check_l3_disable(index, this_leaf);
 452         } else {
 453                 cpuid_count(4, index, &eax.full, &ebx.full, &ecx.full, &edx);
 454         }
 455
 456         if (eax.split.type == CACHE_TYPE_NULL)
 457                 return -EIO; /* better error ? */
 458
 459         this_leaf->eax = eax;
 460         this_leaf->ebx = ebx;
 461         this_leaf->ecx = ecx;
 462         this_leaf->size = (ecx.split.number_of_sets          + 1) *
 463                           (ebx.split.coherency_line_size     + 1) *
 464                           (ebx.split.physical_line_partition + 1) *
 465                           (ebx.split.ways_of_associativity   + 1);
 466         return 0;
 467 }
 468
 469 static int __cpuinit find_num_cache_leaves(void)
 470 {
 471         unsigned int            eax, ebx, ecx, edx;
 472         union _cpuid4_leaf_eax  cache_eax;
 473         int                     i = -1;
 474
 475         do {
 476                 ++i;
 477                 /* Do cpuid(4) loop to find out num_cache_leaves */
 478                 cpuid_count(4, i, &eax, &ebx, &ecx, &edx);
 479                 cache_eax.full = eax;
 480         } while (cache_eax.split.type != CACHE_TYPE_NULL);
 481         return i;
 482 }
 483
 484 unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
 485 {
 486         /* Cache sizes */
 487         unsigned int trace = 0, l1i = 0, l1d = 0, l2 = 0, l3 = 0;
 488         unsigned int new_l1d = 0, new_l1i = 0; /* Cache sizes from cpuid(4) */
 489         unsigned int new_l2 = 0, new_l3 = 0, i; /* Cache sizes from cpuid(4) */
 490         unsigned int l2_id = 0, l3_id = 0, num_threads_sharing, index_msb;
 491 #ifdef CONFIG_X86_HT
 492         unsigned int cpu = c->cpu_index;
 493 #endif
 494
 495         if (c->cpuid_level > 3) {
 496                 static int is_initialized;
 497
 498                 if (is_initialized == 0) {
 499                         /* Init num_cache_leaves from boot CPU */
 500                         num_cache_leaves = find_num_cache_leaves();
 501                         is_initialized++;
 502                 }
 503
 504                 /*
 505                  * Whenever possible use cpuid(4), deterministic cache
 506                  * parameters cpuid leaf to find the cache details
 507                  */
 508                 for (i = 0; i < num_cache_leaves; i++) {
 509                         struct _cpuid4_info_regs this_leaf;
 510                         int retval;
 511
 512                         retval = cpuid4_cache_lookup_regs(i, &this_leaf);
 513                         if (retval >= 0) {
 514                                 switch (this_leaf.eax.split.level) {
 515                                 case 1:
 516                                         if (this_leaf.eax.split.type ==
 517                                                         CACHE_TYPE_DATA)
 518                                                 new_l1d = this_leaf.size/1024;
 519                                         else if (this_leaf.eax.split.type ==
 520                                                         CACHE_TYPE_INST)
 521                                                 new_l1i = this_leaf.size/1024;
 522                                         break;
 523                                 case 2:
 524                                         new_l2 = this_leaf.size/1024;
 525                                         num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
 526                                         index_msb = get_count_order(num_threads_sharing);
 527                                         l2_id = c->apicid >> index_msb;
 528                                         break;
 529                                 case 3:
 530                                         new_l3 = this_leaf.size/1024;
 531                                         num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
 532                                         index_msb = get_count_order(
 533                                                         num_threads_sharing);
 534                                         l3_id = c->apicid >> index_msb;
 535                                         break;
 536                                 default:
 537                                         break;
 538                                 }
 539                         }
 540                 }
 541         }
 542         /*
 543          * Don't use cpuid2 if cpuid4 is supported. For P4, we use cpuid2 for
 544          * trace cache
 545          */
 546         if ((num_cache_leaves == 0 || c->x86 == 15) && c->cpuid_level > 1) {
 547                 /* supports eax=2  call */
 548                 int j, n;
 549                 unsigned int regs[4];
 550                 unsigned char *dp = (unsigned char *)regs;
 551                 int only_trace = 0;
 552
 553                 if (num_cache_leaves != 0 && c->x86 == 15)
 554                         only_trace = 1;
 555
 556                 /* Number of times to iterate */
 557                 n = cpuid_eax(2) & 0xFF;
 558
 559                 for (i = 0 ; i < n ; i++) {
 560                         cpuid(2, &regs[0], &regs[1], &regs[2], &regs[3]);
 561
 562                         /* If bit 31 is set, this is an unknown format */
 563                         for (j = 0 ; j < 3 ; j++)
 564                                 if (regs[j] & (1 << 31))
 565                                         regs[j] = 0;
 566
 567                         /* Byte 0 is level count, not a descriptor */
 568                         for (j = 1 ; j < 16 ; j++) {
 569                                 unsigned char des = dp[j];
 570                                 unsigned char k = 0;
 571
 572                                 /* look up this descriptor in the table */
 573                                 while (cache_table[k].descriptor != 0) {
 574                                         if (cache_table[k].descriptor == des) {
 575                                                 if (only_trace && cache_table[k].cache_type != LVL_TRACE)
 576                                                         break;
 577                                                 switch (cache_table[k].cache_type) {
 578                                                 case LVL_1_INST:
 579                                                         l1i += cache_table[k].size;
 580                                                         break;
 581                                                 case LVL_1_DATA:
 582                                                         l1d += cache_table[k].size;
 583                                                         break;
 584                                                 case LVL_2:
 585                                                         l2 += cache_table[k].size;
 586                                                         break;
 587                                                 case LVL_3:
 588                                                         l3 += cache_table[k].size;
 589                                                         break;
 590                                                 case LVL_TRACE:
 591                                                         trace += cache_table[k].size;
 592                                                         break;
 593                                                 }
 594
 595                                                 break;
 596                                         }
 597
 598                                         k++;
 599                                 }
 600                         }
 601                 }
 602         }
 603
 604         if (new_l1d)
 605                 l1d = new_l1d;
 606
 607         if (new_l1i)
 608                 l1i = new_l1i;
 609
 610         if (new_l2) {
 611                 l2 = new_l2;
 612 #ifdef CONFIG_X86_HT
 613                 per_cpu(cpu_llc_id, cpu) = l2_id;
 614 #endif
 615         }
 616
 617         if (new_l3) {
 618                 l3 = new_l3;
 619 #ifdef CONFIG_X86_HT
 620                 per_cpu(cpu_llc_id, cpu) = l3_id;
 621 #endif
 622         }
 623
 624         c->x86_cache_size = l3 ? l3 : (l2 ? l2 : (l1i+l1d));
 625
 626         return l2;
 627 }
 628
 629 #ifdef CONFIG_SYSFS
 630
 631 /* pointer to _cpuid4_info array (for each cache leaf) */
 632 static DEFINE_PER_CPU(struct _cpuid4_info *, ici_cpuid4_info);
 633 #define CPUID4_INFO_IDX(x, y)   (&((per_cpu(ici_cpuid4_info, x))[y]))
 634
 635 #ifdef CONFIG_SMP
 636 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
 637 {
 638         struct _cpuid4_info     *this_leaf, *sibling_leaf;
 639         unsigned long num_threads_sharing;
 640         int index_msb, i, sibling;
 641         struct cpuinfo_x86 *c = &cpu_data(cpu);
 642
 643         if ((index == 3) && (c->x86_vendor == X86_VENDOR_AMD)) {
 644                 for_each_cpu(i, c->llc_shared_map) {
 645                         if (!per_cpu(ici_cpuid4_info, i))
 646                                 continue;
 647                         this_leaf = CPUID4_INFO_IDX(i, index);
 648                         for_each_cpu(sibling, c->llc_shared_map) {
 649                                 if (!cpu_online(sibling))
 650                                         continue;
 651                                 set_bit(sibling, this_leaf->shared_cpu_map);
 652                         }
 653                 }
 654                 return;
 655         }
 656         this_leaf = CPUID4_INFO_IDX(cpu, index);
 657         num_threads_sharing = 1 + this_leaf->eax.split.num_threads_sharing;
 658
 659         if (num_threads_sharing == 1)
 660                 cpumask_set_cpu(cpu, to_cpumask(this_leaf->shared_cpu_map));
 661         else {
 662                 index_msb = get_count_order(num_threads_sharing);
 663
 664                 for_each_online_cpu(i) {
 665                         if (cpu_data(i).apicid >> index_msb ==
 666                             c->apicid >> index_msb) {
 667                                 cpumask_set_cpu(i,
 668                                         to_cpumask(this_leaf->shared_cpu_map));
 669                                 if (i != cpu && per_cpu(ici_cpuid4_info, i))  {
 670                                         sibling_leaf =
 671                                                 CPUID4_INFO_IDX(i, index);
 672                                         cpumask_set_cpu(cpu, to_cpumask(
 673                                                 sibling_leaf->shared_cpu_map));
 674                                 }
 675                         }
 676                 }
 677         }
 678 }
 679 static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
 680 {
 681         struct _cpuid4_info     *this_leaf, *sibling_leaf;
 682         int sibling;
 683
 684         this_leaf = CPUID4_INFO_IDX(cpu, index);
 685         for_each_cpu(sibling, to_cpumask(this_leaf->shared_cpu_map)) {
 686                 sibling_leaf = CPUID4_INFO_IDX(sibling, index);
 687                 cpumask_clear_cpu(cpu,
 688                                   to_cpumask(sibling_leaf->shared_cpu_map));
 689         }
 690 }
 691 #else
 692 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
 693 {
 694 }
 695
 696 static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
 697 {
 698 }
 699 #endif
 700
 701 static void __cpuinit free_cache_attributes(unsigned int cpu)
 702 {
 703         int i;
 704
 705         for (i = 0; i < num_cache_leaves; i++)
 706                 cache_remove_shared_cpu_map(cpu, i);
 707
 708         kfree(per_cpu(ici_cpuid4_info, cpu));
 709         per_cpu(ici_cpuid4_info, cpu) = NULL;
 710 }
 711
 712 static int
 713 __cpuinit cpuid4_cache_lookup(int index, struct _cpuid4_info *this_leaf)
 714 {
 715         struct _cpuid4_info_regs *leaf_regs =
 716                 (struct _cpuid4_info_regs *)this_leaf;
 717
 718         return cpuid4_cache_lookup_regs(index, leaf_regs);
 719 }
 720
 721 static void __cpuinit get_cpu_leaves(void *_retval)
 722 {
 723         int j, *retval = _retval, cpu = smp_processor_id();
 724
 725         /* Do cpuid and store the results */
 726         for (j = 0; j < num_cache_leaves; j++) {
 727                 struct _cpuid4_info *this_leaf;
 728                 this_leaf = CPUID4_INFO_IDX(cpu, j);
 729                 *retval = cpuid4_cache_lookup(j, this_leaf);
 730                 if (unlikely(*retval < 0)) {
 731                         int i;
 732
 733                         for (i = 0; i < j; i++)
 734                                 cache_remove_shared_cpu_map(cpu, i);
 735                         break;
 736                 }
 737                 cache_shared_cpu_map_setup(cpu, j);
 738         }
 739 }
 740
 741 static int __cpuinit detect_cache_attributes(unsigned int cpu)
 742 {
 743         int                     retval;
 744
 745         if (num_cache_leaves == 0)
 746                 return -ENOENT;
 747
 748         per_cpu(ici_cpuid4_info, cpu) = kzalloc(
 749             sizeof(struct _cpuid4_info) * num_cache_leaves, GFP_KERNEL);
 750         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
 751                 return -ENOMEM;
 752
 753         smp_call_function_single(cpu, get_cpu_leaves, &retval, true);
 754         if (retval) {
 755                 kfree(per_cpu(ici_cpuid4_info, cpu));
 756                 per_cpu(ici_cpuid4_info, cpu) = NULL;
 757         }
 758
 759         return retval;
 760 }
 761
 762 #include <linux/kobject.h>
 763 #include <linux/sysfs.h>
 764
 765 extern struct sysdev_class cpu_sysdev_class; /* from drivers/base/cpu.c */
 766
 767 /* pointer to kobject for cpuX/cache */
 768 static DEFINE_PER_CPU(struct kobject *, ici_cache_kobject);
 769
 770 struct _index_kobject {
 771         struct kobject kobj;
 772         unsigned int cpu;
 773         unsigned short index;
 774 };
 775
 776 /* pointer to array of kobjects for cpuX/cache/indexY */
 777 static DEFINE_PER_CPU(struct _index_kobject *, ici_index_kobject);
 778 #define INDEX_KOBJECT_PTR(x, y)         (&((per_cpu(ici_index_kobject, x))[y]))
 779
 780 #define show_one_plus(file_name, object, val)                           \
 781 static ssize_t show_##file_name                                         \
 782                         (struct _cpuid4_info *this_leaf, char *buf)     \
 783 {                                                                       \
 784         return sprintf(buf, "%lu\n", (unsigned long)this_leaf->object + val); \
 785 }
 786
 787 show_one_plus(level, eax.split.level, 0);
 788 show_one_plus(coherency_line_size, ebx.split.coherency_line_size, 1);
 789 show_one_plus(physical_line_partition, ebx.split.physical_line_partition, 1);
 790 show_one_plus(ways_of_associativity, ebx.split.ways_of_associativity, 1);
 791 show_one_plus(number_of_sets, ecx.split.number_of_sets, 1);
 792
 793 static ssize_t show_size(struct _cpuid4_info *this_leaf, char *buf)
 794 {
 795         return sprintf(buf, "%luK\n", this_leaf->size / 1024);
 796 }
 797
 798 static ssize_t show_shared_cpu_map_func(struct _cpuid4_info *this_leaf,
 799                                         int type, char *buf)
 800 {
 801         ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
 802         int n = 0;
 803
 804         if (len > 1) {
 805                 const struct cpumask *mask;
 806
 807                 mask = to_cpumask(this_leaf->shared_cpu_map);
 808                 n = type ?
 809                         cpulist_scnprintf(buf, len-2, mask) :
 810                         cpumask_scnprintf(buf, len-2, mask);
 811                 buf[n++] = '\n';
 812                 buf[n] = '\0';
 813         }
 814         return n;
 815 }
 816
 817 static inline ssize_t show_shared_cpu_map(struct _cpuid4_info *leaf, char *buf)
 818 {
 819         return show_shared_cpu_map_func(leaf, 0, buf);
 820 }
 821
 822 static inline ssize_t show_shared_cpu_list(struct _cpuid4_info *leaf, char *buf)
 823 {
 824         return show_shared_cpu_map_func(leaf, 1, buf);
 825 }
 826
 827 static ssize_t show_type(struct _cpuid4_info *this_leaf, char *buf)
 828 {
 829         switch (this_leaf->eax.split.type) {
 830         case CACHE_TYPE_DATA:
 831                 return sprintf(buf, "Data\n");
 832         case CACHE_TYPE_INST:
 833                 return sprintf(buf, "Instruction\n");
 834         case CACHE_TYPE_UNIFIED:
 835                 return sprintf(buf, "Unified\n");
 836         default:
 837                 return sprintf(buf, "Unknown\n");
 838         }
 839 }
 840
 841 #define to_object(k)    container_of(k, struct _index_kobject, kobj)
 842 #define to_attr(a)      container_of(a, struct _cache_attr, attr)
 843
 844 #define define_one_ro(_name) \
 845 static struct _cache_attr _name = \
 846         __ATTR(_name, 0444, show_##_name, NULL)
 847
 848 define_one_ro(level);
 849 define_one_ro(type);
 850 define_one_ro(coherency_line_size);
 851 define_one_ro(physical_line_partition);
 852 define_one_ro(ways_of_associativity);
 853 define_one_ro(number_of_sets);
 854 define_one_ro(size);
 855 define_one_ro(shared_cpu_map);
 856 define_one_ro(shared_cpu_list);
 857
 858 #define DEFAULT_SYSFS_CACHE_ATTRS       \
 859         &type.attr,                     \
 860         &level.attr,                    \
 861         &coherency_line_size.attr,      \
 862         &physical_line_partition.attr,  \
 863         &ways_of_associativity.attr,    \
 864         &number_of_sets.attr,           \
 865         &size.attr,                     \
 866         &shared_cpu_map.attr,           \
 867         &shared_cpu_list.attr
 868
 869 static struct attribute *default_attrs[] = {
 870         DEFAULT_SYSFS_CACHE_ATTRS,
 871         NULL
 872 };
 873
 874 static struct attribute *default_l3_attrs[] = {
 875         DEFAULT_SYSFS_CACHE_ATTRS,
 876 #ifdef CONFIG_CPU_SUP_AMD
 877         &cache_disable_0.attr,
 878         &cache_disable_1.attr,
 879 #endif
 880         NULL
 881 };
 882
 883 static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
 884 {
 885         struct _cache_attr *fattr = to_attr(attr);
 886         struct _index_kobject *this_leaf = to_object(kobj);
 887         ssize_t ret;
 888
 889         ret = fattr->show ?
 890                 fattr->show(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
 891                         buf) :
 892                 0;
 893         return ret;
 894 }
 895
 896 static ssize_t store(struct kobject *kobj, struct attribute *attr,
 897                      const char *buf, size_t count)
 898 {
 899         struct _cache_attr *fattr = to_attr(attr);
 900         struct _index_kobject *this_leaf = to_object(kobj);
 901         ssize_t ret;
 902
 903         ret = fattr->store ?
 904                 fattr->store(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
 905                         buf, count) :
 906                 0;
 907         return ret;
 908 }
 909
 910 static const struct sysfs_ops sysfs_ops = {
 911         .show   = show,
 912         .store  = store,
 913 };
 914
 915 static struct kobj_type ktype_cache = {
 916         .sysfs_ops      = &sysfs_ops,
 917         .default_attrs  = default_attrs,
 918 };
 919
 920 static struct kobj_type ktype_percpu_entry = {
 921         .sysfs_ops      = &sysfs_ops,
 922 };
 923
 924 static void __cpuinit cpuid4_cache_sysfs_exit(unsigned int cpu)
 925 {
 926         kfree(per_cpu(ici_cache_kobject, cpu));
 927         kfree(per_cpu(ici_index_kobject, cpu));
 928         per_cpu(ici_cache_kobject, cpu) = NULL;
 929         per_cpu(ici_index_kobject, cpu) = NULL;
 930         free_cache_attributes(cpu);
 931 }
 932
 933 static int __cpuinit cpuid4_cache_sysfs_init(unsigned int cpu)
 934 {
 935         int err;
 936
 937         if (num_cache_leaves == 0)
 938                 return -ENOENT;
 939
 940         err = detect_cache_attributes(cpu);
 941         if (err)
 942                 return err;
 943
 944         /* Allocate all required memory */
 945         per_cpu(ici_cache_kobject, cpu) =
 946                 kzalloc(sizeof(struct kobject), GFP_KERNEL);
 947         if (unlikely(per_cpu(ici_cache_kobject, cpu) == NULL))
 948                 goto err_out;
 949
 950         per_cpu(ici_index_kobject, cpu) = kzalloc(
 951             sizeof(struct _index_kobject) * num_cache_leaves, GFP_KERNEL);
 952         if (unlikely(per_cpu(ici_index_kobject, cpu) == NULL))
 953                 goto err_out;
 954
 955         return 0;
 956
 957 err_out:
 958         cpuid4_cache_sysfs_exit(cpu);
 959         return -ENOMEM;
 960 }
 961
 962 static DECLARE_BITMAP(cache_dev_map, NR_CPUS);
 963
 964 /* Add/Remove cache interface for CPU device */
 965 static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
 966 {
 967         unsigned int cpu = sys_dev->id;
 968         unsigned long i, j;
 969         struct _index_kobject *this_object;
 970         struct _cpuid4_info   *this_leaf;
 971         int retval;
 972
 973         retval = cpuid4_cache_sysfs_init(cpu);
 974         if (unlikely(retval < 0))
 975                 return retval;
 976
 977         retval = kobject_init_and_add(per_cpu(ici_cache_kobject, cpu),
 978                                       &ktype_percpu_entry,
 979                                       &sys_dev->kobj, "%s", "cache");
 980         if (retval < 0) {
 981                 cpuid4_cache_sysfs_exit(cpu);
 982                 return retval;
 983         }
 984
 985         for (i = 0; i < num_cache_leaves; i++) {
 986                 this_object = INDEX_KOBJECT_PTR(cpu, i);
 987                 this_object->cpu = cpu;
 988                 this_object->index = i;
 989
 990                 this_leaf = CPUID4_INFO_IDX(cpu, i);
 991
 992                 if (this_leaf->can_disable)
 993                         ktype_cache.default_attrs = default_l3_attrs;
 994                 else
 995                         ktype_cache.default_attrs = default_attrs;
 996
 997                 retval = kobject_init_and_add(&(this_object->kobj),
 998                                               &ktype_cache,
 999                                               per_cpu(ici_cache_kobject, cpu),
1000                                               "index%1lu", i);
1001                 if (unlikely(retval)) {
1002                         for (j = 0; j < i; j++)
1003                                 kobject_put(&(INDEX_KOBJECT_PTR(cpu, j)->kobj));
1004                         kobject_put(per_cpu(ici_cache_kobject, cpu));
1005                         cpuid4_cache_sysfs_exit(cpu);
1006                         return retval;
1007                 }
1008                 kobject_uevent(&(this_object->kobj), KOBJ_ADD);
1009         }
1010         cpumask_set_cpu(cpu, to_cpumask(cache_dev_map));
1011
1012         kobject_uevent(per_cpu(ici_cache_kobject, cpu), KOBJ_ADD);
1013         return 0;
1014 }
1015
1016 static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
1017 {
1018         unsigned int cpu = sys_dev->id;
1019         unsigned long i;
1020
1021         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
1022                 return;
1023         if (!cpumask_test_cpu(cpu, to_cpumask(cache_dev_map)))
1024                 return;
1025         cpumask_clear_cpu(cpu, to_cpumask(cache_dev_map));
1026
1027         for (i = 0; i < num_cache_leaves; i++)
1028                 kobject_put(&(INDEX_KOBJECT_PTR(cpu, i)->kobj));
1029         kobject_put(per_cpu(ici_cache_kobject, cpu));
1030         cpuid4_cache_sysfs_exit(cpu);
1031 }
1032
1033 static int __cpuinit cacheinfo_cpu_callback(struct notifier_block *nfb,
1034                                         unsigned long action, void *hcpu)
1035 {
1036         unsigned int cpu = (unsigned long)hcpu;
1037         struct sys_device *sys_dev;
1038
1039         sys_dev = get_cpu_sysdev(cpu);
1040         switch (action) {
1041         case CPU_ONLINE:
1042         case CPU_ONLINE_FROZEN:
1043                 cache_add_dev(sys_dev);
1044                 break;
1045         case CPU_DEAD:
1046         case CPU_DEAD_FROZEN:
1047                 cache_remove_dev(sys_dev);
1048                 break;
1049         }
1050         return NOTIFY_OK;
1051 }
1052
1053 static struct notifier_block __cpuinitdata cacheinfo_cpu_notifier = {
1054         .notifier_call = cacheinfo_cpu_callback,
1055 };
1056
1057 static int __cpuinit cache_sysfs_init(void)
1058 {
1059         int i;
1060
1061         if (num_cache_leaves == 0)
1062                 return 0;
1063
1064         for_each_online_cpu(i) {
1065                 int err;
1066                 struct sys_device *sys_dev = get_cpu_sysdev(i);
1067
1068                 err = cache_add_dev(sys_dev);
1069                 if (err)
1070                         return err;
1071         }
1072         register_hotcpu_notifier(&cacheinfo_cpu_notifier);
1073         return 0;
1074 }
1075
1076 device_initcall(cache_sysfs_init);
1077
1078 #endif