mirror of
https://github.com/torvalds/linux.git
synced 2024-12-15 15:41:58 +00:00
cb2252522a
The ev_sel_ext in PCU_MSR_PMON_CTL is locked on some CPU models, so despite it being documented in the SDM, if we write 1 to that bit then we can get a #GP fault. Which #GP the perf fuzzer happily triggered in Peter Zijlstra's testing. Also, there are no public events which use that bit, so remove ev_sel_ext bit support for PCU. Reported-by: Peter Zijlstra <peterz@infradead.org> Signed-off-by: Kan Liang <kan.liang@intel.com> Acked-by: Peter Zijlstra <peterz@infradead.org> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Arnaldo Carvalho de Melo <acme@redhat.com> Cc: David Ahern <dsahern@gmail.com> Cc: Jiri Olsa <jolsa@redhat.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Namhyung Kim <namhyung@kernel.org> Cc: Stephane Eranian <eranian@google.com> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Vince Weaver <vincent.weaver@maine.edu> Link: http://lkml.kernel.org/r/1458500301-3594-1-git-send-email-kan.liang@intel.com Signed-off-by: Ingo Molnar <mingo@kernel.org>
3133 lines
94 KiB
C
3133 lines
94 KiB
C
/* SandyBridge-EP/IvyTown uncore support */
|
|
#include "uncore.h"
|
|
|
|
/* SNB-EP Box level control */
|
|
#define SNBEP_PMON_BOX_CTL_RST_CTRL (1 << 0)
|
|
#define SNBEP_PMON_BOX_CTL_RST_CTRS (1 << 1)
|
|
#define SNBEP_PMON_BOX_CTL_FRZ (1 << 8)
|
|
#define SNBEP_PMON_BOX_CTL_FRZ_EN (1 << 16)
|
|
#define SNBEP_PMON_BOX_CTL_INT (SNBEP_PMON_BOX_CTL_RST_CTRL | \
|
|
SNBEP_PMON_BOX_CTL_RST_CTRS | \
|
|
SNBEP_PMON_BOX_CTL_FRZ_EN)
|
|
/* SNB-EP event control */
|
|
#define SNBEP_PMON_CTL_EV_SEL_MASK 0x000000ff
|
|
#define SNBEP_PMON_CTL_UMASK_MASK 0x0000ff00
|
|
#define SNBEP_PMON_CTL_RST (1 << 17)
|
|
#define SNBEP_PMON_CTL_EDGE_DET (1 << 18)
|
|
#define SNBEP_PMON_CTL_EV_SEL_EXT (1 << 21)
|
|
#define SNBEP_PMON_CTL_EN (1 << 22)
|
|
#define SNBEP_PMON_CTL_INVERT (1 << 23)
|
|
#define SNBEP_PMON_CTL_TRESH_MASK 0xff000000
|
|
#define SNBEP_PMON_RAW_EVENT_MASK (SNBEP_PMON_CTL_EV_SEL_MASK | \
|
|
SNBEP_PMON_CTL_UMASK_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_PMON_CTL_INVERT | \
|
|
SNBEP_PMON_CTL_TRESH_MASK)
|
|
|
|
/* SNB-EP Ubox event control */
|
|
#define SNBEP_U_MSR_PMON_CTL_TRESH_MASK 0x1f000000
|
|
#define SNBEP_U_MSR_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_PMON_CTL_EV_SEL_MASK | \
|
|
SNBEP_PMON_CTL_UMASK_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_PMON_CTL_INVERT | \
|
|
SNBEP_U_MSR_PMON_CTL_TRESH_MASK)
|
|
|
|
#define SNBEP_CBO_PMON_CTL_TID_EN (1 << 19)
|
|
#define SNBEP_CBO_MSR_PMON_RAW_EVENT_MASK (SNBEP_PMON_RAW_EVENT_MASK | \
|
|
SNBEP_CBO_PMON_CTL_TID_EN)
|
|
|
|
/* SNB-EP PCU event control */
|
|
#define SNBEP_PCU_MSR_PMON_CTL_OCC_SEL_MASK 0x0000c000
|
|
#define SNBEP_PCU_MSR_PMON_CTL_TRESH_MASK 0x1f000000
|
|
#define SNBEP_PCU_MSR_PMON_CTL_OCC_INVERT (1 << 30)
|
|
#define SNBEP_PCU_MSR_PMON_CTL_OCC_EDGE_DET (1 << 31)
|
|
#define SNBEP_PCU_MSR_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_PMON_CTL_EV_SEL_MASK | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_SEL_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_PMON_CTL_INVERT | \
|
|
SNBEP_PCU_MSR_PMON_CTL_TRESH_MASK | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_INVERT | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_EDGE_DET)
|
|
|
|
#define SNBEP_QPI_PCI_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_PMON_RAW_EVENT_MASK | \
|
|
SNBEP_PMON_CTL_EV_SEL_EXT)
|
|
|
|
/* SNB-EP pci control register */
|
|
#define SNBEP_PCI_PMON_BOX_CTL 0xf4
|
|
#define SNBEP_PCI_PMON_CTL0 0xd8
|
|
/* SNB-EP pci counter register */
|
|
#define SNBEP_PCI_PMON_CTR0 0xa0
|
|
|
|
/* SNB-EP home agent register */
|
|
#define SNBEP_HA_PCI_PMON_BOX_ADDRMATCH0 0x40
|
|
#define SNBEP_HA_PCI_PMON_BOX_ADDRMATCH1 0x44
|
|
#define SNBEP_HA_PCI_PMON_BOX_OPCODEMATCH 0x48
|
|
/* SNB-EP memory controller register */
|
|
#define SNBEP_MC_CHy_PCI_PMON_FIXED_CTL 0xf0
|
|
#define SNBEP_MC_CHy_PCI_PMON_FIXED_CTR 0xd0
|
|
/* SNB-EP QPI register */
|
|
#define SNBEP_Q_Py_PCI_PMON_PKT_MATCH0 0x228
|
|
#define SNBEP_Q_Py_PCI_PMON_PKT_MATCH1 0x22c
|
|
#define SNBEP_Q_Py_PCI_PMON_PKT_MASK0 0x238
|
|
#define SNBEP_Q_Py_PCI_PMON_PKT_MASK1 0x23c
|
|
|
|
/* SNB-EP Ubox register */
|
|
#define SNBEP_U_MSR_PMON_CTR0 0xc16
|
|
#define SNBEP_U_MSR_PMON_CTL0 0xc10
|
|
|
|
#define SNBEP_U_MSR_PMON_UCLK_FIXED_CTL 0xc08
|
|
#define SNBEP_U_MSR_PMON_UCLK_FIXED_CTR 0xc09
|
|
|
|
/* SNB-EP Cbo register */
|
|
#define SNBEP_C0_MSR_PMON_CTR0 0xd16
|
|
#define SNBEP_C0_MSR_PMON_CTL0 0xd10
|
|
#define SNBEP_C0_MSR_PMON_BOX_CTL 0xd04
|
|
#define SNBEP_C0_MSR_PMON_BOX_FILTER 0xd14
|
|
#define SNBEP_CBO_MSR_OFFSET 0x20
|
|
|
|
#define SNBEP_CB0_MSR_PMON_BOX_FILTER_TID 0x1f
|
|
#define SNBEP_CB0_MSR_PMON_BOX_FILTER_NID 0x3fc00
|
|
#define SNBEP_CB0_MSR_PMON_BOX_FILTER_STATE 0x7c0000
|
|
#define SNBEP_CB0_MSR_PMON_BOX_FILTER_OPC 0xff800000
|
|
|
|
#define SNBEP_CBO_EVENT_EXTRA_REG(e, m, i) { \
|
|
.event = (e), \
|
|
.msr = SNBEP_C0_MSR_PMON_BOX_FILTER, \
|
|
.config_mask = (m), \
|
|
.idx = (i) \
|
|
}
|
|
|
|
/* SNB-EP PCU register */
|
|
#define SNBEP_PCU_MSR_PMON_CTR0 0xc36
|
|
#define SNBEP_PCU_MSR_PMON_CTL0 0xc30
|
|
#define SNBEP_PCU_MSR_PMON_BOX_CTL 0xc24
|
|
#define SNBEP_PCU_MSR_PMON_BOX_FILTER 0xc34
|
|
#define SNBEP_PCU_MSR_PMON_BOX_FILTER_MASK 0xffffffff
|
|
#define SNBEP_PCU_MSR_CORE_C3_CTR 0x3fc
|
|
#define SNBEP_PCU_MSR_CORE_C6_CTR 0x3fd
|
|
|
|
/* IVBEP event control */
|
|
#define IVBEP_PMON_BOX_CTL_INT (SNBEP_PMON_BOX_CTL_RST_CTRL | \
|
|
SNBEP_PMON_BOX_CTL_RST_CTRS)
|
|
#define IVBEP_PMON_RAW_EVENT_MASK (SNBEP_PMON_CTL_EV_SEL_MASK | \
|
|
SNBEP_PMON_CTL_UMASK_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_PMON_CTL_TRESH_MASK)
|
|
/* IVBEP Ubox */
|
|
#define IVBEP_U_MSR_PMON_GLOBAL_CTL 0xc00
|
|
#define IVBEP_U_PMON_GLOBAL_FRZ_ALL (1 << 31)
|
|
#define IVBEP_U_PMON_GLOBAL_UNFRZ_ALL (1 << 29)
|
|
|
|
#define IVBEP_U_MSR_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_PMON_CTL_EV_SEL_MASK | \
|
|
SNBEP_PMON_CTL_UMASK_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_U_MSR_PMON_CTL_TRESH_MASK)
|
|
/* IVBEP Cbo */
|
|
#define IVBEP_CBO_MSR_PMON_RAW_EVENT_MASK (IVBEP_PMON_RAW_EVENT_MASK | \
|
|
SNBEP_CBO_PMON_CTL_TID_EN)
|
|
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_TID (0x1fULL << 0)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_LINK (0xfULL << 5)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_STATE (0x3fULL << 17)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_NID (0xffffULL << 32)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_OPC (0x1ffULL << 52)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_C6 (0x1ULL << 61)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_NC (0x1ULL << 62)
|
|
#define IVBEP_CB0_MSR_PMON_BOX_FILTER_ISOC (0x1ULL << 63)
|
|
|
|
/* IVBEP home agent */
|
|
#define IVBEP_HA_PCI_PMON_CTL_Q_OCC_RST (1 << 16)
|
|
#define IVBEP_HA_PCI_PMON_RAW_EVENT_MASK \
|
|
(IVBEP_PMON_RAW_EVENT_MASK | \
|
|
IVBEP_HA_PCI_PMON_CTL_Q_OCC_RST)
|
|
/* IVBEP PCU */
|
|
#define IVBEP_PCU_MSR_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_PMON_CTL_EV_SEL_MASK | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_SEL_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_PCU_MSR_PMON_CTL_TRESH_MASK | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_INVERT | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_EDGE_DET)
|
|
/* IVBEP QPI */
|
|
#define IVBEP_QPI_PCI_PMON_RAW_EVENT_MASK \
|
|
(IVBEP_PMON_RAW_EVENT_MASK | \
|
|
SNBEP_PMON_CTL_EV_SEL_EXT)
|
|
|
|
#define __BITS_VALUE(x, i, n) ((typeof(x))(((x) >> ((i) * (n))) & \
|
|
((1ULL << (n)) - 1)))
|
|
|
|
/* Haswell-EP Ubox */
|
|
#define HSWEP_U_MSR_PMON_CTR0 0x709
|
|
#define HSWEP_U_MSR_PMON_CTL0 0x705
|
|
#define HSWEP_U_MSR_PMON_FILTER 0x707
|
|
|
|
#define HSWEP_U_MSR_PMON_UCLK_FIXED_CTL 0x703
|
|
#define HSWEP_U_MSR_PMON_UCLK_FIXED_CTR 0x704
|
|
|
|
#define HSWEP_U_MSR_PMON_BOX_FILTER_TID (0x1 << 0)
|
|
#define HSWEP_U_MSR_PMON_BOX_FILTER_CID (0x1fULL << 1)
|
|
#define HSWEP_U_MSR_PMON_BOX_FILTER_MASK \
|
|
(HSWEP_U_MSR_PMON_BOX_FILTER_TID | \
|
|
HSWEP_U_MSR_PMON_BOX_FILTER_CID)
|
|
|
|
/* Haswell-EP CBo */
|
|
#define HSWEP_C0_MSR_PMON_CTR0 0xe08
|
|
#define HSWEP_C0_MSR_PMON_CTL0 0xe01
|
|
#define HSWEP_C0_MSR_PMON_BOX_CTL 0xe00
|
|
#define HSWEP_C0_MSR_PMON_BOX_FILTER0 0xe05
|
|
#define HSWEP_CBO_MSR_OFFSET 0x10
|
|
|
|
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_TID (0x3fULL << 0)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_LINK (0xfULL << 6)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_STATE (0x7fULL << 17)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_NID (0xffffULL << 32)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_OPC (0x1ffULL << 52)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_C6 (0x1ULL << 61)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_NC (0x1ULL << 62)
|
|
#define HSWEP_CB0_MSR_PMON_BOX_FILTER_ISOC (0x1ULL << 63)
|
|
|
|
|
|
/* Haswell-EP Sbox */
|
|
#define HSWEP_S0_MSR_PMON_CTR0 0x726
|
|
#define HSWEP_S0_MSR_PMON_CTL0 0x721
|
|
#define HSWEP_S0_MSR_PMON_BOX_CTL 0x720
|
|
#define HSWEP_SBOX_MSR_OFFSET 0xa
|
|
#define HSWEP_S_MSR_PMON_RAW_EVENT_MASK (SNBEP_PMON_RAW_EVENT_MASK | \
|
|
SNBEP_CBO_PMON_CTL_TID_EN)
|
|
|
|
/* Haswell-EP PCU */
|
|
#define HSWEP_PCU_MSR_PMON_CTR0 0x717
|
|
#define HSWEP_PCU_MSR_PMON_CTL0 0x711
|
|
#define HSWEP_PCU_MSR_PMON_BOX_CTL 0x710
|
|
#define HSWEP_PCU_MSR_PMON_BOX_FILTER 0x715
|
|
|
|
/* KNL Ubox */
|
|
#define KNL_U_MSR_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_U_MSR_PMON_RAW_EVENT_MASK | \
|
|
SNBEP_CBO_PMON_CTL_TID_EN)
|
|
/* KNL CHA */
|
|
#define KNL_CHA_MSR_OFFSET 0xc
|
|
#define KNL_CHA_MSR_PMON_CTL_QOR (1 << 16)
|
|
#define KNL_CHA_MSR_PMON_RAW_EVENT_MASK \
|
|
(SNBEP_CBO_MSR_PMON_RAW_EVENT_MASK | \
|
|
KNL_CHA_MSR_PMON_CTL_QOR)
|
|
#define KNL_CHA_MSR_PMON_BOX_FILTER_TID 0x1ff
|
|
#define KNL_CHA_MSR_PMON_BOX_FILTER_STATE (7 << 18)
|
|
#define KNL_CHA_MSR_PMON_BOX_FILTER_OP (0xfffffe2aULL << 32)
|
|
|
|
/* KNL EDC/MC UCLK */
|
|
#define KNL_UCLK_MSR_PMON_CTR0_LOW 0x400
|
|
#define KNL_UCLK_MSR_PMON_CTL0 0x420
|
|
#define KNL_UCLK_MSR_PMON_BOX_CTL 0x430
|
|
#define KNL_UCLK_MSR_PMON_UCLK_FIXED_LOW 0x44c
|
|
#define KNL_UCLK_MSR_PMON_UCLK_FIXED_CTL 0x454
|
|
#define KNL_PMON_FIXED_CTL_EN 0x1
|
|
|
|
/* KNL EDC */
|
|
#define KNL_EDC0_ECLK_MSR_PMON_CTR0_LOW 0xa00
|
|
#define KNL_EDC0_ECLK_MSR_PMON_CTL0 0xa20
|
|
#define KNL_EDC0_ECLK_MSR_PMON_BOX_CTL 0xa30
|
|
#define KNL_EDC0_ECLK_MSR_PMON_ECLK_FIXED_LOW 0xa3c
|
|
#define KNL_EDC0_ECLK_MSR_PMON_ECLK_FIXED_CTL 0xa44
|
|
|
|
/* KNL MC */
|
|
#define KNL_MC0_CH0_MSR_PMON_CTR0_LOW 0xb00
|
|
#define KNL_MC0_CH0_MSR_PMON_CTL0 0xb20
|
|
#define KNL_MC0_CH0_MSR_PMON_BOX_CTL 0xb30
|
|
#define KNL_MC0_CH0_MSR_PMON_FIXED_LOW 0xb3c
|
|
#define KNL_MC0_CH0_MSR_PMON_FIXED_CTL 0xb44
|
|
|
|
/* KNL IRP */
|
|
#define KNL_IRP_PCI_PMON_BOX_CTL 0xf0
|
|
#define KNL_IRP_PCI_PMON_RAW_EVENT_MASK (SNBEP_PMON_RAW_EVENT_MASK | \
|
|
KNL_CHA_MSR_PMON_CTL_QOR)
|
|
/* KNL PCU */
|
|
#define KNL_PCU_PMON_CTL_EV_SEL_MASK 0x0000007f
|
|
#define KNL_PCU_PMON_CTL_USE_OCC_CTR (1 << 7)
|
|
#define KNL_PCU_MSR_PMON_CTL_TRESH_MASK 0x3f000000
|
|
#define KNL_PCU_MSR_PMON_RAW_EVENT_MASK \
|
|
(KNL_PCU_PMON_CTL_EV_SEL_MASK | \
|
|
KNL_PCU_PMON_CTL_USE_OCC_CTR | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_SEL_MASK | \
|
|
SNBEP_PMON_CTL_EDGE_DET | \
|
|
SNBEP_CBO_PMON_CTL_TID_EN | \
|
|
SNBEP_PMON_CTL_INVERT | \
|
|
KNL_PCU_MSR_PMON_CTL_TRESH_MASK | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_INVERT | \
|
|
SNBEP_PCU_MSR_PMON_CTL_OCC_EDGE_DET)
|
|
|
|
DEFINE_UNCORE_FORMAT_ATTR(event, event, "config:0-7");
|
|
DEFINE_UNCORE_FORMAT_ATTR(event2, event, "config:0-6");
|
|
DEFINE_UNCORE_FORMAT_ATTR(event_ext, event, "config:0-7,21");
|
|
DEFINE_UNCORE_FORMAT_ATTR(use_occ_ctr, use_occ_ctr, "config:7");
|
|
DEFINE_UNCORE_FORMAT_ATTR(umask, umask, "config:8-15");
|
|
DEFINE_UNCORE_FORMAT_ATTR(qor, qor, "config:16");
|
|
DEFINE_UNCORE_FORMAT_ATTR(edge, edge, "config:18");
|
|
DEFINE_UNCORE_FORMAT_ATTR(tid_en, tid_en, "config:19");
|
|
DEFINE_UNCORE_FORMAT_ATTR(inv, inv, "config:23");
|
|
DEFINE_UNCORE_FORMAT_ATTR(thresh8, thresh, "config:24-31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(thresh6, thresh, "config:24-29");
|
|
DEFINE_UNCORE_FORMAT_ATTR(thresh5, thresh, "config:24-28");
|
|
DEFINE_UNCORE_FORMAT_ATTR(occ_sel, occ_sel, "config:14-15");
|
|
DEFINE_UNCORE_FORMAT_ATTR(occ_invert, occ_invert, "config:30");
|
|
DEFINE_UNCORE_FORMAT_ATTR(occ_edge, occ_edge, "config:14-51");
|
|
DEFINE_UNCORE_FORMAT_ATTR(occ_edge_det, occ_edge_det, "config:31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_tid, filter_tid, "config1:0-4");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_tid2, filter_tid, "config1:0");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_tid3, filter_tid, "config1:0-5");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_tid4, filter_tid, "config1:0-8");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_cid, filter_cid, "config1:5");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_link, filter_link, "config1:5-8");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_link2, filter_link, "config1:6-8");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_link3, filter_link, "config1:12");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_nid, filter_nid, "config1:10-17");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_nid2, filter_nid, "config1:32-47");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_state, filter_state, "config1:18-22");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_state2, filter_state, "config1:17-22");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_state3, filter_state, "config1:17-23");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_state4, filter_state, "config1:18-20");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_local, filter_local, "config1:33");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_all_op, filter_all_op, "config1:35");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_nnm, filter_nnm, "config1:37");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_opc, filter_opc, "config1:23-31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_opc2, filter_opc, "config1:52-60");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_opc3, filter_opc, "config1:41-60");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_nc, filter_nc, "config1:62");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_c6, filter_c6, "config1:61");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_isoc, filter_isoc, "config1:63");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_band0, filter_band0, "config1:0-7");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_band1, filter_band1, "config1:8-15");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_band2, filter_band2, "config1:16-23");
|
|
DEFINE_UNCORE_FORMAT_ATTR(filter_band3, filter_band3, "config1:24-31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_rds, match_rds, "config1:48-51");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_rnid30, match_rnid30, "config1:32-35");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_rnid4, match_rnid4, "config1:31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_dnid, match_dnid, "config1:13-17");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_mc, match_mc, "config1:9-12");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_opc, match_opc, "config1:5-8");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match_vnw, match_vnw, "config1:3-4");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match0, match0, "config1:0-31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(match1, match1, "config1:32-63");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_rds, mask_rds, "config2:48-51");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_rnid30, mask_rnid30, "config2:32-35");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_rnid4, mask_rnid4, "config2:31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_dnid, mask_dnid, "config2:13-17");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_mc, mask_mc, "config2:9-12");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_opc, mask_opc, "config2:5-8");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask_vnw, mask_vnw, "config2:3-4");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask0, mask0, "config2:0-31");
|
|
DEFINE_UNCORE_FORMAT_ATTR(mask1, mask1, "config2:32-63");
|
|
|
|
static void snbep_uncore_pci_disable_box(struct intel_uncore_box *box)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
int box_ctl = uncore_pci_box_ctl(box);
|
|
u32 config = 0;
|
|
|
|
if (!pci_read_config_dword(pdev, box_ctl, &config)) {
|
|
config |= SNBEP_PMON_BOX_CTL_FRZ;
|
|
pci_write_config_dword(pdev, box_ctl, config);
|
|
}
|
|
}
|
|
|
|
static void snbep_uncore_pci_enable_box(struct intel_uncore_box *box)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
int box_ctl = uncore_pci_box_ctl(box);
|
|
u32 config = 0;
|
|
|
|
if (!pci_read_config_dword(pdev, box_ctl, &config)) {
|
|
config &= ~SNBEP_PMON_BOX_CTL_FRZ;
|
|
pci_write_config_dword(pdev, box_ctl, config);
|
|
}
|
|
}
|
|
|
|
static void snbep_uncore_pci_enable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
|
|
pci_write_config_dword(pdev, hwc->config_base, hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static void snbep_uncore_pci_disable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
|
|
pci_write_config_dword(pdev, hwc->config_base, hwc->config);
|
|
}
|
|
|
|
static u64 snbep_uncore_pci_read_counter(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
u64 count = 0;
|
|
|
|
pci_read_config_dword(pdev, hwc->event_base, (u32 *)&count);
|
|
pci_read_config_dword(pdev, hwc->event_base + 4, (u32 *)&count + 1);
|
|
|
|
return count;
|
|
}
|
|
|
|
static void snbep_uncore_pci_init_box(struct intel_uncore_box *box)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
int box_ctl = uncore_pci_box_ctl(box);
|
|
|
|
pci_write_config_dword(pdev, box_ctl, SNBEP_PMON_BOX_CTL_INT);
|
|
}
|
|
|
|
static void snbep_uncore_msr_disable_box(struct intel_uncore_box *box)
|
|
{
|
|
u64 config;
|
|
unsigned msr;
|
|
|
|
msr = uncore_msr_box_ctl(box);
|
|
if (msr) {
|
|
rdmsrl(msr, config);
|
|
config |= SNBEP_PMON_BOX_CTL_FRZ;
|
|
wrmsrl(msr, config);
|
|
}
|
|
}
|
|
|
|
static void snbep_uncore_msr_enable_box(struct intel_uncore_box *box)
|
|
{
|
|
u64 config;
|
|
unsigned msr;
|
|
|
|
msr = uncore_msr_box_ctl(box);
|
|
if (msr) {
|
|
rdmsrl(msr, config);
|
|
config &= ~SNBEP_PMON_BOX_CTL_FRZ;
|
|
wrmsrl(msr, config);
|
|
}
|
|
}
|
|
|
|
static void snbep_uncore_msr_enable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
|
|
if (reg1->idx != EXTRA_REG_NONE)
|
|
wrmsrl(reg1->reg, uncore_shared_reg_config(box, 0));
|
|
|
|
wrmsrl(hwc->config_base, hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static void snbep_uncore_msr_disable_event(struct intel_uncore_box *box,
|
|
struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
|
|
wrmsrl(hwc->config_base, hwc->config);
|
|
}
|
|
|
|
static void snbep_uncore_msr_init_box(struct intel_uncore_box *box)
|
|
{
|
|
unsigned msr = uncore_msr_box_ctl(box);
|
|
|
|
if (msr)
|
|
wrmsrl(msr, SNBEP_PMON_BOX_CTL_INT);
|
|
}
|
|
|
|
static struct attribute *snbep_uncore_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *snbep_uncore_ubox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh5.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *snbep_uncore_cbox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
&format_attr_filter_tid.attr,
|
|
&format_attr_filter_nid.attr,
|
|
&format_attr_filter_state.attr,
|
|
&format_attr_filter_opc.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *snbep_uncore_pcu_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_occ_sel.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh5.attr,
|
|
&format_attr_occ_invert.attr,
|
|
&format_attr_occ_edge.attr,
|
|
&format_attr_filter_band0.attr,
|
|
&format_attr_filter_band1.attr,
|
|
&format_attr_filter_band2.attr,
|
|
&format_attr_filter_band3.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *snbep_uncore_qpi_formats_attr[] = {
|
|
&format_attr_event_ext.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
&format_attr_match_rds.attr,
|
|
&format_attr_match_rnid30.attr,
|
|
&format_attr_match_rnid4.attr,
|
|
&format_attr_match_dnid.attr,
|
|
&format_attr_match_mc.attr,
|
|
&format_attr_match_opc.attr,
|
|
&format_attr_match_vnw.attr,
|
|
&format_attr_match0.attr,
|
|
&format_attr_match1.attr,
|
|
&format_attr_mask_rds.attr,
|
|
&format_attr_mask_rnid30.attr,
|
|
&format_attr_mask_rnid4.attr,
|
|
&format_attr_mask_dnid.attr,
|
|
&format_attr_mask_mc.attr,
|
|
&format_attr_mask_opc.attr,
|
|
&format_attr_mask_vnw.attr,
|
|
&format_attr_mask0.attr,
|
|
&format_attr_mask1.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct uncore_event_desc snbep_uncore_imc_events[] = {
|
|
INTEL_UNCORE_EVENT_DESC(clockticks, "event=0xff,umask=0x00"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_read, "event=0x04,umask=0x03"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_read.scale, "6.103515625e-5"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_read.unit, "MiB"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_write, "event=0x04,umask=0x0c"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_write.scale, "6.103515625e-5"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_write.unit, "MiB"),
|
|
{ /* end: all zeroes */ },
|
|
};
|
|
|
|
static struct uncore_event_desc snbep_uncore_qpi_events[] = {
|
|
INTEL_UNCORE_EVENT_DESC(clockticks, "event=0x14"),
|
|
INTEL_UNCORE_EVENT_DESC(txl_flits_active, "event=0x00,umask=0x06"),
|
|
INTEL_UNCORE_EVENT_DESC(drs_data, "event=0x102,umask=0x08"),
|
|
INTEL_UNCORE_EVENT_DESC(ncb_data, "event=0x103,umask=0x04"),
|
|
{ /* end: all zeroes */ },
|
|
};
|
|
|
|
static struct attribute_group snbep_uncore_format_group = {
|
|
.name = "format",
|
|
.attrs = snbep_uncore_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group snbep_uncore_ubox_format_group = {
|
|
.name = "format",
|
|
.attrs = snbep_uncore_ubox_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group snbep_uncore_cbox_format_group = {
|
|
.name = "format",
|
|
.attrs = snbep_uncore_cbox_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group snbep_uncore_pcu_format_group = {
|
|
.name = "format",
|
|
.attrs = snbep_uncore_pcu_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group snbep_uncore_qpi_format_group = {
|
|
.name = "format",
|
|
.attrs = snbep_uncore_qpi_formats_attr,
|
|
};
|
|
|
|
#define __SNBEP_UNCORE_MSR_OPS_COMMON_INIT() \
|
|
.disable_box = snbep_uncore_msr_disable_box, \
|
|
.enable_box = snbep_uncore_msr_enable_box, \
|
|
.disable_event = snbep_uncore_msr_disable_event, \
|
|
.enable_event = snbep_uncore_msr_enable_event, \
|
|
.read_counter = uncore_msr_read_counter
|
|
|
|
#define SNBEP_UNCORE_MSR_OPS_COMMON_INIT() \
|
|
__SNBEP_UNCORE_MSR_OPS_COMMON_INIT(), \
|
|
.init_box = snbep_uncore_msr_init_box \
|
|
|
|
static struct intel_uncore_ops snbep_uncore_msr_ops = {
|
|
SNBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
};
|
|
|
|
#define SNBEP_UNCORE_PCI_OPS_COMMON_INIT() \
|
|
.init_box = snbep_uncore_pci_init_box, \
|
|
.disable_box = snbep_uncore_pci_disable_box, \
|
|
.enable_box = snbep_uncore_pci_enable_box, \
|
|
.disable_event = snbep_uncore_pci_disable_event, \
|
|
.read_counter = snbep_uncore_pci_read_counter
|
|
|
|
static struct intel_uncore_ops snbep_uncore_pci_ops = {
|
|
SNBEP_UNCORE_PCI_OPS_COMMON_INIT(),
|
|
.enable_event = snbep_uncore_pci_enable_event, \
|
|
};
|
|
|
|
static struct event_constraint snbep_uncore_cbox_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x01, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x02, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x04, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x05, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x07, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x09, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x12, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x13, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x1b, 0xc),
|
|
UNCORE_EVENT_CONSTRAINT(0x1c, 0xc),
|
|
UNCORE_EVENT_CONSTRAINT(0x1d, 0xc),
|
|
UNCORE_EVENT_CONSTRAINT(0x1e, 0xc),
|
|
EVENT_CONSTRAINT_OVERLAP(0x1f, 0xe, 0xff),
|
|
UNCORE_EVENT_CONSTRAINT(0x21, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x31, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x32, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x33, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x34, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x35, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x37, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x38, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x39, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x3b, 0x1),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct event_constraint snbep_uncore_r2pcie_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x10, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x12, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x24, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x25, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x26, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x32, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x33, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x34, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct event_constraint snbep_uncore_r3qpi_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x10, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x12, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x13, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x20, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x21, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x22, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x24, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x25, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x26, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x28, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x29, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2a, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2b, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2c, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2d, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2e, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2f, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x30, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x31, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x32, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x33, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x34, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x37, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x38, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x39, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type snbep_uncore_ubox = {
|
|
.name = "ubox",
|
|
.num_counters = 2,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 44,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_U_MSR_PMON_CTR0,
|
|
.event_ctl = SNBEP_U_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_U_MSR_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = SNBEP_U_MSR_PMON_UCLK_FIXED_CTR,
|
|
.fixed_ctl = SNBEP_U_MSR_PMON_UCLK_FIXED_CTL,
|
|
.ops = &snbep_uncore_msr_ops,
|
|
.format_group = &snbep_uncore_ubox_format_group,
|
|
};
|
|
|
|
static struct extra_reg snbep_uncore_cbox_extra_regs[] = {
|
|
SNBEP_CBO_EVENT_EXTRA_REG(SNBEP_CBO_PMON_CTL_TID_EN,
|
|
SNBEP_CBO_PMON_CTL_TID_EN, 0x1),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0334, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4334, 0xffff, 0x6),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0534, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4534, 0xffff, 0x6),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0934, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4934, 0xffff, 0x6),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4134, 0xffff, 0x6),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0135, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0335, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4135, 0xffff, 0xa),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4335, 0xffff, 0xa),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4435, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4835, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4a35, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x5035, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0136, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0336, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4136, 0xffff, 0xa),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4336, 0xffff, 0xa),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4436, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4836, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4a36, 0xffff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4037, 0x40ff, 0x2),
|
|
EVENT_EXTRA_END
|
|
};
|
|
|
|
static void snbep_cbox_put_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct intel_uncore_extra_reg *er = &box->shared_regs[0];
|
|
int i;
|
|
|
|
if (uncore_box_is_fake(box))
|
|
return;
|
|
|
|
for (i = 0; i < 5; i++) {
|
|
if (reg1->alloc & (0x1 << i))
|
|
atomic_sub(1 << (i * 6), &er->ref);
|
|
}
|
|
reg1->alloc = 0;
|
|
}
|
|
|
|
static struct event_constraint *
|
|
__snbep_cbox_get_constraint(struct intel_uncore_box *box, struct perf_event *event,
|
|
u64 (*cbox_filter_mask)(int fields))
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct intel_uncore_extra_reg *er = &box->shared_regs[0];
|
|
int i, alloc = 0;
|
|
unsigned long flags;
|
|
u64 mask;
|
|
|
|
if (reg1->idx == EXTRA_REG_NONE)
|
|
return NULL;
|
|
|
|
raw_spin_lock_irqsave(&er->lock, flags);
|
|
for (i = 0; i < 5; i++) {
|
|
if (!(reg1->idx & (0x1 << i)))
|
|
continue;
|
|
if (!uncore_box_is_fake(box) && (reg1->alloc & (0x1 << i)))
|
|
continue;
|
|
|
|
mask = cbox_filter_mask(0x1 << i);
|
|
if (!__BITS_VALUE(atomic_read(&er->ref), i, 6) ||
|
|
!((reg1->config ^ er->config) & mask)) {
|
|
atomic_add(1 << (i * 6), &er->ref);
|
|
er->config &= ~mask;
|
|
er->config |= reg1->config & mask;
|
|
alloc |= (0x1 << i);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
raw_spin_unlock_irqrestore(&er->lock, flags);
|
|
if (i < 5)
|
|
goto fail;
|
|
|
|
if (!uncore_box_is_fake(box))
|
|
reg1->alloc |= alloc;
|
|
|
|
return NULL;
|
|
fail:
|
|
for (; i >= 0; i--) {
|
|
if (alloc & (0x1 << i))
|
|
atomic_sub(1 << (i * 6), &er->ref);
|
|
}
|
|
return &uncore_constraint_empty;
|
|
}
|
|
|
|
static u64 snbep_cbox_filter_mask(int fields)
|
|
{
|
|
u64 mask = 0;
|
|
|
|
if (fields & 0x1)
|
|
mask |= SNBEP_CB0_MSR_PMON_BOX_FILTER_TID;
|
|
if (fields & 0x2)
|
|
mask |= SNBEP_CB0_MSR_PMON_BOX_FILTER_NID;
|
|
if (fields & 0x4)
|
|
mask |= SNBEP_CB0_MSR_PMON_BOX_FILTER_STATE;
|
|
if (fields & 0x8)
|
|
mask |= SNBEP_CB0_MSR_PMON_BOX_FILTER_OPC;
|
|
|
|
return mask;
|
|
}
|
|
|
|
static struct event_constraint *
|
|
snbep_cbox_get_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
return __snbep_cbox_get_constraint(box, event, snbep_cbox_filter_mask);
|
|
}
|
|
|
|
static int snbep_cbox_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct extra_reg *er;
|
|
int idx = 0;
|
|
|
|
for (er = snbep_uncore_cbox_extra_regs; er->msr; er++) {
|
|
if (er->event != (event->hw.config & er->config_mask))
|
|
continue;
|
|
idx |= er->idx;
|
|
}
|
|
|
|
if (idx) {
|
|
reg1->reg = SNBEP_C0_MSR_PMON_BOX_FILTER +
|
|
SNBEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;
|
|
reg1->config = event->attr.config1 & snbep_cbox_filter_mask(idx);
|
|
reg1->idx = idx;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct intel_uncore_ops snbep_uncore_cbox_ops = {
|
|
SNBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
.hw_config = snbep_cbox_hw_config,
|
|
.get_constraint = snbep_cbox_get_constraint,
|
|
.put_constraint = snbep_cbox_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type snbep_uncore_cbox = {
|
|
.name = "cbox",
|
|
.num_counters = 4,
|
|
.num_boxes = 8,
|
|
.perf_ctr_bits = 44,
|
|
.event_ctl = SNBEP_C0_MSR_PMON_CTL0,
|
|
.perf_ctr = SNBEP_C0_MSR_PMON_CTR0,
|
|
.event_mask = SNBEP_CBO_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_C0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = SNBEP_CBO_MSR_OFFSET,
|
|
.num_shared_regs = 1,
|
|
.constraints = snbep_uncore_cbox_constraints,
|
|
.ops = &snbep_uncore_cbox_ops,
|
|
.format_group = &snbep_uncore_cbox_format_group,
|
|
};
|
|
|
|
static u64 snbep_pcu_alter_er(struct perf_event *event, int new_idx, bool modify)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
u64 config = reg1->config;
|
|
|
|
if (new_idx > reg1->idx)
|
|
config <<= 8 * (new_idx - reg1->idx);
|
|
else
|
|
config >>= 8 * (reg1->idx - new_idx);
|
|
|
|
if (modify) {
|
|
hwc->config += new_idx - reg1->idx;
|
|
reg1->config = config;
|
|
reg1->idx = new_idx;
|
|
}
|
|
return config;
|
|
}
|
|
|
|
static struct event_constraint *
|
|
snbep_pcu_get_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct intel_uncore_extra_reg *er = &box->shared_regs[0];
|
|
unsigned long flags;
|
|
int idx = reg1->idx;
|
|
u64 mask, config1 = reg1->config;
|
|
bool ok = false;
|
|
|
|
if (reg1->idx == EXTRA_REG_NONE ||
|
|
(!uncore_box_is_fake(box) && reg1->alloc))
|
|
return NULL;
|
|
again:
|
|
mask = 0xffULL << (idx * 8);
|
|
raw_spin_lock_irqsave(&er->lock, flags);
|
|
if (!__BITS_VALUE(atomic_read(&er->ref), idx, 8) ||
|
|
!((config1 ^ er->config) & mask)) {
|
|
atomic_add(1 << (idx * 8), &er->ref);
|
|
er->config &= ~mask;
|
|
er->config |= config1 & mask;
|
|
ok = true;
|
|
}
|
|
raw_spin_unlock_irqrestore(&er->lock, flags);
|
|
|
|
if (!ok) {
|
|
idx = (idx + 1) % 4;
|
|
if (idx != reg1->idx) {
|
|
config1 = snbep_pcu_alter_er(event, idx, false);
|
|
goto again;
|
|
}
|
|
return &uncore_constraint_empty;
|
|
}
|
|
|
|
if (!uncore_box_is_fake(box)) {
|
|
if (idx != reg1->idx)
|
|
snbep_pcu_alter_er(event, idx, true);
|
|
reg1->alloc = 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void snbep_pcu_put_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct intel_uncore_extra_reg *er = &box->shared_regs[0];
|
|
|
|
if (uncore_box_is_fake(box) || !reg1->alloc)
|
|
return;
|
|
|
|
atomic_sub(1 << (reg1->idx * 8), &er->ref);
|
|
reg1->alloc = 0;
|
|
}
|
|
|
|
static int snbep_pcu_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
int ev_sel = hwc->config & SNBEP_PMON_CTL_EV_SEL_MASK;
|
|
|
|
if (ev_sel >= 0xb && ev_sel <= 0xe) {
|
|
reg1->reg = SNBEP_PCU_MSR_PMON_BOX_FILTER;
|
|
reg1->idx = ev_sel - 0xb;
|
|
reg1->config = event->attr.config1 & (0xff << (reg1->idx * 8));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct intel_uncore_ops snbep_uncore_pcu_ops = {
|
|
SNBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
.hw_config = snbep_pcu_hw_config,
|
|
.get_constraint = snbep_pcu_get_constraint,
|
|
.put_constraint = snbep_pcu_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type snbep_uncore_pcu = {
|
|
.name = "pcu",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCU_MSR_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCU_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_PCU_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCU_MSR_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &snbep_uncore_pcu_ops,
|
|
.format_group = &snbep_uncore_pcu_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type *snbep_msr_uncores[] = {
|
|
&snbep_uncore_ubox,
|
|
&snbep_uncore_cbox,
|
|
&snbep_uncore_pcu,
|
|
NULL,
|
|
};
|
|
|
|
void snbep_uncore_cpu_init(void)
|
|
{
|
|
if (snbep_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
|
|
snbep_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
|
|
uncore_msr_uncores = snbep_msr_uncores;
|
|
}
|
|
|
|
enum {
|
|
SNBEP_PCI_QPI_PORT0_FILTER,
|
|
SNBEP_PCI_QPI_PORT1_FILTER,
|
|
HSWEP_PCI_PCU_3,
|
|
};
|
|
|
|
static int snbep_qpi_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
struct hw_perf_event_extra *reg2 = &hwc->branch_reg;
|
|
|
|
if ((hwc->config & SNBEP_PMON_CTL_EV_SEL_MASK) == 0x38) {
|
|
reg1->idx = 0;
|
|
reg1->reg = SNBEP_Q_Py_PCI_PMON_PKT_MATCH0;
|
|
reg1->config = event->attr.config1;
|
|
reg2->reg = SNBEP_Q_Py_PCI_PMON_PKT_MASK0;
|
|
reg2->config = event->attr.config2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void snbep_qpi_enable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
struct hw_perf_event_extra *reg2 = &hwc->branch_reg;
|
|
|
|
if (reg1->idx != EXTRA_REG_NONE) {
|
|
int idx = box->pmu->pmu_idx + SNBEP_PCI_QPI_PORT0_FILTER;
|
|
int pkg = topology_phys_to_logical_pkg(box->pci_phys_id);
|
|
struct pci_dev *filter_pdev = uncore_extra_pci_dev[pkg].dev[idx];
|
|
|
|
if (filter_pdev) {
|
|
pci_write_config_dword(filter_pdev, reg1->reg,
|
|
(u32)reg1->config);
|
|
pci_write_config_dword(filter_pdev, reg1->reg + 4,
|
|
(u32)(reg1->config >> 32));
|
|
pci_write_config_dword(filter_pdev, reg2->reg,
|
|
(u32)reg2->config);
|
|
pci_write_config_dword(filter_pdev, reg2->reg + 4,
|
|
(u32)(reg2->config >> 32));
|
|
}
|
|
}
|
|
|
|
pci_write_config_dword(pdev, hwc->config_base, hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static struct intel_uncore_ops snbep_uncore_qpi_ops = {
|
|
SNBEP_UNCORE_PCI_OPS_COMMON_INIT(),
|
|
.enable_event = snbep_qpi_enable_event,
|
|
.hw_config = snbep_qpi_hw_config,
|
|
.get_constraint = uncore_get_constraint,
|
|
.put_constraint = uncore_put_constraint,
|
|
};
|
|
|
|
#define SNBEP_UNCORE_PCI_COMMON_INIT() \
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0, \
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0, \
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK, \
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL, \
|
|
.ops = &snbep_uncore_pci_ops, \
|
|
.format_group = &snbep_uncore_format_group
|
|
|
|
static struct intel_uncore_type snbep_uncore_ha = {
|
|
.name = "ha",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type snbep_uncore_imc = {
|
|
.name = "imc",
|
|
.num_counters = 4,
|
|
.num_boxes = 4,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.fixed_ctr = SNBEP_MC_CHy_PCI_PMON_FIXED_CTR,
|
|
.fixed_ctl = SNBEP_MC_CHy_PCI_PMON_FIXED_CTL,
|
|
.event_descs = snbep_uncore_imc_events,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type snbep_uncore_qpi = {
|
|
.name = "qpi",
|
|
.num_counters = 4,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0,
|
|
.event_mask = SNBEP_QPI_PCI_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &snbep_uncore_qpi_ops,
|
|
.event_descs = snbep_uncore_qpi_events,
|
|
.format_group = &snbep_uncore_qpi_format_group,
|
|
};
|
|
|
|
|
|
static struct intel_uncore_type snbep_uncore_r2pcie = {
|
|
.name = "r2pcie",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 44,
|
|
.constraints = snbep_uncore_r2pcie_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type snbep_uncore_r3qpi = {
|
|
.name = "r3qpi",
|
|
.num_counters = 3,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 44,
|
|
.constraints = snbep_uncore_r3qpi_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
enum {
|
|
SNBEP_PCI_UNCORE_HA,
|
|
SNBEP_PCI_UNCORE_IMC,
|
|
SNBEP_PCI_UNCORE_QPI,
|
|
SNBEP_PCI_UNCORE_R2PCIE,
|
|
SNBEP_PCI_UNCORE_R3QPI,
|
|
};
|
|
|
|
static struct intel_uncore_type *snbep_pci_uncores[] = {
|
|
[SNBEP_PCI_UNCORE_HA] = &snbep_uncore_ha,
|
|
[SNBEP_PCI_UNCORE_IMC] = &snbep_uncore_imc,
|
|
[SNBEP_PCI_UNCORE_QPI] = &snbep_uncore_qpi,
|
|
[SNBEP_PCI_UNCORE_R2PCIE] = &snbep_uncore_r2pcie,
|
|
[SNBEP_PCI_UNCORE_R3QPI] = &snbep_uncore_r3qpi,
|
|
NULL,
|
|
};
|
|
|
|
static const struct pci_device_id snbep_uncore_pci_ids[] = {
|
|
{ /* Home Agent */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_HA),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_HA, 0),
|
|
},
|
|
{ /* MC Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_IMC0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_IMC, 0),
|
|
},
|
|
{ /* MC Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_IMC1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_IMC, 1),
|
|
},
|
|
{ /* MC Channel 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_IMC2),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_IMC, 2),
|
|
},
|
|
{ /* MC Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_IMC3),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_IMC, 3),
|
|
},
|
|
{ /* QPI Port 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_QPI0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_QPI, 0),
|
|
},
|
|
{ /* QPI Port 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_QPI1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_QPI, 1),
|
|
},
|
|
{ /* R2PCIe */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_R2PCIE),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_R2PCIE, 0),
|
|
},
|
|
{ /* R3QPI Link 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_R3QPI0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_R3QPI, 0),
|
|
},
|
|
{ /* R3QPI Link 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_UNC_R3QPI1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(SNBEP_PCI_UNCORE_R3QPI, 1),
|
|
},
|
|
{ /* QPI Port 0 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x3c86),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
SNBEP_PCI_QPI_PORT0_FILTER),
|
|
},
|
|
{ /* QPI Port 0 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x3c96),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
SNBEP_PCI_QPI_PORT1_FILTER),
|
|
},
|
|
{ /* end: all zeroes */ }
|
|
};
|
|
|
|
static struct pci_driver snbep_uncore_pci_driver = {
|
|
.name = "snbep_uncore",
|
|
.id_table = snbep_uncore_pci_ids,
|
|
};
|
|
|
|
/*
|
|
* build pci bus to socket mapping
|
|
*/
|
|
static int snbep_pci2phy_map_init(int devid)
|
|
{
|
|
struct pci_dev *ubox_dev = NULL;
|
|
int i, bus, nodeid, segment;
|
|
struct pci2phy_map *map;
|
|
int err = 0;
|
|
u32 config = 0;
|
|
|
|
while (1) {
|
|
/* find the UBOX device */
|
|
ubox_dev = pci_get_device(PCI_VENDOR_ID_INTEL, devid, ubox_dev);
|
|
if (!ubox_dev)
|
|
break;
|
|
bus = ubox_dev->bus->number;
|
|
/* get the Node ID of the local register */
|
|
err = pci_read_config_dword(ubox_dev, 0x40, &config);
|
|
if (err)
|
|
break;
|
|
nodeid = config;
|
|
/* get the Node ID mapping */
|
|
err = pci_read_config_dword(ubox_dev, 0x54, &config);
|
|
if (err)
|
|
break;
|
|
|
|
segment = pci_domain_nr(ubox_dev->bus);
|
|
raw_spin_lock(&pci2phy_map_lock);
|
|
map = __find_pci2phy_map(segment);
|
|
if (!map) {
|
|
raw_spin_unlock(&pci2phy_map_lock);
|
|
err = -ENOMEM;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* every three bits in the Node ID mapping register maps
|
|
* to a particular node.
|
|
*/
|
|
for (i = 0; i < 8; i++) {
|
|
if (nodeid == ((config >> (3 * i)) & 0x7)) {
|
|
map->pbus_to_physid[bus] = i;
|
|
break;
|
|
}
|
|
}
|
|
raw_spin_unlock(&pci2phy_map_lock);
|
|
}
|
|
|
|
if (!err) {
|
|
/*
|
|
* For PCI bus with no UBOX device, find the next bus
|
|
* that has UBOX device and use its mapping.
|
|
*/
|
|
raw_spin_lock(&pci2phy_map_lock);
|
|
list_for_each_entry(map, &pci2phy_map_head, list) {
|
|
i = -1;
|
|
for (bus = 255; bus >= 0; bus--) {
|
|
if (map->pbus_to_physid[bus] >= 0)
|
|
i = map->pbus_to_physid[bus];
|
|
else
|
|
map->pbus_to_physid[bus] = i;
|
|
}
|
|
}
|
|
raw_spin_unlock(&pci2phy_map_lock);
|
|
}
|
|
|
|
pci_dev_put(ubox_dev);
|
|
|
|
return err ? pcibios_err_to_errno(err) : 0;
|
|
}
|
|
|
|
int snbep_uncore_pci_init(void)
|
|
{
|
|
int ret = snbep_pci2phy_map_init(0x3ce0);
|
|
if (ret)
|
|
return ret;
|
|
uncore_pci_uncores = snbep_pci_uncores;
|
|
uncore_pci_driver = &snbep_uncore_pci_driver;
|
|
return 0;
|
|
}
|
|
/* end of Sandy Bridge-EP uncore support */
|
|
|
|
/* IvyTown uncore support */
|
|
static void ivbep_uncore_msr_init_box(struct intel_uncore_box *box)
|
|
{
|
|
unsigned msr = uncore_msr_box_ctl(box);
|
|
if (msr)
|
|
wrmsrl(msr, IVBEP_PMON_BOX_CTL_INT);
|
|
}
|
|
|
|
static void ivbep_uncore_pci_init_box(struct intel_uncore_box *box)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
|
|
pci_write_config_dword(pdev, SNBEP_PCI_PMON_BOX_CTL, IVBEP_PMON_BOX_CTL_INT);
|
|
}
|
|
|
|
#define IVBEP_UNCORE_MSR_OPS_COMMON_INIT() \
|
|
.init_box = ivbep_uncore_msr_init_box, \
|
|
.disable_box = snbep_uncore_msr_disable_box, \
|
|
.enable_box = snbep_uncore_msr_enable_box, \
|
|
.disable_event = snbep_uncore_msr_disable_event, \
|
|
.enable_event = snbep_uncore_msr_enable_event, \
|
|
.read_counter = uncore_msr_read_counter
|
|
|
|
static struct intel_uncore_ops ivbep_uncore_msr_ops = {
|
|
IVBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_ops ivbep_uncore_pci_ops = {
|
|
.init_box = ivbep_uncore_pci_init_box,
|
|
.disable_box = snbep_uncore_pci_disable_box,
|
|
.enable_box = snbep_uncore_pci_enable_box,
|
|
.disable_event = snbep_uncore_pci_disable_event,
|
|
.enable_event = snbep_uncore_pci_enable_event,
|
|
.read_counter = snbep_uncore_pci_read_counter,
|
|
};
|
|
|
|
#define IVBEP_UNCORE_PCI_COMMON_INIT() \
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0, \
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0, \
|
|
.event_mask = IVBEP_PMON_RAW_EVENT_MASK, \
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL, \
|
|
.ops = &ivbep_uncore_pci_ops, \
|
|
.format_group = &ivbep_uncore_format_group
|
|
|
|
static struct attribute *ivbep_uncore_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *ivbep_uncore_ubox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh5.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *ivbep_uncore_cbox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_thresh8.attr,
|
|
&format_attr_filter_tid.attr,
|
|
&format_attr_filter_link.attr,
|
|
&format_attr_filter_state2.attr,
|
|
&format_attr_filter_nid2.attr,
|
|
&format_attr_filter_opc2.attr,
|
|
&format_attr_filter_nc.attr,
|
|
&format_attr_filter_c6.attr,
|
|
&format_attr_filter_isoc.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *ivbep_uncore_pcu_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_occ_sel.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_thresh5.attr,
|
|
&format_attr_occ_invert.attr,
|
|
&format_attr_occ_edge.attr,
|
|
&format_attr_filter_band0.attr,
|
|
&format_attr_filter_band1.attr,
|
|
&format_attr_filter_band2.attr,
|
|
&format_attr_filter_band3.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute *ivbep_uncore_qpi_formats_attr[] = {
|
|
&format_attr_event_ext.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_thresh8.attr,
|
|
&format_attr_match_rds.attr,
|
|
&format_attr_match_rnid30.attr,
|
|
&format_attr_match_rnid4.attr,
|
|
&format_attr_match_dnid.attr,
|
|
&format_attr_match_mc.attr,
|
|
&format_attr_match_opc.attr,
|
|
&format_attr_match_vnw.attr,
|
|
&format_attr_match0.attr,
|
|
&format_attr_match1.attr,
|
|
&format_attr_mask_rds.attr,
|
|
&format_attr_mask_rnid30.attr,
|
|
&format_attr_mask_rnid4.attr,
|
|
&format_attr_mask_dnid.attr,
|
|
&format_attr_mask_mc.attr,
|
|
&format_attr_mask_opc.attr,
|
|
&format_attr_mask_vnw.attr,
|
|
&format_attr_mask0.attr,
|
|
&format_attr_mask1.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group ivbep_uncore_format_group = {
|
|
.name = "format",
|
|
.attrs = ivbep_uncore_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group ivbep_uncore_ubox_format_group = {
|
|
.name = "format",
|
|
.attrs = ivbep_uncore_ubox_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group ivbep_uncore_cbox_format_group = {
|
|
.name = "format",
|
|
.attrs = ivbep_uncore_cbox_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group ivbep_uncore_pcu_format_group = {
|
|
.name = "format",
|
|
.attrs = ivbep_uncore_pcu_formats_attr,
|
|
};
|
|
|
|
static struct attribute_group ivbep_uncore_qpi_format_group = {
|
|
.name = "format",
|
|
.attrs = ivbep_uncore_qpi_formats_attr,
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_ubox = {
|
|
.name = "ubox",
|
|
.num_counters = 2,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 44,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_U_MSR_PMON_CTR0,
|
|
.event_ctl = SNBEP_U_MSR_PMON_CTL0,
|
|
.event_mask = IVBEP_U_MSR_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = SNBEP_U_MSR_PMON_UCLK_FIXED_CTR,
|
|
.fixed_ctl = SNBEP_U_MSR_PMON_UCLK_FIXED_CTL,
|
|
.ops = &ivbep_uncore_msr_ops,
|
|
.format_group = &ivbep_uncore_ubox_format_group,
|
|
};
|
|
|
|
static struct extra_reg ivbep_uncore_cbox_extra_regs[] = {
|
|
SNBEP_CBO_EVENT_EXTRA_REG(SNBEP_CBO_PMON_CTL_TID_EN,
|
|
SNBEP_CBO_PMON_CTL_TID_EN, 0x1),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x1031, 0x10ff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x1134, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4134, 0xffff, 0xc),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x5134, 0xffff, 0xc),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0334, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4334, 0xffff, 0xc),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0534, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4534, 0xffff, 0xc),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0934, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4934, 0xffff, 0xc),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0135, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0335, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2135, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2335, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4135, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4335, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4435, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4835, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4a35, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x5035, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8135, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8335, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0136, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0336, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2136, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2336, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4136, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4336, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4436, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4836, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4a36, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x5036, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8136, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8336, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4037, 0x40ff, 0x8),
|
|
EVENT_EXTRA_END
|
|
};
|
|
|
|
static u64 ivbep_cbox_filter_mask(int fields)
|
|
{
|
|
u64 mask = 0;
|
|
|
|
if (fields & 0x1)
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_TID;
|
|
if (fields & 0x2)
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_LINK;
|
|
if (fields & 0x4)
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_STATE;
|
|
if (fields & 0x8)
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_NID;
|
|
if (fields & 0x10) {
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_OPC;
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_NC;
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_C6;
|
|
mask |= IVBEP_CB0_MSR_PMON_BOX_FILTER_ISOC;
|
|
}
|
|
|
|
return mask;
|
|
}
|
|
|
|
static struct event_constraint *
|
|
ivbep_cbox_get_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
return __snbep_cbox_get_constraint(box, event, ivbep_cbox_filter_mask);
|
|
}
|
|
|
|
static int ivbep_cbox_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct extra_reg *er;
|
|
int idx = 0;
|
|
|
|
for (er = ivbep_uncore_cbox_extra_regs; er->msr; er++) {
|
|
if (er->event != (event->hw.config & er->config_mask))
|
|
continue;
|
|
idx |= er->idx;
|
|
}
|
|
|
|
if (idx) {
|
|
reg1->reg = SNBEP_C0_MSR_PMON_BOX_FILTER +
|
|
SNBEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;
|
|
reg1->config = event->attr.config1 & ivbep_cbox_filter_mask(idx);
|
|
reg1->idx = idx;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void ivbep_cbox_enable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
|
|
if (reg1->idx != EXTRA_REG_NONE) {
|
|
u64 filter = uncore_shared_reg_config(box, 0);
|
|
wrmsrl(reg1->reg, filter & 0xffffffff);
|
|
wrmsrl(reg1->reg + 6, filter >> 32);
|
|
}
|
|
|
|
wrmsrl(hwc->config_base, hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static struct intel_uncore_ops ivbep_uncore_cbox_ops = {
|
|
.init_box = ivbep_uncore_msr_init_box,
|
|
.disable_box = snbep_uncore_msr_disable_box,
|
|
.enable_box = snbep_uncore_msr_enable_box,
|
|
.disable_event = snbep_uncore_msr_disable_event,
|
|
.enable_event = ivbep_cbox_enable_event,
|
|
.read_counter = uncore_msr_read_counter,
|
|
.hw_config = ivbep_cbox_hw_config,
|
|
.get_constraint = ivbep_cbox_get_constraint,
|
|
.put_constraint = snbep_cbox_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_cbox = {
|
|
.name = "cbox",
|
|
.num_counters = 4,
|
|
.num_boxes = 15,
|
|
.perf_ctr_bits = 44,
|
|
.event_ctl = SNBEP_C0_MSR_PMON_CTL0,
|
|
.perf_ctr = SNBEP_C0_MSR_PMON_CTR0,
|
|
.event_mask = IVBEP_CBO_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_C0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = SNBEP_CBO_MSR_OFFSET,
|
|
.num_shared_regs = 1,
|
|
.constraints = snbep_uncore_cbox_constraints,
|
|
.ops = &ivbep_uncore_cbox_ops,
|
|
.format_group = &ivbep_uncore_cbox_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_ops ivbep_uncore_pcu_ops = {
|
|
IVBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
.hw_config = snbep_pcu_hw_config,
|
|
.get_constraint = snbep_pcu_get_constraint,
|
|
.put_constraint = snbep_pcu_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_pcu = {
|
|
.name = "pcu",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCU_MSR_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCU_MSR_PMON_CTL0,
|
|
.event_mask = IVBEP_PCU_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCU_MSR_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &ivbep_uncore_pcu_ops,
|
|
.format_group = &ivbep_uncore_pcu_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type *ivbep_msr_uncores[] = {
|
|
&ivbep_uncore_ubox,
|
|
&ivbep_uncore_cbox,
|
|
&ivbep_uncore_pcu,
|
|
NULL,
|
|
};
|
|
|
|
void ivbep_uncore_cpu_init(void)
|
|
{
|
|
if (ivbep_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
|
|
ivbep_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
|
|
uncore_msr_uncores = ivbep_msr_uncores;
|
|
}
|
|
|
|
static struct intel_uncore_type ivbep_uncore_ha = {
|
|
.name = "ha",
|
|
.num_counters = 4,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 48,
|
|
IVBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_imc = {
|
|
.name = "imc",
|
|
.num_counters = 4,
|
|
.num_boxes = 8,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.fixed_ctr = SNBEP_MC_CHy_PCI_PMON_FIXED_CTR,
|
|
.fixed_ctl = SNBEP_MC_CHy_PCI_PMON_FIXED_CTL,
|
|
.event_descs = snbep_uncore_imc_events,
|
|
IVBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
/* registers in IRP boxes are not properly aligned */
|
|
static unsigned ivbep_uncore_irp_ctls[] = {0xd8, 0xdc, 0xe0, 0xe4};
|
|
static unsigned ivbep_uncore_irp_ctrs[] = {0xa0, 0xb0, 0xb8, 0xc0};
|
|
|
|
static void ivbep_uncore_irp_enable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
|
|
pci_write_config_dword(pdev, ivbep_uncore_irp_ctls[hwc->idx],
|
|
hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static void ivbep_uncore_irp_disable_event(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
|
|
pci_write_config_dword(pdev, ivbep_uncore_irp_ctls[hwc->idx], hwc->config);
|
|
}
|
|
|
|
static u64 ivbep_uncore_irp_read_counter(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
u64 count = 0;
|
|
|
|
pci_read_config_dword(pdev, ivbep_uncore_irp_ctrs[hwc->idx], (u32 *)&count);
|
|
pci_read_config_dword(pdev, ivbep_uncore_irp_ctrs[hwc->idx] + 4, (u32 *)&count + 1);
|
|
|
|
return count;
|
|
}
|
|
|
|
static struct intel_uncore_ops ivbep_uncore_irp_ops = {
|
|
.init_box = ivbep_uncore_pci_init_box,
|
|
.disable_box = snbep_uncore_pci_disable_box,
|
|
.enable_box = snbep_uncore_pci_enable_box,
|
|
.disable_event = ivbep_uncore_irp_disable_event,
|
|
.enable_event = ivbep_uncore_irp_enable_event,
|
|
.read_counter = ivbep_uncore_irp_read_counter,
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_irp = {
|
|
.name = "irp",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.event_mask = IVBEP_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.ops = &ivbep_uncore_irp_ops,
|
|
.format_group = &ivbep_uncore_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_ops ivbep_uncore_qpi_ops = {
|
|
.init_box = ivbep_uncore_pci_init_box,
|
|
.disable_box = snbep_uncore_pci_disable_box,
|
|
.enable_box = snbep_uncore_pci_enable_box,
|
|
.disable_event = snbep_uncore_pci_disable_event,
|
|
.enable_event = snbep_qpi_enable_event,
|
|
.read_counter = snbep_uncore_pci_read_counter,
|
|
.hw_config = snbep_qpi_hw_config,
|
|
.get_constraint = uncore_get_constraint,
|
|
.put_constraint = uncore_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_qpi = {
|
|
.name = "qpi",
|
|
.num_counters = 4,
|
|
.num_boxes = 3,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0,
|
|
.event_mask = IVBEP_QPI_PCI_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &ivbep_uncore_qpi_ops,
|
|
.format_group = &ivbep_uncore_qpi_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_r2pcie = {
|
|
.name = "r2pcie",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 44,
|
|
.constraints = snbep_uncore_r2pcie_constraints,
|
|
IVBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type ivbep_uncore_r3qpi = {
|
|
.name = "r3qpi",
|
|
.num_counters = 3,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 44,
|
|
.constraints = snbep_uncore_r3qpi_constraints,
|
|
IVBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
enum {
|
|
IVBEP_PCI_UNCORE_HA,
|
|
IVBEP_PCI_UNCORE_IMC,
|
|
IVBEP_PCI_UNCORE_IRP,
|
|
IVBEP_PCI_UNCORE_QPI,
|
|
IVBEP_PCI_UNCORE_R2PCIE,
|
|
IVBEP_PCI_UNCORE_R3QPI,
|
|
};
|
|
|
|
static struct intel_uncore_type *ivbep_pci_uncores[] = {
|
|
[IVBEP_PCI_UNCORE_HA] = &ivbep_uncore_ha,
|
|
[IVBEP_PCI_UNCORE_IMC] = &ivbep_uncore_imc,
|
|
[IVBEP_PCI_UNCORE_IRP] = &ivbep_uncore_irp,
|
|
[IVBEP_PCI_UNCORE_QPI] = &ivbep_uncore_qpi,
|
|
[IVBEP_PCI_UNCORE_R2PCIE] = &ivbep_uncore_r2pcie,
|
|
[IVBEP_PCI_UNCORE_R3QPI] = &ivbep_uncore_r3qpi,
|
|
NULL,
|
|
};
|
|
|
|
static const struct pci_device_id ivbep_uncore_pci_ids[] = {
|
|
{ /* Home Agent 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe30),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_HA, 0),
|
|
},
|
|
{ /* Home Agent 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe38),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_HA, 1),
|
|
},
|
|
{ /* MC0 Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xeb4),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 0),
|
|
},
|
|
{ /* MC0 Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xeb5),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 1),
|
|
},
|
|
{ /* MC0 Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xeb0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 2),
|
|
},
|
|
{ /* MC0 Channel 4 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xeb1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 3),
|
|
},
|
|
{ /* MC1 Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xef4),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 4),
|
|
},
|
|
{ /* MC1 Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xef5),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 5),
|
|
},
|
|
{ /* MC1 Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xef0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 6),
|
|
},
|
|
{ /* MC1 Channel 4 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xef1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IMC, 7),
|
|
},
|
|
{ /* IRP */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe39),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_IRP, 0),
|
|
},
|
|
{ /* QPI0 Port 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe32),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_QPI, 0),
|
|
},
|
|
{ /* QPI0 Port 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe33),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_QPI, 1),
|
|
},
|
|
{ /* QPI1 Port 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe3a),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_QPI, 2),
|
|
},
|
|
{ /* R2PCIe */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe34),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_R2PCIE, 0),
|
|
},
|
|
{ /* R3QPI0 Link 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe36),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_R3QPI, 0),
|
|
},
|
|
{ /* R3QPI0 Link 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe37),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_R3QPI, 1),
|
|
},
|
|
{ /* R3QPI1 Link 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe3e),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(IVBEP_PCI_UNCORE_R3QPI, 2),
|
|
},
|
|
{ /* QPI Port 0 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe86),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
SNBEP_PCI_QPI_PORT0_FILTER),
|
|
},
|
|
{ /* QPI Port 0 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe96),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
SNBEP_PCI_QPI_PORT1_FILTER),
|
|
},
|
|
{ /* end: all zeroes */ }
|
|
};
|
|
|
|
static struct pci_driver ivbep_uncore_pci_driver = {
|
|
.name = "ivbep_uncore",
|
|
.id_table = ivbep_uncore_pci_ids,
|
|
};
|
|
|
|
int ivbep_uncore_pci_init(void)
|
|
{
|
|
int ret = snbep_pci2phy_map_init(0x0e1e);
|
|
if (ret)
|
|
return ret;
|
|
uncore_pci_uncores = ivbep_pci_uncores;
|
|
uncore_pci_driver = &ivbep_uncore_pci_driver;
|
|
return 0;
|
|
}
|
|
/* end of IvyTown uncore support */
|
|
|
|
/* KNL uncore support */
|
|
static struct attribute *knl_uncore_ubox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh5.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group knl_uncore_ubox_format_group = {
|
|
.name = "format",
|
|
.attrs = knl_uncore_ubox_formats_attr,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_ubox = {
|
|
.name = "ubox",
|
|
.num_counters = 2,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = HSWEP_U_MSR_PMON_CTR0,
|
|
.event_ctl = HSWEP_U_MSR_PMON_CTL0,
|
|
.event_mask = KNL_U_MSR_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = HSWEP_U_MSR_PMON_UCLK_FIXED_CTR,
|
|
.fixed_ctl = HSWEP_U_MSR_PMON_UCLK_FIXED_CTL,
|
|
.ops = &snbep_uncore_msr_ops,
|
|
.format_group = &knl_uncore_ubox_format_group,
|
|
};
|
|
|
|
static struct attribute *knl_uncore_cha_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_qor.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
&format_attr_filter_tid4.attr,
|
|
&format_attr_filter_link3.attr,
|
|
&format_attr_filter_state4.attr,
|
|
&format_attr_filter_local.attr,
|
|
&format_attr_filter_all_op.attr,
|
|
&format_attr_filter_nnm.attr,
|
|
&format_attr_filter_opc3.attr,
|
|
&format_attr_filter_nc.attr,
|
|
&format_attr_filter_isoc.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group knl_uncore_cha_format_group = {
|
|
.name = "format",
|
|
.attrs = knl_uncore_cha_formats_attr,
|
|
};
|
|
|
|
static struct event_constraint knl_uncore_cha_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x1f, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x1),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct extra_reg knl_uncore_cha_extra_regs[] = {
|
|
SNBEP_CBO_EVENT_EXTRA_REG(SNBEP_CBO_PMON_CTL_TID_EN,
|
|
SNBEP_CBO_PMON_CTL_TID_EN, 0x1),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x3d, 0xff, 0x2),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x35, 0xff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x36, 0xff, 0x4),
|
|
EVENT_EXTRA_END
|
|
};
|
|
|
|
static u64 knl_cha_filter_mask(int fields)
|
|
{
|
|
u64 mask = 0;
|
|
|
|
if (fields & 0x1)
|
|
mask |= KNL_CHA_MSR_PMON_BOX_FILTER_TID;
|
|
if (fields & 0x2)
|
|
mask |= KNL_CHA_MSR_PMON_BOX_FILTER_STATE;
|
|
if (fields & 0x4)
|
|
mask |= KNL_CHA_MSR_PMON_BOX_FILTER_OP;
|
|
return mask;
|
|
}
|
|
|
|
static struct event_constraint *
|
|
knl_cha_get_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
return __snbep_cbox_get_constraint(box, event, knl_cha_filter_mask);
|
|
}
|
|
|
|
static int knl_cha_hw_config(struct intel_uncore_box *box,
|
|
struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct extra_reg *er;
|
|
int idx = 0;
|
|
|
|
for (er = knl_uncore_cha_extra_regs; er->msr; er++) {
|
|
if (er->event != (event->hw.config & er->config_mask))
|
|
continue;
|
|
idx |= er->idx;
|
|
}
|
|
|
|
if (idx) {
|
|
reg1->reg = HSWEP_C0_MSR_PMON_BOX_FILTER0 +
|
|
KNL_CHA_MSR_OFFSET * box->pmu->pmu_idx;
|
|
reg1->config = event->attr.config1 & knl_cha_filter_mask(idx);
|
|
reg1->idx = idx;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void hswep_cbox_enable_event(struct intel_uncore_box *box,
|
|
struct perf_event *event);
|
|
|
|
static struct intel_uncore_ops knl_uncore_cha_ops = {
|
|
.init_box = snbep_uncore_msr_init_box,
|
|
.disable_box = snbep_uncore_msr_disable_box,
|
|
.enable_box = snbep_uncore_msr_enable_box,
|
|
.disable_event = snbep_uncore_msr_disable_event,
|
|
.enable_event = hswep_cbox_enable_event,
|
|
.read_counter = uncore_msr_read_counter,
|
|
.hw_config = knl_cha_hw_config,
|
|
.get_constraint = knl_cha_get_constraint,
|
|
.put_constraint = snbep_cbox_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_cha = {
|
|
.name = "cha",
|
|
.num_counters = 4,
|
|
.num_boxes = 38,
|
|
.perf_ctr_bits = 48,
|
|
.event_ctl = HSWEP_C0_MSR_PMON_CTL0,
|
|
.perf_ctr = HSWEP_C0_MSR_PMON_CTR0,
|
|
.event_mask = KNL_CHA_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_C0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = KNL_CHA_MSR_OFFSET,
|
|
.num_shared_regs = 1,
|
|
.constraints = knl_uncore_cha_constraints,
|
|
.ops = &knl_uncore_cha_ops,
|
|
.format_group = &knl_uncore_cha_format_group,
|
|
};
|
|
|
|
static struct attribute *knl_uncore_pcu_formats_attr[] = {
|
|
&format_attr_event2.attr,
|
|
&format_attr_use_occ_ctr.attr,
|
|
&format_attr_occ_sel.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh6.attr,
|
|
&format_attr_occ_invert.attr,
|
|
&format_attr_occ_edge_det.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group knl_uncore_pcu_format_group = {
|
|
.name = "format",
|
|
.attrs = knl_uncore_pcu_formats_attr,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_pcu = {
|
|
.name = "pcu",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = HSWEP_PCU_MSR_PMON_CTR0,
|
|
.event_ctl = HSWEP_PCU_MSR_PMON_CTL0,
|
|
.event_mask = KNL_PCU_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_PCU_MSR_PMON_BOX_CTL,
|
|
.ops = &snbep_uncore_msr_ops,
|
|
.format_group = &knl_uncore_pcu_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type *knl_msr_uncores[] = {
|
|
&knl_uncore_ubox,
|
|
&knl_uncore_cha,
|
|
&knl_uncore_pcu,
|
|
NULL,
|
|
};
|
|
|
|
void knl_uncore_cpu_init(void)
|
|
{
|
|
uncore_msr_uncores = knl_msr_uncores;
|
|
}
|
|
|
|
static void knl_uncore_imc_enable_box(struct intel_uncore_box *box)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
int box_ctl = uncore_pci_box_ctl(box);
|
|
|
|
pci_write_config_dword(pdev, box_ctl, 0);
|
|
}
|
|
|
|
static void knl_uncore_imc_enable_event(struct intel_uncore_box *box,
|
|
struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
|
|
if ((event->attr.config & SNBEP_PMON_CTL_EV_SEL_MASK)
|
|
== UNCORE_FIXED_EVENT)
|
|
pci_write_config_dword(pdev, hwc->config_base,
|
|
hwc->config | KNL_PMON_FIXED_CTL_EN);
|
|
else
|
|
pci_write_config_dword(pdev, hwc->config_base,
|
|
hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static struct intel_uncore_ops knl_uncore_imc_ops = {
|
|
.init_box = snbep_uncore_pci_init_box,
|
|
.disable_box = snbep_uncore_pci_disable_box,
|
|
.enable_box = knl_uncore_imc_enable_box,
|
|
.read_counter = snbep_uncore_pci_read_counter,
|
|
.enable_event = knl_uncore_imc_enable_event,
|
|
.disable_event = snbep_uncore_pci_disable_event,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_imc_uclk = {
|
|
.name = "imc_uclk",
|
|
.num_counters = 4,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = KNL_UCLK_MSR_PMON_CTR0_LOW,
|
|
.event_ctl = KNL_UCLK_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = KNL_UCLK_MSR_PMON_UCLK_FIXED_LOW,
|
|
.fixed_ctl = KNL_UCLK_MSR_PMON_UCLK_FIXED_CTL,
|
|
.box_ctl = KNL_UCLK_MSR_PMON_BOX_CTL,
|
|
.ops = &knl_uncore_imc_ops,
|
|
.format_group = &snbep_uncore_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_imc_dclk = {
|
|
.name = "imc",
|
|
.num_counters = 4,
|
|
.num_boxes = 6,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = KNL_MC0_CH0_MSR_PMON_CTR0_LOW,
|
|
.event_ctl = KNL_MC0_CH0_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = KNL_MC0_CH0_MSR_PMON_FIXED_LOW,
|
|
.fixed_ctl = KNL_MC0_CH0_MSR_PMON_FIXED_CTL,
|
|
.box_ctl = KNL_MC0_CH0_MSR_PMON_BOX_CTL,
|
|
.ops = &knl_uncore_imc_ops,
|
|
.format_group = &snbep_uncore_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_edc_uclk = {
|
|
.name = "edc_uclk",
|
|
.num_counters = 4,
|
|
.num_boxes = 8,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = KNL_UCLK_MSR_PMON_CTR0_LOW,
|
|
.event_ctl = KNL_UCLK_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = KNL_UCLK_MSR_PMON_UCLK_FIXED_LOW,
|
|
.fixed_ctl = KNL_UCLK_MSR_PMON_UCLK_FIXED_CTL,
|
|
.box_ctl = KNL_UCLK_MSR_PMON_BOX_CTL,
|
|
.ops = &knl_uncore_imc_ops,
|
|
.format_group = &snbep_uncore_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_edc_eclk = {
|
|
.name = "edc_eclk",
|
|
.num_counters = 4,
|
|
.num_boxes = 8,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = KNL_EDC0_ECLK_MSR_PMON_CTR0_LOW,
|
|
.event_ctl = KNL_EDC0_ECLK_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = KNL_EDC0_ECLK_MSR_PMON_ECLK_FIXED_LOW,
|
|
.fixed_ctl = KNL_EDC0_ECLK_MSR_PMON_ECLK_FIXED_CTL,
|
|
.box_ctl = KNL_EDC0_ECLK_MSR_PMON_BOX_CTL,
|
|
.ops = &knl_uncore_imc_ops,
|
|
.format_group = &snbep_uncore_format_group,
|
|
};
|
|
|
|
static struct event_constraint knl_uncore_m2pcie_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_m2pcie = {
|
|
.name = "m2pcie",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.constraints = knl_uncore_m2pcie_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct attribute *knl_uncore_irp_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_qor.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group knl_uncore_irp_format_group = {
|
|
.name = "format",
|
|
.attrs = knl_uncore_irp_formats_attr,
|
|
};
|
|
|
|
static struct intel_uncore_type knl_uncore_irp = {
|
|
.name = "irp",
|
|
.num_counters = 2,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0,
|
|
.event_mask = KNL_IRP_PCI_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = KNL_IRP_PCI_PMON_BOX_CTL,
|
|
.ops = &snbep_uncore_pci_ops,
|
|
.format_group = &knl_uncore_irp_format_group,
|
|
};
|
|
|
|
enum {
|
|
KNL_PCI_UNCORE_MC_UCLK,
|
|
KNL_PCI_UNCORE_MC_DCLK,
|
|
KNL_PCI_UNCORE_EDC_UCLK,
|
|
KNL_PCI_UNCORE_EDC_ECLK,
|
|
KNL_PCI_UNCORE_M2PCIE,
|
|
KNL_PCI_UNCORE_IRP,
|
|
};
|
|
|
|
static struct intel_uncore_type *knl_pci_uncores[] = {
|
|
[KNL_PCI_UNCORE_MC_UCLK] = &knl_uncore_imc_uclk,
|
|
[KNL_PCI_UNCORE_MC_DCLK] = &knl_uncore_imc_dclk,
|
|
[KNL_PCI_UNCORE_EDC_UCLK] = &knl_uncore_edc_uclk,
|
|
[KNL_PCI_UNCORE_EDC_ECLK] = &knl_uncore_edc_eclk,
|
|
[KNL_PCI_UNCORE_M2PCIE] = &knl_uncore_m2pcie,
|
|
[KNL_PCI_UNCORE_IRP] = &knl_uncore_irp,
|
|
NULL,
|
|
};
|
|
|
|
/*
|
|
* KNL uses a common PCI device ID for multiple instances of an Uncore PMU
|
|
* device type. prior to KNL, each instance of a PMU device type had a unique
|
|
* device ID.
|
|
*
|
|
* PCI Device ID Uncore PMU Devices
|
|
* ----------------------------------
|
|
* 0x7841 MC0 UClk, MC1 UClk
|
|
* 0x7843 MC0 DClk CH 0, MC0 DClk CH 1, MC0 DClk CH 2,
|
|
* MC1 DClk CH 0, MC1 DClk CH 1, MC1 DClk CH 2
|
|
* 0x7833 EDC0 UClk, EDC1 UClk, EDC2 UClk, EDC3 UClk,
|
|
* EDC4 UClk, EDC5 UClk, EDC6 UClk, EDC7 UClk
|
|
* 0x7835 EDC0 EClk, EDC1 EClk, EDC2 EClk, EDC3 EClk,
|
|
* EDC4 EClk, EDC5 EClk, EDC6 EClk, EDC7 EClk
|
|
* 0x7817 M2PCIe
|
|
* 0x7814 IRP
|
|
*/
|
|
|
|
static const struct pci_device_id knl_uncore_pci_ids[] = {
|
|
{ /* MC UClk */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x7841),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(KNL_PCI_UNCORE_MC_UCLK, 0),
|
|
},
|
|
{ /* MC DClk Channel */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x7843),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(KNL_PCI_UNCORE_MC_DCLK, 0),
|
|
},
|
|
{ /* EDC UClk */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x7833),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(KNL_PCI_UNCORE_EDC_UCLK, 0),
|
|
},
|
|
{ /* EDC EClk */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x7835),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(KNL_PCI_UNCORE_EDC_ECLK, 0),
|
|
},
|
|
{ /* M2PCIe */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x7817),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(KNL_PCI_UNCORE_M2PCIE, 0),
|
|
},
|
|
{ /* IRP */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x7814),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(KNL_PCI_UNCORE_IRP, 0),
|
|
},
|
|
{ /* end: all zeroes */ }
|
|
};
|
|
|
|
static struct pci_driver knl_uncore_pci_driver = {
|
|
.name = "knl_uncore",
|
|
.id_table = knl_uncore_pci_ids,
|
|
};
|
|
|
|
int knl_uncore_pci_init(void)
|
|
{
|
|
int ret;
|
|
|
|
/* All KNL PCI based PMON units are on the same PCI bus except IRP */
|
|
ret = snb_pci2phy_map_init(0x7814); /* IRP */
|
|
if (ret)
|
|
return ret;
|
|
ret = snb_pci2phy_map_init(0x7817); /* M2PCIe */
|
|
if (ret)
|
|
return ret;
|
|
uncore_pci_uncores = knl_pci_uncores;
|
|
uncore_pci_driver = &knl_uncore_pci_driver;
|
|
return 0;
|
|
}
|
|
|
|
/* end of KNL uncore support */
|
|
|
|
/* Haswell-EP uncore support */
|
|
static struct attribute *hswep_uncore_ubox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh5.attr,
|
|
&format_attr_filter_tid2.attr,
|
|
&format_attr_filter_cid.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group hswep_uncore_ubox_format_group = {
|
|
.name = "format",
|
|
.attrs = hswep_uncore_ubox_formats_attr,
|
|
};
|
|
|
|
static int hswep_ubox_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
reg1->reg = HSWEP_U_MSR_PMON_FILTER;
|
|
reg1->config = event->attr.config1 & HSWEP_U_MSR_PMON_BOX_FILTER_MASK;
|
|
reg1->idx = 0;
|
|
return 0;
|
|
}
|
|
|
|
static struct intel_uncore_ops hswep_uncore_ubox_ops = {
|
|
SNBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
.hw_config = hswep_ubox_hw_config,
|
|
.get_constraint = uncore_get_constraint,
|
|
.put_constraint = uncore_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_ubox = {
|
|
.name = "ubox",
|
|
.num_counters = 2,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 44,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = HSWEP_U_MSR_PMON_CTR0,
|
|
.event_ctl = HSWEP_U_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_U_MSR_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = HSWEP_U_MSR_PMON_UCLK_FIXED_CTR,
|
|
.fixed_ctl = HSWEP_U_MSR_PMON_UCLK_FIXED_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &hswep_uncore_ubox_ops,
|
|
.format_group = &hswep_uncore_ubox_format_group,
|
|
};
|
|
|
|
static struct attribute *hswep_uncore_cbox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_thresh8.attr,
|
|
&format_attr_filter_tid3.attr,
|
|
&format_attr_filter_link2.attr,
|
|
&format_attr_filter_state3.attr,
|
|
&format_attr_filter_nid2.attr,
|
|
&format_attr_filter_opc2.attr,
|
|
&format_attr_filter_nc.attr,
|
|
&format_attr_filter_c6.attr,
|
|
&format_attr_filter_isoc.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group hswep_uncore_cbox_format_group = {
|
|
.name = "format",
|
|
.attrs = hswep_uncore_cbox_formats_attr,
|
|
};
|
|
|
|
static struct event_constraint hswep_uncore_cbox_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x01, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x09, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x38, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x3b, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x3e, 0x1),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct extra_reg hswep_uncore_cbox_extra_regs[] = {
|
|
SNBEP_CBO_EVENT_EXTRA_REG(SNBEP_CBO_PMON_CTL_TID_EN,
|
|
SNBEP_CBO_PMON_CTL_TID_EN, 0x1),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0334, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0534, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0934, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x1134, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2134, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4134, 0xffff, 0x4),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4037, 0x40ff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4028, 0x40ff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4032, 0x40ff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4029, 0x40ff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4033, 0x40ff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x402A, 0x40ff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0135, 0xffff, 0x12),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0335, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4135, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4435, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4835, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x5035, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4335, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4a35, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2335, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8335, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2135, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8135, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0136, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x0336, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4136, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4436, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4836, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4336, 0xffff, 0x18),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x4a36, 0xffff, 0x8),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2336, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8336, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x2136, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x8136, 0xffff, 0x10),
|
|
SNBEP_CBO_EVENT_EXTRA_REG(0x5036, 0xffff, 0x8),
|
|
EVENT_EXTRA_END
|
|
};
|
|
|
|
static u64 hswep_cbox_filter_mask(int fields)
|
|
{
|
|
u64 mask = 0;
|
|
if (fields & 0x1)
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_TID;
|
|
if (fields & 0x2)
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_LINK;
|
|
if (fields & 0x4)
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_STATE;
|
|
if (fields & 0x8)
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_NID;
|
|
if (fields & 0x10) {
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_OPC;
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_NC;
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_C6;
|
|
mask |= HSWEP_CB0_MSR_PMON_BOX_FILTER_ISOC;
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
static struct event_constraint *
|
|
hswep_cbox_get_constraint(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
return __snbep_cbox_get_constraint(box, event, hswep_cbox_filter_mask);
|
|
}
|
|
|
|
static int hswep_cbox_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
|
|
struct extra_reg *er;
|
|
int idx = 0;
|
|
|
|
for (er = hswep_uncore_cbox_extra_regs; er->msr; er++) {
|
|
if (er->event != (event->hw.config & er->config_mask))
|
|
continue;
|
|
idx |= er->idx;
|
|
}
|
|
|
|
if (idx) {
|
|
reg1->reg = HSWEP_C0_MSR_PMON_BOX_FILTER0 +
|
|
HSWEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;
|
|
reg1->config = event->attr.config1 & hswep_cbox_filter_mask(idx);
|
|
reg1->idx = idx;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void hswep_cbox_enable_event(struct intel_uncore_box *box,
|
|
struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
|
|
if (reg1->idx != EXTRA_REG_NONE) {
|
|
u64 filter = uncore_shared_reg_config(box, 0);
|
|
wrmsrl(reg1->reg, filter & 0xffffffff);
|
|
wrmsrl(reg1->reg + 1, filter >> 32);
|
|
}
|
|
|
|
wrmsrl(hwc->config_base, hwc->config | SNBEP_PMON_CTL_EN);
|
|
}
|
|
|
|
static struct intel_uncore_ops hswep_uncore_cbox_ops = {
|
|
.init_box = snbep_uncore_msr_init_box,
|
|
.disable_box = snbep_uncore_msr_disable_box,
|
|
.enable_box = snbep_uncore_msr_enable_box,
|
|
.disable_event = snbep_uncore_msr_disable_event,
|
|
.enable_event = hswep_cbox_enable_event,
|
|
.read_counter = uncore_msr_read_counter,
|
|
.hw_config = hswep_cbox_hw_config,
|
|
.get_constraint = hswep_cbox_get_constraint,
|
|
.put_constraint = snbep_cbox_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_cbox = {
|
|
.name = "cbox",
|
|
.num_counters = 4,
|
|
.num_boxes = 18,
|
|
.perf_ctr_bits = 48,
|
|
.event_ctl = HSWEP_C0_MSR_PMON_CTL0,
|
|
.perf_ctr = HSWEP_C0_MSR_PMON_CTR0,
|
|
.event_mask = SNBEP_CBO_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_C0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = HSWEP_CBO_MSR_OFFSET,
|
|
.num_shared_regs = 1,
|
|
.constraints = hswep_uncore_cbox_constraints,
|
|
.ops = &hswep_uncore_cbox_ops,
|
|
.format_group = &hswep_uncore_cbox_format_group,
|
|
};
|
|
|
|
/*
|
|
* Write SBOX Initialization register bit by bit to avoid spurious #GPs
|
|
*/
|
|
static void hswep_uncore_sbox_msr_init_box(struct intel_uncore_box *box)
|
|
{
|
|
unsigned msr = uncore_msr_box_ctl(box);
|
|
|
|
if (msr) {
|
|
u64 init = SNBEP_PMON_BOX_CTL_INT;
|
|
u64 flags = 0;
|
|
int i;
|
|
|
|
for_each_set_bit(i, (unsigned long *)&init, 64) {
|
|
flags |= (1ULL << i);
|
|
wrmsrl(msr, flags);
|
|
}
|
|
}
|
|
}
|
|
|
|
static struct intel_uncore_ops hswep_uncore_sbox_msr_ops = {
|
|
__SNBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
.init_box = hswep_uncore_sbox_msr_init_box
|
|
};
|
|
|
|
static struct attribute *hswep_uncore_sbox_formats_attr[] = {
|
|
&format_attr_event.attr,
|
|
&format_attr_umask.attr,
|
|
&format_attr_edge.attr,
|
|
&format_attr_tid_en.attr,
|
|
&format_attr_inv.attr,
|
|
&format_attr_thresh8.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group hswep_uncore_sbox_format_group = {
|
|
.name = "format",
|
|
.attrs = hswep_uncore_sbox_formats_attr,
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_sbox = {
|
|
.name = "sbox",
|
|
.num_counters = 4,
|
|
.num_boxes = 4,
|
|
.perf_ctr_bits = 44,
|
|
.event_ctl = HSWEP_S0_MSR_PMON_CTL0,
|
|
.perf_ctr = HSWEP_S0_MSR_PMON_CTR0,
|
|
.event_mask = HSWEP_S_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_S0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = HSWEP_SBOX_MSR_OFFSET,
|
|
.ops = &hswep_uncore_sbox_msr_ops,
|
|
.format_group = &hswep_uncore_sbox_format_group,
|
|
};
|
|
|
|
static int hswep_pcu_hw_config(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
|
|
int ev_sel = hwc->config & SNBEP_PMON_CTL_EV_SEL_MASK;
|
|
|
|
if (ev_sel >= 0xb && ev_sel <= 0xe) {
|
|
reg1->reg = HSWEP_PCU_MSR_PMON_BOX_FILTER;
|
|
reg1->idx = ev_sel - 0xb;
|
|
reg1->config = event->attr.config1 & (0xff << reg1->idx);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct intel_uncore_ops hswep_uncore_pcu_ops = {
|
|
SNBEP_UNCORE_MSR_OPS_COMMON_INIT(),
|
|
.hw_config = hswep_pcu_hw_config,
|
|
.get_constraint = snbep_pcu_get_constraint,
|
|
.put_constraint = snbep_pcu_put_constraint,
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_pcu = {
|
|
.name = "pcu",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = HSWEP_PCU_MSR_PMON_CTR0,
|
|
.event_ctl = HSWEP_PCU_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_PCU_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_PCU_MSR_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &hswep_uncore_pcu_ops,
|
|
.format_group = &snbep_uncore_pcu_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type *hswep_msr_uncores[] = {
|
|
&hswep_uncore_ubox,
|
|
&hswep_uncore_cbox,
|
|
&hswep_uncore_sbox,
|
|
&hswep_uncore_pcu,
|
|
NULL,
|
|
};
|
|
|
|
void hswep_uncore_cpu_init(void)
|
|
{
|
|
int pkg = topology_phys_to_logical_pkg(0);
|
|
|
|
if (hswep_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
|
|
hswep_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
|
|
|
|
/* Detect 6-8 core systems with only two SBOXes */
|
|
if (uncore_extra_pci_dev[pkg].dev[HSWEP_PCI_PCU_3]) {
|
|
u32 capid4;
|
|
|
|
pci_read_config_dword(uncore_extra_pci_dev[pkg].dev[HSWEP_PCI_PCU_3],
|
|
0x94, &capid4);
|
|
if (((capid4 >> 6) & 0x3) == 0)
|
|
hswep_uncore_sbox.num_boxes = 2;
|
|
}
|
|
|
|
uncore_msr_uncores = hswep_msr_uncores;
|
|
}
|
|
|
|
static struct intel_uncore_type hswep_uncore_ha = {
|
|
.name = "ha",
|
|
.num_counters = 5,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 48,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct uncore_event_desc hswep_uncore_imc_events[] = {
|
|
INTEL_UNCORE_EVENT_DESC(clockticks, "event=0x00,umask=0x00"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_read, "event=0x04,umask=0x03"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_read.scale, "6.103515625e-5"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_read.unit, "MiB"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_write, "event=0x04,umask=0x0c"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_write.scale, "6.103515625e-5"),
|
|
INTEL_UNCORE_EVENT_DESC(cas_count_write.unit, "MiB"),
|
|
{ /* end: all zeroes */ },
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_imc = {
|
|
.name = "imc",
|
|
.num_counters = 5,
|
|
.num_boxes = 8,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.fixed_ctr = SNBEP_MC_CHy_PCI_PMON_FIXED_CTR,
|
|
.fixed_ctl = SNBEP_MC_CHy_PCI_PMON_FIXED_CTL,
|
|
.event_descs = hswep_uncore_imc_events,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static unsigned hswep_uncore_irp_ctrs[] = {0xa0, 0xa8, 0xb0, 0xb8};
|
|
|
|
static u64 hswep_uncore_irp_read_counter(struct intel_uncore_box *box, struct perf_event *event)
|
|
{
|
|
struct pci_dev *pdev = box->pci_dev;
|
|
struct hw_perf_event *hwc = &event->hw;
|
|
u64 count = 0;
|
|
|
|
pci_read_config_dword(pdev, hswep_uncore_irp_ctrs[hwc->idx], (u32 *)&count);
|
|
pci_read_config_dword(pdev, hswep_uncore_irp_ctrs[hwc->idx] + 4, (u32 *)&count + 1);
|
|
|
|
return count;
|
|
}
|
|
|
|
static struct intel_uncore_ops hswep_uncore_irp_ops = {
|
|
.init_box = snbep_uncore_pci_init_box,
|
|
.disable_box = snbep_uncore_pci_disable_box,
|
|
.enable_box = snbep_uncore_pci_enable_box,
|
|
.disable_event = ivbep_uncore_irp_disable_event,
|
|
.enable_event = ivbep_uncore_irp_enable_event,
|
|
.read_counter = hswep_uncore_irp_read_counter,
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_irp = {
|
|
.name = "irp",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.ops = &hswep_uncore_irp_ops,
|
|
.format_group = &snbep_uncore_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_qpi = {
|
|
.name = "qpi",
|
|
.num_counters = 5,
|
|
.num_boxes = 3,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0,
|
|
.event_mask = SNBEP_QPI_PCI_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &snbep_uncore_qpi_ops,
|
|
.format_group = &snbep_uncore_qpi_format_group,
|
|
};
|
|
|
|
static struct event_constraint hswep_uncore_r2pcie_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x10, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x13, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x24, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x25, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x26, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x27, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x28, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x29, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2a, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x2b, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2c, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2d, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x32, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x33, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x34, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x35, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_r2pcie = {
|
|
.name = "r2pcie",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.constraints = hswep_uncore_r2pcie_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct event_constraint hswep_uncore_r3qpi_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x01, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x07, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x08, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x09, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x0a, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x0e, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x10, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x12, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x13, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x14, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x15, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x1f, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x20, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x21, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x22, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x25, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x26, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x28, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x29, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2c, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2d, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2e, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2f, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x31, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x32, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x33, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x34, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x37, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x38, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x39, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type hswep_uncore_r3qpi = {
|
|
.name = "r3qpi",
|
|
.num_counters = 4,
|
|
.num_boxes = 3,
|
|
.perf_ctr_bits = 44,
|
|
.constraints = hswep_uncore_r3qpi_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
enum {
|
|
HSWEP_PCI_UNCORE_HA,
|
|
HSWEP_PCI_UNCORE_IMC,
|
|
HSWEP_PCI_UNCORE_IRP,
|
|
HSWEP_PCI_UNCORE_QPI,
|
|
HSWEP_PCI_UNCORE_R2PCIE,
|
|
HSWEP_PCI_UNCORE_R3QPI,
|
|
};
|
|
|
|
static struct intel_uncore_type *hswep_pci_uncores[] = {
|
|
[HSWEP_PCI_UNCORE_HA] = &hswep_uncore_ha,
|
|
[HSWEP_PCI_UNCORE_IMC] = &hswep_uncore_imc,
|
|
[HSWEP_PCI_UNCORE_IRP] = &hswep_uncore_irp,
|
|
[HSWEP_PCI_UNCORE_QPI] = &hswep_uncore_qpi,
|
|
[HSWEP_PCI_UNCORE_R2PCIE] = &hswep_uncore_r2pcie,
|
|
[HSWEP_PCI_UNCORE_R3QPI] = &hswep_uncore_r3qpi,
|
|
NULL,
|
|
};
|
|
|
|
static const struct pci_device_id hswep_uncore_pci_ids[] = {
|
|
{ /* Home Agent 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f30),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_HA, 0),
|
|
},
|
|
{ /* Home Agent 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f38),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_HA, 1),
|
|
},
|
|
{ /* MC0 Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fb0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 0),
|
|
},
|
|
{ /* MC0 Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fb1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 1),
|
|
},
|
|
{ /* MC0 Channel 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fb4),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 2),
|
|
},
|
|
{ /* MC0 Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fb5),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 3),
|
|
},
|
|
{ /* MC1 Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fd0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 4),
|
|
},
|
|
{ /* MC1 Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fd1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 5),
|
|
},
|
|
{ /* MC1 Channel 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fd4),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 6),
|
|
},
|
|
{ /* MC1 Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fd5),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IMC, 7),
|
|
},
|
|
{ /* IRP */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f39),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_IRP, 0),
|
|
},
|
|
{ /* QPI0 Port 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f32),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_QPI, 0),
|
|
},
|
|
{ /* QPI0 Port 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f33),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_QPI, 1),
|
|
},
|
|
{ /* QPI1 Port 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f3a),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_QPI, 2),
|
|
},
|
|
{ /* R2PCIe */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f34),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_R2PCIE, 0),
|
|
},
|
|
{ /* R3QPI0 Link 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f36),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_R3QPI, 0),
|
|
},
|
|
{ /* R3QPI0 Link 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f37),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_R3QPI, 1),
|
|
},
|
|
{ /* R3QPI1 Link 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f3e),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(HSWEP_PCI_UNCORE_R3QPI, 2),
|
|
},
|
|
{ /* QPI Port 0 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f86),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
SNBEP_PCI_QPI_PORT0_FILTER),
|
|
},
|
|
{ /* QPI Port 1 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f96),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
SNBEP_PCI_QPI_PORT1_FILTER),
|
|
},
|
|
{ /* PCU.3 (for Capability registers) */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fc0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
|
|
HSWEP_PCI_PCU_3),
|
|
},
|
|
{ /* end: all zeroes */ }
|
|
};
|
|
|
|
static struct pci_driver hswep_uncore_pci_driver = {
|
|
.name = "hswep_uncore",
|
|
.id_table = hswep_uncore_pci_ids,
|
|
};
|
|
|
|
int hswep_uncore_pci_init(void)
|
|
{
|
|
int ret = snbep_pci2phy_map_init(0x2f1e);
|
|
if (ret)
|
|
return ret;
|
|
uncore_pci_uncores = hswep_pci_uncores;
|
|
uncore_pci_driver = &hswep_uncore_pci_driver;
|
|
return 0;
|
|
}
|
|
/* end of Haswell-EP uncore support */
|
|
|
|
/* BDX uncore support */
|
|
|
|
static struct intel_uncore_type bdx_uncore_ubox = {
|
|
.name = "ubox",
|
|
.num_counters = 2,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.perf_ctr = HSWEP_U_MSR_PMON_CTR0,
|
|
.event_ctl = HSWEP_U_MSR_PMON_CTL0,
|
|
.event_mask = SNBEP_U_MSR_PMON_RAW_EVENT_MASK,
|
|
.fixed_ctr = HSWEP_U_MSR_PMON_UCLK_FIXED_CTR,
|
|
.fixed_ctl = HSWEP_U_MSR_PMON_UCLK_FIXED_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &ivbep_uncore_msr_ops,
|
|
.format_group = &ivbep_uncore_ubox_format_group,
|
|
};
|
|
|
|
static struct event_constraint bdx_uncore_cbox_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x09, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x3e, 0x1),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_cbox = {
|
|
.name = "cbox",
|
|
.num_counters = 4,
|
|
.num_boxes = 24,
|
|
.perf_ctr_bits = 48,
|
|
.event_ctl = HSWEP_C0_MSR_PMON_CTL0,
|
|
.perf_ctr = HSWEP_C0_MSR_PMON_CTR0,
|
|
.event_mask = SNBEP_CBO_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_C0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = HSWEP_CBO_MSR_OFFSET,
|
|
.num_shared_regs = 1,
|
|
.constraints = bdx_uncore_cbox_constraints,
|
|
.ops = &hswep_uncore_cbox_ops,
|
|
.format_group = &hswep_uncore_cbox_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_sbox = {
|
|
.name = "sbox",
|
|
.num_counters = 4,
|
|
.num_boxes = 4,
|
|
.perf_ctr_bits = 48,
|
|
.event_ctl = HSWEP_S0_MSR_PMON_CTL0,
|
|
.perf_ctr = HSWEP_S0_MSR_PMON_CTR0,
|
|
.event_mask = HSWEP_S_MSR_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = HSWEP_S0_MSR_PMON_BOX_CTL,
|
|
.msr_offset = HSWEP_SBOX_MSR_OFFSET,
|
|
.ops = &hswep_uncore_sbox_msr_ops,
|
|
.format_group = &hswep_uncore_sbox_format_group,
|
|
};
|
|
|
|
#define BDX_MSR_UNCORE_SBOX 3
|
|
|
|
static struct intel_uncore_type *bdx_msr_uncores[] = {
|
|
&bdx_uncore_ubox,
|
|
&bdx_uncore_cbox,
|
|
&hswep_uncore_pcu,
|
|
&bdx_uncore_sbox,
|
|
NULL,
|
|
};
|
|
|
|
void bdx_uncore_cpu_init(void)
|
|
{
|
|
if (bdx_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
|
|
bdx_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
|
|
uncore_msr_uncores = bdx_msr_uncores;
|
|
|
|
/* BDX-DE doesn't have SBOX */
|
|
if (boot_cpu_data.x86_model == 86)
|
|
uncore_msr_uncores[BDX_MSR_UNCORE_SBOX] = NULL;
|
|
}
|
|
|
|
static struct intel_uncore_type bdx_uncore_ha = {
|
|
.name = "ha",
|
|
.num_counters = 4,
|
|
.num_boxes = 2,
|
|
.perf_ctr_bits = 48,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_imc = {
|
|
.name = "imc",
|
|
.num_counters = 5,
|
|
.num_boxes = 8,
|
|
.perf_ctr_bits = 48,
|
|
.fixed_ctr_bits = 48,
|
|
.fixed_ctr = SNBEP_MC_CHy_PCI_PMON_FIXED_CTR,
|
|
.fixed_ctl = SNBEP_MC_CHy_PCI_PMON_FIXED_CTL,
|
|
.event_descs = hswep_uncore_imc_events,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_irp = {
|
|
.name = "irp",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.event_mask = SNBEP_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.ops = &hswep_uncore_irp_ops,
|
|
.format_group = &snbep_uncore_format_group,
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_qpi = {
|
|
.name = "qpi",
|
|
.num_counters = 4,
|
|
.num_boxes = 3,
|
|
.perf_ctr_bits = 48,
|
|
.perf_ctr = SNBEP_PCI_PMON_CTR0,
|
|
.event_ctl = SNBEP_PCI_PMON_CTL0,
|
|
.event_mask = SNBEP_QPI_PCI_PMON_RAW_EVENT_MASK,
|
|
.box_ctl = SNBEP_PCI_PMON_BOX_CTL,
|
|
.num_shared_regs = 1,
|
|
.ops = &snbep_uncore_qpi_ops,
|
|
.format_group = &snbep_uncore_qpi_format_group,
|
|
};
|
|
|
|
static struct event_constraint bdx_uncore_r2pcie_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x10, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x13, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x25, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x26, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x28, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2c, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2d, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_r2pcie = {
|
|
.name = "r2pcie",
|
|
.num_counters = 4,
|
|
.num_boxes = 1,
|
|
.perf_ctr_bits = 48,
|
|
.constraints = bdx_uncore_r2pcie_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
static struct event_constraint bdx_uncore_r3qpi_constraints[] = {
|
|
UNCORE_EVENT_CONSTRAINT(0x01, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x07, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x08, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x09, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x0a, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x0e, 0x7),
|
|
UNCORE_EVENT_CONSTRAINT(0x10, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x11, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x13, 0x1),
|
|
UNCORE_EVENT_CONSTRAINT(0x14, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x15, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x1f, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x20, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x21, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x22, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x23, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x25, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x26, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x28, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x29, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2c, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2d, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2e, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x2f, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x33, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x34, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x36, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x37, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x38, 0x3),
|
|
UNCORE_EVENT_CONSTRAINT(0x39, 0x3),
|
|
EVENT_CONSTRAINT_END
|
|
};
|
|
|
|
static struct intel_uncore_type bdx_uncore_r3qpi = {
|
|
.name = "r3qpi",
|
|
.num_counters = 3,
|
|
.num_boxes = 3,
|
|
.perf_ctr_bits = 48,
|
|
.constraints = bdx_uncore_r3qpi_constraints,
|
|
SNBEP_UNCORE_PCI_COMMON_INIT(),
|
|
};
|
|
|
|
enum {
|
|
BDX_PCI_UNCORE_HA,
|
|
BDX_PCI_UNCORE_IMC,
|
|
BDX_PCI_UNCORE_IRP,
|
|
BDX_PCI_UNCORE_QPI,
|
|
BDX_PCI_UNCORE_R2PCIE,
|
|
BDX_PCI_UNCORE_R3QPI,
|
|
};
|
|
|
|
static struct intel_uncore_type *bdx_pci_uncores[] = {
|
|
[BDX_PCI_UNCORE_HA] = &bdx_uncore_ha,
|
|
[BDX_PCI_UNCORE_IMC] = &bdx_uncore_imc,
|
|
[BDX_PCI_UNCORE_IRP] = &bdx_uncore_irp,
|
|
[BDX_PCI_UNCORE_QPI] = &bdx_uncore_qpi,
|
|
[BDX_PCI_UNCORE_R2PCIE] = &bdx_uncore_r2pcie,
|
|
[BDX_PCI_UNCORE_R3QPI] = &bdx_uncore_r3qpi,
|
|
NULL,
|
|
};
|
|
|
|
static const struct pci_device_id bdx_uncore_pci_ids[] = {
|
|
{ /* Home Agent 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f30),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_HA, 0),
|
|
},
|
|
{ /* Home Agent 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f38),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_HA, 1),
|
|
},
|
|
{ /* MC0 Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fb0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 0),
|
|
},
|
|
{ /* MC0 Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fb1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 1),
|
|
},
|
|
{ /* MC0 Channel 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fb4),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 2),
|
|
},
|
|
{ /* MC0 Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fb5),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 3),
|
|
},
|
|
{ /* MC1 Channel 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fd0),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 4),
|
|
},
|
|
{ /* MC1 Channel 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fd1),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 5),
|
|
},
|
|
{ /* MC1 Channel 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fd4),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 6),
|
|
},
|
|
{ /* MC1 Channel 3 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fd5),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IMC, 7),
|
|
},
|
|
{ /* IRP */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f39),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_IRP, 0),
|
|
},
|
|
{ /* QPI0 Port 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f32),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_QPI, 0),
|
|
},
|
|
{ /* QPI0 Port 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f33),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_QPI, 1),
|
|
},
|
|
{ /* QPI1 Port 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f3a),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_QPI, 2),
|
|
},
|
|
{ /* R2PCIe */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f34),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_R2PCIE, 0),
|
|
},
|
|
{ /* R3QPI0 Link 0 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f36),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_R3QPI, 0),
|
|
},
|
|
{ /* R3QPI0 Link 1 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f37),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_R3QPI, 1),
|
|
},
|
|
{ /* R3QPI1 Link 2 */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f3e),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(BDX_PCI_UNCORE_R3QPI, 2),
|
|
},
|
|
{ /* QPI Port 0 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f86),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, 0),
|
|
},
|
|
{ /* QPI Port 1 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f96),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, 1),
|
|
},
|
|
{ /* QPI Port 2 filter */
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6f46),
|
|
.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, 2),
|
|
},
|
|
{ /* end: all zeroes */ }
|
|
};
|
|
|
|
static struct pci_driver bdx_uncore_pci_driver = {
|
|
.name = "bdx_uncore",
|
|
.id_table = bdx_uncore_pci_ids,
|
|
};
|
|
|
|
int bdx_uncore_pci_init(void)
|
|
{
|
|
int ret = snbep_pci2phy_map_init(0x6f1e);
|
|
|
|
if (ret)
|
|
return ret;
|
|
uncore_pci_uncores = bdx_pci_uncores;
|
|
uncore_pci_driver = &bdx_uncore_pci_driver;
|
|
return 0;
|
|
}
|
|
|
|
/* end of BDX uncore support */
|