[linux-2.6-block.git] / arch / x86 / kernel / cpu / microcode / intel_lib.c

/*
 *	Intel CPU Microcode Update Driver for Linux
 *
 *	Copyright (C) 2012 Fenghua Yu <fenghua.yu@intel.com>
 *			   H Peter Anvin" <hpa@zytor.com>
 *
 *	This driver allows to upgrade microcode on Intel processors
 *	belonging to IA-32 family - PentiumPro, Pentium II,
 *	Pentium III, Xeon, Pentium 4, etc.
 *
 *	Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture
 *	Software Developer's Manual
 *	Order Number 253668 or free download from:
 *
 *	http://developer.intel.com/Assets/PDF/manual/253668.pdf
 *
 *	For more information, go to http://www.urbanmyth.org/microcode
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 */
#include <linux/firmware.h>
#include <linux/uaccess.h>
#include <linux/kernel.h>

#include <asm/microcode_intel.h>
#include <asm/processor.h>
#include <asm/msr.h>

static inline bool cpu_signatures_match(unsigned int s1, unsigned int p1,
					unsigned int s2, unsigned int p2)
{
	if (s1 != s2)
		return false;

	/* Processor flags are either both 0 ... */
	if (!p1 && !p2)
		return true;

	/* ... or they intersect. */
	return p1 & p2;
}

int microcode_sanity_check(void *mc, int print_err)
{
	unsigned long total_size, data_size, ext_table_size;
	struct microcode_header_intel *mc_header = mc;
	struct extended_sigtable *ext_header = NULL;
	u32 sum, orig_sum, ext_sigcount = 0, i;
	struct extended_signature *ext_sig;

	total_size = get_totalsize(mc_header);
	data_size = get_datasize(mc_header);

	if (data_size + MC_HEADER_SIZE > total_size) {
		if (print_err)
			pr_err("Error: bad microcode data file size.\n");
		return -EINVAL;
	}

	if (mc_header->ldrver != 1 || mc_header->hdrver != 1) {
		if (print_err)
			pr_err("Error: invalid/unknown microcode update format.\n");
		return -EINVAL;
	}

	ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
	if (ext_table_size) {
		u32 ext_table_sum = 0;
		u32 *ext_tablep;

		if ((ext_table_size < EXT_HEADER_SIZE)
		 || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
			if (print_err)
				pr_err("Error: truncated extended signature table.\n");
			return -EINVAL;
		}

		ext_header = mc + MC_HEADER_SIZE + data_size;
		if (ext_table_size != exttable_size(ext_header)) {
			if (print_err)
				pr_err("Error: extended signature table size mismatch.\n");
			return -EFAULT;
		}

		ext_sigcount = ext_header->count;

		/*
		 * Check extended table checksum: the sum of all dwords that
		 * comprise a valid table must be 0.
		 */
		ext_tablep = (u32 *)ext_header;

		i = ext_table_size / sizeof(u32);
		while (i--)
			ext_table_sum += ext_tablep[i];

		if (ext_table_sum) {
			if (print_err)
				pr_warn("Bad extended signature table checksum, aborting.\n");
			return -EINVAL;
		}
	}

	/*
	 * Calculate the checksum of update data and header. The checksum of
	 * valid update data and header including the extended signature table
	 * must be 0.
	 */
	orig_sum = 0;
	i = (MC_HEADER_SIZE + data_size) / sizeof(u32);
	while (i--)
		orig_sum += ((u32 *)mc)[i];

	if (orig_sum) {
		if (print_err)
			pr_err("Bad microcode data checksum, aborting.\n");
		return -EINVAL;
	}

	if (!ext_table_size)
		return 0;

	/*
	 * Check extended signature checksum: 0 => valid.
	 */
	for (i = 0; i < ext_sigcount; i++) {
		ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
			  EXT_SIGNATURE_SIZE * i;

		sum = (mc_header->sig + mc_header->pf + mc_header->cksum) -
		      (ext_sig->sig + ext_sig->pf + ext_sig->cksum);
		if (sum) {
			if (print_err)
				pr_err("Bad extended signature checksum, aborting.\n");
			return -EINVAL;
		}
	}
	return 0;
}
EXPORT_SYMBOL_GPL(microcode_sanity_check);

/*
 * Returns 1 if update has been found, 0 otherwise.
 */
