1 /* 2 * fam15h_power.c - AMD Family 15h processor power monitoring 3 * 4 * Copyright (c) 2011 Advanced Micro Devices, Inc. 5 * Author: Andreas Herrmann <andreas.herrmann3@amd.com> 6 * 7 * 8 * This driver is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License; either 10 * version 2 of the License, or (at your option) any later version. 11 * 12 * This driver is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 15 * See the GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this driver; if not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include <linux/err.h> 22 #include <linux/hwmon.h> 23 #include <linux/hwmon-sysfs.h> 24 #include <linux/init.h> 25 #include <linux/module.h> 26 #include <linux/pci.h> 27 #include <linux/bitops.h> 28 #include <asm/processor.h> 29 30 MODULE_DESCRIPTION("AMD Family 15h CPU processor power monitor"); 31 MODULE_AUTHOR("Andreas Herrmann <andreas.herrmann3@amd.com>"); 32 MODULE_LICENSE("GPL"); 33 34 /* D18F3 */ 35 #define REG_NORTHBRIDGE_CAP 0xe8 36 37 /* D18F4 */ 38 #define REG_PROCESSOR_TDP 0x1b8 39 40 /* D18F5 */ 41 #define REG_TDP_RUNNING_AVERAGE 0xe0 42 #define REG_TDP_LIMIT3 0xe8 43 44 struct fam15h_power_data { 45 struct device *hwmon_dev; 46 unsigned int tdp_to_watts; 47 unsigned int base_tdp; 48 unsigned int processor_pwr_watts; 49 }; 50 51 static ssize_t show_power(struct device *dev, 52 struct device_attribute *attr, char *buf) 53 { 54 u32 val, tdp_limit, running_avg_range; 55 s32 running_avg_capture; 56 u64 curr_pwr_watts; 57 struct pci_dev *f4 = to_pci_dev(dev); 58 struct fam15h_power_data *data = dev_get_drvdata(dev); 59 60 pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), 61 REG_TDP_RUNNING_AVERAGE, &val); 62 running_avg_capture = (val >> 4) & 0x3fffff; 63 running_avg_capture = sign_extend32(running_avg_capture, 21); 64 running_avg_range = (val & 0xf) + 1; 65 66 pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), 67 REG_TDP_LIMIT3, &val); 68 69 tdp_limit = val >> 16; 70 curr_pwr_watts = (tdp_limit + data->base_tdp) << running_avg_range; 71 curr_pwr_watts -= running_avg_capture; 72 curr_pwr_watts *= data->tdp_to_watts; 73 74 /* 75 * Convert to microWatt 76 * 77 * power is in Watt provided as fixed point integer with 78 * scaling factor 1/(2^16). For conversion we use 79 * (10^6)/(2^16) = 15625/(2^10) 80 */ 81 curr_pwr_watts = (curr_pwr_watts * 15625) >> (10 + running_avg_range); 82 return sprintf(buf, "%u\n", (unsigned int) curr_pwr_watts); 83 } 84 static DEVICE_ATTR(power1_input, S_IRUGO, show_power, NULL); 85 86 static ssize_t show_power_crit(struct device *dev, 87 struct device_attribute *attr, char *buf) 88 { 89 struct fam15h_power_data *data = dev_get_drvdata(dev); 90 91 return sprintf(buf, "%u\n", data->processor_pwr_watts); 92 } 93 static DEVICE_ATTR(power1_crit, S_IRUGO, show_power_crit, NULL); 94 95 static ssize_t show_name(struct device *dev, 96 struct device_attribute *attr, char *buf) 97 { 98 return sprintf(buf, "fam15h_power\n"); 99 } 100 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 101 102 static struct attribute *fam15h_power_attrs[] = { 103 &dev_attr_power1_input.attr, 104 &dev_attr_power1_crit.attr, 105 &dev_attr_name.attr, 106 NULL 107 }; 108 109 static const struct attribute_group fam15h_power_attr_group = { 110 .attrs = fam15h_power_attrs, 111 }; 112 113 static bool __devinit fam15h_power_is_internal_node0(struct pci_dev *f4) 114 { 115 u32 val; 116 117 pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 3), 118 REG_NORTHBRIDGE_CAP, &val); 119 if ((val & BIT(29)) && ((val >> 30) & 3)) 120 return false; 121 122 return true; 123 } 124 125 /* 126 * Newer BKDG versions have an updated recommendation on how to properly 127 * initialize the running average range (was: 0xE, now: 0x9). This avoids 128 * counter saturations resulting in bogus power readings. 129 * We correct this value ourselves to cope with older BIOSes. 130 */ 131 static DEFINE_PCI_DEVICE_TABLE(affected_device) = { 132 { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F4) }, 133 { 0 } 134 }; 135 136 static void __devinit tweak_runavg_range(struct pci_dev *pdev) 137 { 138 u32 val; 139 140 /* 141 * let this quirk apply only to the current version of the 142 * northbridge, since future versions may change the behavior 143 */ 144 if (!pci_match_id(affected_device, pdev)) 145 return; 146 147 pci_bus_read_config_dword(pdev->bus, 148 PCI_DEVFN(PCI_SLOT(pdev->devfn), 5), 149 REG_TDP_RUNNING_AVERAGE, &val); 150 if ((val & 0xf) != 0xe) 151 return; 152 153 val &= ~0xf; 154 val |= 0x9; 155 pci_bus_write_config_dword(pdev->bus, 156 PCI_DEVFN(PCI_SLOT(pdev->devfn), 5), 157 REG_TDP_RUNNING_AVERAGE, val); 158 } 159 160 static void __devinit fam15h_power_init_data(struct pci_dev *f4, 161 struct fam15h_power_data *data) 162 { 163 u32 val; 164 u64 tmp; 165 166 pci_read_config_dword(f4, REG_PROCESSOR_TDP, &val); 167 data->base_tdp = val >> 16; 168 tmp = val & 0xffff; 169 170 pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), 171 REG_TDP_LIMIT3, &val); 172 173 data->tdp_to_watts = ((val & 0x3ff) << 6) | ((val >> 10) & 0x3f); 174 tmp *= data->tdp_to_watts; 175 176 /* result not allowed to be >= 256W */ 177 if ((tmp >> 16) >= 256) 178 dev_warn(&f4->dev, "Bogus value for ProcessorPwrWatts " 179 "(processor_pwr_watts>=%u)\n", 180 (unsigned int) (tmp >> 16)); 181 182 /* convert to microWatt */ 183 data->processor_pwr_watts = (tmp * 15625) >> 10; 184 } 185 186 static int __devinit fam15h_power_probe(struct pci_dev *pdev, 187 const struct pci_device_id *id) 188 { 189 struct fam15h_power_data *data; 190 struct device *dev; 191 int err; 192 193 /* 194 * though we ignore every other northbridge, we still have to 195 * do the tweaking on _each_ node in MCM processors as the counters 196 * are working hand-in-hand 197 */ 198 tweak_runavg_range(pdev); 199 200 if (!fam15h_power_is_internal_node0(pdev)) { 201 err = -ENODEV; 202 goto exit; 203 } 204 205 data = kzalloc(sizeof(struct fam15h_power_data), GFP_KERNEL); 206 if (!data) { 207 err = -ENOMEM; 208 goto exit; 209 } 210 fam15h_power_init_data(pdev, data); 211 dev = &pdev->dev; 212 213 dev_set_drvdata(dev, data); 214 err = sysfs_create_group(&dev->kobj, &fam15h_power_attr_group); 215 if (err) 216 goto exit_free_data; 217 218 data->hwmon_dev = hwmon_device_register(dev); 219 if (IS_ERR(data->hwmon_dev)) { 220 err = PTR_ERR(data->hwmon_dev); 221 goto exit_remove_group; 222 } 223 224 return 0; 225 226 exit_remove_group: 227 sysfs_remove_group(&dev->kobj, &fam15h_power_attr_group); 228 exit_free_data: 229 kfree(data); 230 exit: 231 return err; 232 } 233 234 static void __devexit fam15h_power_remove(struct pci_dev *pdev) 235 { 236 struct device *dev; 237 struct fam15h_power_data *data; 238 239 dev = &pdev->dev; 240 data = dev_get_drvdata(dev); 241 hwmon_device_unregister(data->hwmon_dev); 242 sysfs_remove_group(&dev->kobj, &fam15h_power_attr_group); 243 dev_set_drvdata(dev, NULL); 244 kfree(data); 245 } 246 247 static DEFINE_PCI_DEVICE_TABLE(fam15h_power_id_table) = { 248 { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F4) }, 249 {} 250 }; 251 MODULE_DEVICE_TABLE(pci, fam15h_power_id_table); 252 253 static struct pci_driver fam15h_power_driver = { 254 .name = "fam15h_power", 255 .id_table = fam15h_power_id_table, 256 .probe = fam15h_power_probe, 257 .remove = __devexit_p(fam15h_power_remove), 258 }; 259 260 static int __init fam15h_power_init(void) 261 { 262 return pci_register_driver(&fam15h_power_driver); 263 } 264 265 static void __exit fam15h_power_exit(void) 266 { 267 pci_unregister_driver(&fam15h_power_driver); 268 } 269 270 module_init(fam15h_power_init) 271 module_exit(fam15h_power_exit) 272