1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2022 Intel Corporation 4 */ 5 6 #include <linux/bitfield.h> 7 #include <linux/fault-inject.h> 8 #include <linux/firmware.h> 9 10 #include <drm/drm_managed.h> 11 12 #include "regs/xe_guc_regs.h" 13 #include "xe_bo.h" 14 #include "xe_device_types.h" 15 #include "xe_force_wake.h" 16 #include "xe_gsc.h" 17 #include "xe_gt.h" 18 #include "xe_gt_printk.h" 19 #include "xe_guc.h" 20 #include "xe_map.h" 21 #include "xe_mmio.h" 22 #include "xe_module.h" 23 #include "xe_sriov.h" 24 #include "xe_uc_fw.h" 25 26 /* 27 * List of required GuC and HuC binaries per-platform. They must be ordered 28 * based on platform, from newer to older. 29 * 30 * Versioning follows the guidelines from 31 * Documentation/driver-api/firmware/firmware-usage-guidelines.rst. There is a 32 * distinction for platforms being officially supported by the driver or not. 33 * Platforms not available publicly or not yet officially supported by the 34 * driver (under force-probe), use the mmp_ver(): the firmware autoselect logic 35 * will select the firmware from disk with filename that matches the full 36 * "mpp version", i.e. major.minor.patch. mmp_ver() should only be used for 37 * this case. 38 * 39 * For platforms officially supported by the driver, the filename always only 40 * ever contains the major version (GuC) or no version at all (HuC). 41 * 42 * After loading the file, the driver parses the versions embedded in the blob. 43 * The major version needs to match a major version supported by the driver (if 44 * any). The minor version is also checked and a notice emitted to the log if 45 * the version found is smaller than the version wanted. This is done only for 46 * informational purposes so users may have a chance to upgrade, but the driver 47 * still loads and use the older firmware. 48 * 49 * Examples: 50 * 51 * 1) Platform officially supported by i915 - using Tigerlake as example. 52 * Driver loads the following firmware blobs from disk: 53 * 54 * - i915/tgl_guc_<major>.bin 55 * - i915/tgl_huc.bin 56 * 57 * <major> number for GuC is checked that it matches the version inside 58 * the blob. <minor> version is checked and if smaller than the expected 59 * an info message is emitted about that. 60 * 61 * 1) XE_<FUTUREINTELPLATFORM>, still under require_force_probe. Using 62 * "wipplat" as a short-name. Driver loads the following firmware blobs 63 * from disk: 64 * 65 * - xe/wipplat_guc_<major>.<minor>.<patch>.bin 66 * - xe/wipplat_huc_<major>.<minor>.<patch>.bin 67 * 68 * <major> and <minor> are checked that they match the version inside 69 * the blob. Both of them need to match exactly what the driver is 70 * expecting, otherwise it fails. 71 * 72 * 3) Platform officially supported by xe and out of force-probe. Using 73 * "plat" as a short-name. Except for the different directory, the 74 * behavior is the same as (1). Driver loads the following firmware 75 * blobs from disk: 76 * 77 * - xe/plat_guc_<major>.bin 78 * - xe/plat_huc.bin 79 * 80 * <major> number for GuC is checked that it matches the version inside 81 * the blob. <minor> version is checked and if smaller than the expected 82 * an info message is emitted about that. 83 * 84 * For the platforms already released with a major version, they should never be 85 * removed from the table. Instead new entries with newer versions may be added 86 * before them, so they take precedence. 87 * 88 * TODO: Currently there's no fallback on major version. That's because xe 89 * driver only supports the one major version of each firmware in the table. 90 * This needs to be fixed when the major version of GuC is updated. 91 */ 92 93 struct uc_fw_entry { 94 enum xe_platform platform; 95 struct { 96 const char *path; 97 u16 major; 98 u16 minor; 99 u16 patch; 100 bool full_ver_required; 101 }; 102 }; 103 104 struct fw_blobs_by_type { 105 const struct uc_fw_entry *entries; 106 u32 count; 107 }; 108 109 #define XE_GUC_FIRMWARE_DEFS(fw_def, mmp_ver, major_ver) \ 110 fw_def(BATTLEMAGE, major_ver(xe, guc, bmg, 70, 29, 2)) \ 111 fw_def(LUNARLAKE, major_ver(xe, guc, lnl, 70, 29, 2)) \ 112 fw_def(METEORLAKE, major_ver(i915, guc, mtl, 70, 29, 2)) \ 113 fw_def(DG2, major_ver(i915, guc, dg2, 70, 29, 2)) \ 114 fw_def(DG1, major_ver(i915, guc, dg1, 70, 29, 2)) \ 115 fw_def(ALDERLAKE_N, major_ver(i915, guc, tgl, 70, 29, 2)) \ 116 fw_def(ALDERLAKE_P, major_ver(i915, guc, adlp, 70, 29, 2)) \ 117 fw_def(ALDERLAKE_S, major_ver(i915, guc, tgl, 70, 29, 2)) \ 118 fw_def(ROCKETLAKE, major_ver(i915, guc, tgl, 70, 29, 2)) \ 119 fw_def(TIGERLAKE, major_ver(i915, guc, tgl, 70, 29, 2)) 120 121 #define XE_HUC_FIRMWARE_DEFS(fw_def, mmp_ver, no_ver) \ 122 fw_def(BATTLEMAGE, no_ver(xe, huc, bmg)) \ 123 fw_def(LUNARLAKE, no_ver(xe, huc, lnl)) \ 124 fw_def(METEORLAKE, no_ver(i915, huc_gsc, mtl)) \ 125 fw_def(DG1, no_ver(i915, huc, dg1)) \ 126 fw_def(ALDERLAKE_P, no_ver(i915, huc, tgl)) \ 127 fw_def(ALDERLAKE_S, no_ver(i915, huc, tgl)) \ 128 fw_def(ROCKETLAKE, no_ver(i915, huc, tgl)) \ 129 fw_def(TIGERLAKE, no_ver(i915, huc, tgl)) 130 131 /* for the GSC FW we match the compatibility version and not the release one */ 132 #define XE_GSC_FIRMWARE_DEFS(fw_def, major_ver) \ 133 fw_def(LUNARLAKE, major_ver(xe, gsc, lnl, 104, 1, 0)) \ 134 fw_def(METEORLAKE, major_ver(i915, gsc, mtl, 102, 1, 0)) 135 136 #define MAKE_FW_PATH(dir__, uc__, shortname__, version__) \ 137 __stringify(dir__) "/" __stringify(shortname__) "_" __stringify(uc__) version__ ".bin" 138 139 #define fw_filename_mmp_ver(dir_, uc_, shortname_, a, b, c) \ 140 MAKE_FW_PATH(dir_, uc_, shortname_, "_" __stringify(a ## . ## b ## . ## c)) 141 #define fw_filename_major_ver(dir_, uc_, shortname_, a, b, c) \ 142 MAKE_FW_PATH(dir_, uc_, shortname_, "_" __stringify(a)) 143 #define fw_filename_no_ver(dir_, uc_, shortname_) \ 144 MAKE_FW_PATH(dir_, uc_, shortname_, "") 145 #define fw_filename_gsc(dir_, uc_, shortname_, a, b, c) \ 146 MAKE_FW_PATH(dir_, uc_, shortname_, "_" __stringify(b)) 147 148 #define uc_fw_entry_mmp_ver(dir_, uc_, shortname_, a, b, c) \ 149 { fw_filename_mmp_ver(dir_, uc_, shortname_, a, b, c), \ 150 a, b, c, true } 151 #define uc_fw_entry_major_ver(dir_, uc_, shortname_, a, b, c) \ 152 { fw_filename_major_ver(dir_, uc_, shortname_, a, b, c), \ 153 a, b, c } 154 #define uc_fw_entry_no_ver(dir_, uc_, shortname_) \ 155 { fw_filename_no_ver(dir_, uc_, shortname_), \ 156 0, 0 } 157 #define uc_fw_entry_gsc(dir_, uc_, shortname_, a, b, c) \ 158 { fw_filename_gsc(dir_, uc_, shortname_, a, b, c), \ 159 a, b, c } 160 161 /* All blobs need to be declared via MODULE_FIRMWARE() */ 162 #define XE_UC_MODULE_FIRMWARE(platform__, fw_filename) \ 163 MODULE_FIRMWARE(fw_filename); 164 165 #define XE_UC_FW_ENTRY(platform__, entry__) \ 166 { \ 167 .platform = XE_ ## platform__, \ 168 entry__, \ 169 }, 170 171 XE_GUC_FIRMWARE_DEFS(XE_UC_MODULE_FIRMWARE, 172 fw_filename_mmp_ver, fw_filename_major_ver) 173 XE_HUC_FIRMWARE_DEFS(XE_UC_MODULE_FIRMWARE, 174 fw_filename_mmp_ver, fw_filename_no_ver) 175 XE_GSC_FIRMWARE_DEFS(XE_UC_MODULE_FIRMWARE, fw_filename_gsc) 176 177 static struct xe_gt * 178 __uc_fw_to_gt(struct xe_uc_fw *uc_fw, enum xe_uc_fw_type type) 179 { 180 XE_WARN_ON(type >= XE_UC_FW_NUM_TYPES); 181 182 switch (type) { 183 case XE_UC_FW_TYPE_GUC: 184 return container_of(uc_fw, struct xe_gt, uc.guc.fw); 185 case XE_UC_FW_TYPE_HUC: 186 return container_of(uc_fw, struct xe_gt, uc.huc.fw); 187 case XE_UC_FW_TYPE_GSC: 188 return container_of(uc_fw, struct xe_gt, uc.gsc.fw); 189 default: 190 return NULL; 191 } 192 } 193 194 static struct xe_gt *uc_fw_to_gt(struct xe_uc_fw *uc_fw) 195 { 196 return __uc_fw_to_gt(uc_fw, uc_fw->type); 197 } 198 199 static struct xe_device *uc_fw_to_xe(struct xe_uc_fw *uc_fw) 200 { 201 return gt_to_xe(uc_fw_to_gt(uc_fw)); 202 } 203 204 static void 205 uc_fw_auto_select(struct xe_device *xe, struct xe_uc_fw *uc_fw) 206 { 207 static const struct uc_fw_entry entries_guc[] = { 208 XE_GUC_FIRMWARE_DEFS(XE_UC_FW_ENTRY, 209 uc_fw_entry_mmp_ver, 210 uc_fw_entry_major_ver) 211 }; 212 static const struct uc_fw_entry entries_huc[] = { 213 XE_HUC_FIRMWARE_DEFS(XE_UC_FW_ENTRY, 214 uc_fw_entry_mmp_ver, 215 uc_fw_entry_no_ver) 216 }; 217 static const struct uc_fw_entry entries_gsc[] = { 218 XE_GSC_FIRMWARE_DEFS(XE_UC_FW_ENTRY, uc_fw_entry_gsc) 219 }; 220 static const struct fw_blobs_by_type blobs_all[XE_UC_FW_NUM_TYPES] = { 221 [XE_UC_FW_TYPE_GUC] = { entries_guc, ARRAY_SIZE(entries_guc) }, 222 [XE_UC_FW_TYPE_HUC] = { entries_huc, ARRAY_SIZE(entries_huc) }, 223 [XE_UC_FW_TYPE_GSC] = { entries_gsc, ARRAY_SIZE(entries_gsc) }, 224 }; 225 static const struct uc_fw_entry *entries; 226 enum xe_platform p = xe->info.platform; 227 u32 count; 228 int i; 229 230 xe_assert(xe, uc_fw->type < ARRAY_SIZE(blobs_all)); 231 entries = blobs_all[uc_fw->type].entries; 232 count = blobs_all[uc_fw->type].count; 233 234 for (i = 0; i < count && p <= entries[i].platform; i++) { 235 if (p == entries[i].platform) { 236 uc_fw->path = entries[i].path; 237 uc_fw->versions.wanted.major = entries[i].major; 238 uc_fw->versions.wanted.minor = entries[i].minor; 239 uc_fw->versions.wanted.patch = entries[i].patch; 240 uc_fw->full_ver_required = entries[i].full_ver_required; 241 242 if (uc_fw->type == XE_UC_FW_TYPE_GSC) 243 uc_fw->versions.wanted_type = XE_UC_FW_VER_COMPATIBILITY; 244 else 245 uc_fw->versions.wanted_type = XE_UC_FW_VER_RELEASE; 246 247 break; 248 } 249 } 250 } 251 252 static void 253 uc_fw_override(struct xe_uc_fw *uc_fw) 254 { 255 char *path_override = NULL; 256 257 /* empty string disables, but it's not allowed for GuC */ 258 switch (uc_fw->type) { 259 case XE_UC_FW_TYPE_GUC: 260 if (xe_modparam.guc_firmware_path && *xe_modparam.guc_firmware_path) 261 path_override = xe_modparam.guc_firmware_path; 262 break; 263 case XE_UC_FW_TYPE_HUC: 264 path_override = xe_modparam.huc_firmware_path; 265 break; 266 case XE_UC_FW_TYPE_GSC: 267 path_override = xe_modparam.gsc_firmware_path; 268 break; 269 default: 270 break; 271 } 272 273 if (path_override) { 274 uc_fw->path = path_override; 275 uc_fw->user_overridden = true; 276 } 277 } 278 279 /** 280 * xe_uc_fw_copy_rsa - copy fw RSA to buffer 281 * 282 * @uc_fw: uC firmware 283 * @dst: dst buffer 284 * @max_len: max number of bytes to copy 285 * 286 * Return: number of copied bytes. 287 */ 288 size_t xe_uc_fw_copy_rsa(struct xe_uc_fw *uc_fw, void *dst, u32 max_len) 289 { 290 struct xe_device *xe = uc_fw_to_xe(uc_fw); 291 u32 size = min_t(u32, uc_fw->rsa_size, max_len); 292 293 xe_assert(xe, !(size % 4)); 294 xe_assert(xe, xe_uc_fw_is_available(uc_fw)); 295 296 xe_map_memcpy_from(xe, dst, &uc_fw->bo->vmap, 297 xe_uc_fw_rsa_offset(uc_fw), size); 298 299 return size; 300 } 301 302 static void uc_fw_fini(struct drm_device *drm, void *arg) 303 { 304 struct xe_uc_fw *uc_fw = arg; 305 306 if (!xe_uc_fw_is_available(uc_fw)) 307 return; 308 309 xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_SELECTED); 310 } 311 312 static int guc_read_css_info(struct xe_uc_fw *uc_fw, struct uc_css_header *css) 313 { 314 struct xe_gt *gt = uc_fw_to_gt(uc_fw); 315 struct xe_uc_fw_version *release = &uc_fw->versions.found[XE_UC_FW_VER_RELEASE]; 316 struct xe_uc_fw_version *compatibility = &uc_fw->versions.found[XE_UC_FW_VER_COMPATIBILITY]; 317 318 xe_gt_assert(gt, uc_fw->type == XE_UC_FW_TYPE_GUC); 319 320 /* We don't support GuC releases older than 70.29.2 */ 321 if (MAKE_GUC_VER_STRUCT(*release) < MAKE_GUC_VER(70, 29, 2)) { 322 xe_gt_err(gt, "Unsupported GuC v%u.%u.%u! v70.29.2 or newer is required\n", 323 release->major, release->minor, release->patch); 324 return -EINVAL; 325 } 326 327 compatibility->major = FIELD_GET(CSS_SW_VERSION_UC_MAJOR, css->submission_version); 328 compatibility->minor = FIELD_GET(CSS_SW_VERSION_UC_MINOR, css->submission_version); 329 compatibility->patch = FIELD_GET(CSS_SW_VERSION_UC_PATCH, css->submission_version); 330 331 uc_fw->private_data_size = css->private_data_size; 332 333 return 0; 334 } 335 336 int xe_uc_fw_check_version_requirements(struct xe_uc_fw *uc_fw) 337 { 338 struct xe_device *xe = uc_fw_to_xe(uc_fw); 339 struct xe_uc_fw_version *wanted = &uc_fw->versions.wanted; 340 struct xe_uc_fw_version *found = &uc_fw->versions.found[uc_fw->versions.wanted_type]; 341 342 /* Driver has no requirement on any version, any is good. */ 343 if (!wanted->major) 344 return 0; 345 346 /* 347 * If full version is required, both major and minor should match. 348 * Otherwise, at least the major version. 349 */ 350 if (wanted->major != found->major || 351 (uc_fw->full_ver_required && 352 ((wanted->minor != found->minor) || 353 (wanted->patch != found->patch)))) { 354 drm_notice(&xe->drm, "%s firmware %s: unexpected version: %u.%u.%u != %u.%u.%u\n", 355 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, 356 found->major, found->minor, found->patch, 357 wanted->major, wanted->minor, wanted->patch); 358 goto fail; 359 } 360 361 if (wanted->minor > found->minor || 362 (wanted->minor == found->minor && wanted->patch > found->patch)) { 363 drm_notice(&xe->drm, "%s firmware (%u.%u.%u) is recommended, but only (%u.%u.%u) was found in %s\n", 364 xe_uc_fw_type_repr(uc_fw->type), 365 wanted->major, wanted->minor, wanted->patch, 366 found->major, found->minor, found->patch, 367 uc_fw->path); 368 drm_info(&xe->drm, "Consider updating your linux-firmware pkg or downloading from %s\n", 369 XE_UC_FIRMWARE_URL); 370 } 371 372 return 0; 373 374 fail: 375 if (xe_uc_fw_is_overridden(uc_fw)) 376 return 0; 377 378 return -ENOEXEC; 379 } 380 381 /* Refer to the "CSS-based Firmware Layout" documentation entry for details */ 382 static int parse_css_header(struct xe_uc_fw *uc_fw, const void *fw_data, size_t fw_size) 383 { 384 struct xe_device *xe = uc_fw_to_xe(uc_fw); 385 struct xe_uc_fw_version *release = &uc_fw->versions.found[XE_UC_FW_VER_RELEASE]; 386 struct uc_css_header *css; 387 size_t size; 388 389 /* Check the size of the blob before examining buffer contents */ 390 if (unlikely(fw_size < sizeof(struct uc_css_header))) { 391 drm_warn(&xe->drm, "%s firmware %s: invalid size: %zu < %zu\n", 392 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, 393 fw_size, sizeof(struct uc_css_header)); 394 return -ENODATA; 395 } 396 397 css = (struct uc_css_header *)fw_data; 398 399 /* Check integrity of size values inside CSS header */ 400 size = (css->header_size_dw - css->key_size_dw - css->modulus_size_dw - 401 css->exponent_size_dw) * sizeof(u32); 402 if (unlikely(size != sizeof(struct uc_css_header))) { 403 drm_warn(&xe->drm, 404 "%s firmware %s: unexpected header size: %zu != %zu\n", 405 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, 406 fw_size, sizeof(struct uc_css_header)); 407 return -EPROTO; 408 } 409 410 /* uCode size must calculated from other sizes */ 411 uc_fw->ucode_size = (css->size_dw - css->header_size_dw) * sizeof(u32); 412 413 /* now RSA */ 414 uc_fw->rsa_size = css->key_size_dw * sizeof(u32); 415 416 /* At least, it should have header, uCode and RSA. Size of all three. */ 417 size = sizeof(struct uc_css_header) + uc_fw->ucode_size + 418 uc_fw->rsa_size; 419 if (unlikely(fw_size < size)) { 420 drm_warn(&xe->drm, "%s firmware %s: invalid size: %zu < %zu\n", 421 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, 422 fw_size, size); 423 return -ENOEXEC; 424 } 425 426 /* Get version numbers from the CSS header */ 427 release->major = FIELD_GET(CSS_SW_VERSION_UC_MAJOR, css->sw_version); 428 release->minor = FIELD_GET(CSS_SW_VERSION_UC_MINOR, css->sw_version); 429 release->patch = FIELD_GET(CSS_SW_VERSION_UC_PATCH, css->sw_version); 430 431 if (uc_fw->type == XE_UC_FW_TYPE_GUC) 432 return guc_read_css_info(uc_fw, css); 433 434 return 0; 435 } 436 437 static bool is_cpd_header(const void *data) 438 { 439 const u32 *marker = data; 440 441 return *marker == GSC_CPD_HEADER_MARKER; 442 } 443 444 static u32 entry_offset(const struct gsc_cpd_header_v2 *header, const char *name) 445 { 446 const struct gsc_cpd_entry *entry; 447 int i; 448 449 entry = (void *)header + header->header_length; 450 451 for (i = 0; i < header->num_of_entries; i++, entry++) 452 if (strcmp(entry->name, name) == 0) 453 return entry->offset & GSC_CPD_ENTRY_OFFSET_MASK; 454 455 return 0; 456 } 457 458 /* Refer to the "GSC-based Firmware Layout" documentation entry for details */ 459 static int parse_cpd_header(struct xe_uc_fw *uc_fw, const void *data, size_t size, 460 const char *manifest_entry, const char *css_entry) 461 { 462 struct xe_gt *gt = uc_fw_to_gt(uc_fw); 463 struct xe_device *xe = gt_to_xe(gt); 464 const struct gsc_cpd_header_v2 *header = data; 465 struct xe_uc_fw_version *release = &uc_fw->versions.found[XE_UC_FW_VER_RELEASE]; 466 const struct gsc_manifest_header *manifest; 467 size_t min_size = sizeof(*header); 468 u32 offset; 469 470 /* manifest_entry is mandatory, css_entry is optional */ 471 xe_assert(xe, manifest_entry); 472 473 if (size < min_size || !is_cpd_header(header)) 474 return -ENOENT; 475 476 if (header->header_length < sizeof(struct gsc_cpd_header_v2)) { 477 xe_gt_err(gt, "invalid CPD header length %u!\n", header->header_length); 478 return -EINVAL; 479 } 480 481 min_size = header->header_length + sizeof(struct gsc_cpd_entry) * header->num_of_entries; 482 if (size < min_size) { 483 xe_gt_err(gt, "FW too small! %zu < %zu\n", size, min_size); 484 return -ENODATA; 485 } 486 487 /* Look for the manifest first */ 488 offset = entry_offset(header, manifest_entry); 489 if (!offset) { 490 xe_gt_err(gt, "Failed to find %s manifest!\n", 491 xe_uc_fw_type_repr(uc_fw->type)); 492 return -ENODATA; 493 } 494 495 min_size = offset + sizeof(struct gsc_manifest_header); 496 if (size < min_size) { 497 xe_gt_err(gt, "FW too small! %zu < %zu\n", size, min_size); 498 return -ENODATA; 499 } 500 501 manifest = data + offset; 502 503 release->major = manifest->fw_version.major; 504 release->minor = manifest->fw_version.minor; 505 release->patch = manifest->fw_version.hotfix; 506 507 if (uc_fw->type == XE_UC_FW_TYPE_GSC) { 508 struct xe_gsc *gsc = container_of(uc_fw, struct xe_gsc, fw); 509 510 release->build = manifest->fw_version.build; 511 gsc->security_version = manifest->security_version; 512 } 513 514 /* then optionally look for the css header */ 515 if (css_entry) { 516 int ret; 517 518 /* 519 * This section does not contain a CSS entry on DG2. We 520 * don't support DG2 HuC right now, so no need to handle 521 * it, just add a reminder in case that changes. 522 */ 523 xe_assert(xe, xe->info.platform != XE_DG2); 524 525 offset = entry_offset(header, css_entry); 526 527 /* the CSS header parser will check that the CSS header fits */ 528 if (offset > size) { 529 xe_gt_err(gt, "FW too small! %zu < %u\n", size, offset); 530 return -ENODATA; 531 } 532 533 ret = parse_css_header(uc_fw, data + offset, size - offset); 534 if (ret) 535 return ret; 536 537 uc_fw->css_offset = offset; 538 } 539 540 uc_fw->has_gsc_headers = true; 541 542 return 0; 543 } 544 545 static int parse_gsc_layout(struct xe_uc_fw *uc_fw, const void *data, size_t size) 546 { 547 struct xe_gt *gt = uc_fw_to_gt(uc_fw); 548 const struct gsc_layout_pointers *layout = data; 549 const struct gsc_bpdt_header *bpdt_header = NULL; 550 const struct gsc_bpdt_entry *bpdt_entry = NULL; 551 size_t min_size = sizeof(*layout); 552 int i; 553 554 if (size < min_size) { 555 xe_gt_err(gt, "GSC FW too small! %zu < %zu\n", size, min_size); 556 return -ENODATA; 557 } 558 559 min_size = layout->boot1.offset + layout->boot1.size; 560 if (size < min_size) { 561 xe_gt_err(gt, "GSC FW too small for boot section! %zu < %zu\n", 562 size, min_size); 563 return -ENODATA; 564 } 565 566 min_size = sizeof(*bpdt_header); 567 if (layout->boot1.size < min_size) { 568 xe_gt_err(gt, "GSC FW boot section too small for BPDT header: %u < %zu\n", 569 layout->boot1.size, min_size); 570 return -ENODATA; 571 } 572 573 bpdt_header = data + layout->boot1.offset; 574 if (bpdt_header->signature != GSC_BPDT_HEADER_SIGNATURE) { 575 xe_gt_err(gt, "invalid signature for BPDT header: 0x%08x!\n", 576 bpdt_header->signature); 577 return -EINVAL; 578 } 579 580 min_size += sizeof(*bpdt_entry) * bpdt_header->descriptor_count; 581 if (layout->boot1.size < min_size) { 582 xe_gt_err(gt, "GSC FW boot section too small for BPDT entries: %u < %zu\n", 583 layout->boot1.size, min_size); 584 return -ENODATA; 585 } 586 587 bpdt_entry = (void *)bpdt_header + sizeof(*bpdt_header); 588 for (i = 0; i < bpdt_header->descriptor_count; i++, bpdt_entry++) { 589 if ((bpdt_entry->type & GSC_BPDT_ENTRY_TYPE_MASK) != 590 GSC_BPDT_ENTRY_TYPE_GSC_RBE) 591 continue; 592 593 min_size = bpdt_entry->sub_partition_offset; 594 595 /* the CPD header parser will check that the CPD header fits */ 596 if (layout->boot1.size < min_size) { 597 xe_gt_err(gt, "GSC FW boot section too small for CPD offset: %u < %zu\n", 598 layout->boot1.size, min_size); 599 return -ENODATA; 600 } 601 602 return parse_cpd_header(uc_fw, 603 (void *)bpdt_header + min_size, 604 layout->boot1.size - min_size, 605 "RBEP.man", NULL); 606 } 607 608 xe_gt_err(gt, "couldn't find CPD header in GSC binary!\n"); 609 return -ENODATA; 610 } 611 612 static int parse_headers(struct xe_uc_fw *uc_fw, const struct firmware *fw) 613 { 614 int ret; 615 616 /* 617 * All GuC releases and older HuC ones use CSS headers, while newer HuC 618 * releases use GSC CPD headers. 619 */ 620 switch (uc_fw->type) { 621 case XE_UC_FW_TYPE_GSC: 622 return parse_gsc_layout(uc_fw, fw->data, fw->size); 623 case XE_UC_FW_TYPE_HUC: 624 ret = parse_cpd_header(uc_fw, fw->data, fw->size, "HUCP.man", "huc_fw"); 625 if (!ret || ret != -ENOENT) 626 return ret; 627 fallthrough; 628 case XE_UC_FW_TYPE_GUC: 629 return parse_css_header(uc_fw, fw->data, fw->size); 630 default: 631 return -EINVAL; 632 } 633 634 return 0; 635 } 636 637 #define print_uc_fw_version(p_, version_, prefix_, ...) \ 638 do { \ 639 struct xe_uc_fw_version *ver_ = (version_); \ 640 if (ver_->build) \ 641 drm_printf(p_, prefix_ " version %u.%u.%u.%u\n", ##__VA_ARGS__, \ 642 ver_->major, ver_->minor, \ 643 ver_->patch, ver_->build); \ 644 else \ 645 drm_printf(p_, prefix_ " version %u.%u.%u\n", ##__VA_ARGS__, \ 646 ver_->major, ver_->minor, ver_->patch); \ 647 } while (0) 648 649 static int uc_fw_request(struct xe_uc_fw *uc_fw, const struct firmware **firmware_p) 650 { 651 struct xe_device *xe = uc_fw_to_xe(uc_fw); 652 struct device *dev = xe->drm.dev; 653 struct drm_printer p = drm_info_printer(dev); 654 const struct firmware *fw = NULL; 655 int err; 656 657 /* 658 * we use FIRMWARE_UNINITIALIZED to detect checks against uc_fw->status 659 * before we're looked at the HW caps to see if we have uc support 660 */ 661 BUILD_BUG_ON(XE_UC_FIRMWARE_UNINITIALIZED); 662 xe_assert(xe, !uc_fw->status); 663 xe_assert(xe, !uc_fw->path); 664 665 uc_fw_auto_select(xe, uc_fw); 666 667 if (IS_SRIOV_VF(xe)) { 668 /* Only GuC/HuC are supported */ 669 if (uc_fw->type != XE_UC_FW_TYPE_GUC && 670 uc_fw->type != XE_UC_FW_TYPE_HUC) 671 uc_fw->path = NULL; 672 /* VF will support only firmwares that driver can autoselect */ 673 xe_uc_fw_change_status(uc_fw, uc_fw->path ? 674 XE_UC_FIRMWARE_PRELOADED : 675 XE_UC_FIRMWARE_NOT_SUPPORTED); 676 return 0; 677 } 678 679 uc_fw_override(uc_fw); 680 681 xe_uc_fw_change_status(uc_fw, uc_fw->path ? 682 XE_UC_FIRMWARE_SELECTED : 683 XE_UC_FIRMWARE_NOT_SUPPORTED); 684 685 if (!xe_uc_fw_is_supported(uc_fw)) { 686 if (uc_fw->type == XE_UC_FW_TYPE_GUC) { 687 drm_err(&xe->drm, "No GuC firmware defined for platform\n"); 688 return -ENOENT; 689 } 690 return 0; 691 } 692 693 /* an empty path means the firmware is disabled */ 694 if (!xe_device_uc_enabled(xe) || !(*uc_fw->path)) { 695 xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_DISABLED); 696 drm_dbg(&xe->drm, "%s disabled", xe_uc_fw_type_repr(uc_fw->type)); 697 return 0; 698 } 699 700 err = request_firmware(&fw, uc_fw->path, dev); 701 if (err) 702 goto fail; 703 704 err = parse_headers(uc_fw, fw); 705 if (err) 706 goto fail; 707 708 print_uc_fw_version(&p, 709 &uc_fw->versions.found[XE_UC_FW_VER_RELEASE], 710 "Using %s firmware from %s", 711 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path); 712 713 /* for GSC FW we want the compatibility version, which we query after load */ 714 if (uc_fw->type != XE_UC_FW_TYPE_GSC) { 715 err = xe_uc_fw_check_version_requirements(uc_fw); 716 if (err) 717 goto fail; 718 } 719 720 *firmware_p = fw; 721 722 return 0; 723 724 fail: 725 xe_uc_fw_change_status(uc_fw, err == -ENOENT ? 726 XE_UC_FIRMWARE_MISSING : 727 XE_UC_FIRMWARE_ERROR); 728 729 drm_notice(&xe->drm, "%s firmware %s: fetch failed with error %d\n", 730 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, err); 731 drm_info(&xe->drm, "%s firmware(s) can be downloaded from %s\n", 732 xe_uc_fw_type_repr(uc_fw->type), XE_UC_FIRMWARE_URL); 733 734 release_firmware(fw); /* OK even if fw is NULL */ 735 736 return err; 737 } 738 739 static void uc_fw_release(const struct firmware *fw) 740 { 741 release_firmware(fw); 742 } 743 744 static int uc_fw_copy(struct xe_uc_fw *uc_fw, const void *data, size_t size, u32 flags) 745 { 746 struct xe_device *xe = uc_fw_to_xe(uc_fw); 747 struct xe_gt *gt = uc_fw_to_gt(uc_fw); 748 struct xe_tile *tile = gt_to_tile(gt); 749 struct xe_bo *obj; 750 int err; 751 752 obj = xe_managed_bo_create_from_data(xe, tile, data, size, flags); 753 if (IS_ERR(obj)) { 754 drm_notice(&xe->drm, "%s firmware %s: failed to create / populate bo", 755 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path); 756 err = PTR_ERR(obj); 757 goto fail; 758 } 759 760 uc_fw->bo = obj; 761 uc_fw->size = size; 762 763 xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_AVAILABLE); 764 765 err = drmm_add_action_or_reset(&xe->drm, uc_fw_fini, uc_fw); 766 if (err) 767 goto fail; 768 769 return 0; 770 771 fail: 772 xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_ERROR); 773 drm_notice(&xe->drm, "%s firmware %s: copy failed with error %d\n", 774 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, err); 775 776 return err; 777 } 778 779 int xe_uc_fw_init(struct xe_uc_fw *uc_fw) 780 { 781 const struct firmware *fw = NULL; 782 int err; 783 784 err = uc_fw_request(uc_fw, &fw); 785 if (err) 786 return err; 787 788 /* no error and no firmware means nothing to copy */ 789 if (!fw) 790 return 0; 791 792 err = uc_fw_copy(uc_fw, fw->data, fw->size, 793 XE_BO_FLAG_SYSTEM | XE_BO_FLAG_GGTT | 794 XE_BO_FLAG_GGTT_INVALIDATE); 795 796 uc_fw_release(fw); 797 798 return err; 799 } 800 ALLOW_ERROR_INJECTION(xe_uc_fw_init, ERRNO); /* See xe_pci_probe() */ 801 802 static u32 uc_fw_ggtt_offset(struct xe_uc_fw *uc_fw) 803 { 804 return xe_bo_ggtt_addr(uc_fw->bo); 805 } 806 807 static int uc_fw_xfer(struct xe_uc_fw *uc_fw, u32 offset, u32 dma_flags) 808 { 809 struct xe_device *xe = uc_fw_to_xe(uc_fw); 810 struct xe_gt *gt = uc_fw_to_gt(uc_fw); 811 struct xe_mmio *mmio = >->mmio; 812 u64 src_offset; 813 u32 dma_ctrl; 814 int ret; 815 816 xe_force_wake_assert_held(gt_to_fw(gt), XE_FW_GT); 817 818 /* Set the source address for the uCode */ 819 src_offset = uc_fw_ggtt_offset(uc_fw) + uc_fw->css_offset; 820 xe_mmio_write32(mmio, DMA_ADDR_0_LOW, lower_32_bits(src_offset)); 821 xe_mmio_write32(mmio, DMA_ADDR_0_HIGH, 822 upper_32_bits(src_offset) | DMA_ADDRESS_SPACE_GGTT); 823 824 /* Set the DMA destination */ 825 xe_mmio_write32(mmio, DMA_ADDR_1_LOW, offset); 826 xe_mmio_write32(mmio, DMA_ADDR_1_HIGH, DMA_ADDRESS_SPACE_WOPCM); 827 828 /* 829 * Set the transfer size. The header plus uCode will be copied to WOPCM 830 * via DMA, excluding any other components 831 */ 832 xe_mmio_write32(mmio, DMA_COPY_SIZE, 833 sizeof(struct uc_css_header) + uc_fw->ucode_size); 834 835 /* Start the DMA */ 836 xe_mmio_write32(mmio, DMA_CTRL, 837 _MASKED_BIT_ENABLE(dma_flags | START_DMA)); 838 839 /* Wait for DMA to finish */ 840 ret = xe_mmio_wait32(mmio, DMA_CTRL, START_DMA, 0, 100000, &dma_ctrl, 841 false); 842 if (ret) 843 drm_err(&xe->drm, "DMA for %s fw failed, DMA_CTRL=%u\n", 844 xe_uc_fw_type_repr(uc_fw->type), dma_ctrl); 845 846 /* Disable the bits once DMA is over */ 847 xe_mmio_write32(mmio, DMA_CTRL, _MASKED_BIT_DISABLE(dma_flags)); 848 849 return ret; 850 } 851 852 int xe_uc_fw_upload(struct xe_uc_fw *uc_fw, u32 offset, u32 dma_flags) 853 { 854 struct xe_device *xe = uc_fw_to_xe(uc_fw); 855 int err; 856 857 /* make sure the status was cleared the last time we reset the uc */ 858 xe_assert(xe, !xe_uc_fw_is_loaded(uc_fw)); 859 860 if (!xe_uc_fw_is_loadable(uc_fw)) 861 return -ENOEXEC; 862 863 /* Call custom loader */ 864 err = uc_fw_xfer(uc_fw, offset, dma_flags); 865 if (err) 866 goto fail; 867 868 xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_TRANSFERRED); 869 return 0; 870 871 fail: 872 drm_err(&xe->drm, "Failed to load %s firmware %s (%d)\n", 873 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path, 874 err); 875 xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_LOAD_FAIL); 876 return err; 877 } 878 879 static const char *version_type_repr(enum xe_uc_fw_version_types type) 880 { 881 switch (type) { 882 case XE_UC_FW_VER_RELEASE: 883 return "release"; 884 case XE_UC_FW_VER_COMPATIBILITY: 885 return "compatibility"; 886 default: 887 return "Unknown version type"; 888 } 889 } 890 891 void xe_uc_fw_print(struct xe_uc_fw *uc_fw, struct drm_printer *p) 892 { 893 int i; 894 895 drm_printf(p, "%s firmware: %s\n", 896 xe_uc_fw_type_repr(uc_fw->type), uc_fw->path); 897 drm_printf(p, "\tstatus: %s\n", 898 xe_uc_fw_status_repr(uc_fw->status)); 899 900 print_uc_fw_version(p, &uc_fw->versions.wanted, "\twanted %s", 901 version_type_repr(uc_fw->versions.wanted_type)); 902 903 for (i = 0; i < XE_UC_FW_VER_TYPE_COUNT; i++) { 904 struct xe_uc_fw_version *ver = &uc_fw->versions.found[i]; 905 906 if (ver->major) 907 print_uc_fw_version(p, ver, "\tfound %s", 908 version_type_repr(i)); 909 } 910 911 if (uc_fw->ucode_size) 912 drm_printf(p, "\tuCode: %u bytes\n", uc_fw->ucode_size); 913 if (uc_fw->rsa_size) 914 drm_printf(p, "\tRSA: %u bytes\n", uc_fw->rsa_size); 915 } 916