microcode_amd.c 8.4 KB

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