GNU Linux-libre 4.4.297-gnu1
[releases.git] / arch / ia64 / kernel / palinfo.c
1 /*
2  * palinfo.c
3  *
4  * Prints processor specific information reported by PAL.
5  * This code is based on specification of PAL as of the
6  * Intel IA-64 Architecture Software Developer's Manual v1.0.
7  *
8  *
9  * Copyright (C) 2000-2001, 2003 Hewlett-Packard Co
10  *      Stephane Eranian <eranian@hpl.hp.com>
11  * Copyright (C) 2004 Intel Corporation
12  *  Ashok Raj <ashok.raj@intel.com>
13  *
14  * 05/26/2000   S.Eranian       initial release
15  * 08/21/2000   S.Eranian       updated to July 2000 PAL specs
16  * 02/05/2001   S.Eranian       fixed module support
17  * 10/23/2001   S.Eranian       updated pal_perf_mon_info bug fixes
18  * 03/24/2004   Ashok Raj       updated to work with CPU Hotplug
19  * 10/26/2006   Russ Anderson   updated processor features to rev 2.2 spec
20  */
21 #include <linux/types.h>
22 #include <linux/errno.h>
23 #include <linux/init.h>
24 #include <linux/proc_fs.h>
25 #include <linux/seq_file.h>
26 #include <linux/mm.h>
27 #include <linux/module.h>
28 #include <linux/efi.h>
29 #include <linux/notifier.h>
30 #include <linux/cpu.h>
31 #include <linux/cpumask.h>
32
33 #include <asm/pal.h>
34 #include <asm/sal.h>
35 #include <asm/page.h>
36 #include <asm/processor.h>
37 #include <linux/smp.h>
38
39 MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
40 MODULE_DESCRIPTION("/proc interface to IA-64 PAL");
41 MODULE_LICENSE("GPL");
42
43 #define PALINFO_VERSION "0.5"
44
45 typedef int (*palinfo_func_t)(struct seq_file *);
46
47 typedef struct {
48         const char              *name;          /* name of the proc entry */
49         palinfo_func_t          proc_read;      /* function to call for reading */
50         struct proc_dir_entry   *entry;         /* registered entry (removal) */
51 } palinfo_entry_t;
52
53
54 /*
55  *  A bunch of string array to get pretty printing
56  */
57
58 static const char *cache_types[] = {
59         "",                     /* not used */
60         "Instruction",
61         "Data",
62         "Data/Instruction"      /* unified */
63 };
64
65 static const char *cache_mattrib[]={
66         "WriteThrough",
67         "WriteBack",
68         "",             /* reserved */
69         ""              /* reserved */
70 };
71
72 static const char *cache_st_hints[]={
73         "Temporal, level 1",
74         "Reserved",
75         "Reserved",
76         "Non-temporal, all levels",
77         "Reserved",
78         "Reserved",
79         "Reserved",
80         "Reserved"
81 };
82
83 static const char *cache_ld_hints[]={
84         "Temporal, level 1",
85         "Non-temporal, level 1",
86         "Reserved",
87         "Non-temporal, all levels",
88         "Reserved",
89         "Reserved",
90         "Reserved",
91         "Reserved"
92 };
93
94 static const char *rse_hints[]={
95         "enforced lazy",
96         "eager stores",
97         "eager loads",
98         "eager loads and stores"
99 };
100
101 #define RSE_HINTS_COUNT ARRAY_SIZE(rse_hints)
102
103 static const char *mem_attrib[]={
104         "WB",           /* 000 */
105         "SW",           /* 001 */
106         "010",          /* 010 */
107         "011",          /* 011 */
108         "UC",           /* 100 */
109         "UCE",          /* 101 */
110         "WC",           /* 110 */
111         "NaTPage"       /* 111 */
112 };
113
114 /*
115  * Take a 64bit vector and produces a string such that
116  * if bit n is set then 2^n in clear text is generated. The adjustment
117  * to the right unit is also done.
118  *
119  * Input:
120  *      - a pointer to a buffer to hold the string
121  *      - a 64-bit vector
122  * Ouput:
123  *      - a pointer to the end of the buffer
124  *
125  */
126 static void bitvector_process(struct seq_file *m, u64 vector)
127 {
128         int i,j;
129         static const char *units[]={ "", "K", "M", "G", "T" };
130
131         for (i=0, j=0; i < 64; i++ , j=i/10) {
132                 if (vector & 0x1)
133                         seq_printf(m, "%d%s ", 1 << (i-j*10), units[j]);
134                 vector >>= 1;
135         }
136 }
137
138 /*
139  * Take a 64bit vector and produces a string such that
140  * if bit n is set then register n is present. The function
141  * takes into account consecutive registers and prints out ranges.
142  *
143  * Input:
144  *      - a pointer to a buffer to hold the string
145  *      - a 64-bit vector
146  * Ouput:
147  *      - a pointer to the end of the buffer
148  *
149  */
150 static void bitregister_process(struct seq_file *m, u64 *reg_info, int max)
151 {
152         int i, begin, skip = 0;
153         u64 value = reg_info[0];
154
155         value >>= i = begin = ffs(value) - 1;
156
157         for(; i < max; i++ ) {
158
159                 if (i != 0 && (i%64) == 0) value = *++reg_info;
160
161                 if ((value & 0x1) == 0 && skip == 0) {
162                         if (begin  <= i - 2)
163                                 seq_printf(m, "%d-%d ", begin, i-1);
164                         else
165                                 seq_printf(m, "%d ", i-1);
166                         skip  = 1;
167                         begin = -1;
168                 } else if ((value & 0x1) && skip == 1) {
169                         skip = 0;
170                         begin = i;
171                 }
172                 value >>=1;
173         }
174         if (begin > -1) {
175                 if (begin < 127)
176                         seq_printf(m, "%d-127", begin);
177                 else
178                         seq_puts(m, "127");
179         }
180 }
181
182 static int power_info(struct seq_file *m)
183 {
184         s64 status;
185         u64 halt_info_buffer[8];
186         pal_power_mgmt_info_u_t *halt_info =(pal_power_mgmt_info_u_t *)halt_info_buffer;
187         int i;
188
189         status = ia64_pal_halt_info(halt_info);
190         if (status != 0) return 0;
191
192         for (i=0; i < 8 ; i++ ) {
193                 if (halt_info[i].pal_power_mgmt_info_s.im == 1) {
194                         seq_printf(m,
195                                    "Power level %d:\n"
196                                    "\tentry_latency       : %d cycles\n"
197                                    "\texit_latency        : %d cycles\n"
198                                    "\tpower consumption   : %d mW\n"
199                                    "\tCache+TLB coherency : %s\n", i,
200                                    halt_info[i].pal_power_mgmt_info_s.entry_latency,
201                                    halt_info[i].pal_power_mgmt_info_s.exit_latency,
202                                    halt_info[i].pal_power_mgmt_info_s.power_consumption,
203                                    halt_info[i].pal_power_mgmt_info_s.co ? "Yes" : "No");
204                 } else {
205                         seq_printf(m,"Power level %d: not implemented\n", i);
206                 }
207         }
208         return 0;
209 }
210
211 static int cache_info(struct seq_file *m)
212 {
213         unsigned long i, levels, unique_caches;
214         pal_cache_config_info_t cci;
215         int j, k;
216         long status;
217
218         if ((status = ia64_pal_cache_summary(&levels, &unique_caches)) != 0) {
219                 printk(KERN_ERR "ia64_pal_cache_summary=%ld\n", status);
220                 return 0;
221         }
222
223         seq_printf(m, "Cache levels  : %ld\nUnique caches : %ld\n\n",
224                    levels, unique_caches);
225
226         for (i=0; i < levels; i++) {
227                 for (j=2; j >0 ; j--) {
228                         /* even without unification some level may not be present */
229                         if ((status=ia64_pal_cache_config_info(i,j, &cci)) != 0)
230                                 continue;
231
232                         seq_printf(m,
233                                    "%s Cache level %lu:\n"
234                                    "\tSize           : %u bytes\n"
235                                    "\tAttributes     : ",
236                                    cache_types[j+cci.pcci_unified], i+1,
237                                    cci.pcci_cache_size);
238
239                         if (cci.pcci_unified)
240                                 seq_puts(m, "Unified ");
241
242                         seq_printf(m, "%s\n", cache_mattrib[cci.pcci_cache_attr]);
243
244                         seq_printf(m,
245                                    "\tAssociativity  : %d\n"
246                                    "\tLine size      : %d bytes\n"
247                                    "\tStride         : %d bytes\n",
248                                    cci.pcci_assoc,
249                                    1<<cci.pcci_line_size,
250                                    1<<cci.pcci_stride);
251                         if (j == 1)
252                                 seq_puts(m, "\tStore latency  : N/A\n");
253                         else
254                                 seq_printf(m, "\tStore latency  : %d cycle(s)\n",
255                                            cci.pcci_st_latency);
256
257                         seq_printf(m,
258                                    "\tLoad latency   : %d cycle(s)\n"
259                                    "\tStore hints    : ", cci.pcci_ld_latency);
260
261                         for(k=0; k < 8; k++ ) {
262                                 if ( cci.pcci_st_hints & 0x1)
263                                         seq_printf(m, "[%s]", cache_st_hints[k]);
264                                 cci.pcci_st_hints >>=1;
265                         }
266                         seq_puts(m, "\n\tLoad hints     : ");
267
268                         for(k=0; k < 8; k++ ) {
269                                 if (cci.pcci_ld_hints & 0x1)
270                                         seq_printf(m, "[%s]", cache_ld_hints[k]);
271                                 cci.pcci_ld_hints >>=1;
272                         }
273                         seq_printf(m,
274                                    "\n\tAlias boundary : %d byte(s)\n"
275                                    "\tTag LSB        : %d\n"
276                                    "\tTag MSB        : %d\n",
277                                    1<<cci.pcci_alias_boundary, cci.pcci_tag_lsb,
278                                    cci.pcci_tag_msb);
279
280                         /* when unified, data(j=2) is enough */
281                         if (cci.pcci_unified)
282                                 break;
283                 }
284         }
285         return 0;
286 }
287
288
289 static int vm_info(struct seq_file *m)
290 {
291         u64 tr_pages =0, vw_pages=0, tc_pages;
292         u64 attrib;
293         pal_vm_info_1_u_t vm_info_1;
294         pal_vm_info_2_u_t vm_info_2;
295         pal_tc_info_u_t tc_info;
296         ia64_ptce_info_t ptce;
297         const char *sep;
298         int i, j;
299         long status;
300
301         if ((status = ia64_pal_vm_summary(&vm_info_1, &vm_info_2)) !=0) {
302                 printk(KERN_ERR "ia64_pal_vm_summary=%ld\n", status);
303         } else {
304
305                 seq_printf(m,
306                      "Physical Address Space         : %d bits\n"
307                      "Virtual Address Space          : %d bits\n"
308                      "Protection Key Registers(PKR)  : %d\n"
309                      "Implemented bits in PKR.key    : %d\n"
310                      "Hash Tag ID                    : 0x%x\n"
311                      "Size of RR.rid                 : %d\n"
312                      "Max Purges                     : ",
313                      vm_info_1.pal_vm_info_1_s.phys_add_size,
314                      vm_info_2.pal_vm_info_2_s.impl_va_msb+1,
315                      vm_info_1.pal_vm_info_1_s.max_pkr+1,
316                      vm_info_1.pal_vm_info_1_s.key_size,
317                      vm_info_1.pal_vm_info_1_s.hash_tag_id,
318                      vm_info_2.pal_vm_info_2_s.rid_size);
319                 if (vm_info_2.pal_vm_info_2_s.max_purges == PAL_MAX_PURGES)
320                         seq_puts(m, "unlimited\n");
321                 else
322                         seq_printf(m, "%d\n",
323                                 vm_info_2.pal_vm_info_2_s.max_purges ?
324                                 vm_info_2.pal_vm_info_2_s.max_purges : 1);
325         }
326
327         if (ia64_pal_mem_attrib(&attrib) == 0) {
328                 seq_puts(m, "Supported memory attributes    : ");
329                 sep = "";
330                 for (i = 0; i < 8; i++) {
331                         if (attrib & (1 << i)) {
332                                 seq_printf(m, "%s%s", sep, mem_attrib[i]);
333                                 sep = ", ";
334                         }
335                 }
336                 seq_putc(m, '\n');
337         }
338
339         if ((status = ia64_pal_vm_page_size(&tr_pages, &vw_pages)) !=0) {
340                 printk(KERN_ERR "ia64_pal_vm_page_size=%ld\n", status);
341         } else {
342
343                 seq_printf(m,
344                            "\nTLB walker                     : %simplemented\n"
345                            "Number of DTR                  : %d\n"
346                            "Number of ITR                  : %d\n"
347                            "TLB insertable page sizes      : ",
348                            vm_info_1.pal_vm_info_1_s.vw ? "" : "not ",
349                            vm_info_1.pal_vm_info_1_s.max_dtr_entry+1,
350                            vm_info_1.pal_vm_info_1_s.max_itr_entry+1);
351
352                 bitvector_process(m, tr_pages);
353
354                 seq_puts(m, "\nTLB purgeable page sizes       : ");
355
356                 bitvector_process(m, vw_pages);
357         }
358
359         if ((status = ia64_get_ptce(&ptce)) != 0) {
360                 printk(KERN_ERR "ia64_get_ptce=%ld\n", status);
361         } else {
362                 seq_printf(m,
363                      "\nPurge base address             : 0x%016lx\n"
364                      "Purge outer loop count         : %d\n"
365                      "Purge inner loop count         : %d\n"
366                      "Purge outer loop stride        : %d\n"
367                      "Purge inner loop stride        : %d\n",
368                      ptce.base, ptce.count[0], ptce.count[1],
369                      ptce.stride[0], ptce.stride[1]);
370
371                 seq_printf(m,
372                      "TC Levels                      : %d\n"
373                      "Unique TC(s)                   : %d\n",
374                      vm_info_1.pal_vm_info_1_s.num_tc_levels,
375                      vm_info_1.pal_vm_info_1_s.max_unique_tcs);
376
377                 for(i=0; i < vm_info_1.pal_vm_info_1_s.num_tc_levels; i++) {
378                         for (j=2; j>0 ; j--) {
379                                 tc_pages = 0; /* just in case */
380
381                                 /* even without unification, some levels may not be present */
382                                 if ((status=ia64_pal_vm_info(i,j, &tc_info, &tc_pages)) != 0)
383                                         continue;
384
385                                 seq_printf(m,
386                                      "\n%s Translation Cache Level %d:\n"
387                                      "\tHash sets           : %d\n"
388                                      "\tAssociativity       : %d\n"
389                                      "\tNumber of entries   : %d\n"
390                                      "\tFlags               : ",
391                                      cache_types[j+tc_info.tc_unified], i+1,
392                                      tc_info.tc_num_sets,
393                                      tc_info.tc_associativity,
394                                      tc_info.tc_num_entries);
395
396                                 if (tc_info.tc_pf)
397                                         seq_puts(m, "PreferredPageSizeOptimized ");
398                                 if (tc_info.tc_unified)
399                                         seq_puts(m, "Unified ");
400                                 if (tc_info.tc_reduce_tr)
401                                         seq_puts(m, "TCReduction");
402
403                                 seq_puts(m, "\n\tSupported page sizes: ");
404
405                                 bitvector_process(m, tc_pages);
406
407                                 /* when unified date (j=2) is enough */
408                                 if (tc_info.tc_unified)
409                                         break;
410                         }
411                 }
412         }
413
414         seq_putc(m, '\n');
415         return 0;
416 }
417
418
419 static int register_info(struct seq_file *m)
420 {
421         u64 reg_info[2];
422         u64 info;
423         unsigned long phys_stacked;
424         pal_hints_u_t hints;
425         unsigned long iregs, dregs;
426         static const char * const info_type[] = {
427                 "Implemented AR(s)",
428                 "AR(s) with read side-effects",
429                 "Implemented CR(s)",
430                 "CR(s) with read side-effects",
431         };
432
433         for(info=0; info < 4; info++) {
434                 if (ia64_pal_register_info(info, &reg_info[0], &reg_info[1]) != 0)
435                         return 0;
436                 seq_printf(m, "%-32s : ", info_type[info]);
437                 bitregister_process(m, reg_info, 128);
438                 seq_putc(m, '\n');
439         }
440
441         if (ia64_pal_rse_info(&phys_stacked, &hints) == 0)
442                 seq_printf(m,
443                            "RSE stacked physical registers   : %ld\n"
444                            "RSE load/store hints             : %ld (%s)\n",
445                            phys_stacked, hints.ph_data,
446                            hints.ph_data < RSE_HINTS_COUNT ? rse_hints[hints.ph_data]: "(??)");
447
448         if (ia64_pal_debug_info(&iregs, &dregs))
449                 return 0;
450
451         seq_printf(m,
452                    "Instruction debug register pairs : %ld\n"
453                    "Data debug register pairs        : %ld\n", iregs, dregs);
454
455         return 0;
456 }
457
458 static const char *const proc_features_0[]={            /* Feature set 0 */
459         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
460         NULL,NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,
461         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
462         NULL,NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,
463         "Unimplemented instruction address fault",
464         "INIT, PMI, and LINT pins",
465         "Simple unimplemented instr addresses",
466         "Variable P-state performance",
467         "Virtual machine features implemented",
468         "XIP,XPSR,XFS implemented",
469         "XR1-XR3 implemented",
470         "Disable dynamic predicate prediction",
471         "Disable processor physical number",
472         "Disable dynamic data cache prefetch",
473         "Disable dynamic inst cache prefetch",
474         "Disable dynamic branch prediction",
475         NULL, NULL, NULL, NULL,
476         "Disable P-states",
477         "Enable MCA on Data Poisoning",
478         "Enable vmsw instruction",
479         "Enable extern environmental notification",
480         "Disable BINIT on processor time-out",
481         "Disable dynamic power management (DPM)",
482         "Disable coherency",
483         "Disable cache",
484         "Enable CMCI promotion",
485         "Enable MCA to BINIT promotion",
486         "Enable MCA promotion",
487         "Enable BERR promotion"
488 };
489
490 static const char *const proc_features_16[]={           /* Feature set 16 */
491         "Disable ETM",
492         "Enable ETM",
493         "Enable MCA on half-way timer",
494         "Enable snoop WC",
495         NULL,
496         "Enable Fast Deferral",
497         "Disable MCA on memory aliasing",
498         "Enable RSB",
499         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
500         "DP system processor",
501         "Low Voltage",
502         "HT supported",
503         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
504         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
505         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
506         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
507         NULL, NULL, NULL, NULL, NULL
508 };
509
510 static const char *const *const proc_features[]={
511         proc_features_0,
512         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
513         NULL, NULL, NULL, NULL,
514         proc_features_16,
515         NULL, NULL, NULL, NULL,
516 };
517
518 static void feature_set_info(struct seq_file *m, u64 avail, u64 status, u64 control,
519                              unsigned long set)
520 {
521         const char *const *vf, *const *v;
522         int i;
523
524         vf = v = proc_features[set];
525         for(i=0; i < 64; i++, avail >>=1, status >>=1, control >>=1) {
526
527                 if (!(control))         /* No remaining bits set */
528                         break;
529                 if (!(avail & 0x1))     /* Print only bits that are available */
530                         continue;
531                 if (vf)
532                         v = vf + i;
533                 if ( v && *v ) {
534                         seq_printf(m, "%-40s : %s %s\n", *v,
535                                 avail & 0x1 ? (status & 0x1 ?
536                                               "On " : "Off"): "",
537                                 avail & 0x1 ? (control & 0x1 ?
538                                                 "Ctrl" : "NoCtrl"): "");
539                 } else {
540                         seq_printf(m, "Feature set %2ld bit %2d\t\t\t"
541                                         " : %s %s\n",
542                                 set, i,
543                                 avail & 0x1 ? (status & 0x1 ?
544                                                 "On " : "Off"): "",
545                                 avail & 0x1 ? (control & 0x1 ?
546                                                 "Ctrl" : "NoCtrl"): "");
547                 }
548         }
549 }
550
551 static int processor_info(struct seq_file *m)
552 {
553         u64 avail=1, status=1, control=1, feature_set=0;
554         s64 ret;
555
556         do {
557                 ret = ia64_pal_proc_get_features(&avail, &status, &control,
558                                                 feature_set);
559                 if (ret < 0)
560                         return 0;
561
562                 if (ret == 1) {
563                         feature_set++;
564                         continue;
565                 }
566
567                 feature_set_info(m, avail, status, control, feature_set);
568                 feature_set++;
569         } while(1);
570
571         return 0;
572 }
573
574 static const char *const bus_features[]={
575         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
576         NULL,NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,
577         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
578         NULL,NULL,
579         "Request  Bus Parking",
580         "Bus Lock Mask",
581         "Enable Half Transfer",
582         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
583         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
584         NULL, NULL, NULL, NULL,
585         "Enable Cache Line Repl. Shared",
586         "Enable Cache Line Repl. Exclusive",
587         "Disable Transaction Queuing",
588         "Disable Response Error Checking",
589         "Disable Bus Error Checking",
590         "Disable Bus Requester Internal Error Signalling",
591         "Disable Bus Requester Error Signalling",
592         "Disable Bus Initialization Event Checking",
593         "Disable Bus Initialization Event Signalling",
594         "Disable Bus Address Error Checking",
595         "Disable Bus Address Error Signalling",
596         "Disable Bus Data Error Checking"
597 };
598
599
600 static int bus_info(struct seq_file *m)
601 {
602         const char *const *v = bus_features;
603         pal_bus_features_u_t av, st, ct;
604         u64 avail, status, control;
605         int i;
606         s64 ret;
607
608         if ((ret=ia64_pal_bus_get_features(&av, &st, &ct)) != 0)
609                 return 0;
610
611         avail   = av.pal_bus_features_val;
612         status  = st.pal_bus_features_val;
613         control = ct.pal_bus_features_val;
614
615         for(i=0; i < 64; i++, v++, avail >>=1, status >>=1, control >>=1) {
616                 if ( ! *v )
617                         continue;
618                 seq_printf(m, "%-48s : %s%s %s\n", *v,
619                            avail & 0x1 ? "" : "NotImpl",
620                            avail & 0x1 ? (status  & 0x1 ? "On" : "Off"): "",
621                            avail & 0x1 ? (control & 0x1 ? "Ctrl" : "NoCtrl"): "");
622         }
623         return 0;
624 }
625
626 static int version_info(struct seq_file *m)
627 {
628         pal_version_u_t min_ver, cur_ver;
629
630         if (ia64_pal_version(&min_ver, &cur_ver) != 0)
631                 return 0;
632
633         seq_printf(m,
634                    "PAL_vendor : 0x%02x (min=0x%02x)\n"
635                    "PAL_A      : %02x.%02x (min=%02x.%02x)\n"
636                    "PAL_B      : %02x.%02x (min=%02x.%02x)\n",
637                    cur_ver.pal_version_s.pv_pal_vendor,
638                    min_ver.pal_version_s.pv_pal_vendor,
639                    cur_ver.pal_version_s.pv_pal_a_model,
640                    cur_ver.pal_version_s.pv_pal_a_rev,
641                    min_ver.pal_version_s.pv_pal_a_model,
642                    min_ver.pal_version_s.pv_pal_a_rev,
643                    cur_ver.pal_version_s.pv_pal_b_model,
644                    cur_ver.pal_version_s.pv_pal_b_rev,
645                    min_ver.pal_version_s.pv_pal_b_model,
646                    min_ver.pal_version_s.pv_pal_b_rev);
647         return 0;
648 }
649
650 static int perfmon_info(struct seq_file *m)
651 {
652         u64 pm_buffer[16];
653         pal_perf_mon_info_u_t pm_info;
654
655         if (ia64_pal_perf_mon_info(pm_buffer, &pm_info) != 0)
656                 return 0;
657
658         seq_printf(m,
659                    "PMC/PMD pairs                 : %d\n"
660                    "Counter width                 : %d bits\n"
661                    "Cycle event number            : %d\n"
662                    "Retired event number          : %d\n"
663                    "Implemented PMC               : ",
664                    pm_info.pal_perf_mon_info_s.generic,
665                    pm_info.pal_perf_mon_info_s.width,
666                    pm_info.pal_perf_mon_info_s.cycles,
667                    pm_info.pal_perf_mon_info_s.retired);
668
669         bitregister_process(m, pm_buffer, 256);
670         seq_puts(m, "\nImplemented PMD               : ");
671         bitregister_process(m, pm_buffer+4, 256);
672         seq_puts(m, "\nCycles count capable          : ");
673         bitregister_process(m, pm_buffer+8, 256);
674         seq_puts(m, "\nRetired bundles count capable : ");
675
676 #ifdef CONFIG_ITANIUM
677         /*
678          * PAL_PERF_MON_INFO reports that only PMC4 can be used to count CPU_CYCLES
679          * which is wrong, both PMC4 and PMD5 support it.
680          */
681         if (pm_buffer[12] == 0x10)
682                 pm_buffer[12]=0x30;
683 #endif
684
685         bitregister_process(m, pm_buffer+12, 256);
686         seq_putc(m, '\n');
687         return 0;
688 }
689
690 static int frequency_info(struct seq_file *m)
691 {
692         struct pal_freq_ratio proc, itc, bus;
693         unsigned long base;
694
695         if (ia64_pal_freq_base(&base) == -1)
696                 seq_puts(m, "Output clock            : not implemented\n");
697         else
698                 seq_printf(m, "Output clock            : %ld ticks/s\n", base);
699
700         if (ia64_pal_freq_ratios(&proc, &bus, &itc) != 0) return 0;
701
702         seq_printf(m,
703                      "Processor/Clock ratio   : %d/%d\n"
704                      "Bus/Clock ratio         : %d/%d\n"
705                      "ITC/Clock ratio         : %d/%d\n",
706                      proc.num, proc.den, bus.num, bus.den, itc.num, itc.den);
707         return 0;
708 }
709
710 static int tr_info(struct seq_file *m)
711 {
712         long status;
713         pal_tr_valid_u_t tr_valid;
714         u64 tr_buffer[4];
715         pal_vm_info_1_u_t vm_info_1;
716         pal_vm_info_2_u_t vm_info_2;
717         unsigned long i, j;
718         unsigned long max[3], pgm;
719         struct ifa_reg {
720                 unsigned long valid:1;
721                 unsigned long ig:11;
722                 unsigned long vpn:52;
723         } *ifa_reg;
724         struct itir_reg {
725                 unsigned long rv1:2;
726                 unsigned long ps:6;
727                 unsigned long key:24;
728                 unsigned long rv2:32;
729         } *itir_reg;
730         struct gr_reg {
731                 unsigned long p:1;
732                 unsigned long rv1:1;
733                 unsigned long ma:3;
734                 unsigned long a:1;
735                 unsigned long d:1;
736                 unsigned long pl:2;
737                 unsigned long ar:3;
738                 unsigned long ppn:38;
739                 unsigned long rv2:2;
740                 unsigned long ed:1;
741                 unsigned long ig:11;
742         } *gr_reg;
743         struct rid_reg {
744                 unsigned long ig1:1;
745                 unsigned long rv1:1;
746                 unsigned long ig2:6;
747                 unsigned long rid:24;
748                 unsigned long rv2:32;
749         } *rid_reg;
750
751         if ((status = ia64_pal_vm_summary(&vm_info_1, &vm_info_2)) !=0) {
752                 printk(KERN_ERR "ia64_pal_vm_summary=%ld\n", status);
753                 return 0;
754         }
755         max[0] = vm_info_1.pal_vm_info_1_s.max_itr_entry+1;
756         max[1] = vm_info_1.pal_vm_info_1_s.max_dtr_entry+1;
757
758         for (i=0; i < 2; i++ ) {
759                 for (j=0; j < max[i]; j++) {
760
761                 status = ia64_pal_tr_read(j, i, tr_buffer, &tr_valid);
762                 if (status != 0) {
763                         printk(KERN_ERR "palinfo: pal call failed on tr[%lu:%lu]=%ld\n",
764                                i, j, status);
765                         continue;
766                 }
767
768                 ifa_reg  = (struct ifa_reg *)&tr_buffer[2];
769
770                 if (ifa_reg->valid == 0)
771                         continue;
772
773                 gr_reg   = (struct gr_reg *)tr_buffer;
774                 itir_reg = (struct itir_reg *)&tr_buffer[1];
775                 rid_reg  = (struct rid_reg *)&tr_buffer[3];
776
777                 pgm      = -1 << (itir_reg->ps - 12);
778                 seq_printf(m,
779                            "%cTR%lu: av=%d pv=%d dv=%d mv=%d\n"
780                            "\tppn  : 0x%lx\n"
781                            "\tvpn  : 0x%lx\n"
782                            "\tps   : ",
783                            "ID"[i], j,
784                            tr_valid.pal_tr_valid_s.access_rights_valid,
785                            tr_valid.pal_tr_valid_s.priv_level_valid,
786                            tr_valid.pal_tr_valid_s.dirty_bit_valid,
787                            tr_valid.pal_tr_valid_s.mem_attr_valid,
788                            (gr_reg->ppn & pgm)<< 12, (ifa_reg->vpn & pgm)<< 12);
789
790                 bitvector_process(m, 1<< itir_reg->ps);
791
792                 seq_printf(m,
793                            "\n\tpl   : %d\n"
794                            "\tar   : %d\n"
795                            "\trid  : %x\n"
796                            "\tp    : %d\n"
797                            "\tma   : %d\n"
798                            "\td    : %d\n",
799                            gr_reg->pl, gr_reg->ar, rid_reg->rid, gr_reg->p, gr_reg->ma,
800                            gr_reg->d);
801                 }
802         }
803         return 0;
804 }
805
806
807
808 /*
809  * List {name,function} pairs for every entry in /proc/palinfo/cpu*
810  */
811 static const palinfo_entry_t palinfo_entries[]={
812         { "version_info",       version_info, },
813         { "vm_info",            vm_info, },
814         { "cache_info",         cache_info, },
815         { "power_info",         power_info, },
816         { "register_info",      register_info, },
817         { "processor_info",     processor_info, },
818         { "perfmon_info",       perfmon_info, },
819         { "frequency_info",     frequency_info, },
820         { "bus_info",           bus_info },
821         { "tr_info",            tr_info, }
822 };
823
824 #define NR_PALINFO_ENTRIES      (int) ARRAY_SIZE(palinfo_entries)
825
826 static struct proc_dir_entry *palinfo_dir;
827
828 /*
829  * This data structure is used to pass which cpu,function is being requested
830  * It must fit in a 64bit quantity to be passed to the proc callback routine
831  *
832  * In SMP mode, when we get a request for another CPU, we must call that
833  * other CPU using IPI and wait for the result before returning.
834  */
835 typedef union {
836         u64 value;
837         struct {
838                 unsigned        req_cpu: 32;    /* for which CPU this info is */
839                 unsigned        func_id: 32;    /* which function is requested */
840         } pal_func_cpu;
841 } pal_func_cpu_u_t;
842
843 #define req_cpu pal_func_cpu.req_cpu
844 #define func_id pal_func_cpu.func_id
845
846 #ifdef CONFIG_SMP
847
848 /*
849  * used to hold information about final function to call
850  */
851 typedef struct {
852         palinfo_func_t  func;   /* pointer to function to call */
853         struct seq_file *m;     /* buffer to store results */
854         int             ret;    /* return value from call */
855 } palinfo_smp_data_t;
856
857
858 /*
859  * this function does the actual final call and he called
860  * from the smp code, i.e., this is the palinfo callback routine
861  */
862 static void
863 palinfo_smp_call(void *info)
864 {
865         palinfo_smp_data_t *data = (palinfo_smp_data_t *)info;
866         data->ret = (*data->func)(data->m);
867 }
868
869 /*
870  * function called to trigger the IPI, we need to access a remote CPU
871  * Return:
872  *      0 : error or nothing to output
873  *      otherwise how many bytes in the "page" buffer were written
874  */
875 static
876 int palinfo_handle_smp(struct seq_file *m, pal_func_cpu_u_t *f)
877 {
878         palinfo_smp_data_t ptr;
879         int ret;
880
881         ptr.func = palinfo_entries[f->func_id].proc_read;
882         ptr.m = m;
883         ptr.ret  = 0; /* just in case */
884
885
886         /* will send IPI to other CPU and wait for completion of remote call */
887         if ((ret=smp_call_function_single(f->req_cpu, palinfo_smp_call, &ptr, 1))) {
888                 printk(KERN_ERR "palinfo: remote CPU call from %d to %d on function %d: "
889                        "error %d\n", smp_processor_id(), f->req_cpu, f->func_id, ret);
890                 return 0;
891         }
892         return ptr.ret;
893 }
894 #else /* ! CONFIG_SMP */
895 static
896 int palinfo_handle_smp(struct seq_file *m, pal_func_cpu_u_t *f)
897 {
898         printk(KERN_ERR "palinfo: should not be called with non SMP kernel\n");
899         return 0;
900 }
901 #endif /* CONFIG_SMP */
902
903 /*
904  * Entry point routine: all calls go through this function
905  */
906 static int proc_palinfo_show(struct seq_file *m, void *v)
907 {
908         pal_func_cpu_u_t *f = (pal_func_cpu_u_t *)&m->private;
909
910         /*
911          * in SMP mode, we may need to call another CPU to get correct
912          * information. PAL, by definition, is processor specific
913          */
914         if (f->req_cpu == get_cpu())
915                 (*palinfo_entries[f->func_id].proc_read)(m);
916         else
917                 palinfo_handle_smp(m, f);
918
919         put_cpu();
920         return 0;
921 }
922
923 static int proc_palinfo_open(struct inode *inode, struct file *file)
924 {
925         return single_open(file, proc_palinfo_show, PDE_DATA(inode));
926 }
927
928 static const struct file_operations proc_palinfo_fops = {
929         .open           = proc_palinfo_open,
930         .read           = seq_read,
931         .llseek         = seq_lseek,
932         .release        = single_release,
933 };
934
935 static void
936 create_palinfo_proc_entries(unsigned int cpu)
937 {
938         pal_func_cpu_u_t f;
939         struct proc_dir_entry *cpu_dir;
940         int j;
941         char cpustr[3+4+1];     /* cpu numbers are up to 4095 on itanic */
942         sprintf(cpustr, "cpu%d", cpu);
943
944         cpu_dir = proc_mkdir(cpustr, palinfo_dir);
945         if (!cpu_dir)
946                 return;
947
948         f.req_cpu = cpu;
949
950         for (j=0; j < NR_PALINFO_ENTRIES; j++) {
951                 f.func_id = j;
952                 proc_create_data(palinfo_entries[j].name, 0, cpu_dir,
953                                  &proc_palinfo_fops, (void *)f.value);
954         }
955 }
956
957 static void
958 remove_palinfo_proc_entries(unsigned int hcpu)
959 {
960         char cpustr[3+4+1];     /* cpu numbers are up to 4095 on itanic */
961         sprintf(cpustr, "cpu%d", hcpu);
962         remove_proc_subtree(cpustr, palinfo_dir);
963 }
964
965 static int palinfo_cpu_callback(struct notifier_block *nfb,
966                                         unsigned long action, void *hcpu)
967 {
968         unsigned int hotcpu = (unsigned long)hcpu;
969
970         switch (action) {
971         case CPU_ONLINE:
972         case CPU_ONLINE_FROZEN:
973                 create_palinfo_proc_entries(hotcpu);
974                 break;
975         case CPU_DEAD:
976         case CPU_DEAD_FROZEN:
977                 remove_palinfo_proc_entries(hotcpu);
978                 break;
979         }
980         return NOTIFY_OK;
981 }
982
983 static struct notifier_block __refdata palinfo_cpu_notifier =
984 {
985         .notifier_call = palinfo_cpu_callback,
986         .priority = 0,
987 };
988
989 static int __init
990 palinfo_init(void)
991 {
992         int i = 0;
993
994         printk(KERN_INFO "PAL Information Facility v%s\n", PALINFO_VERSION);
995         palinfo_dir = proc_mkdir("pal", NULL);
996         if (!palinfo_dir)
997                 return -ENOMEM;
998
999         cpu_notifier_register_begin();
1000
1001         /* Create palinfo dirs in /proc for all online cpus */
1002         for_each_online_cpu(i) {
1003                 create_palinfo_proc_entries(i);
1004         }
1005
1006         /* Register for future delivery via notify registration */
1007         __register_hotcpu_notifier(&palinfo_cpu_notifier);
1008
1009         cpu_notifier_register_done();
1010
1011         return 0;
1012 }
1013
1014 static void __exit
1015 palinfo_exit(void)
1016 {
1017         unregister_hotcpu_notifier(&palinfo_cpu_notifier);
1018         remove_proc_subtree("pal", NULL);
1019 }
1020
1021 module_init(palinfo_init);
1022 module_exit(palinfo_exit);