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 /** 32 * HyperV definitions for messages that are sent between instances of the 33 * Channel Management Library in separate partitions, or in some cases, 34 * back to itself. 35 */ 36 37 #ifndef __HYPERV_H__ 38 #define __HYPERV_H__ 39 40 #include <sys/param.h> 41 #include <sys/mbuf.h> 42 #include <sys/queue.h> 43 #include <sys/malloc.h> 44 #include <sys/kthread.h> 45 #include <sys/taskqueue.h> 46 #include <sys/systm.h> 47 #include <sys/lock.h> 48 #include <sys/sema.h> 49 #include <sys/smp.h> 50 #include <sys/mutex.h> 51 #include <sys/bus.h> 52 #include <sys/sysctl.h> 53 #include <vm/vm.h> 54 #include <vm/vm_param.h> 55 #include <vm/pmap.h> 56 57 #include <amd64/include/xen/synch_bitops.h> 58 #include <amd64/include/atomic.h> 59 #include <dev/hyperv/include/hyperv_busdma.h> 60 61 typedef uint8_t hv_bool_uint8_t; 62 63 #define HV_S_OK 0x00000000 64 #define HV_E_FAIL 0x80004005 65 #define HV_ERROR_NOT_SUPPORTED 0x80070032 66 #define HV_ERROR_MACHINE_LOCKED 0x800704F7 67 68 /* 69 * VMBUS version is 32 bit, upper 16 bit for major_number and lower 70 * 16 bit for minor_number. 71 * 72 * 0.13 -- Windows Server 2008 73 * 1.1 -- Windows 7 74 * 2.4 -- Windows 8 75 * 3.0 -- Windows 8.1 76 */ 77 #define VMBUS_VERSION_WS2008 ((0 << 16) | (13)) 78 #define VMBUS_VERSION_WIN7 ((1 << 16) | (1)) 79 #define VMBUS_VERSION_WIN8 ((2 << 16) | (4)) 80 #define VMBUS_VERSION_WIN8_1 ((3 << 16) | (0)) 81 82 #define VMBUS_VERSION_MAJOR(ver) (((uint32_t)(ver)) >> 16) 83 #define VMBUS_VERSION_MINOR(ver) (((uint32_t)(ver)) & 0xffff) 84 85 struct hyperv_guid { 86 uint8_t hv_guid[16]; 87 } __packed; 88 89 #define HYPERV_GUID_STRLEN 40 90 91 int hyperv_guid2str(const struct hyperv_guid *, char *, size_t); 92 93 #define HW_MACADDR_LEN 6 94 95 /* 96 * Common defines for Hyper-V ICs 97 */ 98 #define HV_ICMSGTYPE_NEGOTIATE 0 99 #define HV_ICMSGTYPE_HEARTBEAT 1 100 #define HV_ICMSGTYPE_KVPEXCHANGE 2 101 #define HV_ICMSGTYPE_SHUTDOWN 3 102 #define HV_ICMSGTYPE_TIMESYNC 4 103 #define HV_ICMSGTYPE_VSS 5 104 105 #define HV_ICMSGHDRFLAG_TRANSACTION 1 106 #define HV_ICMSGHDRFLAG_REQUEST 2 107 #define HV_ICMSGHDRFLAG_RESPONSE 4 108 109 typedef struct hv_vmbus_pipe_hdr { 110 uint32_t flags; 111 uint32_t msgsize; 112 } __packed hv_vmbus_pipe_hdr; 113 114 typedef struct hv_vmbus_ic_version { 115 uint16_t major; 116 uint16_t minor; 117 } __packed hv_vmbus_ic_version; 118 119 typedef struct hv_vmbus_icmsg_hdr { 120 hv_vmbus_ic_version icverframe; 121 uint16_t icmsgtype; 122 hv_vmbus_ic_version icvermsg; 123 uint16_t icmsgsize; 124 uint32_t status; 125 uint8_t ictransaction_id; 126 uint8_t icflags; 127 uint8_t reserved[2]; 128 } __packed hv_vmbus_icmsg_hdr; 129 130 typedef struct hv_vmbus_icmsg_negotiate { 131 uint16_t icframe_vercnt; 132 uint16_t icmsg_vercnt; 133 uint32_t reserved; 134 hv_vmbus_ic_version icversion_data[1]; /* any size array */ 135 } __packed hv_vmbus_icmsg_negotiate; 136 137 typedef struct hv_vmbus_shutdown_msg_data { 138 uint32_t reason_code; 139 uint32_t timeout_seconds; 140 uint32_t flags; 141 uint8_t display_message[2048]; 142 } __packed hv_vmbus_shutdown_msg_data; 143 144 typedef struct hv_vmbus_heartbeat_msg_data { 145 uint64_t seq_num; 146 uint32_t reserved[8]; 147 } __packed hv_vmbus_heartbeat_msg_data; 148 149 typedef struct { 150 /* 151 * offset in bytes from the start of ring data below 152 */ 153 volatile uint32_t write_index; 154 /* 155 * offset in bytes from the start of ring data below 156 */ 157 volatile uint32_t read_index; 158 /* 159 * NOTE: The interrupt_mask field is used only for channels, but 160 * vmbus connection also uses this data structure 161 */ 162 volatile uint32_t interrupt_mask; 163 /* pad it to PAGE_SIZE so that data starts on a page */ 164 uint8_t reserved[4084]; 165 166 /* 167 * WARNING: Ring data starts here 168 * !!! DO NOT place any fields below this !!! 169 */ 170 uint8_t buffer[0]; /* doubles as interrupt mask */ 171 } __packed hv_vmbus_ring_buffer; 172 173 typedef struct { 174 hv_vmbus_ring_buffer* ring_buffer; 175 struct mtx ring_lock; 176 uint32_t ring_data_size; /* ring_size */ 177 } hv_vmbus_ring_buffer_info; 178 179 typedef void (*vmbus_chan_callback_t)(void *); 180 181 typedef struct hv_vmbus_channel { 182 device_t ch_dev; 183 struct vmbus_softc *vmbus_sc; 184 uint32_t ch_flags; /* VMBUS_CHAN_FLAG_ */ 185 uint32_t ch_id; /* channel id */ 186 187 /* 188 * These are based on the offer_msg.monitor_id. 189 * Save it here for easy access. 190 */ 191 int ch_montrig_idx; /* MNF trig index */ 192 uint32_t ch_montrig_mask;/* MNF trig mask */ 193 194 /* 195 * send to parent 196 */ 197 hv_vmbus_ring_buffer_info outbound; 198 /* 199 * receive from parent 200 */ 201 hv_vmbus_ring_buffer_info inbound; 202 203 struct taskqueue *ch_tq; 204 struct task ch_task; 205 vmbus_chan_callback_t ch_cb; 206 void *ch_cbarg; 207 208 struct hyperv_mon_param *ch_monprm; 209 struct hyperv_dma ch_monprm_dma; 210 211 int ch_cpuid; /* owner cpu */ 212 /* 213 * Virtual cpuid for ch_cpuid; it is used to communicate cpuid 214 * related information w/ Hyper-V. If MSR_HV_VP_INDEX does not 215 * exist, ch_vcpuid will always be 0 for compatibility. 216 */ 217 uint32_t ch_vcpuid; 218 219 /* 220 * If this is a primary channel, ch_subchan* fields 221 * contain sub-channels belonging to this primary 222 * channel. 223 */ 224 struct mtx ch_subchan_lock; 225 TAILQ_HEAD(, hv_vmbus_channel) ch_subchans; 226 int ch_subchan_cnt; 227 228 /* If this is a sub-channel */ 229 TAILQ_ENTRY(hv_vmbus_channel) ch_sublink; /* sub-channel link */ 230 struct hv_vmbus_channel *ch_prichan; /* owner primary chan */ 231 232 /* 233 * Driver private data 234 */ 235 void *hv_chan_priv1; 236 void *hv_chan_priv2; 237 void *hv_chan_priv3; 238 239 void *ch_bufring; /* TX+RX bufrings */ 240 struct hyperv_dma ch_bufring_dma; 241 uint32_t ch_bufring_gpadl; 242 243 struct task ch_detach_task; 244 TAILQ_ENTRY(hv_vmbus_channel) ch_prilink; /* primary chan link */ 245 uint32_t ch_subidx; /* subchan index */ 246 volatile uint32_t ch_stflags; /* atomic-op */ 247 /* VMBUS_CHAN_ST_ */ 248 struct hyperv_guid ch_guid_type; 249 struct hyperv_guid ch_guid_inst; 250 251 struct sysctl_ctx_list ch_sysctl_ctx; 252 } hv_vmbus_channel; 253 254 #define VMBUS_CHAN_ISPRIMARY(chan) ((chan)->ch_subidx == 0) 255 256 #define VMBUS_CHAN_FLAG_HASMNF 0x0001 257 /* 258 * If this flag is set, this channel's interrupt will be masked in ISR, 259 * and the RX bufring will be drained before this channel's interrupt is 260 * unmasked. 261 * 262 * This flag is turned on by default. Drivers can turn it off according 263 * to their own requirement. 264 */ 265 #define VMBUS_CHAN_FLAG_BATCHREAD 0x0002 266 267 #define VMBUS_CHAN_ST_OPENED_SHIFT 0 268 #define VMBUS_CHAN_ST_OPENED (1 << VMBUS_CHAN_ST_OPENED_SHIFT) 269 270 static inline void 271 hv_set_channel_read_state(hv_vmbus_channel* channel, boolean_t on) 272 { 273 if (!on) 274 channel->ch_flags &= ~VMBUS_CHAN_FLAG_BATCHREAD; 275 else 276 channel->ch_flags |= VMBUS_CHAN_FLAG_BATCHREAD; 277 } 278 279 int hv_vmbus_channel_open(struct hv_vmbus_channel *chan, 280 int txbr_size, int rxbr_size, const void *udata, int udlen, 281 vmbus_chan_callback_t cb, void *cbarg); 282 void hv_vmbus_channel_close(hv_vmbus_channel *channel); 283 284 struct hv_vmbus_channel* vmbus_select_outgoing_channel(struct hv_vmbus_channel *promary); 285 286 /** 287 * @brief Get physical address from virtual 288 */ 289 static inline unsigned long 290 hv_get_phys_addr(void *virt) 291 { 292 unsigned long ret; 293 ret = (vtophys(virt) | ((vm_offset_t) virt & PAGE_MASK)); 294 return (ret); 295 } 296 297 static __inline struct hv_vmbus_channel * 298 vmbus_get_channel(device_t dev) 299 { 300 return device_get_ivars(dev); 301 } 302 303 #endif /* __HYPERV_H__ */ 304