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