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