microcode_amd.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353
  1. /*
  2. * AMD CPU Microcode Update Driver for Linux
  3. * Copyright (C) 2008 Advanced Micro Devices Inc.
  4. *
  5. * Author: Peter Oruba <peter.oruba@amd.com>
  6. *
  7. * Based on work by:
  8. * Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
  9. *
  10. * This driver allows to upgrade microcode on AMD
  11. * family 0x10 and 0x11 processors.
  12. *
  13. * Licensed under the terms of the GNU General Public
  14. * License version 2. See file COPYING for details.
  15. */
  16. #include <linux/firmware.h>
  17. #include <linux/pci_ids.h>
  18. #include <linux/uaccess.h>
  19. #include <linux/vmalloc.h>
  20. #include <linux/kernel.h>
  21. #include <linux/module.h>
  22. #include <linux/pci.h>
  23. #include <asm/microcode.h>
  24. #include <asm/processor.h>
  25. #include <asm/msr.h>
  26. MODULE_DESCRIPTION("AMD Microcode Update Driver");
  27. MODULE_AUTHOR("Peter Oruba");
  28. MODULE_LICENSE("GPL v2");
  29. #define UCODE_MAGIC 0x00414d44
  30. #define UCODE_EQUIV_CPU_TABLE_TYPE 0x00000000
  31. #define UCODE_UCODE_TYPE 0x00000001
  32. struct equiv_cpu_entry {
  33. u32 installed_cpu;
  34. u32 fixed_errata_mask;
  35. u32 fixed_errata_compare;
  36. u16 equiv_cpu;
  37. u16 res;
  38. } __attribute__((packed));
  39. struct microcode_header_amd {
  40. u32 data_code;
  41. u32 patch_id;
  42. u16 mc_patch_data_id;
  43. u8 mc_patch_data_len;
  44. u8 init_flag;
  45. u32 mc_patch_data_checksum;
  46. u32 nb_dev_id;
  47. u32 sb_dev_id;
  48. u16 processor_rev_id;
  49. u8 nb_rev_id;
  50. u8 sb_rev_id;
  51. u8 bios_api_rev;
  52. u8 reserved1[3];
  53. u32 match_reg[8];
  54. } __attribute__((packed));
  55. struct microcode_amd {
  56. struct microcode_header_amd hdr;
  57. unsigned int mpb[0];
  58. };
  59. #define UCODE_MAX_SIZE 2048
  60. #define UCODE_CONTAINER_SECTION_HDR 8
  61. #define UCODE_CONTAINER_HEADER_SIZE 12
  62. static struct equiv_cpu_entry *equiv_cpu_table;
  63. static int collect_cpu_info_amd(int cpu, struct cpu_signature *csig)
  64. {
  65. struct cpuinfo_x86 *c = &cpu_data(cpu);
  66. u32 dummy;
  67. memset(csig, 0, sizeof(*csig));
  68. if (c->x86_vendor != X86_VENDOR_AMD || c->x86 < 0x10) {
  69. printk(KERN_WARNING "microcode: CPU%d: AMD CPU family 0x%x not "
  70. "supported\n", cpu, c->x86);
  71. return -1;
  72. }
  73. rdmsr(MSR_AMD64_PATCH_LEVEL, csig->rev, dummy);
  74. printk(KERN_INFO "microcode: CPU%d: patch_level=0x%x\n", cpu, csig->rev);
  75. return 0;
  76. }
  77. static int get_matching_microcode(int cpu, void *mc, int rev)
  78. {
  79. struct microcode_header_amd *mc_header = mc;
  80. unsigned int current_cpu_id;
  81. u16 equiv_cpu_id = 0;
  82. unsigned int i = 0;
  83. BUG_ON(equiv_cpu_table == NULL);
  84. current_cpu_id = cpuid_eax(0x00000001);
  85. while (equiv_cpu_table[i].installed_cpu != 0) {
  86. if (current_cpu_id == equiv_cpu_table[i].installed_cpu) {
  87. equiv_cpu_id = equiv_cpu_table[i].equiv_cpu;
  88. break;
  89. }
  90. i++;
  91. }
  92. if (!equiv_cpu_id) {
  93. printk(KERN_WARNING "microcode: CPU%d: cpu revision "
  94. "not listed in equivalent cpu table\n", cpu);
  95. return 0;
  96. }
  97. if (mc_header->processor_rev_id != equiv_cpu_id)
  98. return 0;
  99. /* ucode might be chipset specific -- currently we don't support this */
  100. if (mc_header->nb_dev_id || mc_header->sb_dev_id) {
  101. printk(KERN_ERR "microcode: CPU%d: loading of chipset "
  102. "specific code not yet supported\n", cpu);
  103. return 0;
  104. }
  105. if (mc_header->patch_id <= rev)
  106. return 0;
  107. return 1;
  108. }
  109. static int apply_microcode_amd(int cpu)
  110. {
  111. u32 rev, dummy;
  112. int cpu_num = raw_smp_processor_id();
  113. struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
  114. struct microcode_amd *mc_amd = uci->mc;
  115. /* We should bind the task to the CPU */
  116. BUG_ON(cpu_num != cpu);
  117. if (mc_amd == NULL)
  118. return 0;
  119. wrmsrl(MSR_AMD64_PATCH_LOADER, (u64)(long)&mc_amd->hdr.data_code);
  120. /* get patch id after patching */
  121. rdmsr(MSR_AMD64_PATCH_LEVEL, rev, dummy);
  122. /* check current patch id and patch's id for match */
  123. if (rev != mc_amd->hdr.patch_id) {
  124. printk(KERN_ERR "microcode: CPU%d: update failed "
  125. "(for patch_level=0x%x)\n", cpu, mc_amd->hdr.patch_id);
  126. return -1;
  127. }
  128. printk(KERN_INFO "microcode: CPU%d: updated (new patch_level=0x%x)\n",
  129. cpu, rev);
  130. uci->cpu_sig.rev = rev;
  131. return 0;
  132. }
  133. static int get_ucode_data(void *to, const u8 *from, size_t n)
  134. {
  135. memcpy(to, from, n);
  136. return 0;
  137. }
  138. static void *
  139. get_next_ucode(const u8 *buf, unsigned int size, unsigned int *mc_size)
  140. {
  141. unsigned int total_size;
  142. u8 section_hdr[UCODE_CONTAINER_SECTION_HDR];
  143. void *mc;
  144. if (get_ucode_data(section_hdr, buf, UCODE_CONTAINER_SECTION_HDR))
  145. return NULL;
  146. if (section_hdr[0] != UCODE_UCODE_TYPE) {
  147. printk(KERN_ERR "microcode: error: invalid type field in "
  148. "container file section header\n");
  149. return NULL;
  150. }
  151. total_size = (unsigned long) (section_hdr[4] + (section_hdr[5] << 8));
  152. if (total_size > size || total_size > UCODE_MAX_SIZE) {
  153. printk(KERN_ERR "microcode: error: size mismatch\n");
  154. return NULL;
  155. }
  156. mc = vmalloc(UCODE_MAX_SIZE);
  157. if (mc) {
  158. memset(mc, 0, UCODE_MAX_SIZE);
  159. if (get_ucode_data(mc, buf + UCODE_CONTAINER_SECTION_HDR,
  160. total_size)) {
  161. vfree(mc);
  162. mc = NULL;
  163. } else
  164. *mc_size = total_size + UCODE_CONTAINER_SECTION_HDR;
  165. }
  166. return mc;
  167. }
  168. static int install_equiv_cpu_table(const u8 *buf)
  169. {
  170. u8 *container_hdr[UCODE_CONTAINER_HEADER_SIZE];
  171. unsigned int *buf_pos = (unsigned int *)container_hdr;
  172. unsigned long size;
  173. if (get_ucode_data(&container_hdr, buf, UCODE_CONTAINER_HEADER_SIZE))
  174. return 0;
  175. size = buf_pos[2];
  176. if (buf_pos[1] != UCODE_EQUIV_CPU_TABLE_TYPE || !size) {
  177. printk(KERN_ERR "microcode: error: invalid type field in "
  178. "container file section header\n");
  179. return 0;
  180. }
  181. equiv_cpu_table = (struct equiv_cpu_entry *) vmalloc(size);
  182. if (!equiv_cpu_table) {
  183. printk(KERN_ERR "microcode: failed to allocate "
  184. "equivalent CPU table\n");
  185. return 0;
  186. }
  187. buf += UCODE_CONTAINER_HEADER_SIZE;
  188. if (get_ucode_data(equiv_cpu_table, buf, size)) {
  189. vfree(equiv_cpu_table);
  190. return 0;
  191. }
  192. return size + UCODE_CONTAINER_HEADER_SIZE; /* add header length */
  193. }
  194. static void free_equiv_cpu_table(void)
  195. {
  196. vfree(equiv_cpu_table);
  197. equiv_cpu_table = NULL;
  198. }
  199. static enum ucode_state
  200. generic_load_microcode(int cpu, const u8 *data, size_t size)
  201. {
  202. struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
  203. const u8 *ucode_ptr = data;
  204. void *new_mc = NULL;
  205. void *mc;
  206. int new_rev = uci->cpu_sig.rev;
  207. unsigned int leftover;
  208. unsigned long offset;
  209. enum ucode_state state = UCODE_OK;
  210. offset = install_equiv_cpu_table(ucode_ptr);
  211. if (!offset) {
  212. printk(KERN_ERR "microcode: failed to create "
  213. "equivalent cpu table\n");
  214. return UCODE_ERROR;
  215. }
  216. ucode_ptr += offset;
  217. leftover = size - offset;
  218. while (leftover) {
  219. unsigned int uninitialized_var(mc_size);
  220. struct microcode_header_amd *mc_header;
  221. mc = get_next_ucode(ucode_ptr, leftover, &mc_size);
  222. if (!mc)
  223. break;
  224. mc_header = (struct microcode_header_amd *)mc;
  225. if (get_matching_microcode(cpu, mc, new_rev)) {
  226. vfree(new_mc);
  227. new_rev = mc_header->patch_id;
  228. new_mc = mc;
  229. } else
  230. vfree(mc);
  231. ucode_ptr += mc_size;
  232. leftover -= mc_size;
  233. }
  234. if (new_mc) {
  235. if (!leftover) {
  236. vfree(uci->mc);
  237. uci->mc = new_mc;
  238. pr_debug("microcode: CPU%d found a matching microcode "
  239. "update with version 0x%x (current=0x%x)\n",
  240. cpu, new_rev, uci->cpu_sig.rev);
  241. } else {
  242. vfree(new_mc);
  243. state = UCODE_ERROR;
  244. }
  245. } else
  246. state = UCODE_NFOUND;
  247. free_equiv_cpu_table();
  248. return state;
  249. }
  250. static enum ucode_state request_microcode_fw(int cpu, struct device *device)
  251. {
  252. const char *fw_name = "amd-ucode/microcode_amd.bin";
  253. const struct firmware *firmware;
  254. enum ucode_state ret;
  255. if (request_firmware(&firmware, fw_name, device)) {
  256. printk(KERN_ERR "microcode: failed to load file %s\n", fw_name);
  257. return UCODE_NFOUND;
  258. }
  259. if (*(u32 *)firmware->data != UCODE_MAGIC) {
  260. printk(KERN_ERR "microcode: invalid UCODE_MAGIC (0x%08x)\n",
  261. *(u32 *)firmware->data);
  262. return UCODE_ERROR;
  263. }
  264. ret = generic_load_microcode(cpu, firmware->data, firmware->size);
  265. release_firmware(firmware);
  266. return ret;
  267. }
  268. static enum ucode_state
  269. request_microcode_user(int cpu, const void __user *buf, size_t size)
  270. {
  271. printk(KERN_INFO "microcode: AMD microcode update via "
  272. "/dev/cpu/microcode not supported\n");
  273. return UCODE_ERROR;
  274. }
  275. static void microcode_fini_cpu_amd(int cpu)
  276. {
  277. struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
  278. vfree(uci->mc);
  279. uci->mc = NULL;
  280. }
  281. static struct microcode_ops microcode_amd_ops = {
  282. .request_microcode_user = request_microcode_user,
  283. .request_microcode_fw = request_microcode_fw,
  284. .collect_cpu_info = collect_cpu_info_amd,
  285. .apply_microcode = apply_microcode_amd,
  286. .microcode_fini_cpu = microcode_fini_cpu_amd,
  287. };
  288. struct microcode_ops * __init init_amd_microcode(void)
  289. {
  290. return &microcode_amd_ops;
  291. }