int find_matching_signature(void *mc, unsigned int csig, int cpf)
{
	struct microcode_header_intel *mc_hdr = mc;
	struct extended_sigtable *ext_hdr;
	struct extended_signature *ext_sig;
	int i;

	if (cpu_signatures_match(csig, cpf, mc_hdr->sig, mc_hdr->pf))
		return 1;

	/* Look for ext. headers: */
	if (get_totalsize(mc_hdr) <= get_datasize(mc_hdr) + MC_HEADER_SIZE)
		return 0;

	ext_hdr = mc + get_datasize(mc_hdr) + MC_HEADER_SIZE;
	ext_sig = (void *)ext_hdr + EXT_HEADER_SIZE;

	for (i = 0; i < ext_hdr->count; i++) {
		if (cpu_signatures_match(csig, cpf, ext_sig->sig, ext_sig->pf))
			return 1;
		ext_sig++;
	}
	return 0;
}

/*
 * Returns 1 if update has been found, 0 otherwise.
 */
int has_newer_microcode(void *mc, unsigned int csig, int cpf, int new_rev)
{
	struct microcode_header_intel *mc_hdr = mc;

	if (mc_hdr->rev <= new_rev)
		return 0;

	return find_matching_signature(mc, csig, cpf);
}
EXPORT_SYMBOL_GPL(has_newer_microcode);
Commit	Line	Data
e666dfa2 FY	1	/*
	2	* Intel CPU Microcode Update Driver for Linux
	3	*
	4	* Copyright (C) 2012 Fenghua Yu <fenghua.yu@intel.com>
	5	* H Peter Anvin" <hpa@zytor.com>
	6	*
	7	* This driver allows to upgrade microcode on Intel processors
	8	* belonging to IA-32 family - PentiumPro, Pentium II,
	9	* Pentium III, Xeon, Pentium 4, etc.
	10	*
	11	* Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture
	12	* Software Developer's Manual
	13	* Order Number 253668 or free download from:
	14	*
	15	* http://developer.intel.com/Assets/PDF/manual/253668.pdf
	16	*
	17	* For more information, go to http://www.urbanmyth.org/microcode
	18	*
	19	* This program is free software; you can redistribute it and/or
	20	* modify it under the terms of the GNU General Public License
	21	* as published by the Free Software Foundation; either version
	22	* 2 of the License, or (at your option) any later version.
	23	*
	24	*/
	25	#include <linux/firmware.h>
	26	#include <linux/uaccess.h>
	27	#include <linux/kernel.h>
e666dfa2 FY	28
	29	#include <asm/microcode_intel.h>
	30	#include <asm/processor.h>
	31	#include <asm/msr.h>
	32
