开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
palinfo.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：24k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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 Hewlett-Packard Co
  10.  * Stephane Eranian <eranian@hpl.hp.com>
  11.  *
  12.  * 05/26/2000 S.Eranian initial release
  13.  * 08/21/2000 S.Eranian updated to July 2000 PAL specs
  14.  * 02/05/2001   S.Eranian fixed module support
  15.  * 10/23/2001 S.Eranian updated pal_perf_mon_info bug fixes
  16.  */
  17. #include <linux/config.h>
  18. #include <linux/types.h>
  19. #include <linux/errno.h>
  20. #include <linux/init.h>
  21. #include <linux/proc_fs.h>
  22. #include <linux/mm.h>
  23. #include <linux/module.h>
  24. #include <linux/efi.h>
  26. #include <asm/pal.h>
  27. #include <asm/sal.h>
  28. #include <asm/page.h>
  29. #include <asm/processor.h>
  30. #ifdef CONFIG_SMP
  31. #include <linux/smp.h>
  32. #endif
  34. MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
  35. MODULE_DESCRIPTION("/proc interface to IA-64 PAL");
  36. MODULE_LICENSE("GPL");
  38. #define PALINFO_VERSION "0.5"
  40. #ifdef CONFIG_SMP
  41. #define cpu_is_online(i) (cpu_online_map & (1UL << i))
  42. #else
  43. #define cpu_is_online(i) 1
  44. #endif
  46. typedef int (*palinfo_func_t)(char*);
  48. typedef struct {
  49. const char *name; /* name of the proc entry */
  50. palinfo_func_t proc_read; /* function to call for reading */
  51. struct proc_dir_entry *entry; /* registered entry (removal) */
  52. } palinfo_entry_t;
  55. /*
  56.  *  A bunch of string array to get pretty printing
  57.  */
  59. static char *cache_types[] = {
  60. "", /* not used */
  61. "Instruction",
  62. "Data",
  63. "Data/Instruction" /* unified */
  64. };
  66. static const char *cache_mattrib[]={
  67. "WriteThrough",
  68. "WriteBack",
  69. "", /* reserved */
  70. "" /* reserved */
  71. };
  73. static const char *cache_st_hints[]={
  74. "Temporal, level 1",
  75. "Reserved",
  76. "Reserved",
  77. "Non-temporal, all levels",
  78. "Reserved",
  79. "Reserved",
  80. "Reserved",
  81. "Reserved"
  82. };
  84. static const char *cache_ld_hints[]={
  85. "Temporal, level 1",
  86. "Non-temporal, level 1",
  87. "Reserved",
  88. "Non-temporal, all levels",
  89. "Reserved",
  90. "Reserved",
  91. "Reserved",
  92. "Reserved"
  93. };
  95. static const char *rse_hints[]={
  96. "enforced lazy",
  97. "eager stores",
  98. "eager loads",
  99. "eager loads and stores"
  100. };
  102. #define RSE_HINTS_COUNT (sizeof(rse_hints)/sizeof(const char *))
  104. /*
  105.  * The current revision of the Volume 2 (July 2000) of
  106.  * IA-64 Architecture Software Developer's Manual is wrong.
  107.  * Table 4-10 has invalid information concerning the ma field:
  108.  * Correct table is:
  109.  *      bit 0 - 001 - UC
  110.  *      bit 4 - 100 - UC
  111.  *      bit 5 - 101 - UCE
  112.  *      bit 6 - 110 - WC
  113.  *      bit 7 - 111 - NatPage
  114.  */
  115. static const char *mem_attrib[]={
  116. "Write Back (WB)", /* 000 */
  117. "Uncacheable (UC)", /* 001 */
  118. "Reserved", /* 010 */
  119. "Reserved", /* 011 */
  120. "Uncacheable (UC)", /* 100 */
  121. "Uncacheable Exported (UCE)", /* 101 */
  122. "Write Coalescing (WC)", /* 110 */
  123. "NaTPage" /* 111 */
  124. };
  126. /*
  127.  * Take a 64bit vector and produces a string such that
  128.  * if bit n is set then 2^n in clear text is generated. The adjustment
  129.  * to the right unit is also done.
  130.  *
  131.  * Input:
  132.  * - a pointer to a buffer to hold the string
  133.  * - a 64-bit vector
  134.  * Ouput:
  135.  * - a pointer to the end of the buffer
  136.  *
  137.  */
  138. static char *
  139. bitvector_process(char *p, u64 vector)
  140. {
  141. int i,j;
  142. const char *units[]={ "", "K", "M", "G", "T" };
  144. for (i=0, j=0; i < 64; i++ , j=i/10) {
  145. if (vector & 0x1) {
  146. p += sprintf(p, "%d%s ", 1 << (i-j*10), units[j]);
  147. }
  148. vector >>= 1;
  149. }
  150. return p;
  151. }
  153. /*
  154.  * Take a 64bit vector and produces a string such that
  155.  * if bit n is set then register n is present. The function
  156.  * takes into account consecutive registers and prints out ranges.
  157.  *
  158.  * Input:
  159.  * - a pointer to a buffer to hold the string
  160.  * - a 64-bit vector
  161.  * Ouput:
  162.  * - a pointer to the end of the buffer
  163.  *
  164.  */
  165. static char *
  166. bitregister_process(char *p, u64 *reg_info, int max)
  167. {
  168. int i, begin, skip = 0;
  169. u64 value = reg_info[0];
  171. value >>= i = begin = ffs(value) - 1;
  173. for(; i < max; i++ ) {
  175. if (i != 0 && (i%64) == 0) value = *++reg_info;
  177. if ((value & 0x1) == 0 && skip == 0) {
  178. if (begin  <= i - 2)
  179. p += sprintf(p, "%d-%d ", begin, i-1);
  180. else
  181. p += sprintf(p, "%d ", i-1);
  182. skip  = 1;
  183. begin = -1;
  184. } else if ((value & 0x1) && skip == 1) {
  185. skip = 0;
  186. begin = i;
  187. }
  188. value >>=1;
  189. }
  190. if (begin > -1) {
  191. if (begin < 127)
  192. p += sprintf(p, "%d-127", begin);
  193. else
  194. p += sprintf(p, "127");
  195. }
  197. return p;
  198. }
  200. static int
  201. power_info(char *page)
  202. {
  203. s64 status;
  204. char *p = page;
  205. u64 halt_info_buffer[8];
  206. pal_power_mgmt_info_u_t *halt_info =(pal_power_mgmt_info_u_t *)halt_info_buffer;
  207. int i;
  209. status = ia64_pal_halt_info(halt_info);
  210. if (status != 0) return 0;
  212. for (i=0; i < 8 ; i++ ) {
  213. if (halt_info[i].pal_power_mgmt_info_s.im == 1) {
  214. p += sprintf(p, "Power level %d:n" 
  215. "tentry_latency       : %d cyclesn" 
  216. "texit_latency        : %d cyclesn" 
  217. "tpower consumption   : %d mWn" 
  218. "tCache+TLB coherency : %sn", i,
  219. halt_info[i].pal_power_mgmt_info_s.entry_latency,
  220. halt_info[i].pal_power_mgmt_info_s.exit_latency,
  221. halt_info[i].pal_power_mgmt_info_s.power_consumption,
  222. halt_info[i].pal_power_mgmt_info_s.co ? "Yes" : "No");
  223. } else {
  224. p += sprintf(p,"Power level %d: not implementedn",i);
  225. }
  226. }
  227. return p - page;
  228. }
  230. static int
  231. cache_info(char *page)
  232. {
  233. char *p = page;
  234. u64 levels, unique_caches;
  235. pal_cache_config_info_t cci;
  236. int i,j, k;
  237. s64 status;
  239. if ((status=ia64_pal_cache_summary(&levels, &unique_caches)) != 0) {
  240. printk("ia64_pal_cache_summary=%ldn", status);
  241. return 0;
  242. }
  244. p += sprintf(p, "Cache levels  : %ldn" 
  245. "Unique caches : %ldnn",
  246. levels,
  247. unique_caches);
  249. for (i=0; i < levels; i++) {
  251. for (j=2; j >0 ; j--) {
  253. /* even without unification some level may not be present */
  254. if ((status=ia64_pal_cache_config_info(i,j, &cci)) != 0) {
  255. continue;
  256. }
  257. p += sprintf(p, "%s Cache level %d:n" 
  258. "tSize           : %ld bytesn" 
  259. "tAttributes     : ",
  260. cache_types[j+cci.pcci_unified], i+1,
  261. cci.pcci_cache_size);
  263. if (cci.pcci_unified) p += sprintf(p, "Unified ");
  265. p += sprintf(p, "%sn", cache_mattrib[cci.pcci_cache_attr]);
  267. p += sprintf(p, "tAssociativity  : %dn" 
  268. "tLine size      : %d bytesn" 
  269. "tStride         : %d bytesn",
  270. cci.pcci_assoc,
  271. 1<<cci.pcci_line_size,
  272. 1<<cci.pcci_stride);
  273. if (j == 1)
  274. p += sprintf(p, "tStore latency  : N/An");
  275. else
  276. p += sprintf(p, "tStore latency  : %d cycle(s)n",
  277. cci.pcci_st_latency);
  279. p += sprintf(p, "tLoad latency   : %d cycle(s)n" 
  280. "tStore hints    : ",
  281. cci.pcci_ld_latency);
  283. for(k=0; k < 8; k++ ) {
  284. if ( cci.pcci_st_hints & 0x1) p += sprintf(p, "[%s]", cache_st_hints[k]);
  285. cci.pcci_st_hints >>=1;
  286. }
  287. p += sprintf(p, "ntLoad hints     : ");
  289. for(k=0; k < 8; k++ ) {
  290. if ( cci.pcci_ld_hints & 0x1) p += sprintf(p, "[%s]", cache_ld_hints[k]);
  291. cci.pcci_ld_hints >>=1;
  292. }
  293. p += sprintf(p, "ntAlias boundary : %d byte(s)n" 
  294. "tTag LSB        : %dn" 
  295. "tTag MSB        : %dn",
  296. 1<<cci.pcci_alias_boundary,
  297. cci.pcci_tag_lsb,
  298. cci.pcci_tag_msb);
  300. /* when unified, data(j=2) is enough */
  301. if (cci.pcci_unified) break;
  302. }
  303. }
  304. return p - page;
  305. }
  308. static int
  309. vm_info(char *page)
  310. {
  311. char *p = page;
  312. u64 tr_pages =0, vw_pages=0, tc_pages;
  313. u64 attrib;
  314. pal_vm_info_1_u_t vm_info_1;
  315. pal_vm_info_2_u_t vm_info_2;
  316. pal_tc_info_u_t tc_info;
  317. ia64_ptce_info_t ptce;
  318. int i, j;
  319. s64 status;
  321. if ((status=ia64_pal_vm_summary(&vm_info_1, &vm_info_2)) !=0) {
  322. printk("ia64_pal_vm_summary=%ldn", status);
  323. return 0;
  324. }
  327. p += sprintf(p, "Physical Address Space         : %d bitsn" 
  328. "Virtual Address Space          : %d bitsn" 
  329. "Protection Key Registers(PKR)  : %dn" 
  330. "Implemented bits in PKR.key    : %dn" 
  331. "Hash Tag ID                    : 0x%xn" 
  332. "Size of RR.rid                 : %dn",
  333. vm_info_1.pal_vm_info_1_s.phys_add_size,
  334. vm_info_2.pal_vm_info_2_s.impl_va_msb+1,
  335. vm_info_1.pal_vm_info_1_s.max_pkr+1,
  336. vm_info_1.pal_vm_info_1_s.key_size,
  337. vm_info_1.pal_vm_info_1_s.hash_tag_id,
  338. vm_info_2.pal_vm_info_2_s.rid_size);
  340. if (ia64_pal_mem_attrib(&attrib) != 0) return 0;
  342. p += sprintf(p, "Supported memory attributes    : %sn", mem_attrib[attrib&0x7]);
  344. if ((status=ia64_pal_vm_page_size(&tr_pages, &vw_pages)) !=0) {
  345. printk("ia64_pal_vm_page_size=%ldn", status);
  346. return 0;
  347. }
  349. p += sprintf(p, "nTLB walker                     : %s implementedn" 
  350. "Number of DTR                  : %dn" 
  351. "Number of ITR                  : %dn" 
  352. "TLB insertable page sizes      : ",
  353. vm_info_1.pal_vm_info_1_s.vw ? "b":"not",
  354. vm_info_1.pal_vm_info_1_s.max_dtr_entry+1,
  355. vm_info_1.pal_vm_info_1_s.max_itr_entry+1);
  358. p = bitvector_process(p, tr_pages);
  360. p += sprintf(p, "nTLB purgeable page sizes       : ");
  362. p = bitvector_process(p, vw_pages);
  364. if ((status=ia64_get_ptce(&ptce)) != 0) {
  365. printk("ia64_get_ptce=%ldn",status);
  366. return 0;
  367. }
  369. p += sprintf(p, "nPurge base address             : 0x%016lxn" 
  370. "Purge outer loop count         : %dn" 
  371. "Purge inner loop count         : %dn" 
  372. "Purge outer loop stride        : %dn" 
  373. "Purge inner loop stride        : %dn",
  374. ptce.base,
  375. ptce.count[0],
  376. ptce.count[1],
  377. ptce.stride[0],
  378. ptce.stride[1]);
  380. p += sprintf(p, "TC Levels                      : %dn" 
  381. "Unique TC(s)                   : %dn",
  382. vm_info_1.pal_vm_info_1_s.num_tc_levels,
  383. vm_info_1.pal_vm_info_1_s.max_unique_tcs);
  385. for(i=0; i < vm_info_1.pal_vm_info_1_s.num_tc_levels; i++) {
  386. for (j=2; j>0 ; j--) {
  387. tc_pages = 0; /* just in case */
  390. /* even without unification, some levels may not be present */
  391. if ((status=ia64_pal_vm_info(i,j, &tc_info, &tc_pages)) != 0) {
  392. continue;
  393. }
  395. p += sprintf(p, "n%s Translation Cache Level %d:n" 
  396. "tHash sets           : %dn" 
  397. "tAssociativity       : %dn" 
  398. "tNumber of entries   : %dn" 
  399. "tFlags               : ",
  400. cache_types[j+tc_info.tc_unified], i+1,
  401. tc_info.tc_num_sets,
  402. tc_info.tc_associativity,
  403. tc_info.tc_num_entries);
  405. if (tc_info.tc_pf) p += sprintf(p, "PreferredPageSizeOptimized ");
  406. if (tc_info.tc_unified) p += sprintf(p, "Unified ");
  407. if (tc_info.tc_reduce_tr) p += sprintf(p, "TCReduction");
  409. p += sprintf(p, "ntSupported page sizes: ");
  411. p = bitvector_process(p, tc_pages);
  413. /* when unified date (j=2) is enough */
  414. if (tc_info.tc_unified) break;
  415. }
  416. }
  417. p += sprintf(p, "n");
  419. return p - page;
  420. }
  423. static int
  424. register_info(char *page)
  425. {
  426. char *p = page;
  427. u64 reg_info[2];
  428. u64 info;
  429. u64 phys_stacked;
  430. pal_hints_u_t hints;
  431. u64 iregs, dregs;
  432. char *info_type[]={
  433. "Implemented AR(s)",
  434. "AR(s) with read side-effects",
  435. "Implemented CR(s)",
  436. "CR(s) with read side-effects",
  437. };
  439. for(info=0; info < 4; info++) {
  441. if (ia64_pal_register_info(info, &reg_info[0], &reg_info[1]) != 0) return 0;
  443. p += sprintf(p, "%-32s : ", info_type[info]);
  445. p = bitregister_process(p, reg_info, 128);
  447. p += sprintf(p, "n");
  448. }
  450. if (ia64_pal_rse_info(&phys_stacked, &hints) != 0) return 0;
  452. p += sprintf(p, "RSE stacked physical registers   : %ldn" 
  453. "RSE load/store hints             : %ld (%s)n",
  454. phys_stacked,
  455. hints.ph_data,
  456. hints.ph_data < RSE_HINTS_COUNT ? rse_hints[hints.ph_data]: "(??)");
  458. if (ia64_pal_debug_info(&iregs, &dregs)) return 0;
  460. p += sprintf(p, "Instruction debug register pairs : %ldn" 
  461. "Data debug register pairs        : %ldn",
  462. iregs, dregs);
  464. return p - page;
  465. }
  467. static const char *proc_features[]={
  468. NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
  469. NULL,NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,
  470. NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
  471. NULL,NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,
  472. NULL,NULL,NULL,NULL,NULL,
  473. "XIP,XPSR,XFS implemented",
  474. "XR1-XR3 implemented",
  475. "Disable dynamic predicate prediction",
  476. "Disable processor physical number",
  477. "Disable dynamic data cache prefetch",
  478. "Disable dynamic inst cache prefetch",
  479. "Disable dynamic branch prediction",
  480. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  481. "Disable BINIT on processor time-out",
  482. "Disable dynamic power management (DPM)",
  483. "Disable coherency",
  484. "Disable cache",
  485. "Enable CMCI promotion",
  486. "Enable MCA to BINIT promotion",
  487. "Enable MCA promotion",
  488. "Enable BEER promotion"
  489. };
  492. static int
  493. processor_info(char *page)
  494. {
  495. char *p = page;
  496. const char **v = proc_features;
  497. u64 avail=1, status=1, control=1;
  498. int i;
  499. s64 ret;
  501. if ((ret=ia64_pal_proc_get_features(&avail, &status, &control)) != 0) return 0;
  503. for(i=0; i < 64; i++, v++,avail >>=1, status >>=1, control >>=1) {
  504. if ( ! *v ) continue;
  505. p += sprintf(p, "%-40s : %s%s %sn", *v,
  506. avail & 0x1 ? "" : "NotImpl",
  507. avail & 0x1 ? (status & 0x1 ? "On" : "Off"): "",
  508. avail & 0x1 ? (control & 0x1 ? "Ctrl" : "NoCtrl"): "");
  509. }
  510. return p - page;
  511. }
  513. static const char *bus_features[]={
  514. NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
  515. NULL,NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,
  516. NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
  517. NULL,NULL,
  518. "Request  Bus Parking",
  519. "Bus Lock Mask",
  520. "Enable Half Transfer",
  521. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  522. NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  523. NULL, NULL, NULL, NULL,
  524. "Enable Cache Line Repl. Exclusive",
  525. "Enable Cache Line Repl. Shared",
  526. "Disable Transaction Queuing",
  527. "Disable Reponse Error Checking",
  528. "Disable Bus Error Checking",
  529. "Disable Bus Requester Internal Error Signalling",
  530. "Disable Bus Requester Error Signalling",
  531. "Disable Bus Initialization Event Checking",
  532. "Disable Bus Initialization Event Signalling",
  533. "Disable Bus Address Error Checking",
  534. "Disable Bus Address Error Signalling",
  535. "Disable Bus Data Error Checking"
  536. };
  539. static int
  540. bus_info(char *page)
  541. {
  542. char *p = page;
  543. const char **v = bus_features;
  544. pal_bus_features_u_t av, st, ct;
  545. u64 avail, status, control;
  546. int i;
  547. s64 ret;
  549. if ((ret=ia64_pal_bus_get_features(&av, &st, &ct)) != 0) return 0;
  551. avail   = av.pal_bus_features_val;
  552. status  = st.pal_bus_features_val;
  553. control = ct.pal_bus_features_val;
  555. for(i=0; i < 64; i++, v++, avail >>=1, status >>=1, control >>=1) {
  556. if ( ! *v ) continue;
  557. p += sprintf(p, "%-48s : %s%s %sn", *v,
  558. avail & 0x1 ? "" : "NotImpl",
  559. avail & 0x1 ? (status  & 0x1 ? "On" : "Off"): "",
  560. avail & 0x1 ? (control & 0x1 ? "Ctrl" : "NoCtrl"): "");
  561. }
  562. return p - page;
  563. }
  565. static int
  566. version_info(char *page)
  567. {
  568. pal_version_u_t min_ver, cur_ver;
  569. char *p = page;
  571. /* The PAL_VERSION call is advertised as being able to support
  572.  * both physical and virtual mode calls. This seems to be a documentation
  573.  * bug rather than firmware bug. In fact, it does only support physical mode.
  574.  * So now the code reflects this fact and the pal_version() has been updated
  575.  * accordingly.
  576.  */
  577. if (ia64_pal_version(&min_ver, &cur_ver) != 0) return 0;
  579. p += sprintf(p, "PAL_vendor : 0x%02x (min=0x%02x)n" 
  580. "PAL_A      : %x.%x.%x (min=%x.%x.%x)n" 
  581. "PAL_B      : %x.%x.%x (min=%x.%x.%x)n",
  582. cur_ver.pal_version_s.pv_pal_vendor,
  583. min_ver.pal_version_s.pv_pal_vendor,
  585. cur_ver.pal_version_s.pv_pal_a_model>>4,
  586. cur_ver.pal_version_s.pv_pal_a_model&0xf,
  587. cur_ver.pal_version_s.pv_pal_a_rev,
  588. min_ver.pal_version_s.pv_pal_a_model>>4,
  589. min_ver.pal_version_s.pv_pal_a_model&0xf,
  590. min_ver.pal_version_s.pv_pal_a_rev,
  592. cur_ver.pal_version_s.pv_pal_b_model>>4,
  593. cur_ver.pal_version_s.pv_pal_b_model&0xf,
  594. cur_ver.pal_version_s.pv_pal_b_rev,
  595. min_ver.pal_version_s.pv_pal_b_model>>4,
  596. min_ver.pal_version_s.pv_pal_b_model&0xf,
  597. min_ver.pal_version_s.pv_pal_b_rev);
  599. return p - page;
  600. }
  602. static int
  603. perfmon_info(char *page)
  604. {
  605. char *p = page;
  606. u64 pm_buffer[16];
  607. pal_perf_mon_info_u_t pm_info;
  609. if (ia64_pal_perf_mon_info(pm_buffer, &pm_info) != 0) return 0;
  611. p += sprintf(p, "PMC/PMD pairs                 : %dn" 
  612. "Counter width                 : %d bitsn" 
  613. "Cycle event number            : %dn" 
  614. "Retired event number          : %dn" 
  615. "Implemented PMC               : ",
  616. pm_info.pal_perf_mon_info_s.generic,
  617. pm_info.pal_perf_mon_info_s.width,
  618. pm_info.pal_perf_mon_info_s.cycles,
  619. pm_info.pal_perf_mon_info_s.retired);
  621. p = bitregister_process(p, pm_buffer, 256);
  623. p += sprintf(p, "nImplemented PMD               : ");
  625. p = bitregister_process(p, pm_buffer+4, 256);
  627. p += sprintf(p, "nCycles count capable          : ");
  629. p = bitregister_process(p, pm_buffer+8, 256);
  631. p += sprintf(p, "nRetired bundles count capable : ");
  633. #ifdef CONFIG_ITANIUM
  634. /*
  635.  * PAL_PERF_MON_INFO reports that only PMC4 can be used to count CPU_CYCLES
  636.  * which is wrong, both PMC4 and PMD5 support it.
  637.  */
  638. if (pm_buffer[12] == 0x10) pm_buffer[12]=0x30;
  639. #endif
  641. p = bitregister_process(p, pm_buffer+12, 256);
  643. p += sprintf(p, "n");
  645. return p - page;
  646. }
  648. static int
  649. frequency_info(char *page)
  650. {
  651. char *p = page;
  652. struct pal_freq_ratio proc, itc, bus;
  653. u64 base;
  655. if (ia64_pal_freq_base(&base) == -1)
  656. p += sprintf(p, "Output clock            : not implementedn");
  657. else
  658. p += sprintf(p, "Output clock            : %ld ticks/sn", base);
  660. if (ia64_pal_freq_ratios(&proc, &bus, &itc) != 0) return 0;
  662. p += sprintf(p, "Processor/Clock ratio   : %ld/%ldn" 
  663. "Bus/Clock ratio         : %ld/%ldn" 
  664. "ITC/Clock ratio         : %ld/%ldn",
  665. proc.num, proc.den,
  666. bus.num, bus.den,
  667. itc.num, itc.den);
  669. return p - page;
  670. }
  672. static int
  673. tr_info(char *page)
  674. {
  675. char *p = page;
  676. s64 status;
  677. pal_tr_valid_u_t tr_valid;
  678. u64 tr_buffer[4];
  679. pal_vm_info_1_u_t vm_info_1;
  680. pal_vm_info_2_u_t vm_info_2;
  681. int i, j;
  682. u64 max[3], pgm;
  683. struct ifa_reg {
  684. u64 valid:1;
  685. u64 ig:11;
  686. u64 vpn:52;
  687. } *ifa_reg;
  688. struct itir_reg {
  689. u64 rv1:2;
  690. u64 ps:6;
  691. u64 key:24;
  692. u64 rv2:32;
  693. } *itir_reg;
  694. struct gr_reg {
  695. u64 p:1;
  696. u64 rv1:1;
  697. u64 ma:3;
  698. u64 a:1;
  699. u64 d:1;
  700. u64 pl:2;
  701. u64 ar:3;
  702. u64 ppn:38;
  703. u64 rv2:2;
  704. u64 ed:1;
  705. u64 ig:11;
  706. } *gr_reg;
  707. struct rid_reg {
  708. u64 ig1:1;
  709. u64 rv1:1;
  710. u64 ig2:6;
  711. u64 rid:24;
  712. u64 rv2:32;
  713. } *rid_reg;
  715. if ((status=ia64_pal_vm_summary(&vm_info_1, &vm_info_2)) !=0) {
  716. printk("ia64_pal_vm_summary=%ldn", status);
  717. return 0;
  718. }
  719. max[0] = vm_info_1.pal_vm_info_1_s.max_itr_entry+1;
  720. max[1] = vm_info_1.pal_vm_info_1_s.max_dtr_entry+1;
  722. for (i=0; i < 2; i++ ) {
  723. for (j=0; j < max[i]; j++) {
  725. status = ia64_pal_tr_read(j, i, tr_buffer, &tr_valid);
  726. if (status != 0) {
  727. printk("palinfo: pal call failed on tr[%d:%d]=%ldn", i, j, status);
  728. continue;
  729. }
  731. ifa_reg  = (struct ifa_reg *)&tr_buffer[2];
  733. if (ifa_reg->valid == 0) continue;
  735. gr_reg   = (struct gr_reg *)tr_buffer;
  736. itir_reg = (struct itir_reg *)&tr_buffer[1];
  737. rid_reg  = (struct rid_reg *)&tr_buffer[3];
  739. pgm  = -1 << (itir_reg->ps - 12);
  740. p += sprintf(p, "%cTR%d: av=%d pv=%d dv=%d mv=%dn" 
  741. "tppn  : 0x%lxn" 
  742. "tvpn  : 0x%lxn" 
  743. "tps   : ",
  745. "ID"[i],
  746. j,
  747. tr_valid.pal_tr_valid_s.access_rights_valid,
  748. tr_valid.pal_tr_valid_s.priv_level_valid,
  749. tr_valid.pal_tr_valid_s.dirty_bit_valid,
  750. tr_valid.pal_tr_valid_s.mem_attr_valid,
  751. (gr_reg->ppn & pgm)<< 12,
  752. (ifa_reg->vpn & pgm)<< 12);
  754. p = bitvector_process(p, 1<< itir_reg->ps);
  756. p += sprintf(p, "ntpl   : %dn" 
  757. "tar   : %dn" 
  758. "trid  : %xn" 
  759. "tp    : %dn" 
  760. "tma   : %dn" 
  761. "td    : %dn",
  762. gr_reg->pl,
  763. gr_reg->ar,
  764. rid_reg->rid,
  765. gr_reg->p,
  766. gr_reg->ma,
  767. gr_reg->d);
  768. }
  769. }
  770. return p - page;
  771. }
  775. /*
  776.  * List {name,function} pairs for every entry in /proc/palinfo/cpu*
  777.  */
  778. static palinfo_entry_t palinfo_entries[]={
  779. { "version_info", version_info, },
  780. { "vm_info", vm_info, },
  781. { "cache_info", cache_info, },
  782. { "power_info", power_info, },
  783. { "register_info", register_info, },
  784. { "processor_info", processor_info, },
  785. { "perfmon_info", perfmon_info, },
  786. { "frequency_info", frequency_info, },
  787. { "bus_info", bus_info },
  788. { "tr_info", tr_info, }
  789. };
  791. #define NR_PALINFO_ENTRIES (sizeof(palinfo_entries)/sizeof(palinfo_entry_t))
  793. /*
  794.  * this array is used to keep track of the proc entries we create. This is
  795.  * required in the module mode when we need to remove all entries. The procfs code
  796.  * does not do recursion of deletion
  797.  *
  798.  * Notes:
  799.  * - first +1 accounts for the cpuN entry
  800.  * - second +1 account for toplevel palinfo
  801.  *
  802.  */
  803. #define NR_PALINFO_PROC_ENTRIES (NR_CPUS*(NR_PALINFO_ENTRIES+1)+1)
  805. static struct proc_dir_entry *palinfo_proc_entries[NR_PALINFO_PROC_ENTRIES];
  807. /*
  808.  * This data structure is used to pass which cpu,function is being requested
  809.  * It must fit in a 64bit quantity to be passed to the proc callback routine
  810.  *
  811.  * In SMP mode, when we get a request for another CPU, we must call that
  812.  * other CPU using IPI and wait for the result before returning.
  813.  */
  814. typedef union {
  815. u64 value;
  816. struct {
  817. unsigned req_cpu: 32; /* for which CPU this info is */
  818. unsigned func_id: 32; /* which function is requested */
  819. } pal_func_cpu;
  820. } pal_func_cpu_u_t;
  822. #define req_cpu pal_func_cpu.req_cpu
  823. #define func_id pal_func_cpu.func_id
  825. #ifdef CONFIG_SMP
  827. /*
  828.  * used to hold information about final function to call
  829.  */
  830. typedef struct {
  831. palinfo_func_t func; /* pointer to function to call */
  832. char *page; /* buffer to store results */
  833. int ret; /* return value from call */
  834. } palinfo_smp_data_t;
  837. /*
  838.  * this function does the actual final call and he called
  839.  * from the smp code, i.e., this is the palinfo callback routine
  840.  */
  841. static void
  842. palinfo_smp_call(void *info)
  843. {
  844. palinfo_smp_data_t *data = (palinfo_smp_data_t *)info;
  845. if (data == NULL) {
  846. printk("%s palinfo: data pointer is NULLn", KERN_ERR);
  847. data->ret = 0; /* no output */
  848. return;
  849. }
  850. /* does this actual call */
  851. data->ret = (*data->func)(data->page);
  852. }
  854. /*
  855.  * function called to trigger the IPI, we need to access a remote CPU
  856.  * Return:
  857.  * 0 : error or nothing to output
  858.  * otherwise how many bytes in the "page" buffer were written
  859.  */
  860. static
  861. int palinfo_handle_smp(pal_func_cpu_u_t *f, char *page)
  862. {
  863. palinfo_smp_data_t ptr;
  864. int ret;
  866. ptr.func = palinfo_entries[f->func_id].proc_read;
  867. ptr.page = page;
  868. ptr.ret  = 0; /* just in case */
  871. /* will send IPI to other CPU and wait for completion of remote call */
  872. if ((ret=smp_call_function_single(f->req_cpu, palinfo_smp_call, &ptr, 0, 1))) {
  873. printk("palinfo: remote CPU call from %d to %d on function %d: error %dn", smp_processor_id(), f->req_cpu, f->func_id, ret);
  874. return 0;
  875. }
  876. return ptr.ret;
  877. }
  878. #else /* ! CONFIG_SMP */
  879. static
  880. int palinfo_handle_smp(pal_func_cpu_u_t *f, char *page)
  881. {
  882. printk("palinfo: should not be called with non SMP kerneln");
  883. return 0;
  884. }
  885. #endif /* CONFIG_SMP */
  887. /*
  888.  * Entry point routine: all calls go through this function
  889.  */
  890. static int
  891. palinfo_read_entry(char *page, char **start, off_t off, int count, int *eof, void *data)
  892. {
  893. int len=0;
  894. pal_func_cpu_u_t *f = (pal_func_cpu_u_t *)&data;
  896. MOD_INC_USE_COUNT;
  897. /*
  898.  * in SMP mode, we may need to call another CPU to get correct
  899.  * information. PAL, by definition, is processor specific
  900.  */
  901. if (f->req_cpu == smp_processor_id())
  902. len = (*palinfo_entries[f->func_id].proc_read)(page);
  903. else
  904. len = palinfo_handle_smp(f, page);
  906. if (len <= off+count) *eof = 1;
  908. *start = page + off;
  909. len   -= off;
  911. if (len>count) len = count;
  912. if (len<0) len = 0;
  914. MOD_DEC_USE_COUNT;
  916. return len;
  917. }
  919. static int __init
  920. palinfo_init(void)
  921. {
  922. # define CPUSTR "cpu%d"
  924. pal_func_cpu_u_t f;
  925. struct proc_dir_entry **pdir = palinfo_proc_entries;
  926. struct proc_dir_entry *palinfo_dir, *cpu_dir;
  927. int i, j;
  928. char cpustr[sizeof(CPUSTR)];
  930. printk(KERN_INFO "PAL Information Facility v%sn", PALINFO_VERSION);
  932. palinfo_dir = proc_mkdir("pal", NULL);
  934. /*
  935.  * we keep track of created entries in a depth-first order for
  936.  * cleanup purposes. Each entry is stored into palinfo_proc_entries
  937.  */
  938. for (i=0; i < NR_CPUS; i++) {
  940. if (!cpu_is_online(i)) continue;
  942. sprintf(cpustr,CPUSTR, i);
  944. cpu_dir = proc_mkdir(cpustr, palinfo_dir);
  946. f.req_cpu = i;
  948. for (j=0; j < NR_PALINFO_ENTRIES; j++) {
  949. f.func_id = j;
  950. *pdir++ = create_proc_read_entry (palinfo_entries[j].name, 0, cpu_dir,
  951. palinfo_read_entry, (void *)f.value);
  952. }
  953. *pdir++ = cpu_dir;
  954. }
  955. *pdir = palinfo_dir;
  957. return 0;
  958. }
  960. static void __exit
  961. palinfo_exit(void)
  962. {
  963. int i = 0;
  965. /* remove all nodes: depth first pass. Could optimize this  */
  966. for (i=0; i< NR_PALINFO_PROC_ENTRIES ; i++) {
  967. if (palinfo_proc_entries[i])
  968. remove_proc_entry (palinfo_proc_entries[i]->name, NULL);
  969. }
  970. }
  972. module_init(palinfo_init);
  973. module_exit(palinfo_exit);