1 /* 2 * Intel Management Engine Interface (Intel MEI) Linux driver 3 * Copyright (c) 2015, Intel Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/interrupt.h> 18 #include <linux/debugfs.h> 19 #include <linux/completion.h> 20 #include <linux/watchdog.h> 21 22 #include <linux/uuid.h> 23 #include <linux/mei_cl_bus.h> 24 25 /* 26 * iAMT Watchdog Device 27 */ 28 #define INTEL_AMT_WATCHDOG_ID "iamt_wdt" 29 30 #define MEI_WDT_DEFAULT_TIMEOUT 120 /* seconds */ 31 #define MEI_WDT_MIN_TIMEOUT 120 /* seconds */ 32 #define MEI_WDT_MAX_TIMEOUT 65535 /* seconds */ 33 34 /* Commands */ 35 #define MEI_MANAGEMENT_CONTROL 0x02 36 37 /* MEI Management Control version number */ 38 #define MEI_MC_VERSION_NUMBER 0x10 39 40 /* Sub Commands */ 41 #define MEI_MC_START_WD_TIMER_REQ 0x13 42 #define MEI_MC_START_WD_TIMER_RES 0x83 43 #define MEI_WDT_STATUS_SUCCESS 0 44 #define MEI_WDT_WDSTATE_NOT_REQUIRED 0x1 45 #define MEI_MC_STOP_WD_TIMER_REQ 0x14 46 47 /** 48 * enum mei_wdt_state - internal watchdog state 49 * 50 * @MEI_WDT_PROBE: wd in probing stage 51 * @MEI_WDT_IDLE: wd is idle and not opened 52 * @MEI_WDT_START: wd was opened, start was called 53 * @MEI_WDT_RUNNING: wd is expecting keep alive pings 54 * @MEI_WDT_STOPPING: wd is stopping and will move to IDLE 55 * @MEI_WDT_NOT_REQUIRED: wd device is not required 56 */ 57 enum mei_wdt_state { 58 MEI_WDT_PROBE, 59 MEI_WDT_IDLE, 60 MEI_WDT_START, 61 MEI_WDT_RUNNING, 62 MEI_WDT_STOPPING, 63 MEI_WDT_NOT_REQUIRED, 64 }; 65 66 static const char *mei_wdt_state_str(enum mei_wdt_state state) 67 { 68 switch (state) { 69 case MEI_WDT_PROBE: 70 return "PROBE"; 71 case MEI_WDT_IDLE: 72 return "IDLE"; 73 case MEI_WDT_START: 74 return "START"; 75 case MEI_WDT_RUNNING: 76 return "RUNNING"; 77 case MEI_WDT_STOPPING: 78 return "STOPPING"; 79 case MEI_WDT_NOT_REQUIRED: 80 return "NOT_REQUIRED"; 81 default: 82 return "unknown"; 83 } 84 } 85 86 /** 87 * struct mei_wdt - mei watchdog driver 88 * @wdd: watchdog device 89 * 90 * @cldev: mei watchdog client device 91 * @state: watchdog internal state 92 * @resp_required: ping required response 93 * @response: ping response completion 94 * @unregister: unregister worker 95 * @reg_lock: watchdog device registration lock 96 * @timeout: watchdog current timeout 97 * 98 * @dbgfs_dir: debugfs dir entry 99 */ 100 struct mei_wdt { 101 struct watchdog_device wdd; 102 103 struct mei_cl_device *cldev; 104 enum mei_wdt_state state; 105 bool resp_required; 106 struct completion response; 107 struct work_struct unregister; 108 struct mutex reg_lock; 109 u16 timeout; 110 111 #if IS_ENABLED(CONFIG_DEBUG_FS) 112 struct dentry *dbgfs_dir; 113 #endif /* CONFIG_DEBUG_FS */ 114 }; 115 116 /* 117 * struct mei_mc_hdr - Management Control Command Header 118 * 119 * @command: Management Control (0x2) 120 * @bytecount: Number of bytes in the message beyond this byte 121 * @subcommand: Management Control Subcommand 122 * @versionnumber: Management Control Version (0x10) 123 */ 124 struct mei_mc_hdr { 125 u8 command; 126 u8 bytecount; 127 u8 subcommand; 128 u8 versionnumber; 129 }; 130 131 /** 132 * struct mei_wdt_start_request watchdog start/ping 133 * 134 * @hdr: Management Control Command Header 135 * @timeout: timeout value 136 * @reserved: reserved (legacy) 137 */ 138 struct mei_wdt_start_request { 139 struct mei_mc_hdr hdr; 140 u16 timeout; 141 u8 reserved[17]; 142 } __packed; 143 144 /** 145 * struct mei_wdt_start_response watchdog start/ping response 146 * 147 * @hdr: Management Control Command Header 148 * @status: operation status 149 * @wdstate: watchdog status bit mask 150 */ 151 struct mei_wdt_start_response { 152 struct mei_mc_hdr hdr; 153 u8 status; 154 u8 wdstate; 155 } __packed; 156 157 /** 158 * struct mei_wdt_stop_request - watchdog stop 159 * 160 * @hdr: Management Control Command Header 161 */ 162 struct mei_wdt_stop_request { 163 struct mei_mc_hdr hdr; 164 } __packed; 165 166 /** 167 * mei_wdt_ping - send wd start/ping command 168 * 169 * @wdt: mei watchdog device 170 * 171 * Return: 0 on success, 172 * negative errno code on failure 173 */ 174 static int mei_wdt_ping(struct mei_wdt *wdt) 175 { 176 struct mei_wdt_start_request req; 177 const size_t req_len = sizeof(req); 178 int ret; 179 180 memset(&req, 0, req_len); 181 req.hdr.command = MEI_MANAGEMENT_CONTROL; 182 req.hdr.bytecount = req_len - offsetof(struct mei_mc_hdr, subcommand); 183 req.hdr.subcommand = MEI_MC_START_WD_TIMER_REQ; 184 req.hdr.versionnumber = MEI_MC_VERSION_NUMBER; 185 req.timeout = wdt->timeout; 186 187 ret = mei_cldev_send(wdt->cldev, (u8 *)&req, req_len); 188 if (ret < 0) 189 return ret; 190 191 return 0; 192 } 193 194 /** 195 * mei_wdt_stop - send wd stop command 196 * 197 * @wdt: mei watchdog device 198 * 199 * Return: 0 on success, 200 * negative errno code on failure 201 */ 202 static int mei_wdt_stop(struct mei_wdt *wdt) 203 { 204 struct mei_wdt_stop_request req; 205 const size_t req_len = sizeof(req); 206 int ret; 207 208 memset(&req, 0, req_len); 209 req.hdr.command = MEI_MANAGEMENT_CONTROL; 210 req.hdr.bytecount = req_len - offsetof(struct mei_mc_hdr, subcommand); 211 req.hdr.subcommand = MEI_MC_STOP_WD_TIMER_REQ; 212 req.hdr.versionnumber = MEI_MC_VERSION_NUMBER; 213 214 ret = mei_cldev_send(wdt->cldev, (u8 *)&req, req_len); 215 if (ret < 0) 216 return ret; 217 218 return 0; 219 } 220 221 /** 222 * mei_wdt_ops_start - wd start command from the watchdog core. 223 * 224 * @wdd: watchdog device 225 * 226 * Return: 0 on success or -ENODEV; 227 */ 228 static int mei_wdt_ops_start(struct watchdog_device *wdd) 229 { 230 struct mei_wdt *wdt = watchdog_get_drvdata(wdd); 231 232 wdt->state = MEI_WDT_START; 233 wdd->timeout = wdt->timeout; 234 return 0; 235 } 236 237 /** 238 * mei_wdt_ops_stop - wd stop command from the watchdog core. 239 * 240 * @wdd: watchdog device 241 * 242 * Return: 0 if success, negative errno code for failure 243 */ 244 static int mei_wdt_ops_stop(struct watchdog_device *wdd) 245 { 246 struct mei_wdt *wdt = watchdog_get_drvdata(wdd); 247 int ret; 248 249 if (wdt->state != MEI_WDT_RUNNING) 250 return 0; 251 252 wdt->state = MEI_WDT_STOPPING; 253 254 ret = mei_wdt_stop(wdt); 255 if (ret) 256 return ret; 257 258 wdt->state = MEI_WDT_IDLE; 259 260 return 0; 261 } 262 263 /** 264 * mei_wdt_ops_ping - wd ping command from the watchdog core. 265 * 266 * @wdd: watchdog device 267 * 268 * Return: 0 if success, negative errno code on failure 269 */ 270 static int mei_wdt_ops_ping(struct watchdog_device *wdd) 271 { 272 struct mei_wdt *wdt = watchdog_get_drvdata(wdd); 273 int ret; 274 275 if (wdt->state != MEI_WDT_START && wdt->state != MEI_WDT_RUNNING) 276 return 0; 277 278 if (wdt->resp_required) 279 init_completion(&wdt->response); 280 281 wdt->state = MEI_WDT_RUNNING; 282 ret = mei_wdt_ping(wdt); 283 if (ret) 284 return ret; 285 286 if (wdt->resp_required) 287 ret = wait_for_completion_killable(&wdt->response); 288 289 return ret; 290 } 291 292 /** 293 * mei_wdt_ops_set_timeout - wd set timeout command from the watchdog core. 294 * 295 * @wdd: watchdog device 296 * @timeout: timeout value to set 297 * 298 * Return: 0 if success, negative errno code for failure 299 */ 300 static int mei_wdt_ops_set_timeout(struct watchdog_device *wdd, 301 unsigned int timeout) 302 { 303 304 struct mei_wdt *wdt = watchdog_get_drvdata(wdd); 305 306 /* valid value is already checked by the caller */ 307 wdt->timeout = timeout; 308 wdd->timeout = timeout; 309 310 return 0; 311 } 312 313 static const struct watchdog_ops wd_ops = { 314 .owner = THIS_MODULE, 315 .start = mei_wdt_ops_start, 316 .stop = mei_wdt_ops_stop, 317 .ping = mei_wdt_ops_ping, 318 .set_timeout = mei_wdt_ops_set_timeout, 319 }; 320 321 /* not const as the firmware_version field need to be retrieved */ 322 static struct watchdog_info wd_info = { 323 .identity = INTEL_AMT_WATCHDOG_ID, 324 .options = WDIOF_KEEPALIVEPING | 325 WDIOF_SETTIMEOUT | 326 WDIOF_ALARMONLY, 327 }; 328 329 /** 330 * __mei_wdt_is_registered - check if wdt is registered 331 * 332 * @wdt: mei watchdog device 333 * 334 * Return: true if the wdt is registered with the watchdog subsystem 335 * Locking: should be called under wdt->reg_lock 336 */ 337 static inline bool __mei_wdt_is_registered(struct mei_wdt *wdt) 338 { 339 return !!watchdog_get_drvdata(&wdt->wdd); 340 } 341 342 /** 343 * mei_wdt_unregister - unregister from the watchdog subsystem 344 * 345 * @wdt: mei watchdog device 346 */ 347 static void mei_wdt_unregister(struct mei_wdt *wdt) 348 { 349 mutex_lock(&wdt->reg_lock); 350 351 if (__mei_wdt_is_registered(wdt)) { 352 watchdog_unregister_device(&wdt->wdd); 353 watchdog_set_drvdata(&wdt->wdd, NULL); 354 memset(&wdt->wdd, 0, sizeof(wdt->wdd)); 355 } 356 357 mutex_unlock(&wdt->reg_lock); 358 } 359 360 /** 361 * mei_wdt_register - register with the watchdog subsystem 362 * 363 * @wdt: mei watchdog device 364 * 365 * Return: 0 if success, negative errno code for failure 366 */ 367 static int mei_wdt_register(struct mei_wdt *wdt) 368 { 369 struct device *dev; 370 int ret; 371 372 if (!wdt || !wdt->cldev) 373 return -EINVAL; 374 375 dev = &wdt->cldev->dev; 376 377 mutex_lock(&wdt->reg_lock); 378 379 if (__mei_wdt_is_registered(wdt)) { 380 ret = 0; 381 goto out; 382 } 383 384 wdt->wdd.info = &wd_info; 385 wdt->wdd.ops = &wd_ops; 386 wdt->wdd.parent = dev; 387 wdt->wdd.timeout = MEI_WDT_DEFAULT_TIMEOUT; 388 wdt->wdd.min_timeout = MEI_WDT_MIN_TIMEOUT; 389 wdt->wdd.max_timeout = MEI_WDT_MAX_TIMEOUT; 390 391 watchdog_set_drvdata(&wdt->wdd, wdt); 392 ret = watchdog_register_device(&wdt->wdd); 393 if (ret) { 394 dev_err(dev, "unable to register watchdog device = %d.\n", ret); 395 watchdog_set_drvdata(&wdt->wdd, NULL); 396 } 397 398 wdt->state = MEI_WDT_IDLE; 399 400 out: 401 mutex_unlock(&wdt->reg_lock); 402 return ret; 403 } 404 405 static void mei_wdt_unregister_work(struct work_struct *work) 406 { 407 struct mei_wdt *wdt = container_of(work, struct mei_wdt, unregister); 408 409 mei_wdt_unregister(wdt); 410 } 411 412 /** 413 * mei_wdt_event_rx - callback for data receive 414 * 415 * @cldev: bus device 416 */ 417 static void mei_wdt_event_rx(struct mei_cl_device *cldev) 418 { 419 struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev); 420 struct mei_wdt_start_response res; 421 const size_t res_len = sizeof(res); 422 int ret; 423 424 ret = mei_cldev_recv(wdt->cldev, (u8 *)&res, res_len); 425 if (ret < 0) { 426 dev_err(&cldev->dev, "failure in recv %d\n", ret); 427 return; 428 } 429 430 /* Empty response can be sent on stop */ 431 if (ret == 0) 432 return; 433 434 if (ret < sizeof(struct mei_mc_hdr)) { 435 dev_err(&cldev->dev, "recv small data %d\n", ret); 436 return; 437 } 438 439 if (res.hdr.command != MEI_MANAGEMENT_CONTROL || 440 res.hdr.versionnumber != MEI_MC_VERSION_NUMBER) { 441 dev_err(&cldev->dev, "wrong command received\n"); 442 return; 443 } 444 445 if (res.hdr.subcommand != MEI_MC_START_WD_TIMER_RES) { 446 dev_warn(&cldev->dev, "unsupported command %d :%s[%d]\n", 447 res.hdr.subcommand, 448 mei_wdt_state_str(wdt->state), 449 wdt->state); 450 return; 451 } 452 453 /* Run the unregistration in a worker as this can be 454 * run only after ping completion, otherwise the flow will 455 * deadlock on watchdog core mutex. 456 */ 457 if (wdt->state == MEI_WDT_RUNNING) { 458 if (res.wdstate & MEI_WDT_WDSTATE_NOT_REQUIRED) { 459 wdt->state = MEI_WDT_NOT_REQUIRED; 460 schedule_work(&wdt->unregister); 461 } 462 goto out; 463 } 464 465 if (wdt->state == MEI_WDT_PROBE) { 466 if (res.wdstate & MEI_WDT_WDSTATE_NOT_REQUIRED) { 467 wdt->state = MEI_WDT_NOT_REQUIRED; 468 } else { 469 /* stop the watchdog and register watchdog device */ 470 mei_wdt_stop(wdt); 471 mei_wdt_register(wdt); 472 } 473 return; 474 } 475 476 dev_warn(&cldev->dev, "not in correct state %s[%d]\n", 477 mei_wdt_state_str(wdt->state), wdt->state); 478 479 out: 480 if (!completion_done(&wdt->response)) 481 complete(&wdt->response); 482 } 483 484 /* 485 * mei_wdt_notify_event - callback for event notification 486 * 487 * @cldev: bus device 488 */ 489 static void mei_wdt_notify_event(struct mei_cl_device *cldev) 490 { 491 struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev); 492 493 if (wdt->state != MEI_WDT_NOT_REQUIRED) 494 return; 495 496 mei_wdt_register(wdt); 497 } 498 499 /** 500 * mei_wdt_event - callback for event receive 501 * 502 * @cldev: bus device 503 * @events: event mask 504 * @context: callback context 505 */ 506 static void mei_wdt_event(struct mei_cl_device *cldev, 507 u32 events, void *context) 508 { 509 if (events & BIT(MEI_CL_EVENT_RX)) 510 mei_wdt_event_rx(cldev); 511 512 if (events & BIT(MEI_CL_EVENT_NOTIF)) 513 mei_wdt_notify_event(cldev); 514 } 515 516 #if IS_ENABLED(CONFIG_DEBUG_FS) 517 518 static ssize_t mei_dbgfs_read_activation(struct file *file, char __user *ubuf, 519 size_t cnt, loff_t *ppos) 520 { 521 struct mei_wdt *wdt = file->private_data; 522 const size_t bufsz = 32; 523 char buf[32]; 524 ssize_t pos; 525 526 mutex_lock(&wdt->reg_lock); 527 pos = scnprintf(buf, bufsz, "%s\n", 528 __mei_wdt_is_registered(wdt) ? "activated" : "deactivated"); 529 mutex_unlock(&wdt->reg_lock); 530 531 return simple_read_from_buffer(ubuf, cnt, ppos, buf, pos); 532 } 533 534 static const struct file_operations dbgfs_fops_activation = { 535 .open = simple_open, 536 .read = mei_dbgfs_read_activation, 537 .llseek = generic_file_llseek, 538 }; 539 540 static ssize_t mei_dbgfs_read_state(struct file *file, char __user *ubuf, 541 size_t cnt, loff_t *ppos) 542 { 543 struct mei_wdt *wdt = file->private_data; 544 const size_t bufsz = 32; 545 char buf[bufsz]; 546 ssize_t pos; 547 548 pos = scnprintf(buf, bufsz, "state: %s\n", 549 mei_wdt_state_str(wdt->state)); 550 551 return simple_read_from_buffer(ubuf, cnt, ppos, buf, pos); 552 } 553 554 static const struct file_operations dbgfs_fops_state = { 555 .open = simple_open, 556 .read = mei_dbgfs_read_state, 557 .llseek = generic_file_llseek, 558 }; 559 560 static void dbgfs_unregister(struct mei_wdt *wdt) 561 { 562 debugfs_remove_recursive(wdt->dbgfs_dir); 563 wdt->dbgfs_dir = NULL; 564 } 565 566 static int dbgfs_register(struct mei_wdt *wdt) 567 { 568 struct dentry *dir, *f; 569 570 dir = debugfs_create_dir(KBUILD_MODNAME, NULL); 571 if (!dir) 572 return -ENOMEM; 573 574 wdt->dbgfs_dir = dir; 575 f = debugfs_create_file("state", S_IRUSR, dir, wdt, &dbgfs_fops_state); 576 if (!f) 577 goto err; 578 579 f = debugfs_create_file("activation", S_IRUSR, 580 dir, wdt, &dbgfs_fops_activation); 581 if (!f) 582 goto err; 583 584 return 0; 585 err: 586 dbgfs_unregister(wdt); 587 return -ENODEV; 588 } 589 590 #else 591 592 static inline void dbgfs_unregister(struct mei_wdt *wdt) {} 593 594 static inline int dbgfs_register(struct mei_wdt *wdt) 595 { 596 return 0; 597 } 598 #endif /* CONFIG_DEBUG_FS */ 599 600 static int mei_wdt_probe(struct mei_cl_device *cldev, 601 const struct mei_cl_device_id *id) 602 { 603 struct mei_wdt *wdt; 604 int ret; 605 606 wdt = kzalloc(sizeof(struct mei_wdt), GFP_KERNEL); 607 if (!wdt) 608 return -ENOMEM; 609 610 wdt->timeout = MEI_WDT_DEFAULT_TIMEOUT; 611 wdt->state = MEI_WDT_PROBE; 612 wdt->cldev = cldev; 613 wdt->resp_required = mei_cldev_ver(cldev) > 0x1; 614 mutex_init(&wdt->reg_lock); 615 init_completion(&wdt->response); 616 INIT_WORK(&wdt->unregister, mei_wdt_unregister_work); 617 618 mei_cldev_set_drvdata(cldev, wdt); 619 620 ret = mei_cldev_enable(cldev); 621 if (ret < 0) { 622 dev_err(&cldev->dev, "Could not enable cl device\n"); 623 goto err_out; 624 } 625 626 ret = mei_cldev_register_event_cb(wdt->cldev, 627 BIT(MEI_CL_EVENT_RX) | 628 BIT(MEI_CL_EVENT_NOTIF), 629 mei_wdt_event, NULL); 630 631 /* on legacy devices notification is not supported 632 * this doesn't fail the registration for RX event 633 */ 634 if (ret && ret != -EOPNOTSUPP) { 635 dev_err(&cldev->dev, "Could not register event ret=%d\n", ret); 636 goto err_disable; 637 } 638 639 wd_info.firmware_version = mei_cldev_ver(cldev); 640 641 if (wdt->resp_required) 642 ret = mei_wdt_ping(wdt); 643 else 644 ret = mei_wdt_register(wdt); 645 646 if (ret) 647 goto err_disable; 648 649 if (dbgfs_register(wdt)) 650 dev_warn(&cldev->dev, "cannot register debugfs\n"); 651 652 return 0; 653 654 err_disable: 655 mei_cldev_disable(cldev); 656 657 err_out: 658 kfree(wdt); 659 660 return ret; 661 } 662 663 static int mei_wdt_remove(struct mei_cl_device *cldev) 664 { 665 struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev); 666 667 /* Free the caller in case of fw initiated or unexpected reset */ 668 if (!completion_done(&wdt->response)) 669 complete(&wdt->response); 670 671 cancel_work_sync(&wdt->unregister); 672 673 mei_wdt_unregister(wdt); 674 675 mei_cldev_disable(cldev); 676 677 dbgfs_unregister(wdt); 678 679 kfree(wdt); 680 681 return 0; 682 } 683 684 #define MEI_UUID_WD UUID_LE(0x05B79A6F, 0x4628, 0x4D7F, \ 685 0x89, 0x9D, 0xA9, 0x15, 0x14, 0xCB, 0x32, 0xAB) 686 687 static struct mei_cl_device_id mei_wdt_tbl[] = { 688 { .uuid = MEI_UUID_WD, .version = MEI_CL_VERSION_ANY }, 689 /* required last entry */ 690 { } 691 }; 692 MODULE_DEVICE_TABLE(mei, mei_wdt_tbl); 693 694 static struct mei_cl_driver mei_wdt_driver = { 695 .id_table = mei_wdt_tbl, 696 .name = KBUILD_MODNAME, 697 698 .probe = mei_wdt_probe, 699 .remove = mei_wdt_remove, 700 }; 701 702 static int __init mei_wdt_init(void) 703 { 704 int ret; 705 706 ret = mei_cldev_driver_register(&mei_wdt_driver); 707 if (ret) { 708 pr_err(KBUILD_MODNAME ": module registration failed\n"); 709 return ret; 710 } 711 return 0; 712 } 713 714 static void __exit mei_wdt_exit(void) 715 { 716 mei_cldev_driver_unregister(&mei_wdt_driver); 717 } 718 719 module_init(mei_wdt_init); 720 module_exit(mei_wdt_exit); 721 722 MODULE_AUTHOR("Intel Corporation"); 723 MODULE_LICENSE("GPL"); 724 MODULE_DESCRIPTION("Device driver for Intel MEI iAMT watchdog"); 725