1// SPDX-License-Identifier: MIT 2/* 3 * Copyright �� 2022 Intel Corporation 4 */ 5 6#include "xe_step.h" 7 8#include <linux/bitfield.h> 9 10#include "xe_device.h" 11#include "xe_platform_types.h" 12 13/* 14 * Provide mapping between PCI's revision ID to the individual GMD 15 * (Graphics/Media/Display) stepping values that can be compared numerically. 16 * 17 * Some platforms may have unusual ways of mapping PCI revision ID to GMD 18 * steppings. E.g., in some cases a higher PCI revision may translate to a 19 * lower stepping of the GT and/or display IP. 20 * 21 * Also note that some revisions/steppings may have been set aside as 22 * placeholders but never materialized in real hardware; in those cases there 23 * may be jumps in the revision IDs or stepping values in the tables below. 24 */ 25 26/* 27 * Some platforms always have the same stepping value for GT and display; 28 * use a macro to define these to make it easier to identify the platforms 29 * where the two steppings can deviate. 30 */ 31#define COMMON_GT_MEDIA_STEP(x_) \ 32 .graphics = STEP_##x_, \ 33 .media = STEP_##x_ 34 35#define COMMON_STEP(x_) \ 36 COMMON_GT_MEDIA_STEP(x_), \ 37 .graphics = STEP_##x_, \ 38 .media = STEP_##x_, \ 39 .display = STEP_##x_ 40 41__diag_push(); 42__diag_ignore_all("-Woverride-init", "Allow field overrides in table"); 43 44/* Same GT stepping between tgl_uy_revids and tgl_revids don't mean the same HW */ 45static const struct xe_step_info tgl_revids[] = { 46 [0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_B0 }, 47 [1] = { COMMON_GT_MEDIA_STEP(B0), .display = STEP_D0 }, 48}; 49 50static const struct xe_step_info dg1_revids[] = { 51 [0] = { COMMON_STEP(A0) }, 52 [1] = { COMMON_STEP(B0) }, 53}; 54 55static const struct xe_step_info adls_revids[] = { 56 [0x0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_A0 }, 57 [0x1] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_A2 }, 58 [0x4] = { COMMON_GT_MEDIA_STEP(B0), .display = STEP_B0 }, 59 [0x8] = { COMMON_GT_MEDIA_STEP(C0), .display = STEP_B0 }, 60 [0xC] = { COMMON_GT_MEDIA_STEP(D0), .display = STEP_C0 }, 61}; 62 63static const struct xe_step_info adls_rpls_revids[] = { 64 [0x4] = { COMMON_GT_MEDIA_STEP(D0), .display = STEP_D0 }, 65 [0xC] = { COMMON_GT_MEDIA_STEP(D0), .display = STEP_C0 }, 66}; 67 68static const struct xe_step_info adlp_revids[] = { 69 [0x0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_A0 }, 70 [0x4] = { COMMON_GT_MEDIA_STEP(B0), .display = STEP_B0 }, 71 [0x8] = { COMMON_GT_MEDIA_STEP(C0), .display = STEP_C0 }, 72 [0xC] = { COMMON_GT_MEDIA_STEP(C0), .display = STEP_D0 }, 73}; 74 75static const struct xe_step_info adlp_rpl_revids[] = { 76 [0x4] = { COMMON_GT_MEDIA_STEP(C0), .display = STEP_E0 }, 77}; 78 79static const struct xe_step_info adln_revids[] = { 80 [0x0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_D0 }, 81}; 82 83static const struct xe_step_info dg2_g10_revid_step_tbl[] = { 84 [0x0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_A0 }, 85 [0x1] = { COMMON_GT_MEDIA_STEP(A1), .display = STEP_A0 }, 86 [0x4] = { COMMON_GT_MEDIA_STEP(B0), .display = STEP_B0 }, 87 [0x8] = { COMMON_GT_MEDIA_STEP(C0), .display = STEP_C0 }, 88}; 89 90static const struct xe_step_info dg2_g11_revid_step_tbl[] = { 91 [0x0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_B0 }, 92 [0x4] = { COMMON_GT_MEDIA_STEP(B0), .display = STEP_C0 }, 93 [0x5] = { COMMON_GT_MEDIA_STEP(B1), .display = STEP_C0 }, 94}; 95 96static const struct xe_step_info dg2_g12_revid_step_tbl[] = { 97 [0x0] = { COMMON_GT_MEDIA_STEP(A0), .display = STEP_C0 }, 98 [0x1] = { COMMON_GT_MEDIA_STEP(A1), .display = STEP_C0 }, 99}; 100 101static const struct xe_step_info pvc_revid_step_tbl[] = { 102 [0x5] = { .graphics = STEP_B0 }, 103 [0x6] = { .graphics = STEP_B1 }, 104 [0x7] = { .graphics = STEP_C0 }, 105}; 106 107static const int pvc_basedie_subids[] = { 108 [0x3] = STEP_B0, 109 [0x4] = STEP_B1, 110 [0x5] = STEP_B3, 111}; 112 113__diag_pop(); 114 115/** 116 * xe_step_pre_gmdid_get - Determine IP steppings from PCI revid 117 * @xe: Xe device 118 * 119 * Convert the PCI revid into proper IP steppings. This should only be 120 * used on platforms that do not have GMD_ID support. 121 */ 122struct xe_step_info xe_step_pre_gmdid_get(struct xe_device *xe) 123{ 124 const struct xe_step_info *revids = NULL; 125 struct xe_step_info step = {}; 126 u16 revid = xe->info.revid; 127 int size = 0; 128 const int *basedie_info = NULL; 129 int basedie_size = 0; 130 int baseid = 0; 131 132 if (xe->info.platform == XE_PVC) { 133 baseid = FIELD_GET(GENMASK(5, 3), xe->info.revid); 134 revid = FIELD_GET(GENMASK(2, 0), xe->info.revid); 135 revids = pvc_revid_step_tbl; 136 size = ARRAY_SIZE(pvc_revid_step_tbl); 137 basedie_info = pvc_basedie_subids; 138 basedie_size = ARRAY_SIZE(pvc_basedie_subids); 139 } else if (xe->info.subplatform == XE_SUBPLATFORM_DG2_G10) { 140 revids = dg2_g10_revid_step_tbl; 141 size = ARRAY_SIZE(dg2_g10_revid_step_tbl); 142 } else if (xe->info.subplatform == XE_SUBPLATFORM_DG2_G11) { 143 revids = dg2_g11_revid_step_tbl; 144 size = ARRAY_SIZE(dg2_g11_revid_step_tbl); 145 } else if (xe->info.subplatform == XE_SUBPLATFORM_DG2_G12) { 146 revids = dg2_g12_revid_step_tbl; 147 size = ARRAY_SIZE(dg2_g12_revid_step_tbl); 148 } else if (xe->info.platform == XE_ALDERLAKE_N) { 149 revids = adln_revids; 150 size = ARRAY_SIZE(adln_revids); 151 } else if (xe->info.subplatform == XE_SUBPLATFORM_ALDERLAKE_S_RPLS) { 152 revids = adls_rpls_revids; 153 size = ARRAY_SIZE(adls_rpls_revids); 154 } else if (xe->info.subplatform == XE_SUBPLATFORM_ALDERLAKE_P_RPLU) { 155 revids = adlp_rpl_revids; 156 size = ARRAY_SIZE(adlp_rpl_revids); 157 } else if (xe->info.platform == XE_ALDERLAKE_P) { 158 revids = adlp_revids; 159 size = ARRAY_SIZE(adlp_revids); 160 } else if (xe->info.platform == XE_ALDERLAKE_S) { 161 revids = adls_revids; 162 size = ARRAY_SIZE(adls_revids); 163 } else if (xe->info.platform == XE_DG1) { 164 revids = dg1_revids; 165 size = ARRAY_SIZE(dg1_revids); 166 } else if (xe->info.platform == XE_TIGERLAKE) { 167 revids = tgl_revids; 168 size = ARRAY_SIZE(tgl_revids); 169 } 170 171 /* Not using the stepping scheme for the platform yet. */ 172 if (!revids) 173 return step; 174 175 if (revid < size && revids[revid].graphics != STEP_NONE) { 176 step = revids[revid]; 177 } else { 178 drm_warn(&xe->drm, "Unknown revid 0x%02x\n", revid); 179 180 /* 181 * If we hit a gap in the revid array, use the information for 182 * the next revid. 183 * 184 * This may be wrong in all sorts of ways, especially if the 185 * steppings in the array are not monotonically increasing, but 186 * it's better than defaulting to 0. 187 */ 188 while (revid < size && revids[revid].graphics == STEP_NONE) 189 revid++; 190 191 if (revid < size) { 192 drm_dbg(&xe->drm, "Using steppings for revid 0x%02x\n", 193 revid); 194 step = revids[revid]; 195 } else { 196 drm_dbg(&xe->drm, "Using future steppings\n"); 197 step.graphics = STEP_FUTURE; 198 step.display = STEP_FUTURE; 199 } 200 } 201 202 drm_WARN_ON(&xe->drm, step.graphics == STEP_NONE); 203 204 if (basedie_info && basedie_size) { 205 if (baseid < basedie_size && basedie_info[baseid] != STEP_NONE) { 206 step.basedie = basedie_info[baseid]; 207 } else { 208 drm_warn(&xe->drm, "Unknown baseid 0x%02x\n", baseid); 209 step.basedie = STEP_FUTURE; 210 } 211 } 212 213 return step; 214} 215 216/** 217 * xe_step_gmdid_get - Determine IP steppings from GMD_ID revid fields 218 * @xe: Xe device 219 * @graphics_gmdid_revid: value of graphics GMD_ID register's revid field 220 * @media_gmdid_revid: value of media GMD_ID register's revid field 221 * 222 * Convert the revid fields of the GMD_ID registers into proper IP steppings. 223 * 224 * GMD_ID revid values are currently expected to have consistent meanings on 225 * all platforms: major steppings (A0, B0, etc.) are 4 apart, with minor 226 * steppings (A1, A2, etc.) taking the values in between. 227 */ 228struct xe_step_info xe_step_gmdid_get(struct xe_device *xe, 229 u32 graphics_gmdid_revid, 230 u32 media_gmdid_revid) 231{ 232 struct xe_step_info step = { 233 .graphics = STEP_A0 + graphics_gmdid_revid, 234 .media = STEP_A0 + media_gmdid_revid, 235 }; 236 237 if (step.graphics >= STEP_FUTURE) { 238 step.graphics = STEP_FUTURE; 239 drm_dbg(&xe->drm, "Graphics GMD_ID revid value %d treated as future stepping\n", 240 graphics_gmdid_revid); 241 } 242 243 if (step.media >= STEP_FUTURE) { 244 step.media = STEP_FUTURE; 245 drm_dbg(&xe->drm, "Media GMD_ID revid value %d treated as future stepping\n", 246 media_gmdid_revid); 247 } 248 249 return step; 250} 251 252#define STEP_NAME_CASE(name) \ 253 case STEP_##name: \ 254 return #name; 255 256const char *xe_step_name(enum xe_step step) 257{ 258 switch (step) { 259 STEP_NAME_LIST(STEP_NAME_CASE); 260 261 default: 262 return "**"; 263 } 264} 265