| #ifndef _ASM_X86_MSHYPER_H |
| #define _ASM_X86_MSHYPER_H |
| |
| #include <linux/types.h> |
| #include <linux/interrupt.h> |
| #include <linux/clocksource.h> |
| #include <asm/hyperv.h> |
| |
| /* |
| * The below CPUID leaves are present if VersionAndFeatures.HypervisorPresent |
| * is set by CPUID(HVCPUID_VERSION_FEATURES). |
| */ |
| enum hv_cpuid_function { |
| HVCPUID_VERSION_FEATURES = 0x00000001, |
| HVCPUID_VENDOR_MAXFUNCTION = 0x40000000, |
| HVCPUID_INTERFACE = 0x40000001, |
| |
| /* |
| * The remaining functions depend on the value of |
| * HVCPUID_INTERFACE |
| */ |
| HVCPUID_VERSION = 0x40000002, |
| HVCPUID_FEATURES = 0x40000003, |
| HVCPUID_ENLIGHTENMENT_INFO = 0x40000004, |
| HVCPUID_IMPLEMENTATION_LIMITS = 0x40000005, |
| }; |
| |
| struct ms_hyperv_info { |
| u32 features; |
| u32 misc_features; |
| u32 hints; |
| }; |
| |
| extern struct ms_hyperv_info ms_hyperv; |
| |
| /* |
| * Declare the MSR used to setup pages used to communicate with the hypervisor. |
| */ |
| union hv_x64_msr_hypercall_contents { |
| u64 as_uint64; |
| struct { |
| u64 enable:1; |
| u64 reserved:11; |
| u64 guest_physical_address:52; |
| }; |
| }; |
| |
| /* |
| * TSC page layout. |
| */ |
| |
| struct ms_hyperv_tsc_page { |
| volatile u32 tsc_sequence; |
| u32 reserved1; |
| volatile u64 tsc_scale; |
| volatile s64 tsc_offset; |
| u64 reserved2[509]; |
| }; |
| |
| /* |
| * The guest OS needs to register the guest ID with the hypervisor. |
| * The guest ID is a 64 bit entity and the structure of this ID is |
| * specified in the Hyper-V specification: |
| * |
| * msdn.microsoft.com/en-us/library/windows/hardware/ff542653%28v=vs.85%29.aspx |
| * |
| * While the current guideline does not specify how Linux guest ID(s) |
| * need to be generated, our plan is to publish the guidelines for |
| * Linux and other guest operating systems that currently are hosted |
| * on Hyper-V. The implementation here conforms to this yet |
| * unpublished guidelines. |
| * |
| * |
| * Bit(s) |
| * 63 - Indicates if the OS is Open Source or not; 1 is Open Source |
| * 62:56 - Os Type; Linux is 0x100 |
| * 55:48 - Distro specific identification |
| * 47:16 - Linux kernel version number |
| * 15:0 - Distro specific identification |
| * |
| * |
| */ |
| |
| #define HV_LINUX_VENDOR_ID 0x8100 |
| |
| /* |
| * Generate the guest ID based on the guideline described above. |
| */ |
| |
| static inline __u64 generate_guest_id(__u64 d_info1, __u64 kernel_version, |
| __u64 d_info2) |
| { |
| __u64 guest_id = 0; |
| |
| guest_id = (((__u64)HV_LINUX_VENDOR_ID) << 48); |
| guest_id |= (d_info1 << 48); |
| guest_id |= (kernel_version << 16); |
| guest_id |= d_info2; |
| |
| return guest_id; |
| } |
| |
| |
| /* Free the message slot and signal end-of-message if required */ |
| static inline void vmbus_signal_eom(struct hv_message *msg, u32 old_msg_type) |
| { |
| /* |
| * On crash we're reading some other CPU's message page and we need |
| * to be careful: this other CPU may already had cleared the header |
| * and the host may already had delivered some other message there. |
| * In case we blindly write msg->header.message_type we're going |
| * to lose it. We can still lose a message of the same type but |
| * we count on the fact that there can only be one |
| * CHANNELMSG_UNLOAD_RESPONSE and we don't care about other messages |
| * on crash. |
| */ |
| if (cmpxchg(&msg->header.message_type, old_msg_type, |
| HVMSG_NONE) != old_msg_type) |
| return; |
| |
| /* |
| * Make sure the write to MessageType (ie set to |
| * HVMSG_NONE) happens before we read the |
| * MessagePending and EOMing. Otherwise, the EOMing |
| * will not deliver any more messages since there is |
| * no empty slot |
| */ |
| mb(); |
| |
| if (msg->header.message_flags.msg_pending) { |
| /* |
| * This will cause message queue rescan to |
| * possibly deliver another msg from the |
| * hypervisor |
| */ |
| wrmsrl(HV_X64_MSR_EOM, 0); |
| } |
| } |
| |
| #define hv_get_current_tick(tick) rdmsrl(HV_X64_MSR_TIME_REF_COUNT, tick) |
| #define hv_init_timer(timer, tick) wrmsrl(timer, tick) |
| #define hv_init_timer_config(config, val) wrmsrl(config, val) |
| |
| #define hv_get_simp(val) rdmsrl(HV_X64_MSR_SIMP, val) |
| #define hv_set_simp(val) wrmsrl(HV_X64_MSR_SIMP, val) |
| |
| #define hv_get_siefp(val) rdmsrl(HV_X64_MSR_SIEFP, val) |
| #define hv_set_siefp(val) wrmsrl(HV_X64_MSR_SIEFP, val) |
| |
| #define hv_get_synic_state(val) rdmsrl(HV_X64_MSR_SCONTROL, val) |
| #define hv_set_synic_state(val) wrmsrl(HV_X64_MSR_SCONTROL, val) |
| |
| #define hv_get_vp_index(index) rdmsrl(HV_X64_MSR_VP_INDEX, index) |
| |
| #define hv_get_synint_state(int_num, val) rdmsrl(int_num, val) |
| #define hv_set_synint_state(int_num, val) wrmsrl(int_num, val) |
| |
| void hyperv_callback_vector(void); |
| #ifdef CONFIG_TRACING |
| #define trace_hyperv_callback_vector hyperv_callback_vector |
| #endif |
| void hyperv_vector_handler(struct pt_regs *regs); |
| void hv_setup_vmbus_irq(void (*handler)(void)); |
| void hv_remove_vmbus_irq(void); |
| |
| void hv_setup_kexec_handler(void (*handler)(void)); |
| void hv_remove_kexec_handler(void); |
| void hv_setup_crash_handler(void (*handler)(struct pt_regs *regs)); |
| void hv_remove_crash_handler(void); |
| |
| #if IS_ENABLED(CONFIG_HYPERV) |
| extern struct clocksource *hyperv_cs; |
| |
| void hyperv_init(void); |
| void hyperv_report_panic(struct pt_regs *regs); |
| bool hv_is_hypercall_page_setup(void); |
| void hyperv_cleanup(void); |
| #endif |
| #endif |