xref: /titanic_51/usr/src/uts/i86pc/os/microcode.c (revision 126b0a7149858848c18e1e18979f54c432790aa2)
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