[mirror_ubuntu-zesty-kernel.git] / drivers / hwmon / hwmon-vid.c

/*
 * hwmon-vid.c - VID/VRM/VRD voltage conversions
 *
 * Copyright (c) 2004 Rudolf Marek <r.marek@assembler.cz>
 *
 * Partly imported from i2c-vid.h of the lm_sensors project
 * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
 * With assistance from Trent Piepho <xyzzy@speakeasy.org>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/hwmon-vid.h>

/*
 * Common code for decoding VID pins.
 *
 * References:
 *
 * For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
 * available at http://developer.intel.com/.
 *
 * For VRD 10.0 and up, "VRD x.y Design Guide",
 * available at http://developer.intel.com/.
 *
 * AMD Opteron processors don't follow the Intel specifications.
 * I'm going to "make up" 2.4 as the spec number for the Opterons.
 * No good reason just a mnemonic for the 24x Opteron processor
 * series.
 *
 * Opteron VID encoding is:
 *    00000  =  1.550 V
 *    00001  =  1.525 V
 *     . . . .
 *    11110  =  0.800 V
 *    11111  =  0.000 V (off)
 *
 * The 17 specification is in fact Intel Mobile Voltage Positioning -
 * (IMVP-II). You can find more information in the datasheet of Max1718
 * http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2452
 *
 * The 13 specification corresponds to the Intel Pentium M series. There
 * doesn't seem to be any named specification for these. The conversion
 * tables are detailed directly in the various Pentium M datasheets:
 * http://www.intel.com/design/intarch/pentiumm/docs_pentiumm.htm
 *
 * The 14 specification corresponds to Intel Core series. There
 * doesn't seem to be any named specification for these. The conversion
 * tables are detailed directly in the various Pentium Core datasheets:
 * http://www.intel.com/design/mobile/datashts/309221.htm
 *
 * The 110 (VRM 11) specification corresponds to Intel Conroe based series.
 * http://www.intel.com/design/processor/applnots/313214.htm
 */

/*
 * vrm is the VRM/VRD document version multiplied by 10.
 * val is the 4-bit or more VID code.
 * Returned value is in mV to avoid floating point in the kernel.
 * Some VID have some bits in uV scale, this is rounded to mV.
 */
int vid_from_reg(int val, u8 vrm)
{
	int vid;

	switch(vrm) {

	case 100:               /* VRD 10.0 */
		/* compute in uV, round to mV */
		val &= 0x3f;
		if((val & 0x1f) == 0x1f)
			return 0;
		if((val & 0x1f) <= 0x09 || val == 0x0a)
			vid = 1087500 - (val & 0x1f) * 25000;
		else
			vid = 1862500 - (val & 0x1f) * 25000;
		if(val & 0x20)
			vid -= 12500;
		return((vid + 500) / 1000);

	case 110:		/* Intel Conroe */
				/* compute in uV, round to mV */
		val &= 0xff;
		if (val < 0x02 || val > 0xb2)
			return 0;
		return((1600000 - (val - 2) * 6250 + 500) / 1000);
	case 24:                /* Opteron processor */
		val &= 0x1f;
		return(val == 0x1f ? 0 : 1550 - val * 25);

	case 91:		/* VRM 9.1 */
	case 90:		/* VRM 9.0 */
		val &= 0x1f;
		return(val == 0x1f ? 0 :
		                       1850 - val * 25);

	case 85:		/* VRM 8.5 */
		val &= 0x1f;
		return((val & 0x10  ? 25 : 0) +
		       ((val & 0x0f) > 0x04 ? 2050 : 1250) -
		       ((val & 0x0f) * 50));

	case 84:		/* VRM 8.4 */
		val &= 0x0f;
				/* fall through */
	case 82:		/* VRM 8.2 */
		val &= 0x1f;
		return(val == 0x1f ? 0 :
		       val & 0x10  ? 5100 - (val) * 100 :
		                     2050 - (val) * 50);
	case 17:		/* Intel IMVP-II */
		val &= 0x1f;
		return(val & 0x10 ? 975 - (val & 0xF) * 25 :
				    1750 - val * 50);
	case 13:
		val &= 0x3f;
		return(1708 - val * 16);
	case 14:		/* Intel Core */
				/* compute in uV, round to mV */
		val &= 0x7f;
		return(val > 0x77 ? 0 : (1500000 - (val * 12500) + 500) / 1000);
	default:		/* report 0 for unknown */
		if (vrm)
			printk(KERN_WARNING "hwmon-vid: Requested unsupported "
			       "VRM version (%u)\n", (unsigned int)vrm);
		return 0;
	}
}


