| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (c) 2014 Google, Inc |
| * Copyright (C) 2000 Ronald G. Minnich |
| * |
| * Microcode update for Intel PIII and later CPUs |
| */ |
| |
| #include <common.h> |
| #include <errno.h> |
| #include <fdtdec.h> |
| #include <log.h> |
| #include <asm/global_data.h> |
| #include <linux/libfdt.h> |
| #include <asm/cpu.h> |
| #include <asm/microcode.h> |
| #include <asm/msr.h> |
| #include <asm/msr-index.h> |
| #include <asm/processor.h> |
| |
| DECLARE_GLOBAL_DATA_PTR; |
| |
| /** |
| * struct microcode_update - standard microcode header from Intel |
| * |
| * We read this information out of the device tree and use it to determine |
| * whether the update is applicable or not. We also use the same structure |
| * to read information from the CPU. |
| */ |
| struct microcode_update { |
| uint header_version; |
| uint update_revision; |
| uint date_code; |
| uint processor_signature; |
| uint checksum; |
| uint loader_revision; |
| uint processor_flags; |
| const void *data; |
| int size; |
| }; |
| |
| static int microcode_decode_node(const void *blob, int node, |
| struct microcode_update *update) |
| { |
| update->data = fdt_getprop(blob, node, "data", &update->size); |
| if (!update->data) |
| return -ENOENT; |
| |
| update->header_version = fdtdec_get_int(blob, node, |
| "intel,header-version", 0); |
| update->update_revision = fdtdec_get_int(blob, node, |
| "intel,update-revision", 0); |
| update->date_code = fdtdec_get_int(blob, node, |
| "intel,date-code", 0); |
| update->processor_signature = fdtdec_get_int(blob, node, |
| "intel,processor-signature", 0); |
| update->checksum = fdtdec_get_int(blob, node, "intel,checksum", 0); |
| update->loader_revision = fdtdec_get_int(blob, node, |
| "intel,loader-revision", 0); |
| update->processor_flags = fdtdec_get_int(blob, node, |
| "intel,processor-flags", 0); |
| |
| return 0; |
| } |
| |
| int microcode_read_rev(void) |
| { |
| /* Quark does not have microcode MSRs */ |
| #ifdef CONFIG_INTEL_QUARK |
| return 0; |
| #else |
| /* |
| * Some Intel CPUs can be very finicky about the CPUID sequence used. |
| * So this is implemented in assembly so that it works reliably. |
| */ |
| uint32_t low, high; |
| |
| asm volatile ( |
| "xorl %%eax, %%eax\n" |
| "xorl %%edx, %%edx\n" |
| "movl %2, %%ecx\n" |
| "wrmsr\n" |
| "movl $0x01, %%eax\n" |
| "cpuid\n" |
| "movl %2, %%ecx\n" |
| "rdmsr\n" |
| : /* outputs */ |
| "=a" (low), "=d" (high) |
| : /* inputs */ |
| "i" (MSR_IA32_UCODE_REV) |
| : /* clobbers */ |
| "ebx", "ecx" |
| ); |
| |
| return high; |
| #endif |
| } |
| |
| static void microcode_read_cpu(struct microcode_update *cpu) |
| { |
| /* CPUID sets MSR 0x8B iff a microcode update has been loaded. */ |
| unsigned int x86_model, x86_family; |
| struct cpuid_result result; |
| uint32_t low, high; |
| |
| wrmsr(MSR_IA32_UCODE_REV, 0, 0); |
| result = cpuid(1); |
| rdmsr(MSR_IA32_UCODE_REV, low, cpu->update_revision); |
| x86_model = (result.eax >> 4) & 0x0f; |
| x86_family = (result.eax >> 8) & 0x0f; |
| cpu->processor_signature = result.eax; |
| |
| cpu->processor_flags = 0; |
| if ((x86_model >= 5) || (x86_family > 6)) { |
| rdmsr(0x17, low, high); |
| cpu->processor_flags = 1 << ((high >> 18) & 7); |
| } |
| debug("microcode: sig=%#x pf=%#x revision=%#x\n", |
| cpu->processor_signature, cpu->processor_flags, |
| cpu->update_revision); |
| } |
| |
| /* Get a microcode update from the device tree and apply it */ |
| int microcode_update_intel(void) |
| { |
| struct microcode_update cpu, update; |
| ulong address; |
| const void *blob = gd->fdt_blob; |
| int skipped; |
| int count; |
| int node; |
| int ret; |
| int rev; |
| |
| microcode_read_cpu(&cpu); |
| node = 0; |
| count = 0; |
| skipped = 0; |
| do { |
| node = fdtdec_next_compatible(blob, node, |
| COMPAT_INTEL_MICROCODE); |
| if (node < 0) { |
| debug("%s: Found %d updates\n", __func__, count); |
| return count ? 0 : skipped ? -EEXIST : -ENOENT; |
| } |
| |
| ret = microcode_decode_node(blob, node, &update); |
| if (ret == -ENOENT && ucode_base) { |
| /* |
| * The microcode has been removed from the device tree |
| * in the build system. In that case it will have |
| * already been updated in car_init(). |
| */ |
| debug("%s: Microcode data not available\n", __func__); |
| skipped++; |
| continue; |
| } |
| if (ret) { |
| debug("%s: Unable to decode update: %d\n", __func__, |
| ret); |
| return ret; |
| } |
| if (!(update.processor_signature == cpu.processor_signature && |
| (update.processor_flags & cpu.processor_flags))) { |
| debug("%s: Skipping non-matching update, sig=%x, pf=%x\n", |
| __func__, update.processor_signature, |
| update.processor_flags); |
| skipped++; |
| continue; |
| } |
| address = (ulong)update.data + UCODE_HEADER_LEN; |
| wrmsr(MSR_IA32_UCODE_WRITE, address, 0); |
| rev = microcode_read_rev(); |
| debug("microcode: updated to revision 0x%x date=%04x-%02x-%02x\n", |
| rev, update.date_code & 0xffff, |
| (update.date_code >> 24) & 0xff, |
| (update.date_code >> 16) & 0xff); |
| if (update.update_revision != rev) { |
| printf("Microcode update failed\n"); |
| return -EFAULT; |
| } |
| count++; |
| if (!ucode_base) { |
| ucode_base = (ulong)update.data; |
| ucode_size = update.size; |
| } |
| } while (1); |
| } |