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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
pentiumLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：39k
源码类别：

VxWorks

开发平台：

C/C++

pentiumLib.c：源码内容
  1. /* pentiumLib.c - Pentium and Pentium[234] library */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01f,20nov01,hdn  doc clean up for 5.5
  10. 01e,01nov01,hdn  added pentiumMsrInit() and pentiumMcaEnable().
  11. 01d,21aug01,hdn  added P5/P6 PMC routines from T31 ver 01e
  12.  fixed a bug in pentiumMtrr[GS]et() (spr 68103)
  13. 01c,24mar99,jdi  doc: added basic formatting cmds, particularly .CS/.CE
  14.  to set off code snippets as per standard practice.
  15. 01b,17apr98,hdn  fixed typo.
  16. 01b,17apr98,hdn  added documentation.
  17. 01a,09jul97,hdn  written.
  18. */
  20. /*
  21. DESCRIPTION
  22. This library provides Pentium and Pentium[234] specific routines. 
  24. .SS "MTRR (Memory Type Range Register)"
  25. MTRR (Memory Type Range Register) are a new feature introduced in the 
  26. P6 family processor that allow the processor to optimize memory operations
  27. for different types of memory, such as RAM, ROM, frame buffer memory, and
  28. memory-mapped IO.  MTRRs configure an internal map of how physical address 
  29. ranges are mapped to various types of memory.  The processor uses this internal
  30. map to determine the cacheability of various physical memory locations and the
  31. optimal method of accessing memory locations.  For example, if a memory
  32. location is specified in an MTRR as write-through memory, the processor handles
  33. accesses to this location as follows.  It reads data from that location in 
  34. lines and caches the read data or maps all writes to that location to the bus
  35. and updates the cache to maintain cache coherency.  In mapping the physical
  36. address space with MTRRs, the processor recognizes five types of memory:
  37. uncacheable (UC), write-combining (WC), write-through (WT),
  38. write-protected (WP), and write-back (WB).
  40. There is one table - sysMtrr[] in sysLib.c - and four routines to interface
  41. the MTRR.  These four routines are:
  42. .CS
  43.   void pentiumMtrrEnable (void)
  45.   void pentiumMtrrDisable (void)
  47.   STATUS pentiumMtrrGet
  48.       (
  49.       MTRR * pMtrr /@ MTRR table @/
  50.       )
  52.   STATUS pentiumMtrrSet (void)
  53.       (
  54.       MTRR * pMtrr /@ MTRR table @/
  55.       )
  56. .CE
  57. pentiumMtrrEnable() enables MTRR, pentiumMtrrDisable() disables MTRR.
  58. pentiumMtrrGet() gets MTRRs to the specified MTRR table.
  59. pentiumMtrrGet() sets MTRRs from the specified MTRR table.
  60. The MTRR table is defined as follows:
  61. .CS
  62. typedef struct mtrr_fix         /@ MTRR - fixed range register @/
  63.     {
  64.     char type[8]; /@ address range: [0]=0-7 ... [7]=56-63 @/
  65.     } MTRR_FIX;
  67. typedef struct mtrr_var         /@ MTRR - variable range register @/
  68.     {
  69.     long long int base; /@ base register @/
  70.     long long int mask; /@ mask register @/
  71.     } MTRR_VAR;
  73. typedef struct mtrr             /@ MTRR @/
  74.     {
  75.     int cap[2];                 /@ MTRR cap register @/
  76.     int deftype[2];             /@ MTRR defType register @/
  77.     MTRR_FIX fix[11];           /@ MTRR fixed range registers @/
  78.     MTRR_VAR var[8];            /@ MTRR variable range registers @/
  79.     } MTRR;
  80. .CE
  81. Fixed Range Register's type array can be one of following memory types.
  82. MTRR_UC (uncacheable), MTRR_WC (write-combining), 
  83. MTRR_WT (write-through), MTRR_WP (write-protected), and MTRR_WB (write-back).
  84. MTRR is enabled in sysHwInit().
  86. .SS "PMC (Performance Monitoring Counters)"
  87. The P5 and P6 family of processors has two performance-monitoring counters
  88. for use in monitoring internal hardware operations. These counters are
  89. duration or event counters that can be programmed to count any of approximately
  90. 100 different types of events, such as the number of instructions decoded,
  91. number of interrupts received, or number of cache loads. However, the set of
  92. events can be counted with PMC is different in the P5 and P6 family of
  93. processors; and the locations and bit difinitions of the related counter and
  94. control registers are also different. So there are two set of PMC routines,
  95. one for P6 family and one for P5 family respectively in pentiumALib. For
  96. convenience, the PMC routines here are acting as wrappers to those routines
  97. in pentiumALib. They will call the P5 or P6 routine depending on the processor 
  98. type.
  100. There are twelve routines to interface the PMC.  These twelve routines are:
  101. .CS
  102.   STATUS pentiumPmcStart
  103.          (
  104.          int pmcEvtSel0;        /@ performance event select register 0 @/
  105.          int pmcEvtSel1;        /@ performance event select register 1 @/
  106.          )
  107.   STATUS pentiumPmcStart0
  108.          (
  109.          int pmcEvtSel0;        /@ performance event select register 0 @/
  110.          )
  111.   STATUS pentiumPmcStart1
  112.          (
  113.          int pmcEvtSel1;        /@ performance event select register 1 @/
  114.          )
  115.   void   pentiumPmcStop (void)
  116.   void   pentiumPmcStop0 (void)
  117.   void   pentiumPmcStop1 (void)
  118.   void   pentiumPmcGet
  119.          (
  120.          long long int * pPmc0; /@ performance monitoring counter 0 @/
  121.          long long int * pPmc1; /@ performance monitoring counter 1 @/
  122.          )
  123.   void   pentiumPmcGet0
  124.          (
  125.          long long int * pPmc0; /@ performance monitoring counter 0 @/
  126.          )
  127.   void   pentiumPmcGet1
  128.          (
  129.          long long int * pPmc1; /@ performance monitoring counter 1 @/
  130.          )
  131.   void   pentiumPmcReset (void)
  132.   void   pentiumPmcReset0 (void)
  133.   void   pentiumPmcReset1 (void)
  134. .CE
  135. pentiumPmcStart() starts both PMC0 and PMC1. pentiumPmcStart0() starts PMC0,
  136. and pentiumPmcStart1() starts PMC1.
  137. pentiumPmcStop() stops both PMC0 and PMC1. pentiumPmcStop0() stops PMC0, 
  138. and pentiumPmcStop1() stops PMC1.
  139. pentiumPmcGet() gets contents of PMC0 and PMC1.  pentiumPmcGet0() gets
  140. contents of PMC0, and pentiumPmcGet1() gets contents of PMC1.
  141. pentiumPmcReset() resets both PMC0 and PMC1.  pentiumPmcReset0() resets
  142. PMC0, and pentiumPmcReset1() resets PMC1.
  143. PMC is enabled in sysHwInit().  Selected events in the default configuration
  144. are PMC0 = number of hardware interrupts received and PMC1 = number of
  145. misaligned data memory references.
  147. .SS "MSR (Model Specific Registers)"
  148. The P5(Pentium), P6(PentiumPro, II, III), and P7(Pentium4) family processors
  149. contain a model-specific registers (MSRs).  These registers are implement-
  150. ation specific.  They are provided to control a variety of hardware and 
  151. software related features including the performance monitoring, the debug
  152. extensions, the machine check architecture, etc.
  154. There is one routine - pentiumMsrInit() - to initialize all the MSRs.
  155. This routine initializes all the MSRs in the processor and works on either
  156. P5, P6 or P7 family processors.
  158. .SS "MCA (Machine Check Architecture)"
  159. The P5(Pentium), P6(PentiumPro, II, III), and P7(Pentium4) family processors
  160. have a machine-check architecture that provides a mechanism for detecting 
  161. and reporting hardware (machine) errors, such as system bus errors, ECC
  162. errors, parity errors, cache errors and TLB errors.  It consists of a set
  163. of model-specific registers (MSRs) that are used to set up machine checking 
  164. and additional banks of MSRs for recording errors that are detected.
  165. The processor signals the detection of a machine-check error by generating
  166. a machine-check exception, which an abort class exception.  The implement-
  167. ation of the machine-check architecture, does not ordinarily permit the 
  168. processor to be restarted reliably after generating a machine-check 
  169. exception.  However, the machine-check exception handler can collect
  170. information about the machine-check error from the machine-check MSRs.
  172. There is one routine - pentiumMcaEnable() - to enable or disable the MCA.
  173. The routine enables or disables 1) the Machine Check Architecture and its 
  174. Error Reporting register banks 2) the Machine Check Exception by toggling
  175. the MCE bit in the CR4.  This routine works on either P5, P6 or P7 family.
  177. SEE ALSO:
  178. .I PentiumALib, "Pentium, Pentium[234] Family Developer's Manual"
  179. */
  181. /* includes */
  183. #include "vxWorks.h"
  184. #include "regs.h"
  185. #include "arch/i86/pentiumLib.h"
  186. #include "vxLib.h"
  187. #include "intLib.h"
  188. #include "cacheLib.h"
  191. /* defines */
  193. #define IA32_MISC_ENABLE_DEFAULT (MSC_FAST_STRING_ENABLE | 
  194.  MSC_THERMAL_MON_ENABLE)
  195. #define MSR_ROB_CR_BKUPTMPDR6_DEFAULT 0x4
  198. /* externals */
  200. IMPORT CPUID sysCpuId;
  201. IMPORT int sysProcessor;
  204. /* globals */
  206. PENTIUM_MSR pentiumMsrP5[] = {
  207.     {MSR_P5_MC_ADDR, "P5_MC_ADDR"},
  208.     {MSR_P5_MC_TYPE, "P5_MC_TYPE"},
  209.     {MSR_TSC, "TSC"},
  210.     {MSR_CESR, "CESR"},
  211.     {MSR_CTR0, "CTR0"},
  212.     {MSR_CTR1, "CTR1"},
  213.     };
  214. INT32 pentiumMsrP5NumEnt = NELEMENTS (pentiumMsrP5);
  216. PENTIUM_MSR pentiumMsrP6[] = {
  217.     {MSR_P5_MC_ADDR, "P5_MC_ADDR"},
  218.     {MSR_P5_MC_TYPE, "P5_MC_TYPE"},
  219.     {MSR_TSC, "TSC"},
  220.     {IA32_PLATFORM_ID, "IA32_PLATFORM_ID"},
  221.     {MSR_APICBASE, "APICBASE"},
  222.     {MSR_EBL_CR_POWERON, "EBL_CR_POWERON"},
  223.     {MSR_TEST_CTL, "TEST_CTL"},
  224.     /* RW triggers the loading of the microcode update.
  225.     {MSR_BIOS_UPDT_TRIG, "BIOS_UPDT_TRIG"},
  226.     */
  227.     {MSR_BBL_CR_D0, "BBL_CR_D0"},
  228.     {MSR_BBL_CR_D1, "BBL_CR_D1"},
  229.     {MSR_BBL_CR_D2, "BBL_CR_D2"},
  230.     {MSR_BIOS_SIGN, "BIOS_SIGN"},
  231.     {MSR_PERFCTR0, "PERFCTR0"},
  232.     {MSR_PERFCTR1, "PERFCTR1"},
  233.     {MSR_MTRR_CAP, "MTRR_CAP"},
  234.     {MSR_BBL_CR_ADDR, "BBL_CR_ADDR"},
  235.     {MSR_BBL_CR_DECC, "BBL_CR_DECC"},
  236.     {MSR_BBL_CR_CTL, "BBL_CR_CTL"},
  237.     /* write only with Data=0, reading generates GPF exception.
  238.     {MSR_BBL_CR_TRIG, "BBL_CR_TRIG"},
  239.     */
  240.     {MSR_BBL_CR_BUSY, "BBL_CR_BUSY"},
  241.     {MSR_BBL_CR_CTL3, "BBL_CR_CTL3"},
  242.     {MSR_SYSENTER_CS, "SYSENTER_CS"},
  243.     {MSR_SYSENTER_ESP, "SYSENTER_ESP"},
  244.     {MSR_SYSENTER_EIP, "SYSENTER_EIP"},
  245.     {MSR_MCG_CAP, "MCG_CAP"},
  246.     {MSR_MCG_STATUS, "MCG_STATUS"},
  247.     /* generate GPF exception if not present.
  248.     {MSR_MCG_CTL, "MCG_CTL"},
  249.     */
  250.     {MSR_EVNTSEL0, "EVNTSEL0"},
  251.     {MSR_EVNTSEL1, "EVNTSEL1"},
  252.     {MSR_DEBUGCTLMSR, "DEBUGCTLMSR"},
  253.     {MSR_LASTBRANCH_FROMIP, "LASTBRANCH_FROMIP"},
  254.     {MSR_LASTBRANCH_TOIP, "LASTBRANCH_TOIP"},
  255.     {MSR_LASTINT_FROMIP, "LASTINT_FROMIP"},
  256.     {MSR_LASTINT_TOIP, "LASTINT_TOIP"},
  257.     {MSR_ROB_CR_BKUPTMPDR6, "ROB_CR_BKUPTMPDR6"},
  258.     {MSR_MTRR_PHYS_BASE0, "MTRR_PHYS_BASE0"},
  259.     {MSR_MTRR_PHYS_MASK0, "MTRR_PHYS_MASK0"},
  260.     {MSR_MTRR_PHYS_BASE1, "MTRR_PHYS_BASE1"},
  261.     {MSR_MTRR_PHYS_MASK1, "MTRR_PHYS_MASK1"},
  262.     {MSR_MTRR_PHYS_BASE2, "MTRR_PHYS_BASE2"},
  263.     {MSR_MTRR_PHYS_MASK2, "MTRR_PHYS_MASK2"},
  264.     {MSR_MTRR_PHYS_BASE3, "MTRR_PHYS_BASE3"},
  265.     {MSR_MTRR_PHYS_MASK3, "MTRR_PHYS_MASK3"},
  266.     {MSR_MTRR_PHYS_BASE4, "MTRR_PHYS_BASE4"},
  267.     {MSR_MTRR_PHYS_MASK4, "MTRR_PHYS_MASK4"},
  268.     {MSR_MTRR_PHYS_BASE5, "MTRR_PHYS_BASE5"},
  269.     {MSR_MTRR_PHYS_MASK5, "MTRR_PHYS_MASK5"},
  270.     {MSR_MTRR_PHYS_BASE6, "MTRR_PHYS_BASE6"},
  271.     {MSR_MTRR_PHYS_MASK6, "MTRR_PHYS_MASK6"},
  272.     {MSR_MTRR_PHYS_BASE7, "MTRR_PHYS_BASE7"},
  273.     {MSR_MTRR_PHYS_MASK7, "MTRR_PHYS_MASK7"},
  274.     {MSR_MTRR_FIX_00000, "MTRR_FIX_00000"},
  275.     {MSR_MTRR_FIX_80000, "MTRR_FIX_80000"},
  276.     {MSR_MTRR_FIX_A0000, "MTRR_FIX_A0000"},
  277.     {MSR_MTRR_FIX_C0000, "MTRR_FIX_C0000"},
  278.     {MSR_MTRR_FIX_C8000, "MTRR_FIX_C8000"},
  279.     {MSR_MTRR_FIX_D0000, "MTRR_FIX_D0000"},
  280.     {MSR_MTRR_FIX_D8000, "MTRR_FIX_D8000"},
  281.     {MSR_MTRR_FIX_E0000, "MTRR_FIX_E0000"},
  282.     {MSR_MTRR_FIX_E8000, "MTRR_FIX_E8000"},
  283.     {MSR_MTRR_FIX_F0000, "MTRR_FIX_F0000"},
  284.     {MSR_MTRR_FIX_F8000, "MTRR_FIX_F8000"},
  285.     {MSR_MTRR_DEFTYPE, "MTRR_DEFTYPE"},
  286.     /* use pentiumMcaEnable() or pentiumMcaShow()
  287.     {MSR_MC0_CTL, "MC0_CTL"},
  288.     {MSR_MC0_STATUS, "MC0_STATUS"},
  289.     {MSR_MC0_ADDR, "MC0_ADDR"},
  290.     {MSR_MC0_MISC, "MC0_MISC"},
  291.     {MSR_MC1_CTL, "MC1_CTL"},
  292.     {MSR_MC1_STATUS, "MC1_STATUS"},
  293.     {MSR_MC1_ADDR, "MC1_ADDR"},
  294.     {MSR_MC1_MISC, "MC1_MISC"},
  295.     {MSR_MC2_CTL, "MC2_CTL"},
  296.     {MSR_MC2_STATUS, "MC2_STATUS"},
  297.     {MSR_MC2_ADDR, "MC2_ADDR"},
  298.     {MSR_MC2_MISC, "MC2_MISC"},
  299.     {MSR_MC4_CTL, "MC4_CTL"},
  300.     {MSR_MC4_STATUS, "MC4_STATUS"},
  301.     {MSR_MC4_ADDR, "MC4_ADDR"},
  302.     {MSR_MC4_MISC, "MC4_MISC"},
  303.     {MSR_MC3_CTL, "MC3_CTL"},
  304.     {MSR_MC3_STATUS, "MC3_STATUS"},
  305.     {MSR_MC3_ADDR, "MC3_ADDR"},
  306.     {MSR_MC3_MISC, "MC3_MISC"},
  307.     */
  308.     };
  309. INT32 pentiumMsrP6NumEnt = NELEMENTS (pentiumMsrP6);
  311. PENTIUM_MSR pentiumMsrP7[] = {
  312.     {IA32_P5_MC_ADDR, "IA32_P5_MC_ADDR"},
  313.     {IA32_P5_MC_TYPE, "IA32_P5_MC_TYPE"},
  314.     {IA32_TIME_STAMP_COUNTER, "IA32_TIME_STAMP_COUNTER"},
  315.     {IA32_PLATFORM_ID, "IA32_PLATFORM_ID"},
  316.     {IA32_APIC_BASE, "IA32_APIC_BASE"},
  317.     {MSR_EBC_HARD_POWERON, "EBC_HARD_POWERON"},
  318.     {MSR_EBC_SOFT_POWERON, "EBC_SOFT_POWERON"},
  319.     {MSR_EBC_FREQUENCY_ID, "EBC_FREQUENCY_ID"},
  320.     /* RW triggers the loading of the microcode update.
  321.     {IA32_BIOS_UPDT_TRIG, "IA32_BIOS_UPDT_TRIG"},
  322.      */
  323.     {IA32_BIOS_SIGN_ID, "IA32_BIOS_SIGN_ID"},
  324.     {IA32_MTRRCAP, "IA32_MTRRCAP"},
  325.     {IA32_MISC_CTL, "IA32_MISC_CTL"},
  326.     {IA32_SYSENTER_CS, "IA32_SYSENTER_CS"},
  327.     {IA32_SYSENTER_ESP, "IA32_SYSENTER_ESP"},
  328.     {IA32_SYSENTER_EIP, "IA32_SYSENTER_EIP"},
  329.     {IA32_MCG_CAP, "IA32_MCG_CAP"},
  330.     {IA32_MCG_STATUS, "IA32_MCG_STATUS"},
  331.     /* generate GPF exception if not present.
  332.     {IA32_MCG_CTL, "IA32_MCG_CTL"},
  333.     {IA32_MCG_EAX, "IA32_MCG_EAX"},
  334.     {IA32_MCG_EBX, "IA32_MCG_EBX"},
  335.     {IA32_MCG_ECX, "IA32_MCG_ECX"},
  336.     {IA32_MCG_EDX, "IA32_MCG_EDX"},
  337.     {IA32_MCG_ESI, "IA32_MCG_ESI"},
  338.     {IA32_MCG_EDI, "IA32_MCG_EDI"},
  339.     {IA32_MCG_EBP, "IA32_MCG_EBP"},
  340.     {IA32_MCG_ESP, "IA32_MCG_ESP"},
  341.     {IA32_MCG_EFLAGS, "IA32_MCG_EFLAGS"},
  342.     {IA32_MCG_EIP, "IA32_MCG_EIP"},
  343.     {IA32_MCG_MISC, "IA32_MCG_MISC"},
  344.      */
  345.     {IA32_THERM_CONTROL, "IA32_THERM_CONTROL"},
  346.     {IA32_THERM_INTERRUPT, "IA32_THERM_INTERRUPT"},
  347.     {IA32_THERM_STATUS, "IA32_THERM_STATUS"},
  348.     {IA32_MISC_ENABLE, "IA32_MISC_ENABLE"},
  349.     {MSR_LER_FROM_LIP, "LER_FROM_LIP"},
  350.     {MSR_LER_TO_LIP, "LER_TO_LIP"},
  351.     {IA32_DEBUGCTL, "IA32_DEBUGCTL"},
  352.     {MSR_LASTBRANCH_TOS, "LASTBRANCH_TOS"},
  353.     {MSR_LASTBRANCH_0, "LASTBRANCH_0"},
  354.     {MSR_LASTBRANCH_1, "LASTBRANCH_1"},
  355.     {MSR_LASTBRANCH_2, "LASTBRANCH_2"},
  356.     {MSR_LASTBRANCH_3, "LASTBRANCH_3"},
  357.     {IA32_MTRR_PHYSBASE0, "IA32_MTRR_PHYSBASE0"},
  358.     {IA32_MTRR_PHYSMASK0, "IA32_MTRR_PHYSMASK0"},
  359.     {IA32_MTRR_PHYSBASE1, "IA32_MTRR_PHYSBASE1"},
  360.     {IA32_MTRR_PHYSMASK1, "IA32_MTRR_PHYSMASK1"},
  361.     {IA32_MTRR_PHYSBASE2, "IA32_MTRR_PHYSBASE2"},
  362.     {IA32_MTRR_PHYSMASK2, "IA32_MTRR_PHYSMASK2"},
  363.     {IA32_MTRR_PHYSBASE3, "IA32_MTRR_PHYSBASE3"},
  364.     {IA32_MTRR_PHYSMASK3, "IA32_MTRR_PHYSMASK3"},
  365.     {IA32_MTRR_PHYSBASE4, "IA32_MTRR_PHYSBASE4"},
  366.     {IA32_MTRR_PHYSMASK4, "IA32_MTRR_PHYSMASK4"},
  367.     {IA32_MTRR_PHYSBASE5, "IA32_MTRR_PHYSBASE5"},
  368.     {IA32_MTRR_PHYSMASK5, "IA32_MTRR_PHYSMASK5"},
  369.     {IA32_MTRR_PHYSBASE6, "IA32_MTRR_PHYSBASE6"},
  370.     {IA32_MTRR_PHYSMASK6, "IA32_MTRR_PHYSMASK6"},
  371.     {IA32_MTRR_PHYSBASE7, "IA32_MTRR_PHYSBASE7"},
  372.     {IA32_MTRR_PHYSMASK7, "IA32_MTRR_PHYSMASK7"},
  373.     {IA32_MTRR_FIX64K_00000, "IA32_MTRR_FIX64K_00000"},
  374.     {IA32_MTRR_FIX16K_80000, "IA32_MTRR_FIX16K_80000"},
  375.     {IA32_MTRR_FIX16K_A0000, "IA32_MTRR_FIX16K_A0000"},
  376.     {IA32_MTRR_FIX4K_C0000, "IA32_MTRR_FIX4K_C0000"},
  377.     {IA32_MTRR_FIX4K_C8000, "IA32_MTRR_FIX4K_C8000"},
  378.     {IA32_MTRR_FIX4K_D0000, "IA32_MTRR_FIX4K_D0000"},
  379.     {IA32_MTRR_FIX4K_D8000, "IA32_MTRR_FIX4K_D8000"},
  380.     {IA32_MTRR_FIX4K_E0000, "IA32_MTRR_FIX4K_E0000"},
  381.     {IA32_MTRR_FIX4K_E8000, "IA32_MTRR_FIX4K_E8000"},
  382.     {IA32_MTRR_FIX4K_F8000, "IA32_MTRR_FIX4K_F8000"},
  383.     {IA32_CR_PAT, "IA32_CR_PAT"},
  384.     {IA32_MTRR_DEF_TYPE, "IA32_MTRR_DEF_TYPE"},
  385.     {MSR_BPU_COUNTER0, "BPU_COUNTER0"},
  386.     {MSR_BPU_COUNTER1, "BPU_COUNTER1"},
  387.     {MSR_BPU_COUNTER2, "BPU_COUNTER2"},
  388.     {MSR_BPU_COUNTER3, "BPU_COUNTER3"},
  389.     {MSR_MS_COUNTER0, "MS_COUNTER0"},
  390.     {MSR_MS_COUNTER1, "MS_COUNTER1"},
  391.     {MSR_MS_COUNTER2, "MS_COUNTER2"},
  392.     {MSR_MS_COUNTER3, "MS_COUNTER3"},
  393.     {MSR_FLAME_COUNTER0, "FLAME_COUNTER0"},
  394.     {MSR_FLAME_COUNTER1, "FLAME_COUNTER1"},
  395.     {MSR_FLAME_COUNTER2, "FLAME_COUNTER2"},
  396.     {MSR_FLAME_COUNTER3, "FLAME_COUNTER3"},
  397.     {MSR_IQ_COUNTER0, "IQ_COUNTER0"},
  398.     {MSR_IQ_COUNTER1, "IQ_COUNTER1"},
  399.     {MSR_IQ_COUNTER2, "IQ_COUNTER2"},
  400.     {MSR_IQ_COUNTER3, "IQ_COUNTER3"},
  401.     {MSR_IQ_COUNTER4, "IQ_COUNTER4"},
  402.     {MSR_IQ_COUNTER5, "IQ_COUNTER5"},
  403.     {MSR_BPU_CCCR0, "BPU_CCCR0"},
  404.     {MSR_BPU_CCCR1, "BPU_CCCR1"},
  405.     {MSR_BPU_CCCR2, "BPU_CCCR2"},
  406.     {MSR_BPU_CCCR3, "BPU_CCCR3"},
  407.     {MSR_MS_CCCR0, "MS_CCCR0"},
  408.     {MSR_MS_CCCR1, "MS_CCCR1"},
  409.     {MSR_MS_CCCR2, "MS_CCCR2"},
  410.     {MSR_MS_CCCR3, "MS_CCCR3"},
  411.     {MSR_FLAME_CCCR0, "FLAME_CCCR0"},
  412.     {MSR_FLAME_CCCR1, "FLAME_CCCR1"},
  413.     {MSR_FLAME_CCCR2, "FLAME_CCCR2"},
  414.     {MSR_FLAME_CCCR3, "FLAME_CCCR3"},
  415.     {MSR_IQ_CCCR0, "IQ_CCCR0"},
  416.     {MSR_IQ_CCCR1, "IQ_CCCR1"},
  417.     {MSR_IQ_CCCR2, "IQ_CCCR2"},
  418.     {MSR_IQ_CCCR3, "IQ_CCCR3"},
  419.     {MSR_IQ_CCCR4, "IQ_CCCR4"},
  420.     {MSR_IQ_CCCR5, "IQ_CCCR5"},
  421.     {MSR_BSU_ESCR0, "BSU_ESCR0"},
  422.     {MSR_BSU_ESCR1, "BSU_ESCR1"},
  423.     {MSR_FSB_ESCR0, "FSB_ESCR0"},
  424.     {MSR_FSB_ESCR1, "FSB_ESCR1"},
  425.     {MSR_FIRM_ESCR0, "FIRM_ESCR0"},
  426.     {MSR_FIRM_ESCR1, "FIRM_ESCR1"},
  427.     {MSR_FLAME_ESCR0, "FLAME_ESCR0"},
  428.     {MSR_FLAME_ESCR1, "FLAME_ESCR1"},
  429.     {MSR_DAC_ESCR0, "DAC_ESCR0"},
  430.     {MSR_DAC_ESCR1, "DAC_ESCR1"},
  431.     {MSR_MOB_ESCR0, "MOB_ESCR0"},
  432.     {MSR_MOB_ESCR1, "MOB_ESCR1"},
  433.     {MSR_PMH_ESCR0, "PMH_ESCR0"},
  434.     {MSR_PMH_ESCR1, "PMH_ESCR1"},
  435.     {MSR_SAAT_ESCR0, "SAAT_ESCR0"},
  436.     {MSR_SAAT_ESCR1, "SAAT_ESCR1"},
  437.     {MSR_U2L_ESCR0, "U2L_ESCR0"},
  438.     {MSR_U2L_ESCR1, "U2L_ESCR1"},
  439.     {MSR_BPU_ESCR0, "BPU_ESCR0"},
  440.     {MSR_BPU_ESCR1, "BPU_ESCR1"},
  441.     {MSR_IS_ESCR0, "IS_ESCR0"},
  442.     {MSR_IS_ESCR1, "IS_ESCR1"},
  443.     {MSR_ITLB_ESCR0, "ITLB_ESCR0"},
  444.     {MSR_ITLB_ESCR1, "ITLB_ESCR1"},
  445.     {MSR_CRU_ESCR0, "CRU_ESCR0"},
  446.     {MSR_CRU_ESCR1, "CRU_ESCR1"},
  447.     {MSR_IQ_ESCR0, "IQ_ESCR0"},
  448.     {MSR_IQ_ESCR1, "IQ_ESCR1"},
  449.     {MSR_RAT_ESCR0, "RAT_ESCR0"},
  450.     {MSR_RAT_ESCR1, "RAT_ESCR1"},
  451.     {MSR_SSU_ESCR0, "SSU_ESCR0"},
  452.     {MSR_MS_ESCR0, "MS_ESCR0"},
  453.     {MSR_MS_ESCR1, "MS_ESCR1"},
  454.     {MSR_TBPU_ESCR0, "TBPU_ESCR0"},
  455.     {MSR_TBPU_ESCR1, "TBPU_ESCR1"},
  456.     {MSR_TC_ESCR0, "TC_ESCR0"},
  457.     {MSR_TC_ESCR1, "TC_ESCR1"},
  458.     {MSR_IX_ESCR0, "IX_ESCR0"},
  459.     {MSR_IX_ESCR1, "IX_ESCR1"},
  460.     {MSR_ALF_ESCR0, "ALF_ESCR0"},
  461.     {MSR_ALF_ESCR1, "ALF_ESCR1"},
  462.     {MSR_CRU_ESCR2, "CRU_ESCR2"},
  463.     {MSR_CRU_ESCR3, "CRU_ESCR3"},
  464.     {MSR_CRU_ESCR4, "CRU_ESCR4"},
  465.     {MSR_CRU_ESCR5, "CRU_ESCR5"},
  466.     {MSR_TC_PRECISE_EVENT, "TC_PRECISE_EVENT"},
  467.     {IA32_PEBS_ENABLE, "IA32_PEBS_ENABLE"},
  468.     {MSR_PEBS_MATRIX_VERT, "PEBS_MATRIX_VERT"},
  469.     /* use pentiumMcaEnable() or pentiumMcaShow()
  470.     {IA32_MC0_CTL, "IA32_MC0_CTL"},
  471.     {IA32_MC0_STATUS, "IA32_MC0_STATUS"},
  472.     {IA32_MC0_ADDR, "IA32_MC0_ADDR"},
  473.     {IA32_MC0_MISC, "IA32_MC0_MISC"},
  474.     {IA32_MC1_CTL, "IA32_MC1_CTL"},
  475.     {IA32_MC1_STATUS, "IA32_MC1_STATUS"},
  476.     {IA32_MC1_ADDR, "IA32_MC1_ADDR"},
  477.     {IA32_MC1_MISC, "IA32_MC1_MISC"},
  478.     {IA32_MC2_CTL, "IA32_MC2_CTL"},
  479.     {IA32_MC2_STATUS, "IA32_MC2_STATUS"},
  480.     {IA32_MC2_ADDR, "IA32_MC2_ADDR"},
  481.     {IA32_MC2_MISC, "IA32_MC2_MISC"},
  482.     {IA32_MC3_CTL, "IA32_MC3_CTL"},
  483.     {IA32_MC3_STATUS, "IA32_MC3_STATUS"},
  484.     {IA32_MC3_ADDR, "IA32_MC3_ADDR"},
  485.     {IA32_MC3_MISC, "IA32_MC3_MISC"},
  486.     */
  487.     {IA32_DS_AREA, "IA32_DS_AREA"},
  488.     };
  489. INT32 pentiumMsrP7NumEnt = NELEMENTS (pentiumMsrP7);
  492. /* locals */
  494. LOCAL char mtrrBusy = FALSE; /* MTRR busy flag */
  497. /*******************************************************************************
  498. *
  499. * pentiumMtrrEnable - enable MTRR (Memory Type Range Register)
  500. *
  501. * This routine enables the MTRR that provide a mechanism for associating the
  502. * memory types with physical address ranges in system memory.
  503. *
  504. * RETURNS: N/A
  505. */
  507. void pentiumMtrrEnable (void)
  508.     {
  509.     int oldLevel;
  510.     int deftype[2];
  511.     int oldCr4;
  513.     oldLevel = intLock ();                      /* LOCK INTERRUPT */
  514.     cacheFlush (DATA_CACHE, NULL, 0); /* flush cache w WBINVD */
  515.     oldCr4 = pentiumCr4Get (); /* save CR4 */
  516.     pentiumCr4Set (oldCr4 & ~CR4_PGE); /* clear PGE bit */
  517.     pentiumTlbFlush (); /* flush TLB */
  519.     pentiumMsrGet (MSR_MTRR_DEFTYPE, (LL_INT *)&deftype);
  520.     deftype[0] |= (MTRR_E | MTRR_FE); /* set enable bits */
  521.     pentiumMsrSet (MSR_MTRR_DEFTYPE, (LL_INT *)&deftype);
  523.     cacheFlush (DATA_CACHE, NULL, 0); /* flush cache w WBINVD */
  524.     pentiumTlbFlush (); /* flush TLB */
  525.     pentiumCr4Set (oldCr4); /* restore CR4 */
  526.     intUnlock (oldLevel); /* UNLOCK INTERRUPT */
  527.     }
  529. /*******************************************************************************
  530. *
  531. * pentiumMtrrDisable - disable MTRR (Memory Type Range Register)
  532. *
  533. * This routine disables the MTRR that provide a mechanism for associating the
  534. * memory types with physical address ranges in system memory.
  535. *
  536. * RETURNS: N/A
  537. */
  539. void pentiumMtrrDisable (void)
  540.     {
  541.     int oldLevel;
  542.     int deftype[2];
  543.     int oldCr4;
  545.     oldLevel = intLock ();                      /* LOCK INTERRUPT */
  546.     cacheFlush (DATA_CACHE, NULL, 0); /* flush cache w WBINVD */
  547.     oldCr4 = pentiumCr4Get (); /* save CR4 */
  548.     pentiumCr4Set (oldCr4 & ~CR4_PGE); /* clear PGE bit */
  549.     pentiumTlbFlush (); /* flush TLB */
  551.     pentiumMsrGet (MSR_MTRR_DEFTYPE, (LL_INT *)&deftype);
  552.     deftype[0] &= ~(MTRR_E | MTRR_FE); /* clear enable bits */
  553.     pentiumMsrSet (MSR_MTRR_DEFTYPE, (LL_INT *)&deftype);
  555.     cacheFlush (DATA_CACHE, NULL, 0); /* flush cache w WBINVD */
  556.     pentiumTlbFlush (); /* flush TLB */
  557.     pentiumCr4Set (oldCr4); /* restore CR4 */
  558.     intUnlock (oldLevel); /* UNLOCK INTERRUPT */
  559.     }
  561. /*******************************************************************************
  562. *
  563. * pentiumMtrrGet - get MTRRs to a specified MTRR table
  564. *
  565. * This routine gets MTRRs to a specified MTRR table with RDMSR instruction.
  566. * The read MTRRs are CAP register, DEFTYPE register, fixed range MTRRs, and
  567. * variable range MTRRs.
  568. *
  569. * RETURNS: OK, or ERROR if MTRR is being accessed.
  570. */
  572. STATUS pentiumMtrrGet
  573.     (
  574.     MTRR * pMtrr /* MTRR table */
  575.     )
  576.     {
  577.     int ix;
  578.     int addr = MSR_MTRR_PHYS_BASE0;
  580.     /* mutual exclusion ON */
  582.     if (pentiumBts (&mtrrBusy) != OK)
  583. return (ERROR);
  585.     pentiumMsrGet (MSR_MTRR_CAP, (LL_INT *)&pMtrr->cap);
  586.     pentiumMsrGet (MSR_MTRR_DEFTYPE, (LL_INT *)&pMtrr->deftype);
  587.     if (pMtrr->cap[0] & MTRR_FIX_SUPPORT)
  588. {
  589.         pentiumMsrGet (MSR_MTRR_FIX_00000, (LL_INT *)&pMtrr->fix[0].type);
  590.         pentiumMsrGet (MSR_MTRR_FIX_80000, (LL_INT *)&pMtrr->fix[1].type);
  591.         pentiumMsrGet (MSR_MTRR_FIX_A0000, (LL_INT *)&pMtrr->fix[2].type);
  592.         pentiumMsrGet (MSR_MTRR_FIX_C0000, (LL_INT *)&pMtrr->fix[3].type);
  593.         pentiumMsrGet (MSR_MTRR_FIX_C8000, (LL_INT *)&pMtrr->fix[4].type);
  594.         pentiumMsrGet (MSR_MTRR_FIX_D0000, (LL_INT *)&pMtrr->fix[5].type);
  595.         pentiumMsrGet (MSR_MTRR_FIX_D8000, (LL_INT *)&pMtrr->fix[6].type);
  596.         pentiumMsrGet (MSR_MTRR_FIX_E0000, (LL_INT *)&pMtrr->fix[7].type);
  597.         pentiumMsrGet (MSR_MTRR_FIX_E8000, (LL_INT *)&pMtrr->fix[8].type);
  598.         pentiumMsrGet (MSR_MTRR_FIX_F0000, (LL_INT *)&pMtrr->fix[9].type);
  599.         pentiumMsrGet (MSR_MTRR_FIX_F8000, (LL_INT *)&pMtrr->fix[10].type);
  600. }
  601.     for (ix = 0; ix < (pMtrr->cap[0] & MTRR_VCNT); ix++)
  602. {
  603.         pentiumMsrGet (addr++, &pMtrr->var[ix].base);
  604.         pentiumMsrGet (addr++, &pMtrr->var[ix].mask);
  605. }
  607.     /* mutual exclusion OFF */
  609.     (void) pentiumBtc (&mtrrBusy);
  610.     return (OK);
  611.     }
  613. /*******************************************************************************
  614. *
  615. * pentiumMtrrSet - set MTRRs from specified MTRR table with WRMSR instruction.
  616. *
  617. * This routine sets MTRRs from specified MTRR table with WRMSR instruction.
  618. * The written MTRRs are DEFTYPE register, fixed range MTRRs, and variable
  619. * range MTRRs.
  620. *
  621. * RETURNS: OK, or ERROR if MTRR is enabled or being accessed.
  622. */
  624. STATUS pentiumMtrrSet 
  625.     (
  626.     MTRR * pMtrr /* MTRR table */
  627.     )
  628.     {
  629.     int ix;
  630.     int addr = MSR_MTRR_PHYS_BASE0;
  632.     /* MTRR should be disabled */
  634.     pentiumMsrGet (MSR_MTRR_DEFTYPE, (LL_INT *)&pMtrr->deftype);
  635.     if ((pMtrr->deftype[0] & (MTRR_E | MTRR_FE)) != 0)
  636. return (ERROR);
  638.     /* mutual exclusion ON */
  640.     if (pentiumBts (&mtrrBusy) != OK)
  641. return (ERROR);
  643.     pentiumMsrSet (MSR_MTRR_DEFTYPE, (LL_INT *)&pMtrr->deftype);
  644.     pentiumMsrGet (MSR_MTRR_CAP, (LL_INT *)&pMtrr->cap);
  645.     if (pMtrr->cap[0] & MTRR_FIX_SUPPORT)
  646. {
  647.         pentiumMsrSet (MSR_MTRR_FIX_00000, (LL_INT *)&pMtrr->fix[0].type);
  648.         pentiumMsrSet (MSR_MTRR_FIX_80000, (LL_INT *)&pMtrr->fix[1].type);
  649.         pentiumMsrSet (MSR_MTRR_FIX_A0000, (LL_INT *)&pMtrr->fix[2].type);
  650.         pentiumMsrSet (MSR_MTRR_FIX_C0000, (LL_INT *)&pMtrr->fix[3].type);
  651.         pentiumMsrSet (MSR_MTRR_FIX_C8000, (LL_INT *)&pMtrr->fix[4].type);
  652.         pentiumMsrSet (MSR_MTRR_FIX_D0000, (LL_INT *)&pMtrr->fix[5].type);
  653.         pentiumMsrSet (MSR_MTRR_FIX_D8000, (LL_INT *)&pMtrr->fix[6].type);
  654.         pentiumMsrSet (MSR_MTRR_FIX_E0000, (LL_INT *)&pMtrr->fix[7].type);
  655.         pentiumMsrSet (MSR_MTRR_FIX_E8000, (LL_INT *)&pMtrr->fix[8].type);
  656.         pentiumMsrSet (MSR_MTRR_FIX_F0000, (LL_INT *)&pMtrr->fix[9].type);
  657.         pentiumMsrSet (MSR_MTRR_FIX_F8000, (LL_INT *)&pMtrr->fix[10].type);
  658. }
  659.     for (ix = 0; ix < (pMtrr->cap[0] & MTRR_VCNT); ix++)
  660. {
  661.         pentiumMsrSet (addr++, &pMtrr->var[ix].base);
  662.         pentiumMsrSet (addr++, &pMtrr->var[ix].mask);
  663. }
  665.     /* mutual exclusion OFF */
  667.     (void) pentiumBtc (&mtrrBusy);
  668.     return (OK);
  669.     }
  671. /*******************************************************************************
  672. *
  673. * pentiumPmcStart - start both PMC0 and PMC1
  674. *
  675. * SYNOPSIS
  676. * ss
  677. * STATUS pentiumPmcStart (pmcEvtSel0, pmcEvtSel1)
  678. *     int pmcEvtSel0; /@ Performance Event Select Register 0 @/
  679. *     int pmcEvtSel1; /@ Performance Event Select Register 1 @/
  680. * se
  681. * 
  682. * This routine starts both PMC0 (Performance Monitoring Counter 0) and PMC1
  683. * by writing specified events to Performance Event Select Registers. 
  684. * The first parameter is a content of Performance Event Select Register 0,
  685. * and the second parameter is for the Performance Event Select Register 1.
  686. *
  687. * RETURNS: OK or ERROR if PMC is already started.
  688. */
  689. STATUS   pentiumPmcStart
  690.     (
  691.     int pmcEvtSel0,
  692.     int pmcEvtSel1
  693.     )
  694.     {
  695.     STATUS retVal;
  697.     retVal = ERROR;
  698.     if (sysCpuId.featuresEdx & CPUID_MSR)
  699.         {
  700.         if (sysProcessor == X86CPU_PENTIUM)
  701.     {
  702.             if(pentiumP5PmcStart0(pmcEvtSel0) == OK    
  703.                     && pentiumP5PmcStart1(pmcEvtSel1) == OK) 
  704.                 retVal = OK;
  705.             }
  706.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  707.             retVal = pentiumP6PmcStart(pmcEvtSel0, pmcEvtSel1);
  708.         }
  710.     return (retVal);
  711.     }
  712.    
  713. /*******************************************************************************
  714. *
  715. * pentiumPmcStart0 - start PMC0
  716. *
  717. * SYNOPSIS
  718. * ss
  719. * STATUS pentiumPmcStart0 (pmcEvtSel0)
  720. *       int pmcEvtSel0;           /@ PMC0 control and event select @/
  721. * se
  722. *
  723. * This routine starts PMC0 (Performance Monitoring Counter 0) 
  724. * by writing specified PMC0 events to Performance Event Select Registers. 
  725. * The only parameter is the content of Performance Event Select Register.
  726. *
  727. * RETURNS: OK or ERROR if PMC is already started.
  728. */
  729. STATUS   pentiumPmcStart0
  730.     (
  731.     int pmcEvtSel0
  732.     )
  733.     {
  735.     if ((sysCpuId.featuresEdx & CPUID_MSR) && (sysProcessor == X86CPU_PENTIUM))
  736.        return (pentiumP5PmcStart0(pmcEvtSel0));            
  737.     else
  738.        return (ERROR);
  739.     }
  741. /*******************************************************************************
  742. *
  743. * pentiumPmcStart1 - start PMC1
  744. *
  745. * SYNOPSIS
  746. * ss
  747. * STATUS pentiumPmcStart1 (pmcEvtSel1)
  748. *       int pmcEvtSel1;           /@ PMC1 control and event select @/
  749. * se
  750. *
  751. * This routine starts PMC1 (Performance Monitoring Counter 0) 
  752. * by writing specified PMC1 events to Performance Event Select Registers. 
  753. * The only parameter is the content of Performance Event Select Register.
  754. *
  755. * RETURNS: OK or ERROR if PMC1 is already started.
  756. */
  757. STATUS   pentiumPmcStart1
  758.     (
  759.     int pmcEvtSel1
  760.     )
  761.     {
  762.     if ((sysCpuId.featuresEdx & CPUID_MSR) && (sysProcessor == X86CPU_PENTIUM))
  763.         return (pentiumP5PmcStart1(pmcEvtSel1));                
  764.     else
  765.         return (ERROR);
  766.     }
  768. /*******************************************************************************
  769. *
  770. * pentiumPmcStop - stop both PMC0 and PMC1
  771. *
  772. * SYNOPSIS
  773. * ss
  774. * void pentiumPmcStop (void)
  775. * se
  776. *
  777. * This routine stops both PMC0 (Performance Monitoring Counter 0)
  778. * and PMC1 by clearing two Performance Event Select Registers.
  779. *
  780. * RETURNS: N/A
  781. */
  782. void pentiumPmcStop (void)
  783.     {
  784.     if (sysCpuId.featuresEdx & CPUID_MSR)
  785. {
  786.         if (sysProcessor == X86CPU_PENTIUM)
  787.             {
  788.             pentiumP5PmcStop0();
  789.             pentiumP5PmcStop1();
  790.             }
  791.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  792.             pentiumP6PmcStop();
  793.         }
  794.     }
  796. /*******************************************************************************
  797. *
  798. * pentiumPmcStop0 - stop PMC0
  799. *
  800. * SYNOPSIS
  801. * ss
  802. * void pentiumPmcStop0 (void)
  803. * se
  804. *
  805. * This routine stops only PMC0 (Performance Monitoring Counter 0)
  806. * by clearing the PMC0 bits of Control and Event Select Register.
  807. *
  808. * RETURNS: N/A
  809. */
  810. void pentiumPmcStop0 (void)
  811.     {
  812.     if ((sysCpuId.featuresEdx & CPUID_MSR) && (sysProcessor == X86CPU_PENTIUM))
  813.         pentiumP5PmcStop0();
  814.     }
  816. /*******************************************************************************
  817. *
  818. * pentiumPmcStop1 - stop PMC1
  819. *
  820. * SYNOPSIS
  821. * ss
  822. * void pentiumPmcStop1 (void)
  823. * se
  824. *
  825. * This routine stops only PMC1 (Performance Monitoring Counter 1)
  826. * by clearing the PMC1 bits of Control and Event Select Register.
  827. *
  828. * RETURNS: N/A
  829. */
  830. void pentiumPmcStop1 (void)
  831.     {
  832.     if (sysCpuId.featuresEdx & CPUID_MSR)
  833.         {
  834.         if (sysProcessor == X86CPU_PENTIUM)
  835.             pentiumP5PmcStop1();
  836.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  837.             pentiumP6PmcStop1();
  838.         }
  839.     }
  841. /*******************************************************************************
  842. *
  843. * pentiumPmcGet - get the contents of PMC0 and PMC1
  844. *
  845. * SYNOPSIS
  846. * ss
  847. * void pentiumPmcGet (pPmc0, pPmc1)
  848. *     long long int * pPmc0;            /@ Performance Monitoring Counter 0 @/
  849. *     long long int * pPmc1;            /@ Performance Monitoring Counter 1 @/
  850. * se
  851. *
  852. * This routine gets the contents of both PMC0 (Performance Monitoring Counter 0)
  853. * and PMC1.  The first parameter is a pointer of 64Bit variable to store
  854. * the content of the Counter 0, and the second parameter is for the Counter 1.
  855. *
  856. * RETURNS: N/A
  857. */
  858. void pentiumPmcGet
  859.     (
  860.     long long int * pPmc0, 
  861.     long long int * pPmc1
  862.     )
  863.     {
  864.     if (sysCpuId.featuresEdx & CPUID_MSR)
  865.         {
  866.         if (sysProcessor == X86CPU_PENTIUM)
  867.             pentiumP5PmcGet(pPmc0, pPmc1);
  868.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  869.             pentiumP6PmcGet(pPmc0, pPmc1);
  870.         }
  871.     }
  873. /*******************************************************************************
  874. *
  875. * pentiumPmcGet0 - get the contents of PMC0
  876. *
  877. * SYNOPSIS
  878. * ss
  879. * void pentiumPmcGet0 (pPmc0)
  880. *     long long int * pPmc0;            /@ Performance Monitoring Counter 0 @/
  881. * se
  882. *
  883. * This routine gets the contents of PMC0 (Performance Monitoring Counter 0).
  884. * The parameter is a pointer of 64Bit variable to store the content of
  885. * the Counter.
  886. *
  887. * RETURNS: N/A
  888. */
  889. void pentiumPmcGet0
  890.     (
  891.     long long int * pPmc0
  892.     )
  893.     {
  894.     if (sysCpuId.featuresEdx & CPUID_MSR)
  895.         {
  896.         if (sysProcessor == X86CPU_PENTIUM)
  897.             pentiumP5PmcGet0(pPmc0);
  898.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  899.             pentiumP6PmcGet0(pPmc0);
  900.         }
  901.     }
  903. /*******************************************************************************
  904. *
  905. * pentiumPmcGet1 - get the contents of PMC1
  906. *
  907. * SYNOPSIS
  908. * ss
  909. * void pentiumPmcGet1 (pPmc1)
  910. *     long long int * pPmc1;            /@ Performance Monitoring Counter 1 @/
  911. * se
  912. *
  913. * This routine gets a content of PMC1 (Performance Monitoring Counter 1).
  914. * Parameter is a pointer of 64Bit variable to store the content of the Counter.
  915. *
  916. * RETURNS: N/A
  917. */
  918. void pentiumPmcGet1
  919.     (
  920.     long long int * pPmc1
  921.     )
  922.     {
  923.     if (sysCpuId.featuresEdx & CPUID_MSR)
  924.         {
  925.         if (sysProcessor == X86CPU_PENTIUM)
  926.             pentiumP5PmcGet1(pPmc1);
  927.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  928.             pentiumP6PmcGet1(pPmc1);
  929.         }
  930.     }
  931.     
  932. /*******************************************************************************
  933. *
  934. * pentiumPmcReset - reset both PMC0 and PMC1
  935. *
  936. * SYNOPSIS
  937. * ss
  938. * void pentiumPmcReset (void)
  939. * se
  940. * 
  941. * This routine resets both PMC0 (Performance Monitoring Counter 0) and PMC1.
  942. *
  943. * RETURNS: N/A
  944. */
  945. void pentiumPmcReset (void)
  946.     {
  947.     if (sysCpuId.featuresEdx & CPUID_MSR)
  948.         {
  949.         if (sysProcessor == X86CPU_PENTIUM)
  950.             pentiumP5PmcReset();
  951.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  952.             pentiumP6PmcReset();
  953.         }
  954.     }
  956. /*******************************************************************************
  957. *
  958. * pentiumPmcReset0 - reset PMC0
  959. *
  960. * SYNOPSIS
  961. * ss
  962. * void pentiumPmcReset0 (void)
  963. * se
  964. *
  965. * This routine resets PMC0 (Performance Monitoring Counter 0).
  966. *
  967. * RETURNS: N/A 
  968. */
  969. void pentiumPmcReset0 (void)
  970.     {
  971.     if (sysCpuId.featuresEdx & CPUID_MSR)
  972.         {
  973.         if (sysProcessor == X86CPU_PENTIUM)
  974.             pentiumP5PmcReset0();
  975.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  976.             pentiumP6PmcReset0();
  977.         }
  978.     }
  980. /*******************************************************************************
  981. *
  982. * pentiumPmcReset1 - reset PMC1
  983. *
  984. * SYNOPSIS
  985. * ss
  986. * void pentiumPmcReset1 (void)
  987. * se
  988. *
  989. * This routine resets PMC1 (Performance Monitoring Counter 1).
  990. *
  991. * RETURNS: N/A
  992. */
  993. void pentiumPmcReset1 (void)
  994.     {
  995.     if (sysCpuId.featuresEdx & CPUID_MSR)
  996.         {
  997.         if (sysProcessor == X86CPU_PENTIUM)
  998.             pentiumP5PmcReset1();
  999.         else if (sysProcessor == X86CPU_PENTIUMPRO)
  1000.             pentiumP6PmcReset1();
  1001.         }
  1002.     }
  1004. /*******************************************************************************
  1005. *
  1006. * pentiumMsrInit - initialize all the MSRs (Model Specific Register)
  1007. *
  1008. * This routine initializes all the MSRs in the processor.
  1009. * This routine works on either P5, P6 or P7 family processors.
  1010. *
  1011. * RETURNS: OK, or ERROR if RDMSR/WRMSR instructions are not supported.
  1012. */
  1014. STATUS pentiumMsrInit (void)
  1015.     {
  1016.     PENTIUM_MSR * pMsr; /* pointer to the MSR table */
  1017.     UINT32 value[2] = {0,0};
  1018.     UINT32 zero[2]  = {0,0};
  1019.     int ix;
  1021.     /* just return if RDMSR and WRMSR instruction are not supported */
  1023.     if ((sysCpuId.featuresEdx & CPUID_MSR) == 0)
  1024. return (ERROR);
  1026.     switch (sysProcessor)
  1027. {
  1028. case X86CPU_PENTIUM:
  1029.     pMsr = pentiumMsrP5;
  1030.          for (ix = 0; ix < pentiumMsrP5NumEnt; ix++, pMsr++)
  1031.         {
  1032.         switch (pMsr->addr)
  1033.             {
  1034.             case MSR_P5_MC_ADDR: /* disable the MCA */
  1035.         pentiumMcaEnable (FALSE);
  1036.                 break;
  1038.             case MSR_CESR: /* disable the PM */
  1039.                 pentiumMsrSet (pMsr->addr, (LL_INT *)&zero);
  1040.                 break;
  1042.             default:
  1043.                 break;
  1044.             }
  1045.         }
  1046.     break;
  1048. case X86CPU_PENTIUMPRO: /* PENTIUM[23] */
  1049.     pMsr = pentiumMsrP6;
  1050.          for (ix = 0; ix < pentiumMsrP6NumEnt; ix++, pMsr++)
  1051.         {
  1052.         switch (pMsr->addr)
  1053.             {
  1054.             case MSR_APICBASE: /* don't touch */
  1055.         /* bit-11 can't be re-enabled except by hard reset */
  1056.                 break;
  1058.             case MSR_ROB_CR_BKUPTMPDR6: /* set the default value */
  1059.                 pentiumMsrGet (pMsr->addr, (LL_INT *)&value);
  1060.            value[0] = MSR_ROB_CR_BKUPTMPDR6_DEFAULT;
  1061.                 pentiumMsrSet (pMsr->addr, (LL_INT *)&value);
  1062.                 break;
  1064.             case MSR_MCG_CAP: /* disable the MCA */
  1065.         pentiumMcaEnable (FALSE);
  1066.                 break;
  1068.             case MSR_DEBUGCTLMSR: /* disable the debug features */
  1069.             case MSR_EVNTSEL0: /* disable the PM */
  1070.             case MSR_EVNTSEL1: /* disable the PM */
  1071.             case MSR_PERFCTR0: /* disable the PM */
  1072.             case MSR_PERFCTR1: /* disable the PM */
  1073.                 pentiumMsrSet (pMsr->addr, (LL_INT *)&zero);
  1074.                 break;
  1076.             default:
  1077.                 break;
  1078.             }
  1079.         }
  1080.     break;
  1082. case X86CPU_PENTIUM4:
  1083.     pMsr = pentiumMsrP7;
  1084.          for (ix = 0; ix < pentiumMsrP7NumEnt; ix++, pMsr++)
  1085.         {
  1086.         switch (pMsr->addr)
  1087.             {
  1088.             case IA32_APIC_BASE: /* don't touch */
  1089.         /* bit-11 can't be re-enabled except by hard reset */
  1090.                 break;
  1092.             case IA32_MISC_ENABLE: /* set the default value */
  1093.                 pentiumMsrGet (pMsr->addr, (LL_INT *)&value);
  1094.            value[0] = IA32_MISC_ENABLE_DEFAULT;
  1095.                 pentiumMsrSet (pMsr->addr, (LL_INT *)&value);
  1096.                 break;
  1098.             case IA32_MCG_CAP: /* disable the MCA */
  1099.         pentiumMcaEnable (FALSE);
  1100.                 break;
  1102.             case IA32_MISC_CTL: /* disable the serial number */
  1103.             case IA32_THERM_INTERRUPT: /* disable the thermal int. */
  1104.             case IA32_DEBUGCTL: /* disable the debug features */
  1105.             case MSR_TC_PRECISE_EVENT: /* disable the FE tagging */
  1106.             case IA32_PEBS_ENABLE: /* disable the PEBS */
  1107.             case MSR_BPU_CCCR0: /* disable the PM */
  1108.             case MSR_BPU_CCCR1: /* disable the PM */
  1109.             case MSR_BPU_CCCR2: /* disable the PM */
  1110.             case MSR_BPU_CCCR3: /* disable the PM */
  1111.             case MSR_MS_CCCR0: /* disable the PM */
  1112.             case MSR_MS_CCCR1: /* disable the PM */
  1113.             case MSR_MS_CCCR2: /* disable the PM */
  1114.             case MSR_MS_CCCR3: /* disable the PM */
  1115.             case MSR_FLAME_CCCR0: /* disable the PM */
  1116.             case MSR_FLAME_CCCR1: /* disable the PM */
  1117.             case MSR_FLAME_CCCR2: /* disable the PM */
  1118.             case MSR_FLAME_CCCR3: /* disable the PM */
  1119.             case MSR_IQ_CCCR0: /* disable the PM */
  1120.             case MSR_IQ_CCCR1: /* disable the PM */
  1121.             case MSR_IQ_CCCR2: /* disable the PM */
  1122.             case MSR_IQ_CCCR3: /* disable the PM */
  1123.             case MSR_IQ_CCCR4: /* disable the PM */
  1124.             case MSR_IQ_CCCR5: /* disable the PM */
  1125.                 pentiumMsrSet (pMsr->addr, (LL_INT *)&zero);
  1126.                 break;
  1128.             default:
  1129.                 break;
  1130.             }
  1131.         }
  1132.     break;
  1134. default:
  1135.     break;
  1136. }
  1138.     return (OK);
  1139.     }
  1141. /*******************************************************************************
  1142. *
  1143. * pentiumMcaEnable - enable/disable the MCA (Machine Check Architecture)
  1144. *
  1145. * This routine enables/disables 1) the Machine Check Architecture and its 
  1146. * Error Reporting register banks 2) the Machine Check Exception by toggling
  1147. * the MCE bit in the CR4.  This routine works on either P5, P6 or P7 family.
  1148. *
  1149. * RETURNS: N/A
  1150. */
  1152. void pentiumMcaEnable 
  1153.     (
  1154.     BOOL enable /* TRUE to enable, FALSE to disable the MCA */
  1155.     )
  1156.     {
  1157.     UINT32 zero[2] = {0x00000000,0x00000000};
  1158.     UINT32 one[2]  = {0xffffffff,0xffffffff};
  1159.     UINT32 cap[2]; /* MCG_CAP */
  1160.     int mcaBanks; /* MCA Error-Reporting Bank Registers */
  1161.     int ix;
  1163.     if ((sysCpuId.featuresEdx & CPUID_MCE) == CPUID_MCE)
  1164. {
  1165.         if ((sysCpuId.featuresEdx & CPUID_MCA) == CPUID_MCA)
  1166.     {
  1167.     pentiumMsrGet (MSR_MCG_CAP, (LL_INT *)&cap);
  1169.     /* enable/disable all the machine-check features */
  1171.     if (cap[0] & MCG_CTL_P)
  1172. {
  1173. if (enable)
  1174.     pentiumMsrSet (MSR_MCG_CTL, (LL_INT *)&one);
  1175. else
  1176.     pentiumMsrSet (MSR_MCG_CTL, (LL_INT *)&zero);
  1177. }
  1179.     mcaBanks = cap[0] & MCG_COUNT; /* get number of banks */
  1181.     /* enable all error-logging banks except MC0_CTL register */
  1183.     for (ix = 1; ix < mcaBanks; ix++)
  1184. pentiumMsrSet (MSR_MC0_CTL+(ix * 4), (LL_INT *)&one);
  1186.     /* clear all errors */
  1188.     for (ix = 0; ix < mcaBanks; ix++)
  1189. pentiumMsrSet (MSR_MC0_STATUS+(ix * 4), (LL_INT *)&zero);
  1191.     }
  1193. /* enable/disable the MCE exception */
  1195. if (enable)
  1196.     vxCr4Set (vxCr4Get () | CR4_MCE);
  1197. else
  1198.     vxCr4Set (vxCr4Get () & ~CR4_MCE);
  1199. }
  1200.     }