sys/dev/hyperv/vmbus/hv_vmbus_priv.h

   1 /*-
   2  * Copyright (c) 2009-2012,2016 Microsoft Corp.
   3  * Copyright (c) 2012 NetApp Inc.
   4  * Copyright (c) 2012 Citrix Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #ifndef __HYPERV_PRIV_H__
  32 #define __HYPERV_PRIV_H__
  33
  34 #include <sys/param.h>
  35 #include <sys/lock.h>
  36 #include <sys/mutex.h>
  37 #include <sys/sema.h>
  38
  39 #include <dev/hyperv/include/hyperv.h>
  40
  41
  42 /*
  43  *  Status codes for hypervisor operations.
  44  */
  45
  46 typedef uint16_t hv_vmbus_status;
  47
  48 #define HV_MESSAGE_SIZE                 (256)
  49 #define HV_MESSAGE_PAYLOAD_BYTE_COUNT   (240)
  50 #define HV_MESSAGE_PAYLOAD_QWORD_COUNT  (30)
  51 #define HV_ANY_VP                       (0xFFFFFFFF)
  52
  53 /*
  54  * Synthetic interrupt controller flag constants.
  55  */
  56
  57 #define HV_EVENT_FLAGS_COUNT        (256 * 8)
  58 #define HV_EVENT_FLAGS_BYTE_COUNT   (256)
  59 #define HV_EVENT_FLAGS_DWORD_COUNT  (256 / sizeof(uint32_t))
  60 #define HV_EVENT_FLAGS_ULONG_COUNT  (256 / sizeof(unsigned long))
  61
  62 /**
  63  * max channel count <== event_flags_dword_count * bit_of_dword
  64  */
  65 #ifdef __LP64__
  66 #define HV_CHANNEL_ULONG_LEN        (64)
  67 #define HV_CHANNEL_ULONG_SHIFT      (6)
  68 #else
  69 #define HV_CHANNEL_ULONG_LEN        (32)
  70 #define HV_CHANNEL_ULONG_SHIFT      (5)
  71 #endif
  72 #define HV_CHANNEL_DWORD_LEN        (32)
  73 #define HV_CHANNEL_MAX_COUNT        \
  74         ((HV_EVENT_FLAGS_DWORD_COUNT) * HV_CHANNEL_DWORD_LEN)
  75 /*
  76  * MessageId: HV_STATUS_INSUFFICIENT_BUFFERS
  77  * MessageText:
  78  *    You did not supply enough message buffers to send a message.
  79  */
  80
  81 #define HV_STATUS_SUCCESS                ((uint16_t)0)
  82 #define HV_STATUS_INSUFFICIENT_BUFFERS   ((uint16_t)0x0013)
  83
  84 typedef void (*hv_vmbus_channel_callback)(void *context);
  85
  86 typedef struct {
  87         void*           data;
  88         uint32_t        length;
  89 } hv_vmbus_sg_buffer_list;
  90
  91 typedef struct {
  92         uint32_t        current_interrupt_mask;
  93         uint32_t        current_read_index;
  94         uint32_t        current_write_index;
  95         uint32_t        bytes_avail_to_read;
  96         uint32_t        bytes_avail_to_write;
  97 } hv_vmbus_ring_buffer_debug_info;
  98
  99 typedef struct {
 100         uint32_t                rel_id;
 101         hv_vmbus_channel_state  state;
 102         hv_guid                 interface_type;
 103         hv_guid                 interface_instance;
 104         uint32_t                monitor_id;
 105         uint32_t                server_monitor_pending;
 106         uint32_t                server_monitor_latency;
 107         uint32_t                server_monitor_connection_id;
 108         uint32_t                client_monitor_pending;
 109         uint32_t                client_monitor_latency;
 110         uint32_t                client_monitor_connection_id;
 111         hv_vmbus_ring_buffer_debug_info inbound;
 112         hv_vmbus_ring_buffer_debug_info outbound;
 113 } hv_vmbus_channel_debug_info;
 114
 115 typedef union {
 116         hv_vmbus_channel_version_supported      version_supported;
 117         hv_vmbus_channel_open_result            open_result;
 118         hv_vmbus_channel_gpadl_torndown         gpadl_torndown;
 119         hv_vmbus_channel_gpadl_created          gpadl_created;
 120         hv_vmbus_channel_version_response       version_response;
 121 } hv_vmbus_channel_msg_response;
 122
 123 /*
 124  * Represents each channel msg on the vmbus connection
 125  * This is a variable-size data structure depending on
 126  * the msg type itself
 127  */
 128 typedef struct hv_vmbus_channel_msg_info {
 129         /*
 130          * Bookkeeping stuff
 131          */
 132         TAILQ_ENTRY(hv_vmbus_channel_msg_info)  msg_list_entry;
 133         /*
 134          * So far, this is only used to handle
 135          * gpadl body message
 136          */
 137         TAILQ_HEAD(, hv_vmbus_channel_msg_info) sub_msg_list_anchor;
 138         /*
 139          * Synchronize the request/response if
 140          * needed.
 141          * KYS: Use a semaphore for now.
 142          * Not perf critical.
 143          */
 144         struct sema                             wait_sema;
 145         hv_vmbus_channel_msg_response           response;
 146         uint32_t                                message_size;
 147         /**
 148          * The channel message that goes out on
 149          *  the "wire". It will contain at
 150          *  minimum the
 151          *  hv_vmbus_channel_msg_header
 152          * header.
 153          */
 154         unsigned char                           msg[0];
 155 } hv_vmbus_channel_msg_info;
 156
 157 /*
 158  * The format must be the same as hv_vm_data_gpa_direct
 159  */
 160 typedef struct hv_vmbus_channel_packet_page_buffer {
 161         uint16_t                type;
 162         uint16_t                data_offset8;
 163         uint16_t                length8;
 164         uint16_t                flags;
 165         uint64_t                transaction_id;
 166         uint32_t                reserved;
 167         uint32_t                range_count;
 168         hv_vmbus_page_buffer    range[HV_MAX_PAGE_BUFFER_COUNT];
 169 } __packed hv_vmbus_channel_packet_page_buffer;
 170
 171 /*
 172  * The format must be the same as hv_vm_data_gpa_direct
 173  */
 174 typedef struct hv_vmbus_channel_packet_multipage_buffer {
 175         uint16_t                        type;
 176         uint16_t                        data_offset8;
 177         uint16_t                        length8;
 178         uint16_t                        flags;
 179         uint64_t                        transaction_id;
 180         uint32_t                        reserved;
 181         uint32_t                        range_count; /* Always 1 in this case */
 182         hv_vmbus_multipage_buffer       range;
 183 } __packed hv_vmbus_channel_packet_multipage_buffer;
 184
 185 enum {
 186         HV_VMBUS_MESSAGE_CONNECTION_ID  = 1,
 187         HV_VMBUS_MESSAGE_PORT_ID        = 1,
 188         HV_VMBUS_EVENT_CONNECTION_ID    = 2,
 189         HV_VMBUS_EVENT_PORT_ID          = 2,
 190         HV_VMBUS_MONITOR_CONNECTION_ID  = 3,
 191         HV_VMBUS_MONITOR_PORT_ID        = 3,
 192         HV_VMBUS_MESSAGE_SINT           = 2,
 193         HV_VMBUS_TIMER_SINT             = 4,
 194 };
 195
 196 #define HV_PRESENT_BIT          0x80000000
 197
 198 #define HV_HYPERCALL_PARAM_ALIGN sizeof(uint64_t)
 199
 200 typedef struct {
 201         hv_bool_uint8_t syn_ic_initialized;
 202
 203         hv_vmbus_handle syn_ic_msg_page[MAXCPU];
 204         hv_vmbus_handle syn_ic_event_page[MAXCPU];
 205         /*
 206          * For FreeBSD cpuid to Hyper-V vcpuid mapping.
 207          */
 208         uint32_t        hv_vcpu_index[MAXCPU];
 209         /*
 210          * Each cpu has its own software interrupt handler for channel
 211          * event and msg handling.
 212          */
 213         struct taskqueue                *hv_event_queue[MAXCPU];
 214         struct taskqueue                *hv_msg_tq[MAXCPU];
 215         struct task                     hv_msg_task[MAXCPU];
 216         /*
 217          * Host use this vector to interrupt guest for vmbus channel
 218          * event and msg.
 219          */
 220         int                             hv_cb_vector;
 221 } hv_vmbus_context;
 222
 223 /*
 224  * Define hypervisor message types
 225  */
 226 typedef enum {
 227
 228         HV_MESSAGE_TYPE_NONE                            = 0x00000000,
 229
 230         /*
 231          * Memory access messages
 232          */
 233         HV_MESSAGE_TYPE_UNMAPPED_GPA                    = 0x80000000,
 234         HV_MESSAGE_TYPE_GPA_INTERCEPT                   = 0x80000001,
 235
 236         /*
 237          * Timer notification messages
 238          */
 239         HV_MESSAGE_TIMER_EXPIRED                        = 0x80000010,
 240
 241         /*
 242          * Error messages
 243          */
 244         HV_MESSAGE_TYPE_INVALID_VP_REGISTER_VALUE       = 0x80000020,
 245         HV_MESSAGE_TYPE_UNRECOVERABLE_EXCEPTION         = 0x80000021,
 246         HV_MESSAGE_TYPE_UNSUPPORTED_FEATURE             = 0x80000022,
 247
 248         /*
 249          * Trace buffer complete messages
 250          */
 251         HV_MESSAGE_TYPE_EVENT_LOG_BUFFER_COMPLETE       = 0x80000040,
 252
 253         /*
 254          * Platform-specific processor intercept messages
 255          */
 256         HV_MESSAGE_TYPE_X64_IO_PORT_INTERCEPT           = 0x80010000,
 257         HV_MESSAGE_TYPE_X64_MSR_INTERCEPT               = 0x80010001,
 258         HV_MESSAGE_TYPE_X64_CPU_INTERCEPT               = 0x80010002,
 259         HV_MESSAGE_TYPE_X64_EXCEPTION_INTERCEPT         = 0x80010003,
 260         HV_MESSAGE_TYPE_X64_APIC_EOI                    = 0x80010004,
 261         HV_MESSAGE_TYPE_X64_LEGACY_FP_ERROR             = 0x80010005
 262
 263 } hv_vmbus_msg_type;
 264
 265 /*
 266  * Define port identifier type
 267  */
 268 typedef union _hv_vmbus_port_id {
 269         uint32_t        as_uint32_t;
 270         struct {
 271                 uint32_t        id:24;
 272                 uint32_t        reserved:8;
 273         } u ;
 274 } hv_vmbus_port_id;
 275
 276 /*
 277  * Define synthetic interrupt controller message flag
 278  */
 279 typedef union {
 280         uint8_t as_uint8_t;
 281         struct {
 282                 uint8_t message_pending:1;
 283                 uint8_t reserved:7;
 284         } u;
 285 } hv_vmbus_msg_flags;
 286
 287 typedef uint64_t hv_vmbus_partition_id;
 288
 289 /*
 290  * Define synthetic interrupt controller message header
 291  */
 292 typedef struct {
 293         hv_vmbus_msg_type       message_type;
 294         uint8_t                 payload_size;
 295         hv_vmbus_msg_flags      message_flags;
 296         uint8_t                 reserved[2];
 297         union {
 298                 hv_vmbus_partition_id   sender;
 299                 hv_vmbus_port_id        port;
 300         } u;
 301 } hv_vmbus_msg_header;
 302
 303 /*
 304  *  Define synthetic interrupt controller message format
 305  */
 306 typedef struct {
 307         hv_vmbus_msg_header     header;
 308         union {
 309                 uint64_t        payload[HV_MESSAGE_PAYLOAD_QWORD_COUNT];
 310         } u ;
 311 } hv_vmbus_message;
 312
 313 /*
 314  *  Maximum channels is determined by the size of the interrupt
 315  *  page which is PAGE_SIZE. 1/2 of PAGE_SIZE is for
 316  *  send endpoint interrupt and the other is receive
 317  *  endpoint interrupt.
 318  *
 319  *   Note: (PAGE_SIZE >> 1) << 3 allocates 16348 channels
 320  */
 321 #define HV_MAX_NUM_CHANNELS                     (PAGE_SIZE >> 1) << 3
 322
 323 /*
 324  * (The value here must be in multiple of 32)
 325  */
 326 #define HV_MAX_NUM_CHANNELS_SUPPORTED           256
 327
 328 /*
 329  * VM Bus connection states
 330  */
 331 typedef enum {
 332         HV_DISCONNECTED,
 333         HV_CONNECTING,
 334         HV_CONNECTED,
 335         HV_DISCONNECTING
 336 } hv_vmbus_connect_state;
 337
 338 #define HV_MAX_SIZE_CHANNEL_MESSAGE     HV_MESSAGE_PAYLOAD_BYTE_COUNT
 339
 340
 341 typedef struct {
 342         hv_vmbus_connect_state                  connect_state;
 343         uint32_t                                next_gpadl_handle;
 344         /**
 345          * Represents channel interrupts. Each bit position
 346          * represents a channel.
 347          * When a channel sends an interrupt via VMBUS, it
 348          * finds its bit in the send_interrupt_page, set it and
 349          * calls Hv to generate a port event. The other end
 350          * receives the port event and parse the
 351          * recv_interrupt_page to see which bit is set
 352          */
 353         void                                    *interrupt_page;
 354         void                                    *send_interrupt_page;
 355         void                                    *recv_interrupt_page;
 356         /*
 357          * 2 pages - 1st page for parent->child
 358          * notification and 2nd is child->parent
 359          * notification
 360          */
 361         void                                    *monitor_page_1;
 362         void                                    *monitor_page_2;
 363         TAILQ_HEAD(, hv_vmbus_channel_msg_info) channel_msg_anchor;
 364         struct mtx                              channel_msg_lock;
 365         /**
 366          * List of primary channels. Sub channels will be linked
 367          * under their primary channel.
 368          */
 369         TAILQ_HEAD(, hv_vmbus_channel)          channel_anchor;
 370         struct mtx                              channel_lock;
 371
 372         /**
 373          * channel table for fast lookup through id.
 374         */
 375         hv_vmbus_channel                        **channels;
 376 } hv_vmbus_connection;
 377
 378 typedef union {
 379         uint64_t as_uint64_t;
 380         struct {
 381                 uint64_t build_number           : 16;
 382                 uint64_t service_version        : 8; /* Service Pack, etc. */
 383                 uint64_t minor_version          : 8;
 384                 uint64_t major_version          : 8;
 385                 /*
 386                  * HV_GUEST_OS_MICROSOFT_IDS (If Vendor=MS)
 387                  * HV_GUEST_OS_VENDOR
 388                  */
 389                 uint64_t os_id                  : 8;
 390                 uint64_t vendor_id              : 16;
 391         } u;
 392 } hv_vmbus_x64_msr_guest_os_id_contents;
 393
 394
 395 typedef union {
 396         uint64_t as_uint64_t;
 397         struct {
 398                 uint64_t enable :1;
 399                 uint64_t reserved :11;
 400                 uint64_t guest_physical_address :52;
 401         } u;
 402 } hv_vmbus_x64_msr_hypercall_contents;
 403
 404 typedef union {
 405         uint32_t as_uint32_t;
 406         struct {
 407                 uint32_t group_enable :4;
 408                 uint32_t rsvd_z :28;
 409         } u;
 410 } hv_vmbus_monitor_trigger_state;
 411
 412 typedef union {
 413         uint64_t as_uint64_t;
 414         struct {
 415                 uint32_t pending;
 416                 uint32_t armed;
 417         } u;
 418 } hv_vmbus_monitor_trigger_group;
 419
 420 typedef struct {
 421         hv_vmbus_connection_id  connection_id;
 422         uint16_t                flag_number;
 423         uint16_t                rsvd_z;
 424 } hv_vmbus_monitor_parameter;
 425
 426 /*
 427  * hv_vmbus_monitor_page Layout
 428  * ------------------------------------------------------
 429  * | 0   | trigger_state (4 bytes) | Rsvd1 (4 bytes)     |
 430  * | 8   | trigger_group[0]                              |
 431  * | 10  | trigger_group[1]                              |
 432  * | 18  | trigger_group[2]                              |
 433  * | 20  | trigger_group[3]                              |
 434  * | 28  | Rsvd2[0]                                      |
 435  * | 30  | Rsvd2[1]                                      |
 436  * | 38  | Rsvd2[2]                                      |
 437  * | 40  | next_check_time[0][0] | next_check_time[0][1] |
 438  * | ...                                                 |
 439  * | 240 | latency[0][0..3]                              |
 440  * | 340 | Rsvz3[0]                                      |
 441  * | 440 | parameter[0][0]                               |
 442  * | 448 | parameter[0][1]                               |
 443  * | ...                                                 |
 444  * | 840 | Rsvd4[0]                                      |
 445  * ------------------------------------------------------
 446  */
 447
 448 typedef struct {
 449         hv_vmbus_monitor_trigger_state  trigger_state;
 450         uint32_t                        rsvd_z1;
 451
 452         hv_vmbus_monitor_trigger_group  trigger_group[4];
 453         uint64_t                        rsvd_z2[3];
 454
 455         int32_t                         next_check_time[4][32];
 456
 457         uint16_t                        latency[4][32];
 458         uint64_t                        rsvd_z3[32];
 459
 460         hv_vmbus_monitor_parameter      parameter[4][32];
 461
 462         uint8_t                         rsvd_z4[1984];
 463 } hv_vmbus_monitor_page;
 464
 465 /*
 466  * The below CPUID leaves are present if VersionAndFeatures.HypervisorPresent
 467  * is set by CPUID(HV_CPU_ID_FUNCTION_VERSION_AND_FEATURES).
 468  */
 469 typedef enum {
 470         HV_CPU_ID_FUNCTION_VERSION_AND_FEATURES                 = 0x00000001,
 471         HV_CPU_ID_FUNCTION_HV_VENDOR_AND_MAX_FUNCTION           = 0x40000000,
 472         HV_CPU_ID_FUNCTION_HV_INTERFACE                         = 0x40000001,
 473         /*
 474          * The remaining functions depend on the value
 475          * of hv_cpu_id_function_interface
 476          */
 477         HV_CPU_ID_FUNCTION_MS_HV_VERSION                        = 0x40000002,
 478         HV_CPU_ID_FUNCTION_MS_HV_FEATURES                       = 0x40000003,
 479         HV_CPU_ID_FUNCTION_MS_HV_ENLIGHTENMENT_INFORMATION      = 0x40000004,
 480         HV_CPU_ID_FUNCTION_MS_HV_IMPLEMENTATION_LIMITS          = 0x40000005,
 481         HV_CPU_ID_FUNCTION_MS_HV_HARDWARE_FEATURE               = 0x40000006
 482 } hv_vmbus_cpuid_function;
 483
 484 #define HV_FEATURE_MSR_TIME_REFCNT      0x0002  /* MSR_TIME_REF_COUNT */
 485 #define HV_FEATURE_MSR_SYNIC            0x0004  /* MSRs for SynIC */
 486 #define HV_FEATURE_MSR_SYNTIMER         0x0008  /* MSRs for SynTimer */
 487 #define HV_FEATURE_MSR_APIC             0x0010  /* MSR_{EOI,ICR,TPR} */
 488 #define HV_FEATURE_MSR_HYPERCALL        0x0020  /* MSR_{GUEST_OS_ID,HYPERCALL} */
 489 #define HV_FEATURE_MSR_GUEST_IDLE       0x0400  /* MSR_GUEST_IDLE */
 490
 491 #define HV_PM_FEATURE_CSTATE_MASK       0x000f
 492 #define HV_PM_FEATURE_C3_HPET           0x0010  /* C3 requires HPET */
 493 #define HV_PM_FEATURE_CSTATE(f)         ((f) & HV_PM_FEATURE_CSTATE_MASK)
 494
 495 #define HV_FEATURE3_MWAIT               0x0001  /* MWAIT */
 496 #define HV_FEATURE3_XMM_HYPERCALL       0x0010  /* hypercall input through XMM regs */
 497 #define HV_FEATURE3_GUEST_IDLE          0x0020  /* guest idle support */
 498 #define HV_FEATURE3_NUMA                0x0080  /* NUMA distance query support */
 499 #define HV_FEATURE3_TIME_FREQ           0x0100  /* timer frequency query (TSC, LAPIC) */
 500 #define HV_FEATURE3_MSR_CRASH           0x0400  /* MSRs for guest crash */
 501
 502 /*
 503  * Define the format of the SIMP register
 504  */
 505 typedef union {
 506         uint64_t as_uint64_t;
 507         struct {
 508                 uint64_t simp_enabled   : 1;
 509                 uint64_t preserved      : 11;
 510                 uint64_t base_simp_gpa  : 52;
 511         } u;
 512 } hv_vmbus_synic_simp;
 513
 514 /*
 515  * Define the format of the SIEFP register
 516  */
 517 typedef union {
 518         uint64_t as_uint64_t;
 519         struct {
 520                 uint64_t siefp_enabled  : 1;
 521                 uint64_t preserved      : 11;
 522                 uint64_t base_siefp_gpa : 52;
 523         } u;
 524 } hv_vmbus_synic_siefp;
 525
 526 /*
 527  * Define synthetic interrupt source
 528  */
 529 typedef union {
 530         uint64_t as_uint64_t;
 531         struct {
 532                 uint64_t vector         : 8;
 533                 uint64_t reserved1      : 8;
 534                 uint64_t masked         : 1;
 535                 uint64_t auto_eoi       : 1;
 536                 uint64_t reserved2      : 46;
 537         } u;
 538 } hv_vmbus_synic_sint;
 539
 540 /*
 541  * Timer configuration register.
 542  */
 543 union hv_timer_config {
 544         uint64_t as_uint64;
 545         struct {
 546                 uint64_t enable:1;
 547                 uint64_t periodic:1;
 548                 uint64_t lazy:1;
 549                 uint64_t auto_enable:1;
 550                 uint64_t reserved_z0:12;
 551                 uint64_t sintx:4;
 552                 uint64_t reserved_z1:44;
 553         };
 554 };
 555
 556 /*
 557  * Define syn_ic control register
 558  */
 559 typedef union _hv_vmbus_synic_scontrol {
 560     uint64_t as_uint64_t;
 561     struct {
 562         uint64_t enable         : 1;
 563         uint64_t reserved       : 63;
 564     } u;
 565 } hv_vmbus_synic_scontrol;
 566
 567 /*
 568  *  Define the hv_vmbus_post_message hypercall input structure
 569  */
 570 typedef struct {
 571         hv_vmbus_connection_id  connection_id;
 572         uint32_t                reserved;
 573         hv_vmbus_msg_type       message_type;
 574         uint32_t                payload_size;
 575         uint64_t                payload[HV_MESSAGE_PAYLOAD_QWORD_COUNT];
 576 } hv_vmbus_input_post_message;
 577
 578 /*
 579  * Define the synthetic interrupt controller event flags format
 580  */
 581 typedef union {
 582         uint8_t         flags8[HV_EVENT_FLAGS_BYTE_COUNT];
 583         uint32_t        flags32[HV_EVENT_FLAGS_DWORD_COUNT];
 584         unsigned long   flagsul[HV_EVENT_FLAGS_ULONG_COUNT];
 585 } hv_vmbus_synic_event_flags;
 586 CTASSERT(sizeof(hv_vmbus_synic_event_flags) == HV_EVENT_FLAGS_BYTE_COUNT);
 587
 588 #define HV_X64_CPUID_MIN        (0x40000005)
 589 #define HV_X64_CPUID_MAX        (0x4000ffff)
 590
 591 /*
 592  * Declare the MSR used to identify the guest OS
 593  */
 594 #define HV_X64_MSR_GUEST_OS_ID  (0x40000000)
 595 /*
 596  *  Declare the MSR used to setup pages used to communicate with the hypervisor
 597  */
 598 #define HV_X64_MSR_HYPERCALL    (0x40000001)
 599 /* MSR used to provide vcpu index */
 600 #define HV_X64_MSR_VP_INDEX     (0x40000002)
 601
 602 #define HV_X64_MSR_TIME_REF_COUNT      (0x40000020)
 603
 604 /*
 605  * Define synthetic interrupt controller model specific registers
 606  */
 607 #define HV_X64_MSR_SCONTROL   (0x40000080)
 608 #define HV_X64_MSR_SVERSION   (0x40000081)
 609 #define HV_X64_MSR_SIEFP      (0x40000082)
 610 #define HV_X64_MSR_SIMP       (0x40000083)
 611 #define HV_X64_MSR_EOM        (0x40000084)
 612
 613 #define HV_X64_MSR_SINT0      (0x40000090)
 614 #define HV_X64_MSR_SINT1      (0x40000091)
 615 #define HV_X64_MSR_SINT2      (0x40000092)
 616 #define HV_X64_MSR_SINT3      (0x40000093)
 617 #define HV_X64_MSR_SINT4      (0x40000094)
 618 #define HV_X64_MSR_SINT5      (0x40000095)
 619 #define HV_X64_MSR_SINT6      (0x40000096)
 620 #define HV_X64_MSR_SINT7      (0x40000097)
 621 #define HV_X64_MSR_SINT8      (0x40000098)
 622 #define HV_X64_MSR_SINT9      (0x40000099)
 623 #define HV_X64_MSR_SINT10     (0x4000009A)
 624 #define HV_X64_MSR_SINT11     (0x4000009B)
 625 #define HV_X64_MSR_SINT12     (0x4000009C)
 626 #define HV_X64_MSR_SINT13     (0x4000009D)
 627 #define HV_X64_MSR_SINT14     (0x4000009E)
 628 #define HV_X64_MSR_SINT15     (0x4000009F)
 629
 630 /*
 631  * Synthetic Timer MSRs. Four timers per vcpu.
 632  */
 633 #define HV_X64_MSR_STIMER0_CONFIG               0x400000B0
 634 #define HV_X64_MSR_STIMER0_COUNT                0x400000B1
 635 #define HV_X64_MSR_STIMER1_CONFIG               0x400000B2
 636 #define HV_X64_MSR_STIMER1_COUNT                0x400000B3
 637 #define HV_X64_MSR_STIMER2_CONFIG               0x400000B4
 638 #define HV_X64_MSR_STIMER2_COUNT                0x400000B5
 639 #define HV_X64_MSR_STIMER3_CONFIG               0x400000B6
 640 #define HV_X64_MSR_STIMER3_COUNT                0x400000B7
 641
 642 /*
 643  * Declare the various hypercall operations
 644  */
 645 typedef enum {
 646         HV_CALL_POST_MESSAGE    = 0x005c,
 647         HV_CALL_SIGNAL_EVENT    = 0x005d,
 648 } hv_vmbus_call_code;
 649
 650 /**
 651  * Global variables
 652  */
 653
 654 extern hv_vmbus_context         hv_vmbus_g_context;
 655 extern hv_vmbus_connection      hv_vmbus_g_connection;
 656
 657 extern u_int                    hyperv_features;
 658 extern u_int                    hyperv_recommends;
 659
 660 typedef void (*vmbus_msg_handler)(hv_vmbus_channel_msg_header *msg);
 661
 662 typedef struct hv_vmbus_channel_msg_table_entry {
 663         hv_vmbus_channel_msg_type    messageType;
 664
 665         vmbus_msg_handler   messageHandler;
 666 } hv_vmbus_channel_msg_table_entry;
 667
 668 extern hv_vmbus_channel_msg_table_entry g_channel_message_table[];
 669
 670 /*
 671  * Private, VM Bus functions
 672  */
 673 struct sysctl_ctx_list;
 674 struct sysctl_oid_list;
 675
 676 void                    hv_ring_buffer_stat(
 677                                 struct sysctl_ctx_list          *ctx,
 678                                 struct sysctl_oid_list          *tree_node,
 679                                 hv_vmbus_ring_buffer_info       *rbi,
 680                                 const char                      *desc);
 681
 682 int                     hv_vmbus_ring_buffer_init(
 683                                 hv_vmbus_ring_buffer_info       *ring_info,
 684                                 void                            *buffer,
 685                                 uint32_t                        buffer_len);
 686
 687 void                    hv_ring_buffer_cleanup(
 688                                 hv_vmbus_ring_buffer_info       *ring_info);
 689
 690 int                     hv_ring_buffer_write(
 691                                 hv_vmbus_ring_buffer_info       *ring_info,
 692                                 hv_vmbus_sg_buffer_list         sg_buffers[],
 693                                 uint32_t                        sg_buff_count,
 694                                 boolean_t                       *need_sig);
 695
 696 int                     hv_ring_buffer_peek(
 697                                 hv_vmbus_ring_buffer_info       *ring_info,
 698                                 void                            *buffer,
 699                                 uint32_t                        buffer_len);
 700
 701 int                     hv_ring_buffer_read(
 702                                 hv_vmbus_ring_buffer_info       *ring_info,
 703                                 void                            *buffer,
 704                                 uint32_t                        buffer_len,
 705                                 uint32_t                        offset);
 706
 707 uint32_t                hv_vmbus_get_ring_buffer_interrupt_mask(
 708                                 hv_vmbus_ring_buffer_info       *ring_info);
 709
 710 void                    hv_vmbus_dump_ring_info(
 711                                 hv_vmbus_ring_buffer_info       *ring_info,
 712                                 char                            *prefix);
 713
 714 void                    hv_ring_buffer_read_begin(
 715                                 hv_vmbus_ring_buffer_info       *ring_info);
 716
 717 uint32_t                hv_ring_buffer_read_end(
 718                                 hv_vmbus_ring_buffer_info       *ring_info);
 719
 720 hv_vmbus_channel*       hv_vmbus_allocate_channel(void);
 721 void                    hv_vmbus_free_vmbus_channel(hv_vmbus_channel *channel);
 722 int                     hv_vmbus_request_channel_offers(void);
 723 void                    hv_vmbus_release_unattached_channels(void);
 724
 725 uint16_t                hv_vmbus_post_msg_via_msg_ipc(
 726                                 hv_vmbus_connection_id  connection_id,
 727                                 hv_vmbus_msg_type       message_type,
 728                                 void                    *payload,
 729                                 size_t                  payload_size);
 730
 731 uint16_t                hv_vmbus_signal_event(void *con_id);
 732 void                    hv_vmbus_synic_init(void *irq_arg);
 733 void                    hv_vmbus_synic_cleanup(void *arg);
 734
 735 struct hv_device*       hv_vmbus_child_device_create(
 736                                 hv_guid                 device_type,
 737                                 hv_guid                 device_instance,
 738                                 hv_vmbus_channel        *channel);
 739
 740 int                     hv_vmbus_child_device_register(
 741                                         struct hv_device *child_dev);
 742 int                     hv_vmbus_child_device_unregister(
 743                                         struct hv_device *child_dev);
 744
 745 /**
 746  * Connection interfaces
 747  */
 748 int                     hv_vmbus_connect(void);
 749 int                     hv_vmbus_disconnect(void);
 750 int                     hv_vmbus_post_message(void *buffer, size_t buf_size);
 751 int                     hv_vmbus_set_event(hv_vmbus_channel *channel);
 752
 753 /**
 754  * Event Timer interfaces
 755  */
 756 void                    hv_et_init(void);
 757 void                    hv_et_intr(struct trapframe*);
 758
 759 /* Wait for device creation */
 760 void                    vmbus_scan(void);
 761
 762 typedef struct {
 763         unsigned int    vector;
 764         void            *page_buffers[2 * MAXCPU];
 765 } hv_setup_args;
 766
 767 #endif  /* __HYPERV_PRIV_H__ */