1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2010, Microsoft Corporation. 4 * 5 * Authors: 6 * Haiyang Zhang <haiyangz@microsoft.com> 7 * Hank Janssen <hjanssen@microsoft.com> 8 */ 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/init.h> 13 #include <linux/module.h> 14 #include <linux/slab.h> 15 #include <linux/sysctl.h> 16 #include <linux/reboot.h> 17 #include <linux/hyperv.h> 18 #include <linux/clockchips.h> 19 #include <linux/ptp_clock_kernel.h> 20 #include <asm/mshyperv.h> 21 22 #include "hyperv_vmbus.h" 23 24 #define SD_MAJOR 3 25 #define SD_MINOR 0 26 #define SD_MINOR_1 1 27 #define SD_MINOR_2 2 28 #define SD_VERSION_3_1 (SD_MAJOR << 16 | SD_MINOR_1) 29 #define SD_VERSION_3_2 (SD_MAJOR << 16 | SD_MINOR_2) 30 #define SD_VERSION (SD_MAJOR << 16 | SD_MINOR) 31 32 #define SD_MAJOR_1 1 33 #define SD_VERSION_1 (SD_MAJOR_1 << 16 | SD_MINOR) 34 35 #define TS_MAJOR 4 36 #define TS_MINOR 0 37 #define TS_VERSION (TS_MAJOR << 16 | TS_MINOR) 38 39 #define TS_MAJOR_1 1 40 #define TS_VERSION_1 (TS_MAJOR_1 << 16 | TS_MINOR) 41 42 #define TS_MAJOR_3 3 43 #define TS_VERSION_3 (TS_MAJOR_3 << 16 | TS_MINOR) 44 45 #define HB_MAJOR 3 46 #define HB_MINOR 0 47 #define HB_VERSION (HB_MAJOR << 16 | HB_MINOR) 48 49 #define HB_MAJOR_1 1 50 #define HB_VERSION_1 (HB_MAJOR_1 << 16 | HB_MINOR) 51 52 static int sd_srv_version; 53 static int ts_srv_version; 54 static int hb_srv_version; 55 56 #define SD_VER_COUNT 4 57 static const int sd_versions[] = { 58 SD_VERSION_3_2, 59 SD_VERSION_3_1, 60 SD_VERSION, 61 SD_VERSION_1 62 }; 63 64 #define TS_VER_COUNT 3 65 static const int ts_versions[] = { 66 TS_VERSION, 67 TS_VERSION_3, 68 TS_VERSION_1 69 }; 70 71 #define HB_VER_COUNT 2 72 static const int hb_versions[] = { 73 HB_VERSION, 74 HB_VERSION_1 75 }; 76 77 #define FW_VER_COUNT 2 78 static const int fw_versions[] = { 79 UTIL_FW_VERSION, 80 UTIL_WS2K8_FW_VERSION 81 }; 82 83 /* 84 * Send the "hibernate" udev event in a thread context. 85 */ 86 struct hibernate_work_context { 87 struct work_struct work; 88 struct hv_device *dev; 89 }; 90 91 static struct hibernate_work_context hibernate_context; 92 static bool hibernation_supported; 93 94 static void send_hibernate_uevent(struct work_struct *work) 95 { 96 char *uevent_env[2] = { "EVENT=hibernate", NULL }; 97 struct hibernate_work_context *ctx; 98 99 ctx = container_of(work, struct hibernate_work_context, work); 100 101 kobject_uevent_env(&ctx->dev->device.kobj, KOBJ_CHANGE, uevent_env); 102 103 pr_info("Sent hibernation uevent\n"); 104 } 105 106 static int hv_shutdown_init(struct hv_util_service *srv) 107 { 108 struct vmbus_channel *channel = srv->channel; 109 110 INIT_WORK(&hibernate_context.work, send_hibernate_uevent); 111 hibernate_context.dev = channel->device_obj; 112 113 hibernation_supported = hv_is_hibernation_supported(); 114 115 return 0; 116 } 117 118 static void shutdown_onchannelcallback(void *context); 119 static struct hv_util_service util_shutdown = { 120 .util_cb = shutdown_onchannelcallback, 121 .util_init = hv_shutdown_init, 122 }; 123 124 static int hv_timesync_init(struct hv_util_service *srv); 125 static int hv_timesync_pre_suspend(void); 126 static void hv_timesync_deinit(void); 127 128 static void timesync_onchannelcallback(void *context); 129 static struct hv_util_service util_timesynch = { 130 .util_cb = timesync_onchannelcallback, 131 .util_init = hv_timesync_init, 132 .util_pre_suspend = hv_timesync_pre_suspend, 133 .util_deinit = hv_timesync_deinit, 134 }; 135 136 static void heartbeat_onchannelcallback(void *context); 137 static struct hv_util_service util_heartbeat = { 138 .util_cb = heartbeat_onchannelcallback, 139 }; 140 141 static struct hv_util_service util_kvp = { 142 .util_cb = hv_kvp_onchannelcallback, 143 .util_init = hv_kvp_init, 144 .util_init_transport = hv_kvp_init_transport, 145 .util_pre_suspend = hv_kvp_pre_suspend, 146 .util_pre_resume = hv_kvp_pre_resume, 147 .util_deinit = hv_kvp_deinit, 148 }; 149 150 static struct hv_util_service util_vss = { 151 .util_cb = hv_vss_onchannelcallback, 152 .util_init = hv_vss_init, 153 .util_init_transport = hv_vss_init_transport, 154 .util_pre_suspend = hv_vss_pre_suspend, 155 .util_pre_resume = hv_vss_pre_resume, 156 .util_deinit = hv_vss_deinit, 157 }; 158 159 static void perform_shutdown(struct work_struct *dummy) 160 { 161 orderly_poweroff(true); 162 } 163 164 static void perform_restart(struct work_struct *dummy) 165 { 166 orderly_reboot(); 167 } 168 169 /* 170 * Perform the shutdown operation in a thread context. 171 */ 172 static DECLARE_WORK(shutdown_work, perform_shutdown); 173 174 /* 175 * Perform the restart operation in a thread context. 176 */ 177 static DECLARE_WORK(restart_work, perform_restart); 178 179 static void shutdown_onchannelcallback(void *context) 180 { 181 struct vmbus_channel *channel = context; 182 struct work_struct *work = NULL; 183 u32 recvlen; 184 u64 requestid; 185 u8 *shut_txf_buf = util_shutdown.recv_buffer; 186 187 struct shutdown_msg_data *shutdown_msg; 188 189 struct icmsg_hdr *icmsghdrp; 190 191 if (vmbus_recvpacket(channel, shut_txf_buf, HV_HYP_PAGE_SIZE, &recvlen, &requestid)) { 192 pr_err_ratelimited("Shutdown request received. Could not read into shut txf buf\n"); 193 return; 194 } 195 196 if (!recvlen) 197 return; 198 199 /* Ensure recvlen is big enough to read header data */ 200 if (recvlen < ICMSG_HDR) { 201 pr_err_ratelimited("Shutdown request received. Packet length too small: %d\n", 202 recvlen); 203 return; 204 } 205 206 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[sizeof(struct vmbuspipe_hdr)]; 207 208 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 209 if (vmbus_prep_negotiate_resp(icmsghdrp, 210 shut_txf_buf, recvlen, 211 fw_versions, FW_VER_COUNT, 212 sd_versions, SD_VER_COUNT, 213 NULL, &sd_srv_version)) { 214 pr_info("Shutdown IC version %d.%d\n", 215 sd_srv_version >> 16, 216 sd_srv_version & 0xFFFF); 217 } 218 } else if (icmsghdrp->icmsgtype == ICMSGTYPE_SHUTDOWN) { 219 /* Ensure recvlen is big enough to contain shutdown_msg_data struct */ 220 if (recvlen < ICMSG_HDR + sizeof(struct shutdown_msg_data)) { 221 pr_err_ratelimited("Invalid shutdown msg data. Packet length too small: %u\n", 222 recvlen); 223 return; 224 } 225 226 shutdown_msg = (struct shutdown_msg_data *)&shut_txf_buf[ICMSG_HDR]; 227 228 /* 229 * shutdown_msg->flags can be 0(shut down), 2(reboot), 230 * or 4(hibernate). It may bitwise-OR 1, which means 231 * performing the request by force. Linux always tries 232 * to perform the request by force. 233 */ 234 switch (shutdown_msg->flags) { 235 case 0: 236 case 1: 237 icmsghdrp->status = HV_S_OK; 238 work = &shutdown_work; 239 pr_info("Shutdown request received - graceful shutdown initiated\n"); 240 break; 241 case 2: 242 case 3: 243 icmsghdrp->status = HV_S_OK; 244 work = &restart_work; 245 pr_info("Restart request received - graceful restart initiated\n"); 246 break; 247 case 4: 248 case 5: 249 pr_info("Hibernation request received\n"); 250 icmsghdrp->status = hibernation_supported ? 251 HV_S_OK : HV_E_FAIL; 252 if (hibernation_supported) 253 work = &hibernate_context.work; 254 break; 255 default: 256 icmsghdrp->status = HV_E_FAIL; 257 pr_info("Shutdown request received - Invalid request\n"); 258 break; 259 } 260 } else { 261 icmsghdrp->status = HV_E_FAIL; 262 pr_err_ratelimited("Shutdown request received. Invalid msg type: %d\n", 263 icmsghdrp->icmsgtype); 264 } 265 266 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 267 | ICMSGHDRFLAG_RESPONSE; 268 269 vmbus_sendpacket(channel, shut_txf_buf, 270 recvlen, requestid, 271 VM_PKT_DATA_INBAND, 0); 272 273 if (work) 274 schedule_work(work); 275 } 276 277 /* 278 * Set the host time in a process context. 279 */ 280 static struct work_struct adj_time_work; 281 282 /* 283 * The last time sample, received from the host. PTP device responds to 284 * requests by using this data and the current partition-wide time reference 285 * count. 286 */ 287 static struct { 288 u64 host_time; 289 u64 ref_time; 290 spinlock_t lock; 291 } host_ts; 292 293 static bool timesync_implicit; 294 295 module_param(timesync_implicit, bool, 0644); 296 MODULE_PARM_DESC(timesync_implicit, "If set treat SAMPLE as SYNC when clock is behind"); 297 298 static inline u64 reftime_to_ns(u64 reftime) 299 { 300 return (reftime - WLTIMEDELTA) * 100; 301 } 302 303 /* 304 * Hard coded threshold for host timesync delay: 600 seconds 305 */ 306 static const u64 HOST_TIMESYNC_DELAY_THRESH = 600 * (u64)NSEC_PER_SEC; 307 308 static int hv_get_adj_host_time(struct timespec64 *ts) 309 { 310 u64 newtime, reftime, timediff_adj; 311 unsigned long flags; 312 int ret = 0; 313 314 spin_lock_irqsave(&host_ts.lock, flags); 315 reftime = hv_read_reference_counter(); 316 317 /* 318 * We need to let the caller know that last update from host 319 * is older than the max allowable threshold. clock_gettime() 320 * and PTP ioctl do not have a documented error that we could 321 * return for this specific case. Use ESTALE to report this. 322 */ 323 timediff_adj = reftime - host_ts.ref_time; 324 if (timediff_adj * 100 > HOST_TIMESYNC_DELAY_THRESH) { 325 pr_warn_once("TIMESYNC IC: Stale time stamp, %llu nsecs old\n", 326 (timediff_adj * 100)); 327 ret = -ESTALE; 328 } 329 330 newtime = host_ts.host_time + timediff_adj; 331 *ts = ns_to_timespec64(reftime_to_ns(newtime)); 332 spin_unlock_irqrestore(&host_ts.lock, flags); 333 334 return ret; 335 } 336 337 static void hv_set_host_time(struct work_struct *work) 338 { 339 340 struct timespec64 ts; 341 342 if (!hv_get_adj_host_time(&ts)) 343 do_settimeofday64(&ts); 344 } 345 346 /* 347 * Due to a bug on Hyper-V hosts, the sync flag may not always be sent on resume. 348 * Force a sync if the guest is behind. 349 */ 350 static inline bool hv_implicit_sync(u64 host_time) 351 { 352 struct timespec64 new_ts; 353 struct timespec64 threshold_ts; 354 355 new_ts = ns_to_timespec64(reftime_to_ns(host_time)); 356 ktime_get_real_ts64(&threshold_ts); 357 358 threshold_ts.tv_sec += 5; 359 360 /* 361 * If guest behind the host by 5 or more seconds. 362 */ 363 if (timespec64_compare(&new_ts, &threshold_ts) >= 0) 364 return true; 365 366 return false; 367 } 368 369 /* 370 * Synchronize time with host after reboot, restore, etc. 371 * 372 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM. 373 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time 374 * message after the timesync channel is opened. Since the hv_utils module is 375 * loaded after hv_vmbus, the first message is usually missed. This bit is 376 * considered a hard request to discipline the clock. 377 * 378 * ICTIMESYNCFLAG_SAMPLE bit indicates a time sample from host. This is 379 * typically used as a hint to the guest. The guest is under no obligation 380 * to discipline the clock. 381 */ 382 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 adj_flags) 383 { 384 unsigned long flags; 385 u64 cur_reftime; 386 387 /* 388 * Save the adjusted time sample from the host and the snapshot 389 * of the current system time. 390 */ 391 spin_lock_irqsave(&host_ts.lock, flags); 392 393 cur_reftime = hv_read_reference_counter(); 394 host_ts.host_time = hosttime; 395 host_ts.ref_time = cur_reftime; 396 397 /* 398 * TimeSync v4 messages contain reference time (guest's Hyper-V 399 * clocksource read when the time sample was generated), we can 400 * improve the precision by adding the delta between now and the 401 * time of generation. For older protocols we set 402 * reftime == cur_reftime on call. 403 */ 404 host_ts.host_time += (cur_reftime - reftime); 405 406 spin_unlock_irqrestore(&host_ts.lock, flags); 407 408 /* Schedule work to do do_settimeofday64() */ 409 if ((adj_flags & ICTIMESYNCFLAG_SYNC) || 410 (timesync_implicit && hv_implicit_sync(host_ts.host_time))) 411 schedule_work(&adj_time_work); 412 } 413 414 /* 415 * Time Sync Channel message handler. 416 */ 417 static void timesync_onchannelcallback(void *context) 418 { 419 struct vmbus_channel *channel = context; 420 u32 recvlen; 421 u64 requestid; 422 struct icmsg_hdr *icmsghdrp; 423 struct ictimesync_data *timedatap; 424 struct ictimesync_ref_data *refdata; 425 u8 *time_txf_buf = util_timesynch.recv_buffer; 426 427 /* 428 * Drain the ring buffer and use the last packet to update 429 * host_ts 430 */ 431 while (1) { 432 int ret = vmbus_recvpacket(channel, time_txf_buf, 433 HV_HYP_PAGE_SIZE, &recvlen, 434 &requestid); 435 if (ret) { 436 pr_err_ratelimited("TimeSync IC pkt recv failed (Err: %d)\n", 437 ret); 438 break; 439 } 440 441 if (!recvlen) 442 break; 443 444 /* Ensure recvlen is big enough to read header data */ 445 if (recvlen < ICMSG_HDR) { 446 pr_err_ratelimited("Timesync request received. Packet length too small: %d\n", 447 recvlen); 448 break; 449 } 450 451 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[ 452 sizeof(struct vmbuspipe_hdr)]; 453 454 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 455 if (vmbus_prep_negotiate_resp(icmsghdrp, 456 time_txf_buf, recvlen, 457 fw_versions, FW_VER_COUNT, 458 ts_versions, TS_VER_COUNT, 459 NULL, &ts_srv_version)) { 460 pr_info("TimeSync IC version %d.%d\n", 461 ts_srv_version >> 16, 462 ts_srv_version & 0xFFFF); 463 } 464 } else if (icmsghdrp->icmsgtype == ICMSGTYPE_TIMESYNC) { 465 if (ts_srv_version > TS_VERSION_3) { 466 /* Ensure recvlen is big enough to read ictimesync_ref_data */ 467 if (recvlen < ICMSG_HDR + sizeof(struct ictimesync_ref_data)) { 468 pr_err_ratelimited("Invalid ictimesync ref data. Length too small: %u\n", 469 recvlen); 470 break; 471 } 472 refdata = (struct ictimesync_ref_data *)&time_txf_buf[ICMSG_HDR]; 473 474 adj_guesttime(refdata->parenttime, 475 refdata->vmreferencetime, 476 refdata->flags); 477 } else { 478 /* Ensure recvlen is big enough to read ictimesync_data */ 479 if (recvlen < ICMSG_HDR + sizeof(struct ictimesync_data)) { 480 pr_err_ratelimited("Invalid ictimesync data. Length too small: %u\n", 481 recvlen); 482 break; 483 } 484 timedatap = (struct ictimesync_data *)&time_txf_buf[ICMSG_HDR]; 485 486 adj_guesttime(timedatap->parenttime, 487 hv_read_reference_counter(), 488 timedatap->flags); 489 } 490 } else { 491 icmsghdrp->status = HV_E_FAIL; 492 pr_err_ratelimited("Timesync request received. Invalid msg type: %d\n", 493 icmsghdrp->icmsgtype); 494 } 495 496 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 497 | ICMSGHDRFLAG_RESPONSE; 498 499 vmbus_sendpacket(channel, time_txf_buf, 500 recvlen, requestid, 501 VM_PKT_DATA_INBAND, 0); 502 } 503 } 504 505 /* 506 * Heartbeat functionality. 507 * Every two seconds, Hyper-V send us a heartbeat request message. 508 * we respond to this message, and Hyper-V knows we are alive. 509 */ 510 static void heartbeat_onchannelcallback(void *context) 511 { 512 struct vmbus_channel *channel = context; 513 u32 recvlen; 514 u64 requestid; 515 struct icmsg_hdr *icmsghdrp; 516 struct heartbeat_msg_data *heartbeat_msg; 517 u8 *hbeat_txf_buf = util_heartbeat.recv_buffer; 518 519 while (1) { 520 521 if (vmbus_recvpacket(channel, hbeat_txf_buf, HV_HYP_PAGE_SIZE, 522 &recvlen, &requestid)) { 523 pr_err_ratelimited("Heartbeat request received. Could not read into hbeat txf buf\n"); 524 return; 525 } 526 527 if (!recvlen) 528 break; 529 530 /* Ensure recvlen is big enough to read header data */ 531 if (recvlen < ICMSG_HDR) { 532 pr_err_ratelimited("Heartbeat request received. Packet length too small: %d\n", 533 recvlen); 534 break; 535 } 536 537 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[ 538 sizeof(struct vmbuspipe_hdr)]; 539 540 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 541 if (vmbus_prep_negotiate_resp(icmsghdrp, 542 hbeat_txf_buf, recvlen, 543 fw_versions, FW_VER_COUNT, 544 hb_versions, HB_VER_COUNT, 545 NULL, &hb_srv_version)) { 546 547 pr_info("Heartbeat IC version %d.%d\n", 548 hb_srv_version >> 16, 549 hb_srv_version & 0xFFFF); 550 } 551 } else if (icmsghdrp->icmsgtype == ICMSGTYPE_HEARTBEAT) { 552 /* 553 * Ensure recvlen is big enough to read seq_num. Reserved area is not 554 * included in the check as the host may not fill it up entirely 555 */ 556 if (recvlen < ICMSG_HDR + sizeof(u64)) { 557 pr_err_ratelimited("Invalid heartbeat msg data. Length too small: %u\n", 558 recvlen); 559 break; 560 } 561 heartbeat_msg = (struct heartbeat_msg_data *)&hbeat_txf_buf[ICMSG_HDR]; 562 563 heartbeat_msg->seq_num += 1; 564 } else { 565 icmsghdrp->status = HV_E_FAIL; 566 pr_err_ratelimited("Heartbeat request received. Invalid msg type: %d\n", 567 icmsghdrp->icmsgtype); 568 } 569 570 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 571 | ICMSGHDRFLAG_RESPONSE; 572 573 vmbus_sendpacket(channel, hbeat_txf_buf, 574 recvlen, requestid, 575 VM_PKT_DATA_INBAND, 0); 576 } 577 } 578 579 #define HV_UTIL_RING_SEND_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) 580 #define HV_UTIL_RING_RECV_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) 581 582 static int util_probe(struct hv_device *dev, 583 const struct hv_vmbus_device_id *dev_id) 584 { 585 struct hv_util_service *srv = 586 (struct hv_util_service *)dev_id->driver_data; 587 int ret; 588 589 srv->recv_buffer = kmalloc(HV_HYP_PAGE_SIZE * 4, GFP_KERNEL); 590 if (!srv->recv_buffer) 591 return -ENOMEM; 592 srv->channel = dev->channel; 593 if (srv->util_init) { 594 ret = srv->util_init(srv); 595 if (ret) 596 goto error1; 597 } 598 599 /* 600 * The set of services managed by the util driver are not performance 601 * critical and do not need batched reading. Furthermore, some services 602 * such as KVP can only handle one message from the host at a time. 603 * Turn off batched reading for all util drivers before we open the 604 * channel. 605 */ 606 set_channel_read_mode(dev->channel, HV_CALL_DIRECT); 607 608 hv_set_drvdata(dev, srv); 609 610 ret = vmbus_open(dev->channel, HV_UTIL_RING_SEND_SIZE, 611 HV_UTIL_RING_RECV_SIZE, NULL, 0, srv->util_cb, 612 dev->channel); 613 if (ret) 614 goto error; 615 616 if (srv->util_init_transport) { 617 ret = srv->util_init_transport(); 618 if (ret) { 619 vmbus_close(dev->channel); 620 goto error; 621 } 622 } 623 return 0; 624 625 error: 626 if (srv->util_deinit) 627 srv->util_deinit(); 628 error1: 629 kfree(srv->recv_buffer); 630 return ret; 631 } 632 633 static void util_remove(struct hv_device *dev) 634 { 635 struct hv_util_service *srv = hv_get_drvdata(dev); 636 637 if (srv->util_deinit) 638 srv->util_deinit(); 639 vmbus_close(dev->channel); 640 kfree(srv->recv_buffer); 641 } 642 643 /* 644 * When we're in util_suspend(), all the userspace processes have been frozen 645 * (refer to hibernate() -> freeze_processes()). The userspace is thawed only 646 * after the whole resume procedure, including util_resume(), finishes. 647 */ 648 static int util_suspend(struct hv_device *dev) 649 { 650 struct hv_util_service *srv = hv_get_drvdata(dev); 651 int ret = 0; 652 653 if (srv->util_pre_suspend) { 654 ret = srv->util_pre_suspend(); 655 if (ret) 656 return ret; 657 } 658 659 vmbus_close(dev->channel); 660 661 return 0; 662 } 663 664 static int util_resume(struct hv_device *dev) 665 { 666 struct hv_util_service *srv = hv_get_drvdata(dev); 667 int ret = 0; 668 669 if (srv->util_pre_resume) { 670 ret = srv->util_pre_resume(); 671 if (ret) 672 return ret; 673 } 674 675 ret = vmbus_open(dev->channel, HV_UTIL_RING_SEND_SIZE, 676 HV_UTIL_RING_RECV_SIZE, NULL, 0, srv->util_cb, 677 dev->channel); 678 return ret; 679 } 680 681 static const struct hv_vmbus_device_id id_table[] = { 682 /* Shutdown guid */ 683 { HV_SHUTDOWN_GUID, 684 .driver_data = (unsigned long)&util_shutdown 685 }, 686 /* Time synch guid */ 687 { HV_TS_GUID, 688 .driver_data = (unsigned long)&util_timesynch 689 }, 690 /* Heartbeat guid */ 691 { HV_HEART_BEAT_GUID, 692 .driver_data = (unsigned long)&util_heartbeat 693 }, 694 /* KVP guid */ 695 { HV_KVP_GUID, 696 .driver_data = (unsigned long)&util_kvp 697 }, 698 /* VSS GUID */ 699 { HV_VSS_GUID, 700 .driver_data = (unsigned long)&util_vss 701 }, 702 { }, 703 }; 704 705 MODULE_DEVICE_TABLE(vmbus, id_table); 706 707 /* The one and only one */ 708 static struct hv_driver util_drv = { 709 .name = "hv_utils", 710 .id_table = id_table, 711 .probe = util_probe, 712 .remove = util_remove, 713 .suspend = util_suspend, 714 .resume = util_resume, 715 .driver = { 716 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 717 }, 718 }; 719 720 static int hv_ptp_enable(struct ptp_clock_info *info, 721 struct ptp_clock_request *request, int on) 722 { 723 return -EOPNOTSUPP; 724 } 725 726 static int hv_ptp_settime(struct ptp_clock_info *p, const struct timespec64 *ts) 727 { 728 return -EOPNOTSUPP; 729 } 730 731 static int hv_ptp_adjfine(struct ptp_clock_info *ptp, long delta) 732 { 733 return -EOPNOTSUPP; 734 } 735 static int hv_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) 736 { 737 return -EOPNOTSUPP; 738 } 739 740 static int hv_ptp_gettime(struct ptp_clock_info *info, struct timespec64 *ts) 741 { 742 return hv_get_adj_host_time(ts); 743 } 744 745 static struct ptp_clock_info ptp_hyperv_info = { 746 .name = "hyperv", 747 .enable = hv_ptp_enable, 748 .adjtime = hv_ptp_adjtime, 749 .adjfine = hv_ptp_adjfine, 750 .gettime64 = hv_ptp_gettime, 751 .settime64 = hv_ptp_settime, 752 .owner = THIS_MODULE, 753 }; 754 755 static struct ptp_clock *hv_ptp_clock; 756 757 static int hv_timesync_init(struct hv_util_service *srv) 758 { 759 spin_lock_init(&host_ts.lock); 760 761 INIT_WORK(&adj_time_work, hv_set_host_time); 762 763 /* 764 * ptp_clock_register() returns NULL when CONFIG_PTP_1588_CLOCK is 765 * disabled but the driver is still useful without the PTP device 766 * as it still handles the ICTIMESYNCFLAG_SYNC case. 767 */ 768 hv_ptp_clock = ptp_clock_register(&ptp_hyperv_info, NULL); 769 if (IS_ERR_OR_NULL(hv_ptp_clock)) { 770 pr_err("cannot register PTP clock: %d\n", 771 PTR_ERR_OR_ZERO(hv_ptp_clock)); 772 hv_ptp_clock = NULL; 773 } 774 775 return 0; 776 } 777 778 static void hv_timesync_cancel_work(void) 779 { 780 cancel_work_sync(&adj_time_work); 781 } 782 783 static int hv_timesync_pre_suspend(void) 784 { 785 hv_timesync_cancel_work(); 786 return 0; 787 } 788 789 static void hv_timesync_deinit(void) 790 { 791 if (hv_ptp_clock) 792 ptp_clock_unregister(hv_ptp_clock); 793 794 hv_timesync_cancel_work(); 795 } 796 797 static int __init init_hyperv_utils(void) 798 { 799 pr_info("Registering HyperV Utility Driver\n"); 800 801 return vmbus_driver_register(&util_drv); 802 } 803 804 static void exit_hyperv_utils(void) 805 { 806 pr_info("De-Registered HyperV Utility Driver\n"); 807 808 vmbus_driver_unregister(&util_drv); 809 } 810 811 module_init(init_hyperv_utils); 812 module_exit(exit_hyperv_utils); 813 814 MODULE_DESCRIPTION("Hyper-V Utilities"); 815 MODULE_LICENSE("GPL"); 816