/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * * Copyright 2012 Nexenta Systems, Inc. All rights reserved. * Copyright (c) 2018, Joyent, Inc. * Copyright 2021 OmniOS Community Edition (OmniOSce) Association. * Copyright 2025 Oxide Computer Company */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include extern void *ucode_zalloc(size_t); extern void ucode_free(void *, size_t); extern const char *ucode_path(void); extern int ucode_force_update; extern bool ucode_use_kmem; static ucode_file_amd_t *amd_ucodef; static size_t amd_ucodef_len, amd_ucodef_buflen; static ucode_eqtbl_amd_t *ucode_eqtbl_amd; static uint_t ucode_eqtbl_amd_entries; static bool ucode_amd_fallback = false; /* * Check whether this module can be used for microcode updates on this * platform. */ static bool ucode_select_amd(cpu_t *cp) { if ((get_hwenv() & HW_VIRTUAL) != 0) return (false); return (cpuid_getvendor(cp) == X86_VENDOR_AMD); } /* * Check whether or not a processor is capable of microcode operations * * At this point we only support microcode update for: * - AMD processors family 0x10 and above. */ static bool ucode_capable_amd(cpu_t *cp) { return (cpuid_getfamily(cp) >= 0x10); } /* * Called when it is no longer necessary to keep the microcode around, * or when the cached microcode doesn't match the CPU being processed. */ static void ucode_file_reset_amd(void) { if (amd_ucodef == NULL) return; ucode_free(amd_ucodef, amd_ucodef_buflen); amd_ucodef = NULL; amd_ucodef_buflen = amd_ucodef_len = 0; } /* * Find the equivalent CPU id in the equivalence table. */ static ucode_errno_t ucode_equiv_cpu_amd(cpu_t *cp, uint16_t *eq_sig) { char *name = NULL; int cpi_sig = cpuid_getsig(cp); ucode_errno_t ret = EM_OK; if (ucode_eqtbl_amd == NULL) { name = ucode_zalloc(MAXPATHLEN); if (name == NULL) return (EM_NOMEM); (void) snprintf(name, MAXPATHLEN, "%s/%s/%s", ucode_path(), cpuid_getvendorstr(cp), UCODE_AMD_EQUIVALENCE_TABLE_NAME); } if (!ucode_use_kmem) { /* * No kmem_zalloc() etc. available yet. */ ucode_eqtbl_amd_t eqtbl; int count, offset = 0; intptr_t fd; ASSERT3P(name, !=, NULL); if ((fd = kobj_open(name)) == -1) { ret = EM_OPENFILE; goto out; } do { count = kobj_read(fd, (int8_t *)&eqtbl, sizeof (eqtbl), offset); if (count != sizeof (eqtbl)) { (void) kobj_close(fd); ret = EM_HIGHERREV; goto out; } offset += count; } while (eqtbl.ue_inst_cpu != 0 && eqtbl.ue_inst_cpu != cpi_sig); (void) kobj_close(fd); *eq_sig = eqtbl.ue_equiv_cpu; } else { ucode_eqtbl_amd_t *eqtbl; /* * If not already done, load the equivalence table. */ if (ucode_eqtbl_amd == NULL) { struct _buf *eq; uint64_t size; int count; ASSERT3P(name, !=, NULL); if ((eq = kobj_open_file(name)) == (struct _buf *)-1) { ret = EM_OPENFILE; goto out; } if (kobj_get_filesize(eq, &size) < 0) { kobj_close_file(eq); ret = EM_OPENFILE; goto out; } if (size == 0 || size % sizeof (*ucode_eqtbl_amd) != 0) { kobj_close_file(eq); ret = EM_HIGHERREV; goto out; } ucode_eqtbl_amd = kmem_zalloc(size, KM_NOSLEEP); if (ucode_eqtbl_amd == NULL) { kobj_close_file(eq); ret = EM_NOMEM; goto out; } count = kobj_read_file(eq, (char *)ucode_eqtbl_amd, size, 0); kobj_close_file(eq); if (count != size) { ucode_eqtbl_amd_entries = 0; ret = EM_FILESIZE; goto out; } ucode_eqtbl_amd_entries = size / sizeof (*ucode_eqtbl_amd); } eqtbl = ucode_eqtbl_amd; *eq_sig = 0; for (uint_t i = 0; i < ucode_eqtbl_amd_entries; i++, eqtbl++) { if (eqtbl->ue_inst_cpu == 0) { /* End of table */ ret = EM_HIGHERREV; goto out; } if (eqtbl->ue_inst_cpu == cpi_sig) { *eq_sig = eqtbl->ue_equiv_cpu; ret = EM_OK; goto out; } } /* * No equivalent CPU id found, assume outdated microcode file. */ ret = EM_HIGHERREV; } out: ucode_free(name, MAXPATHLEN); return (ret); } static ucode_errno_t ucode_match_amd(uint16_t eq_sig, cpu_ucode_info_t *uinfop, ucode_file_amd_t *ucodefp, size_t size) { ucode_header_amd_t *uh; if (ucodefp == NULL || size < sizeof (ucode_header_amd_t)) return (EM_NOMATCH); uh = &ucodefp->uf_header; /* * Don't even think about loading patches that would require code * execution. Does not apply to patches for family 0x14 and beyond. */ if (uh->uh_cpu_rev < 0x5000 && size > offsetof(ucode_file_amd_t, uf_code_present) && ucodefp->uf_code_present) { return (EM_NOMATCH); } if (eq_sig != uh->uh_cpu_rev) return (EM_NOMATCH); if (uh->uh_nb_id) { cmn_err(CE_WARN, "ignoring northbridge-specific ucode: " "chipset id %x, revision %x", uh->uh_nb_id, uh->uh_nb_rev); return (EM_NOMATCH); } if (uh->uh_sb_id) { cmn_err(CE_WARN, "ignoring southbridge-specific ucode: " "chipset id %x, revision %x", uh->uh_sb_id, uh->uh_sb_rev); return (EM_NOMATCH); } if (uh->uh_patch_id <= uinfop->cui_rev && !ucode_force_update) return (EM_HIGHERREV); return (EM_OK); } /* * Copy the given ucode into cpu_ucode_info_t in preparation for loading onto * the corresponding CPU via ucode_load_amd(). */ static ucode_errno_t ucode_copy_amd(cpu_ucode_info_t *uinfop, const ucode_file_amd_t *ucodefp, size_t size) { ASSERT3P(uinfop->cui_pending_ucode, ==, NULL); ASSERT3U(size, <=, UCODE_AMD_MAXSIZE); uinfop->cui_pending_ucode = ucode_zalloc(size); if (uinfop->cui_pending_ucode == NULL) return (EM_NOMEM); (void) memcpy(uinfop->cui_pending_ucode, ucodefp, size); uinfop->cui_pending_size = size; uinfop->cui_pending_rev = ucodefp->uf_header.uh_patch_id; return (EM_OK); } /* * Populate the ucode file structure from the microcode file corresponding to * this CPU, if exists. * * Return EM_OK on success, corresponding error code on failure. */ static ucode_errno_t i_ucode_locate_amd(cpu_t *cp, cpu_ucode_info_t *uinfop, bool fallback) { uint16_t eq_sig; ucode_errno_t rc; /* get equivalent CPU id */ eq_sig = 0; if ((rc = ucode_equiv_cpu_amd(cp, &eq_sig)) != EM_OK) return (rc); /* * Allocate a buffer for the microcode patch. If the buffer has been * allocated before, check for a matching microcode to avoid loading * the file again. */ if (amd_ucodef == NULL) { size_t len = PAGESIZE; amd_ucodef = ucode_zalloc(len); if (amd_ucodef == NULL) return (EM_NOMEM); amd_ucodef_buflen = len; } else { rc = ucode_match_amd(eq_sig, uinfop, amd_ucodef, amd_ucodef_len); if (rc == EM_HIGHERREV) return (rc); if (rc == EM_OK) { return (ucode_copy_amd(uinfop, amd_ucodef, amd_ucodef_len)); } } /* * Find the patch for this CPU. The patch files are named XXXX-YY, where * XXXX is the equivalent CPU id and YY is the running patch number. * Patches specific to certain chipsets are guaranteed to have lower * numbers than less specific patches, so we can just load the first * patch that matches. */ for (uint_t i = 0; i < 0xff; i++) { char name[MAXPATHLEN]; intptr_t fd; int count; /* This is a uint_t to match the signature of kobj_read() */ uint_t size; (void) snprintf(name, MAXPATHLEN, "%s/%s/%s%04X-%02X", ucode_path(), cpuid_getvendorstr(cp), fallback ? "fallback/" : "", eq_sig, i); if ((fd = kobj_open(name)) == -1) return (EM_NOMATCH); /* * Since this code will run for the boot CPU before kmem is * initialised we can't use the kobj_*_file() functions. * In the case where the archive contains compressed files, * kobj_fstat() will return the compressed size and so we must * read the entire file through to determine its size. */ size = 0; do { count = kobj_read(fd, (char *)amd_ucodef, amd_ucodef_buflen, size); if (count < 0) { (void) kobj_close(fd); return (EM_OPENFILE); } size += count; } while (count == amd_ucodef_buflen && size <= UCODE_AMD_MAXSIZE); if (size > UCODE_AMD_MAXSIZE) { (void) kobj_close(fd); cmn_err(CE_WARN, "ucode: microcode file %s is " "too large (over 0x%x bytes)", name, UCODE_AMD_MAXSIZE); return (EM_FILESIZE); } if (size > amd_ucodef_buflen) { size_t len = P2ROUNDUP(size, PAGESIZE); ucode_file_reset_amd(); amd_ucodef = ucode_zalloc(len); if (amd_ucodef == NULL) { (void) kobj_close(fd); return (EM_NOMEM); } amd_ucodef_buflen = len; } count = kobj_read(fd, (char *)amd_ucodef, amd_ucodef_buflen, 0); (void) kobj_close(fd); if (count < 0 || count != size) return (EM_OPENFILE); amd_ucodef_len = count; rc = ucode_match_amd(eq_sig, uinfop, amd_ucodef, amd_ucodef_len); if (rc == EM_HIGHERREV) return (rc); if (rc == EM_OK) { return (ucode_copy_amd(uinfop, amd_ucodef, amd_ucodef_len)); } } return (EM_NOMATCH); } ucode_errno_t ucode_locate_amd(cpu_t *cp, cpu_ucode_info_t *uinfop) { return (i_ucode_locate_amd(cp, uinfop, ucode_amd_fallback)); } ucode_errno_t ucode_locate_fallback_amd(cpu_t *cp, cpu_ucode_info_t *uinfop) { /* Once we have switched to the fallback microcode, stick with it */ ucode_amd_fallback = true; return (i_ucode_locate_amd(cp, uinfop, ucode_amd_fallback)); } static void ucode_read_rev_amd(cpu_ucode_info_t *uinfop) { uinfop->cui_rev = rdmsr(MSR_AMD_PATCHLEVEL); } static void ucode_load_amd(cpu_ucode_info_t *uinfop) { ucode_file_amd_t *ucodefp = uinfop->cui_pending_ucode; on_trap_data_t otd; VERIFY3P(ucodefp, !=, NULL); VERIFY3U(ucodefp->uf_header.uh_patch_id, ==, uinfop->cui_pending_rev); kpreempt_disable(); if (on_trap(&otd, OT_DATA_ACCESS)) { no_trap(); goto out; } wrmsr(MSR_AMD_PATCHLOADER, (uintptr_t)ucodefp); no_trap(); out: kpreempt_enable(); } static ucode_errno_t ucode_extract_amd(ucode_update_t *uusp, uint8_t *ucodep, size_t size) { uint32_t *ptr = (uint32_t *)ucodep; ucode_eqtbl_amd_t *eqtbl; ucode_file_amd_t *ufp; uint32_t count; bool higher = false; ucode_errno_t rc = EM_NOMATCH; uint16_t eq_sig; /* skip over magic number & equivalence table header */ ptr += 2; size -= 8; count = *ptr++; size -= 4; for (eqtbl = (ucode_eqtbl_amd_t *)ptr; eqtbl->ue_inst_cpu && eqtbl->ue_inst_cpu != uusp->sig; eqtbl++) ; eq_sig = eqtbl->ue_equiv_cpu; /* No equivalent CPU id found, assume outdated microcode file. */ if (eq_sig == 0) return (EM_HIGHERREV); /* Use the first microcode patch that matches. */ do { ptr += count >> 2; size -= count; if (size == 0) return (higher ? EM_HIGHERREV : EM_NOMATCH); ptr++; size -= 4; count = *ptr++; size -= 4; ufp = (ucode_file_amd_t *)ptr; rc = ucode_match_amd(eq_sig, &uusp->info, ufp, count); if (rc == EM_HIGHERREV) higher = true; } while (rc != EM_OK); uusp->ucodep = (uint8_t *)ufp; uusp->usize = count; uusp->expected_rev = ufp->uf_header.uh_patch_id; return (EM_OK); } static const ucode_source_t ucode_amd = { .us_name = "AMD microcode updater", .us_write_msr = MSR_AMD_PATCHLOADER, .us_invalidate = false, .us_select = ucode_select_amd, .us_capable = ucode_capable_amd, .us_file_reset = ucode_file_reset_amd, .us_read_rev = ucode_read_rev_amd, .us_load = ucode_load_amd, .us_validate = ucode_validate_amd, .us_extract = ucode_extract_amd, .us_locate = ucode_locate_amd, .us_locate_fallback = ucode_locate_fallback_amd }; UCODE_SOURCE(ucode_amd);