[mirror_ubuntu-artful-kernel.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 data size in microcode data file\n");
		return -EINVAL;
	}

	if (mc_header->ldrver != 1 || mc_header->hdrver != 1) {
		if (print_err)
			pr_err("error! Unknown microcode update format\n");
		return -EINVAL;
	}
	ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
	if (ext_table_size) {
		if ((ext_table_size < EXT_HEADER_SIZE)
		 || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
			if (print_err)
				pr_err("error! Small exttable size in microcode data file\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! Bad exttable size in microcode data file\n");
			return -EFAULT;
		}
		ext_sigcount = ext_header->count;
	}

	/* check extended table checksum */
	if (ext_table_size) {
		u32 ext_table_sum = 0;
		u32 *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("aborting, bad extended signature table checksum\n");
			return -EINVAL;
		}
	}

	/* calculate the checksum */
	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("aborting, bad checksum\n");
		return -EINVAL;
	}
	if (!ext_table_size)
		return 0;
	/* check extended signature checksum */
	for (i = 0; i < ext_sigcount; i++) {
		ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
			  EXT_SIGNATURE_SIZE * i;
		sum = orig_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("aborting, bad checksum\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)
	60	pr_err("error! Bad data size in microcode data file\n");
	61	return -EINVAL;
	62	}
	63
	64	if (mc_header->ldrver != 1 \|\| mc_header->hdrver != 1) {
	65	if (print_err)
	66	pr_err("error! Unknown microcode update format\n");
	67	return -EINVAL;
	68	}
	69	ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
	70	if (ext_table_size) {
	71	if ((ext_table_size < EXT_HEADER_SIZE)
	72	\|\| ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
	73	if (print_err)
	74	pr_err("error! Small exttable size in microcode data file\n");
	75	return -EINVAL;
	76	}
	77	ext_header = mc + MC_HEADER_SIZE + data_size;
	78	if (ext_table_size != exttable_size(ext_header)) {
	79	if (print_err)
	80	pr_err("error! Bad exttable size in microcode data file\n");
	81	return -EFAULT;
	82	}
	83	ext_sigcount = ext_header->count;
	84	}
	85
	86	/* check extended table checksum */
	87	if (ext_table_size) {
bc864af1 CB	88	u32 ext_table_sum = 0;
bc864af1 CB	89	u32 ext_tablep = (u32 )ext_header;
e666dfa2	90
c0414622	91	i = ext_table_size / sizeof(u32);
e666dfa2 FY	92	while (i--)
	93	ext_table_sum += ext_tablep[i];
	94	if (ext_table_sum) {
	95	if (print_err)
	96	pr_warn("aborting, bad extended signature table checksum\n");
	97	return -EINVAL;
	98	}
	99	}
	100
	101	/* calculate the checksum */
	102	orig_sum = 0;
c0414622	103	i = (MC_HEADER_SIZE + data_size) / sizeof(u32);
e666dfa2	104	while (i--)
bc864af1	105	orig_sum += ((u32 *)mc)[i];
e666dfa2 FY	106	if (orig_sum) {
	107	if (print_err)
	108	pr_err("aborting, bad checksum\n");
	109	return -EINVAL;
	110	}
	111	if (!ext_table_size)
	112	return 0;
	113	/* check extended signature checksum */
	114	for (i = 0; i < ext_sigcount; i++) {
	115	ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
	116	EXT_SIGNATURE_SIZE * i;
	117	sum = orig_sum
	118	- (mc_header->sig + mc_header->pf + mc_header->cksum)
	119	+ (ext_sig->sig + ext_sig->pf + ext_sig->cksum);
	120	if (sum) {
	121	if (print_err)
	122	pr_err("aborting, bad checksum\n");
	123	return -EINVAL;
	124	}
	125	}
	126	return 0;
	127	}
	128	EXPORT_SYMBOL_GPL(microcode_sanity_check);
	129
	130	/*
e3d8f674	131	* Returns 1 if update has been found, 0 otherwise.
e666dfa2	132	*/
e774eaa9	133	int find_matching_signature(void *mc, unsigned int csig, int cpf)
e666dfa2	134	{
9e5aed83 BP	135	struct microcode_header_intel *mc_hdr = mc;
9e5aed83 BP	136	struct extended_sigtable *ext_hdr;
e666dfa2	137	struct extended_signature *ext_sig;
9e5aed83	138	int i;
e666dfa2	139
9e5aed83	140	if (cpu_signatures_match(csig, cpf, mc_hdr->sig, mc_hdr->pf))
e666dfa2 FY	141	return 1;
	142
	143	/* Look for ext. headers: */
9e5aed83	144	if (get_totalsize(mc_hdr) <= get_datasize(mc_hdr) + MC_HEADER_SIZE)
e666dfa2 FY	145	return 0;
e666dfa2 FY	146
9e5aed83 BP	147	ext_hdr = mc + get_datasize(mc_hdr) + MC_HEADER_SIZE;
9e5aed83 BP	148	ext_sig = (void *)ext_hdr + EXT_HEADER_SIZE;
e666dfa2	149
9e5aed83	150	for (i = 0; i < ext_hdr->count; i++) {
6b2d469f	151	if (cpu_signatures_match(csig, cpf, ext_sig->sig, ext_sig->pf))
e666dfa2 FY	152	return 1;
	153	ext_sig++;
	154	}
	155	return 0;
	156	}
	157
	158	/*
e3d8f674	159	* Returns 1 if update has been found, 0 otherwise.
e666dfa2	160	*/
8de3eafc	161	int has_newer_microcode(void *mc, unsigned int csig, int cpf, int new_rev)
e666dfa2	162	{
e3d8f674	163	struct microcode_header_intel *mc_hdr = mc;
e666dfa2	164
a1a32d29	165	if (mc_hdr->rev <= new_rev)
e666dfa2 FY	166	return 0;
e666dfa2 FY	167
e774eaa9	168	return find_matching_signature(mc, csig, cpf);
e666dfa2	169	}
8de3eafc	170	EXPORT_SYMBOL_GPL(has_newer_microcode);