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

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

Linux/Unix编程

开发平台：

Unix_Linux

mca.c：源码内容
  1. /*
  2.  * File: mca.c
  3.  * Purpose: Generic MCA handling layer
  4.  *
  5.  * Updated for latest kernel
  6.  * Copyright (C) 2002 Dell Computer Corporation
  7.  * Copyright (C) Matt Domsch (Matt_Domsch@dell.com)
  8.  *
  9.  * Copyright (C) 2002 Intel
  10.  * Copyright (C) Jenna Hall (jenna.s.hall@intel.com)
  11.  *
  12.  * Copyright (C) 2001 Intel
  13.  * Copyright (C) Fred Lewis (frederick.v.lewis@intel.com)
  14.  *
  15.  * Copyright (C) 2000 Intel
  16.  * Copyright (C) Chuck Fleckenstein (cfleck@co.intel.com)
  17.  *
  18.  * Copyright (C) 1999 Silicon Graphics, Inc.
  19.  * Copyright (C) Vijay Chander(vijay@engr.sgi.com)
  20.  *
  21.  * 02/03/25 M. Domsch GUID cleanups
  22.  *
  23.  * 02/01/04 J. Hall Aligned MCA stack to 16 bytes, added platform vs. CPU
  24.  * error flag, set SAL default return values, changed
  25.  * error record structure to linked list, added init call
  26.  * to sal_get_state_info_size().
  27.  *
  28.  * 01/01/03 F. Lewis    Added setup of CMCI and CPEI IRQs, logging of corrected
  29.  *                      platform errors, completed code for logging of
  30.  *                      corrected & uncorrected machine check errors, and
  31.  *                      updated for conformance with Nov. 2000 revision of the
  32.  *                      SAL 3.0 spec.
  33.  * 00/03/29 C. Fleckenstein  Fixed PAL/SAL update issues, began MCA bug fixes, logging issues,
  34.  *                           added min save state dump, added INIT handler.
  35.  */
  36. #include <linux/config.h>
  37. #include <linux/types.h>
  38. #include <linux/init.h>
  39. #include <linux/sched.h>
  40. #include <linux/interrupt.h>
  41. #include <linux/irq.h>
  42. #include <linux/smp_lock.h>
  43. #include <linux/bootmem.h>
  44. #include <linux/acpi.h>
  46. #include <asm/machvec.h>
  47. #include <asm/page.h>
  48. #include <asm/ptrace.h>
  49. #include <asm/system.h>
  50. #include <asm/sal.h>
  51. #include <asm/mca.h>
  53. #include <asm/irq.h>
  54. #include <asm/hw_irq.h>
  56. #undef MCA_PRT_XTRA_DATA
  58. typedef struct ia64_fptr {
  59. unsigned long fp;
  60. unsigned long gp;
  61. } ia64_fptr_t;
  63. ia64_mc_info_t ia64_mc_info;
  64. ia64_mca_sal_to_os_state_t ia64_sal_to_os_handoff_state;
  65. ia64_mca_os_to_sal_state_t ia64_os_to_sal_handoff_state;
  66. u64 ia64_mca_proc_state_dump[512];
  67. u64 ia64_mca_stack[1024] __attribute__((aligned(16)));
  68. u64 ia64_mca_stackframe[32];
  69. u64 ia64_mca_bspstore[1024];
  70. u64 ia64_init_stack[INIT_TASK_SIZE] __attribute__((aligned(16)));
  71. u64 ia64_mca_sal_data_area[1356];
  72. u64 ia64_mca_min_state_save_info;
  73. u64 ia64_tlb_functional;
  74. u64 ia64_os_mca_recovery_successful;
  76. static void ia64_mca_wakeup_ipi_wait(void);
  77. static void ia64_mca_wakeup(int cpu);
  78. static void ia64_mca_wakeup_all(void);
  79. static void ia64_log_init(int);
  80. extern void ia64_monarch_init_handler (void);
  81. extern void ia64_slave_init_handler (void);
  82. extern struct hw_interrupt_type irq_type_iosapic_level;
  84. static struct irqaction cmci_irqaction = {
  85. handler:    ia64_mca_cmc_int_handler,
  86. flags:      SA_INTERRUPT,
  87. name:       "cmc_hndlr"
  88. };
  90. static struct irqaction mca_rdzv_irqaction = {
  91. handler:    ia64_mca_rendez_int_handler,
  92. flags:      SA_INTERRUPT,
  93. name:       "mca_rdzv"
  94. };
  96. static struct irqaction mca_wkup_irqaction = {
  97. handler:    ia64_mca_wakeup_int_handler,
  98. flags:      SA_INTERRUPT,
  99. name:       "mca_wkup"
  100. };
  102. static struct irqaction mca_cpe_irqaction = {
  103. handler:    ia64_mca_cpe_int_handler,
  104. flags:      SA_INTERRUPT,
  105. name:       "cpe_hndlr"
  106. };
  108. /*
  109.  *  ia64_mca_log_sal_error_record
  110.  *
  111.  *  This function retrieves a specified error record type from SAL, sends it to
  112.  *  the system log, and notifies SALs to clear the record from its non-volatile
  113.  *  memory.
  114.  *
  115.  *  Inputs  :   sal_info_type   (Type of error record MCA/CMC/CPE/INIT)
  116.  *  Outputs :   platform error status
  117.  */
  118. int
  119. ia64_mca_log_sal_error_record(int sal_info_type)
  120. {
  121. int platform_err = 0;
  123. /* Get the MCA error record */
  124. if (!ia64_log_get(sal_info_type, (prfunc_t)printk))
  125. return platform_err;                 // no record retrieved
  127. /* TODO:
  128.  * 1. analyze error logs to determine recoverability
  129.  * 2. perform error recovery procedures, if applicable
  130.  * 3. set ia64_os_mca_recovery_successful flag, if applicable
  131.  */
  133. platform_err = ia64_log_print(sal_info_type, (prfunc_t)printk);
  134. ia64_sal_clear_state_info(sal_info_type);
  136. return platform_err;
  137. }
  139. /*
  140.  * platform dependent error handling
  141.  */
  142. #ifndef PLATFORM_MCA_HANDLERS
  143. void
  144. mca_handler_platform (void)
  145. {
  147. }
  149. void
  150. ia64_mca_cpe_int_handler (int cpe_irq, void *arg, struct pt_regs *ptregs)
  151. {
  152. IA64_MCA_DEBUG("ia64_mca_cpe_int_handler: received interrupt. vector = %#xn", cpe_irq);
  154. /* Get the CMC error record and log it */
  155. ia64_mca_log_sal_error_record(SAL_INFO_TYPE_CPE);
  156. }
  158. /*
  159.  * This routine will be used to deal with platform specific handling
  160.  * of the init, i.e. drop into the kernel debugger on server machine,
  161.  * or if the processor is part of some parallel machine without a
  162.  * console, then we would call the appropriate debug hooks here.
  163.  */
  164. void
  165. init_handler_platform (struct pt_regs *regs)
  166. {
  167. /* if a kernel debugger is available call it here else just dump the registers */
  169. show_regs(regs); /* dump the state info */
  170. while (1); /* hang city if no debugger */
  171. }
  173. /*
  174.  * ia64_mca_init_platform
  175.  *
  176.  *  External entry for platform specific MCA initialization.
  177.  *
  178.  *  Inputs
  179.  *      None
  180.  *
  181.  *  Outputs
  182.  *      None
  183.  */
  184. void
  185. ia64_mca_init_platform (void)
  186. {
  188. }
  190. /*
  191.  *  ia64_mca_check_errors
  192.  *
  193.  *  External entry to check for error records which may have been posted by SAL
  194.  *  for a prior failure which resulted in a machine shutdown before an the
  195.  *  error could be logged.  This function must be called after the filesystem
  196.  *  is initialized.
  197.  *
  198.  *  Inputs  :   None
  199.  *
  200.  *  Outputs :   None
  201.  */
  202. void
  203. ia64_mca_check_errors (void)
  204. {
  205. /*
  206.  *  If there is an MCA error record pending, get it and log it.
  207.  */
  208. ia64_mca_log_sal_error_record(SAL_INFO_TYPE_MCA);
  209. }
  211. /*
  212.  * ia64_mca_register_cpev
  213.  *
  214.  *  Register the corrected platform error vector with SAL.
  215.  *
  216.  *  Inputs
  217.  *      cpev        Corrected Platform Error Vector number
  218.  *
  219.  *  Outputs
  220.  *      None
  221.  */
  222. static void
  223. ia64_mca_register_cpev (int cpev)
  224. {
  225. /* Register the CPE interrupt vector with SAL */
  226. if (ia64_sal_mc_set_params(SAL_MC_PARAM_CPE_INT, SAL_MC_PARAM_MECHANISM_INT, cpev, 0, 0)) {
  227. printk("ia64_mca_platform_init: failed to register Corrected "
  228.        "Platform Error interrupt vector with SAL.n");
  229. return;
  230. }
  232. IA64_MCA_DEBUG("ia64_mca_platform_init: corrected platform error "
  233.        "vector %#x setup and enabledn", cpev);
  234. }
  236. #endif /* PLATFORM_MCA_HANDLERS */
  238. static char *min_state_labels[] = {
  239. "nat",
  240. "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8",
  241. "r9", "r10","r11", "r12","r13","r14", "r15",
  242. "b0r16","b0r17", "b0r18", "b0r19", "b0r20",
  243. "b0r21", "b0r22","b0r23", "b0r24", "b0r25",
  244. "b0r26", "b0r27", "b0r28","b0r29", "b0r30", "b0r31",
  245. "r16", "r17", "r18","r19", "r20", "r21","r22",
  246. "r23", "r24","r25", "r26", "r27","r28", "r29", "r30","r31",
  247. "preds", "br0", "rsc",
  248. "iip", "ipsr", "ifs",
  249. "xip", "xpsr", "xfs"
  250. };
  252. int ia64_pmss_dump_bank0=0;  /* dump bank 0 ? */
  254. /*
  255.  * routine to process and prepare to dump min_state_save
  256.  * information for debugging purposes.
  257.  *
  258.  */
  259. void
  260. ia64_process_min_state_save (pal_min_state_area_t *pmss, struct pt_regs *ptregs)
  261. {
  262. int i, max=57;
  263. u64 *tpmss_ptr=(u64 *)pmss;
  265. /* dump out the min_state_area information */
  267. for (i=0;i<max;i++) {
  269. if(!ia64_pmss_dump_bank0) {
  270. if(strncmp("B0",min_state_labels[i],2)==0) {
  271. tpmss_ptr++;  /* skip to next entry */
  272. continue;
  273. }
  274. }
  276. printk("%5s=0x%16.16lx ",min_state_labels[i],*tpmss_ptr++);
  278. if (((i+1)%3)==0 || ((!strcmp("GR16",min_state_labels[i]))
  279.      && !ia64_pmss_dump_bank0))
  280. printk("n");
  281. }
  282. }
  284. /*
  285.  * ia64_mca_cmc_vector_setup
  286.  *
  287.  *  Setup the corrected machine check vector register in the processor and
  288.  *  unmask interrupt.  This function is invoked on a per-processor basis.
  289.  *
  290.  * Inputs
  291.  *      None
  292.  *
  293.  * Outputs
  294.  * None
  295.  */
  296. void
  297. ia64_mca_cmc_vector_setup (void)
  298. {
  299. cmcv_reg_t cmcv;
  301. cmcv.cmcv_regval = 0;
  302. cmcv.cmcv_mask = 0;        /* Unmask/enable interrupt */
  303. cmcv.cmcv_vector = IA64_CMC_VECTOR;
  304. ia64_set_cmcv(cmcv.cmcv_regval);
  306. IA64_MCA_DEBUG("ia64_mca_platform_init: CPU %d corrected "
  307.        "machine check vector %#x setup and enabled.n",
  308.        smp_processor_id(), IA64_CMC_VECTOR);
  310. IA64_MCA_DEBUG("ia64_mca_platform_init: CPU %d CMCV = %#016lxn",
  311.        smp_processor_id(), ia64_get_cmcv());
  312. }
  315. #if defined(MCA_TEST)
  317. sal_log_processor_info_t slpi_buf;
  319. void
  320. mca_test(void)
  321. {
  322. slpi_buf.valid.psi_static_struct = 1;
  323. slpi_buf.valid.num_cache_check = 1;
  324. slpi_buf.valid.num_tlb_check = 1;
  325. slpi_buf.valid.num_bus_check = 1;
  326. slpi_buf.valid.processor_static_info.minstate = 1;
  327. slpi_buf.valid.processor_static_info.br = 1;
  328. slpi_buf.valid.processor_static_info.cr = 1;
  329. slpi_buf.valid.processor_static_info.ar = 1;
  330. slpi_buf.valid.processor_static_info.rr = 1;
  331. slpi_buf.valid.processor_static_info.fr = 1;
  333. ia64_os_mca_dispatch();
  334. }
  336. #endif /* #if defined(MCA_TEST) */
  339. /*
  340.  *  verify_guid
  341.  *
  342.  *  Compares a test guid to a target guid and returns result.
  343.  *
  344.  *  Inputs
  345.  *      test_guid *     (ptr to guid to be verified)
  346.  *      target_guid *   (ptr to standard guid to be verified against)
  347.  *
  348.  *  Outputs
  349.  *      0               (test verifies against target)
  350.  *      non-zero        (test guid does not verify)
  351.  */
  352. static int
  353. verify_guid (efi_guid_t *test, efi_guid_t *target)
  354. {
  355. int     rc;
  356. #ifdef IA64_MCA_DEBUG_INFO
  357. char out[40];
  358. #endif
  360. if ((rc = efi_guidcmp(*test, *target))) {
  361. IA64_MCA_DEBUG(KERN_DEBUG
  362.        "verify_guid: invalid GUID = %sn",
  363.        efi_guid_unparse(test, out));
  364. }
  365. return rc;
  366. }
  368. /*
  369.  * ia64_mca_init
  370.  *
  371.  *  Do all the system level mca specific initialization.
  372.  *
  373.  * 1. Register spinloop and wakeup request interrupt vectors
  374.  *
  375.  * 2. Register OS_MCA handler entry point
  376.  *
  377.  * 3. Register OS_INIT handler entry point
  378.  *
  379.  *  4. Initialize MCA/CMC/INIT related log buffers maintained by the OS.
  380.  *
  381.  *  Note that this initialization is done very early before some kernel
  382.  *  services are available.
  383.  *
  384.  *  Inputs  :   None
  385.  *
  386.  *  Outputs :   None
  387.  */
  388. void __init
  389. ia64_mca_init(void)
  390. {
  391. ia64_fptr_t *mon_init_ptr = (ia64_fptr_t *)ia64_monarch_init_handler;
  392. ia64_fptr_t *slave_init_ptr = (ia64_fptr_t *)ia64_slave_init_handler;
  393. ia64_fptr_t *mca_hldlr_ptr = (ia64_fptr_t *)ia64_os_mca_dispatch;
  394. int i;
  395. s64 rc;
  397. IA64_MCA_DEBUG("ia64_mca_init: beginn");
  399. /* initialize recovery success indicator */
  400. ia64_os_mca_recovery_successful = 0;
  402. /* Clear the Rendez checkin flag for all cpus */
  403. for(i = 0 ; i < NR_CPUS; i++)
  404. ia64_mc_info.imi_rendez_checkin[i] = IA64_MCA_RENDEZ_CHECKIN_NOTDONE;
  406. /*
  407.  * Register the rendezvous spinloop and wakeup mechanism with SAL
  408.  */
  410. /* Register the rendezvous interrupt vector with SAL */
  411. if ((rc = ia64_sal_mc_set_params(SAL_MC_PARAM_RENDEZ_INT,
  412.  SAL_MC_PARAM_MECHANISM_INT,
  413.  IA64_MCA_RENDEZ_VECTOR,
  414.  IA64_MCA_RENDEZ_TIMEOUT,
  415.  0)))
  416. {
  417. printk("ia64_mca_init: Failed to register rendezvous interrupt "
  418.        "with SAL.  rc = %ldn", rc);
  419. return;
  420. }
  422. /* Register the wakeup interrupt vector with SAL */
  423. if ((rc = ia64_sal_mc_set_params(SAL_MC_PARAM_RENDEZ_WAKEUP,
  424.  SAL_MC_PARAM_MECHANISM_INT,
  425.  IA64_MCA_WAKEUP_VECTOR,
  426.  0, 0)))
  427. {
  428. printk("ia64_mca_init: Failed to register wakeup interrupt with SAL.  rc = %ldn",
  429.        rc);
  430. return;
  431. }
  433. IA64_MCA_DEBUG("ia64_mca_init: registered mca rendezvous spinloop and wakeup mech.n");
  435. ia64_mc_info.imi_mca_handler        = __pa(mca_hldlr_ptr->fp);
  436. /*
  437.  * XXX - disable SAL checksum by setting size to 0; should be
  438.  * __pa(ia64_os_mca_dispatch_end) - __pa(ia64_os_mca_dispatch);
  439.  */
  440. ia64_mc_info.imi_mca_handler_size = 0;
  442. /* Register the os mca handler with SAL */
  443. if ((rc = ia64_sal_set_vectors(SAL_VECTOR_OS_MCA,
  444.        ia64_mc_info.imi_mca_handler,
  445.        mca_hldlr_ptr->gp,
  446.        ia64_mc_info.imi_mca_handler_size,
  447.        0, 0, 0)))
  448. {
  449. printk("ia64_mca_init: Failed to register os mca handler with SAL.  rc = %ldn",
  450.        rc);
  451. return;
  452. }
  454. IA64_MCA_DEBUG("ia64_mca_init: registered os mca handler with SAL at 0x%lx, gp = 0x%lxn",
  455.        ia64_mc_info.imi_mca_handler, mca_hldlr_ptr->gp);
  457. /*
  458.  * XXX - disable SAL checksum by setting size to 0, should be
  459.  * IA64_INIT_HANDLER_SIZE
  460.  */
  461. ia64_mc_info.imi_monarch_init_handler = __pa(mon_init_ptr->fp);
  462. ia64_mc_info.imi_monarch_init_handler_size = 0;
  463. ia64_mc_info.imi_slave_init_handler = __pa(slave_init_ptr->fp);
  464. ia64_mc_info.imi_slave_init_handler_size = 0;
  466. IA64_MCA_DEBUG("ia64_mca_init: os init handler at %lxn",
  467.        ia64_mc_info.imi_monarch_init_handler);
  469. /* Register the os init handler with SAL */
  470. if ((rc = ia64_sal_set_vectors(SAL_VECTOR_OS_INIT,
  471.        ia64_mc_info.imi_monarch_init_handler,
  472.        __pa(ia64_get_gp()),
  473.        ia64_mc_info.imi_monarch_init_handler_size,
  474.        ia64_mc_info.imi_slave_init_handler,
  475.        __pa(ia64_get_gp()),
  476.        ia64_mc_info.imi_slave_init_handler_size)))
  477. {
  478. printk("ia64_mca_init: Failed to register m/s init handlers with SAL. rc = %ldn",
  479.        rc);
  480. return;
  481. }
  483. IA64_MCA_DEBUG("ia64_mca_init: registered os init handler with SALn");
  485. /*
  486.  *  Configure the CMCI vector and handler. Interrupts for CMC are
  487.  *  per-processor, so AP CMC interrupts are setup in smp_callin() (smpboot.c).
  488.  */
  489. register_percpu_irq(IA64_CMC_VECTOR, &cmci_irqaction);
  490. ia64_mca_cmc_vector_setup();       /* Setup vector on BSP & enable */
  492. /* Setup the MCA rendezvous interrupt vector */
  493. register_percpu_irq(IA64_MCA_RENDEZ_VECTOR, &mca_rdzv_irqaction);
  495. /* Setup the MCA wakeup interrupt vector */
  496. register_percpu_irq(IA64_MCA_WAKEUP_VECTOR, &mca_wkup_irqaction);
  498. /* Setup the CPE interrupt vector */
  499. {
  500. irq_desc_t *desc;
  501. unsigned int irq;
  502. int cpev = acpi_request_vector(ACPI_INTERRUPT_CPEI);
  504. if (cpev >= 0) {
  505. for (irq = 0; irq < NR_IRQS; ++irq)
  506. if (irq_to_vector(irq) == cpev) {
  507. desc = irq_desc(irq);
  508. desc->status |= IRQ_PER_CPU;
  509. desc->handler = &irq_type_iosapic_level;
  510. setup_irq(irq, &mca_cpe_irqaction);
  511. }
  512. ia64_mca_register_cpev(cpev);
  513. } else
  514. printk("ia64_mca_init: Failed to get routed CPEI vector from ACPI.n");
  515. }
  517. /* Initialize the areas set aside by the OS to buffer the
  518.  * platform/processor error states for MCA/INIT/CMC
  519.  * handling.
  520.  */
  521. ia64_log_init(SAL_INFO_TYPE_MCA);
  522. ia64_log_init(SAL_INFO_TYPE_INIT);
  523. ia64_log_init(SAL_INFO_TYPE_CMC);
  524. ia64_log_init(SAL_INFO_TYPE_CPE);
  526. /* Zero the min state save info */
  527. ia64_mca_min_state_save_info = 0;
  529. #if defined(MCA_TEST)
  530. mca_test();
  531. #endif /* #if defined(MCA_TEST) */
  533. printk("Mca related initialization donen");
  535. #if 0   // Too early in initialization -- error log is lost
  536. /* Do post-failure MCA error logging */
  537. ia64_mca_check_errors();
  538. #endif  // Too early in initialization -- error log is lost
  539. }
  541. /*
  542.  * ia64_mca_wakeup_ipi_wait
  543.  *
  544.  * Wait for the inter-cpu interrupt to be sent by the
  545.  * monarch processor once it is done with handling the
  546.  * MCA.
  547.  *
  548.  *  Inputs  :   None
  549.  *  Outputs :   None
  550.  */
  551. void
  552. ia64_mca_wakeup_ipi_wait(void)
  553. {
  554. int irr_num = (IA64_MCA_WAKEUP_VECTOR >> 6);
  555. int irr_bit = (IA64_MCA_WAKEUP_VECTOR & 0x3f);
  556. u64 irr = 0;
  558. do {
  559. switch(irr_num) {
  560.       case 0:
  561. irr = ia64_get_irr0();
  562. break;
  563.       case 1:
  564. irr = ia64_get_irr1();
  565. break;
  566.       case 2:
  567. irr = ia64_get_irr2();
  568. break;
  569.       case 3:
  570. irr = ia64_get_irr3();
  571. break;
  572. }
  573. } while (!(irr & (1 << irr_bit))) ;
  574. }
  576. /*
  577.  * ia64_mca_wakeup
  578.  *
  579.  * Send an inter-cpu interrupt to wake-up a particular cpu
  580.  * and mark that cpu to be out of rendez.
  581.  *
  582.  *  Inputs  :   cpuid
  583.  *  Outputs :   None
  584.  */
  585. void
  586. ia64_mca_wakeup(int cpu)
  587. {
  588. platform_send_ipi(cpu, IA64_MCA_WAKEUP_VECTOR, IA64_IPI_DM_INT, 0);
  589. ia64_mc_info.imi_rendez_checkin[cpu] = IA64_MCA_RENDEZ_CHECKIN_NOTDONE;
  591. }
  593. /*
  594.  * ia64_mca_wakeup_all
  595.  *
  596.  * Wakeup all the cpus which have rendez'ed previously.
  597.  *
  598.  *  Inputs  :   None
  599.  *  Outputs :   None
  600.  */
  601. void
  602. ia64_mca_wakeup_all(void)
  603. {
  604. int cpu;
  606. /* Clear the Rendez checkin flag for all cpus */
  607. for(cpu = 0; cpu < smp_num_cpus; cpu++)
  608. if (ia64_mc_info.imi_rendez_checkin[cpu] == IA64_MCA_RENDEZ_CHECKIN_DONE)
  609. ia64_mca_wakeup(cpu);
  611. }
  613. /*
  614.  * ia64_mca_rendez_interrupt_handler
  615.  *
  616.  * This is handler used to put slave processors into spinloop
  617.  * while the monarch processor does the mca handling and later
  618.  * wake each slave up once the monarch is done.
  619.  *
  620.  *  Inputs  :   None
  621.  *  Outputs :   None
  622.  */
  623. void
  624. ia64_mca_rendez_int_handler(int rendez_irq, void *arg, struct pt_regs *ptregs)
  625. {
  626. int flags, cpu = 0;
  627. /* Mask all interrupts */
  628. save_and_cli(flags);
  630. #ifdef CONFIG_SMP
  631. cpu = cpu_logical_id(hard_smp_processor_id());
  632. #endif
  633. ia64_mc_info.imi_rendez_checkin[cpu] = IA64_MCA_RENDEZ_CHECKIN_DONE;
  634. /* Register with the SAL monarch that the slave has
  635.  * reached SAL
  636.  */
  637. ia64_sal_mc_rendez();
  639. /* Wait for the wakeup IPI from the monarch
  640.  * This waiting is done by polling on the wakeup-interrupt
  641.  * vector bit in the processor's IRRs
  642.  */
  643. ia64_mca_wakeup_ipi_wait();
  645. /* Enable all interrupts */
  646. restore_flags(flags);
  647. }
  650. /*
  651.  * ia64_mca_wakeup_int_handler
  652.  *
  653.  * The interrupt handler for processing the inter-cpu interrupt to the
  654.  * slave cpu which was spinning in the rendez loop.
  655.  * Since this spinning is done by turning off the interrupts and
  656.  * polling on the wakeup-interrupt bit in the IRR, there is
  657.  * nothing useful to be done in the handler.
  658.  *
  659.  *  Inputs  :   wakeup_irq  (Wakeup-interrupt bit)
  660.  * arg (Interrupt handler specific argument)
  661.  * ptregs (Exception frame at the time of the interrupt)
  662.  *  Outputs :   None
  663.  *
  664.  */
  665. void
  666. ia64_mca_wakeup_int_handler(int wakeup_irq, void *arg, struct pt_regs *ptregs)
  667. {
  669. }
  671. /*
  672.  * ia64_return_to_sal_check
  673.  *
  674.  * This is function called before going back from the OS_MCA handler
  675.  * to the OS_MCA dispatch code which finally takes the control back
  676.  * to the SAL.
  677.  * The main purpose of this routine is to setup the OS_MCA to SAL
  678.  * return state which can be used by the OS_MCA dispatch code
  679.  * just before going back to SAL.
  680.  *
  681.  *  Inputs  :   None
  682.  *  Outputs :   None
  683.  */
  685. void
  686. ia64_return_to_sal_check(void)
  687. {
  688. /* Copy over some relevant stuff from the sal_to_os_mca_handoff
  689.  * so that it can be used at the time of os_mca_to_sal_handoff
  690.  */
  691. ia64_os_to_sal_handoff_state.imots_sal_gp =
  692. ia64_sal_to_os_handoff_state.imsto_sal_gp;
  694. ia64_os_to_sal_handoff_state.imots_sal_check_ra =
  695. ia64_sal_to_os_handoff_state.imsto_sal_check_ra;
  697. /* Cold Boot for uncorrectable MCA */
  698. ia64_os_to_sal_handoff_state.imots_os_status = IA64_MCA_COLD_BOOT;
  700. /* Default = tell SAL to return to same context */
  701. ia64_os_to_sal_handoff_state.imots_context = IA64_MCA_SAME_CONTEXT;
  703. /* Register pointer to new min state values */
  704. /* NOTE: need to do something with this during recovery phase */
  705. ia64_os_to_sal_handoff_state.imots_new_min_state = &ia64_mca_min_state_save_info;
  706. }
  708. /*
  709.  * ia64_mca_ucmc_handler
  710.  *
  711.  * This is uncorrectable machine check handler called from OS_MCA
  712.  * dispatch code which is in turn called from SAL_CHECK().
  713.  * This is the place where the core of OS MCA handling is done.
  714.  * Right now the logs are extracted and displayed in a well-defined
  715.  * format. This handler code is supposed to be run only on the
  716.  * monarch processor. Once the monarch is done with MCA handling
  717.  * further MCA logging is enabled by clearing logs.
  718.  * Monarch also has the duty of sending wakeup-IPIs to pull the
  719.  * slave processors out of rendezvous spinloop.
  720.  *
  721.  *  Inputs  :   None
  722.  *  Outputs :   None
  723.  */
  724. void
  725. ia64_mca_ucmc_handler(void)
  726. {
  727. int platform_err = 0;
  729. /* Get the MCA error record and log it */
  730. platform_err = ia64_mca_log_sal_error_record(SAL_INFO_TYPE_MCA);
  732. /*
  733.  *  Do Platform-specific mca error handling if required.
  734.  */
  735. if (platform_err)
  736. mca_handler_platform();
  738. /*
  739.  *  Wakeup all the processors which are spinning in the rendezvous
  740.  *  loop.
  741.  */
  742. ia64_mca_wakeup_all();
  744. /* Return to SAL */
  745. ia64_return_to_sal_check();
  746. }
  748. /*
  749.  * ia64_mca_cmc_int_handler
  750.  *
  751.  *  This is corrected machine check interrupt handler.
  752.  * Right now the logs are extracted and displayed in a well-defined
  753.  * format.
  754.  *
  755.  * Inputs
  756.  *      interrupt number
  757.  *      client data arg ptr
  758.  *      saved registers ptr
  759.  *
  760.  * Outputs
  761.  * None
  762.  */
  763. void
  764. ia64_mca_cmc_int_handler(int cmc_irq, void *arg, struct pt_regs *ptregs)
  765. {
  766. IA64_MCA_DEBUG("ia64_mca_cmc_int_handler: received interrupt vector = %#x on CPU %dn",
  767.        cmc_irq, smp_processor_id());
  769. /* Get the CMC error record and log it */
  770. ia64_mca_log_sal_error_record(SAL_INFO_TYPE_CMC);
  771. }
  773. /*
  774.  * IA64_MCA log support
  775.  */
  776. #define IA64_MAX_LOGS 2 /* Double-buffering for nested MCAs */
  777. #define IA64_MAX_LOG_TYPES      4   /* MCA, INIT, CMC, CPE */
  779. typedef struct ia64_state_log_s
  780. {
  781. spinlock_t isl_lock;
  782. int isl_index;
  783. ia64_err_rec_t  *isl_log[IA64_MAX_LOGS]; /* need space to store header + error log */
  784. } ia64_state_log_t;
  786. static ia64_state_log_t ia64_state_log[IA64_MAX_LOG_TYPES];
  788. #define IA64_LOG_ALLOCATE(it, size) 
  789. {ia64_state_log[it].isl_log[IA64_LOG_CURR_INDEX(it)] = 
  790. (ia64_err_rec_t *)alloc_bootmem(size); 
  791. ia64_state_log[it].isl_log[IA64_LOG_NEXT_INDEX(it)] = 
  792. (ia64_err_rec_t *)alloc_bootmem(size);}
  793. #define IA64_LOG_LOCK_INIT(it) spin_lock_init(&ia64_state_log[it].isl_lock)
  794. #define IA64_LOG_LOCK(it)      spin_lock_irqsave(&ia64_state_log[it].isl_lock, s)
  795. #define IA64_LOG_UNLOCK(it)    spin_unlock_irqrestore(&ia64_state_log[it].isl_lock,s)
  796. #define IA64_LOG_NEXT_INDEX(it)    ia64_state_log[it].isl_index
  797. #define IA64_LOG_CURR_INDEX(it)    1 - ia64_state_log[it].isl_index
  798. #define IA64_LOG_INDEX_INC(it) 
  799.     ia64_state_log[it].isl_index = 1 - ia64_state_log[it].isl_index
  800. #define IA64_LOG_INDEX_DEC(it) 
  801.     ia64_state_log[it].isl_index = 1 - ia64_state_log[it].isl_index
  802. #define IA64_LOG_NEXT_BUFFER(it)   (void *)((ia64_state_log[it].isl_log[IA64_LOG_NEXT_INDEX(it)]))
  803. #define IA64_LOG_CURR_BUFFER(it)   (void *)((ia64_state_log[it].isl_log[IA64_LOG_CURR_INDEX(it)]))
  805. /*
  806.  * C portion of the OS INIT handler
  807.  *
  808.  * Called from ia64_monarch_init_handler
  809.  *
  810.  * Inputs: pointer to pt_regs where processor info was saved.
  811.  *
  812.  * Returns:
  813.  *   0 if SAL must warm boot the System
  814.  *   1 if SAL must return to interrupted context using PAL_MC_RESUME
  815.  *
  816.  */
  817. void
  818. ia64_init_handler (struct pt_regs *regs)
  819. {
  820. sal_log_processor_info_t *proc_ptr;
  821. ia64_err_rec_t *plog_ptr;
  823. printk("Entered OS INIT handlern");
  825. /* Get the INIT processor log */
  826. if (!ia64_log_get(SAL_INFO_TYPE_INIT, (prfunc_t)printk))
  827. return;                 // no record retrieved
  829. #ifdef IA64_DUMP_ALL_PROC_INFO
  830. ia64_log_print(SAL_INFO_TYPE_INIT, (prfunc_t)printk);
  831. #endif
  833. /*
  834.  * get pointer to min state save area
  835.  *
  836.  */
  837. plog_ptr=(ia64_err_rec_t *)IA64_LOG_CURR_BUFFER(SAL_INFO_TYPE_INIT);
  838. proc_ptr = &plog_ptr->proc_err;
  840. ia64_process_min_state_save(&proc_ptr->processor_static_info.min_state_area,
  841.     regs);
  843. /* Clear the INIT SAL logs now that they have been saved in the OS buffer */
  844. ia64_sal_clear_state_info(SAL_INFO_TYPE_INIT);
  846. init_handler_platform(regs);              /* call platform specific routines */
  847. }
  849. /*
  850.  *  ia64_log_prt_guid
  851.  *
  852.  *  Print a formatted GUID.
  853.  *
  854.  * Inputs   :   p_guid      (ptr to the GUID)
  855.  *              prfunc      (print function)
  856.  * Outputs  :   None
  857.  *
  858.  */
  859. void
  860. ia64_log_prt_guid (efi_guid_t *p_guid, prfunc_t prfunc)
  861. {
  862. char out[40];
  863. printk(KERN_DEBUG "GUID = %sn", efi_guid_unparse(p_guid, out));
  864. }
  866. static void
  867. ia64_log_hexdump(unsigned char *p, unsigned long n_ch, prfunc_t prfunc)
  868. {
  869. int i, j;
  871. if (!p)
  872. return;
  874. for (i = 0; i < n_ch;) {
  875. prfunc("%p ", (void *)p);
  876. for (j = 0; (j < 16) && (i < n_ch); i++, j++, p++) {
  877. prfunc("%02x ", *p);
  878. }
  879. prfunc("n");
  880. }
  881. }
  883. #ifdef MCA_PRT_XTRA_DATA    // for test only @FVL
  885. static void
  886. ia64_log_prt_record_header (sal_log_record_header_t *rh, prfunc_t prfunc)
  887. {
  888. prfunc("SAL RECORD HEADER:  Record buffer = %p,  header size = %ldn",
  889.        (void *)rh, sizeof(sal_log_record_header_t));
  890. ia64_log_hexdump((unsigned char *)rh, sizeof(sal_log_record_header_t),
  891.  (prfunc_t)prfunc);
  892. prfunc("Total record length = %dn", rh->len);
  893. ia64_log_prt_guid(&rh->platform_guid, prfunc);
  894. prfunc("End of SAL RECORD HEADERn");
  895. }
  897. static void
  898. ia64_log_prt_section_header (sal_log_section_hdr_t *sh, prfunc_t prfunc)
  899. {
  900. prfunc("SAL SECTION HEADER:  Record buffer = %p,  header size = %ldn",
  901.        (void *)sh, sizeof(sal_log_section_hdr_t));
  902. ia64_log_hexdump((unsigned char *)sh, sizeof(sal_log_section_hdr_t),
  903.  (prfunc_t)prfunc);
  904. prfunc("Length of section & header = %dn", sh->len);
  905. ia64_log_prt_guid(&sh->guid, prfunc);
  906. prfunc("End of SAL SECTION HEADERn");
  907. }
  908. #endif  // MCA_PRT_XTRA_DATA for test only @FVL
  910. /*
  911.  * ia64_log_init
  912.  * Reset the OS ia64 log buffer
  913.  * Inputs   :   info_type   (SAL_INFO_TYPE_{MCA,INIT,CMC,CPE})
  914.  * Outputs : None
  915.  */
  916. void
  917. ia64_log_init(int sal_info_type)
  918. {
  919. u64 max_size = 0;
  921. IA64_LOG_NEXT_INDEX(sal_info_type) = 0;
  922. IA64_LOG_LOCK_INIT(sal_info_type);
  924. // SAL will tell us the maximum size of any error record of this type
  925. max_size = ia64_sal_get_state_info_size(sal_info_type);
  927. // set up OS data structures to hold error info
  928. IA64_LOG_ALLOCATE(sal_info_type, max_size);
  929. memset(IA64_LOG_CURR_BUFFER(sal_info_type), 0, max_size);
  930. memset(IA64_LOG_NEXT_BUFFER(sal_info_type), 0, max_size);
  931. }
  933. /*
  934.  * ia64_log_get
  935.  *
  936.  * Get the current MCA log from SAL and copy it into the OS log buffer.
  937.  *
  938.  *  Inputs  :   info_type   (SAL_INFO_TYPE_{MCA,INIT,CMC,CPE})
  939.  *              prfunc      (fn ptr of log output function)
  940.  *  Outputs :   size        (total record length)
  941.  *
  942.  */
  943. u64
  944. ia64_log_get(int sal_info_type, prfunc_t prfunc)
  945. {
  946. sal_log_record_header_t     *log_buffer;
  947. u64                         total_len = 0;
  948. int                         s;
  950. IA64_LOG_LOCK(sal_info_type);
  952. /* Get the process state information */
  953. log_buffer = IA64_LOG_NEXT_BUFFER(sal_info_type);
  955. total_len = ia64_sal_get_state_info(sal_info_type, (u64 *)log_buffer);
  957. if (total_len) {
  958. IA64_LOG_INDEX_INC(sal_info_type);
  959. IA64_LOG_UNLOCK(sal_info_type);
  960. IA64_MCA_DEBUG("ia64_log_get: SAL error record type %d retrieved. "
  961.        "Record length = %ldn", sal_info_type, total_len);
  962. return total_len;
  963. } else {
  964. IA64_LOG_UNLOCK(sal_info_type);
  965. prfunc("ia64_log_get: No SAL error record available for type %dn", sal_info_type);
  966. return 0;
  967. }
  968. }
  970. /*
  971.  *  ia64_log_prt_oem_data
  972.  *
  973.  *  Print OEM specific data if included.
  974.  *
  975.  * Inputs   :   header_len  (length passed in section header)
  976.  *              sect_len    (default length of section type)
  977.  *              p_data      (ptr to data)
  978.  * prfunc (print function)
  979.  * Outputs : None
  980.  *
  981.  */
  982. void
  983. ia64_log_prt_oem_data (int header_len, int sect_len, u8 *p_data, prfunc_t prfunc)
  984. {
  985. int oem_data_len, i;
  987. if ((oem_data_len = header_len - sect_len) > 0) {
  988. prfunc(" OEM Specific Data:");
  989. for (i = 0; i < oem_data_len; i++, p_data++)
  990. prfunc(" %02x", *p_data);
  991. }
  992. prfunc("n");
  993. }
  995. /*
  996.  *  ia64_log_rec_header_print
  997.  *
  998.  *  Log info from the SAL error record header.
  999.  *
  1000.  *  Inputs  :   lh *    (ptr to SAL log error record header)
  1001.  *              prfunc  (fn ptr of log output function to use)
  1002.  *  Outputs :   None
  1003.  */
  1004. void
  1005. ia64_log_rec_header_print (sal_log_record_header_t *lh, prfunc_t prfunc)
  1006. {
  1007. char str_buf[32];
  1009. sprintf(str_buf, "%2d.%02d",
  1010. (lh->revision.major >> 4) * 10 + (lh->revision.major & 0xf),
  1011. (lh->revision.minor >> 4) * 10 + (lh->revision.minor & 0xf));
  1012. prfunc("+Err Record ID: %d    SAL Rev: %sn", lh->id, str_buf);
  1013. sprintf(str_buf, "%02d/%02d/%04d/ %02d:%02d:%02d",
  1014. (lh->timestamp.slh_month >> 4) * 10 +
  1015. (lh->timestamp.slh_month & 0xf),
  1016. (lh->timestamp.slh_day >> 4) * 10 +
  1017. (lh->timestamp.slh_day & 0xf),
  1018. (lh->timestamp.slh_century >> 4) * 1000 +
  1019. (lh->timestamp.slh_century & 0xf) * 100 +
  1020. (lh->timestamp.slh_year >> 4) * 10 +
  1021. (lh->timestamp.slh_year & 0xf),
  1022. (lh->timestamp.slh_hour >> 4) * 10 +
  1023. (lh->timestamp.slh_hour & 0xf),
  1024. (lh->timestamp.slh_minute >> 4) * 10 +
  1025. (lh->timestamp.slh_minute & 0xf),
  1026. (lh->timestamp.slh_second >> 4) * 10 +
  1027. (lh->timestamp.slh_second & 0xf));
  1028. prfunc("+Time: %s    Severity %dn", str_buf, lh->severity);
  1029. }
  1031. /*
  1032.  * ia64_log_processor_regs_print
  1033.  * Print the contents of the saved processor register(s) in the format
  1034.  * <reg_prefix>[<index>] <value>
  1035.  *
  1036.  * Inputs : regs (Register save buffer)
  1037.  * reg_num (# of registers)
  1038.  * reg_class (application/banked/control/bank1_general)
  1039.  * reg_prefix (ar/br/cr/b1_gr)
  1040.  * Outputs : None
  1041.  *
  1042.  */
  1043. void
  1044. ia64_log_processor_regs_print(u64 *regs,
  1045.       int reg_num,
  1046.       char *reg_class,
  1047.       char *reg_prefix,
  1048.       prfunc_t prfunc)
  1049. {
  1050. int i;
  1052. prfunc("+%s Registersn", reg_class);
  1053. for (i = 0; i < reg_num; i++)
  1054. prfunc("+ %s[%d] 0x%lxn", reg_prefix, i, regs[i]);
  1055. }
  1057. /*
  1058.  * ia64_log_processor_fp_regs_print
  1059.  *  Print the contents of the saved floating page register(s) in the format
  1060.  *      <reg_prefix>[<index>] <value>
  1061.  *
  1062.  * Inputs:  ia64_fpreg  (Register save buffer)
  1063.  *          reg_num     (# of registers)
  1064.  *          reg_class   (application/banked/control/bank1_general)
  1065.  *          reg_prefix  (ar/br/cr/b1_gr)
  1066.  * Outputs: None
  1067.  *
  1068.  */
  1069. void
  1070. ia64_log_processor_fp_regs_print (struct ia64_fpreg *regs,
  1071.                                   int               reg_num,
  1072.                                   char              *reg_class,
  1073.                                   char              *reg_prefix,
  1074.                                   prfunc_t          prfunc)
  1075. {
  1076. int i;
  1078. prfunc("+%s Registersn", reg_class);
  1079. for (i = 0; i < reg_num; i++)
  1080. prfunc("+ %s[%d] 0x%lx%016lxn", reg_prefix, i, regs[i].u.bits[1],
  1081.        regs[i].u.bits[0]);
  1082. }
  1084. static char *pal_mesi_state[] = {
  1085. "Invalid",
  1086. "Shared",
  1087. "Exclusive",
  1088. "Modified",
  1089. "Reserved1",
  1090. "Reserved2",
  1091. "Reserved3",
  1092. "Reserved4"
  1093. };
  1095. static char *pal_cache_op[] = {
  1096. "Unknown",
  1097. "Move in",
  1098. "Cast out",
  1099. "Coherency check",
  1100. "Internal",
  1101. "Instruction fetch",
  1102. "Implicit Writeback",
  1103. "Reserved"
  1104. };
  1106. /*
  1107.  * ia64_log_cache_check_info_print
  1108.  * Display the machine check information related to cache error(s).
  1109.  * Inputs:  i           (Multiple errors are logged, i - index of logged error)
  1110.  *          cc_info *   (Ptr to cache check info logged by the PAL and later
  1111.  *  captured by the SAL)
  1112.  *          prfunc      (fn ptr of print function to be used for output)
  1113.  * Outputs: None
  1114.  */
  1115. void
  1116. ia64_log_cache_check_info_print (int                      i,
  1117.                                  sal_log_mod_error_info_t *cache_check_info,
  1118.  prfunc_t prfunc)
  1119. {
  1120. pal_cache_check_info_t  *info;
  1121. u64                     target_addr;
  1123. if (!cache_check_info->valid.check_info) {
  1124. IA64_MCA_DEBUG("ia64_mca_log_print: invalid cache_check_info[%d]n",i);
  1125. return;                 /* If check info data not valid, skip it */
  1126. }
  1128. info        = (pal_cache_check_info_t *)&cache_check_info->check_info;
  1129. target_addr = cache_check_info->target_identifier;
  1131. prfunc("+ Cache check info[%d]n+", i);
  1132. prfunc("  Level: L%d,",info->level);
  1133. if (info->mv)
  1134. prfunc(" Mesi: %s,",pal_mesi_state[info->mesi]);
  1135. prfunc(" Index: %d,", info->index);
  1136. if (info->ic)
  1137. prfunc(" Cache: Instruction,");
  1138. if (info->dc)
  1139. prfunc(" Cache: Data,");
  1140. if (info->tl)
  1141. prfunc(" Line: Tag,");
  1142. if (info->dl)
  1143. prfunc(" Line: Data,");
  1144. prfunc(" Operation: %s,", pal_cache_op[info->op]);
  1145. if (info->wv)
  1146. prfunc(" Way: %d,", info->way);
  1147. if (cache_check_info->valid.target_identifier)
  1148. /* Hope target address is saved in target_identifier */
  1149. if (info->tv)
  1150. prfunc(" Target Addr: 0x%lx,", target_addr);
  1151. if (info->mc)
  1152. prfunc(" MC: Corrected");
  1153. prfunc("n");
  1154. }
  1156. /*
  1157.  * ia64_log_tlb_check_info_print
  1158.  * Display the machine check information related to tlb error(s).
  1159.  * Inputs:  i           (Multiple errors are logged, i - index of logged error)
  1160.  *          tlb_info *  (Ptr to machine check info logged by the PAL and later
  1161.  *  captured by the SAL)
  1162.  *          prfunc      (fn ptr of print function to be used for output)
  1163.  * Outputs: None
  1164.  */
  1165. void
  1166. ia64_log_tlb_check_info_print (int                      i,
  1167.                                sal_log_mod_error_info_t *tlb_check_info,
  1168.                                prfunc_t                 prfunc)
  1170. {
  1171. pal_tlb_check_info_t    *info;
  1173. if (!tlb_check_info->valid.check_info) {
  1174. IA64_MCA_DEBUG("ia64_mca_log_print: invalid tlb_check_info[%d]n", i);
  1175. return;                 /* If check info data not valid, skip it */
  1176. }
  1178. info = (pal_tlb_check_info_t *)&tlb_check_info->check_info;
  1180. prfunc("+ TLB Check Info [%d]n+", i);
  1181. if (info->itc)
  1182. prfunc("  Failure: Instruction Translation Cache");
  1183. if (info->dtc)
  1184. prfunc("  Failure: Data Translation Cache");
  1185. if (info->itr) {
  1186. prfunc("  Failure: Instruction Translation Register");
  1187. prfunc(" ,Slot: %d", info->tr_slot);
  1188. }
  1189. if (info->dtr) {
  1190. prfunc("  Failure: Data Translation Register");
  1191. prfunc(" ,Slot: %d", info->tr_slot);
  1192. }
  1193. if (info->mc)
  1194. prfunc(" ,MC: Corrected");
  1195. prfunc("n");
  1196. }
  1198. /*
  1199.  * ia64_log_bus_check_info_print
  1200.  * Display the machine check information related to bus error(s).
  1201.  * Inputs:  i           (Multiple errors are logged, i - index of logged error)
  1202.  *          bus_info *  (Ptr to machine check info logged by the PAL and later
  1203.  *  captured by the SAL)
  1204.  *          prfunc      (fn ptr of print function to be used for output)
  1205.  * Outputs: None
  1206.  */
  1207. void
  1208. ia64_log_bus_check_info_print (int                      i,
  1209.                                sal_log_mod_error_info_t *bus_check_info,
  1210.                                prfunc_t                 prfunc)
  1211. {
  1212. pal_bus_check_info_t *info;
  1213. u64         req_addr;   /* Address of the requestor of the transaction */
  1214. u64         resp_addr;  /* Address of the responder of the transaction */
  1215. u64         targ_addr;  /* Address where the data was to be delivered to */
  1216. /* or obtained from */
  1218. if (!bus_check_info->valid.check_info) {
  1219. IA64_MCA_DEBUG("ia64_mca_log_print: invalid bus_check_info[%d]n", i);
  1220. return;                 /* If check info data not valid, skip it */
  1221. }
  1223. info      = (pal_bus_check_info_t *)&bus_check_info->check_info;
  1224. req_addr  = bus_check_info->requestor_identifier;
  1225. resp_addr = bus_check_info->responder_identifier;
  1226. targ_addr = bus_check_info->target_identifier;
  1228. prfunc("+ BUS Check Info [%d]n+", i);
  1229. prfunc(" Status Info: %d", info->bsi);
  1230. prfunc(" ,Severity: %d", info->sev);
  1231. prfunc(" ,Transaction Type: %d", info->type);
  1232. prfunc(" ,Transaction Size: %d", info->size);
  1233. if (info->cc)
  1234. prfunc(" ,Cache-cache-transfer");
  1235. if (info->ib)
  1236. prfunc(" ,Error: Internal");
  1237. if (info->eb)
  1238. prfunc(" ,Error: External");
  1239. if (info->mc)
  1240. prfunc(" ,MC: Corrected");
  1241. if (info->tv)
  1242. prfunc(" ,Target Address: 0x%lx", targ_addr);
  1243. if (info->rq)
  1244. prfunc(" ,Requestor Address: 0x%lx", req_addr);
  1245. if (info->tv)
  1246. prfunc(" ,Responder Address: 0x%lx", resp_addr);
  1247. prfunc("n");
  1248. }
  1250. /*
  1251.  *  ia64_log_mem_dev_err_info_print
  1252.  *
  1253.  *  Format and log the platform memory device error record section data.
  1254.  *
  1255.  *  Inputs:  mem_dev_err_info * (Ptr to memory device error record section
  1256.  *                               returned by SAL)
  1257.  *           prfunc             (fn ptr of print function to be used for output)
  1258.  *  Outputs: None
  1259.  */
  1260. void
  1261. ia64_log_mem_dev_err_info_print (sal_log_mem_dev_err_info_t *mdei,
  1262.                                  prfunc_t                   prfunc)
  1263. {
  1264. prfunc("+ Mem Error Detail: ");
  1266. if (mdei->valid.error_status)
  1267. prfunc(" Error Status: %#lx,", mdei->error_status);
  1268. if (mdei->valid.physical_addr)
  1269. prfunc(" Physical Address: %#lx,", mdei->physical_addr);
  1270. if (mdei->valid.addr_mask)
  1271. prfunc(" Address Mask: %#lx,", mdei->addr_mask);
  1272. if (mdei->valid.node)
  1273. prfunc(" Node: %d,", mdei->node);
  1274. if (mdei->valid.card)
  1275. prfunc(" Card: %d,", mdei->card);
  1276. if (mdei->valid.module)
  1277. prfunc(" Module: %d,", mdei->module);
  1278. if (mdei->valid.bank)
  1279. prfunc(" Bank: %d,", mdei->bank);
  1280. if (mdei->valid.device)
  1281. prfunc(" Device: %d,", mdei->device);
  1282. if (mdei->valid.row)
  1283. prfunc(" Row: %d,", mdei->row);
  1284. if (mdei->valid.column)
  1285. prfunc(" Column: %d,", mdei->column);
  1286. if (mdei->valid.bit_position)
  1287. prfunc(" Bit Position: %d,", mdei->bit_position);
  1288. if (mdei->valid.target_id)
  1289. prfunc(" ,Target Address: %#lx,", mdei->target_id);
  1290. if (mdei->valid.requestor_id)
  1291. prfunc(" ,Requestor Address: %#lx,", mdei->requestor_id);
  1292. if (mdei->valid.responder_id)
  1293. prfunc(" ,Responder Address: %#lx,", mdei->responder_id);
  1294. if (mdei->valid.bus_spec_data)
  1295. prfunc(" Bus Specific Data: %#lx,", mdei->bus_spec_data);
  1296. prfunc("n");
  1298. if (mdei->valid.oem_id) {
  1299. u8  *p_data = &(mdei->oem_id[0]);
  1300. int i;
  1302. prfunc(" OEM Memory Controller ID:");
  1303. for (i = 0; i < 16; i++, p_data++)
  1304. prfunc(" %02x", *p_data);
  1305. prfunc("n");
  1306. }
  1308. if (mdei->valid.oem_data) {
  1309. platform_mem_dev_err_print((int)mdei->header.len,
  1310.       (int)sizeof(sal_log_mem_dev_err_info_t) - 1,
  1311.       &(mdei->oem_data[0]), prfunc);
  1312. }
  1313. }
  1315. /*
  1316.  *  ia64_log_sel_dev_err_info_print
  1317.  *
  1318.  *  Format and log the platform SEL device error record section data.
  1319.  *
  1320.  *  Inputs:  sel_dev_err_info * (Ptr to the SEL device error record section
  1321.  *                               returned by SAL)
  1322.  *           prfunc             (fn ptr of print function to be used for output)
  1323.  *  Outputs: None
  1324.  */
  1325. void
  1326. ia64_log_sel_dev_err_info_print (sal_log_sel_dev_err_info_t *sdei,
  1327.                                  prfunc_t                   prfunc)
  1328. {
  1329. int     i;
  1331. prfunc("+ SEL Device Error Detail: ");
  1333. if (sdei->valid.record_id)
  1334. prfunc(" Record ID: %#x", sdei->record_id);
  1335. if (sdei->valid.record_type)
  1336. prfunc(" Record Type: %#x", sdei->record_type);
  1337. prfunc(" Time Stamp: ");
  1338. for (i = 0; i < 4; i++)
  1339. prfunc("%1d", sdei->timestamp[i]);
  1340. if (sdei->valid.generator_id)
  1341. prfunc(" Generator ID: %#x", sdei->generator_id);
  1342. if (sdei->valid.evm_rev)
  1343. prfunc(" Message Format Version: %#x", sdei->evm_rev);
  1344. if (sdei->valid.sensor_type)
  1345. prfunc(" Sensor Type: %#x", sdei->sensor_type);
  1346. if (sdei->valid.sensor_num)
  1347. prfunc(" Sensor Number: %#x", sdei->sensor_num);
  1348. if (sdei->valid.event_dir)
  1349. prfunc(" Event Direction Type: %#x", sdei->event_dir);
  1350. if (sdei->valid.event_data1)
  1351. prfunc(" Data1: %#x", sdei->event_data1);
  1352. if (sdei->valid.event_data2)
  1353. prfunc(" Data2: %#x", sdei->event_data2);
  1354. if (sdei->valid.event_data3)
  1355. prfunc(" Data3: %#x", sdei->event_data3);
  1356. prfunc("n");
  1358. }
  1360. /*
  1361.  *  ia64_log_pci_bus_err_info_print
  1362.  *
  1363.  *  Format and log the platform PCI bus error record section data.
  1364.  *
  1365.  *  Inputs:  pci_bus_err_info * (Ptr to the PCI bus error record section
  1366.  *                               returned by SAL)
  1367.  *           prfunc             (fn ptr of print function to be used for output)
  1368.  *  Outputs: None
  1369.  */
  1370. void
  1371. ia64_log_pci_bus_err_info_print (sal_log_pci_bus_err_info_t *pbei,
  1372.                                  prfunc_t                   prfunc)
  1373. {
  1374. prfunc("+ PCI Bus Error Detail: ");
  1376. if (pbei->valid.err_status)
  1377. prfunc(" Error Status: %#lx", pbei->err_status);
  1378. if (pbei->valid.err_type)
  1379. prfunc(" Error Type: %#x", pbei->err_type);
  1380. if (pbei->valid.bus_id)
  1381. prfunc(" Bus ID: %#x", pbei->bus_id);
  1382. if (pbei->valid.bus_address)
  1383. prfunc(" Bus Address: %#lx", pbei->bus_address);
  1384. if (pbei->valid.bus_data)
  1385. prfunc(" Bus Data: %#lx", pbei->bus_data);
  1386. if (pbei->valid.bus_cmd)
  1387. prfunc(" Bus Command: %#lx", pbei->bus_cmd);
  1388. if (pbei->valid.requestor_id)
  1389. prfunc(" Requestor ID: %#lx", pbei->requestor_id);
  1390. if (pbei->valid.responder_id)
  1391. prfunc(" Responder ID: %#lx", pbei->responder_id);
  1392. if (pbei->valid.target_id)
  1393. prfunc(" Target ID: %#lx", pbei->target_id);
  1394. if (pbei->valid.oem_data)
  1395. prfunc("n");
  1397. if (pbei->valid.oem_data) {
  1398. platform_pci_bus_err_print((int)pbei->header.len,
  1399.       (int)sizeof(sal_log_pci_bus_err_info_t) - 1,
  1400.       &(pbei->oem_data[0]), prfunc);
  1401. }
  1402. }
  1404. /*
  1405.  *  ia64_log_smbios_dev_err_info_print
  1406.  *
  1407.  *  Format and log the platform SMBIOS device error record section data.
  1408.  *
  1409.  *  Inputs:  smbios_dev_err_info * (Ptr to the SMBIOS device error record
  1410.  *                                  section returned by SAL)
  1411.  *           prfunc             (fn ptr of print function to be used for output)
  1412.  *  Outputs: None
  1413.  */
  1414. void
  1415. ia64_log_smbios_dev_err_info_print (sal_log_smbios_dev_err_info_t *sdei,
  1416.                                     prfunc_t                      prfunc)
  1417. {
  1418. u8      i;
  1420. prfunc("+ SMBIOS Device Error Detail: ");
  1422. if (sdei->valid.event_type)
  1423. prfunc(" Event Type: %#x", sdei->event_type);
  1424. if (sdei->valid.time_stamp) {
  1425. prfunc(" Time Stamp: ");
  1426. for (i = 0; i < 6; i++)
  1427. prfunc("%d", sdei->time_stamp[i]);
  1428. }
  1429. if ((sdei->valid.data) && (sdei->valid.length)) {
  1430. prfunc(" Data: ");
  1431. for (i = 0; i < sdei->length; i++)
  1432. prfunc(" %02x", sdei->data[i]);
  1433. }
  1434. prfunc("n");
  1435. }
  1437. /*
  1438.  *  ia64_log_pci_comp_err_info_print
  1439.  *
  1440.  *  Format and log the platform PCI component error record section data.
  1441.  *
  1442.  *  Inputs:  pci_comp_err_info * (Ptr to the PCI component error record section
  1443.  *                                returned by SAL)
  1444.  *           prfunc             (fn ptr of print function to be used for output)
  1445.  *  Outputs: None
  1446.  */
  1447. void
  1448. ia64_log_pci_comp_err_info_print(sal_log_pci_comp_err_info_t *pcei,
  1449.  prfunc_t                     prfunc)
  1450. {
  1451. u32     n_mem_regs, n_io_regs;
  1452. u64     i, n_pci_data;
  1453. u64     *p_reg_data;
  1454. u8      *p_oem_data;
  1456. prfunc("+ PCI Component Error Detail: ");
  1458. if (pcei->valid.err_status)
  1459. prfunc(" Error Status: %#lxn", pcei->err_status);
  1460. if (pcei->valid.comp_info)
  1461. prfunc(" Component Info: Vendor Id = %#x, Device Id = %#x,"
  1462.        " Class Code = %#x, Seg/Bus/Dev/Func = %d/%d/%d/%dn",
  1463.        pcei->comp_info.vendor_id, pcei->comp_info.device_id,
  1464.        pcei->comp_info.class_code, pcei->comp_info.seg_num,
  1465.        pcei->comp_info.bus_num, pcei->comp_info.dev_num,
  1466.        pcei->comp_info.func_num);
  1468. n_mem_regs = (pcei->valid.num_mem_regs) ? pcei->num_mem_regs : 0;
  1469. n_io_regs =  (pcei->valid.num_io_regs)  ? pcei->num_io_regs  : 0;
  1470. p_reg_data = &(pcei->reg_data_pairs[0]);
  1471. p_oem_data = (u8 *)p_reg_data +
  1472. (n_mem_regs + n_io_regs) * 2 * sizeof(u64);
  1473. n_pci_data = p_oem_data - (u8 *)pcei;
  1475. if (n_pci_data > pcei->header.len) {
  1476. prfunc(" Invalid PCI Component Error Record format: length = %ld, "
  1477.        " Size PCI Data = %d, Num Mem-Map/IO-Map Regs = %ld/%ldn",
  1478.        pcei->header.len, n_pci_data, n_mem_regs, n_io_regs);
  1479. return;
  1480. }
  1482. if (n_mem_regs) {
  1483. prfunc(" Memory Mapped Registersn Address tValuen");
  1484. for (i = 0; i < pcei->num_mem_regs; i++) {
  1485. prfunc(" %#lx %#lxn", p_reg_data[0], p_reg_data[1]);
  1486. p_reg_data += 2;
  1487. }
  1488. }
  1489. if (n_io_regs) {
  1490. prfunc(" I/O Mapped Registersn Address tValuen");
  1491. for (i = 0; i < pcei->num_io_regs; i++) {
  1492. prfunc(" %#lx %#lxn", p_reg_data[0], p_reg_data[1]);
  1493. p_reg_data += 2;
  1494. }
  1495. }
  1496. if (pcei->valid.oem_data) {
  1497. platform_pci_comp_err_print((int)pcei->header.len, n_pci_data,
  1498.       p_oem_data, prfunc);
  1499. prfunc("n");
  1500. }
  1501. }
  1503. /*
  1504.  *  ia64_log_plat_specific_err_info_print
  1505.  *
  1506.  *  Format and log the platform specifie error record section data.
  1507.  *
  1508.  *  Inputs:  sel_dev_err_info * (Ptr to the platform specific error record
  1509.  *                               section returned by SAL)
  1510.  *           prfunc             (fn ptr of print function to be used for output)
  1511.  *  Outputs: None
  1512.  */
  1513. void
  1514. ia64_log_plat_specific_err_info_print (sal_log_plat_specific_err_info_t *psei,
  1515.                                        prfunc_t                         prfunc)
  1516. {
  1517. prfunc("+ Platform Specific Error Detail: ");
  1519. if (psei->valid.err_status)
  1520. prfunc(" Error Status: %#lx", psei->err_status);
  1521. if (psei->valid.guid) {
  1522. prfunc(" GUID: ");
  1523. ia64_log_prt_guid(&psei->guid, prfunc);
  1524. }
  1525. if (psei->valid.oem_data) {
  1526. platform_plat_specific_err_print((int)psei->header.len,
  1527.       (int)sizeof(sal_log_plat_specific_err_info_t) - 1,
  1528.       &(psei->oem_data[0]), prfunc);
  1529. }
  1530. prfunc("n");
  1531. }
  1533. /*
  1534.  *  ia64_log_host_ctlr_err_info_print
  1535.  *
  1536.  *  Format and log the platform host controller error record section data.
  1537.  *
  1538.  *  Inputs:  host_ctlr_err_info * (Ptr to the host controller error record
  1539.  *                                 section returned by SAL)
  1540.  *           prfunc             (fn ptr of print function to be used for output)
  1541.  *  Outputs: None
  1542.  */
  1543. void
  1544. ia64_log_host_ctlr_err_info_print (sal_log_host_ctlr_err_info_t *hcei,
  1545.                                    prfunc_t                     prfunc)
  1546. {
  1547. prfunc("+ Host Controller Error Detail: ");
  1549. if (hcei->valid.err_status)
  1550. prfunc(" Error Status: %#lx", hcei->err_status);
  1551. if (hcei->valid.requestor_id)
  1552. prfunc(" Requestor ID: %#lx", hcei->requestor_id);
  1553. if (hcei->valid.responder_id)
  1554. prfunc(" Responder ID: %#lx", hcei->responder_id);
  1555. if (hcei->valid.target_id)
  1556. prfunc(" Target ID: %#lx", hcei->target_id);
  1557. if (hcei->valid.bus_spec_data)
  1558. prfunc(" Bus Specific Data: %#lx", hcei->bus_spec_data);
  1559. if (hcei->valid.oem_data) {
  1560. platform_host_ctlr_err_print((int)hcei->header.len,
  1561.       (int)sizeof(sal_log_host_ctlr_err_info_t) - 1,
  1562.       &(hcei->oem_data[0]), prfunc);
  1563. }
  1564. prfunc("n");
  1565. }
  1567. /*
  1568.  *  ia64_log_plat_bus_err_info_print
  1569.  *
  1570.  *  Format and log the platform bus error record section data.
  1571.  *
  1572.  *  Inputs:  plat_bus_err_info * (Ptr to the platform bus error record section
  1573.  *                                returned by SAL)
  1574.  *           prfunc             (fn ptr of print function to be used for output)
  1575.  *  Outputs: None
  1576.  */
  1577. void
  1578. ia64_log_plat_bus_err_info_print (sal_log_plat_bus_err_info_t *pbei,
  1579.                                   prfunc_t                    prfunc)
  1580. {
  1581. prfunc("+ Platform Bus Error Detail: ");
  1583. if (pbei->valid.err_status)
  1584. prfunc(" Error Status: %#lx", pbei->err_status);
  1585. if (pbei->valid.requestor_id)
  1586. prfunc(" Requestor ID: %#lx", pbei->requestor_id);
  1587. if (pbei->valid.responder_id)
  1588. prfunc(" Responder ID: %#lx", pbei->responder_id);
  1589. if (pbei->valid.target_id)
  1590. prfunc(" Target ID: %#lx", pbei->target_id);
  1591. if (pbei->valid.bus_spec_data)
  1592. prfunc(" Bus Specific Data: %#lx", pbei->bus_spec_data);
  1593. if (pbei->valid.oem_data) {
  1594. platform_plat_bus_err_print((int)pbei->header.len,
  1595.       (int)sizeof(sal_log_plat_bus_err_info_t) - 1,
  1596.       &(pbei->oem_data[0]), prfunc);
  1597. }
  1598. prfunc("n");
  1599. }
  1601. /*
  1602.  *  ia64_log_proc_dev_err_info_print
  1603.  *
  1604.  *  Display the processor device error record.
  1605.  *
  1606.  *  Inputs:  sal_log_processor_info_t * (Ptr to processor device error record
  1607.  *                                       section body).
  1608.  *           prfunc                     (fn ptr of print function to be used
  1609.  *                                       for output).
  1610.  *  Outputs: None
  1611.  */
  1612. void
  1613. ia64_log_proc_dev_err_info_print (sal_log_processor_info_t  *slpi,
  1614.                                   prfunc_t                  prfunc)
  1615. {
  1616. #ifdef MCA_PRT_XTRA_DATA
  1617. size_t  d_len = slpi->header.len - sizeof(sal_log_section_hdr_t);
  1618. #endif
  1619. sal_processor_static_info_t *spsi;
  1620. int                         i;
  1621. sal_log_mod_error_info_t    *p_data;
  1623. prfunc("+Processor Device Error Info Sectionn");
  1625. #ifdef MCA_PRT_XTRA_DATA    // for test only @FVL
  1626. {
  1627. char    *p_data = (char *)&slpi->valid;
  1629. prfunc("SAL_PROC_DEV_ERR SECTION DATA:  Data buffer = %p, "
  1630.        "Data size = %ldn", (void *)p_data, d_len);
  1631. ia64_log_hexdump(p_data, d_len, prfunc);
  1632. prfunc("End of SAL_PROC_DEV_ERR SECTION DATAn");
  1633. }
  1634. #endif  // MCA_PRT_XTRA_DATA for test only @FVL
  1636. if (slpi->valid.proc_error_map)
  1637. prfunc(" Processor Error Map: %#lxn", slpi->proc_error_map);
  1639. if (slpi->valid.proc_state_param)
  1640. prfunc(" Processor State Param: %#lxn", slpi->proc_state_parameter);
  1642. if (slpi->valid.proc_cr_lid)
  1643. prfunc(" Processor LID: %#lxn", slpi->proc_cr_lid);
  1645. /*
  1646.  *  Note: March 2001 SAL spec states that if the number of elements in any
  1647.  *  of  the MOD_ERROR_INFO_STRUCT arrays is zero, the entire array is
  1648.  *  absent. Also, current implementations only allocate space for number of
  1649.  *  elements used.  So we walk the data pointer from here on.
  1650.  */
  1651. p_data = &slpi->cache_check_info[0];
  1653. /* Print the cache check information if any*/
  1654. for (i = 0 ; i < slpi->valid.num_cache_check; i++, p_data++)
  1655. ia64_log_cache_check_info_print(i, p_data, prfunc);
  1657. /* Print the tlb check information if any*/
  1658. for (i = 0 ; i < slpi->valid.num_tlb_check; i++, p_data++)
  1659. ia64_log_tlb_check_info_print(i, p_data, prfunc);
  1661. /* Print the bus check information if any*/
  1662. for (i = 0 ; i < slpi->valid.num_bus_check; i++, p_data++)
  1663. ia64_log_bus_check_info_print(i, p_data, prfunc);
  1665. /* Print the reg file check information if any*/
  1666. for (i = 0 ; i < slpi->valid.num_reg_file_check; i++, p_data++)
  1667. ia64_log_hexdump((u8 *)p_data, sizeof(sal_log_mod_error_info_t),
  1668.  prfunc);    /* Just hex dump for now */
  1670. /* Print the ms check information if any*/
  1671. for (i = 0 ; i < slpi->valid.num_ms_check; i++, p_data++)
  1672. ia64_log_hexdump((u8 *)p_data, sizeof(sal_log_mod_error_info_t),
  1673.  prfunc);    /* Just hex dump for now */
  1675. /* Print CPUID registers if any*/
  1676. if (slpi->valid.cpuid_info) {
  1677. u64     *p = (u64 *)p_data;
  1679. prfunc(" CPUID Regs: %#lx %#lx %#lx %#lxn", p[0], p[1], p[2], p[3]);
  1680. p_data++;
  1681. }
  1683. /* Print processor static info if any */
  1684. if (slpi->valid.psi_static_struct) {
  1685. spsi = (sal_processor_static_info_t *)p_data;
  1687. /* Print branch register contents if valid */
  1688. if (spsi->valid.br)
  1689. ia64_log_processor_regs_print(spsi->br, 8, "Branch", "br",
  1690.       prfunc);
  1692. /* Print control register contents if valid */
  1693. if (spsi->valid.cr)
  1694. ia64_log_processor_regs_print(spsi->cr, 128, "Control", "cr",
  1695.       prfunc);
  1697. /* Print application register contents if valid */
  1698. if (spsi->valid.ar)
  1699. ia64_log_processor_regs_print(spsi->ar, 128, "Application",
  1700.       "ar", prfunc);
  1702. /* Print region register contents if valid */
  1703. if (spsi->valid.rr)
  1704. ia64_log_processor_regs_print(spsi->rr, 8, "Region", "rr",
  1705.       prfunc);
  1707. /* Print floating-point register contents if valid */
  1708. if (spsi->valid.fr)
  1709. ia64_log_processor_fp_regs_print(spsi->fr, 128, "Floating-point", "fr",
  1710.  prfunc);
  1711. }
  1712. }
  1714. /*
  1715.  * ia64_log_processor_info_print
  1716.  *
  1717.  * Display the processor-specific information logged by PAL as a part
  1718.  * of MCA or INIT or CMC.
  1719.  *
  1720.  *  Inputs   :  lh      (Pointer of the sal log header which specifies the
  1721.  *                       format of SAL state info as specified by the SAL spec).
  1722.  *              prfunc  (fn ptr of print function to be used for output).
  1723.  * Outputs : None
  1724.  */
  1725. void
  1726. ia64_log_processor_info_print(sal_log_record_header_t *lh, prfunc_t prfunc)
  1727. {
  1728. sal_log_section_hdr_t       *slsh;
  1729. int                         n_sects;
  1730. int                         ercd_pos;
  1732. if (!lh)
  1733. return;
  1735. #ifdef MCA_PRT_XTRA_DATA    // for test only @FVL
  1736. ia64_log_prt_record_header(lh, prfunc);
  1737. #endif  // MCA_PRT_XTRA_DATA for test only @FVL
  1739. if ((ercd_pos = sizeof(sal_log_record_header_t)) >= lh->len) {
  1740. IA64_MCA_DEBUG("ia64_mca_log_print: "
  1741.        "truncated SAL CMC error record. len = %dn",
  1742.        lh->len);
  1743. return;
  1744. }
  1746. /* Print record header info */
  1747. ia64_log_rec_header_print(lh, prfunc);
  1749. for (n_sects = 0; (ercd_pos < lh->len); n_sects++, ercd_pos += slsh->len) {
  1750. /* point to next section header */
  1751. slsh = (sal_log_section_hdr_t *)((char *)lh + ercd_pos);
  1753. #ifdef MCA_PRT_XTRA_DATA    // for test only @FVL
  1754. ia64_log_prt_section_header(slsh, prfunc);
  1755. #endif  // MCA_PRT_XTRA_DATA for test only @FVL
  1757. if (verify_guid(&slsh->guid, &(SAL_PROC_DEV_ERR_SECT_GUID))) {
  1758. IA64_MCA_DEBUG("ia64_mca_log_print: unsupported record sectionn");
  1759. continue;
  1760. }
  1762. /*
  1763.  *  Now process processor device error record section
  1764.  */
  1765. ia64_log_proc_dev_err_info_print((sal_log_processor_info_t *)slsh,
  1766.  printk);
  1767. }
  1769. IA64_MCA_DEBUG("ia64_mca_log_print: "
  1770.        "found %d sections in SAL CMC error record. len = %dn",
  1771.        n_sects, lh->len);
  1772. if (!n_sects) {
  1773. prfunc("No Processor Device Error Info Section foundn");
  1774. return;
  1775. }
  1776. }
  1778. /*
  1779.  *  ia64_log_platform_info_print
  1780.  *
  1781.  *  Format and Log the SAL Platform Error Record.
  1782.  *
  1783.  *  Inputs  :   lh      (Pointer to the sal error record header with format
  1784.  *                       specified by the SAL spec).
  1785.  *              prfunc  (fn ptr of log output function to use)
  1786.  *  Outputs : platform error status
  1787.  */
  1788. int
  1789. ia64_log_platform_info_print (sal_log_record_header_t *lh, prfunc_t prfunc)
  1790. {
  1791. sal_log_section_hdr_t *slsh;
  1792. int n_sects;
  1793. int ercd_pos;
  1794. int platform_err = 0;
  1796. if (!lh)
  1797. return platform_err;
  1799. #ifdef MCA_PRT_XTRA_DATA    // for test only @FVL
  1800. ia64_log_prt_record_header(lh, prfunc);
  1801. #endif  // MCA_PRT_XTRA_DATA for test only @FVL
  1803. if ((ercd_pos = sizeof(sal_log_record_header_t)) >= lh->len) {
  1804. IA64_MCA_DEBUG("ia64_mca_log_print: "
  1805.        "truncated SAL error record. len = %dn",
  1806.        lh->len);
  1807. return platform_err;
  1808. }
  1810. /* Print record header info */
  1811. ia64_log_rec_header_print(lh, prfunc);
  1813. for (n_sects = 0; (ercd_pos < lh->len); n_sects++, ercd_pos += slsh->len) {
  1814. /* point to next section header */
  1815. slsh = (sal_log_section_hdr_t *)((char *)lh + ercd_pos);
  1817. #ifdef MCA_PRT_XTRA_DATA    // for test only @FVL
  1818. ia64_log_prt_section_header(slsh, prfunc);
  1820. if (efi_guidcmp(slsh->guid, SAL_PROC_DEV_ERR_SECT_GUID) != 0) {
  1821. size_t  d_len = slsh->len - sizeof(sal_log_section_hdr_t);
  1822. char    *p_data = (char *)&((sal_log_mem_dev_err_info_t *)slsh)->valid;
  1824. prfunc("Start of Platform Err Data Section:  Data buffer = %p, "
  1825.        "Data size = %ldn", (void *)p_data, d_len);
  1826. ia64_log_hexdump(p_data, d_len, prfunc);
  1827. prfunc("End of Platform Err Data Sectionn");
  1828. }
  1829. #endif  // MCA_PRT_XTRA_DATA for test only @FVL
  1831. /*
  1832.  *  Now process CPE error record section
  1833.  */
  1834. if (efi_guidcmp(slsh->guid, SAL_PROC_DEV_ERR_SECT_GUID) == 0) {
  1835. ia64_log_proc_dev_err_info_print((sal_log_processor_info_t *)slsh,
  1836.  prfunc);
  1837. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_MEM_DEV_ERR_SECT_GUID) == 0) {
  1838. platform_err = 1;
  1839. prfunc("+Platform Memory Device Error Info Sectionn");
  1840. ia64_log_mem_dev_err_info_print((sal_log_mem_dev_err_info_t *)slsh,
  1841. prfunc);
  1842. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_SEL_DEV_ERR_SECT_GUID) == 0) {
  1843. platform_err = 1;
  1844. prfunc("+Platform SEL Device Error Info Sectionn");
  1845. ia64_log_sel_dev_err_info_print((sal_log_sel_dev_err_info_t *)slsh,
  1846. prfunc);
  1847. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_PCI_BUS_ERR_SECT_GUID) == 0) {
  1848. platform_err = 1;
  1849. prfunc("+Platform PCI Bus Error Info Sectionn");
  1850. ia64_log_pci_bus_err_info_print((sal_log_pci_bus_err_info_t *)slsh,
  1851. prfunc);
  1852. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_SMBIOS_DEV_ERR_SECT_GUID) == 0) {
  1853. platform_err = 1;
  1854. prfunc("+Platform SMBIOS Device Error Info Sectionn");
  1855. ia64_log_smbios_dev_err_info_print((sal_log_smbios_dev_err_info_t *)slsh,
  1856.    prfunc);
  1857. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_PCI_COMP_ERR_SECT_GUID) == 0) {
  1858. platform_err = 1;
  1859. prfunc("+Platform PCI Component Error Info Sectionn");
  1860. ia64_log_pci_comp_err_info_print((sal_log_pci_comp_err_info_t *)slsh,
  1861.  prfunc);
  1862. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_SPECIFIC_ERR_SECT_GUID) == 0) {
  1863. platform_err = 1;
  1864. prfunc("+Platform Specific Error Info Sectionn");
  1865. ia64_log_plat_specific_err_info_print((sal_log_plat_specific_err_info_t *)
  1866.       slsh,
  1867.       prfunc);
  1868. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_HOST_CTLR_ERR_SECT_GUID) == 0) {
  1869. platform_err = 1;
  1870. prfunc("+Platform Host Controller Error Info Sectionn");
  1871. ia64_log_host_ctlr_err_info_print((sal_log_host_ctlr_err_info_t *)slsh,
  1872.   prfunc);
  1873. } else if (efi_guidcmp(slsh->guid, SAL_PLAT_BUS_ERR_SECT_GUID) == 0) {
  1874. platform_err = 1;
  1875. prfunc("+Platform Bus Error Info Sectionn");
  1876. ia64_log_plat_bus_err_info_print((sal_log_plat_bus_err_info_t *)slsh,
  1877.  prfunc);
  1878. } else {
  1879. IA64_MCA_DEBUG("ia64_mca_log_print: unsupported record sectionn");
  1880. continue;
  1881. }
  1882. }
  1884. IA64_MCA_DEBUG("ia64_mca_log_print: found %d sections in SAL error record. len = %dn",
  1885.        n_sects, lh->len);
  1886. if (!n_sects) {
  1887. prfunc("No Platform Error Info Sections foundn");
  1888. return platform_err;
  1889. }
  1890. return platform_err;
  1891. }
  1893. /*
  1894.  * ia64_log_print
  1895.  *
  1896.  *  Displays the contents of the OS error log information
  1897.  *
  1898.  *  Inputs   :  info_type   (SAL_INFO_TYPE_{MCA,INIT,CMC,CPE})
  1899.  *              prfunc      (fn ptr of log output function to use)
  1900.  * Outputs : platform error status
  1901.  */
  1902. int
  1903. ia64_log_print(int sal_info_type, prfunc_t prfunc)
  1904. {
  1905. int platform_err = 0;
  1907. switch(sal_info_type) {
  1908.       case SAL_INFO_TYPE_MCA:
  1909. prfunc("+BEGIN HARDWARE ERROR STATE AT MCAn");
  1910. platform_err = ia64_log_platform_info_print(IA64_LOG_CURR_BUFFER(sal_info_type), prfunc);
  1911. prfunc("+END HARDWARE ERROR STATE AT MCAn");
  1912. break;
  1913.       case SAL_INFO_TYPE_INIT:
  1914. prfunc("+MCA INIT ERROR LOG (UNIMPLEMENTED)n");
  1915. break;
  1916.       case SAL_INFO_TYPE_CMC:
  1917. prfunc("+BEGIN HARDWARE ERROR STATE AT CMCn");
  1918. ia64_log_processor_info_print(IA64_LOG_CURR_BUFFER(sal_info_type), prfunc);
  1919. prfunc("+END HARDWARE ERROR STATE AT CMCn");
  1920. break;
  1921.       case SAL_INFO_TYPE_CPE:
  1922. prfunc("+BEGIN HARDWARE ERROR STATE AT CPEn");
  1923. ia64_log_platform_info_print(IA64_LOG_CURR_BUFFER(sal_info_type), prfunc);
  1924. prfunc("+END HARDWARE ERROR STATE AT CPEn");
  1925. break;
  1926.       default:
  1927. prfunc("+MCA UNKNOWN ERROR LOG (UNIMPLEMENTED)n");
  1928. break;
  1929. }
  1930. return platform_err;
  1931. }