drivers/hv/hv_util.c

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