Removed PF_SYNCTHREAD legacy.
[linux-2.6] / drivers / hwmon / hwmon-vid.c
1 /*
2     hwmon-vid.c - VID/VRM/VRD voltage conversions
3
4     Copyright (c) 2004 Rudolf Marek <r.marek@sh.cvut.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 */
24
25 #include <linux/config.h>
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/hwmon-vid.h>
29
30 /*
31     Common code for decoding VID pins.
32
33     References:
34
35     For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
36     available at http://developer.intel.com/.
37
38     For VRD 10.0 and up, "VRD x.y Design Guide",
39     available at http://developer.intel.com/.
40
41     AMD Opteron processors don't follow the Intel specifications.
42     I'm going to "make up" 2.4 as the spec number for the Opterons.
43     No good reason just a mnemonic for the 24x Opteron processor
44     series.
45
46     Opteron VID encoding is:
47        00000  =  1.550 V
48        00001  =  1.525 V
49         . . . .
50        11110  =  0.800 V
51        11111  =  0.000 V (off)
52 */
53
54 /* vrm is the VRM/VRD document version multiplied by 10.
55    val is the 4-, 5- or 6-bit VID code.
56    Returned value is in mV to avoid floating point in the kernel. */
57 int vid_from_reg(int val, int vrm)
58 {
59         int vid;
60
61         switch(vrm) {
62
63         case  0:
64                 return 0;
65
66         case 100:               /* VRD 10.0 */
67                 if((val & 0x1f) == 0x1f)
68                         return 0;
69                 if((val & 0x1f) <= 0x09 || val == 0x0a)
70                         vid = 10875 - (val & 0x1f) * 250;
71                 else
72                         vid = 18625 - (val & 0x1f) * 250;
73                 if(val & 0x20)
74                         vid -= 125;
75                 vid /= 10;      /* only return 3 dec. places for now */
76                 return vid;
77
78         case 24:                /* Opteron processor */
79                 return(val == 0x1f ? 0 : 1550 - val * 25);
80
81         case 91:                /* VRM 9.1 */
82         case 90:                /* VRM 9.0 */
83                 return(val == 0x1f ? 0 :
84                                        1850 - val * 25);
85
86         case 85:                /* VRM 8.5 */
87                 return((val & 0x10  ? 25 : 0) +
88                        ((val & 0x0f) > 0x04 ? 2050 : 1250) -
89                        ((val & 0x0f) * 50));
90
91         case 84:                /* VRM 8.4 */
92                 val &= 0x0f;
93                                 /* fall through */
94         default:                /* VRM 8.2 */
95                 return(val == 0x1f ? 0 :
96                        val & 0x10  ? 5100 - (val) * 100 :
97                                      2050 - (val) * 50);
98         }
99 }
100
101
102 /*
103     After this point is the code to automatically determine which
104     VRM/VRD specification should be used depending on the CPU.
105 */
106
107 struct vrm_model {
108         u8 vendor;
109         u8 eff_family;
110         u8 eff_model;
111         int vrm_type;
112 };
113
114 #define ANY 0xFF
115
116 #ifdef CONFIG_X86
117
118 static struct vrm_model vrm_models[] = {
119         {X86_VENDOR_AMD, 0x6, ANY, 90},         /* Athlon Duron etc */
120         {X86_VENDOR_AMD, 0xF, ANY, 24},         /* Athlon 64, Opteron */
121         {X86_VENDOR_INTEL, 0x6, 0x9, 85},       /* 0.13um too */
122         {X86_VENDOR_INTEL, 0x6, 0xB, 85},       /* Tualatin */
123         {X86_VENDOR_INTEL, 0x6, ANY, 82},       /* any P6 */
124         {X86_VENDOR_INTEL, 0x7, ANY, 0},        /* Itanium */
125         {X86_VENDOR_INTEL, 0xF, 0x0, 90},       /* P4 */
126         {X86_VENDOR_INTEL, 0xF, 0x1, 90},       /* P4 Willamette */
127         {X86_VENDOR_INTEL, 0xF, 0x2, 90},       /* P4 Northwood */
128         {X86_VENDOR_INTEL, 0xF, 0x3, 100},      /* P4 Prescott */
129         {X86_VENDOR_INTEL, 0xF, 0x4, 100},      /* P4 Prescott */
130         {X86_VENDOR_INTEL, 0x10,ANY, 0},        /* Itanium 2 */
131         {X86_VENDOR_UNKNOWN, ANY, ANY, 0}       /* stop here */
132 };
133
134 static int find_vrm(u8 eff_family, u8 eff_model, u8 vendor)
135 {
136         int i = 0;
137
138         while (vrm_models[i].vendor!=X86_VENDOR_UNKNOWN) {
139                 if (vrm_models[i].vendor==vendor)
140                         if ((vrm_models[i].eff_family==eff_family)
141                          && ((vrm_models[i].eff_model==eff_model) ||
142                              (vrm_models[i].eff_model==ANY)))
143                                 return vrm_models[i].vrm_type;
144                 i++;
145         }
146
147         return 0;
148 }
149
150 int vid_which_vrm(void)
151 {
152         struct cpuinfo_x86 *c = cpu_data;
153         u32 eax;
154         u8 eff_family, eff_model;
155         int vrm_ret;
156
157         if (c->x86 < 6)         /* Any CPU with family lower than 6 */
158                 return 0;       /* doesn't have VID and/or CPUID */
159
160         eax = cpuid_eax(1);
161         eff_family = ((eax & 0x00000F00)>>8);
162         eff_model  = ((eax & 0x000000F0)>>4);
163         if (eff_family == 0xF) {        /* use extended model & family */
164                 eff_family += ((eax & 0x00F00000)>>20);
165                 eff_model += ((eax & 0x000F0000)>>16)<<4;
166         }
167         vrm_ret = find_vrm(eff_family,eff_model,c->x86_vendor);
168         if (vrm_ret == 0)
169                 printk(KERN_INFO "hwmon-vid: Unknown VRM version of your "
170                        "x86 CPU\n");
171         return vrm_ret;
172 }
173
174 /* and now something completely different for the non-x86 world */
175 #else
176 int vid_which_vrm(void)
177 {
178         printk(KERN_INFO "hwmon-vid: Unknown VRM version of your CPU\n");
179         return 0;
180 }
181 #endif
182
183 EXPORT_SYMBOL(vid_from_reg);
184 EXPORT_SYMBOL(vid_which_vrm);
185
186 MODULE_AUTHOR("Rudolf Marek <r.marek@sh.cvut.cz>");
187
188 MODULE_DESCRIPTION("hwmon-vid driver");
189 MODULE_LICENSE("GPL");