1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2023 Intel Corporation 4 */ 5 6 #include "xe_reg_whitelist.h" 7 8 #include "regs/xe_engine_regs.h" 9 #include "regs/xe_gt_regs.h" 10 #include "regs/xe_oa_regs.h" 11 #include "regs/xe_regs.h" 12 #include "xe_gt_types.h" 13 #include "xe_gt_printk.h" 14 #include "xe_platform_types.h" 15 #include "xe_reg_sr.h" 16 #include "xe_rtp.h" 17 #include "xe_step.h" 18 19 #undef XE_REG_MCR 20 #define XE_REG_MCR(...) XE_REG(__VA_ARGS__, .mcr = 1) 21 22 static bool match_not_render(const struct xe_device *xe, 23 const struct xe_gt *gt, 24 const struct xe_hw_engine *hwe) 25 { 26 return hwe->class != XE_ENGINE_CLASS_RENDER; 27 } 28 29 static const struct xe_rtp_entry_sr register_whitelist[] = { 30 { XE_RTP_NAME("WaAllowPMDepthAndInvocationCountAccessFromUMD, 1408556865"), 31 XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210), ENGINE_CLASS(RENDER)), 32 XE_RTP_ACTIONS(WHITELIST(PS_INVOCATION_COUNT, 33 RING_FORCE_TO_NONPRIV_ACCESS_RD | 34 RING_FORCE_TO_NONPRIV_RANGE_4)) 35 }, 36 { XE_RTP_NAME("1508744258, 14012131227, 1808121037"), 37 XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210), ENGINE_CLASS(RENDER)), 38 XE_RTP_ACTIONS(WHITELIST(COMMON_SLICE_CHICKEN1, 0)) 39 }, 40 { XE_RTP_NAME("1806527549"), 41 XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210), ENGINE_CLASS(RENDER)), 42 XE_RTP_ACTIONS(WHITELIST(HIZ_CHICKEN, 0)) 43 }, 44 { XE_RTP_NAME("allow_read_ctx_timestamp"), 45 XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1260), FUNC(match_not_render)), 46 XE_RTP_ACTIONS(WHITELIST(RING_CTX_TIMESTAMP(0), 47 RING_FORCE_TO_NONPRIV_ACCESS_RD, 48 XE_RTP_ACTION_FLAG(ENGINE_BASE))) 49 }, 50 { XE_RTP_NAME("16014440446"), 51 XE_RTP_RULES(PLATFORM(PVC)), 52 XE_RTP_ACTIONS(WHITELIST(XE_REG(0x4400), 53 RING_FORCE_TO_NONPRIV_DENY | 54 RING_FORCE_TO_NONPRIV_RANGE_64), 55 WHITELIST(XE_REG(0x4500), 56 RING_FORCE_TO_NONPRIV_DENY | 57 RING_FORCE_TO_NONPRIV_RANGE_64)) 58 }, 59 { XE_RTP_NAME("16017236439"), 60 XE_RTP_RULES(PLATFORM(PVC), ENGINE_CLASS(COPY)), 61 XE_RTP_ACTIONS(WHITELIST(BCS_SWCTRL(0), 62 RING_FORCE_TO_NONPRIV_DENY, 63 XE_RTP_ACTION_FLAG(ENGINE_BASE))) 64 }, 65 { XE_RTP_NAME("16020183090"), 66 XE_RTP_RULES(GRAPHICS_VERSION(2004), GRAPHICS_STEP(A0, B0), 67 ENGINE_CLASS(RENDER)), 68 XE_RTP_ACTIONS(WHITELIST(CSBE_DEBUG_STATUS(RENDER_RING_BASE), 0)) 69 }, 70 { XE_RTP_NAME("oa_reg_render"), 71 XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, XE_RTP_END_VERSION_UNDEFINED), 72 ENGINE_CLASS(RENDER)), 73 XE_RTP_ACTIONS(WHITELIST(OAG_MMIOTRIGGER, 74 RING_FORCE_TO_NONPRIV_ACCESS_RW), 75 WHITELIST(OAG_OASTATUS, 76 RING_FORCE_TO_NONPRIV_ACCESS_RD), 77 WHITELIST(OAG_OAHEADPTR, 78 RING_FORCE_TO_NONPRIV_ACCESS_RD | 79 RING_FORCE_TO_NONPRIV_RANGE_4)) 80 }, 81 { XE_RTP_NAME("oa_reg_compute"), 82 XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, XE_RTP_END_VERSION_UNDEFINED), 83 ENGINE_CLASS(COMPUTE)), 84 XE_RTP_ACTIONS(WHITELIST(OAG_MMIOTRIGGER, 85 RING_FORCE_TO_NONPRIV_ACCESS_RW), 86 WHITELIST(OAG_OASTATUS, 87 RING_FORCE_TO_NONPRIV_ACCESS_RD), 88 WHITELIST(OAG_OAHEADPTR, 89 RING_FORCE_TO_NONPRIV_ACCESS_RD | 90 RING_FORCE_TO_NONPRIV_RANGE_4)) 91 }, 92 }; 93 94 static void whitelist_apply_to_hwe(struct xe_hw_engine *hwe) 95 { 96 struct xe_reg_sr *sr = &hwe->reg_whitelist; 97 struct xe_reg_sr_entry *entry; 98 struct drm_printer p; 99 unsigned long reg; 100 unsigned int slot; 101 102 xe_gt_dbg(hwe->gt, "Add %s whitelist to engine\n", sr->name); 103 p = xe_gt_dbg_printer(hwe->gt); 104 105 slot = 0; 106 xa_for_each(&sr->xa, reg, entry) { 107 struct xe_reg_sr_entry hwe_entry = { 108 .reg = RING_FORCE_TO_NONPRIV(hwe->mmio_base, slot), 109 .set_bits = entry->reg.addr | entry->set_bits, 110 .clr_bits = ~0u, 111 .read_mask = entry->read_mask, 112 }; 113 114 if (slot == RING_MAX_NONPRIV_SLOTS) { 115 xe_gt_err(hwe->gt, 116 "hwe %s: maximum register whitelist slots (%d) reached, refusing to add more\n", 117 hwe->name, RING_MAX_NONPRIV_SLOTS); 118 break; 119 } 120 121 xe_reg_whitelist_print_entry(&p, 0, reg, entry); 122 xe_reg_sr_add(&hwe->reg_sr, &hwe_entry, hwe->gt); 123 124 slot++; 125 } 126 } 127 128 /** 129 * xe_reg_whitelist_process_engine - process table of registers to whitelist 130 * @hwe: engine instance to process whitelist for 131 * 132 * Process wwhitelist table for this platform, saving in @hwe all the 133 * registers that need to be whitelisted by the hardware so they can be accessed 134 * by userspace. 135 */ 136 void xe_reg_whitelist_process_engine(struct xe_hw_engine *hwe) 137 { 138 struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe); 139 140 xe_rtp_process_to_sr(&ctx, register_whitelist, ARRAY_SIZE(register_whitelist), 141 &hwe->reg_whitelist); 142 whitelist_apply_to_hwe(hwe); 143 } 144 145 /** 146 * xe_reg_whitelist_print_entry - print one whitelist entry 147 * @p: DRM printer 148 * @indent: indent level 149 * @reg: register allowed/denied 150 * @entry: save-restore entry 151 * 152 * Print details about the entry added to allow/deny access 153 */ 154 void xe_reg_whitelist_print_entry(struct drm_printer *p, unsigned int indent, 155 u32 reg, struct xe_reg_sr_entry *entry) 156 { 157 u32 val = entry->set_bits; 158 const char *access_str = "(invalid)"; 159 unsigned int range_bit = 2; 160 u32 range_start, range_end; 161 bool deny; 162 163 deny = val & RING_FORCE_TO_NONPRIV_DENY; 164 165 switch (val & RING_FORCE_TO_NONPRIV_RANGE_MASK) { 166 case RING_FORCE_TO_NONPRIV_RANGE_4: 167 range_bit = 4; 168 break; 169 case RING_FORCE_TO_NONPRIV_RANGE_16: 170 range_bit = 6; 171 break; 172 case RING_FORCE_TO_NONPRIV_RANGE_64: 173 range_bit = 8; 174 break; 175 } 176 177 range_start = reg & REG_GENMASK(25, range_bit); 178 range_end = range_start | REG_GENMASK(range_bit, 0); 179 180 switch (val & RING_FORCE_TO_NONPRIV_ACCESS_MASK) { 181 case RING_FORCE_TO_NONPRIV_ACCESS_RW: 182 access_str = "rw"; 183 break; 184 case RING_FORCE_TO_NONPRIV_ACCESS_RD: 185 access_str = "read"; 186 break; 187 case RING_FORCE_TO_NONPRIV_ACCESS_WR: 188 access_str = "write"; 189 break; 190 } 191 192 drm_printf_indent(p, indent, "REG[0x%x-0x%x]: %s %s access\n", 193 range_start, range_end, 194 deny ? "deny" : "allow", 195 access_str); 196 } 197 198 /** 199 * xe_reg_whitelist_dump - print all whitelist entries 200 * @sr: Save/restore entries 201 * @p: DRM printer 202 */ 203 void xe_reg_whitelist_dump(struct xe_reg_sr *sr, struct drm_printer *p) 204 { 205 struct xe_reg_sr_entry *entry; 206 unsigned long reg; 207 208 if (!sr->name || xa_empty(&sr->xa)) 209 return; 210 211 drm_printf(p, "%s\n", sr->name); 212 xa_for_each(&sr->xa, reg, entry) 213 xe_reg_whitelist_print_entry(p, 1, reg, entry); 214 } 215