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