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