6b2d469f BP	33	static inline bool cpu_signatures_match(unsigned int s1, unsigned int p1,
6b2d469f BP	34	unsigned int s2, unsigned int p2)
e666dfa2	35	{
6b2d469f BP	36	if (s1 != s2)
	37	return false;
	38
	39	/* Processor flags are either both 0 ... */
	40	if (!p1 && !p2)
	41	return true;
	42
	43	/* ... or they intersect. */
	44	return p1 & p2;
e666dfa2 FY	45	}
e666dfa2 FY	46
e666dfa2 FY	47	int microcode_sanity_check(void *mc, int print_err)
	48	{
	49	unsigned long total_size, data_size, ext_table_size;
	50	struct microcode_header_intel *mc_header = mc;
	51	struct extended_sigtable *ext_header = NULL;
bc864af1	52	u32 sum, orig_sum, ext_sigcount = 0, i;
e666dfa2 FY	53	struct extended_signature *ext_sig;
	54
	55	total_size = get_totalsize(mc_header);
	56	data_size = get_datasize(mc_header);
	57
	58	if (data_size + MC_HEADER_SIZE > total_size) {
	59	if (print_err)
5b46b5e0	60	pr_err("Error: bad microcode data file size.\n");
e666dfa2 FY	61	return -EINVAL;
	62	}
	63
	64	if (mc_header->ldrver != 1 \|\| mc_header->hdrver != 1) {
	65	if (print_err)
5b46b5e0	66	pr_err("Error: invalid/unknown microcode update format.\n");
e666dfa2 FY	67	return -EINVAL;
e666dfa2 FY	68	}
5b46b5e0	69
e666dfa2 FY	70	ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
e666dfa2 FY	71	if (ext_table_size) {
7d016156 BP	72	u32 ext_table_sum = 0;
	73	u32 *ext_tablep;
	74
e666dfa2 FY	75	if ((ext_table_size < EXT_HEADER_SIZE)
	76	\|\| ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
	77	if (print_err)
5b46b5e0	78	pr_err("Error: truncated extended signature table.\n");
e666dfa2 FY	79	return -EINVAL;
e666dfa2 FY	80	}
5b46b5e0	81
e666dfa2 FY	82	ext_header = mc + MC_HEADER_SIZE + data_size;
	83	if (ext_table_size != exttable_size(ext_header)) {
	84	if (print_err)
5b46b5e0	85	pr_err("Error: extended signature table size mismatch.\n");
e666dfa2 FY	86	return -EFAULT;
e666dfa2 FY	87	}
5b46b5e0	88
e666dfa2	89	ext_sigcount = ext_header->count;
e666dfa2	90
5b46b5e0 BP	91	/*
	92	* Check extended table checksum: the sum of all dwords that
	93	* comprise a valid table must be 0.
	94	*/
7d016156	95	ext_tablep = (u32 *)ext_header;
e666dfa2	96
c0414622	97	i = ext_table_size / sizeof(u32);
e666dfa2 FY	98	while (i--)
e666dfa2 FY	99	ext_table_sum += ext_tablep[i];
5b46b5e0	100
e666dfa2 FY	101	if (ext_table_sum) {
e666dfa2 FY	102	if (print_err)
5b46b5e0	103	pr_warn("Bad extended signature table checksum, aborting.\n");
e666dfa2 FY	104	return -EINVAL;
	105	}
	106	}
	107
5b46b5e0 BP	108	/*
	109	* Calculate the checksum of update data and header. The checksum of
	110	* valid update data and header including the extended signature table
	111	* must be 0.
	112	*/
e666dfa2	113	orig_sum = 0;
c0414622	114	i = (MC_HEADER_SIZE + data_size) / sizeof(u32);
e666dfa2	115	while (i--)
bc864af1	116	orig_sum += ((u32 *)mc)[i];
5b46b5e0	117
e666dfa2 FY	118	if (orig_sum) {
e666dfa2 FY	119	if (print_err)
5b46b5e0	120	pr_err("Bad microcode data checksum, aborting.\n");
e666dfa2 FY	121	return -EINVAL;
e666dfa2 FY	122	}
5b46b5e0	123
e666dfa2 FY	124	if (!ext_table_size)
e666dfa2 FY	125	return 0;
5b46b5e0 BP	126
	127	/*
	128	* Check extended signature checksum: 0 => valid.
	129	*/
e666dfa2 FY	130	for (i = 0; i < ext_sigcount; i++) {
	131	ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
	132	EXT_SIGNATURE_SIZE * i;
4ace2e7a BP	133
	134	sum = (mc_header->sig + mc_header->pf + mc_header->cksum) -
	135	(ext_sig->sig + ext_sig->pf + ext_sig->cksum);
e666dfa2 FY	136	if (sum) {
e666dfa2 FY	137	if (print_err)
5b46b5e0	138	pr_err("Bad extended signature checksum, aborting.\n");
e666dfa2 FY	139	return -EINVAL;
	140	}
	141	}
	142	return 0;
	143	}
	144	EXPORT_SYMBOL_GPL(microcode_sanity_check);
	145
	146	/*
e3d8f674	147	* Returns 1 if update has been found, 0 otherwise.
e666dfa2	148	*/
e774eaa9	149	int find_matching_signature(void *mc, unsigned int csig, int cpf)
e666dfa2	150	{
9e5aed83 BP	151	struct microcode_header_intel *mc_hdr = mc;
9e5aed83 BP	152	struct extended_sigtable *ext_hdr;
e666dfa2	153	struct extended_signature *ext_sig;
9e5aed83	154	int i;
e666dfa2	155
9e5aed83	156	if (cpu_signatures_match(csig, cpf, mc_hdr->sig, mc_hdr->pf))
e666dfa2 FY	157	return 1;
	158
	159	/* Look for ext. headers: */
9e5aed83	160	if (get_totalsize(mc_hdr) <= get_datasize(mc_hdr) + MC_HEADER_SIZE)
e666dfa2 FY	161	return 0;
e666dfa2 FY	162
9e5aed83 BP	163	ext_hdr = mc + get_datasize(mc_hdr) + MC_HEADER_SIZE;
9e5aed83 BP	164	ext_sig = (void *)ext_hdr + EXT_HEADER_SIZE;
e666dfa2	165
9e5aed83	166	for (i = 0; i < ext_hdr->count; i++) {
6b2d469f	167	if (cpu_signatures_match(csig, cpf, ext_sig->sig, ext_sig->pf))
e666dfa2 FY	168	return 1;
	169	ext_sig++;
	170	}
	171	return 0;
	172	}
	173
	174	/*
e3d8f674	175	* Returns 1 if update has been found, 0 otherwise.
e666dfa2	176	*/
8de3eafc	177	int has_newer_microcode(void *mc, unsigned int csig, int cpf, int new_rev)
e666dfa2	178	{
e3d8f674	179	struct microcode_header_intel *mc_hdr = mc;
e666dfa2	180
a1a32d29	181	if (mc_hdr->rev <= new_rev)
e666dfa2 FY	182	return 0;
e666dfa2 FY	183
e774eaa9	184	return find_matching_signature(mc, csig, cpf);
e666dfa2	185	}
8de3eafc	186	EXPORT_SYMBOL_GPL(has_newer_microcode);