12449e17fSsherrym /* 22449e17fSsherrym * CDDL HEADER START 32449e17fSsherrym * 42449e17fSsherrym * The contents of this file are subject to the terms of the 52449e17fSsherrym * Common Development and Distribution License (the "License"). 62449e17fSsherrym * You may not use this file except in compliance with the License. 72449e17fSsherrym * 82449e17fSsherrym * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 92449e17fSsherrym * or http://www.opensolaris.org/os/licensing. 102449e17fSsherrym * See the License for the specific language governing permissions 112449e17fSsherrym * and limitations under the License. 122449e17fSsherrym * 132449e17fSsherrym * When distributing Covered Code, include this CDDL HEADER in each 142449e17fSsherrym * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 152449e17fSsherrym * If applicable, add the following below this CDDL HEADER, with the 162449e17fSsherrym * fields enclosed by brackets "[]" replaced with your own identifying 172449e17fSsherrym * information: Portions Copyright [yyyy] [name of copyright owner] 182449e17fSsherrym * 192449e17fSsherrym * CDDL HEADER END 202449e17fSsherrym */ 212449e17fSsherrym 222449e17fSsherrym /* 230ba6f73dSMark Johnson * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 242449e17fSsherrym * Use is subject to license terms. 252449e17fSsherrym */ 262449e17fSsherrym 272449e17fSsherrym #include <sys/asm_linkage.h> 282449e17fSsherrym #include <sys/bootconf.h> 292449e17fSsherrym #include <sys/cpuvar.h> 302449e17fSsherrym #include <sys/cmn_err.h> 312449e17fSsherrym #include <sys/controlregs.h> 322449e17fSsherrym #include <sys/debug.h> 332449e17fSsherrym #include <sys/kobj.h> 342449e17fSsherrym #include <sys/kobj_impl.h> 352449e17fSsherrym #include <sys/machsystm.h> 362449e17fSsherrym #include <sys/param.h> 372449e17fSsherrym #include <sys/machparam.h> 382449e17fSsherrym #include <sys/promif.h> 392449e17fSsherrym #include <sys/sysmacros.h> 402449e17fSsherrym #include <sys/systm.h> 412449e17fSsherrym #include <sys/types.h> 422449e17fSsherrym #include <sys/thread.h> 432449e17fSsherrym #include <sys/ucode.h> 442449e17fSsherrym #include <sys/x86_archext.h> 452449e17fSsherrym #include <sys/x_call.h> 46843e1988Sjohnlev #ifdef __xpv 47843e1988Sjohnlev #include <sys/hypervisor.h> 48843e1988Sjohnlev #endif 492449e17fSsherrym 502449e17fSsherrym /* 51adc586deSMark Johnson * AMD-specific equivalence table 522449e17fSsherrym */ 53adc586deSMark Johnson static ucode_eqtbl_amd_t *ucode_eqtbl_amd; 542449e17fSsherrym 552449e17fSsherrym /* 562449e17fSsherrym * mcpu_ucode_info for the boot CPU. Statically allocated. 572449e17fSsherrym */ 582449e17fSsherrym static struct cpu_ucode_info cpu_ucode_info0; 592449e17fSsherrym 60adc586deSMark Johnson static ucode_file_t ucodefile; 612449e17fSsherrym 62adc586deSMark Johnson static void* ucode_zalloc(processorid_t, size_t); 63adc586deSMark Johnson static void ucode_free(processorid_t, void *, size_t); 64adc586deSMark Johnson 65adc586deSMark Johnson static int ucode_capable_amd(cpu_t *); 66adc586deSMark Johnson static int ucode_capable_intel(cpu_t *); 67adc586deSMark Johnson 68adc586deSMark Johnson static ucode_errno_t ucode_extract_amd(ucode_update_t *, uint8_t *, int); 69adc586deSMark Johnson static ucode_errno_t ucode_extract_intel(ucode_update_t *, uint8_t *, 70adc586deSMark Johnson int); 71adc586deSMark Johnson 72adc586deSMark Johnson static void ucode_file_reset_amd(ucode_file_t *, processorid_t); 73adc586deSMark Johnson static void ucode_file_reset_intel(ucode_file_t *, processorid_t); 74adc586deSMark Johnson 75adc586deSMark Johnson static uint32_t ucode_load_amd(ucode_file_t *, cpu_ucode_info_t *, cpu_t *); 76adc586deSMark Johnson static uint32_t ucode_load_intel(ucode_file_t *, cpu_ucode_info_t *, cpu_t *); 77adc586deSMark Johnson 78882a7af5SMark Johnson #ifdef __xpv 79adc586deSMark Johnson static void ucode_load_xpv(ucode_update_t *); 800ba6f73dSMark Johnson static void ucode_chipset_amd(uint8_t *, int); 81882a7af5SMark Johnson #endif 822449e17fSsherrym 830ba6f73dSMark Johnson static int ucode_equiv_cpu_amd(cpu_t *, uint16_t *); 84adc586deSMark Johnson 85adc586deSMark Johnson static ucode_errno_t ucode_locate_amd(cpu_t *, cpu_ucode_info_t *, 86adc586deSMark Johnson ucode_file_t *); 87adc586deSMark Johnson static ucode_errno_t ucode_locate_intel(cpu_t *, cpu_ucode_info_t *, 88adc586deSMark Johnson ucode_file_t *); 89adc586deSMark Johnson 900ba6f73dSMark Johnson #ifndef __xpv 910ba6f73dSMark Johnson static ucode_errno_t ucode_match_amd(uint16_t, cpu_ucode_info_t *, 92adc586deSMark Johnson ucode_file_amd_t *, int); 930ba6f73dSMark Johnson #endif 94adc586deSMark Johnson static ucode_errno_t ucode_match_intel(int, cpu_ucode_info_t *, 95adc586deSMark Johnson ucode_header_intel_t *, ucode_ext_table_intel_t *); 96adc586deSMark Johnson 97adc586deSMark Johnson static void ucode_read_rev_amd(cpu_ucode_info_t *); 98adc586deSMark Johnson static void ucode_read_rev_intel(cpu_ucode_info_t *); 99adc586deSMark Johnson 100adc586deSMark Johnson static const struct ucode_ops ucode_amd = { 101adc586deSMark Johnson MSR_AMD_PATCHLOADER, 102adc586deSMark Johnson ucode_capable_amd, 103adc586deSMark Johnson ucode_file_reset_amd, 104adc586deSMark Johnson ucode_read_rev_amd, 105adc586deSMark Johnson ucode_load_amd, 106adc586deSMark Johnson ucode_validate_amd, 107adc586deSMark Johnson ucode_extract_amd, 108adc586deSMark Johnson ucode_locate_amd 109adc586deSMark Johnson }; 110adc586deSMark Johnson 111adc586deSMark Johnson static const struct ucode_ops ucode_intel = { 112adc586deSMark Johnson MSR_INTC_UCODE_WRITE, 113adc586deSMark Johnson ucode_capable_intel, 114adc586deSMark Johnson ucode_file_reset_intel, 115adc586deSMark Johnson ucode_read_rev_intel, 116adc586deSMark Johnson ucode_load_intel, 117adc586deSMark Johnson ucode_validate_intel, 118adc586deSMark Johnson ucode_extract_intel, 119adc586deSMark Johnson ucode_locate_intel 120adc586deSMark Johnson }; 121adc586deSMark Johnson 122adc586deSMark Johnson const struct ucode_ops *ucode; 123adc586deSMark Johnson 1242449e17fSsherrym static const char ucode_failure_fmt[] = 12588699bddSsherrym "cpu%d: failed to update microcode from version 0x%x to 0x%x\n"; 1262449e17fSsherrym static const char ucode_success_fmt[] = 12788699bddSsherrym "?cpu%d: microcode has been updated from version 0x%x to 0x%x\n"; 1282449e17fSsherrym 1292449e17fSsherrym /* 1302449e17fSsherrym * Force flag. If set, the first microcode binary that matches 1312449e17fSsherrym * signature and platform id will be used for microcode update, 1322449e17fSsherrym * regardless of version. Should only be used for debugging. 1332449e17fSsherrym */ 1342449e17fSsherrym int ucode_force_update = 0; 1352449e17fSsherrym 1362449e17fSsherrym /* 1372449e17fSsherrym * Allocate space for mcpu_ucode_info in the machcpu structure 1382449e17fSsherrym * for all non-boot CPUs. 1392449e17fSsherrym */ 1402449e17fSsherrym void 1412449e17fSsherrym ucode_alloc_space(cpu_t *cp) 1422449e17fSsherrym { 1432449e17fSsherrym ASSERT(cp->cpu_id != 0); 1442449e17fSsherrym cp->cpu_m.mcpu_ucode_info = 1452449e17fSsherrym kmem_zalloc(sizeof (*cp->cpu_m.mcpu_ucode_info), KM_SLEEP); 1462449e17fSsherrym } 1472449e17fSsherrym 1482449e17fSsherrym void 1492449e17fSsherrym ucode_free_space(cpu_t *cp) 1502449e17fSsherrym { 1512449e17fSsherrym ASSERT(cp->cpu_id != 0); 1522449e17fSsherrym kmem_free(cp->cpu_m.mcpu_ucode_info, 1532449e17fSsherrym sizeof (*cp->cpu_m.mcpu_ucode_info)); 1542449e17fSsherrym } 1552449e17fSsherrym 1562449e17fSsherrym /* 1572449e17fSsherrym * Called when we are done with microcode update on all processors to free up 1582449e17fSsherrym * space allocated for the microcode file. 1592449e17fSsherrym */ 1602449e17fSsherrym void 161adc586deSMark Johnson ucode_cleanup() 1622449e17fSsherrym { 163*126b0a71SMark Johnson if (ucode == NULL) 164*126b0a71SMark Johnson return; 165adc586deSMark Johnson 166adc586deSMark Johnson ucode->file_reset(&ucodefile, -1); 167adc586deSMark Johnson } 168adc586deSMark Johnson 169adc586deSMark Johnson /* 170adc586deSMark Johnson * Allocate/free a buffer used to hold ucode data. Space for the boot CPU is 171adc586deSMark Johnson * allocated with BOP_ALLOC() and does not require a free. 172adc586deSMark Johnson */ 173adc586deSMark Johnson static void* 174adc586deSMark Johnson ucode_zalloc(processorid_t id, size_t size) 175adc586deSMark Johnson { 176adc586deSMark Johnson if (id) 177adc586deSMark Johnson return (kmem_zalloc(size, KM_NOSLEEP)); 178adc586deSMark Johnson 179adc586deSMark Johnson /* BOP_ALLOC() failure results in panic */ 180adc586deSMark Johnson return (BOP_ALLOC(bootops, NULL, size, MMU_PAGESIZE)); 181adc586deSMark Johnson } 182adc586deSMark Johnson 183adc586deSMark Johnson static void 184adc586deSMark Johnson ucode_free(processorid_t id, void* buf, size_t size) 185adc586deSMark Johnson { 186adc586deSMark Johnson if (id) 187adc586deSMark Johnson kmem_free(buf, size); 1882449e17fSsherrym } 1892449e17fSsherrym 1902449e17fSsherrym /* 1912449e17fSsherrym * Check whether or not a processor is capable of microcode operations 1922449e17fSsherrym * Returns 1 if it is capable, 0 if not. 193adc586deSMark Johnson * 194adc586deSMark Johnson * At this point we only support microcode update for: 195adc586deSMark Johnson * - Intel processors family 6 and above, and 196adc586deSMark Johnson * - AMD processors family 0x10 and above. 197adc586deSMark Johnson * 198adc586deSMark Johnson * We also assume that we don't support a mix of Intel and 199adc586deSMark Johnson * AMD processors in the same box. 200adc586deSMark Johnson * 201adc586deSMark Johnson * An i86xpv guest domain can't update the microcode. 2022449e17fSsherrym */ 203adc586deSMark Johnson /*ARGSUSED*/ 2042449e17fSsherrym static int 205adc586deSMark Johnson ucode_capable_amd(cpu_t *cp) 2062449e17fSsherrym { 207b9bfdccdSStuart Maybee int hwenv = get_hwenv(); 208b9bfdccdSStuart Maybee 209b9bfdccdSStuart Maybee if (hwenv == HW_XEN_HVM || (hwenv == HW_XEN_PV && !is_controldom())) { 210adc586deSMark Johnson return (0); 211adc586deSMark Johnson } 2120ba6f73dSMark Johnson return (cpuid_getfamily(cp) >= 0x10); 213adc586deSMark Johnson } 2140ba6f73dSMark Johnson 215adc586deSMark Johnson static int 216adc586deSMark Johnson ucode_capable_intel(cpu_t *cp) 217adc586deSMark Johnson { 218b9bfdccdSStuart Maybee int hwenv = get_hwenv(); 219b9bfdccdSStuart Maybee 220b9bfdccdSStuart Maybee if (hwenv == HW_XEN_HVM || (hwenv == HW_XEN_PV && !is_controldom())) { 221882a7af5SMark Johnson return (0); 222882a7af5SMark Johnson } 223adc586deSMark Johnson return (cpuid_getfamily(cp) >= 6); 2242449e17fSsherrym } 2252449e17fSsherrym 2262449e17fSsherrym /* 2272449e17fSsherrym * Called when it is no longer necessary to keep the microcode around, 2282449e17fSsherrym * or when the cached microcode doesn't match the CPU being processed. 2292449e17fSsherrym */ 2302449e17fSsherrym static void 231adc586deSMark Johnson ucode_file_reset_amd(ucode_file_t *ufp, processorid_t id) 2322449e17fSsherrym { 233adc586deSMark Johnson ucode_file_amd_t *ucodefp = ufp->amd; 2342449e17fSsherrym 2352449e17fSsherrym if (ucodefp == NULL) 2362449e17fSsherrym return; 2372449e17fSsherrym 238adc586deSMark Johnson ucode_free(id, ucodefp, sizeof (ucode_file_amd_t)); 239adc586deSMark Johnson ufp->amd = NULL; 240adc586deSMark Johnson } 241adc586deSMark Johnson 242adc586deSMark Johnson static void 243adc586deSMark Johnson ucode_file_reset_intel(ucode_file_t *ufp, processorid_t id) 244adc586deSMark Johnson { 245adc586deSMark Johnson ucode_file_intel_t *ucodefp = &ufp->intel; 246adc586deSMark Johnson int total_size, body_size; 247adc586deSMark Johnson 248adc586deSMark Johnson if (ucodefp == NULL || ucodefp->uf_header == NULL) 249adc586deSMark Johnson return; 250adc586deSMark Johnson 251adc586deSMark Johnson total_size = UCODE_TOTAL_SIZE_INTEL(ucodefp->uf_header->uh_total_size); 252adc586deSMark Johnson body_size = UCODE_BODY_SIZE_INTEL(ucodefp->uf_header->uh_body_size); 2532449e17fSsherrym if (ucodefp->uf_body) { 254adc586deSMark Johnson ucode_free(id, ucodefp->uf_body, body_size); 2552449e17fSsherrym ucodefp->uf_body = NULL; 2562449e17fSsherrym } 2572449e17fSsherrym 2582449e17fSsherrym if (ucodefp->uf_ext_table) { 259adc586deSMark Johnson int size = total_size - body_size - UCODE_HEADER_SIZE_INTEL; 260adc586deSMark Johnson 261adc586deSMark Johnson ucode_free(id, ucodefp->uf_ext_table, size); 2622449e17fSsherrym ucodefp->uf_ext_table = NULL; 2632449e17fSsherrym } 2642449e17fSsherrym 265adc586deSMark Johnson ucode_free(id, ucodefp->uf_header, UCODE_HEADER_SIZE_INTEL); 266adc586deSMark Johnson ucodefp->uf_header = NULL; 267adc586deSMark Johnson } 268adc586deSMark Johnson 269adc586deSMark Johnson /* 270adc586deSMark Johnson * Find the equivalent CPU id in the equivalence table. 271adc586deSMark Johnson */ 272adc586deSMark Johnson static int 2730ba6f73dSMark Johnson ucode_equiv_cpu_amd(cpu_t *cp, uint16_t *eq_sig) 274adc586deSMark Johnson { 275adc586deSMark Johnson char name[MAXPATHLEN]; 276adc586deSMark Johnson intptr_t fd; 277adc586deSMark Johnson int count; 278adc586deSMark Johnson int offset = 0, cpi_sig = cpuid_getsig(cp); 279adc586deSMark Johnson ucode_eqtbl_amd_t *eqtbl = ucode_eqtbl_amd; 280adc586deSMark Johnson 281adc586deSMark Johnson (void) snprintf(name, MAXPATHLEN, "/%s/%s/equivalence-table", 282adc586deSMark Johnson UCODE_INSTALL_PATH, cpuid_getvendorstr(cp)); 283adc586deSMark Johnson 284adc586deSMark Johnson /* 285adc586deSMark Johnson * No kmem_zalloc() etc. available on boot cpu. 286adc586deSMark Johnson */ 287adc586deSMark Johnson if (cp->cpu_id == 0) { 288adc586deSMark Johnson if ((fd = kobj_open(name)) == -1) 289adc586deSMark Johnson return (EM_OPENFILE); 290adc586deSMark Johnson /* ucode_zalloc() cannot fail on boot cpu */ 291adc586deSMark Johnson eqtbl = ucode_zalloc(cp->cpu_id, sizeof (*eqtbl)); 292adc586deSMark Johnson ASSERT(eqtbl); 293adc586deSMark Johnson do { 294adc586deSMark Johnson count = kobj_read(fd, (int8_t *)eqtbl, 295adc586deSMark Johnson sizeof (*eqtbl), offset); 296adc586deSMark Johnson if (count != sizeof (*eqtbl)) { 297adc586deSMark Johnson (void) kobj_close(fd); 298adc586deSMark Johnson return (EM_HIGHERREV); 299adc586deSMark Johnson } 300adc586deSMark Johnson offset += count; 301adc586deSMark Johnson } while (eqtbl->ue_inst_cpu && eqtbl->ue_inst_cpu != cpi_sig); 302adc586deSMark Johnson (void) kobj_close(fd); 303adc586deSMark Johnson } 304adc586deSMark Johnson 305adc586deSMark Johnson /* 306adc586deSMark Johnson * If not already done, load the equivalence table. 307adc586deSMark Johnson * Not done on boot CPU. 308adc586deSMark Johnson */ 309adc586deSMark Johnson if (eqtbl == NULL) { 310adc586deSMark Johnson struct _buf *eq; 311adc586deSMark Johnson uint64_t size; 312adc586deSMark Johnson 313adc586deSMark Johnson if ((eq = kobj_open_file(name)) == (struct _buf *)-1) 314adc586deSMark Johnson return (EM_OPENFILE); 315adc586deSMark Johnson 316adc586deSMark Johnson if (kobj_get_filesize(eq, &size) < 0) { 317adc586deSMark Johnson kobj_close_file(eq); 318adc586deSMark Johnson return (EM_OPENFILE); 319adc586deSMark Johnson } 320adc586deSMark Johnson 321adc586deSMark Johnson ucode_eqtbl_amd = kmem_zalloc(size, KM_NOSLEEP); 322adc586deSMark Johnson if (ucode_eqtbl_amd == NULL) { 323adc586deSMark Johnson kobj_close_file(eq); 324adc586deSMark Johnson return (EM_NOMEM); 325adc586deSMark Johnson } 326adc586deSMark Johnson 327adc586deSMark Johnson count = kobj_read_file(eq, (char *)ucode_eqtbl_amd, size, 0); 328adc586deSMark Johnson kobj_close_file(eq); 329adc586deSMark Johnson 330adc586deSMark Johnson if (count != size) 331adc586deSMark Johnson return (EM_FILESIZE); 332adc586deSMark Johnson } 333adc586deSMark Johnson 334adc586deSMark Johnson /* Get the equivalent CPU id. */ 335adc586deSMark Johnson if (cp->cpu_id) 336adc586deSMark Johnson for (eqtbl = ucode_eqtbl_amd; 337adc586deSMark Johnson eqtbl->ue_inst_cpu && eqtbl->ue_inst_cpu != cpi_sig; 338adc586deSMark Johnson eqtbl++) 339adc586deSMark Johnson ; 340adc586deSMark Johnson 341adc586deSMark Johnson *eq_sig = eqtbl->ue_equiv_cpu; 342adc586deSMark Johnson 343adc586deSMark Johnson /* No equivalent CPU id found, assume outdated microcode file. */ 344adc586deSMark Johnson if (*eq_sig == 0) 345adc586deSMark Johnson return (EM_HIGHERREV); 346adc586deSMark Johnson 347adc586deSMark Johnson return (EM_OK); 3482449e17fSsherrym } 3492449e17fSsherrym 3502449e17fSsherrym /* 3510ba6f73dSMark Johnson * xVM cannot check for the presence of PCI devices. Look for chipset- 3520ba6f73dSMark Johnson * specific microcode patches in the container file and disable them 3530ba6f73dSMark Johnson * by setting their CPU revision to an invalid value. 3540ba6f73dSMark Johnson */ 3550ba6f73dSMark Johnson #ifdef __xpv 3560ba6f73dSMark Johnson static void 3570ba6f73dSMark Johnson ucode_chipset_amd(uint8_t *buf, int size) 3580ba6f73dSMark Johnson { 3590ba6f73dSMark Johnson ucode_header_amd_t *uh; 3600ba6f73dSMark Johnson uint32_t *ptr = (uint32_t *)buf; 3610ba6f73dSMark Johnson int len = 0; 3620ba6f73dSMark Johnson 3630ba6f73dSMark Johnson /* skip to first microcode patch */ 3640ba6f73dSMark Johnson ptr += 2; len = *ptr++; ptr += len >> 2; size -= len; 3650ba6f73dSMark Johnson 3660ba6f73dSMark Johnson while (size >= sizeof (ucode_header_amd_t) + 8) { 3670ba6f73dSMark Johnson ptr++; len = *ptr++; 3680ba6f73dSMark Johnson uh = (ucode_header_amd_t *)ptr; 3690ba6f73dSMark Johnson ptr += len >> 2; size -= len; 3700ba6f73dSMark Johnson 3710ba6f73dSMark Johnson if (uh->uh_nb_id) { 3720ba6f73dSMark Johnson cmn_err(CE_WARN, "ignoring northbridge-specific ucode: " 3730ba6f73dSMark Johnson "chipset id %x, revision %x", 3740ba6f73dSMark Johnson uh->uh_nb_id, uh->uh_nb_rev); 3750ba6f73dSMark Johnson uh->uh_cpu_rev = 0xffff; 3760ba6f73dSMark Johnson } 3770ba6f73dSMark Johnson 3780ba6f73dSMark Johnson if (uh->uh_sb_id) { 3790ba6f73dSMark Johnson cmn_err(CE_WARN, "ignoring southbridge-specific ucode: " 3800ba6f73dSMark Johnson "chipset id %x, revision %x", 3810ba6f73dSMark Johnson uh->uh_sb_id, uh->uh_sb_rev); 3820ba6f73dSMark Johnson uh->uh_cpu_rev = 0xffff; 3830ba6f73dSMark Johnson } 3840ba6f73dSMark Johnson } 3850ba6f73dSMark Johnson } 3860ba6f73dSMark Johnson #endif 3870ba6f73dSMark Johnson 3880ba6f73dSMark Johnson /* 3892449e17fSsherrym * Populate the ucode file structure from microcode file corresponding to 3902449e17fSsherrym * this CPU, if exists. 3912449e17fSsherrym * 3922449e17fSsherrym * Return EM_OK on success, corresponding error code on failure. 3932449e17fSsherrym */ 3940ba6f73dSMark Johnson /*ARGSUSED*/ 3952449e17fSsherrym static ucode_errno_t 396adc586deSMark Johnson ucode_locate_amd(cpu_t *cp, cpu_ucode_info_t *uinfop, ucode_file_t *ufp) 397adc586deSMark Johnson { 398adc586deSMark Johnson char name[MAXPATHLEN]; 399adc586deSMark Johnson intptr_t fd; 4000ba6f73dSMark Johnson int count, rc; 401adc586deSMark Johnson ucode_file_amd_t *ucodefp = ufp->amd; 402adc586deSMark Johnson 4030ba6f73dSMark Johnson #ifndef __xpv 4040ba6f73dSMark Johnson uint16_t eq_sig = 0; 4050ba6f73dSMark Johnson int i; 4060ba6f73dSMark Johnson 407adc586deSMark Johnson /* get equivalent CPU id */ 408adc586deSMark Johnson if ((rc = ucode_equiv_cpu_amd(cp, &eq_sig)) != EM_OK) 409adc586deSMark Johnson return (rc); 410adc586deSMark Johnson 411adc586deSMark Johnson /* 412adc586deSMark Johnson * Allocate a buffer for the microcode patch. If the buffer has been 413adc586deSMark Johnson * allocated before, check for a matching microcode to avoid loading 414adc586deSMark Johnson * the file again. 415adc586deSMark Johnson */ 416adc586deSMark Johnson if (ucodefp == NULL) 417adc586deSMark Johnson ucodefp = ucode_zalloc(cp->cpu_id, sizeof (*ucodefp)); 418adc586deSMark Johnson else if (ucode_match_amd(eq_sig, uinfop, ucodefp, sizeof (*ucodefp)) 419adc586deSMark Johnson == EM_OK) 420adc586deSMark Johnson return (EM_OK); 421adc586deSMark Johnson 422adc586deSMark Johnson if (ucodefp == NULL) 423adc586deSMark Johnson return (EM_NOMEM); 424adc586deSMark Johnson 425adc586deSMark Johnson ufp->amd = ucodefp; 426adc586deSMark Johnson 427adc586deSMark Johnson /* 428adc586deSMark Johnson * Find the patch for this CPU. The patch files are named XXXX-YY, where 429adc586deSMark Johnson * XXXX is the equivalent CPU id and YY is the running patch number. 430adc586deSMark Johnson * Patches specific to certain chipsets are guaranteed to have lower 431adc586deSMark Johnson * numbers than less specific patches, so we can just load the first 432adc586deSMark Johnson * patch that matches. 433adc586deSMark Johnson */ 434adc586deSMark Johnson 435adc586deSMark Johnson for (i = 0; i < 0xff; i++) { 436adc586deSMark Johnson (void) snprintf(name, MAXPATHLEN, "/%s/%s/%04X-%02X", 437adc586deSMark Johnson UCODE_INSTALL_PATH, cpuid_getvendorstr(cp), eq_sig, i); 438adc586deSMark Johnson if ((fd = kobj_open(name)) == -1) 439adc586deSMark Johnson return (EM_NOMATCH); 440adc586deSMark Johnson count = kobj_read(fd, (char *)ucodefp, sizeof (*ucodefp), 0); 441adc586deSMark Johnson (void) kobj_close(fd); 442adc586deSMark Johnson 443adc586deSMark Johnson if (ucode_match_amd(eq_sig, uinfop, ucodefp, count) == EM_OK) 444adc586deSMark Johnson return (EM_OK); 445adc586deSMark Johnson } 446adc586deSMark Johnson return (EM_NOMATCH); 4470ba6f73dSMark Johnson #else 4480ba6f73dSMark Johnson int size = 0; 4490ba6f73dSMark Johnson char c; 4500ba6f73dSMark Johnson 4510ba6f73dSMark Johnson /* 4520ba6f73dSMark Johnson * The xVM case is special. To support mixed-revision systems, the 4530ba6f73dSMark Johnson * hypervisor will choose which patch to load for which CPU, so the 4540ba6f73dSMark Johnson * whole microcode patch container file will have to be loaded. 4550ba6f73dSMark Johnson * 4560ba6f73dSMark Johnson * Since this code is only run on the boot cpu, we don't have to care 4570ba6f73dSMark Johnson * about failing ucode_zalloc() or freeing allocated memory. 4580ba6f73dSMark Johnson */ 4590ba6f73dSMark Johnson if (cp->cpu_id != 0) 4600ba6f73dSMark Johnson return (EM_INVALIDARG); 4610ba6f73dSMark Johnson 4620ba6f73dSMark Johnson (void) snprintf(name, MAXPATHLEN, "/%s/%s/container", 4630ba6f73dSMark Johnson UCODE_INSTALL_PATH, cpuid_getvendorstr(cp)); 4640ba6f73dSMark Johnson 4650ba6f73dSMark Johnson if ((fd = kobj_open(name)) == -1) 4660ba6f73dSMark Johnson return (EM_OPENFILE); 4670ba6f73dSMark Johnson 4680ba6f73dSMark Johnson /* get the file size by counting bytes */ 4690ba6f73dSMark Johnson do { 4700ba6f73dSMark Johnson count = kobj_read(fd, &c, 1, size); 4710ba6f73dSMark Johnson size += count; 4720ba6f73dSMark Johnson } while (count); 4730ba6f73dSMark Johnson 4740ba6f73dSMark Johnson ucodefp = ucode_zalloc(cp->cpu_id, sizeof (*ucodefp)); 4750ba6f73dSMark Johnson ASSERT(ucodefp); 4760ba6f73dSMark Johnson ufp->amd = ucodefp; 4770ba6f73dSMark Johnson 4780ba6f73dSMark Johnson ucodefp->usize = size; 4790ba6f73dSMark Johnson ucodefp->ucodep = ucode_zalloc(cp->cpu_id, size); 4800ba6f73dSMark Johnson ASSERT(ucodefp->ucodep); 4810ba6f73dSMark Johnson 4820ba6f73dSMark Johnson /* load the microcode patch container file */ 4830ba6f73dSMark Johnson count = kobj_read(fd, (char *)ucodefp->ucodep, size, 0); 4840ba6f73dSMark Johnson (void) kobj_close(fd); 4850ba6f73dSMark Johnson 4860ba6f73dSMark Johnson if (count != size) 4870ba6f73dSMark Johnson return (EM_FILESIZE); 4880ba6f73dSMark Johnson 4890ba6f73dSMark Johnson /* make sure the container file is valid */ 4900ba6f73dSMark Johnson rc = ucode->validate(ucodefp->ucodep, ucodefp->usize); 4910ba6f73dSMark Johnson 4920ba6f73dSMark Johnson if (rc != EM_OK) 4930ba6f73dSMark Johnson return (rc); 4940ba6f73dSMark Johnson 4950ba6f73dSMark Johnson /* disable chipset-specific patches */ 4960ba6f73dSMark Johnson ucode_chipset_amd(ucodefp->ucodep, ucodefp->usize); 4970ba6f73dSMark Johnson 4980ba6f73dSMark Johnson return (EM_OK); 4990ba6f73dSMark Johnson #endif 500adc586deSMark Johnson } 501adc586deSMark Johnson 502adc586deSMark Johnson static ucode_errno_t 503adc586deSMark Johnson ucode_locate_intel(cpu_t *cp, cpu_ucode_info_t *uinfop, ucode_file_t *ufp) 5042449e17fSsherrym { 5052449e17fSsherrym char name[MAXPATHLEN]; 5062449e17fSsherrym intptr_t fd; 5072449e17fSsherrym int count; 508adc586deSMark Johnson int header_size = UCODE_HEADER_SIZE_INTEL; 5092449e17fSsherrym int cpi_sig = cpuid_getsig(cp); 5102449e17fSsherrym ucode_errno_t rc = EM_OK; 511adc586deSMark Johnson ucode_file_intel_t *ucodefp = &ufp->intel; 512adc586deSMark Johnson 513adc586deSMark Johnson ASSERT(ucode); 5142449e17fSsherrym 5152449e17fSsherrym /* 5162449e17fSsherrym * If the microcode matches the CPU we are processing, use it. 5172449e17fSsherrym */ 518adc586deSMark Johnson if (ucode_match_intel(cpi_sig, uinfop, ucodefp->uf_header, 5192449e17fSsherrym ucodefp->uf_ext_table) == EM_OK && ucodefp->uf_body != NULL) { 5202449e17fSsherrym return (EM_OK); 5212449e17fSsherrym } 5222449e17fSsherrym 5232449e17fSsherrym /* 5242449e17fSsherrym * Look for microcode file with the right name. 5252449e17fSsherrym */ 5262449e17fSsherrym (void) snprintf(name, MAXPATHLEN, "/%s/%s/%08X-%02X", 5272449e17fSsherrym UCODE_INSTALL_PATH, cpuid_getvendorstr(cp), cpi_sig, 5282449e17fSsherrym uinfop->cui_platid); 5292449e17fSsherrym if ((fd = kobj_open(name)) == -1) { 5302449e17fSsherrym return (EM_OPENFILE); 5312449e17fSsherrym } 5322449e17fSsherrym 5332449e17fSsherrym /* 5342449e17fSsherrym * We found a microcode file for the CPU we are processing, 5352449e17fSsherrym * reset the microcode data structure and read in the new 5362449e17fSsherrym * file. 5372449e17fSsherrym */ 538adc586deSMark Johnson ucode->file_reset(ufp, cp->cpu_id); 5392449e17fSsherrym 540adc586deSMark Johnson ucodefp->uf_header = ucode_zalloc(cp->cpu_id, header_size); 541adc586deSMark Johnson if (ucodefp->uf_header == NULL) 542adc586deSMark Johnson return (EM_NOMEM); 543adc586deSMark Johnson 544adc586deSMark Johnson count = kobj_read(fd, (char *)ucodefp->uf_header, header_size, 0); 5452449e17fSsherrym 5462449e17fSsherrym switch (count) { 547adc586deSMark Johnson case UCODE_HEADER_SIZE_INTEL: { 5482449e17fSsherrym 549adc586deSMark Johnson ucode_header_intel_t *uhp = ucodefp->uf_header; 5502449e17fSsherrym uint32_t offset = header_size; 5512449e17fSsherrym int total_size, body_size, ext_size; 5522449e17fSsherrym uint32_t sum = 0; 5532449e17fSsherrym 5542449e17fSsherrym /* 5552449e17fSsherrym * Make sure that the header contains valid fields. 5562449e17fSsherrym */ 557adc586deSMark Johnson if ((rc = ucode_header_validate_intel(uhp)) == EM_OK) { 558adc586deSMark Johnson total_size = UCODE_TOTAL_SIZE_INTEL(uhp->uh_total_size); 559adc586deSMark Johnson body_size = UCODE_BODY_SIZE_INTEL(uhp->uh_body_size); 560adc586deSMark Johnson ucodefp->uf_body = ucode_zalloc(cp->cpu_id, body_size); 561adc586deSMark Johnson if (ucodefp->uf_body == NULL) { 5622449e17fSsherrym rc = EM_NOMEM; 5632449e17fSsherrym break; 5642449e17fSsherrym } 5652449e17fSsherrym 5662449e17fSsherrym if (kobj_read(fd, (char *)ucodefp->uf_body, 5672449e17fSsherrym body_size, offset) != body_size) 5682449e17fSsherrym rc = EM_FILESIZE; 5692449e17fSsherrym } 5702449e17fSsherrym 5712449e17fSsherrym if (rc) 5722449e17fSsherrym break; 5732449e17fSsherrym 574adc586deSMark Johnson sum = ucode_checksum_intel(0, header_size, 575adc586deSMark Johnson (uint8_t *)ucodefp->uf_header); 576adc586deSMark Johnson if (ucode_checksum_intel(sum, body_size, ucodefp->uf_body)) { 5772449e17fSsherrym rc = EM_CHECKSUM; 5782449e17fSsherrym break; 5792449e17fSsherrym } 5802449e17fSsherrym 5812449e17fSsherrym /* 5822449e17fSsherrym * Check to see if there is extended signature table. 5832449e17fSsherrym */ 5842449e17fSsherrym offset = body_size + header_size; 5852449e17fSsherrym ext_size = total_size - offset; 5862449e17fSsherrym 5872449e17fSsherrym if (ext_size <= 0) 5882449e17fSsherrym break; 5892449e17fSsherrym 590adc586deSMark Johnson ucodefp->uf_ext_table = ucode_zalloc(cp->cpu_id, ext_size); 591adc586deSMark Johnson if (ucodefp->uf_ext_table == NULL) { 5922449e17fSsherrym rc = EM_NOMEM; 5932449e17fSsherrym break; 5942449e17fSsherrym } 5952449e17fSsherrym 5962449e17fSsherrym if (kobj_read(fd, (char *)ucodefp->uf_ext_table, 5972449e17fSsherrym ext_size, offset) != ext_size) { 5982449e17fSsherrym rc = EM_FILESIZE; 599adc586deSMark Johnson } else if (ucode_checksum_intel(0, ext_size, 6002449e17fSsherrym (uint8_t *)(ucodefp->uf_ext_table))) { 6012449e17fSsherrym rc = EM_CHECKSUM; 6022449e17fSsherrym } else { 6032449e17fSsherrym int i; 6042449e17fSsherrym 605adc586deSMark Johnson ext_size -= UCODE_EXT_TABLE_SIZE_INTEL; 6062449e17fSsherrym for (i = 0; i < ucodefp->uf_ext_table->uet_count; 6072449e17fSsherrym i++) { 608adc586deSMark Johnson if (ucode_checksum_intel(0, 609adc586deSMark Johnson UCODE_EXT_SIG_SIZE_INTEL, 6102449e17fSsherrym (uint8_t *)(&(ucodefp->uf_ext_table-> 6112449e17fSsherrym uet_ext_sig[i])))) { 6122449e17fSsherrym rc = EM_CHECKSUM; 6132449e17fSsherrym break; 6142449e17fSsherrym } 6152449e17fSsherrym } 6162449e17fSsherrym } 6172449e17fSsherrym break; 6182449e17fSsherrym } 6192449e17fSsherrym 6202449e17fSsherrym default: 6212449e17fSsherrym rc = EM_FILESIZE; 6222449e17fSsherrym break; 6232449e17fSsherrym } 6242449e17fSsherrym 6252449e17fSsherrym kobj_close(fd); 6262449e17fSsherrym 6272449e17fSsherrym if (rc != EM_OK) 6282449e17fSsherrym return (rc); 6292449e17fSsherrym 630adc586deSMark Johnson rc = ucode_match_intel(cpi_sig, uinfop, ucodefp->uf_header, 6312449e17fSsherrym ucodefp->uf_ext_table); 6322449e17fSsherrym 6332449e17fSsherrym return (rc); 6342449e17fSsherrym } 6352449e17fSsherrym 6360ba6f73dSMark Johnson #ifndef __xpv 637adc586deSMark Johnson static ucode_errno_t 6380ba6f73dSMark Johnson ucode_match_amd(uint16_t eq_sig, cpu_ucode_info_t *uinfop, 6390ba6f73dSMark Johnson ucode_file_amd_t *ucodefp, int size) 640adc586deSMark Johnson { 641adc586deSMark Johnson ucode_header_amd_t *uh; 642adc586deSMark Johnson 643adc586deSMark Johnson if (ucodefp == NULL || size < sizeof (ucode_header_amd_t)) 644adc586deSMark Johnson return (EM_NOMATCH); 645adc586deSMark Johnson 646adc586deSMark Johnson /* 647adc586deSMark Johnson * Don't even think about loading patches that would require code 648adc586deSMark Johnson * execution. 649adc586deSMark Johnson */ 650adc586deSMark Johnson if (size > offsetof(ucode_file_amd_t, uf_code_present) && 651adc586deSMark Johnson ucodefp->uf_code_present) 652adc586deSMark Johnson return (EM_NOMATCH); 653adc586deSMark Johnson 654adc586deSMark Johnson uh = &ucodefp->uf_header; 655adc586deSMark Johnson 656adc586deSMark Johnson if (eq_sig != uh->uh_cpu_rev) 657adc586deSMark Johnson return (EM_NOMATCH); 658adc586deSMark Johnson 659adc586deSMark Johnson if (uh->uh_nb_id) { 660adc586deSMark Johnson cmn_err(CE_WARN, "ignoring northbridge-specific ucode: " 661adc586deSMark Johnson "chipset id %x, revision %x", uh->uh_nb_id, uh->uh_nb_rev); 662adc586deSMark Johnson return (EM_NOMATCH); 663adc586deSMark Johnson } 664adc586deSMark Johnson 665adc586deSMark Johnson if (uh->uh_sb_id) { 666adc586deSMark Johnson cmn_err(CE_WARN, "ignoring southbridge-specific ucode: " 667adc586deSMark Johnson "chipset id %x, revision %x", uh->uh_sb_id, uh->uh_sb_rev); 668adc586deSMark Johnson return (EM_NOMATCH); 669adc586deSMark Johnson } 670adc586deSMark Johnson 671adc586deSMark Johnson if (uh->uh_patch_id <= uinfop->cui_rev) 672adc586deSMark Johnson return (EM_HIGHERREV); 673adc586deSMark Johnson 674adc586deSMark Johnson return (EM_OK); 675adc586deSMark Johnson } 6760ba6f73dSMark Johnson #endif 6772449e17fSsherrym 6782449e17fSsherrym /* 6792449e17fSsherrym * Returns 1 if the microcode is for this processor; 0 otherwise. 6802449e17fSsherrym */ 6812449e17fSsherrym static ucode_errno_t 682adc586deSMark Johnson ucode_match_intel(int cpi_sig, cpu_ucode_info_t *uinfop, 683adc586deSMark Johnson ucode_header_intel_t *uhp, ucode_ext_table_intel_t *uetp) 6842449e17fSsherrym { 685adc586deSMark Johnson if (uhp == NULL) 686adc586deSMark Johnson return (EM_NOMATCH); 6872449e17fSsherrym 688adc586deSMark Johnson if (UCODE_MATCH_INTEL(cpi_sig, uhp->uh_signature, 6892449e17fSsherrym uinfop->cui_platid, uhp->uh_proc_flags)) { 6902449e17fSsherrym 6912449e17fSsherrym if (uinfop->cui_rev >= uhp->uh_rev && !ucode_force_update) 6922449e17fSsherrym return (EM_HIGHERREV); 6932449e17fSsherrym 6942449e17fSsherrym return (EM_OK); 6952449e17fSsherrym } 6962449e17fSsherrym 6972449e17fSsherrym if (uetp != NULL) { 6982449e17fSsherrym int i; 6992449e17fSsherrym 7002449e17fSsherrym for (i = 0; i < uetp->uet_count; i++) { 701adc586deSMark Johnson ucode_ext_sig_intel_t *uesp; 7022449e17fSsherrym 7032449e17fSsherrym uesp = &uetp->uet_ext_sig[i]; 7042449e17fSsherrym 705adc586deSMark Johnson if (UCODE_MATCH_INTEL(cpi_sig, uesp->ues_signature, 7062449e17fSsherrym uinfop->cui_platid, uesp->ues_proc_flags)) { 7072449e17fSsherrym 7082449e17fSsherrym if (uinfop->cui_rev >= uhp->uh_rev && 7092449e17fSsherrym !ucode_force_update) 7102449e17fSsherrym return (EM_HIGHERREV); 7112449e17fSsherrym 7122449e17fSsherrym return (EM_OK); 7132449e17fSsherrym } 7142449e17fSsherrym } 7152449e17fSsherrym } 7162449e17fSsherrym 7172449e17fSsherrym return (EM_NOMATCH); 7182449e17fSsherrym } 7192449e17fSsherrym 7202449e17fSsherrym /*ARGSUSED*/ 7212449e17fSsherrym static int 7222449e17fSsherrym ucode_write(xc_arg_t arg1, xc_arg_t unused2, xc_arg_t unused3) 7232449e17fSsherrym { 724adc586deSMark Johnson ucode_update_t *uusp = (ucode_update_t *)arg1; 725adc586deSMark Johnson cpu_ucode_info_t *uinfop = CPU->cpu_m.mcpu_ucode_info; 7262449e17fSsherrym 727adc586deSMark Johnson ASSERT(ucode); 7282449e17fSsherrym ASSERT(uusp->ucodep); 7292449e17fSsherrym 730882a7af5SMark Johnson #ifndef __xpv 7312449e17fSsherrym /* 7322449e17fSsherrym * Check one more time to see if it is really necessary to update 7332449e17fSsherrym * microcode just in case this is a hyperthreaded processor where 7342449e17fSsherrym * the threads share the same microcode. 7352449e17fSsherrym */ 7362449e17fSsherrym if (!ucode_force_update) { 737adc586deSMark Johnson ucode->read_rev(uinfop); 7382449e17fSsherrym uusp->new_rev = uinfop->cui_rev; 7392449e17fSsherrym if (uinfop->cui_rev >= uusp->expected_rev) 7402449e17fSsherrym return (0); 7412449e17fSsherrym } 7422449e17fSsherrym 743adc586deSMark Johnson wrmsr(ucode->write_msr, (uintptr_t)uusp->ucodep); 744882a7af5SMark Johnson #endif 745adc586deSMark Johnson ucode->read_rev(uinfop); 7462449e17fSsherrym uusp->new_rev = uinfop->cui_rev; 7472449e17fSsherrym 7482449e17fSsherrym return (0); 7492449e17fSsherrym } 7502449e17fSsherrym 751adc586deSMark Johnson /*ARGSUSED*/ 752adc586deSMark Johnson static uint32_t 753adc586deSMark Johnson ucode_load_amd(ucode_file_t *ufp, cpu_ucode_info_t *uinfop, cpu_t *cp) 7542449e17fSsherrym { 755adc586deSMark Johnson ucode_file_amd_t *ucodefp = ufp->amd; 756adc586deSMark Johnson #ifdef __xpv 757adc586deSMark Johnson ucode_update_t uus; 758adc586deSMark Johnson #endif 759adc586deSMark Johnson 760adc586deSMark Johnson ASSERT(ucode); 761adc586deSMark Johnson ASSERT(ucodefp); 762adc586deSMark Johnson 763adc586deSMark Johnson #ifndef __xpv 7642449e17fSsherrym kpreempt_disable(); 765adc586deSMark Johnson wrmsr(ucode->write_msr, (uintptr_t)ucodefp); 766adc586deSMark Johnson ucode->read_rev(uinfop); 7672449e17fSsherrym kpreempt_enable(); 7680ba6f73dSMark Johnson 7690ba6f73dSMark Johnson return (ucodefp->uf_header.uh_patch_id); 770adc586deSMark Johnson #else 7710ba6f73dSMark Johnson uus.ucodep = ucodefp->ucodep; 7720ba6f73dSMark Johnson uus.usize = ucodefp->usize; 773adc586deSMark Johnson ucode_load_xpv(&uus); 774adc586deSMark Johnson ucode->read_rev(uinfop); 775adc586deSMark Johnson uus.new_rev = uinfop->cui_rev; 776adc586deSMark Johnson 7770ba6f73dSMark Johnson return (uus.new_rev); 7780ba6f73dSMark Johnson #endif 779adc586deSMark Johnson } 780adc586deSMark Johnson 781adc586deSMark Johnson /*ARGSUSED2*/ 782adc586deSMark Johnson static uint32_t 783adc586deSMark Johnson ucode_load_intel(ucode_file_t *ufp, cpu_ucode_info_t *uinfop, cpu_t *cp) 784adc586deSMark Johnson { 785adc586deSMark Johnson ucode_file_intel_t *ucodefp = &ufp->intel; 786adc586deSMark Johnson #ifdef __xpv 787adc586deSMark Johnson uint32_t ext_offset; 788adc586deSMark Johnson uint32_t body_size; 789adc586deSMark Johnson uint32_t ext_size; 790adc586deSMark Johnson uint8_t *ustart; 791adc586deSMark Johnson uint32_t usize; 792adc586deSMark Johnson ucode_update_t uus; 793adc586deSMark Johnson #endif 794adc586deSMark Johnson 795adc586deSMark Johnson ASSERT(ucode); 796adc586deSMark Johnson 797adc586deSMark Johnson #ifdef __xpv 798adc586deSMark Johnson /* 799adc586deSMark Johnson * the hypervisor wants the header, data, and extended 800adc586deSMark Johnson * signature tables. We can only get here from the boot 801adc586deSMark Johnson * CPU (cpu #0), we don't need to free as ucode_zalloc() will 802adc586deSMark Johnson * use BOP_ALLOC(). 803adc586deSMark Johnson */ 804adc586deSMark Johnson usize = UCODE_TOTAL_SIZE_INTEL(ucodefp->uf_header->uh_total_size); 805adc586deSMark Johnson ustart = ucode_zalloc(cp->cpu_id, usize); 806adc586deSMark Johnson ASSERT(ustart); 807adc586deSMark Johnson 808adc586deSMark Johnson body_size = UCODE_BODY_SIZE_INTEL(ucodefp->uf_header->uh_body_size); 809adc586deSMark Johnson ext_offset = body_size + UCODE_HEADER_SIZE_INTEL; 810adc586deSMark Johnson ext_size = usize - ext_offset; 811adc586deSMark Johnson ASSERT(ext_size >= 0); 812adc586deSMark Johnson 813adc586deSMark Johnson (void) memcpy(ustart, ucodefp->uf_header, UCODE_HEADER_SIZE_INTEL); 814adc586deSMark Johnson (void) memcpy(&ustart[UCODE_HEADER_SIZE_INTEL], ucodefp->uf_body, 815adc586deSMark Johnson body_size); 816adc586deSMark Johnson if (ext_size > 0) { 817adc586deSMark Johnson (void) memcpy(&ustart[ext_offset], 818adc586deSMark Johnson ucodefp->uf_ext_table, ext_size); 819adc586deSMark Johnson } 820adc586deSMark Johnson uus.ucodep = ustart; 821adc586deSMark Johnson uus.usize = usize; 822adc586deSMark Johnson ucode_load_xpv(&uus); 823adc586deSMark Johnson ucode->read_rev(uinfop); 824adc586deSMark Johnson uus.new_rev = uinfop->cui_rev; 825adc586deSMark Johnson #else 826adc586deSMark Johnson kpreempt_disable(); 827adc586deSMark Johnson wrmsr(ucode->write_msr, (uintptr_t)ucodefp->uf_body); 828adc586deSMark Johnson ucode->read_rev(uinfop); 829adc586deSMark Johnson kpreempt_enable(); 830adc586deSMark Johnson #endif 831adc586deSMark Johnson 832adc586deSMark Johnson return (ucodefp->uf_header->uh_rev); 8332449e17fSsherrym } 8342449e17fSsherrym 835882a7af5SMark Johnson 836882a7af5SMark Johnson #ifdef __xpv 837882a7af5SMark Johnson static void 838adc586deSMark Johnson ucode_load_xpv(ucode_update_t *uusp) 839882a7af5SMark Johnson { 840882a7af5SMark Johnson xen_platform_op_t op; 841882a7af5SMark Johnson int e; 842882a7af5SMark Johnson 843882a7af5SMark Johnson ASSERT(DOMAIN_IS_INITDOMAIN(xen_info)); 844882a7af5SMark Johnson 845882a7af5SMark Johnson kpreempt_disable(); 846882a7af5SMark Johnson op.cmd = XENPF_microcode_update; 847882a7af5SMark Johnson op.interface_version = XENPF_INTERFACE_VERSION; 848882a7af5SMark Johnson /*LINTED: constant in conditional context*/ 849adc586deSMark Johnson set_xen_guest_handle(op.u.microcode.data, uusp->ucodep); 850adc586deSMark Johnson op.u.microcode.length = uusp->usize; 851882a7af5SMark Johnson e = HYPERVISOR_platform_op(&op); 852882a7af5SMark Johnson if (e != 0) { 853882a7af5SMark Johnson cmn_err(CE_WARN, "hypervisor failed to accept uCode update"); 854882a7af5SMark Johnson } 855882a7af5SMark Johnson kpreempt_enable(); 856882a7af5SMark Johnson } 857882a7af5SMark Johnson #endif /* __xpv */ 858882a7af5SMark Johnson 859adc586deSMark Johnson static void 860adc586deSMark Johnson ucode_read_rev_amd(cpu_ucode_info_t *uinfop) 861adc586deSMark Johnson { 862adc586deSMark Johnson uinfop->cui_rev = rdmsr(MSR_AMD_PATCHLEVEL); 863adc586deSMark Johnson } 864882a7af5SMark Johnson 8652449e17fSsherrym static void 866adc586deSMark Johnson ucode_read_rev_intel(cpu_ucode_info_t *uinfop) 8672449e17fSsherrym { 8682449e17fSsherrym struct cpuid_regs crs; 8692449e17fSsherrym 8702449e17fSsherrym /* 8712449e17fSsherrym * The Intel 64 and IA-32 Architecture Software Developer's Manual 8722449e17fSsherrym * recommends that MSR_INTC_UCODE_REV be loaded with 0 first, then 8732449e17fSsherrym * execute cpuid to guarantee the correct reading of this register. 8742449e17fSsherrym */ 8752449e17fSsherrym wrmsr(MSR_INTC_UCODE_REV, 0); 8762449e17fSsherrym (void) __cpuid_insn(&crs); 8772449e17fSsherrym uinfop->cui_rev = (rdmsr(MSR_INTC_UCODE_REV) >> INTC_UCODE_REV_SHIFT); 8782449e17fSsherrym } 8792449e17fSsherrym 880adc586deSMark Johnson static ucode_errno_t 881adc586deSMark Johnson ucode_extract_amd(ucode_update_t *uusp, uint8_t *ucodep, int size) 882adc586deSMark Johnson { 8830ba6f73dSMark Johnson #ifndef __xpv 884adc586deSMark Johnson uint32_t *ptr = (uint32_t *)ucodep; 885adc586deSMark Johnson ucode_eqtbl_amd_t *eqtbl; 886adc586deSMark Johnson ucode_file_amd_t *ufp; 8870ba6f73dSMark Johnson int count; 8880ba6f73dSMark Johnson int higher = 0; 8890ba6f73dSMark Johnson ucode_errno_t rc = EM_NOMATCH; 8900ba6f73dSMark Johnson uint16_t eq_sig; 891adc586deSMark Johnson 892adc586deSMark Johnson /* skip over magic number & equivalence table header */ 893adc586deSMark Johnson ptr += 2; size -= 8; 894adc586deSMark Johnson 895adc586deSMark Johnson count = *ptr++; size -= 4; 896adc586deSMark Johnson for (eqtbl = (ucode_eqtbl_amd_t *)ptr; 897adc586deSMark Johnson eqtbl->ue_inst_cpu && eqtbl->ue_inst_cpu != uusp->sig; 898adc586deSMark Johnson eqtbl++) 899adc586deSMark Johnson ; 900adc586deSMark Johnson 901adc586deSMark Johnson eq_sig = eqtbl->ue_equiv_cpu; 902adc586deSMark Johnson 903adc586deSMark Johnson /* No equivalent CPU id found, assume outdated microcode file. */ 904adc586deSMark Johnson if (eq_sig == 0) 905adc586deSMark Johnson return (EM_HIGHERREV); 906adc586deSMark Johnson 907adc586deSMark Johnson /* Use the first microcode patch that matches. */ 908adc586deSMark Johnson do { 909adc586deSMark Johnson ptr += count >> 2; size -= count; 910adc586deSMark Johnson 911adc586deSMark Johnson if (!size) 9120ba6f73dSMark Johnson return (higher ? EM_HIGHERREV : EM_NOMATCH); 913adc586deSMark Johnson 914adc586deSMark Johnson ptr++; size -= 4; 915adc586deSMark Johnson count = *ptr++; size -= 4; 916adc586deSMark Johnson ufp = (ucode_file_amd_t *)ptr; 9170ba6f73dSMark Johnson 9180ba6f73dSMark Johnson rc = ucode_match_amd(eq_sig, &uusp->info, ufp, count); 9190ba6f73dSMark Johnson if (rc == EM_HIGHERREV) 9200ba6f73dSMark Johnson higher = 1; 9210ba6f73dSMark Johnson } while (rc != EM_OK); 922adc586deSMark Johnson 923adc586deSMark Johnson uusp->ucodep = (uint8_t *)ufp; 924adc586deSMark Johnson uusp->usize = count; 925adc586deSMark Johnson uusp->expected_rev = ufp->uf_header.uh_patch_id; 9260ba6f73dSMark Johnson #else 9270ba6f73dSMark Johnson /* 9280ba6f73dSMark Johnson * The hypervisor will choose the patch to load, so there is no way to 9290ba6f73dSMark Johnson * know the "expected revision" in advance. This is especially true on 9300ba6f73dSMark Johnson * mixed-revision systems where more than one patch will be loaded. 9310ba6f73dSMark Johnson */ 9320ba6f73dSMark Johnson uusp->expected_rev = 0; 9330ba6f73dSMark Johnson uusp->ucodep = ucodep; 9340ba6f73dSMark Johnson uusp->usize = size; 9350ba6f73dSMark Johnson 9360ba6f73dSMark Johnson ucode_chipset_amd(ucodep, size); 9370ba6f73dSMark Johnson #endif 938adc586deSMark Johnson 939adc586deSMark Johnson return (EM_OK); 940adc586deSMark Johnson } 941adc586deSMark Johnson 942adc586deSMark Johnson static ucode_errno_t 943adc586deSMark Johnson ucode_extract_intel(ucode_update_t *uusp, uint8_t *ucodep, int size) 944adc586deSMark Johnson { 945adc586deSMark Johnson uint32_t header_size = UCODE_HEADER_SIZE_INTEL; 946adc586deSMark Johnson int remaining; 947adc586deSMark Johnson int found = 0; 948adc586deSMark Johnson ucode_errno_t search_rc = EM_NOMATCH; /* search result */ 949adc586deSMark Johnson 950adc586deSMark Johnson /* 951adc586deSMark Johnson * Go through the whole buffer in case there are 952adc586deSMark Johnson * multiple versions of matching microcode for this 953adc586deSMark Johnson * processor. 954adc586deSMark Johnson */ 955adc586deSMark Johnson for (remaining = size; remaining > 0; ) { 956adc586deSMark Johnson int total_size, body_size, ext_size; 957adc586deSMark Johnson uint8_t *curbuf = &ucodep[size - remaining]; 958adc586deSMark Johnson ucode_header_intel_t *uhp = (ucode_header_intel_t *)curbuf; 959adc586deSMark Johnson ucode_ext_table_intel_t *uetp = NULL; 960adc586deSMark Johnson ucode_errno_t tmprc; 961adc586deSMark Johnson 962adc586deSMark Johnson total_size = UCODE_TOTAL_SIZE_INTEL(uhp->uh_total_size); 963adc586deSMark Johnson body_size = UCODE_BODY_SIZE_INTEL(uhp->uh_body_size); 964adc586deSMark Johnson ext_size = total_size - (header_size + body_size); 965adc586deSMark Johnson 966adc586deSMark Johnson if (ext_size > 0) 967adc586deSMark Johnson uetp = (ucode_ext_table_intel_t *) 968adc586deSMark Johnson &curbuf[header_size + body_size]; 969adc586deSMark Johnson 970adc586deSMark Johnson tmprc = ucode_match_intel(uusp->sig, &uusp->info, uhp, uetp); 971adc586deSMark Johnson 972adc586deSMark Johnson /* 973adc586deSMark Johnson * Since we are searching through a big file 974adc586deSMark Johnson * containing microcode for pretty much all the 975adc586deSMark Johnson * processors, we are bound to get EM_NOMATCH 976adc586deSMark Johnson * at one point. However, if we return 977adc586deSMark Johnson * EM_NOMATCH to users, it will really confuse 978adc586deSMark Johnson * them. Therefore, if we ever find a match of 979adc586deSMark Johnson * a lower rev, we will set return code to 980adc586deSMark Johnson * EM_HIGHERREV. 981adc586deSMark Johnson */ 982adc586deSMark Johnson if (tmprc == EM_HIGHERREV) 983adc586deSMark Johnson search_rc = EM_HIGHERREV; 984adc586deSMark Johnson 985adc586deSMark Johnson if (tmprc == EM_OK && 986adc586deSMark Johnson uusp->expected_rev < uhp->uh_rev) { 987adc586deSMark Johnson #ifndef __xpv 988adc586deSMark Johnson uusp->ucodep = (uint8_t *)&curbuf[header_size]; 989adc586deSMark Johnson #else 990adc586deSMark Johnson uusp->ucodep = (uint8_t *)curbuf; 991adc586deSMark Johnson #endif 992adc586deSMark Johnson uusp->usize = 993adc586deSMark Johnson UCODE_TOTAL_SIZE_INTEL(uhp->uh_total_size); 994adc586deSMark Johnson uusp->expected_rev = uhp->uh_rev; 995adc586deSMark Johnson found = 1; 996adc586deSMark Johnson } 997adc586deSMark Johnson 998adc586deSMark Johnson remaining -= total_size; 999adc586deSMark Johnson } 1000adc586deSMark Johnson 1001adc586deSMark Johnson if (!found) 1002adc586deSMark Johnson return (search_rc); 1003adc586deSMark Johnson 1004adc586deSMark Johnson return (EM_OK); 1005adc586deSMark Johnson } 10062449e17fSsherrym /* 10072449e17fSsherrym * Entry point to microcode update from the ucode_drv driver. 10082449e17fSsherrym * 10092449e17fSsherrym * Returns EM_OK on success, corresponding error code on failure. 10102449e17fSsherrym */ 10112449e17fSsherrym ucode_errno_t 10122449e17fSsherrym ucode_update(uint8_t *ucodep, int size) 10132449e17fSsherrym { 10142449e17fSsherrym int found = 0; 10152449e17fSsherrym processorid_t id; 1016adc586deSMark Johnson ucode_update_t cached = { 0 }; 1017adc586deSMark Johnson ucode_update_t *cachedp = NULL; 10182449e17fSsherrym ucode_errno_t rc = EM_OK; 10192449e17fSsherrym ucode_errno_t search_rc = EM_NOMATCH; /* search result */ 10202449e17fSsherrym cpuset_t cpuset; 10212449e17fSsherrym 1022adc586deSMark Johnson ASSERT(ucode); 10232449e17fSsherrym ASSERT(ucodep); 10242449e17fSsherrym CPUSET_ZERO(cpuset); 10252449e17fSsherrym 1026adc586deSMark Johnson if (!ucode->capable(CPU)) 10272449e17fSsherrym return (EM_NOTSUP); 10282449e17fSsherrym 10292449e17fSsherrym mutex_enter(&cpu_lock); 10302449e17fSsherrym 10312449e17fSsherrym for (id = 0; id < max_ncpus; id++) { 10322449e17fSsherrym cpu_t *cpu; 1033adc586deSMark Johnson ucode_update_t uus = { 0 }; 1034adc586deSMark Johnson ucode_update_t *uusp = &uus; 10352449e17fSsherrym 10362449e17fSsherrym /* 10372449e17fSsherrym * If there is no such CPU or it is not xcall ready, skip it. 10382449e17fSsherrym */ 10392449e17fSsherrym if ((cpu = cpu_get(id)) == NULL || 10402449e17fSsherrym !(cpu->cpu_flags & CPU_READY)) 10412449e17fSsherrym continue; 10422449e17fSsherrym 10432449e17fSsherrym uusp->sig = cpuid_getsig(cpu); 10442449e17fSsherrym bcopy(cpu->cpu_m.mcpu_ucode_info, &uusp->info, 10452449e17fSsherrym sizeof (uusp->info)); 10462449e17fSsherrym 10472449e17fSsherrym /* 10482449e17fSsherrym * If the current CPU has the same signature and platform 10492449e17fSsherrym * id as the previous one we processed, reuse the information. 10502449e17fSsherrym */ 10512449e17fSsherrym if (cachedp && cachedp->sig == cpuid_getsig(cpu) && 10522449e17fSsherrym cachedp->info.cui_platid == uusp->info.cui_platid) { 10532449e17fSsherrym uusp->ucodep = cachedp->ucodep; 10542449e17fSsherrym uusp->expected_rev = cachedp->expected_rev; 10552449e17fSsherrym /* 10562449e17fSsherrym * Intuitively we should check here to see whether the 10572449e17fSsherrym * running microcode rev is >= the expected rev, and 10582449e17fSsherrym * quit if it is. But we choose to proceed with the 10592449e17fSsherrym * xcall regardless of the running version so that 10602449e17fSsherrym * the other threads in an HT processor can update 10612449e17fSsherrym * the cpu_ucode_info structure in machcpu. 10622449e17fSsherrym */ 1063adc586deSMark Johnson } else if ((search_rc = ucode->extract(uusp, ucodep, size)) 1064adc586deSMark Johnson == EM_OK) { 10652449e17fSsherrym bcopy(uusp, &cached, sizeof (cached)); 10662449e17fSsherrym cachedp = &cached; 10672449e17fSsherrym found = 1; 10682449e17fSsherrym } 10692449e17fSsherrym 10702449e17fSsherrym /* Nothing to do */ 10712449e17fSsherrym if (uusp->ucodep == NULL) 10722449e17fSsherrym continue; 10732449e17fSsherrym 1074882a7af5SMark Johnson #ifdef __xpv 1075882a7af5SMark Johnson /* 1076882a7af5SMark Johnson * for i86xpv, the hypervisor will update all the CPUs. 1077882a7af5SMark Johnson * the hypervisor wants the header, data, and extended 1078882a7af5SMark Johnson * signature tables. ucode_write will just read in the 1079882a7af5SMark Johnson * updated version on all the CPUs after the update has 1080882a7af5SMark Johnson * completed. 1081882a7af5SMark Johnson */ 1082c9b5d7d2SMark Johnson if (id == 0) { 1083adc586deSMark Johnson ucode_load_xpv(uusp); 1084c9b5d7d2SMark Johnson } 1085882a7af5SMark Johnson #endif 1086882a7af5SMark Johnson 10872449e17fSsherrym CPUSET_ADD(cpuset, id); 10882449e17fSsherrym kpreempt_disable(); 1089f34a7178SJoe Bonasera xc_sync((xc_arg_t)uusp, 0, 0, CPUSET2BV(cpuset), ucode_write); 10902449e17fSsherrym kpreempt_enable(); 10912449e17fSsherrym CPUSET_DEL(cpuset, id); 10922449e17fSsherrym 10930ba6f73dSMark Johnson if (uusp->new_rev != 0 && uusp->info.cui_rev == uusp->new_rev) { 10940ba6f73dSMark Johnson rc = EM_HIGHERREV; 10950ba6f73dSMark Johnson } else if ((uusp->new_rev == 0) || (uusp->expected_rev != 0 && 10960ba6f73dSMark Johnson uusp->expected_rev != uusp->new_rev)) { 10972449e17fSsherrym cmn_err(CE_WARN, ucode_failure_fmt, 10982449e17fSsherrym id, uusp->info.cui_rev, uusp->expected_rev); 10992449e17fSsherrym rc = EM_UPDATE; 11000ba6f73dSMark Johnson } else { 11010ba6f73dSMark Johnson cmn_err(CE_CONT, ucode_success_fmt, 11020ba6f73dSMark Johnson id, uusp->info.cui_rev, uusp->new_rev); 11032449e17fSsherrym } 11042449e17fSsherrym } 11052449e17fSsherrym 11062449e17fSsherrym mutex_exit(&cpu_lock); 11072449e17fSsherrym 11082449e17fSsherrym if (!found) 11092449e17fSsherrym rc = search_rc; 11102449e17fSsherrym 11112449e17fSsherrym return (rc); 11122449e17fSsherrym } 11132449e17fSsherrym 11142449e17fSsherrym /* 11152449e17fSsherrym * Initialize mcpu_ucode_info, and perform microcode update if necessary. 11162449e17fSsherrym * This is the entry point from boot path where pointer to CPU structure 11172449e17fSsherrym * is available. 11182449e17fSsherrym * 11192449e17fSsherrym * cpuid_info must be initialized before ucode_check can be called. 11202449e17fSsherrym */ 11212449e17fSsherrym void 11222449e17fSsherrym ucode_check(cpu_t *cp) 11232449e17fSsherrym { 1124adc586deSMark Johnson cpu_ucode_info_t *uinfop; 11252449e17fSsherrym ucode_errno_t rc = EM_OK; 1126adc586deSMark Johnson uint32_t new_rev = 0; 11272449e17fSsherrym 11282449e17fSsherrym ASSERT(cp); 11292449e17fSsherrym if (cp->cpu_id == 0) 11302449e17fSsherrym cp->cpu_m.mcpu_ucode_info = &cpu_ucode_info0; 11312449e17fSsherrym 11322449e17fSsherrym uinfop = cp->cpu_m.mcpu_ucode_info; 11332449e17fSsherrym ASSERT(uinfop); 11342449e17fSsherrym 1135adc586deSMark Johnson /* set up function pointers if not already done */ 1136adc586deSMark Johnson if (!ucode) 1137adc586deSMark Johnson switch (cpuid_getvendor(cp)) { 1138adc586deSMark Johnson case X86_VENDOR_AMD: 1139adc586deSMark Johnson ucode = &ucode_amd; 1140adc586deSMark Johnson break; 1141adc586deSMark Johnson case X86_VENDOR_Intel: 1142adc586deSMark Johnson ucode = &ucode_intel; 1143adc586deSMark Johnson break; 1144adc586deSMark Johnson default: 1145*126b0a71SMark Johnson ucode = NULL; 1146adc586deSMark Johnson return; 1147adc586deSMark Johnson } 1148adc586deSMark Johnson 1149adc586deSMark Johnson if (!ucode->capable(cp)) 11502449e17fSsherrym return; 11512449e17fSsherrym 11522449e17fSsherrym /* 11532449e17fSsherrym * The MSR_INTC_PLATFORM_ID is supported in Celeron and Xeon 11542449e17fSsherrym * (Family 6, model 5 and above) and all processors after. 11552449e17fSsherrym */ 1156adc586deSMark Johnson if ((cpuid_getvendor(cp) == X86_VENDOR_Intel) && 1157adc586deSMark Johnson ((cpuid_getmodel(cp) >= 5) || (cpuid_getfamily(cp) > 6))) { 11582449e17fSsherrym uinfop->cui_platid = 1 << ((rdmsr(MSR_INTC_PLATFORM_ID) >> 11592449e17fSsherrym INTC_PLATFORM_ID_SHIFT) & INTC_PLATFORM_ID_MASK); 11602449e17fSsherrym } 11612449e17fSsherrym 1162adc586deSMark Johnson ucode->read_rev(uinfop); 11632449e17fSsherrym 1164c9b5d7d2SMark Johnson #ifdef __xpv 1165c9b5d7d2SMark Johnson /* 1166c9b5d7d2SMark Johnson * for i86xpv, the hypervisor will update all the CPUs. We only need 1167c9b5d7d2SMark Johnson * do do this on one of the CPUs (and there always is a CPU 0). 1168c9b5d7d2SMark Johnson */ 1169c9b5d7d2SMark Johnson if (cp->cpu_id != 0) { 1170c9b5d7d2SMark Johnson return; 1171c9b5d7d2SMark Johnson } 1172c9b5d7d2SMark Johnson #endif 1173c9b5d7d2SMark Johnson 11742449e17fSsherrym /* 11752449e17fSsherrym * Check to see if we need ucode update 11762449e17fSsherrym */ 1177adc586deSMark Johnson if ((rc = ucode->locate(cp, uinfop, &ucodefile)) == EM_OK) { 1178adc586deSMark Johnson new_rev = ucode->load(&ucodefile, uinfop, cp); 1179882a7af5SMark Johnson 1180adc586deSMark Johnson if (uinfop->cui_rev != new_rev) 11812449e17fSsherrym cmn_err(CE_WARN, ucode_failure_fmt, cp->cpu_id, 1182adc586deSMark Johnson uinfop->cui_rev, new_rev); 11832449e17fSsherrym } 11842449e17fSsherrym 11852449e17fSsherrym /* 11862449e17fSsherrym * If we fail to find a match for any reason, free the file structure 11872449e17fSsherrym * just in case we have read in a partial file. 11882449e17fSsherrym * 11892449e17fSsherrym * Since the scratch memory for holding the microcode for the boot CPU 11902449e17fSsherrym * came from BOP_ALLOC, we will reset the data structure as if we 11912449e17fSsherrym * never did the allocation so we don't have to keep track of this 11922449e17fSsherrym * special chunk of memory. We free the memory used for the rest 11932449e17fSsherrym * of the CPUs in start_other_cpus(). 11942449e17fSsherrym */ 11952449e17fSsherrym if (rc != EM_OK || cp->cpu_id == 0) 1196adc586deSMark Johnson ucode->file_reset(&ucodefile, cp->cpu_id); 11972449e17fSsherrym } 11982449e17fSsherrym 11992449e17fSsherrym /* 12002449e17fSsherrym * Returns microcode revision from the machcpu structure. 12012449e17fSsherrym */ 12022449e17fSsherrym ucode_errno_t 12032449e17fSsherrym ucode_get_rev(uint32_t *revp) 12042449e17fSsherrym { 12052449e17fSsherrym int i; 12062449e17fSsherrym 1207adc586deSMark Johnson ASSERT(ucode); 12082449e17fSsherrym ASSERT(revp); 12092449e17fSsherrym 1210adc586deSMark Johnson if (!ucode->capable(CPU)) 12112449e17fSsherrym return (EM_NOTSUP); 12122449e17fSsherrym 12132449e17fSsherrym mutex_enter(&cpu_lock); 12142449e17fSsherrym for (i = 0; i < max_ncpus; i++) { 12152449e17fSsherrym cpu_t *cpu; 12162449e17fSsherrym 12172449e17fSsherrym if ((cpu = cpu_get(i)) == NULL) 12182449e17fSsherrym continue; 12192449e17fSsherrym 12202449e17fSsherrym revp[i] = cpu->cpu_m.mcpu_ucode_info->cui_rev; 12212449e17fSsherrym } 12222449e17fSsherrym mutex_exit(&cpu_lock); 12232449e17fSsherrym 12242449e17fSsherrym return (EM_OK); 12252449e17fSsherrym } 1226