amd_energy.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2020 Advanced Micro Devices, Inc.
  4. */
  5. #include <asm/cpu_device_id.h>
  6. #include <linux/bits.h>
  7. #include <linux/cpu.h>
  8. #include <linux/cpumask.h>
  9. #include <linux/delay.h>
  10. #include <linux/device.h>
  11. #include <linux/hwmon.h>
  12. #include <linux/kernel.h>
  13. #include <linux/kthread.h>
  14. #include <linux/list.h>
  15. #include <linux/module.h>
  16. #include <linux/mutex.h>
  17. #include <linux/processor.h>
  18. #include <linux/platform_device.h>
  19. #include <linux/sched.h>
  20. #include <linux/slab.h>
  21. #include <linux/topology.h>
  22. #include <linux/types.h>
  23. #define DRVNAME "amd_energy"
  24. #define ENERGY_PWR_UNIT_MSR 0xC0010299
  25. #define ENERGY_CORE_MSR 0xC001029A
  26. #define ENERGY_PKG_MSR 0xC001029B
  27. #define AMD_ENERGY_UNIT_MASK 0x01F00
  28. #define AMD_ENERGY_MASK 0xFFFFFFFF
  29. struct sensor_accumulator {
  30. u64 energy_ctr;
  31. u64 prev_value;
  32. };
  33. struct amd_energy_data {
  34. struct hwmon_channel_info energy_info;
  35. const struct hwmon_channel_info *info[2];
  36. struct hwmon_chip_info chip;
  37. struct task_struct *wrap_accumulate;
  38. /* Lock around the accumulator */
  39. struct mutex lock;
  40. /* An accumulator for each core and socket */
  41. struct sensor_accumulator *accums;
  42. unsigned int timeout_ms;
  43. /* Energy Status Units */
  44. int energy_units;
  45. int nr_cpus;
  46. int nr_socks;
  47. int core_id;
  48. char (*label)[10];
  49. };
  50. static int amd_energy_read_labels(struct device *dev,
  51. enum hwmon_sensor_types type,
  52. u32 attr, int channel,
  53. const char **str)
  54. {
  55. struct amd_energy_data *data = dev_get_drvdata(dev);
  56. *str = data->label[channel];
  57. return 0;
  58. }
  59. static void get_energy_units(struct amd_energy_data *data)
  60. {
  61. u64 rapl_units;
  62. rdmsrl_safe(ENERGY_PWR_UNIT_MSR, &rapl_units);
  63. data->energy_units = (rapl_units & AMD_ENERGY_UNIT_MASK) >> 8;
  64. }
  65. static void accumulate_delta(struct amd_energy_data *data,
  66. int channel, int cpu, u32 reg)
  67. {
  68. struct sensor_accumulator *accum;
  69. u64 input;
  70. mutex_lock(&data->lock);
  71. rdmsrl_safe_on_cpu(cpu, reg, &input);
  72. input &= AMD_ENERGY_MASK;
  73. accum = &data->accums[channel];
  74. if (input >= accum->prev_value)
  75. accum->energy_ctr +=
  76. input - accum->prev_value;
  77. else
  78. accum->energy_ctr += UINT_MAX -
  79. accum->prev_value + input;
  80. accum->prev_value = input;
  81. mutex_unlock(&data->lock);
  82. }
  83. static void read_accumulate(struct amd_energy_data *data)
  84. {
  85. int sock, scpu, cpu;
  86. for (sock = 0; sock < data->nr_socks; sock++) {
  87. scpu = cpumask_first_and(cpu_online_mask,
  88. cpumask_of_node(sock));
  89. accumulate_delta(data, data->nr_cpus + sock,
  90. scpu, ENERGY_PKG_MSR);
  91. }
  92. if (data->core_id >= data->nr_cpus)
  93. data->core_id = 0;
  94. cpu = data->core_id;
  95. if (cpu_online(cpu))
  96. accumulate_delta(data, cpu, cpu, ENERGY_CORE_MSR);
  97. data->core_id++;
  98. }
  99. static void amd_add_delta(struct amd_energy_data *data, int ch,
  100. int cpu, long *val, u32 reg)
  101. {
  102. struct sensor_accumulator *accum;
  103. u64 input;
  104. mutex_lock(&data->lock);
  105. rdmsrl_safe_on_cpu(cpu, reg, &input);
  106. input &= AMD_ENERGY_MASK;
  107. accum = &data->accums[ch];
  108. if (input >= accum->prev_value)
  109. input += accum->energy_ctr -
  110. accum->prev_value;
  111. else
  112. input += UINT_MAX - accum->prev_value +
  113. accum->energy_ctr;
  114. /* Energy consumed = (1/(2^ESU) * RAW * 1000000UL) μJoules */
  115. *val = div64_ul(input * 1000000UL, BIT(data->energy_units));
  116. mutex_unlock(&data->lock);
  117. }
  118. static int amd_energy_read(struct device *dev,
  119. enum hwmon_sensor_types type,
  120. u32 attr, int channel, long *val)
  121. {
  122. struct amd_energy_data *data = dev_get_drvdata(dev);
  123. u32 reg;
  124. int cpu;
  125. if (channel >= data->nr_cpus) {
  126. cpu = cpumask_first_and(cpu_online_mask,
  127. cpumask_of_node
  128. (channel - data->nr_cpus));
  129. reg = ENERGY_PKG_MSR;
  130. } else {
  131. cpu = channel;
  132. if (!cpu_online(cpu))
  133. return -ENODEV;
  134. reg = ENERGY_CORE_MSR;
  135. }
  136. amd_add_delta(data, channel, cpu, val, reg);
  137. return 0;
  138. }
  139. static umode_t amd_energy_is_visible(const void *_data,
  140. enum hwmon_sensor_types type,
  141. u32 attr, int channel)
  142. {
  143. return 0440;
  144. }
  145. static int energy_accumulator(void *p)
  146. {
  147. struct amd_energy_data *data = (struct amd_energy_data *)p;
  148. unsigned int timeout = data->timeout_ms;
  149. while (!kthread_should_stop()) {
  150. /*
  151. * Ignoring the conditions such as
  152. * cpu being offline or rdmsr failure
  153. */
  154. read_accumulate(data);
  155. set_current_state(TASK_INTERRUPTIBLE);
  156. if (kthread_should_stop())
  157. break;
  158. schedule_timeout(msecs_to_jiffies(timeout));
  159. }
  160. return 0;
  161. }
  162. static const struct hwmon_ops amd_energy_ops = {
  163. .is_visible = amd_energy_is_visible,
  164. .read = amd_energy_read,
  165. .read_string = amd_energy_read_labels,
  166. };
  167. static int amd_create_sensor(struct device *dev,
  168. struct amd_energy_data *data,
  169. enum hwmon_sensor_types type, u32 config)
  170. {
  171. struct hwmon_channel_info *info = &data->energy_info;
  172. struct sensor_accumulator *accums;
  173. int i, num_siblings, cpus, sockets;
  174. u32 *s_config;
  175. char (*label_l)[10];
  176. /* Identify the number of siblings per core */
  177. num_siblings = ((cpuid_ebx(0x8000001e) >> 8) & 0xff) + 1;
  178. sockets = num_possible_nodes();
  179. /*
  180. * Energy counter register is accessed at core level.
  181. * Hence, filterout the siblings.
  182. */
  183. cpus = num_present_cpus() / num_siblings;
  184. s_config = devm_kcalloc(dev, cpus + sockets + 1,
  185. sizeof(u32), GFP_KERNEL);
  186. if (!s_config)
  187. return -ENOMEM;
  188. accums = devm_kcalloc(dev, cpus + sockets,
  189. sizeof(struct sensor_accumulator),
  190. GFP_KERNEL);
  191. if (!accums)
  192. return -ENOMEM;
  193. label_l = devm_kcalloc(dev, cpus + sockets,
  194. sizeof(*label_l), GFP_KERNEL);
  195. if (!label_l)
  196. return -ENOMEM;
  197. info->type = type;
  198. info->config = s_config;
  199. data->nr_cpus = cpus;
  200. data->nr_socks = sockets;
  201. data->accums = accums;
  202. data->label = label_l;
  203. for (i = 0; i < cpus + sockets; i++) {
  204. s_config[i] = config;
  205. if (i < cpus)
  206. scnprintf(label_l[i], 10, "Ecore%03u", i);
  207. else
  208. scnprintf(label_l[i], 10, "Esocket%u", (i - cpus));
  209. }
  210. s_config[i] = 0;
  211. return 0;
  212. }
  213. static int amd_energy_probe(struct platform_device *pdev)
  214. {
  215. struct device *hwmon_dev;
  216. struct amd_energy_data *data;
  217. struct device *dev = &pdev->dev;
  218. int ret;
  219. data = devm_kzalloc(dev,
  220. sizeof(struct amd_energy_data), GFP_KERNEL);
  221. if (!data)
  222. return -ENOMEM;
  223. data->chip.ops = &amd_energy_ops;
  224. data->chip.info = data->info;
  225. dev_set_drvdata(dev, data);
  226. /* Populate per-core energy reporting */
  227. data->info[0] = &data->energy_info;
  228. ret = amd_create_sensor(dev, data, hwmon_energy,
  229. HWMON_E_INPUT | HWMON_E_LABEL);
  230. if (ret)
  231. return ret;
  232. mutex_init(&data->lock);
  233. get_energy_units(data);
  234. hwmon_dev = devm_hwmon_device_register_with_info(dev, DRVNAME,
  235. data,
  236. &data->chip,
  237. NULL);
  238. if (IS_ERR(hwmon_dev))
  239. return PTR_ERR(hwmon_dev);
  240. /*
  241. * On a system with peak wattage of 250W
  242. * timeout = 2 ^ 32 / 2 ^ energy_units / 250 secs
  243. */
  244. data->timeout_ms = 1000 *
  245. BIT(min(28, 31 - data->energy_units)) / 250;
  246. data->wrap_accumulate = kthread_run(energy_accumulator, data,
  247. "%s", dev_name(hwmon_dev));
  248. return PTR_ERR_OR_ZERO(data->wrap_accumulate);
  249. }
  250. static int amd_energy_remove(struct platform_device *pdev)
  251. {
  252. struct amd_energy_data *data = dev_get_drvdata(&pdev->dev);
  253. if (data && data->wrap_accumulate)
  254. kthread_stop(data->wrap_accumulate);
  255. return 0;
  256. }
  257. static const struct platform_device_id amd_energy_ids[] = {
  258. { .name = DRVNAME, },
  259. {}
  260. };
  261. MODULE_DEVICE_TABLE(platform, amd_energy_ids);
  262. static struct platform_driver amd_energy_driver = {
  263. .probe = amd_energy_probe,
  264. .remove = amd_energy_remove,
  265. .id_table = amd_energy_ids,
  266. .driver = {
  267. .name = DRVNAME,
  268. },
  269. };
  270. static struct platform_device *amd_energy_platdev;
  271. static const struct x86_cpu_id cpu_ids[] __initconst = {
  272. X86_MATCH_VENDOR_FAM_MODEL(AMD, 0x17, 0x31, NULL),
  273. {}
  274. };
  275. MODULE_DEVICE_TABLE(x86cpu, cpu_ids);
  276. static int __init amd_energy_init(void)
  277. {
  278. int ret;
  279. if (!x86_match_cpu(cpu_ids))
  280. return -ENODEV;
  281. ret = platform_driver_register(&amd_energy_driver);
  282. if (ret)
  283. return ret;
  284. amd_energy_platdev = platform_device_alloc(DRVNAME, 0);
  285. if (!amd_energy_platdev) {
  286. platform_driver_unregister(&amd_energy_driver);
  287. return -ENOMEM;
  288. }
  289. ret = platform_device_add(amd_energy_platdev);
  290. if (ret) {
  291. platform_device_put(amd_energy_platdev);
  292. platform_driver_unregister(&amd_energy_driver);
  293. return ret;
  294. }
  295. return ret;
  296. }
  297. static void __exit amd_energy_exit(void)
  298. {
  299. platform_device_unregister(amd_energy_platdev);
  300. platform_driver_unregister(&amd_energy_driver);
  301. }
  302. module_init(amd_energy_init);
  303. module_exit(amd_energy_exit);
  304. MODULE_DESCRIPTION("Driver for AMD Energy reporting from RAPL MSR via HWMON interface");
  305. MODULE_AUTHOR("Naveen Krishna Chatradhi <nchatrad@amd.com>");
  306. MODULE_LICENSE("GPL");