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 (boot_cpu_data.x86 != 0x10)
 332                 return;
 333
 334         if (index < 3)
 335                 return;
 336
 337         /* see errata #382 and #388 */
 338         if (boot_cpu_data.x86_model < 0x8)
 339                 return;
 340
 341         if ((boot_cpu_data.x86_model == 0x8 ||
 342              boot_cpu_data.x86_model == 0x9)
 343                 &&
 344              boot_cpu_data.x86_mask < 0x1)
 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                 amd_check_l3_disable(index, this_leaf);
 451         } else {
 452                 cpuid_count(4, index, &eax.full, &ebx.full, &ecx.full, &edx);
 453         }
 454
 455         if (eax.split.type == CACHE_TYPE_NULL)
 456                 return -EIO; /* better error ? */
 457
 458         this_leaf->eax = eax;
 459         this_leaf->ebx = ebx;
 460         this_leaf->ecx = ecx;
 461         this_leaf->size = (ecx.split.number_of_sets          + 1) *
 462                           (ebx.split.coherency_line_size     + 1) *
 463                           (ebx.split.physical_line_partition + 1) *
 464                           (ebx.split.ways_of_associativity   + 1);
 465         return 0;
 466 }
 467
 468 static int __cpuinit find_num_cache_leaves(void)
 469 {
 470         unsigned int            eax, ebx, ecx, edx;
 471         union _cpuid4_leaf_eax  cache_eax;
 472         int                     i = -1;
 473
 474         do {
 475                 ++i;
 476                 /* Do cpuid(4) loop to find out num_cache_leaves */
 477                 cpuid_count(4, i, &eax, &ebx, &ecx, &edx);
 478                 cache_eax.full = eax;
 479         } while (cache_eax.split.type != CACHE_TYPE_NULL);
 480         return i;
 481 }
 482
 483 unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
 484 {
 485         /* Cache sizes */
 486         unsigned int trace = 0, l1i = 0, l1d = 0, l2 = 0, l3 = 0;
 487         unsigned int new_l1d = 0, new_l1i = 0; /* Cache sizes from cpuid(4) */
 488         unsigned int new_l2 = 0, new_l3 = 0, i; /* Cache sizes from cpuid(4) */
 489         unsigned int l2_id = 0, l3_id = 0, num_threads_sharing, index_msb;
 490 #ifdef CONFIG_X86_HT
 491         unsigned int cpu = c->cpu_index;
 492 #endif
 493
 494         if (c->cpuid_level > 3) {
 495                 static int is_initialized;
 496
 497                 if (is_initialized == 0) {
 498                         /* Init num_cache_leaves from boot CPU */
 499                         num_cache_leaves = find_num_cache_leaves();
 500                         is_initialized++;
 501                 }
 502
 503                 /*
 504                  * Whenever possible use cpuid(4), deterministic cache
 505                  * parameters cpuid leaf to find the cache details
 506                  */
 507                 for (i = 0; i < num_cache_leaves; i++) {
 508                         struct _cpuid4_info_regs this_leaf;
 509                         int retval;
 510
 511                         retval = cpuid4_cache_lookup_regs(i, &this_leaf);
 512                         if (retval >= 0) {
 513                                 switch (this_leaf.eax.split.level) {
 514                                 case 1:
 515                                         if (this_leaf.eax.split.type ==
 516                                                         CACHE_TYPE_DATA)
 517                                                 new_l1d = this_leaf.size/1024;
 518                                         else if (this_leaf.eax.split.type ==
 519                                                         CACHE_TYPE_INST)
 520                                                 new_l1i = this_leaf.size/1024;
 521                                         break;
 522                                 case 2:
 523                                         new_l2 = this_leaf.size/1024;
 524                                         num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
 525                                         index_msb = get_count_order(num_threads_sharing);
 526                                         l2_id = c->apicid >> index_msb;
 527                                         break;
 528                                 case 3:
 529                                         new_l3 = this_leaf.size/1024;
 530                                         num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
 531                                         index_msb = get_count_order(
 532                                                         num_threads_sharing);
 533                                         l3_id = c->apicid >> index_msb;
 534                                         break;
 535                                 default:
 536                                         break;
 537                                 }
 538                         }
 539                 }
 540         }
 541         /*
 542          * Don't use cpuid2 if cpuid4 is supported. For P4, we use cpuid2 for
 543          * trace cache
 544          */
 545         if ((num_cache_leaves == 0 || c->x86 == 15) && c->cpuid_level > 1) {
 546                 /* supports eax=2  call */
 547                 int j, n;
 548                 unsigned int regs[4];
 549                 unsigned char *dp = (unsigned char *)regs;
 550                 int only_trace = 0;
 551
 552                 if (num_cache_leaves != 0 && c->x86 == 15)
 553                         only_trace = 1;
 554
 555                 /* Number of times to iterate */
 556                 n = cpuid_eax(2) & 0xFF;
 557
 558                 for (i = 0 ; i < n ; i++) {
 559                         cpuid(2, &regs[0], &regs[1], &regs[2], &regs[3]);
 560
 561                         /* If bit 31 is set, this is an unknown format */
 562                         for (j = 0 ; j < 3 ; j++)
 563                                 if (regs[j] & (1 << 31))
 564                                         regs[j] = 0;
 565
 566                         /* Byte 0 is level count, not a descriptor */
 567                         for (j = 1 ; j < 16 ; j++) {
 568                                 unsigned char des = dp[j];
 569                                 unsigned char k = 0;
 570
 571                                 /* look up this descriptor in the table */
 572                                 while (cache_table[k].descriptor != 0) {
 573                                         if (cache_table[k].descriptor == des) {
 574                                                 if (only_trace && cache_table[k].cache_type != LVL_TRACE)
 575                                                         break;
 576                                                 switch (cache_table[k].cache_type) {
 577                                                 case LVL_1_INST:
 578                                                         l1i += cache_table[k].size;
 579                                                         break;
 580                                                 case LVL_1_DATA:
 581                                                         l1d += cache_table[k].size;
 582                                                         break;
 583                                                 case LVL_2:
 584                                                         l2 += cache_table[k].size;
 585                                                         break;
 586                                                 case LVL_3:
 587                                                         l3 += cache_table[k].size;
 588                                                         break;
 589                                                 case LVL_TRACE:
 590                                                         trace += cache_table[k].size;
 591                                                         break;
 592                                                 }
 593
 594                                                 break;
 595                                         }
 596
 597                                         k++;
 598                                 }
 599                         }
 600                 }
 601         }
 602
 603         if (new_l1d)
 604                 l1d = new_l1d;
 605
 606         if (new_l1i)
 607                 l1i = new_l1i;
 608
 609         if (new_l2) {
 610                 l2 = new_l2;
 611 #ifdef CONFIG_X86_HT
 612                 per_cpu(cpu_llc_id, cpu) = l2_id;
 613 #endif
 614         }
 615
 616         if (new_l3) {
 617                 l3 = new_l3;
 618 #ifdef CONFIG_X86_HT
 619                 per_cpu(cpu_llc_id, cpu) = l3_id;
 620 #endif
 621         }
 622
 623         c->x86_cache_size = l3 ? l3 : (l2 ? l2 : (l1i+l1d));
 624
 625         return l2;
 626 }
 627
 628 #ifdef CONFIG_SYSFS
 629
 630 /* pointer to _cpuid4_info array (for each cache leaf) */
 631 static DEFINE_PER_CPU(struct _cpuid4_info *, ici_cpuid4_info);
 632 #define CPUID4_INFO_IDX(x, y)   (&((per_cpu(ici_cpuid4_info, x))[y]))
 633
 634 #ifdef CONFIG_SMP
 635 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
 636 {
 637         struct _cpuid4_info     *this_leaf, *sibling_leaf;
 638         unsigned long num_threads_sharing;
 639         int index_msb, i, sibling;
 640         struct cpuinfo_x86 *c = &cpu_data(cpu);
 641
 642         if ((index == 3) && (c->x86_vendor == X86_VENDOR_AMD)) {
 643                 for_each_cpu(i, c->llc_shared_map) {
 644                         if (!per_cpu(ici_cpuid4_info, i))
 645                                 continue;
 646                         this_leaf = CPUID4_INFO_IDX(i, index);
 647                         for_each_cpu(sibling, c->llc_shared_map) {
 648                                 if (!cpu_online(sibling))
 649                                         continue;
 650                                 set_bit(sibling, this_leaf->shared_cpu_map);
 651                         }
 652                 }
 653                 return;
 654         }
 655         this_leaf = CPUID4_INFO_IDX(cpu, index);
 656         num_threads_sharing = 1 + this_leaf->eax.split.num_threads_sharing;
 657
 658         if (num_threads_sharing == 1)
 659                 cpumask_set_cpu(cpu, to_cpumask(this_leaf->shared_cpu_map));
 660         else {
 661                 index_msb = get_count_order(num_threads_sharing);
 662
 663                 for_each_online_cpu(i) {
 664                         if (cpu_data(i).apicid >> index_msb ==
 665                             c->apicid >> index_msb) {
 666                                 cpumask_set_cpu(i,
 667                                         to_cpumask(this_leaf->shared_cpu_map));
 668                                 if (i != cpu && per_cpu(ici_cpuid4_info, i))  {
 669                                         sibling_leaf =
 670                                                 CPUID4_INFO_IDX(i, index);
 671                                         cpumask_set_cpu(cpu, to_cpumask(
 672                                                 sibling_leaf->shared_cpu_map));
 673                                 }
 674                         }
 675                 }
 676         }
 677 }
 678 static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
 679 {
 680         struct _cpuid4_info     *this_leaf, *sibling_leaf;
 681         int sibling;
 682
 683         this_leaf = CPUID4_INFO_IDX(cpu, index);
 684         for_each_cpu(sibling, to_cpumask(this_leaf->shared_cpu_map)) {
 685                 sibling_leaf = CPUID4_INFO_IDX(sibling, index);
 686                 cpumask_clear_cpu(cpu,
 687                                   to_cpumask(sibling_leaf->shared_cpu_map));
 688         }
 689 }
 690 #else
 691 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
 692 {
 693 }
 694
 695 static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
 696 {
 697 }
 698 #endif
 699
 700 static void __cpuinit free_cache_attributes(unsigned int cpu)
 701 {
 702         int i;
 703
 704         for (i = 0; i < num_cache_leaves; i++)
 705                 cache_remove_shared_cpu_map(cpu, i);
 706
 707         kfree(per_cpu(ici_cpuid4_info, cpu));
 708         per_cpu(ici_cpuid4_info, cpu) = NULL;
 709 }
 710
 711 static int
 712 __cpuinit cpuid4_cache_lookup(int index, struct _cpuid4_info *this_leaf)
 713 {
 714         struct _cpuid4_info_regs *leaf_regs =
 715                 (struct _cpuid4_info_regs *)this_leaf;
 716
 717         return cpuid4_cache_lookup_regs(index, leaf_regs);
 718 }
 719
 720 static void __cpuinit get_cpu_leaves(void *_retval)
 721 {
 722         int j, *retval = _retval, cpu = smp_processor_id();
 723
 724         /* Do cpuid and store the results */
 725         for (j = 0; j < num_cache_leaves; j++) {
 726                 struct _cpuid4_info *this_leaf;
 727                 this_leaf = CPUID4_INFO_IDX(cpu, j);
 728                 *retval = cpuid4_cache_lookup(j, this_leaf);
 729                 if (unlikely(*retval < 0)) {
 730                         int i;
 731
 732                         for (i = 0; i < j; i++)
 733                                 cache_remove_shared_cpu_map(cpu, i);
 734                         break;
 735                 }
 736                 cache_shared_cpu_map_setup(cpu, j);
 737         }
 738 }
 739
 740 static int __cpuinit detect_cache_attributes(unsigned int cpu)
 741 {
 742         int                     retval;
 743
 744         if (num_cache_leaves == 0)
 745                 return -ENOENT;
 746
 747         per_cpu(ici_cpuid4_info, cpu) = kzalloc(
 748             sizeof(struct _cpuid4_info) * num_cache_leaves, GFP_KERNEL);
 749         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
 750                 return -ENOMEM;
 751
 752         smp_call_function_single(cpu, get_cpu_leaves, &retval, true);
 753         if (retval) {
 754                 kfree(per_cpu(ici_cpuid4_info, cpu));
 755                 per_cpu(ici_cpuid4_info, cpu) = NULL;
 756         }
 757
 758         return retval;
 759 }
 760
 761 #include <linux/kobject.h>
 762 #include <linux/sysfs.h>
 763
 764 extern struct sysdev_class cpu_sysdev_class; /* from drivers/base/cpu.c */
 765
 766 /* pointer to kobject for cpuX/cache */
 767 static DEFINE_PER_CPU(struct kobject *, ici_cache_kobject);
 768
 769 struct _index_kobject {
 770         struct kobject kobj;
 771         unsigned int cpu;
 772         unsigned short index;
 773 };
 774
 775 /* pointer to array of kobjects for cpuX/cache/indexY */
 776 static DEFINE_PER_CPU(struct _index_kobject *, ici_index_kobject);
 777 #define INDEX_KOBJECT_PTR(x, y)         (&((per_cpu(ici_index_kobject, x))[y]))
 778
 779 #define show_one_plus(file_name, object, val)                           \
 780 static ssize_t show_##file_name                                         \
 781                         (struct _cpuid4_info *this_leaf, char *buf)     \
 782 {                                                                       \
 783         return sprintf(buf, "%lu\n", (unsigned long)this_leaf->object + val); \
 784 }
 785
 786 show_one_plus(level, eax.split.level, 0);
 787 show_one_plus(coherency_line_size, ebx.split.coherency_line_size, 1);
 788 show_one_plus(physical_line_partition, ebx.split.physical_line_partition, 1);
 789 show_one_plus(ways_of_associativity, ebx.split.ways_of_associativity, 1);
 790 show_one_plus(number_of_sets, ecx.split.number_of_sets, 1);
 791
 792 static ssize_t show_size(struct _cpuid4_info *this_leaf, char *buf)
 793 {
 794         return sprintf(buf, "%luK\n", this_leaf->size / 1024);
 795 }
 796
 797 static ssize_t show_shared_cpu_map_func(struct _cpuid4_info *this_leaf,
 798                                         int type, char *buf)
 799 {
 800         ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
 801         int n = 0;
 802
 803         if (len > 1) {
 804                 const struct cpumask *mask;
 805
 806                 mask = to_cpumask(this_leaf->shared_cpu_map);
 807                 n = type ?
 808                         cpulist_scnprintf(buf, len-2, mask) :
 809                         cpumask_scnprintf(buf, len-2, mask);
 810                 buf[n++] = '\n';
 811                 buf[n] = '\0';
 812         }
 813         return n;
 814 }
 815
 816 static inline ssize_t show_shared_cpu_map(struct _cpuid4_info *leaf, char *buf)
 817 {
 818         return show_shared_cpu_map_func(leaf, 0, buf);
 819 }
 820
 821 static inline ssize_t show_shared_cpu_list(struct _cpuid4_info *leaf, char *buf)
 822 {
 823         return show_shared_cpu_map_func(leaf, 1, buf);
 824 }
 825
 826 static ssize_t show_type(struct _cpuid4_info *this_leaf, char *buf)
 827 {
 828         switch (this_leaf->eax.split.type) {
 829         case CACHE_TYPE_DATA:
 830                 return sprintf(buf, "Data\n");
 831         case CACHE_TYPE_INST:
 832                 return sprintf(buf, "Instruction\n");
 833         case CACHE_TYPE_UNIFIED:
 834                 return sprintf(buf, "Unified\n");
 835         default:
 836                 return sprintf(buf, "Unknown\n");
 837         }
 838 }
 839
 840 #define to_object(k)    container_of(k, struct _index_kobject, kobj)
 841 #define to_attr(a)      container_of(a, struct _cache_attr, attr)
 842
 843 #define define_one_ro(_name) \
 844 static struct _cache_attr _name = \
 845         __ATTR(_name, 0444, show_##_name, NULL)
 846
 847 define_one_ro(level);
 848 define_one_ro(type);
 849 define_one_ro(coherency_line_size);
 850 define_one_ro(physical_line_partition);
 851 define_one_ro(ways_of_associativity);
 852 define_one_ro(number_of_sets);
 853 define_one_ro(size);
 854 define_one_ro(shared_cpu_map);
 855 define_one_ro(shared_cpu_list);
 856
 857 #define DEFAULT_SYSFS_CACHE_ATTRS       \
 858         &type.attr,                     \
 859         &level.attr,                    \
 860         &coherency_line_size.attr,      \
 861         &physical_line_partition.attr,  \
 862         &ways_of_associativity.attr,    \
 863         &number_of_sets.attr,           \
 864         &size.attr,                     \
 865         &shared_cpu_map.attr,           \
 866         &shared_cpu_list.attr
 867
 868 static struct attribute *default_attrs[] = {
 869         DEFAULT_SYSFS_CACHE_ATTRS,
 870         NULL
 871 };
 872
 873 static struct attribute *default_l3_attrs[] = {
 874         DEFAULT_SYSFS_CACHE_ATTRS,
 875 #ifdef CONFIG_CPU_SUP_AMD
 876         &cache_disable_0.attr,
 877         &cache_disable_1.attr,
 878 #endif
 879         NULL
 880 };
 881
 882 static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
 883 {
 884         struct _cache_attr *fattr = to_attr(attr);
 885         struct _index_kobject *this_leaf = to_object(kobj);
 886         ssize_t ret;
 887
 888         ret = fattr->show ?
 889                 fattr->show(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
 890                         buf) :
 891                 0;
 892         return ret;
 893 }
 894
 895 static ssize_t store(struct kobject *kobj, struct attribute *attr,
 896                      const char *buf, size_t count)
 897 {
 898         struct _cache_attr *fattr = to_attr(attr);
 899         struct _index_kobject *this_leaf = to_object(kobj);
 900         ssize_t ret;
 901
 902         ret = fattr->store ?
 903                 fattr->store(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
 904                         buf, count) :
 905                 0;
 906         return ret;
 907 }
 908
 909 static const struct sysfs_ops sysfs_ops = {
 910         .show   = show,
 911         .store  = store,
 912 };
 913
 914 static struct kobj_type ktype_cache = {
 915         .sysfs_ops      = &sysfs_ops,
 916         .default_attrs  = default_attrs,
 917 };
 918
 919 static struct kobj_type ktype_percpu_entry = {
 920         .sysfs_ops      = &sysfs_ops,
 921 };
 922
 923 static void __cpuinit cpuid4_cache_sysfs_exit(unsigned int cpu)
 924 {
 925         kfree(per_cpu(ici_cache_kobject, cpu));
 926         kfree(per_cpu(ici_index_kobject, cpu));
 927         per_cpu(ici_cache_kobject, cpu) = NULL;
 928         per_cpu(ici_index_kobject, cpu) = NULL;
 929         free_cache_attributes(cpu);
 930 }
 931
 932 static int __cpuinit cpuid4_cache_sysfs_init(unsigned int cpu)
 933 {
 934         int err;
 935
 936         if (num_cache_leaves == 0)
 937                 return -ENOENT;
 938
 939         err = detect_cache_attributes(cpu);
 940         if (err)
 941                 return err;
 942
 943         /* Allocate all required memory */
 944         per_cpu(ici_cache_kobject, cpu) =
 945                 kzalloc(sizeof(struct kobject), GFP_KERNEL);
 946         if (unlikely(per_cpu(ici_cache_kobject, cpu) == NULL))
 947                 goto err_out;
 948
 949         per_cpu(ici_index_kobject, cpu) = kzalloc(
 950             sizeof(struct _index_kobject) * num_cache_leaves, GFP_KERNEL);
 951         if (unlikely(per_cpu(ici_index_kobject, cpu) == NULL))
 952                 goto err_out;
 953
 954         return 0;
 955
 956 err_out:
 957         cpuid4_cache_sysfs_exit(cpu);
 958         return -ENOMEM;
 959 }
 960
 961 static DECLARE_BITMAP(cache_dev_map, NR_CPUS);
 962
 963 /* Add/Remove cache interface for CPU device */
 964 static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
 965 {
 966         unsigned int cpu = sys_dev->id;
 967         unsigned long i, j;
 968         struct _index_kobject *this_object;
 969         struct _cpuid4_info   *this_leaf;
 970         int retval;
 971
 972         retval = cpuid4_cache_sysfs_init(cpu);
 973         if (unlikely(retval < 0))
 974                 return retval;
 975
 976         retval = kobject_init_and_add(per_cpu(ici_cache_kobject, cpu),
 977                                       &ktype_percpu_entry,
 978                                       &sys_dev->kobj, "%s", "cache");
 979         if (retval < 0) {
 980                 cpuid4_cache_sysfs_exit(cpu);
 981                 return retval;
 982         }
 983
 984         for (i = 0; i < num_cache_leaves; i++) {
 985                 this_object = INDEX_KOBJECT_PTR(cpu, i);
 986                 this_object->cpu = cpu;
 987                 this_object->index = i;
 988
 989                 this_leaf = CPUID4_INFO_IDX(cpu, i);
 990
 991                 if (this_leaf->can_disable)
 992                         ktype_cache.default_attrs = default_l3_attrs;
 993                 else
 994                         ktype_cache.default_attrs = default_attrs;
 995
 996                 retval = kobject_init_and_add(&(this_object->kobj),
 997                                               &ktype_cache,
 998                                               per_cpu(ici_cache_kobject, cpu),
 999                                               "index%1lu", i);
1000                 if (unlikely(retval)) {
1001                         for (j = 0; j < i; j++)
1002                                 kobject_put(&(INDEX_KOBJECT_PTR(cpu, j)->kobj));
1003                         kobject_put(per_cpu(ici_cache_kobject, cpu));
1004                         cpuid4_cache_sysfs_exit(cpu);
1005                         return retval;
1006                 }
1007                 kobject_uevent(&(this_object->kobj), KOBJ_ADD);
1008         }
1009         cpumask_set_cpu(cpu, to_cpumask(cache_dev_map));
1010
1011         kobject_uevent(per_cpu(ici_cache_kobject, cpu), KOBJ_ADD);
1012         return 0;
1013 }
1014
1015 static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
1016 {
1017         unsigned int cpu = sys_dev->id;
1018         unsigned long i;
1019
1020         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
1021                 return;
1022         if (!cpumask_test_cpu(cpu, to_cpumask(cache_dev_map)))
1023                 return;
1024         cpumask_clear_cpu(cpu, to_cpumask(cache_dev_map));
1025
1026         for (i = 0; i < num_cache_leaves; i++)
1027                 kobject_put(&(INDEX_KOBJECT_PTR(cpu, i)->kobj));
1028         kobject_put(per_cpu(ici_cache_kobject, cpu));
1029         cpuid4_cache_sysfs_exit(cpu);
1030 }
1031
1032 static int __cpuinit cacheinfo_cpu_callback(struct notifier_block *nfb,
1033                                         unsigned long action, void *hcpu)
1034 {
1035         unsigned int cpu = (unsigned long)hcpu;
1036         struct sys_device *sys_dev;
1037
1038         sys_dev = get_cpu_sysdev(cpu);
1039         switch (action) {
1040         case CPU_ONLINE:
1041         case CPU_ONLINE_FROZEN:
1042                 cache_add_dev(sys_dev);
1043                 break;
1044         case CPU_DEAD:
1045         case CPU_DEAD_FROZEN:
1046                 cache_remove_dev(sys_dev);
1047                 break;
1048         }
1049         return NOTIFY_OK;
1050 }
1051
1052 static struct notifier_block __cpuinitdata cacheinfo_cpu_notifier = {
1053         .notifier_call = cacheinfo_cpu_callback,
1054 };
1055
1056 static int __cpuinit cache_sysfs_init(void)
1057 {
1058         int i;
1059
1060         if (num_cache_leaves == 0)
1061                 return 0;
1062
1063         for_each_online_cpu(i) {
1064                 int err;
1065                 struct sys_device *sys_dev = get_cpu_sysdev(i);
1066
1067                 err = cache_add_dev(sys_dev);
1068                 if (err)
1069                         return err;
1070         }
1071         register_hotcpu_notifier(&cacheinfo_cpu_notifier);
1072         return 0;
1073 }
1074
1075 device_initcall(cache_sysfs_init);
1076
1077 #endif