1 #ifndef _ASM_X86_MICROCODE_H
2 #define _ASM_X86_MICROCODE_H
3
4 #include <linux/earlycpio.h>
5 #include <linux/initrd.h>
6
7 #define native_rdmsr(msr, val1, val2) \
8 do { \
9 u64 __val = native_read_msr((msr)); \
10 (void)((val1) = (u32)__val); \
11 (void)((val2) = (u32)(__val >> 32)); \
12 } while (0)
13
14 #define native_wrmsr(msr, low, high) \
15 native_write_msr(msr, low, high)
16
17 #define native_wrmsrl(msr, val) \
18 native_write_msr((msr), \
19 (u32)((u64)(val)), \
20 (u32)((u64)(val) >> 32))
21
22 struct cpu_signature {
23 unsigned int sig;
24 unsigned int pf;
25 unsigned int rev;
26 };
27
28 struct device;
29
30 enum ucode_state { UCODE_ERROR, UCODE_OK, UCODE_NFOUND };
31
32 struct microcode_ops {
33 enum ucode_state (*request_microcode_user) (int cpu,
34 const void __user *buf, size_t size);
35
36 enum ucode_state (*request_microcode_fw) (int cpu, struct device *,
37 bool refresh_fw);
38
39 void (*microcode_fini_cpu) (int cpu);
40
41 /*
42 * The generic 'microcode_core' part guarantees that
43 * the callbacks below run on a target cpu when they
44 * are being called.
45 * See also the "Synchronization" section in microcode_core.c.
46 */
47 int (*apply_microcode) (int cpu);
48 int (*collect_cpu_info) (int cpu, struct cpu_signature *csig);
49 };
50
51 struct ucode_cpu_info {
52 struct cpu_signature cpu_sig;
53 int valid;
54 void *mc;
55 };
56 extern struct ucode_cpu_info ucode_cpu_info[];
57
58 #ifdef CONFIG_MICROCODE
59 int __init microcode_init(void);
60 #else
microcode_init(void)61 static inline int __init microcode_init(void) { return 0; };
62 #endif
63
64 #ifdef CONFIG_MICROCODE_INTEL
65 extern struct microcode_ops * __init init_intel_microcode(void);
66 #else
init_intel_microcode(void)67 static inline struct microcode_ops * __init init_intel_microcode(void)
68 {
69 return NULL;
70 }
71 #endif /* CONFIG_MICROCODE_INTEL */
72
73 #ifdef CONFIG_MICROCODE_AMD
74 extern struct microcode_ops * __init init_amd_microcode(void);
75 extern void __exit exit_amd_microcode(void);
76 #else
init_amd_microcode(void)77 static inline struct microcode_ops * __init init_amd_microcode(void)
78 {
79 return NULL;
80 }
exit_amd_microcode(void)81 static inline void __exit exit_amd_microcode(void) {}
82 #endif
83
84 #define MAX_UCODE_COUNT 128
85
86 #define QCHAR(a, b, c, d) ((a) + ((b) << 8) + ((c) << 16) + ((d) << 24))
87 #define CPUID_INTEL1 QCHAR('G', 'e', 'n', 'u')
88 #define CPUID_INTEL2 QCHAR('i', 'n', 'e', 'I')
89 #define CPUID_INTEL3 QCHAR('n', 't', 'e', 'l')
90 #define CPUID_AMD1 QCHAR('A', 'u', 't', 'h')
91 #define CPUID_AMD2 QCHAR('e', 'n', 't', 'i')
92 #define CPUID_AMD3 QCHAR('c', 'A', 'M', 'D')
93
94 #define CPUID_IS(a, b, c, ebx, ecx, edx) \
95 (!((ebx ^ (a))|(edx ^ (b))|(ecx ^ (c))))
96
97 /*
98 * In early loading microcode phase on BSP, boot_cpu_data is not set up yet.
99 * x86_vendor() gets vendor id for BSP.
100 *
101 * In 32 bit AP case, accessing boot_cpu_data needs linear address. To simplify
102 * coding, we still use x86_vendor() to get vendor id for AP.
103 *
104 * x86_vendor() gets vendor information directly from CPUID.
105 */
x86_vendor(void)106 static inline int x86_vendor(void)
107 {
108 u32 eax = 0x00000000;
109 u32 ebx, ecx = 0, edx;
110
111 native_cpuid(&eax, &ebx, &ecx, &edx);
112
113 if (CPUID_IS(CPUID_INTEL1, CPUID_INTEL2, CPUID_INTEL3, ebx, ecx, edx))
114 return X86_VENDOR_INTEL;
115
116 if (CPUID_IS(CPUID_AMD1, CPUID_AMD2, CPUID_AMD3, ebx, ecx, edx))
117 return X86_VENDOR_AMD;
118
119 return X86_VENDOR_UNKNOWN;
120 }
121
__x86_family(unsigned int sig)122 static inline unsigned int __x86_family(unsigned int sig)
123 {
124 unsigned int x86;
125
126 x86 = (sig >> 8) & 0xf;
127
128 if (x86 == 0xf)
129 x86 += (sig >> 20) & 0xff;
130
131 return x86;
132 }
133
x86_family(void)134 static inline unsigned int x86_family(void)
135 {
136 u32 eax = 0x00000001;
137 u32 ebx, ecx = 0, edx;
138
139 native_cpuid(&eax, &ebx, &ecx, &edx);
140
141 return __x86_family(eax);
142 }
143
x86_model(unsigned int sig)144 static inline unsigned int x86_model(unsigned int sig)
145 {
146 unsigned int x86, model;
147
148 x86 = __x86_family(sig);
149
150 model = (sig >> 4) & 0xf;
151
152 if (x86 == 0x6 || x86 == 0xf)
153 model += ((sig >> 16) & 0xf) << 4;
154
155 return model;
156 }
157
158 #ifdef CONFIG_MICROCODE
159 extern void __init load_ucode_bsp(void);
160 extern void load_ucode_ap(void);
161 extern int __init save_microcode_in_initrd(void);
162 void reload_early_microcode(void);
163 extern bool get_builtin_firmware(struct cpio_data *cd, const char *name);
164 #else
load_ucode_bsp(void)165 static inline void __init load_ucode_bsp(void) { }
load_ucode_ap(void)166 static inline void load_ucode_ap(void) { }
save_microcode_in_initrd(void)167 static inline int __init save_microcode_in_initrd(void) { return 0; }
reload_early_microcode(void)168 static inline void reload_early_microcode(void) { }
169 static inline bool
get_builtin_firmware(struct cpio_data * cd,const char * name)170 get_builtin_firmware(struct cpio_data *cd, const char *name) { return false; }
171 #endif
172
get_initrd_start(void)173 static inline unsigned long get_initrd_start(void)
174 {
175 #ifdef CONFIG_BLK_DEV_INITRD
176 return initrd_start;
177 #else
178 return 0;
179 #endif
180 }
181
get_initrd_start_addr(void)182 static inline unsigned long get_initrd_start_addr(void)
183 {
184 #ifdef CONFIG_BLK_DEV_INITRD
185 #ifdef CONFIG_X86_32
186 unsigned long *initrd_start_p = (unsigned long *)__pa_nodebug(&initrd_start);
187
188 return (unsigned long)__pa_nodebug(*initrd_start_p);
189 #else
190 return get_initrd_start();
191 #endif
192 #else /* CONFIG_BLK_DEV_INITRD */
193 return 0;
194 #endif
195 }
196
197 #endif /* _ASM_X86_MICROCODE_H */
198