1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * AMD HSMP Platform Driver
4 * Copyright (c) 2024, AMD.
5 * All Rights Reserved.
6 *
7 * This file provides an ACPI based driver implementation for HSMP interface.
8 */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include <asm/amd/hsmp.h>
13
14 #include <linux/acpi.h>
15 #include <linux/array_size.h>
16 #include <linux/bits.h>
17 #include <linux/bitfield.h>
18 #include <linux/device.h>
19 #include <linux/dev_printk.h>
20 #include <linux/ioport.h>
21 #include <linux/kstrtox.h>
22 #include <linux/module.h>
23 #include <linux/platform_device.h>
24 #include <linux/sysfs.h>
25 #include <linux/topology.h>
26 #include <linux/uuid.h>
27
28 #include <uapi/asm-generic/errno-base.h>
29
30 #include "hsmp.h"
31
32 #define DRIVER_NAME "hsmp_acpi"
33
34 /* These are the strings specified in ACPI table */
35 #define MSG_IDOFF_STR "MsgIdOffset"
36 #define MSG_ARGOFF_STR "MsgArgOffset"
37 #define MSG_RESPOFF_STR "MsgRspOffset"
38
39 static struct hsmp_plat_device *hsmp_pdev;
40
41 struct hsmp_sys_attr {
42 struct device_attribute dattr;
43 u32 msg_id;
44 };
45
amd_hsmp_acpi_rdwr(struct hsmp_socket * sock,u32 offset,u32 * value,bool write)46 static int amd_hsmp_acpi_rdwr(struct hsmp_socket *sock, u32 offset,
47 u32 *value, bool write)
48 {
49 if (write)
50 iowrite32(*value, sock->virt_base_addr + offset);
51 else
52 *value = ioread32(sock->virt_base_addr + offset);
53
54 return 0;
55 }
56
57 /* This is the UUID used for HSMP */
58 static const guid_t acpi_hsmp_uuid = GUID_INIT(0xb74d619d, 0x5707, 0x48bd,
59 0xa6, 0x9f, 0x4e, 0xa2,
60 0x87, 0x1f, 0xc2, 0xf6);
61
is_acpi_hsmp_uuid(union acpi_object * obj)62 static inline bool is_acpi_hsmp_uuid(union acpi_object *obj)
63 {
64 if (obj->type == ACPI_TYPE_BUFFER && obj->buffer.length == UUID_SIZE)
65 return guid_equal((guid_t *)obj->buffer.pointer, &acpi_hsmp_uuid);
66
67 return false;
68 }
69
hsmp_get_uid(struct device * dev,u16 * sock_ind)70 static inline int hsmp_get_uid(struct device *dev, u16 *sock_ind)
71 {
72 char *uid;
73
74 /*
75 * UID (ID00, ID01..IDXX) is used for differentiating sockets,
76 * read it and strip the "ID" part of it and convert the remaining
77 * bytes to integer.
78 */
79 uid = acpi_device_uid(ACPI_COMPANION(dev));
80
81 return kstrtou16(uid + 2, 10, sock_ind);
82 }
83
hsmp_resource(struct acpi_resource * res,void * data)84 static acpi_status hsmp_resource(struct acpi_resource *res, void *data)
85 {
86 struct hsmp_socket *sock = data;
87 struct resource r;
88
89 switch (res->type) {
90 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
91 if (!acpi_dev_resource_memory(res, &r))
92 return AE_ERROR;
93 if (!r.start || r.end < r.start || !(r.flags & IORESOURCE_MEM_WRITEABLE))
94 return AE_ERROR;
95 sock->mbinfo.base_addr = r.start;
96 sock->mbinfo.size = resource_size(&r);
97 break;
98 case ACPI_RESOURCE_TYPE_END_TAG:
99 break;
100 default:
101 return AE_ERROR;
102 }
103
104 return AE_OK;
105 }
106
hsmp_read_acpi_dsd(struct hsmp_socket * sock)107 static int hsmp_read_acpi_dsd(struct hsmp_socket *sock)
108 {
109 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
110 union acpi_object *guid, *mailbox_package;
111 union acpi_object *dsd;
112 acpi_status status;
113 int ret = 0;
114 int j;
115
116 status = acpi_evaluate_object_typed(ACPI_HANDLE(sock->dev), "_DSD", NULL,
117 &buf, ACPI_TYPE_PACKAGE);
118 if (ACPI_FAILURE(status)) {
119 dev_err(sock->dev, "Failed to read mailbox reg offsets from DSD table, err: %s\n",
120 acpi_format_exception(status));
121 return -ENODEV;
122 }
123
124 dsd = buf.pointer;
125
126 /* HSMP _DSD property should contain 2 objects.
127 * 1. guid which is an acpi object of type ACPI_TYPE_BUFFER
128 * 2. mailbox which is an acpi object of type ACPI_TYPE_PACKAGE
129 * This mailbox object contains 3 more acpi objects of type
130 * ACPI_TYPE_PACKAGE for holding msgid, msgresp, msgarg offsets
131 * these packages inturn contain 2 acpi objects of type
132 * ACPI_TYPE_STRING and ACPI_TYPE_INTEGER
133 */
134 if (!dsd || dsd->type != ACPI_TYPE_PACKAGE || dsd->package.count != 2) {
135 ret = -EINVAL;
136 goto free_buf;
137 }
138
139 guid = &dsd->package.elements[0];
140 mailbox_package = &dsd->package.elements[1];
141 if (!is_acpi_hsmp_uuid(guid) || mailbox_package->type != ACPI_TYPE_PACKAGE) {
142 dev_err(sock->dev, "Invalid hsmp _DSD table data\n");
143 ret = -EINVAL;
144 goto free_buf;
145 }
146
147 for (j = 0; j < mailbox_package->package.count; j++) {
148 union acpi_object *msgobj, *msgstr, *msgint;
149
150 msgobj = &mailbox_package->package.elements[j];
151 msgstr = &msgobj->package.elements[0];
152 msgint = &msgobj->package.elements[1];
153
154 /* package should have 1 string and 1 integer object */
155 if (msgobj->type != ACPI_TYPE_PACKAGE ||
156 msgstr->type != ACPI_TYPE_STRING ||
157 msgint->type != ACPI_TYPE_INTEGER) {
158 ret = -EINVAL;
159 goto free_buf;
160 }
161
162 if (!strncmp(msgstr->string.pointer, MSG_IDOFF_STR,
163 msgstr->string.length)) {
164 sock->mbinfo.msg_id_off = msgint->integer.value;
165 } else if (!strncmp(msgstr->string.pointer, MSG_RESPOFF_STR,
166 msgstr->string.length)) {
167 sock->mbinfo.msg_resp_off = msgint->integer.value;
168 } else if (!strncmp(msgstr->string.pointer, MSG_ARGOFF_STR,
169 msgstr->string.length)) {
170 sock->mbinfo.msg_arg_off = msgint->integer.value;
171 } else {
172 ret = -ENOENT;
173 goto free_buf;
174 }
175 }
176
177 if (!sock->mbinfo.msg_id_off || !sock->mbinfo.msg_resp_off ||
178 !sock->mbinfo.msg_arg_off)
179 ret = -EINVAL;
180
181 free_buf:
182 ACPI_FREE(buf.pointer);
183 return ret;
184 }
185
hsmp_read_acpi_crs(struct hsmp_socket * sock)186 static int hsmp_read_acpi_crs(struct hsmp_socket *sock)
187 {
188 acpi_status status;
189
190 status = acpi_walk_resources(ACPI_HANDLE(sock->dev), METHOD_NAME__CRS,
191 hsmp_resource, sock);
192 if (ACPI_FAILURE(status)) {
193 dev_err(sock->dev, "Failed to look up MP1 base address from CRS method, err: %s\n",
194 acpi_format_exception(status));
195 return -EINVAL;
196 }
197 if (!sock->mbinfo.base_addr || !sock->mbinfo.size)
198 return -EINVAL;
199
200 /* The mapped region should be un-cached */
201 sock->virt_base_addr = devm_ioremap_uc(sock->dev, sock->mbinfo.base_addr,
202 sock->mbinfo.size);
203 if (!sock->virt_base_addr) {
204 dev_err(sock->dev, "Failed to ioremap MP1 base address\n");
205 return -ENOMEM;
206 }
207
208 return 0;
209 }
210
211 /* Parse the ACPI table to read the data */
hsmp_parse_acpi_table(struct device * dev,u16 sock_ind)212 static int hsmp_parse_acpi_table(struct device *dev, u16 sock_ind)
213 {
214 struct hsmp_socket *sock = &hsmp_pdev->sock[sock_ind];
215 int ret;
216
217 sock->sock_ind = sock_ind;
218 sock->dev = dev;
219 sock->amd_hsmp_rdwr = amd_hsmp_acpi_rdwr;
220
221 sema_init(&sock->hsmp_sem, 1);
222
223 dev_set_drvdata(dev, sock);
224
225 /* Read MP1 base address from CRS method */
226 ret = hsmp_read_acpi_crs(sock);
227 if (ret)
228 return ret;
229
230 /* Read mailbox offsets from DSD table */
231 return hsmp_read_acpi_dsd(sock);
232 }
233
hsmp_metric_tbl_acpi_read(struct file * filp,struct kobject * kobj,const struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)234 static ssize_t hsmp_metric_tbl_acpi_read(struct file *filp, struct kobject *kobj,
235 const struct bin_attribute *bin_attr, char *buf,
236 loff_t off, size_t count)
237 {
238 struct device *dev = container_of(kobj, struct device, kobj);
239 struct hsmp_socket *sock = dev_get_drvdata(dev);
240
241 return hsmp_metric_tbl_read(sock, buf, count);
242 }
243
hsmp_is_sock_attr_visible(struct kobject * kobj,const struct bin_attribute * battr,int id)244 static umode_t hsmp_is_sock_attr_visible(struct kobject *kobj,
245 const struct bin_attribute *battr, int id)
246 {
247 if (hsmp_pdev->proto_ver == HSMP_PROTO_VER6)
248 return battr->attr.mode;
249
250 return 0;
251 }
252
hsmp_is_sock_dev_attr_visible(struct kobject * kobj,struct attribute * attr,int id)253 static umode_t hsmp_is_sock_dev_attr_visible(struct kobject *kobj,
254 struct attribute *attr, int id)
255 {
256 return attr->mode;
257 }
258
259 #define to_hsmp_sys_attr(_attr) container_of(_attr, struct hsmp_sys_attr, dattr)
260
hsmp_msg_resp32_show(struct device * dev,struct device_attribute * attr,char * buf)261 static ssize_t hsmp_msg_resp32_show(struct device *dev, struct device_attribute *attr,
262 char *buf)
263 {
264 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
265 struct hsmp_socket *sock = dev_get_drvdata(dev);
266 u32 data;
267 int ret;
268
269 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
270 if (ret)
271 return ret;
272
273 return sysfs_emit(buf, "%u\n", data);
274 }
275
276 #define DDR_MAX_BW_MASK GENMASK(31, 20)
277 #define DDR_UTIL_BW_MASK GENMASK(19, 8)
278 #define DDR_UTIL_BW_PERC_MASK GENMASK(7, 0)
279 #define FW_VER_MAJOR_MASK GENMASK(23, 16)
280 #define FW_VER_MINOR_MASK GENMASK(15, 8)
281 #define FW_VER_DEBUG_MASK GENMASK(7, 0)
282 #define FMAX_MASK GENMASK(31, 16)
283 #define FMIN_MASK GENMASK(15, 0)
284 #define FREQ_LIMIT_MASK GENMASK(31, 16)
285 #define FREQ_SRC_IND_MASK GENMASK(15, 0)
286
hsmp_ddr_max_bw_show(struct device * dev,struct device_attribute * attr,char * buf)287 static ssize_t hsmp_ddr_max_bw_show(struct device *dev, struct device_attribute *attr,
288 char *buf)
289 {
290 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
291 struct hsmp_socket *sock = dev_get_drvdata(dev);
292 u32 data;
293 int ret;
294
295 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
296 if (ret)
297 return ret;
298
299 return sysfs_emit(buf, "%lu\n", FIELD_GET(DDR_MAX_BW_MASK, data));
300 }
301
hsmp_ddr_util_bw_show(struct device * dev,struct device_attribute * attr,char * buf)302 static ssize_t hsmp_ddr_util_bw_show(struct device *dev, struct device_attribute *attr,
303 char *buf)
304 {
305 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
306 struct hsmp_socket *sock = dev_get_drvdata(dev);
307 u32 data;
308 int ret;
309
310 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
311 if (ret)
312 return ret;
313
314 return sysfs_emit(buf, "%lu\n", FIELD_GET(DDR_UTIL_BW_MASK, data));
315 }
316
hsmp_ddr_util_bw_perc_show(struct device * dev,struct device_attribute * attr,char * buf)317 static ssize_t hsmp_ddr_util_bw_perc_show(struct device *dev, struct device_attribute *attr,
318 char *buf)
319 {
320 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
321 struct hsmp_socket *sock = dev_get_drvdata(dev);
322 u32 data;
323 int ret;
324
325 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
326 if (ret)
327 return ret;
328
329 return sysfs_emit(buf, "%lu\n", FIELD_GET(DDR_UTIL_BW_PERC_MASK, data));
330 }
331
hsmp_msg_fw_ver_show(struct device * dev,struct device_attribute * attr,char * buf)332 static ssize_t hsmp_msg_fw_ver_show(struct device *dev, struct device_attribute *attr,
333 char *buf)
334 {
335 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
336 struct hsmp_socket *sock = dev_get_drvdata(dev);
337 u32 data;
338 int ret;
339
340 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
341 if (ret)
342 return ret;
343
344 return sysfs_emit(buf, "%lu.%lu.%lu\n",
345 FIELD_GET(FW_VER_MAJOR_MASK, data),
346 FIELD_GET(FW_VER_MINOR_MASK, data),
347 FIELD_GET(FW_VER_DEBUG_MASK, data));
348 }
349
hsmp_fclk_show(struct device * dev,struct device_attribute * attr,char * buf)350 static ssize_t hsmp_fclk_show(struct device *dev, struct device_attribute *attr,
351 char *buf)
352 {
353 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
354 struct hsmp_socket *sock = dev_get_drvdata(dev);
355 u32 data[2];
356 int ret;
357
358 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, data, 2);
359 if (ret)
360 return ret;
361
362 return sysfs_emit(buf, "%u\n", data[0]);
363 }
364
hsmp_mclk_show(struct device * dev,struct device_attribute * attr,char * buf)365 static ssize_t hsmp_mclk_show(struct device *dev, struct device_attribute *attr,
366 char *buf)
367 {
368 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
369 struct hsmp_socket *sock = dev_get_drvdata(dev);
370 u32 data[2];
371 int ret;
372
373 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, data, 2);
374 if (ret)
375 return ret;
376
377 return sysfs_emit(buf, "%u\n", data[1]);
378 }
379
hsmp_clk_fmax_show(struct device * dev,struct device_attribute * attr,char * buf)380 static ssize_t hsmp_clk_fmax_show(struct device *dev, struct device_attribute *attr,
381 char *buf)
382 {
383 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
384 struct hsmp_socket *sock = dev_get_drvdata(dev);
385 u32 data;
386 int ret;
387
388 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
389 if (ret)
390 return ret;
391
392 return sysfs_emit(buf, "%lu\n", FIELD_GET(FMAX_MASK, data));
393 }
394
hsmp_clk_fmin_show(struct device * dev,struct device_attribute * attr,char * buf)395 static ssize_t hsmp_clk_fmin_show(struct device *dev, struct device_attribute *attr,
396 char *buf)
397 {
398 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
399 struct hsmp_socket *sock = dev_get_drvdata(dev);
400 u32 data;
401 int ret;
402
403 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
404 if (ret)
405 return ret;
406
407 return sysfs_emit(buf, "%lu\n", FIELD_GET(FMIN_MASK, data));
408 }
409
hsmp_freq_limit_show(struct device * dev,struct device_attribute * attr,char * buf)410 static ssize_t hsmp_freq_limit_show(struct device *dev, struct device_attribute *attr,
411 char *buf)
412 {
413 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
414 struct hsmp_socket *sock = dev_get_drvdata(dev);
415 u32 data;
416 int ret;
417
418 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
419 if (ret)
420 return ret;
421
422 return sysfs_emit(buf, "%lu\n", FIELD_GET(FREQ_LIMIT_MASK, data));
423 }
424
425 static const char * const freqlimit_srcnames[] = {
426 "cHTC-Active",
427 "PROCHOT",
428 "TDC limit",
429 "PPT Limit",
430 "OPN Max",
431 "Reliability Limit",
432 "APML Agent",
433 "HSMP Agent",
434 };
435
hsmp_freq_limit_source_show(struct device * dev,struct device_attribute * attr,char * buf)436 static ssize_t hsmp_freq_limit_source_show(struct device *dev, struct device_attribute *attr,
437 char *buf)
438 {
439 struct hsmp_sys_attr *hattr = to_hsmp_sys_attr(attr);
440 struct hsmp_socket *sock = dev_get_drvdata(dev);
441 unsigned int index;
442 int len = 0;
443 u16 src_ind;
444 u32 data;
445 int ret;
446
447 ret = hsmp_msg_get_nargs(sock->sock_ind, hattr->msg_id, &data, 1);
448 if (ret)
449 return ret;
450
451 src_ind = FIELD_GET(FREQ_SRC_IND_MASK, data);
452 for (index = 0; index < ARRAY_SIZE(freqlimit_srcnames); index++) {
453 if (!src_ind)
454 break;
455 if (src_ind & 1)
456 len += sysfs_emit_at(buf, len, "%s\n", freqlimit_srcnames[index]);
457 src_ind >>= 1;
458 }
459 return len;
460 }
461
init_acpi(struct device * dev)462 static int init_acpi(struct device *dev)
463 {
464 u16 sock_ind;
465 int ret;
466
467 ret = hsmp_get_uid(dev, &sock_ind);
468 if (ret)
469 return ret;
470 if (sock_ind >= hsmp_pdev->num_sockets)
471 return -EINVAL;
472
473 ret = hsmp_parse_acpi_table(dev, sock_ind);
474 if (ret) {
475 dev_err(dev, "Failed to parse ACPI table\n");
476 return ret;
477 }
478
479 /* Test the hsmp interface */
480 ret = hsmp_test(sock_ind, 0xDEADBEEF);
481 if (ret) {
482 dev_err(dev, "HSMP test message failed on Fam:%x model:%x\n",
483 boot_cpu_data.x86, boot_cpu_data.x86_model);
484 dev_err(dev, "Is HSMP disabled in BIOS ?\n");
485 return ret;
486 }
487
488 ret = hsmp_cache_proto_ver(sock_ind);
489 if (ret) {
490 dev_err(dev, "Failed to read HSMP protocol version\n");
491 return ret;
492 }
493
494 if (hsmp_pdev->proto_ver == HSMP_PROTO_VER6) {
495 ret = hsmp_get_tbl_dram_base(sock_ind);
496 if (ret)
497 dev_info(dev, "Failed to init metric table\n");
498 }
499
500 ret = hsmp_create_sensor(dev, sock_ind);
501 if (ret)
502 dev_info(dev, "Failed to register HSMP sensors with hwmon\n");
503
504 dev_set_drvdata(dev, &hsmp_pdev->sock[sock_ind]);
505
506 return 0;
507 }
508
509 static const struct bin_attribute hsmp_metric_tbl_attr = {
510 .attr = { .name = HSMP_METRICS_TABLE_NAME, .mode = 0444},
511 .read = hsmp_metric_tbl_acpi_read,
512 .size = sizeof(struct hsmp_metric_table),
513 };
514
515 static const struct bin_attribute *hsmp_attr_list[] = {
516 &hsmp_metric_tbl_attr,
517 NULL
518 };
519
520 #define HSMP_DEV_ATTR(_name, _msg_id, _show, _mode) \
521 static struct hsmp_sys_attr hattr_##_name = { \
522 .dattr = __ATTR(_name, _mode, _show, NULL), \
523 .msg_id = _msg_id, \
524 }
525
526 HSMP_DEV_ATTR(c0_residency_input, HSMP_GET_C0_PERCENT, hsmp_msg_resp32_show, 0444);
527 HSMP_DEV_ATTR(prochot_status, HSMP_GET_PROC_HOT, hsmp_msg_resp32_show, 0444);
528 HSMP_DEV_ATTR(smu_fw_version, HSMP_GET_SMU_VER, hsmp_msg_fw_ver_show, 0444);
529 HSMP_DEV_ATTR(protocol_version, HSMP_GET_PROTO_VER, hsmp_msg_resp32_show, 0444);
530 HSMP_DEV_ATTR(cclk_freq_limit_input, HSMP_GET_CCLK_THROTTLE_LIMIT, hsmp_msg_resp32_show, 0444);
531 HSMP_DEV_ATTR(ddr_max_bw, HSMP_GET_DDR_BANDWIDTH, hsmp_ddr_max_bw_show, 0444);
532 HSMP_DEV_ATTR(ddr_utilised_bw_input, HSMP_GET_DDR_BANDWIDTH, hsmp_ddr_util_bw_show, 0444);
533 HSMP_DEV_ATTR(ddr_utilised_bw_perc_input, HSMP_GET_DDR_BANDWIDTH, hsmp_ddr_util_bw_perc_show, 0444);
534 HSMP_DEV_ATTR(fclk_input, HSMP_GET_FCLK_MCLK, hsmp_fclk_show, 0444);
535 HSMP_DEV_ATTR(mclk_input, HSMP_GET_FCLK_MCLK, hsmp_mclk_show, 0444);
536 HSMP_DEV_ATTR(clk_fmax, HSMP_GET_SOCKET_FMAX_FMIN, hsmp_clk_fmax_show, 0444);
537 HSMP_DEV_ATTR(clk_fmin, HSMP_GET_SOCKET_FMAX_FMIN, hsmp_clk_fmin_show, 0444);
538 HSMP_DEV_ATTR(pwr_current_active_freq_limit, HSMP_GET_SOCKET_FREQ_LIMIT,
539 hsmp_freq_limit_show, 0444);
540 HSMP_DEV_ATTR(pwr_current_active_freq_limit_source, HSMP_GET_SOCKET_FREQ_LIMIT,
541 hsmp_freq_limit_source_show, 0444);
542
543 static struct attribute *hsmp_dev_attr_list[] = {
544 &hattr_c0_residency_input.dattr.attr,
545 &hattr_prochot_status.dattr.attr,
546 &hattr_smu_fw_version.dattr.attr,
547 &hattr_protocol_version.dattr.attr,
548 &hattr_cclk_freq_limit_input.dattr.attr,
549 &hattr_ddr_max_bw.dattr.attr,
550 &hattr_ddr_utilised_bw_input.dattr.attr,
551 &hattr_ddr_utilised_bw_perc_input.dattr.attr,
552 &hattr_fclk_input.dattr.attr,
553 &hattr_mclk_input.dattr.attr,
554 &hattr_clk_fmax.dattr.attr,
555 &hattr_clk_fmin.dattr.attr,
556 &hattr_pwr_current_active_freq_limit.dattr.attr,
557 &hattr_pwr_current_active_freq_limit_source.dattr.attr,
558 NULL
559 };
560
561 static const struct attribute_group hsmp_attr_grp = {
562 .bin_attrs = hsmp_attr_list,
563 .attrs = hsmp_dev_attr_list,
564 .is_bin_visible = hsmp_is_sock_attr_visible,
565 .is_visible = hsmp_is_sock_dev_attr_visible,
566 };
567
568 static const struct attribute_group *hsmp_groups[] = {
569 &hsmp_attr_grp,
570 NULL
571 };
572
573 static const struct acpi_device_id amd_hsmp_acpi_ids[] = {
574 {ACPI_HSMP_DEVICE_HID, 0},
575 {}
576 };
577 MODULE_DEVICE_TABLE(acpi, amd_hsmp_acpi_ids);
578
hsmp_acpi_probe(struct platform_device * pdev)579 static int hsmp_acpi_probe(struct platform_device *pdev)
580 {
581 int ret;
582
583 hsmp_pdev = get_hsmp_pdev();
584 if (!hsmp_pdev)
585 return -ENOMEM;
586
587 if (!hsmp_pdev->is_probed) {
588 hsmp_pdev->num_sockets = topology_max_packages();
589 if (!hsmp_pdev->num_sockets) {
590 dev_err(&pdev->dev, "No CPU sockets detected\n");
591 return -ENODEV;
592 }
593
594 hsmp_pdev->sock = devm_kcalloc(&pdev->dev, hsmp_pdev->num_sockets,
595 sizeof(*hsmp_pdev->sock),
596 GFP_KERNEL);
597 if (!hsmp_pdev->sock)
598 return -ENOMEM;
599 }
600
601 ret = init_acpi(&pdev->dev);
602 if (ret) {
603 dev_err(&pdev->dev, "Failed to initialize HSMP interface.\n");
604 return ret;
605 }
606
607 if (!hsmp_pdev->is_probed) {
608 ret = hsmp_misc_register(&pdev->dev);
609 if (ret) {
610 dev_err(&pdev->dev, "Failed to register misc device\n");
611 return ret;
612 }
613 hsmp_pdev->is_probed = true;
614 dev_dbg(&pdev->dev, "AMD HSMP ACPI is probed successfully\n");
615 }
616
617 return 0;
618 }
619
hsmp_acpi_remove(struct platform_device * pdev)620 static void hsmp_acpi_remove(struct platform_device *pdev)
621 {
622 /*
623 * We register only one misc_device even on multi-socket system.
624 * So, deregister should happen only once.
625 */
626 if (hsmp_pdev->is_probed) {
627 hsmp_misc_deregister();
628 hsmp_pdev->is_probed = false;
629 }
630 }
631
632 static struct platform_driver amd_hsmp_driver = {
633 .probe = hsmp_acpi_probe,
634 .remove = hsmp_acpi_remove,
635 .driver = {
636 .name = DRIVER_NAME,
637 .acpi_match_table = amd_hsmp_acpi_ids,
638 .dev_groups = hsmp_groups,
639 },
640 };
641
642 module_platform_driver(amd_hsmp_driver);
643
644 MODULE_IMPORT_NS("AMD_HSMP");
645 MODULE_DESCRIPTION("AMD HSMP Platform Interface Driver");
646 MODULE_VERSION(DRIVER_VERSION);
647 MODULE_LICENSE("GPL");
648