Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 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; |
Andreas Herrmann | fc0900c | 2012-03-23 10:02:17 +0100 | [diff] [blame] | 63 | running_avg_capture = sign_extend32(running_avg_capture, 21); |
Andre Przywara | 941a956 | 2012-03-23 10:02:17 +0100 | [diff] [blame] | 64 | running_avg_range = (val & 0xf) + 1; |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 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; |
Andre Przywara | 941a956 | 2012-03-23 10:02:17 +0100 | [diff] [blame] | 70 | curr_pwr_watts = (tdp_limit + data->base_tdp) << running_avg_range; |
| 71 | curr_pwr_watts -= running_avg_capture; |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 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 | */ |
Andre Przywara | 941a956 | 2012-03-23 10:02:17 +0100 | [diff] [blame] | 81 | curr_pwr_watts = (curr_pwr_watts * 15625) >> (10 + running_avg_range); |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 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 | |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 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 | */ |
Guenter Roeck | c3e40a9 | 2012-04-25 13:44:20 -0700 | [diff] [blame] | 131 | static DEFINE_PCI_DEVICE_TABLE(affected_device) = { |
| 132 | { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F4) }, |
| 133 | { 0 } |
| 134 | }; |
| 135 | |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 136 | static void __devinit tweak_runavg_range(struct pci_dev *pdev) |
| 137 | { |
| 138 | u32 val; |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 139 | |
| 140 | /* |
| 141 | * let this quirk apply only to the current version of the |
| 142 | * northbridge, since future versions may change the behavior |
| 143 | */ |
Guenter Roeck | c3e40a9 | 2012-04-25 13:44:20 -0700 | [diff] [blame] | 144 | if (!pci_match_id(affected_device, pdev)) |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 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 | |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 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 | |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 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 | |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 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) |