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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mca.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：54k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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