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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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