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; |
Guenter Roeck | 62867d4 | 2012-06-21 06:26:12 -0700 | [diff] [blame] | 70 | curr_pwr_watts = ((u64)(tdp_limit + |
| 71 | data->base_tdp)) << running_avg_range; |
Andre Przywara | 941a956 | 2012-03-23 10:02:17 +0100 | [diff] [blame] | 72 | curr_pwr_watts -= running_avg_capture; |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 73 | curr_pwr_watts *= data->tdp_to_watts; |
| 74 | |
| 75 | /* |
| 76 | * Convert to microWatt |
| 77 | * |
| 78 | * power is in Watt provided as fixed point integer with |
| 79 | * scaling factor 1/(2^16). For conversion we use |
| 80 | * (10^6)/(2^16) = 15625/(2^10) |
| 81 | */ |
Andre Przywara | 941a956 | 2012-03-23 10:02:17 +0100 | [diff] [blame] | 82 | curr_pwr_watts = (curr_pwr_watts * 15625) >> (10 + running_avg_range); |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 83 | return sprintf(buf, "%u\n", (unsigned int) curr_pwr_watts); |
| 84 | } |
| 85 | static DEVICE_ATTR(power1_input, S_IRUGO, show_power, NULL); |
| 86 | |
| 87 | static ssize_t show_power_crit(struct device *dev, |
| 88 | struct device_attribute *attr, char *buf) |
| 89 | { |
| 90 | struct fam15h_power_data *data = dev_get_drvdata(dev); |
| 91 | |
| 92 | return sprintf(buf, "%u\n", data->processor_pwr_watts); |
| 93 | } |
| 94 | static DEVICE_ATTR(power1_crit, S_IRUGO, show_power_crit, NULL); |
| 95 | |
| 96 | static ssize_t show_name(struct device *dev, |
| 97 | struct device_attribute *attr, char *buf) |
| 98 | { |
| 99 | return sprintf(buf, "fam15h_power\n"); |
| 100 | } |
| 101 | static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); |
| 102 | |
| 103 | static struct attribute *fam15h_power_attrs[] = { |
| 104 | &dev_attr_power1_input.attr, |
| 105 | &dev_attr_power1_crit.attr, |
| 106 | &dev_attr_name.attr, |
| 107 | NULL |
| 108 | }; |
| 109 | |
| 110 | static const struct attribute_group fam15h_power_attr_group = { |
| 111 | .attrs = fam15h_power_attrs, |
| 112 | }; |
| 113 | |
| 114 | static bool __devinit fam15h_power_is_internal_node0(struct pci_dev *f4) |
| 115 | { |
| 116 | u32 val; |
| 117 | |
| 118 | pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 3), |
| 119 | REG_NORTHBRIDGE_CAP, &val); |
| 120 | if ((val & BIT(29)) && ((val >> 30) & 3)) |
| 121 | return false; |
| 122 | |
| 123 | return true; |
| 124 | } |
| 125 | |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 126 | /* |
| 127 | * Newer BKDG versions have an updated recommendation on how to properly |
| 128 | * initialize the running average range (was: 0xE, now: 0x9). This avoids |
| 129 | * counter saturations resulting in bogus power readings. |
| 130 | * We correct this value ourselves to cope with older BIOSes. |
| 131 | */ |
Andreas Herrmann | 5f0ecb9 | 2012-09-23 20:27:32 +0200 | [diff] [blame^] | 132 | static const struct pci_device_id affected_device[] = { |
Guenter Roeck | c3e40a9 | 2012-04-25 13:44:20 -0700 | [diff] [blame] | 133 | { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F4) }, |
| 134 | { 0 } |
| 135 | }; |
| 136 | |
Andreas Herrmann | 5f0ecb9 | 2012-09-23 20:27:32 +0200 | [diff] [blame^] | 137 | static void tweak_runavg_range(struct pci_dev *pdev) |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 138 | { |
| 139 | u32 val; |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 140 | |
| 141 | /* |
| 142 | * let this quirk apply only to the current version of the |
| 143 | * northbridge, since future versions may change the behavior |
| 144 | */ |
Guenter Roeck | c3e40a9 | 2012-04-25 13:44:20 -0700 | [diff] [blame] | 145 | if (!pci_match_id(affected_device, pdev)) |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 146 | return; |
| 147 | |
| 148 | pci_bus_read_config_dword(pdev->bus, |
| 149 | PCI_DEVFN(PCI_SLOT(pdev->devfn), 5), |
| 150 | REG_TDP_RUNNING_AVERAGE, &val); |
| 151 | if ((val & 0xf) != 0xe) |
| 152 | return; |
| 153 | |
| 154 | val &= ~0xf; |
| 155 | val |= 0x9; |
| 156 | pci_bus_write_config_dword(pdev->bus, |
| 157 | PCI_DEVFN(PCI_SLOT(pdev->devfn), 5), |
| 158 | REG_TDP_RUNNING_AVERAGE, val); |
| 159 | } |
| 160 | |
Andreas Herrmann | 5f0ecb9 | 2012-09-23 20:27:32 +0200 | [diff] [blame^] | 161 | #ifdef CONFIG_PM |
| 162 | static int fam15h_power_resume(struct pci_dev *pdev) |
| 163 | { |
| 164 | tweak_runavg_range(pdev); |
| 165 | return 0; |
| 166 | } |
| 167 | #else |
| 168 | #define fam15h_power_resume NULL |
| 169 | #endif |
| 170 | |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 171 | static void __devinit fam15h_power_init_data(struct pci_dev *f4, |
| 172 | struct fam15h_power_data *data) |
| 173 | { |
| 174 | u32 val; |
| 175 | u64 tmp; |
| 176 | |
| 177 | pci_read_config_dword(f4, REG_PROCESSOR_TDP, &val); |
| 178 | data->base_tdp = val >> 16; |
| 179 | tmp = val & 0xffff; |
| 180 | |
| 181 | pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), |
| 182 | REG_TDP_LIMIT3, &val); |
| 183 | |
| 184 | data->tdp_to_watts = ((val & 0x3ff) << 6) | ((val >> 10) & 0x3f); |
| 185 | tmp *= data->tdp_to_watts; |
| 186 | |
| 187 | /* result not allowed to be >= 256W */ |
| 188 | if ((tmp >> 16) >= 256) |
| 189 | dev_warn(&f4->dev, "Bogus value for ProcessorPwrWatts " |
| 190 | "(processor_pwr_watts>=%u)\n", |
| 191 | (unsigned int) (tmp >> 16)); |
| 192 | |
| 193 | /* convert to microWatt */ |
| 194 | data->processor_pwr_watts = (tmp * 15625) >> 10; |
| 195 | } |
| 196 | |
| 197 | static int __devinit fam15h_power_probe(struct pci_dev *pdev, |
| 198 | const struct pci_device_id *id) |
| 199 | { |
| 200 | struct fam15h_power_data *data; |
| 201 | struct device *dev; |
| 202 | int err; |
| 203 | |
Andre Przywara | 00250ec | 2012-04-09 18:16:34 -0400 | [diff] [blame] | 204 | /* |
| 205 | * though we ignore every other northbridge, we still have to |
| 206 | * do the tweaking on _each_ node in MCM processors as the counters |
| 207 | * are working hand-in-hand |
| 208 | */ |
| 209 | tweak_runavg_range(pdev); |
| 210 | |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 211 | if (!fam15h_power_is_internal_node0(pdev)) { |
| 212 | err = -ENODEV; |
| 213 | goto exit; |
| 214 | } |
| 215 | |
| 216 | data = kzalloc(sizeof(struct fam15h_power_data), GFP_KERNEL); |
| 217 | if (!data) { |
| 218 | err = -ENOMEM; |
| 219 | goto exit; |
| 220 | } |
| 221 | fam15h_power_init_data(pdev, data); |
| 222 | dev = &pdev->dev; |
| 223 | |
| 224 | dev_set_drvdata(dev, data); |
| 225 | err = sysfs_create_group(&dev->kobj, &fam15h_power_attr_group); |
| 226 | if (err) |
| 227 | goto exit_free_data; |
| 228 | |
| 229 | data->hwmon_dev = hwmon_device_register(dev); |
| 230 | if (IS_ERR(data->hwmon_dev)) { |
| 231 | err = PTR_ERR(data->hwmon_dev); |
| 232 | goto exit_remove_group; |
| 233 | } |
| 234 | |
| 235 | return 0; |
| 236 | |
| 237 | exit_remove_group: |
| 238 | sysfs_remove_group(&dev->kobj, &fam15h_power_attr_group); |
| 239 | exit_free_data: |
| 240 | kfree(data); |
| 241 | exit: |
| 242 | return err; |
| 243 | } |
| 244 | |
| 245 | static void __devexit fam15h_power_remove(struct pci_dev *pdev) |
| 246 | { |
| 247 | struct device *dev; |
| 248 | struct fam15h_power_data *data; |
| 249 | |
| 250 | dev = &pdev->dev; |
| 251 | data = dev_get_drvdata(dev); |
| 252 | hwmon_device_unregister(data->hwmon_dev); |
| 253 | sysfs_remove_group(&dev->kobj, &fam15h_power_attr_group); |
| 254 | dev_set_drvdata(dev, NULL); |
| 255 | kfree(data); |
| 256 | } |
| 257 | |
| 258 | static DEFINE_PCI_DEVICE_TABLE(fam15h_power_id_table) = { |
| 259 | { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F4) }, |
| 260 | {} |
| 261 | }; |
| 262 | MODULE_DEVICE_TABLE(pci, fam15h_power_id_table); |
| 263 | |
| 264 | static struct pci_driver fam15h_power_driver = { |
| 265 | .name = "fam15h_power", |
| 266 | .id_table = fam15h_power_id_table, |
| 267 | .probe = fam15h_power_probe, |
| 268 | .remove = __devexit_p(fam15h_power_remove), |
Andreas Herrmann | 5f0ecb9 | 2012-09-23 20:27:32 +0200 | [diff] [blame^] | 269 | .resume = fam15h_power_resume, |
Andreas Herrmann | 512d102 | 2011-05-25 20:43:31 +0200 | [diff] [blame] | 270 | }; |
| 271 | |
Axel Lin | f71f5a5 | 2012-04-02 21:25:46 -0400 | [diff] [blame] | 272 | module_pci_driver(fam15h_power_driver); |