[mirror_ubuntu-artful-kernel.git] / arch / x86 / kernel / 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 <linux/module.h>

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

static inline int
update_match_cpu(unsigned int csig, unsigned int cpf,
		 unsigned int sig, unsigned int pf)
{
	return (!sigmatch(sig, csig, pf, cpf)) ? 0 : 1;
}

int
update_match_revision(struct microcode_header_intel *mc_header, int rev)
{
	return (mc_header->rev <= rev) ? 0 : 1;
}

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;
	int 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) {
		int ext_table_sum = 0;
		int *ext_tablep = (int *)ext_header;

		i = ext_table_size / DWSIZE;
		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) / DWSIZE;
	while (i--)
		orig_sum += ((int *)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);

/*
 * return 0 - no update found
 * return 1 - found update
 */
int get_matching_sig(unsigned int csig, int cpf, void *mc, int rev)
{
	struct microcode_header_intel *mc_header = mc;
	struct extended_sigtable *ext_header;
	unsigned long total_size = get_totalsize(mc_header);
	int ext_sigcount, i;
	struct extended_signature *ext_sig;

	if (update_match_cpu(csig, cpf, mc_header->sig, mc_header->pf))
		return 1;

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

	ext_header = mc + get_datasize(mc_header) + MC_HEADER_SIZE;
	ext_sigcount = ext_header->count;
	ext_sig = (void *)ext_header + EXT_HEADER_SIZE;

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

/*
 * return 0 - no update found
 * return 1 - found update
 */
int get_matching_microcode(unsigned int csig, int cpf, void *mc, int rev)
{
	struct microcode_header_intel *mc_header = mc;

	if (!update_match_revision(mc_header, rev))
		return 0;

	return get_matching_sig(csig, cpf, mc, rev);
}
EXPORT_SYMBOL_GPL(get_matching_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>
	28	#include <linux/module.h>
	29
	30	#include <asm/microcode_intel.h>
	31	#include <asm/processor.h>
	32	#include <asm/msr.h>
	33
	34	static inline int
	35	update_match_cpu(unsigned int csig, unsigned int cpf,
	36	unsigned int sig, unsigned int pf)
	37	{
	38	return (!sigmatch(sig, csig, pf, cpf)) ? 0 : 1;
	39	}
	40
	41	int
	42	update_match_revision(struct microcode_header_intel *mc_header, int rev)
	43	{
	44	return (mc_header->rev <= rev) ? 0 : 1;
	45	}
	46
	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;
	52	int sum, orig_sum, ext_sigcount = 0, i;
	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) {
88	int ext_table_sum = 0;
89	int ext_tablep = (int )ext_header;
90
91	i = ext_table_size / DWSIZE;
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;
103	i = (MC_HEADER_SIZE + data_size) / DWSIZE;
104	while (i--)
105	orig_sum += ((int *)mc)[i];
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	/*
131	* return 0 - no update found
132	* return 1 - found update
133	*/
134	int get_matching_sig(unsigned int csig, int cpf, void *mc, int rev)
135	{
136	struct microcode_header_intel *mc_header = mc;
137	struct extended_sigtable *ext_header;
138	unsigned long total_size = get_totalsize(mc_header);
139	int ext_sigcount, i;
140	struct extended_signature *ext_sig;
141
142	if (update_match_cpu(csig, cpf, mc_header->sig, mc_header->pf))
143	return 1;
144
145	/* Look for ext. headers: */
146	if (total_size <= get_datasize(mc_header) + MC_HEADER_SIZE)
147	return 0;
148
149	ext_header = mc + get_datasize(mc_header) + MC_HEADER_SIZE;
150	ext_sigcount = ext_header->count;
151	ext_sig = (void *)ext_header + EXT_HEADER_SIZE;
152
153	for (i = 0; i < ext_sigcount; i++) {
154	if (update_match_cpu(csig, cpf, ext_sig->sig, ext_sig->pf))
155	return 1;
156	ext_sig++;
157	}
158	return 0;
159	}
160
161	/*
162	* return 0 - no update found
163	* return 1 - found update
164	*/
165	int get_matching_microcode(unsigned int csig, int cpf, void *mc, int rev)
166	{
167	struct microcode_header_intel *mc_header = mc;
168
169	if (!update_match_revision(mc_header, rev))
170	return 0;
171
172	return get_matching_sig(csig, cpf, mc, rev);
173	}
174	EXPORT_SYMBOL_GPL(get_matching_microcode);