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