sal.h
上传用户:jlfgdled
上传日期:2013-04-10
资源大小:33168k
文件大小:24k
源码类别:

Linux/Unix编程

开发平台:

Unix_Linux

  1. #ifndef _ASM_IA64_SAL_H
  2. #define _ASM_IA64_SAL_H
  3. /*
  4.  * System Abstraction Layer definitions.
  5.  *
  6.  * This is based on version 2.5 of the manual "IA-64 System
  7.  * Abstraction Layer".
  8.  *
  9.  * Copyright (C) 2001 Intel
  10.  * Copyright (C) 2002 Jenna Hall <jenna.s.hall@intel.com>
  11.  * Copyright (C) 2001 Fred Lewis <frederick.v.lewis@intel.com>
  12.  * Copyright (C) 1998, 1999, 2001 Hewlett-Packard Co
  13.  * Copyright (C) 1998, 1999, 2001 David Mosberger-Tang <davidm@hpl.hp.com>
  14.  * Copyright (C) 1999 Srinivasa Prasad Thirumalachar <sprasad@sprasad.engr.sgi.com>
  15.  *
  16.  * 02/01/04 J. Hall Updated Error Record Structures to conform to July 2001
  17.  *     revision of the SAL spec.
  18.  * 01/01/03 fvlewis Updated Error Record Structures to conform with Nov. 2000
  19.  *                  revision of the SAL spec.
  20.  * 99/09/29 davidm Updated for SAL 2.6.
  21.  * 00/03/29 cfleck      Updated SAL Error Logging info for processor (SAL 2.6) 
  22.  *                      (plus examples of platform error info structures from smariset @ Intel)
  23.  */
  24. #include <linux/spinlock.h>
  25. #include <linux/efi.h>
  26. #include <asm/pal.h>
  27. #include <asm/system.h>
  28. #include <asm/fpu.h>
  29. extern spinlock_t sal_lock;
  30. /* SAL spec _requires_ eight args for each call. */
  31. #define __SAL_CALL(result,a0,a1,a2,a3,a4,a5,a6,a7)
  32. result = (*ia64_sal)(a0,a1,a2,a3,a4,a5,a6,a7)
  33. # define SAL_CALL(result,args...) do {
  34. unsigned long flags;
  35. spin_lock_irqsave(&sal_lock, flags);
  36. __SAL_CALL(result,args);
  37. spin_unlock_irqrestore(&sal_lock, flags);
  38. } while (0)
  39. #define SAL_SET_VECTORS 0x01000000
  40. #define SAL_GET_STATE_INFO 0x01000001
  41. #define SAL_GET_STATE_INFO_SIZE 0x01000002
  42. #define SAL_CLEAR_STATE_INFO 0x01000003
  43. #define SAL_MC_RENDEZ 0x01000004
  44. #define SAL_MC_SET_PARAMS 0x01000005
  45. #define SAL_REGISTER_PHYSICAL_ADDR 0x01000006
  46. #define SAL_CACHE_FLUSH 0x01000008
  47. #define SAL_CACHE_INIT 0x01000009
  48. #define SAL_PCI_CONFIG_READ 0x01000010
  49. #define SAL_PCI_CONFIG_WRITE 0x01000011
  50. #define SAL_FREQ_BASE 0x01000012
  51. #define SAL_UPDATE_PAL 0x01000020
  52. struct ia64_sal_retval {
  53. /*
  54.  * A zero status value indicates call completed without error.
  55.  * A negative status value indicates reason of call failure.
  56.  * A positive status value indicates success but an
  57.  * informational value should be printed (e.g., "reboot for
  58.  * change to take effect").
  59.  */
  60. s64 status;
  61. u64 v0;
  62. u64 v1;
  63. u64 v2;
  64. };
  65. typedef struct ia64_sal_retval (*ia64_sal_handler) (u64, ...);
  66. enum {
  67. SAL_FREQ_BASE_PLATFORM = 0,
  68. SAL_FREQ_BASE_INTERVAL_TIMER = 1,
  69. SAL_FREQ_BASE_REALTIME_CLOCK = 2
  70. };
  71. /*
  72.  * The SAL system table is followed by a variable number of variable
  73.  * length descriptors.  The structure of these descriptors follows
  74.  * below.
  75.  * The defininition follows SAL specs from July 2000
  76.  */
  77. struct ia64_sal_systab {
  78. u8 signature[4]; /* should be "SST_" */
  79. u32 size; /* size of this table in bytes */
  80. u8 sal_rev_minor;
  81. u8 sal_rev_major;
  82. u16 entry_count; /* # of entries in variable portion */
  83. u8 checksum;
  84. u8 reserved1[7];
  85. u8 sal_a_rev_minor;
  86. u8 sal_a_rev_major;
  87. u8 sal_b_rev_minor;
  88. u8 sal_b_rev_major;
  89. /* oem_id & product_id: terminating NUL is missing if string is exactly 32 bytes long. */
  90. u8 oem_id[32];
  91. u8 product_id[32]; /* ASCII product id  */
  92. u8 reserved2[8];
  93. };
  94. enum sal_systab_entry_type {
  95. SAL_DESC_ENTRY_POINT = 0,
  96. SAL_DESC_MEMORY = 1,
  97. SAL_DESC_PLATFORM_FEATURE = 2,
  98. SAL_DESC_TR = 3,
  99. SAL_DESC_PTC = 4,
  100. SAL_DESC_AP_WAKEUP = 5
  101. };
  102. /*
  103.  * Entry type: Size:
  104.  * 0 48
  105.  * 1 32
  106.  * 2 16
  107.  * 3 32
  108.  * 4 16
  109.  * 5 16
  110.  */
  111. #define SAL_DESC_SIZE(type) "604020402020"[(unsigned) type]
  112. typedef struct ia64_sal_desc_entry_point {
  113. u8 type;
  114. u8 reserved1[7];
  115. u64 pal_proc;
  116. u64 sal_proc;
  117. u64 gp;
  118. u8 reserved2[16];
  119. }ia64_sal_desc_entry_point_t;
  120. typedef struct ia64_sal_desc_memory {
  121. u8 type;
  122. u8 used_by_sal; /* needs to be mapped for SAL? */
  123. u8 mem_attr; /* current memory attribute setting */
  124. u8 access_rights; /* access rights set up by SAL */
  125. u8 mem_attr_mask; /* mask of supported memory attributes */
  126. u8 reserved1;
  127. u8 mem_type; /* memory type */
  128. u8 mem_usage; /* memory usage */
  129. u64 addr; /* physical address of memory */
  130. u32 length; /* length (multiple of 4KB pages) */
  131. u32 reserved2;
  132. u8 oem_reserved[8];
  133. } ia64_sal_desc_memory_t;
  134. #define IA64_SAL_PLATFORM_FEATURE_BUS_LOCK (1 << 0)
  135. #define IA64_SAL_PLATFORM_FEATURE_IRQ_REDIR_HINT (1 << 1)
  136. #define IA64_SAL_PLATFORM_FEATURE_IPI_REDIR_HINT (1 << 2)
  137. #define IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT   (1 << 3)
  138. typedef struct ia64_sal_desc_platform_feature {
  139. u8 type;
  140. u8 feature_mask;
  141. u8 reserved1[14];
  142. } ia64_sal_desc_platform_feature_t;
  143. typedef struct ia64_sal_desc_tr {
  144. u8 type;
  145. u8 tr_type; /* 0 == instruction, 1 == data */
  146. u8 regnum; /* translation register number */
  147. u8 reserved1[5];
  148. u64 addr; /* virtual address of area covered */
  149. u64 page_size; /* encoded page size */
  150. u8 reserved2[8];
  151. } ia64_sal_desc_tr_t;
  152. typedef struct ia64_sal_desc_ptc {
  153. u8 type;
  154. u8 reserved1[3];
  155. u32 num_domains; /* # of coherence domains */
  156. u64 domain_info; /* physical address of domain info table */
  157. } ia64_sal_desc_ptc_t;
  158. typedef struct ia64_sal_ptc_domain_info {
  159. u64 proc_count; /* number of processors in domain */
  160. u64 proc_list; /* physical address of LID array */
  161. } ia64_sal_ptc_domain_info_t;
  162. typedef struct ia64_sal_ptc_domain_proc_entry {
  163. u64 id  : 8; /* id of processor */
  164. u64 eid : 8; /* eid of processor */
  165. } ia64_sal_ptc_domain_proc_entry_t;
  166. #define IA64_SAL_AP_EXTERNAL_INT 0
  167. typedef struct ia64_sal_desc_ap_wakeup {
  168. u8 type;
  169. u8 mechanism; /* 0 == external interrupt */
  170. u8 reserved1[6];
  171. u64 vector; /* interrupt vector in range 0x10-0xff */
  172. } ia64_sal_desc_ap_wakeup_t ;
  173. extern ia64_sal_handler ia64_sal;
  174. extern struct ia64_sal_desc_ptc *ia64_ptc_domain_info;
  175. extern const char *ia64_sal_strerror (long status);
  176. extern void ia64_sal_init (struct ia64_sal_systab *sal_systab);
  177. /* SAL information type encodings */
  178. enum {
  179. SAL_INFO_TYPE_MCA = 0, /* Machine check abort information */
  180.         SAL_INFO_TYPE_INIT = 1, /* Init information */
  181.         SAL_INFO_TYPE_CMC   =       2,  /* Corrected machine check information */
  182.         SAL_INFO_TYPE_CPE   =       3   /* Corrected platform error information */
  183. };
  184. /* Encodings for machine check parameter types */
  185. enum {
  186.         SAL_MC_PARAM_RENDEZ_INT = 1, /* Rendezevous interrupt */
  187.         SAL_MC_PARAM_RENDEZ_WAKEUP  =   2,  /* Wakeup */
  188.         SAL_MC_PARAM_CPE_INT        =   3   /* Corrected Platform Error Int */
  189. };
  190. /* Encodings for rendezvous mechanisms */
  191. enum {
  192.         SAL_MC_PARAM_MECHANISM_INT = 1, /* Use interrupt */
  193.         SAL_MC_PARAM_MECHANISM_MEM = 2 /* Use memory synchronization variable*/
  194. };
  195. /* Encodings for vectors which can be registered by the OS with SAL */
  196. enum {
  197. SAL_VECTOR_OS_MCA = 0,
  198. SAL_VECTOR_OS_INIT = 1,
  199. SAL_VECTOR_OS_BOOT_RENDEZ = 2
  200. };
  201. /* Encodings for mca_opt parameter sent to SAL_MC_SET_PARAMS */
  202. #define SAL_MC_PARAM_RZ_ALWAYS 0x1
  203. #define SAL_MC_PARAM_BINIT_ESCALATE 0x10
  204. /*
  205. ** Definition of the SAL Error Log from the SAL spec
  206. */
  207. /* SAL Error Record Section GUID Definitions */
  208. #define SAL_PROC_DEV_ERR_SECT_GUID  
  209.     EFI_GUID ( 0xe429faf1, 0x3cb7, 0x11d4,  0xbc, 0xa7, 0x0, 0x80, 
  210.                     0xc7, 0x3c, 0x88, 0x81 )
  211. #define SAL_PLAT_MEM_DEV_ERR_SECT_GUID  
  212.     EFI_GUID(  0xe429faf2, 0x3cb7, 0x11d4,  0xbc, 0xa7, 0x0, 0x80, 
  213.                     0xc7, 0x3c, 0x88, 0x81 )
  214. #define SAL_PLAT_SEL_DEV_ERR_SECT_GUID  
  215.     EFI_GUID(  0xe429faf3, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  216.                     0xc7, 0x3c, 0x88, 0x81 )
  217. #define SAL_PLAT_PCI_BUS_ERR_SECT_GUID  
  218.     EFI_GUID(  0xe429faf4, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  219.                     0xc7, 0x3c, 0x88, 0x81 )
  220. #define SAL_PLAT_SMBIOS_DEV_ERR_SECT_GUID  
  221.     EFI_GUID(  0xe429faf5, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  222.                     0xc7, 0x3c, 0x88, 0x81 )
  223. #define SAL_PLAT_PCI_COMP_ERR_SECT_GUID  
  224.     EFI_GUID(  0xe429faf6, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  225.                     0xc7, 0x3c, 0x88, 0x81 )
  226. #define SAL_PLAT_SPECIFIC_ERR_SECT_GUID  
  227.     EFI_GUID(  0xe429faf7, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  228.                     0xc7, 0x3c, 0x88, 0x81 )
  229. #define SAL_PLAT_HOST_CTLR_ERR_SECT_GUID  
  230.     EFI_GUID(  0xe429faf8, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  231.                     0xc7, 0x3c, 0x88, 0x81 )
  232. #define SAL_PLAT_BUS_ERR_SECT_GUID  
  233.     EFI_GUID(  0xe429faf9, 0x3cb7, 0x11d4, 0xbc, 0xa7, 0x0, 0x80, 
  234.                     0xc7, 0x3c, 0x88, 0x81 )
  235. #define MAX_CACHE_ERRORS 6
  236. #define MAX_TLB_ERRORS 6
  237. #define MAX_BUS_ERRORS 1
  238. /* Definition of version  according to SAL spec for logging purposes */
  239. typedef struct sal_log_revision
  240. {
  241.     u8  minor;              /* BCD (0..99) */
  242.     u8  major;              /* BCD (0..99) */
  243. } sal_log_revision_t;
  244. /* Definition of timestamp according to SAL spec for logging purposes */
  245. typedef struct sal_log_timestamp
  246. {
  247. u8 slh_second; /* Second (0..59) */
  248.     u8 slh_minute;      /* Minute (0..59) */
  249.     u8 slh_hour;        /* Hour (0..23) */
  250.     u8 slh_reserved;
  251.     u8 slh_day;         /* Day (1..31) */
  252.     u8 slh_month;       /* Month (1..12) */
  253.     u8 slh_year;        /* Year (00..99) */
  254.     u8 slh_century;     /* Century (19, 20, 21, ...) */
  255. } sal_log_timestamp_t;
  256. /* Definition of log record  header structures */
  257. typedef struct sal_log_record_header
  258. {
  259.     u64                 id;             /* Unique monotonically increasing ID */
  260.     sal_log_revision_t  revision;       /* Major and Minor revision of header */
  261.     u16                 severity;       /* Error Severity */
  262.     u32                 len;            /* Length of this error log in bytes */
  263.     sal_log_timestamp_t timestamp;      /* Timestamp */
  264.     efi_guid_t          platform_guid;  /* Unique OEM Platform ID */
  265. } sal_log_record_header_t;
  266. /* Definition of log section header structures */
  267. typedef struct sal_log_sec_header
  268. {
  269.     efi_guid_t          guid;       /* Unique Section ID */
  270.     sal_log_revision_t  revision;   /* Major and Minor revision of Section */
  271.     u16                 reserved;
  272.     u32                 len;        /* Section length */
  273. } sal_log_section_hdr_t;
  274. typedef struct sal_log_mod_error_info
  275. {
  276.     struct
  277.     {
  278.         u64 check_info              : 1,
  279.             requestor_identifier    : 1,
  280.             responder_identifier    : 1,
  281.             target_identifier       : 1,
  282.             precise_ip              : 1,
  283.             reserved                : 59;
  284.     } valid;
  285.     u64 check_info;
  286.     u64 requestor_identifier;
  287.     u64 responder_identifier;
  288.     u64 target_identifier;
  289.     u64 precise_ip;
  290. } sal_log_mod_error_info_t;
  291. typedef struct sal_processor_static_info
  292. {
  293.     struct
  294.     {
  295.         u64 minstate        : 1,
  296.             br              : 1,
  297.             cr              : 1,
  298.             ar              : 1,
  299.             rr              : 1,
  300.             fr              : 1,
  301.             reserved        : 58;
  302.     } valid;
  303.     pal_min_state_area_t    min_state_area;
  304.     u64                     br[8];
  305.     u64                     cr[128];
  306.     u64                     ar[128];
  307.     u64                     rr[8];
  308.     struct ia64_fpreg       fr[128];
  309. } sal_processor_static_info_t;
  310. typedef struct sal_log_processor_info
  311. {
  312.     sal_log_section_hdr_t       header;
  313.     struct
  314.     {
  315.         u64 proc_error_map      : 1,
  316.             proc_state_param    : 1,
  317.             proc_cr_lid         : 1,
  318.             psi_static_struct   : 1,
  319.             num_cache_check     : 4,
  320.             num_tlb_check       : 4,
  321.             num_bus_check       : 4,
  322.             num_reg_file_check  : 4,
  323.             num_ms_check        : 4,
  324.             cpuid_info          : 1,
  325.             reserved1           : 39;
  326.     } valid;
  327.     u64                         proc_error_map;
  328.     u64                         proc_state_parameter;
  329.     u64                         proc_cr_lid;
  330.     sal_log_mod_error_info_t    cache_check_info[16];
  331.     sal_log_mod_error_info_t    tlb_check_info[16];
  332.     sal_log_mod_error_info_t    bus_check_info[16];
  333.     sal_log_mod_error_info_t    reg_file_check_info[16];
  334.     sal_log_mod_error_info_t    ms_check_info[16];
  335.     struct
  336.     {
  337.         u64 regs[5];
  338.         u64 reserved;
  339.     } cpuid_info;
  340.     sal_processor_static_info_t processor_static_info;
  341. } sal_log_processor_info_t;
  342. /* platform error log structures */
  343. typedef struct sal_log_mem_dev_err_info
  344. {
  345.     sal_log_section_hdr_t   header;
  346.     struct
  347.     {
  348.         u64 error_status    : 1,
  349.             physical_addr   : 1,
  350.             addr_mask       : 1,
  351.             node            : 1,
  352.             card            : 1,
  353.             module          : 1,
  354.             bank            : 1,
  355.             device          : 1,
  356.             row             : 1,
  357.             column          : 1,
  358.             bit_position    : 1,
  359.             requestor_id    : 1,
  360.             responder_id    : 1,
  361.             target_id       : 1,
  362.             bus_spec_data   : 1,
  363.             oem_id          : 1,
  364.             oem_data        : 1,
  365.             reserved        : 47;
  366.     } valid;
  367.     u64             error_status;
  368.     u64             physical_addr;
  369.     u64             addr_mask;
  370.     u16             node;
  371.     u16             card;
  372.     u16             module;
  373.     u16             bank;
  374.     u16             device;
  375.     u16             row;
  376.     u16             column;
  377.     u16             bit_position;
  378.     u64             requestor_id;
  379.     u64             responder_id;
  380.     u64             target_id;
  381.     u64             bus_spec_data;
  382.     u8              oem_id[16];
  383.     u8              oem_data[1];        /* Variable length data */
  384. } sal_log_mem_dev_err_info_t;
  385. typedef struct sal_log_sel_dev_err_info
  386. {
  387.     sal_log_section_hdr_t   header;
  388.     struct
  389.     {
  390.         u64 record_id       : 1,
  391.             record_type     : 1,
  392.             generator_id    : 1,
  393.             evm_rev         : 1,
  394.             sensor_type     : 1,
  395.             sensor_num      : 1,
  396.             event_dir       : 1,
  397.             event_data1     : 1,
  398.             event_data2     : 1,
  399.             event_data3     : 1,
  400.             reserved        : 54;
  401.     } valid;
  402.     u16             record_id;
  403.     u8              record_type;
  404.     u8              timestamp[4];
  405.     u16             generator_id;
  406.     u8              evm_rev;
  407.     u8              sensor_type;
  408.     u8              sensor_num;
  409.     u8              event_dir;
  410.     u8              event_data1;
  411.     u8              event_data2;
  412.     u8              event_data3;
  413. } sal_log_sel_dev_err_info_t;
  414. typedef struct sal_log_pci_bus_err_info
  415. {
  416.     sal_log_section_hdr_t   header;
  417.     struct
  418.     {
  419.         u64 err_status      : 1,
  420.             err_type        : 1,
  421.             bus_id          : 1,
  422.             bus_address     : 1,
  423.             bus_data        : 1,
  424.             bus_cmd         : 1,
  425.             requestor_id    : 1,
  426.             responder_id    : 1,
  427.             target_id       : 1,
  428.             oem_data        : 1,
  429.             reserved        : 54;
  430.     } valid;
  431.     u64             err_status;
  432.     u16             err_type;
  433.     u16             bus_id;
  434.     u32             reserved;
  435.     u64             bus_address;
  436.     u64             bus_data;
  437.     u64             bus_cmd;
  438.     u64             requestor_id;
  439.     u64             responder_id;
  440.     u64             target_id;
  441.     u8              oem_data[1];        /* Variable length data */
  442. } sal_log_pci_bus_err_info_t;
  443. typedef struct sal_log_smbios_dev_err_info
  444. {
  445.     sal_log_section_hdr_t   header;
  446.     struct
  447.     {
  448.         u64 event_type      : 1,
  449.             length          : 1,
  450.             time_stamp      : 1,
  451.             data            : 1,
  452.             reserved1       : 60;
  453.     } valid;
  454.     u8              event_type;
  455.     u8              length;
  456.     u8              time_stamp[6];
  457.     u8              data[1];  // data of variable length, length == slsmb_length
  458. } sal_log_smbios_dev_err_info_t;
  459. typedef struct sal_log_pci_comp_err_info
  460. {
  461.     sal_log_section_hdr_t   header;
  462.     struct
  463.     {
  464.         u64 err_status      : 1,
  465.             comp_info       : 1,
  466.             num_mem_regs    : 1,
  467.             num_io_regs     : 1,
  468.             reg_data_pairs  : 1,
  469.             oem_data        : 1,
  470.             reserved        : 58;
  471.     } valid;
  472.     u64             err_status;
  473.     struct
  474.     {
  475.         u16 vendor_id;
  476.         u16 device_id;
  477. u8  class_code[3];
  478.         u8  func_num;
  479.         u8  dev_num;
  480.         u8  bus_num;
  481.         u8  seg_num;
  482.         u8  reserved[5];
  483.     }               comp_info;
  484.     u32             num_mem_regs;
  485.     u32             num_io_regs;
  486.     u64             reg_data_pairs[1];
  487.     /* array of address/data register pairs is num_mem_regs + num_io_regs
  488.        elements long.  Each array element consists of a u64 address followed
  489.        by a u64 data value.  The oem_data array immediately follows the the
  490.        reg_data_pairs array */
  491.     u8              oem_data[1];        /* Variable length data */
  492. } sal_log_pci_comp_err_info_t;
  493. typedef struct sal_log_plat_specific_err_info
  494. {
  495.     sal_log_section_hdr_t   header;
  496.     struct
  497.     {
  498.         u64 err_status      : 1,
  499.             guid            : 1,
  500.             oem_data        : 1,
  501.             reserved        : 61;
  502.     } valid;
  503.     u64             err_status;
  504.     efi_guid_t      guid;
  505.     u8              oem_data[1];      /* platform specific variable length data */
  506. } sal_log_plat_specific_err_info_t;
  507. typedef struct sal_log_host_ctlr_err_info
  508. {
  509.     sal_log_section_hdr_t   header;
  510.     struct
  511.     {
  512.         u64 err_status      : 1,
  513.             requestor_id    : 1,
  514.             responder_id    : 1,
  515.             target_id       : 1,
  516.             bus_spec_data   : 1,
  517.             oem_data        : 1,
  518.             reserved        : 58;
  519.     } valid;
  520.     u64             err_status;
  521.     u64             requestor_id;
  522.     u64             responder_id;
  523.     u64             target_id;
  524.     u64             bus_spec_data;
  525.     u8              oem_data[1];        /* Variable length OEM data */
  526. } sal_log_host_ctlr_err_info_t;
  527. typedef struct sal_log_plat_bus_err_info
  528. {
  529.     sal_log_section_hdr_t   header;
  530.     struct
  531.     {
  532.         u64 err_status      : 1,
  533.             requestor_id    : 1,
  534.             responder_id    : 1,
  535.             target_id       : 1,
  536.             bus_spec_data   : 1,
  537.             oem_data        : 1,
  538.             reserved        : 58;
  539.     } valid;
  540.     u64             err_status;
  541.     u64             requestor_id;
  542.     u64             responder_id;
  543.     u64             target_id;
  544.     u64             bus_spec_data;
  545.     u8              oem_data[1];        /* Variable length OEM data */
  546. } sal_log_plat_bus_err_info_t;
  547. /* Overall platform error section structure */
  548. typedef union sal_log_platform_err_info
  549. {
  550.     sal_log_mem_dev_err_info_t          mem_dev_err;
  551.     sal_log_sel_dev_err_info_t          sel_dev_err;
  552.     sal_log_pci_bus_err_info_t          pci_bus_err;
  553.     sal_log_smbios_dev_err_info_t       smbios_dev_err;
  554.     sal_log_pci_comp_err_info_t         pci_comp_err;
  555.     sal_log_plat_specific_err_info_t    plat_specific_err;
  556.     sal_log_host_ctlr_err_info_t        host_ctlr_err;
  557.     sal_log_plat_bus_err_info_t         plat_bus_err;
  558. } sal_log_platform_err_info_t;
  559. /* SAL log over-all, multi-section error record structure (processor+platform) */
  560. typedef struct err_rec
  561. {
  562.     sal_log_record_header_t     sal_elog_header;
  563.     sal_log_processor_info_t    proc_err;
  564.     sal_log_platform_err_info_t plat_err;
  565.     u8                          oem_data_pad[1024];
  566. } ia64_err_rec_t;
  567. /*
  568.  * Now define a couple of inline functions for improved type checking
  569.  * and convenience.
  570.  */
  571. static inline long
  572. ia64_sal_freq_base (unsigned long which, unsigned long *ticks_per_second,
  573.     unsigned long *drift_info)
  574. {
  575. struct ia64_sal_retval isrv;
  576. SAL_CALL(isrv, SAL_FREQ_BASE, which, 0, 0, 0, 0, 0, 0);
  577. *ticks_per_second = isrv.v0;
  578. *drift_info = isrv.v1;
  579. return isrv.status;
  580. }
  581. /* Flush all the processor and platform level instruction and/or data caches */
  582. static inline s64
  583. ia64_sal_cache_flush (u64 cache_type)
  584. {
  585. struct ia64_sal_retval isrv;
  586. SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0);
  587. return isrv.status;
  588. }
  589. /* Initialize all the processor and platform level instruction and data caches */
  590. static inline s64
  591. ia64_sal_cache_init (void)
  592. {
  593. struct ia64_sal_retval isrv;
  594. SAL_CALL(isrv, SAL_CACHE_INIT, 0, 0, 0, 0, 0, 0, 0);
  595. return isrv.status;
  596. }
  597. /* Clear the processor and platform information logged by SAL with respect to the 
  598.  * machine state at the time of MCA's, INITs, CMCs, or CPEs.
  599.  */
  600. static inline s64
  601. ia64_sal_clear_state_info (u64 sal_info_type)
  602. {
  603. struct ia64_sal_retval isrv;
  604.     SAL_CALL(isrv, SAL_CLEAR_STATE_INFO, sal_info_type, 0,
  605.              0, 0, 0, 0, 0);
  606. return isrv.status;
  607. }
  608. /* Get the processor and platform information logged by SAL with respect to the machine
  609.  * state at the time of the MCAs, INITs, CMCs, or CPEs.
  610.  */
  611. static inline u64
  612. ia64_sal_get_state_info (u64 sal_info_type, u64 *sal_info)
  613. {
  614. struct ia64_sal_retval isrv;
  615. SAL_CALL(isrv, SAL_GET_STATE_INFO, sal_info_type, 0,
  616.          sal_info, 0, 0, 0, 0);
  617. if (isrv.status)
  618. return 0;
  619. return isrv.v0;
  620. }
  621. /* Get the maximum size of the information logged by SAL with respect to the machine 
  622.  * state at the time of MCAs, INITs, CMCs, or CPEs.
  623.  */
  624. static inline u64
  625. ia64_sal_get_state_info_size (u64 sal_info_type)
  626. {
  627. struct ia64_sal_retval isrv;
  628.     SAL_CALL(isrv, SAL_GET_STATE_INFO_SIZE, sal_info_type, 0,
  629.              0, 0, 0, 0, 0);
  630. if (isrv.status)
  631. return 0;
  632. return isrv.v0;
  633. }
  634. /* Causes the processor to go into a spin loop within SAL where SAL awaits a wakeup
  635.  * from the monarch processor.
  636.  */
  637. static inline s64
  638. ia64_sal_mc_rendez (void)
  639. {
  640. struct ia64_sal_retval isrv;
  641. SAL_CALL(isrv, SAL_MC_RENDEZ, 0, 0, 0, 0, 0, 0, 0);
  642. return isrv.status;
  643. }
  644. /* Allow the OS to specify the interrupt number to be used by SAL to interrupt OS during
  645.  * the machine check rendezvous sequence as well as the mechanism to wake up the 
  646.  * non-monarch processor at the end of machine check processing.
  647.  */
  648. static inline s64
  649. ia64_sal_mc_set_params (u64 param_type, u64 i_or_m, u64 i_or_m_val, u64 timeout, u64 rz_always)
  650. {
  651. struct ia64_sal_retval isrv;
  652. SAL_CALL(isrv, SAL_MC_SET_PARAMS, param_type, i_or_m, i_or_m_val, timeout, rz_always, 0, 0);
  653. return isrv.status;
  654. }
  655. /* Read from PCI configuration space */
  656. static inline s64
  657. ia64_sal_pci_config_read (u64 pci_config_addr, u64 size, u64 *value)
  658. {
  659. struct ia64_sal_retval isrv;
  660. SAL_CALL(isrv, SAL_PCI_CONFIG_READ, pci_config_addr, size, 0, 0, 0, 0, 0);
  661. if (value)
  662. *value = isrv.v0;
  663. return isrv.status;
  664. }
  665. /* Write to PCI configuration space */
  666. static inline s64
  667. ia64_sal_pci_config_write (u64 pci_config_addr, u64 size, u64 value)
  668. {
  669. struct ia64_sal_retval isrv;
  670. SAL_CALL(isrv, SAL_PCI_CONFIG_WRITE, pci_config_addr, size, value,
  671.          0, 0, 0, 0);
  672. return isrv.status;
  673. }
  674. /*
  675.  * Register physical addresses of locations needed by SAL when SAL
  676.  * procedures are invoked in virtual mode.
  677.  */
  678. static inline s64
  679. ia64_sal_register_physical_addr (u64 phys_entry, u64 phys_addr)
  680. {
  681. struct ia64_sal_retval isrv;
  682. SAL_CALL(isrv, SAL_REGISTER_PHYSICAL_ADDR, phys_entry, phys_addr,
  683.          0, 0, 0, 0, 0);
  684. return isrv.status;
  685. }
  686. /* Register software dependent code locations within SAL. These locations are handlers
  687.  * or entry points where SAL will pass control for the specified event. These event
  688.  * handlers are for the bott rendezvous, MCAs and INIT scenarios.
  689.  */
  690. static inline s64
  691. ia64_sal_set_vectors (u64 vector_type,
  692.       u64 handler_addr1, u64 gp1, u64 handler_len1,
  693.       u64 handler_addr2, u64 gp2, u64 handler_len2)
  694. {
  695. struct ia64_sal_retval isrv;
  696. SAL_CALL(isrv, SAL_SET_VECTORS, vector_type,
  697. handler_addr1, gp1, handler_len1,
  698. handler_addr2, gp2, handler_len2);
  699. return isrv.status;
  700. }
  701. /* Update the contents of PAL block in the non-volatile storage device */
  702. static inline s64
  703. ia64_sal_update_pal (u64 param_buf, u64 scratch_buf, u64 scratch_buf_size,
  704.      u64 *error_code, u64 *scratch_buf_size_needed)
  705. {
  706. struct ia64_sal_retval isrv;
  707. SAL_CALL(isrv, SAL_UPDATE_PAL, param_buf, scratch_buf, scratch_buf_size,
  708.          0, 0, 0, 0);
  709. if (error_code)
  710. *error_code = isrv.v0;
  711. if (scratch_buf_size_needed)
  712. *scratch_buf_size_needed = isrv.v1;
  713. return isrv.status;
  714. }
  715. extern unsigned long sal_platform_features;
  716. #endif /* _ASM_IA64_PAL_H */