/*
 * After this point is the code to automatically determine which
 * VRM/VRD specification should be used depending on the CPU.
 */

struct vrm_model {
	u8 vendor;
	u8 eff_family;
	u8 eff_model;
	u8 eff_stepping;
	u8 vrm_type;
};

#define ANY 0xFF

#ifdef CONFIG_X86

/* the stepping parameter is highest acceptable stepping for current line */

static struct vrm_model vrm_models[] = {
	{X86_VENDOR_AMD, 0x6, ANY, ANY, 90},		/* Athlon Duron etc */
	{X86_VENDOR_AMD, 0xF, ANY, ANY, 24},		/* Athlon 64, Opteron and above VRM 24 */
	{X86_VENDOR_INTEL, 0x6, 0x9, ANY, 13},		/* Pentium M (130 nm) */
	{X86_VENDOR_INTEL, 0x6, 0xB, ANY, 85},		/* Tualatin */
	{X86_VENDOR_INTEL, 0x6, 0xD, ANY, 13},		/* Pentium M (90 nm) */
	{X86_VENDOR_INTEL, 0x6, 0xE, ANY, 14},		/* Intel Core (65 nm) */
	{X86_VENDOR_INTEL, 0x6, 0xF, ANY, 110},		/* Intel Conroe */
	{X86_VENDOR_INTEL, 0x6, ANY, ANY, 82},		/* any P6 */
	{X86_VENDOR_INTEL, 0xF, 0x0, ANY, 90},		/* P4 */
	{X86_VENDOR_INTEL, 0xF, 0x1, ANY, 90},		/* P4 Willamette */
	{X86_VENDOR_INTEL, 0xF, 0x2, ANY, 90},		/* P4 Northwood */
	{X86_VENDOR_INTEL, 0xF, ANY, ANY, 100},		/* Prescott and above assume VRD 10 */
	{X86_VENDOR_CENTAUR, 0x6, 0x7, ANY, 85},	/* Eden ESP/Ezra */
	{X86_VENDOR_CENTAUR, 0x6, 0x8, 0x7, 85},	/* Ezra T */
	{X86_VENDOR_CENTAUR, 0x6, 0x9, 0x7, 85},	/* Nemiah */
	{X86_VENDOR_CENTAUR, 0x6, 0x9, ANY, 17},	/* C3-M, Eden-N */
	{X86_VENDOR_CENTAUR, 0x6, 0xA, 0x7, 0},		/* No information */
	{X86_VENDOR_CENTAUR, 0x6, 0xA, ANY, 13},	/* C7, Esther */
	{X86_VENDOR_UNKNOWN, ANY, ANY, ANY, 0}		/* stop here */
};

static u8 find_vrm(u8 eff_family, u8 eff_model, u8 eff_stepping, u8 vendor)
{
	int i = 0;

	while (vrm_models[i].vendor!=X86_VENDOR_UNKNOWN) {
		if (vrm_models[i].vendor==vendor)
			if ((vrm_models[i].eff_family==eff_family)
			 && ((vrm_models[i].eff_model==eff_model) ||
			     (vrm_models[i].eff_model==ANY)) &&
			     (eff_stepping <= vrm_models[i].eff_stepping))
				return vrm_models[i].vrm_type;
		i++;
	}

	return 0;
}

u8 vid_which_vrm(void)
{
	struct cpuinfo_x86 *c = &cpu_data(0);
	u32 eax;
	u8 eff_family, eff_model, eff_stepping, vrm_ret;

	if (c->x86 < 6)		/* Any CPU with family lower than 6 */
		return 0;	/* doesn't have VID and/or CPUID */

	eax = cpuid_eax(1);
	eff_family = ((eax & 0x00000F00)>>8);
	eff_model  = ((eax & 0x000000F0)>>4);
	eff_stepping = eax & 0xF;
	if (eff_family == 0xF) {	/* use extended model & family */
		eff_family += ((eax & 0x00F00000)>>20);
		eff_model += ((eax & 0x000F0000)>>16)<<4;
	}
	vrm_ret = find_vrm(eff_family, eff_model, eff_stepping, c->x86_vendor);
	if (vrm_ret == 0)
		printk(KERN_INFO "hwmon-vid: Unknown VRM version of your "
		       "x86 CPU\n");
	return vrm_ret;
}

