Commit | Line | Data |
---|---|---|
29fa06c1 RM |
1 | /* |
2 | * k8temp.c - Linux kernel module for hardware monitoring | |
3 | * | |
7188cc66 | 4 | * Copyright (C) 2006 Rudolf Marek <r.marek@assembler.cz> |
29fa06c1 RM |
5 | * |
6 | * Inspired from the w83785 and amd756 drivers. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
21 | * 02110-1301 USA. | |
22 | */ | |
23 | ||
24 | #include <linux/module.h> | |
25 | #include <linux/delay.h> | |
26 | #include <linux/init.h> | |
27 | #include <linux/slab.h> | |
28 | #include <linux/jiffies.h> | |
29 | #include <linux/pci.h> | |
30 | #include <linux/hwmon.h> | |
31 | #include <linux/hwmon-sysfs.h> | |
32 | #include <linux/err.h> | |
33 | #include <linux/mutex.h> | |
bb9a35f2 | 34 | #include <asm/processor.h> |
29fa06c1 RM |
35 | |
36 | #define TEMP_FROM_REG(val) (((((val) >> 16) & 0xff) - 49) * 1000) | |
37 | #define REG_TEMP 0xe4 | |
38 | #define SEL_PLACE 0x40 | |
39 | #define SEL_CORE 0x04 | |
40 | ||
41 | struct k8temp_data { | |
1beeffe4 | 42 | struct device *hwmon_dev; |
29fa06c1 RM |
43 | struct mutex update_lock; |
44 | const char *name; | |
45 | char valid; /* zero until following fields are valid */ | |
46 | unsigned long last_updated; /* in jiffies */ | |
47 | ||
48 | /* registers values */ | |
49 | u8 sensorsp; /* sensor presence bits - SEL_CORE & SEL_PLACE */ | |
50 | u32 temp[2][2]; /* core, place */ | |
a2e066bb | 51 | u8 swap_core_select; /* meaning of SEL_CORE is inverted */ |
76ff08da | 52 | u32 temp_offset; |
29fa06c1 RM |
53 | }; |
54 | ||
55 | static struct k8temp_data *k8temp_update_device(struct device *dev) | |
56 | { | |
57 | struct k8temp_data *data = dev_get_drvdata(dev); | |
58 | struct pci_dev *pdev = to_pci_dev(dev); | |
59 | u8 tmp; | |
60 | ||
61 | mutex_lock(&data->update_lock); | |
62 | ||
63 | if (!data->valid | |
64 | || time_after(jiffies, data->last_updated + HZ)) { | |
65 | pci_read_config_byte(pdev, REG_TEMP, &tmp); | |
66 | tmp &= ~(SEL_PLACE | SEL_CORE); /* Select sensor 0, core0 */ | |
67 | pci_write_config_byte(pdev, REG_TEMP, tmp); | |
68 | pci_read_config_dword(pdev, REG_TEMP, &data->temp[0][0]); | |
69 | ||
70 | if (data->sensorsp & SEL_PLACE) { | |
71 | tmp |= SEL_PLACE; /* Select sensor 1, core0 */ | |
72 | pci_write_config_byte(pdev, REG_TEMP, tmp); | |
73 | pci_read_config_dword(pdev, REG_TEMP, | |
74 | &data->temp[0][1]); | |
75 | } | |
76 | ||
77 | if (data->sensorsp & SEL_CORE) { | |
78 | tmp &= ~SEL_PLACE; /* Select sensor 0, core1 */ | |
79 | tmp |= SEL_CORE; | |
80 | pci_write_config_byte(pdev, REG_TEMP, tmp); | |
81 | pci_read_config_dword(pdev, REG_TEMP, | |
82 | &data->temp[1][0]); | |
83 | ||
84 | if (data->sensorsp & SEL_PLACE) { | |
85 | tmp |= SEL_PLACE; /* Select sensor 1, core1 */ | |
86 | pci_write_config_byte(pdev, REG_TEMP, tmp); | |
87 | pci_read_config_dword(pdev, REG_TEMP, | |
88 | &data->temp[1][1]); | |
89 | } | |
90 | } | |
91 | ||
92 | data->last_updated = jiffies; | |
93 | data->valid = 1; | |
94 | } | |
95 | ||
96 | mutex_unlock(&data->update_lock); | |
97 | return data; | |
98 | } | |
99 | ||
100 | /* | |
101 | * Sysfs stuff | |
102 | */ | |
103 | ||
104 | static ssize_t show_name(struct device *dev, struct device_attribute | |
105 | *devattr, char *buf) | |
106 | { | |
107 | struct k8temp_data *data = dev_get_drvdata(dev); | |
108 | ||
109 | return sprintf(buf, "%s\n", data->name); | |
110 | } | |
111 | ||
112 | ||
113 | static ssize_t show_temp(struct device *dev, | |
114 | struct device_attribute *devattr, char *buf) | |
115 | { | |
116 | struct sensor_device_attribute_2 *attr = | |
117 | to_sensor_dev_attr_2(devattr); | |
118 | int core = attr->nr; | |
119 | int place = attr->index; | |
76ff08da | 120 | int temp; |
29fa06c1 RM |
121 | struct k8temp_data *data = k8temp_update_device(dev); |
122 | ||
a2e066bb AH |
123 | if (data->swap_core_select) |
124 | core = core ? 0 : 1; | |
125 | ||
76ff08da AH |
126 | temp = TEMP_FROM_REG(data->temp[core][place]) + data->temp_offset; |
127 | ||
128 | return sprintf(buf, "%d\n", temp); | |
29fa06c1 RM |
129 | } |
130 | ||
131 | /* core, place */ | |
132 | ||
133 | static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0); | |
134 | static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0, 1); | |
135 | static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 1, 0); | |
136 | static SENSOR_DEVICE_ATTR_2(temp4_input, S_IRUGO, show_temp, NULL, 1, 1); | |
137 | static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); | |
138 | ||
139 | static struct pci_device_id k8temp_ids[] = { | |
140 | { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_K8_NB_MISC) }, | |
141 | { 0 }, | |
142 | }; | |
143 | ||
b17ebc94 JD |
144 | MODULE_DEVICE_TABLE(pci, k8temp_ids); |
145 | ||
29fa06c1 RM |
146 | static int __devinit k8temp_probe(struct pci_dev *pdev, |
147 | const struct pci_device_id *id) | |
148 | { | |
149 | int err; | |
150 | u8 scfg; | |
151 | u32 temp; | |
bb9a35f2 | 152 | u8 model, stepping; |
29fa06c1 | 153 | struct k8temp_data *data; |
29fa06c1 RM |
154 | |
155 | if (!(data = kzalloc(sizeof(struct k8temp_data), GFP_KERNEL))) { | |
156 | err = -ENOMEM; | |
157 | goto exit; | |
158 | } | |
159 | ||
bb9a35f2 AH |
160 | model = boot_cpu_data.x86_model; |
161 | stepping = boot_cpu_data.x86_mask; | |
162 | ||
163 | switch (boot_cpu_data.x86) { | |
164 | case 0xf: | |
165 | /* feature available since SH-C0, exclude older revisions */ | |
166 | if (((model == 4) && (stepping == 0)) || | |
167 | ((model == 5) && (stepping <= 1))) { | |
168 | err = -ENODEV; | |
169 | goto exit_free; | |
170 | } | |
171 | ||
a2e066bb AH |
172 | /* |
173 | * AMD NPT family 0fh, i.e. RevF and RevG: | |
174 | * meaning of SEL_CORE bit is inverted | |
175 | */ | |
bb9a35f2 | 176 | if (model >= 0x40) { |
a2e066bb | 177 | data->swap_core_select = 1; |
bb9a35f2 AH |
178 | dev_warn(&pdev->dev, "Temperature readouts might be " |
179 | "wrong - check erratum #141\n"); | |
180 | } | |
181 | ||
76ff08da AH |
182 | if ((model >= 0x69) && |
183 | !(model == 0xc1 || model == 0x6c || model == 0x7c)) { | |
184 | /* | |
185 | * RevG desktop CPUs (i.e. no socket S1G1 parts) | |
186 | * need additional offset, otherwise reported | |
187 | * temperature is below ambient temperature | |
188 | */ | |
189 | data->temp_offset = 21000; | |
190 | } | |
191 | ||
bb9a35f2 AH |
192 | break; |
193 | } | |
194 | ||
29fa06c1 RM |
195 | pci_read_config_byte(pdev, REG_TEMP, &scfg); |
196 | scfg &= ~(SEL_PLACE | SEL_CORE); /* Select sensor 0, core0 */ | |
197 | pci_write_config_byte(pdev, REG_TEMP, scfg); | |
198 | pci_read_config_byte(pdev, REG_TEMP, &scfg); | |
199 | ||
200 | if (scfg & (SEL_PLACE | SEL_CORE)) { | |
201 | dev_err(&pdev->dev, "Configuration bit(s) stuck at 1!\n"); | |
202 | err = -ENODEV; | |
203 | goto exit_free; | |
204 | } | |
205 | ||
206 | scfg |= (SEL_PLACE | SEL_CORE); | |
207 | pci_write_config_byte(pdev, REG_TEMP, scfg); | |
208 | ||
209 | /* now we know if we can change core and/or sensor */ | |
210 | pci_read_config_byte(pdev, REG_TEMP, &data->sensorsp); | |
211 | ||
212 | if (data->sensorsp & SEL_PLACE) { | |
213 | scfg &= ~SEL_CORE; /* Select sensor 1, core0 */ | |
214 | pci_write_config_byte(pdev, REG_TEMP, scfg); | |
215 | pci_read_config_dword(pdev, REG_TEMP, &temp); | |
216 | scfg |= SEL_CORE; /* prepare for next selection */ | |
217 | if (!((temp >> 16) & 0xff)) /* if temp is 0 -49C is not likely */ | |
218 | data->sensorsp &= ~SEL_PLACE; | |
219 | } | |
220 | ||
221 | if (data->sensorsp & SEL_CORE) { | |
222 | scfg &= ~SEL_PLACE; /* Select sensor 0, core1 */ | |
223 | pci_write_config_byte(pdev, REG_TEMP, scfg); | |
224 | pci_read_config_dword(pdev, REG_TEMP, &temp); | |
225 | if (!((temp >> 16) & 0xff)) /* if temp is 0 -49C is not likely */ | |
226 | data->sensorsp &= ~SEL_CORE; | |
227 | } | |
228 | ||
229 | data->name = "k8temp"; | |
230 | mutex_init(&data->update_lock); | |
231 | dev_set_drvdata(&pdev->dev, data); | |
232 | ||
233 | /* Register sysfs hooks */ | |
234 | err = device_create_file(&pdev->dev, | |
235 | &sensor_dev_attr_temp1_input.dev_attr); | |
236 | if (err) | |
237 | goto exit_remove; | |
238 | ||
239 | /* sensor can be changed and reports something */ | |
240 | if (data->sensorsp & SEL_PLACE) { | |
241 | err = device_create_file(&pdev->dev, | |
242 | &sensor_dev_attr_temp2_input.dev_attr); | |
243 | if (err) | |
244 | goto exit_remove; | |
245 | } | |
246 | ||
247 | /* core can be changed and reports something */ | |
248 | if (data->sensorsp & SEL_CORE) { | |
249 | err = device_create_file(&pdev->dev, | |
250 | &sensor_dev_attr_temp3_input.dev_attr); | |
251 | if (err) | |
252 | goto exit_remove; | |
253 | if (data->sensorsp & SEL_PLACE) | |
254 | err = device_create_file(&pdev->dev, | |
255 | &sensor_dev_attr_temp4_input. | |
256 | dev_attr); | |
257 | if (err) | |
258 | goto exit_remove; | |
259 | } | |
260 | ||
261 | err = device_create_file(&pdev->dev, &dev_attr_name); | |
262 | if (err) | |
263 | goto exit_remove; | |
264 | ||
1beeffe4 | 265 | data->hwmon_dev = hwmon_device_register(&pdev->dev); |
29fa06c1 | 266 | |
1beeffe4 TJ |
267 | if (IS_ERR(data->hwmon_dev)) { |
268 | err = PTR_ERR(data->hwmon_dev); | |
29fa06c1 RM |
269 | goto exit_remove; |
270 | } | |
271 | ||
272 | return 0; | |
273 | ||
274 | exit_remove: | |
275 | device_remove_file(&pdev->dev, | |
276 | &sensor_dev_attr_temp1_input.dev_attr); | |
277 | device_remove_file(&pdev->dev, | |
278 | &sensor_dev_attr_temp2_input.dev_attr); | |
279 | device_remove_file(&pdev->dev, | |
280 | &sensor_dev_attr_temp3_input.dev_attr); | |
281 | device_remove_file(&pdev->dev, | |
282 | &sensor_dev_attr_temp4_input.dev_attr); | |
283 | device_remove_file(&pdev->dev, &dev_attr_name); | |
284 | exit_free: | |
285 | dev_set_drvdata(&pdev->dev, NULL); | |
286 | kfree(data); | |
287 | exit: | |
288 | return err; | |
289 | } | |
290 | ||
291 | static void __devexit k8temp_remove(struct pci_dev *pdev) | |
292 | { | |
293 | struct k8temp_data *data = dev_get_drvdata(&pdev->dev); | |
294 | ||
1beeffe4 | 295 | hwmon_device_unregister(data->hwmon_dev); |
29fa06c1 RM |
296 | device_remove_file(&pdev->dev, |
297 | &sensor_dev_attr_temp1_input.dev_attr); | |
298 | device_remove_file(&pdev->dev, | |
299 | &sensor_dev_attr_temp2_input.dev_attr); | |
300 | device_remove_file(&pdev->dev, | |
301 | &sensor_dev_attr_temp3_input.dev_attr); | |
302 | device_remove_file(&pdev->dev, | |
303 | &sensor_dev_attr_temp4_input.dev_attr); | |
304 | device_remove_file(&pdev->dev, &dev_attr_name); | |
305 | dev_set_drvdata(&pdev->dev, NULL); | |
306 | kfree(data); | |
307 | } | |
308 | ||
309 | static struct pci_driver k8temp_driver = { | |
310 | .name = "k8temp", | |
311 | .id_table = k8temp_ids, | |
312 | .probe = k8temp_probe, | |
313 | .remove = __devexit_p(k8temp_remove), | |
314 | }; | |
315 | ||
316 | static int __init k8temp_init(void) | |
317 | { | |
318 | return pci_register_driver(&k8temp_driver); | |
319 | } | |
320 | ||
321 | static void __exit k8temp_exit(void) | |
322 | { | |
323 | pci_unregister_driver(&k8temp_driver); | |
324 | } | |
325 | ||
7188cc66 | 326 | MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>"); |
29fa06c1 RM |
327 | MODULE_DESCRIPTION("AMD K8 core temperature monitor"); |
328 | MODULE_LICENSE("GPL"); | |
329 | ||
330 | module_init(k8temp_init) | |
331 | module_exit(k8temp_exit) |