/* and now for something completely different for the non-x86 world */
#else
u8 vid_which_vrm(void)
{
	printk(KERN_INFO "hwmon-vid: Unknown VRM version of your CPU\n");
	return 0;
}
#endif

EXPORT_SYMBOL(vid_from_reg);
EXPORT_SYMBOL(vid_which_vrm);

MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>");

MODULE_DESCRIPTION("hwmon-vid driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4	1	/*
15872212 FM	2	* hwmon-vid.c - VID/VRM/VRD voltage conversions
	3	*
	4	* Copyright (c) 2004 Rudolf Marek <r.marek@assembler.cz>
	5	*
	6	* Partly imported from i2c-vid.h of the lm_sensors project
	7	* Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
	8	* With assistance from Trent Piepho <xyzzy@speakeasy.org>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	23	*/
1da177e4	24
1da177e4 LT	25	#include <linux/module.h>
1da177e4 LT	26	#include <linux/kernel.h>
303760b4	27	#include <linux/hwmon-vid.h>
1da177e4	28
d0f28270	29	/*
15872212 FM	30	* Common code for decoding VID pins.
	31	*
	32	* References:
	33	*
	34	* For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
	35	* available at http://developer.intel.com/.
	36	*
	37	* For VRD 10.0 and up, "VRD x.y Design Guide",
	38	* available at http://developer.intel.com/.
	39	*
	40	* AMD Opteron processors don't follow the Intel specifications.
	41	* I'm going to "make up" 2.4 as the spec number for the Opterons.
	42	* No good reason just a mnemonic for the 24x Opteron processor
	43	* series.
	44	*
	45	* Opteron VID encoding is:
	46	* 00000 = 1.550 V
	47	* 00001 = 1.525 V
	48	* . . . .
	49	* 11110 = 0.800 V
	50	* 11111 = 0.000 V (off)
	51	*
	52	* The 17 specification is in fact Intel Mobile Voltage Positioning -
	53	* (IMVP-II). You can find more information in the datasheet of Max1718
	54	* http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2452
	55	*
	56	* The 13 specification corresponds to the Intel Pentium M series. There
	57	* doesn't seem to be any named specification for these. The conversion
	58	* tables are detailed directly in the various Pentium M datasheets:
	59	* http://www.intel.com/design/intarch/pentiumm/docs_pentiumm.htm
	60	*
	61	* The 14 specification corresponds to Intel Core series. There
	62	* doesn't seem to be any named specification for these. The conversion
	63	* tables are detailed directly in the various Pentium Core datasheets:
	64	* http://www.intel.com/design/mobile/datashts/309221.htm
	65	*
	66	* The 110 (VRM 11) specification corresponds to Intel Conroe based series.
	67	* http://www.intel.com/design/processor/applnots/313214.htm
	68	*/
	69
	70	/*
	71	* vrm is the VRM/VRD document version multiplied by 10.
	72	* val is the 4-bit or more VID code.
	73	* Returned value is in mV to avoid floating point in the kernel.
	74	* Some VID have some bits in uV scale, this is rounded to mV.
	75	*/
734a12a3	76	int vid_from_reg(int val, u8 vrm)
d0f28270 JD	77	{
	78	int vid;
	79
	80	switch(vrm) {
	81
d0f28270	82	case 100: /* VRD 10.0 */
6af586dc	83	/* compute in uV, round to mV */
177d165d	84	val &= 0x3f;
d0f28270 JD	85	if((val & 0x1f) == 0x1f)
	86	return 0;
	87	if((val & 0x1f) <= 0x09 \|\| val == 0x0a)
6af586dc	88	vid = 1087500 - (val & 0x1f) * 25000;
d0f28270	89	else
6af586dc	90	vid = 1862500 - (val & 0x1f) * 25000;
d0f28270	91	if(val & 0x20)
6af586dc RM	92	vid -= 12500;
6af586dc RM	93	return((vid + 500) / 1000);
d0f28270	94
6af586dc RM	95	case 110: /* Intel Conroe */
	96	/* compute in uV, round to mV */
	97	val &= 0xff;
9fab2d8b	98	if (val < 0x02 \|\| val > 0xb2)
6af586dc RM	99	return 0;
6af586dc RM	100	return((1600000 - (val - 2) * 6250 + 500) / 1000);
d0f28270	101	case 24: /* Opteron processor */
177d165d	102	val &= 0x1f;
d0f28270 JD	103	return(val == 0x1f ? 0 : 1550 - val * 25);
	104
	105	case 91: /* VRM 9.1 */
	106	case 90: /* VRM 9.0 */
177d165d	107	val &= 0x1f;
d0f28270 JD	108	return(val == 0x1f ? 0 :
	109	1850 - val * 25);
	110
	111	case 85: /* VRM 8.5 */
177d165d	112	val &= 0x1f;
d0f28270 JD	113	return((val & 0x10 ? 25 : 0) +
	114	((val & 0x0f) > 0x04 ? 2050 : 1250) -
	115	((val & 0x0f) * 50));
	116
	117	case 84: /* VRM 8.4 */
	118	val &= 0x0f;
	119	/* fall through */
734a12a3	120	case 82: /* VRM 8.2 */
177d165d	121	val &= 0x1f;
d0f28270 JD	122	return(val == 0x1f ? 0 :
	123	val & 0x10 ? 5100 - (val) * 100 :
	124	2050 - (val) * 50);
734a12a3	125	case 17: /* Intel IMVP-II */
177d165d	126	val &= 0x1f;
734a12a3 RM	127	return(val & 0x10 ? 975 - (val & 0xF) * 25 :
734a12a3 RM	128	1750 - val * 50);
4c537fb2	129	case 13:
177d165d RM	130	val &= 0x3f;
177d165d RM	131	return(1708 - val * 16);
6af586dc RM	132	case 14: /* Intel Core */
	133	/* compute in uV, round to mV */
	134	val &= 0x7f;
	135	return(val > 0x77 ? 0 : (1500000 - (val * 12500) + 500) / 1000);
734a12a3	136	default: /* report 0 for unknown */
45f2acc4 JD	137	if (vrm)
	138	printk(KERN_WARNING "hwmon-vid: Requested unsupported "
	139	"VRM version (%u)\n", (unsigned int)vrm);
734a12a3	140	return 0;
d0f28270 JD	141	}
	142	}
	143
	144
	145	/*
15872212 FM	146	* After this point is the code to automatically determine which
	147	* VRM/VRD specification should be used depending on the CPU.
	148	*/
d0f28270	149
1da177e4 LT	150	struct vrm_model {
	151	u8 vendor;
	152	u8 eff_family;
	153	u8 eff_model;
734a12a3 RM	154	u8 eff_stepping;
734a12a3 RM	155	u8 vrm_type;
1da177e4 LT	156	};
	157
	158	#define ANY 0xFF
	159
	160	#ifdef CONFIG_X86
	161
734a12a3 RM	162	/* the stepping parameter is highest acceptable stepping for current line */
734a12a3 RM	163
1da177e4	164	static struct vrm_model vrm_models[] = {
734a12a3 RM	165	{X86_VENDOR_AMD, 0x6, ANY, ANY, 90}, /* Athlon Duron etc */
734a12a3 RM	166	{X86_VENDOR_AMD, 0xF, ANY, ANY, 24}, /* Athlon 64, Opteron and above VRM 24 */
4c537fb2	167	{X86_VENDOR_INTEL, 0x6, 0x9, ANY, 13}, /* Pentium M (130 nm) */
734a12a3	168	{X86_VENDOR_INTEL, 0x6, 0xB, ANY, 85}, /* Tualatin */
4c537fb2	169	{X86_VENDOR_INTEL, 0x6, 0xD, ANY, 13}, /* Pentium M (90 nm) */
6af586dc RM	170	{X86_VENDOR_INTEL, 0x6, 0xE, ANY, 14}, /* Intel Core (65 nm) */
6af586dc RM	171	{X86_VENDOR_INTEL, 0x6, 0xF, ANY, 110}, /* Intel Conroe */
734a12a3	172	{X86_VENDOR_INTEL, 0x6, ANY, ANY, 82}, /* any P6 */
734a12a3 RM	173	{X86_VENDOR_INTEL, 0xF, 0x0, ANY, 90}, /* P4 */
	174	{X86_VENDOR_INTEL, 0xF, 0x1, ANY, 90}, /* P4 Willamette */
	175	{X86_VENDOR_INTEL, 0xF, 0x2, ANY, 90}, /* P4 Northwood */
	176	{X86_VENDOR_INTEL, 0xF, ANY, ANY, 100}, /* Prescott and above assume VRD 10 */
734a12a3 RM	177	{X86_VENDOR_CENTAUR, 0x6, 0x7, ANY, 85}, /* Eden ESP/Ezra */
	178	{X86_VENDOR_CENTAUR, 0x6, 0x8, 0x7, 85}, /* Ezra T */
	179	{X86_VENDOR_CENTAUR, 0x6, 0x9, 0x7, 85}, /* Nemiah */
e46751bf RM	180	{X86_VENDOR_CENTAUR, 0x6, 0x9, ANY, 17}, /* C3-M, Eden-N */
	181	{X86_VENDOR_CENTAUR, 0x6, 0xA, 0x7, 0}, /* No information */
	182	{X86_VENDOR_CENTAUR, 0x6, 0xA, ANY, 13}, /* C7, Esther */
734a12a3	183	{X86_VENDOR_UNKNOWN, ANY, ANY, ANY, 0} /* stop here */
da97a5a3	184	};
1da177e4	185
734a12a3	186	static u8 find_vrm(u8 eff_family, u8 eff_model, u8 eff_stepping, u8 vendor)
1da177e4 LT	187	{
	188	int i = 0;
	189
	190	while (vrm_models[i].vendor!=X86_VENDOR_UNKNOWN) {
	191	if (vrm_models[i].vendor==vendor)
da97a5a3 JD	192	if ((vrm_models[i].eff_family==eff_family)
da97a5a3 JD	193	&& ((vrm_models[i].eff_model==eff_model) \|\|
734a12a3 RM	194	(vrm_models[i].eff_model==ANY)) &&
734a12a3 RM	195	(eff_stepping <= vrm_models[i].eff_stepping))
1da177e4 LT	196	return vrm_models[i].vrm_type;
	197	i++;
	198	}
	199
	200	return 0;
	201	}
	202
734a12a3	203	u8 vid_which_vrm(void)
1da177e4	204	{
92cb7612	205	struct cpuinfo_x86 *c = &cpu_data(0);
1da177e4	206	u32 eax;
734a12a3	207	u8 eff_family, eff_model, eff_stepping, vrm_ret;
1da177e4	208
da97a5a3 JD	209	if (c->x86 < 6) /* Any CPU with family lower than 6 */
	210	return 0; /* doesn't have VID and/or CPUID */
	211
1da177e4 LT	212	eax = cpuid_eax(1);
	213	eff_family = ((eax & 0x00000F00)>>8);
	214	eff_model = ((eax & 0x000000F0)>>4);
734a12a3	215	eff_stepping = eax & 0xF;
1da177e4 LT	216	if (eff_family == 0xF) { /* use extended model & family */
	217	eff_family += ((eax & 0x00F00000)>>20);
	218	eff_model += ((eax & 0x000F0000)>>16)<<4;
	219	}
734a12a3	220	vrm_ret = find_vrm(eff_family, eff_model, eff_stepping, c->x86_vendor);
1da177e4	221	if (vrm_ret == 0)
da97a5a3 JD	222	printk(KERN_INFO "hwmon-vid: Unknown VRM version of your "
da97a5a3 JD	223	"x86 CPU\n");
1da177e4 LT	224	return vrm_ret;
	225	}
	226
734a12a3	227	/* and now for something completely different for the non-x86 world */
1da177e4	228	#else
734a12a3	229	u8 vid_which_vrm(void)
1da177e4	230	{
303760b4	231	printk(KERN_INFO "hwmon-vid: Unknown VRM version of your CPU\n");
1da177e4 LT	232	return 0;
	233	}
	234	#endif
	235
d0f28270	236	EXPORT_SYMBOL(vid_from_reg);
303760b4	237	EXPORT_SYMBOL(vid_which_vrm);
96478ef3	238
7188cc66	239	MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>");
96478ef3	240
303760b4	241	MODULE_DESCRIPTION("hwmon-vid driver");
96478ef3	242	MODULE_LICENSE("GPL");