xref: /freebsd/sys/dev/hyperv/vmbus/vmbus.c (revision 77321df6e4868a3db5f52c1e09bc24b5a0ce1085)
1b7bb4816SSepherosa Ziehau /*-
2b7bb4816SSepherosa Ziehau  * Copyright (c) 2009-2012,2016 Microsoft Corp.
3b7bb4816SSepherosa Ziehau  * Copyright (c) 2012 NetApp Inc.
4b7bb4816SSepherosa Ziehau  * Copyright (c) 2012 Citrix Inc.
5b7bb4816SSepherosa Ziehau  * All rights reserved.
6b7bb4816SSepherosa Ziehau  *
7b7bb4816SSepherosa Ziehau  * Redistribution and use in source and binary forms, with or without
8b7bb4816SSepherosa Ziehau  * modification, are permitted provided that the following conditions
9b7bb4816SSepherosa Ziehau  * are met:
10b7bb4816SSepherosa Ziehau  * 1. Redistributions of source code must retain the above copyright
11b7bb4816SSepherosa Ziehau  *    notice unmodified, this list of conditions, and the following
12b7bb4816SSepherosa Ziehau  *    disclaimer.
13b7bb4816SSepherosa Ziehau  * 2. Redistributions in binary form must reproduce the above copyright
14b7bb4816SSepherosa Ziehau  *    notice, this list of conditions and the following disclaimer in the
15b7bb4816SSepherosa Ziehau  *    documentation and/or other materials provided with the distribution.
16b7bb4816SSepherosa Ziehau  *
17b7bb4816SSepherosa Ziehau  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18b7bb4816SSepherosa Ziehau  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19b7bb4816SSepherosa Ziehau  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20b7bb4816SSepherosa Ziehau  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21b7bb4816SSepherosa Ziehau  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22b7bb4816SSepherosa Ziehau  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23b7bb4816SSepherosa Ziehau  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24b7bb4816SSepherosa Ziehau  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25b7bb4816SSepherosa Ziehau  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26b7bb4816SSepherosa Ziehau  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27b7bb4816SSepherosa Ziehau  */
28b7bb4816SSepherosa Ziehau 
29b7bb4816SSepherosa Ziehau /*
30b7bb4816SSepherosa Ziehau  * VM Bus Driver Implementation
31b7bb4816SSepherosa Ziehau  */
32b7bb4816SSepherosa Ziehau #include <sys/cdefs.h>
33b7bb4816SSepherosa Ziehau __FBSDID("$FreeBSD$");
34b7bb4816SSepherosa Ziehau 
35b7bb4816SSepherosa Ziehau #include <sys/param.h>
36b7bb4816SSepherosa Ziehau #include <sys/bus.h>
37b7bb4816SSepherosa Ziehau #include <sys/kernel.h>
38b7bb4816SSepherosa Ziehau #include <sys/lock.h>
39b7bb4816SSepherosa Ziehau #include <sys/malloc.h>
40b7bb4816SSepherosa Ziehau #include <sys/module.h>
41b7bb4816SSepherosa Ziehau #include <sys/proc.h>
42b7bb4816SSepherosa Ziehau #include <sys/sysctl.h>
43b7bb4816SSepherosa Ziehau #include <sys/syslog.h>
44b7bb4816SSepherosa Ziehau #include <sys/systm.h>
45b7bb4816SSepherosa Ziehau #include <sys/rtprio.h>
46b7bb4816SSepherosa Ziehau #include <sys/interrupt.h>
47b7bb4816SSepherosa Ziehau #include <sys/sx.h>
48b7bb4816SSepherosa Ziehau #include <sys/taskqueue.h>
49b7bb4816SSepherosa Ziehau #include <sys/mutex.h>
50b7bb4816SSepherosa Ziehau #include <sys/smp.h>
51b7bb4816SSepherosa Ziehau 
52b7bb4816SSepherosa Ziehau #include <machine/resource.h>
53b7bb4816SSepherosa Ziehau #include <sys/rman.h>
54b7bb4816SSepherosa Ziehau 
55b7bb4816SSepherosa Ziehau #include <machine/stdarg.h>
56b7bb4816SSepherosa Ziehau #include <machine/intr_machdep.h>
57b7bb4816SSepherosa Ziehau #include <machine/md_var.h>
58b7bb4816SSepherosa Ziehau #include <machine/segments.h>
59b7bb4816SSepherosa Ziehau #include <sys/pcpu.h>
60b7bb4816SSepherosa Ziehau #include <x86/apicvar.h>
61b7bb4816SSepherosa Ziehau 
62b7bb4816SSepherosa Ziehau #include <dev/hyperv/include/hyperv.h>
63b7bb4816SSepherosa Ziehau #include <dev/hyperv/vmbus/hv_vmbus_priv.h>
64b7bb4816SSepherosa Ziehau #include <dev/hyperv/vmbus/hyperv_reg.h>
65b7bb4816SSepherosa Ziehau #include <dev/hyperv/vmbus/hyperv_var.h>
66b7bb4816SSepherosa Ziehau #include <dev/hyperv/vmbus/vmbus_reg.h>
67b7bb4816SSepherosa Ziehau #include <dev/hyperv/vmbus/vmbus_var.h>
68b7bb4816SSepherosa Ziehau 
69b7bb4816SSepherosa Ziehau #include <contrib/dev/acpica/include/acpi.h>
70b7bb4816SSepherosa Ziehau #include "acpi_if.h"
7138d19df6SSepherosa Ziehau #include "vmbus_if.h"
72b7bb4816SSepherosa Ziehau 
73ee7e313fSSepherosa Ziehau #define VMBUS_GPADL_START		0xe1e10
74ee7e313fSSepherosa Ziehau 
75236764b1SSepherosa Ziehau struct vmbus_msghc {
76236764b1SSepherosa Ziehau 	struct hypercall_postmsg_in	*mh_inprm;
77236764b1SSepherosa Ziehau 	struct hypercall_postmsg_in	mh_inprm_save;
78236764b1SSepherosa Ziehau 	struct hyperv_dma		mh_inprm_dma;
79236764b1SSepherosa Ziehau 
80236764b1SSepherosa Ziehau 	struct vmbus_message		*mh_resp;
81236764b1SSepherosa Ziehau 	struct vmbus_message		mh_resp0;
82236764b1SSepherosa Ziehau };
83236764b1SSepherosa Ziehau 
84236764b1SSepherosa Ziehau struct vmbus_msghc_ctx {
85236764b1SSepherosa Ziehau 	struct vmbus_msghc		*mhc_free;
86236764b1SSepherosa Ziehau 	struct mtx			mhc_free_lock;
87236764b1SSepherosa Ziehau 	uint32_t			mhc_flags;
88236764b1SSepherosa Ziehau 
89236764b1SSepherosa Ziehau 	struct vmbus_msghc		*mhc_active;
90236764b1SSepherosa Ziehau 	struct mtx			mhc_active_lock;
91236764b1SSepherosa Ziehau };
92236764b1SSepherosa Ziehau 
93236764b1SSepherosa Ziehau #define VMBUS_MSGHC_CTXF_DESTROY	0x0001
94236764b1SSepherosa Ziehau 
95236764b1SSepherosa Ziehau static int			vmbus_init(struct vmbus_softc *);
96f24517f0SSepherosa Ziehau static int			vmbus_connect(struct vmbus_softc *, uint32_t);
97c1cc5bdfSSepherosa Ziehau static int			vmbus_req_channels(struct vmbus_softc *sc);
98f24517f0SSepherosa Ziehau static void			vmbus_disconnect(struct vmbus_softc *);
99796a90bfSSepherosa Ziehau static int			vmbus_scan(struct vmbus_softc *);
100796a90bfSSepherosa Ziehau static void			vmbus_scan_wait(struct vmbus_softc *);
101796a90bfSSepherosa Ziehau static void			vmbus_scan_newdev(struct vmbus_softc *);
102236764b1SSepherosa Ziehau 
10347a3ee5cSSepherosa Ziehau static int			vmbus_sysctl_version(SYSCTL_HANDLER_ARGS);
10447a3ee5cSSepherosa Ziehau 
105236764b1SSepherosa Ziehau static struct vmbus_msghc_ctx	*vmbus_msghc_ctx_create(bus_dma_tag_t);
106236764b1SSepherosa Ziehau static void			vmbus_msghc_ctx_destroy(
107236764b1SSepherosa Ziehau 				    struct vmbus_msghc_ctx *);
108236764b1SSepherosa Ziehau static void			vmbus_msghc_ctx_free(struct vmbus_msghc_ctx *);
109236764b1SSepherosa Ziehau static struct vmbus_msghc	*vmbus_msghc_alloc(bus_dma_tag_t);
110236764b1SSepherosa Ziehau static void			vmbus_msghc_free(struct vmbus_msghc *);
111236764b1SSepherosa Ziehau static struct vmbus_msghc	*vmbus_msghc_get1(struct vmbus_msghc_ctx *,
112236764b1SSepherosa Ziehau 				    uint32_t);
113236764b1SSepherosa Ziehau 
114b7bb4816SSepherosa Ziehau struct vmbus_softc	*vmbus_sc;
115b7bb4816SSepherosa Ziehau 
116b7bb4816SSepherosa Ziehau extern inthand_t IDTVEC(vmbus_isr);
117b7bb4816SSepherosa Ziehau 
118236764b1SSepherosa Ziehau static const uint32_t		vmbus_version[] = {
11938d19df6SSepherosa Ziehau 	VMBUS_VERSION_WIN8_1,
12038d19df6SSepherosa Ziehau 	VMBUS_VERSION_WIN8,
12138d19df6SSepherosa Ziehau 	VMBUS_VERSION_WIN7,
12238d19df6SSepherosa Ziehau 	VMBUS_VERSION_WS2008
123236764b1SSepherosa Ziehau };
124236764b1SSepherosa Ziehau 
125236764b1SSepherosa Ziehau static struct vmbus_msghc *
126236764b1SSepherosa Ziehau vmbus_msghc_alloc(bus_dma_tag_t parent_dtag)
127236764b1SSepherosa Ziehau {
128236764b1SSepherosa Ziehau 	struct vmbus_msghc *mh;
129236764b1SSepherosa Ziehau 
130236764b1SSepherosa Ziehau 	mh = malloc(sizeof(*mh), M_DEVBUF, M_WAITOK | M_ZERO);
131236764b1SSepherosa Ziehau 
132236764b1SSepherosa Ziehau 	mh->mh_inprm = hyperv_dmamem_alloc(parent_dtag,
133a570251dSSepherosa Ziehau 	    HYPERCALL_PARAM_ALIGN, 0, HYPERCALL_POSTMSGIN_SIZE,
134236764b1SSepherosa Ziehau 	    &mh->mh_inprm_dma, BUS_DMA_WAITOK);
135236764b1SSepherosa Ziehau 	if (mh->mh_inprm == NULL) {
136236764b1SSepherosa Ziehau 		free(mh, M_DEVBUF);
137236764b1SSepherosa Ziehau 		return NULL;
138236764b1SSepherosa Ziehau 	}
139236764b1SSepherosa Ziehau 	return mh;
140236764b1SSepherosa Ziehau }
141236764b1SSepherosa Ziehau 
142236764b1SSepherosa Ziehau static void
143236764b1SSepherosa Ziehau vmbus_msghc_free(struct vmbus_msghc *mh)
144236764b1SSepherosa Ziehau {
145236764b1SSepherosa Ziehau 	hyperv_dmamem_free(&mh->mh_inprm_dma, mh->mh_inprm);
146236764b1SSepherosa Ziehau 	free(mh, M_DEVBUF);
147236764b1SSepherosa Ziehau }
148236764b1SSepherosa Ziehau 
149236764b1SSepherosa Ziehau static void
150236764b1SSepherosa Ziehau vmbus_msghc_ctx_free(struct vmbus_msghc_ctx *mhc)
151236764b1SSepherosa Ziehau {
152236764b1SSepherosa Ziehau 	KASSERT(mhc->mhc_active == NULL, ("still have active msg hypercall"));
153236764b1SSepherosa Ziehau 	KASSERT(mhc->mhc_free == NULL, ("still have hypercall msg"));
154236764b1SSepherosa Ziehau 
155236764b1SSepherosa Ziehau 	mtx_destroy(&mhc->mhc_free_lock);
156236764b1SSepherosa Ziehau 	mtx_destroy(&mhc->mhc_active_lock);
157236764b1SSepherosa Ziehau 	free(mhc, M_DEVBUF);
158236764b1SSepherosa Ziehau }
159236764b1SSepherosa Ziehau 
160236764b1SSepherosa Ziehau static struct vmbus_msghc_ctx *
161236764b1SSepherosa Ziehau vmbus_msghc_ctx_create(bus_dma_tag_t parent_dtag)
162236764b1SSepherosa Ziehau {
163236764b1SSepherosa Ziehau 	struct vmbus_msghc_ctx *mhc;
164236764b1SSepherosa Ziehau 
165236764b1SSepherosa Ziehau 	mhc = malloc(sizeof(*mhc), M_DEVBUF, M_WAITOK | M_ZERO);
166236764b1SSepherosa Ziehau 	mtx_init(&mhc->mhc_free_lock, "vmbus msghc free", NULL, MTX_DEF);
167236764b1SSepherosa Ziehau 	mtx_init(&mhc->mhc_active_lock, "vmbus msghc act", NULL, MTX_DEF);
168236764b1SSepherosa Ziehau 
169236764b1SSepherosa Ziehau 	mhc->mhc_free = vmbus_msghc_alloc(parent_dtag);
170236764b1SSepherosa Ziehau 	if (mhc->mhc_free == NULL) {
171236764b1SSepherosa Ziehau 		vmbus_msghc_ctx_free(mhc);
172236764b1SSepherosa Ziehau 		return NULL;
173236764b1SSepherosa Ziehau 	}
174236764b1SSepherosa Ziehau 	return mhc;
175236764b1SSepherosa Ziehau }
176236764b1SSepherosa Ziehau 
177236764b1SSepherosa Ziehau static struct vmbus_msghc *
178236764b1SSepherosa Ziehau vmbus_msghc_get1(struct vmbus_msghc_ctx *mhc, uint32_t dtor_flag)
179236764b1SSepherosa Ziehau {
180236764b1SSepherosa Ziehau 	struct vmbus_msghc *mh;
181236764b1SSepherosa Ziehau 
182236764b1SSepherosa Ziehau 	mtx_lock(&mhc->mhc_free_lock);
183236764b1SSepherosa Ziehau 
184236764b1SSepherosa Ziehau 	while ((mhc->mhc_flags & dtor_flag) == 0 && mhc->mhc_free == NULL) {
185236764b1SSepherosa Ziehau 		mtx_sleep(&mhc->mhc_free, &mhc->mhc_free_lock, 0,
186236764b1SSepherosa Ziehau 		    "gmsghc", 0);
187236764b1SSepherosa Ziehau 	}
188236764b1SSepherosa Ziehau 	if (mhc->mhc_flags & dtor_flag) {
189236764b1SSepherosa Ziehau 		/* Being destroyed */
190236764b1SSepherosa Ziehau 		mh = NULL;
191236764b1SSepherosa Ziehau 	} else {
192236764b1SSepherosa Ziehau 		mh = mhc->mhc_free;
193236764b1SSepherosa Ziehau 		KASSERT(mh != NULL, ("no free hypercall msg"));
194236764b1SSepherosa Ziehau 		KASSERT(mh->mh_resp == NULL,
195236764b1SSepherosa Ziehau 		    ("hypercall msg has pending response"));
196236764b1SSepherosa Ziehau 		mhc->mhc_free = NULL;
197236764b1SSepherosa Ziehau 	}
198236764b1SSepherosa Ziehau 
199236764b1SSepherosa Ziehau 	mtx_unlock(&mhc->mhc_free_lock);
200236764b1SSepherosa Ziehau 
201236764b1SSepherosa Ziehau 	return mh;
202236764b1SSepherosa Ziehau }
203236764b1SSepherosa Ziehau 
2042bf62f9aSSepherosa Ziehau void
2052bf62f9aSSepherosa Ziehau vmbus_msghc_reset(struct vmbus_msghc *mh, size_t dsize)
206236764b1SSepherosa Ziehau {
207236764b1SSepherosa Ziehau 	struct hypercall_postmsg_in *inprm;
208236764b1SSepherosa Ziehau 
209236764b1SSepherosa Ziehau 	if (dsize > HYPERCALL_POSTMSGIN_DSIZE_MAX)
2102bf62f9aSSepherosa Ziehau 		panic("invalid data size %zu", dsize);
211236764b1SSepherosa Ziehau 
212236764b1SSepherosa Ziehau 	inprm = mh->mh_inprm;
213236764b1SSepherosa Ziehau 	memset(inprm, 0, HYPERCALL_POSTMSGIN_SIZE);
214236764b1SSepherosa Ziehau 	inprm->hc_connid = VMBUS_CONNID_MESSAGE;
215236764b1SSepherosa Ziehau 	inprm->hc_msgtype = HYPERV_MSGTYPE_CHANNEL;
216236764b1SSepherosa Ziehau 	inprm->hc_dsize = dsize;
2172bf62f9aSSepherosa Ziehau }
218236764b1SSepherosa Ziehau 
2192bf62f9aSSepherosa Ziehau struct vmbus_msghc *
2202bf62f9aSSepherosa Ziehau vmbus_msghc_get(struct vmbus_softc *sc, size_t dsize)
2212bf62f9aSSepherosa Ziehau {
2222bf62f9aSSepherosa Ziehau 	struct vmbus_msghc *mh;
2232bf62f9aSSepherosa Ziehau 
2242bf62f9aSSepherosa Ziehau 	if (dsize > HYPERCALL_POSTMSGIN_DSIZE_MAX)
2252bf62f9aSSepherosa Ziehau 		panic("invalid data size %zu", dsize);
2262bf62f9aSSepherosa Ziehau 
2272bf62f9aSSepherosa Ziehau 	mh = vmbus_msghc_get1(sc->vmbus_msg_hc, VMBUS_MSGHC_CTXF_DESTROY);
2282bf62f9aSSepherosa Ziehau 	if (mh == NULL)
2292bf62f9aSSepherosa Ziehau 		return NULL;
2302bf62f9aSSepherosa Ziehau 
2312bf62f9aSSepherosa Ziehau 	vmbus_msghc_reset(mh, dsize);
232236764b1SSepherosa Ziehau 	return mh;
233236764b1SSepherosa Ziehau }
234236764b1SSepherosa Ziehau 
235236764b1SSepherosa Ziehau void
236236764b1SSepherosa Ziehau vmbus_msghc_put(struct vmbus_softc *sc, struct vmbus_msghc *mh)
237236764b1SSepherosa Ziehau {
238236764b1SSepherosa Ziehau 	struct vmbus_msghc_ctx *mhc = sc->vmbus_msg_hc;
239236764b1SSepherosa Ziehau 
240236764b1SSepherosa Ziehau 	KASSERT(mhc->mhc_active == NULL, ("msg hypercall is active"));
241236764b1SSepherosa Ziehau 	mh->mh_resp = NULL;
242236764b1SSepherosa Ziehau 
243236764b1SSepherosa Ziehau 	mtx_lock(&mhc->mhc_free_lock);
244236764b1SSepherosa Ziehau 	KASSERT(mhc->mhc_free == NULL, ("has free hypercall msg"));
245236764b1SSepherosa Ziehau 	mhc->mhc_free = mh;
246236764b1SSepherosa Ziehau 	mtx_unlock(&mhc->mhc_free_lock);
247236764b1SSepherosa Ziehau 	wakeup(&mhc->mhc_free);
248236764b1SSepherosa Ziehau }
249236764b1SSepherosa Ziehau 
250236764b1SSepherosa Ziehau void *
251236764b1SSepherosa Ziehau vmbus_msghc_dataptr(struct vmbus_msghc *mh)
252236764b1SSepherosa Ziehau {
253236764b1SSepherosa Ziehau 	return mh->mh_inprm->hc_data;
254236764b1SSepherosa Ziehau }
255236764b1SSepherosa Ziehau 
256236764b1SSepherosa Ziehau static void
257236764b1SSepherosa Ziehau vmbus_msghc_ctx_destroy(struct vmbus_msghc_ctx *mhc)
258236764b1SSepherosa Ziehau {
259236764b1SSepherosa Ziehau 	struct vmbus_msghc *mh;
260236764b1SSepherosa Ziehau 
261236764b1SSepherosa Ziehau 	mtx_lock(&mhc->mhc_free_lock);
262236764b1SSepherosa Ziehau 	mhc->mhc_flags |= VMBUS_MSGHC_CTXF_DESTROY;
263236764b1SSepherosa Ziehau 	mtx_unlock(&mhc->mhc_free_lock);
264236764b1SSepherosa Ziehau 	wakeup(&mhc->mhc_free);
265236764b1SSepherosa Ziehau 
266236764b1SSepherosa Ziehau 	mh = vmbus_msghc_get1(mhc, 0);
267236764b1SSepherosa Ziehau 	if (mh == NULL)
268236764b1SSepherosa Ziehau 		panic("can't get msghc");
269236764b1SSepherosa Ziehau 
270236764b1SSepherosa Ziehau 	vmbus_msghc_free(mh);
271236764b1SSepherosa Ziehau 	vmbus_msghc_ctx_free(mhc);
272236764b1SSepherosa Ziehau }
273236764b1SSepherosa Ziehau 
274236764b1SSepherosa Ziehau int
275236764b1SSepherosa Ziehau vmbus_msghc_exec_noresult(struct vmbus_msghc *mh)
276236764b1SSepherosa Ziehau {
277236764b1SSepherosa Ziehau 	sbintime_t time = SBT_1MS;
278236764b1SSepherosa Ziehau 	int i;
279236764b1SSepherosa Ziehau 
280236764b1SSepherosa Ziehau 	/*
281236764b1SSepherosa Ziehau 	 * Save the input parameter so that we could restore the input
282236764b1SSepherosa Ziehau 	 * parameter if the Hypercall failed.
283236764b1SSepherosa Ziehau 	 *
284236764b1SSepherosa Ziehau 	 * XXX
285236764b1SSepherosa Ziehau 	 * Is this really necessary?!  i.e. Will the Hypercall ever
286236764b1SSepherosa Ziehau 	 * overwrite the input parameter?
287236764b1SSepherosa Ziehau 	 */
288236764b1SSepherosa Ziehau 	memcpy(&mh->mh_inprm_save, mh->mh_inprm, HYPERCALL_POSTMSGIN_SIZE);
289236764b1SSepherosa Ziehau 
290236764b1SSepherosa Ziehau 	/*
291236764b1SSepherosa Ziehau 	 * In order to cope with transient failures, e.g. insufficient
292236764b1SSepherosa Ziehau 	 * resources on host side, we retry the post message Hypercall
293236764b1SSepherosa Ziehau 	 * several times.  20 retries seem sufficient.
294236764b1SSepherosa Ziehau 	 */
295236764b1SSepherosa Ziehau #define HC_RETRY_MAX	20
296236764b1SSepherosa Ziehau 
297236764b1SSepherosa Ziehau 	for (i = 0; i < HC_RETRY_MAX; ++i) {
298236764b1SSepherosa Ziehau 		uint64_t status;
299236764b1SSepherosa Ziehau 
300236764b1SSepherosa Ziehau 		status = hypercall_post_message(mh->mh_inprm_dma.hv_paddr);
301236764b1SSepherosa Ziehau 		if (status == HYPERCALL_STATUS_SUCCESS)
302236764b1SSepherosa Ziehau 			return 0;
303236764b1SSepherosa Ziehau 
304236764b1SSepherosa Ziehau 		pause_sbt("hcpmsg", time, 0, C_HARDCLOCK);
305236764b1SSepherosa Ziehau 		if (time < SBT_1S * 2)
306236764b1SSepherosa Ziehau 			time *= 2;
307236764b1SSepherosa Ziehau 
308236764b1SSepherosa Ziehau 		/* Restore input parameter and try again */
309236764b1SSepherosa Ziehau 		memcpy(mh->mh_inprm, &mh->mh_inprm_save,
310236764b1SSepherosa Ziehau 		    HYPERCALL_POSTMSGIN_SIZE);
311236764b1SSepherosa Ziehau 	}
312236764b1SSepherosa Ziehau 
313236764b1SSepherosa Ziehau #undef HC_RETRY_MAX
314236764b1SSepherosa Ziehau 
315236764b1SSepherosa Ziehau 	return EIO;
316236764b1SSepherosa Ziehau }
317236764b1SSepherosa Ziehau 
318236764b1SSepherosa Ziehau int
319236764b1SSepherosa Ziehau vmbus_msghc_exec(struct vmbus_softc *sc, struct vmbus_msghc *mh)
320236764b1SSepherosa Ziehau {
321236764b1SSepherosa Ziehau 	struct vmbus_msghc_ctx *mhc = sc->vmbus_msg_hc;
322236764b1SSepherosa Ziehau 	int error;
323236764b1SSepherosa Ziehau 
324236764b1SSepherosa Ziehau 	KASSERT(mh->mh_resp == NULL, ("hypercall msg has pending response"));
325236764b1SSepherosa Ziehau 
326236764b1SSepherosa Ziehau 	mtx_lock(&mhc->mhc_active_lock);
327236764b1SSepherosa Ziehau 	KASSERT(mhc->mhc_active == NULL, ("pending active msg hypercall"));
328236764b1SSepherosa Ziehau 	mhc->mhc_active = mh;
329236764b1SSepherosa Ziehau 	mtx_unlock(&mhc->mhc_active_lock);
330236764b1SSepherosa Ziehau 
331236764b1SSepherosa Ziehau 	error = vmbus_msghc_exec_noresult(mh);
332236764b1SSepherosa Ziehau 	if (error) {
333236764b1SSepherosa Ziehau 		mtx_lock(&mhc->mhc_active_lock);
334236764b1SSepherosa Ziehau 		KASSERT(mhc->mhc_active == mh, ("msghc mismatch"));
335236764b1SSepherosa Ziehau 		mhc->mhc_active = NULL;
336236764b1SSepherosa Ziehau 		mtx_unlock(&mhc->mhc_active_lock);
337236764b1SSepherosa Ziehau 	}
338236764b1SSepherosa Ziehau 	return error;
339236764b1SSepherosa Ziehau }
340236764b1SSepherosa Ziehau 
341236764b1SSepherosa Ziehau const struct vmbus_message *
342236764b1SSepherosa Ziehau vmbus_msghc_wait_result(struct vmbus_softc *sc, struct vmbus_msghc *mh)
343236764b1SSepherosa Ziehau {
344236764b1SSepherosa Ziehau 	struct vmbus_msghc_ctx *mhc = sc->vmbus_msg_hc;
345236764b1SSepherosa Ziehau 
346236764b1SSepherosa Ziehau 	mtx_lock(&mhc->mhc_active_lock);
347236764b1SSepherosa Ziehau 
348236764b1SSepherosa Ziehau 	KASSERT(mhc->mhc_active == mh, ("msghc mismatch"));
349236764b1SSepherosa Ziehau 	while (mh->mh_resp == NULL) {
350236764b1SSepherosa Ziehau 		mtx_sleep(&mhc->mhc_active, &mhc->mhc_active_lock, 0,
351236764b1SSepherosa Ziehau 		    "wmsghc", 0);
352236764b1SSepherosa Ziehau 	}
353236764b1SSepherosa Ziehau 	mhc->mhc_active = NULL;
354236764b1SSepherosa Ziehau 
355236764b1SSepherosa Ziehau 	mtx_unlock(&mhc->mhc_active_lock);
356236764b1SSepherosa Ziehau 
357236764b1SSepherosa Ziehau 	return mh->mh_resp;
358236764b1SSepherosa Ziehau }
359236764b1SSepherosa Ziehau 
360236764b1SSepherosa Ziehau void
361236764b1SSepherosa Ziehau vmbus_msghc_wakeup(struct vmbus_softc *sc, const struct vmbus_message *msg)
362236764b1SSepherosa Ziehau {
363236764b1SSepherosa Ziehau 	struct vmbus_msghc_ctx *mhc = sc->vmbus_msg_hc;
364236764b1SSepherosa Ziehau 	struct vmbus_msghc *mh;
365236764b1SSepherosa Ziehau 
366236764b1SSepherosa Ziehau 	mtx_lock(&mhc->mhc_active_lock);
367236764b1SSepherosa Ziehau 
368236764b1SSepherosa Ziehau 	mh = mhc->mhc_active;
369236764b1SSepherosa Ziehau 	KASSERT(mh != NULL, ("no pending msg hypercall"));
370236764b1SSepherosa Ziehau 	memcpy(&mh->mh_resp0, msg, sizeof(mh->mh_resp0));
371236764b1SSepherosa Ziehau 	mh->mh_resp = &mh->mh_resp0;
372236764b1SSepherosa Ziehau 
373236764b1SSepherosa Ziehau 	mtx_unlock(&mhc->mhc_active_lock);
374236764b1SSepherosa Ziehau 	wakeup(&mhc->mhc_active);
375236764b1SSepherosa Ziehau }
376236764b1SSepherosa Ziehau 
377ee7e313fSSepherosa Ziehau uint32_t
378ee7e313fSSepherosa Ziehau vmbus_gpadl_alloc(struct vmbus_softc *sc)
379ee7e313fSSepherosa Ziehau {
380ee7e313fSSepherosa Ziehau 	return atomic_fetchadd_int(&sc->vmbus_gpadl, 1);
381ee7e313fSSepherosa Ziehau }
382ee7e313fSSepherosa Ziehau 
383236764b1SSepherosa Ziehau static int
384f24517f0SSepherosa Ziehau vmbus_connect(struct vmbus_softc *sc, uint32_t version)
385236764b1SSepherosa Ziehau {
386f24517f0SSepherosa Ziehau 	struct vmbus_chanmsg_connect *req;
387236764b1SSepherosa Ziehau 	const struct vmbus_message *msg;
388236764b1SSepherosa Ziehau 	struct vmbus_msghc *mh;
389f24517f0SSepherosa Ziehau 	int error, done = 0;
390236764b1SSepherosa Ziehau 
391236764b1SSepherosa Ziehau 	mh = vmbus_msghc_get(sc, sizeof(*req));
392236764b1SSepherosa Ziehau 	if (mh == NULL)
393236764b1SSepherosa Ziehau 		return ENXIO;
394236764b1SSepherosa Ziehau 
395236764b1SSepherosa Ziehau 	req = vmbus_msghc_dataptr(mh);
396f24517f0SSepherosa Ziehau 	req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_CONNECT;
397236764b1SSepherosa Ziehau 	req->chm_ver = version;
398236764b1SSepherosa Ziehau 	req->chm_evtflags = sc->vmbus_evtflags_dma.hv_paddr;
399236764b1SSepherosa Ziehau 	req->chm_mnf1 = sc->vmbus_mnf1_dma.hv_paddr;
400236764b1SSepherosa Ziehau 	req->chm_mnf2 = sc->vmbus_mnf2_dma.hv_paddr;
401236764b1SSepherosa Ziehau 
402236764b1SSepherosa Ziehau 	error = vmbus_msghc_exec(sc, mh);
403236764b1SSepherosa Ziehau 	if (error) {
404236764b1SSepherosa Ziehau 		vmbus_msghc_put(sc, mh);
405236764b1SSepherosa Ziehau 		return error;
406236764b1SSepherosa Ziehau 	}
407236764b1SSepherosa Ziehau 
408236764b1SSepherosa Ziehau 	msg = vmbus_msghc_wait_result(sc, mh);
409f24517f0SSepherosa Ziehau 	done = ((const struct vmbus_chanmsg_connect_resp *)
410f24517f0SSepherosa Ziehau 	    msg->msg_data)->chm_done;
411236764b1SSepherosa Ziehau 
412236764b1SSepherosa Ziehau 	vmbus_msghc_put(sc, mh);
413236764b1SSepherosa Ziehau 
414f24517f0SSepherosa Ziehau 	return (done ? 0 : EOPNOTSUPP);
415236764b1SSepherosa Ziehau }
416236764b1SSepherosa Ziehau 
417236764b1SSepherosa Ziehau static int
418236764b1SSepherosa Ziehau vmbus_init(struct vmbus_softc *sc)
419236764b1SSepherosa Ziehau {
420236764b1SSepherosa Ziehau 	int i;
421236764b1SSepherosa Ziehau 
422236764b1SSepherosa Ziehau 	for (i = 0; i < nitems(vmbus_version); ++i) {
423236764b1SSepherosa Ziehau 		int error;
424236764b1SSepherosa Ziehau 
425f24517f0SSepherosa Ziehau 		error = vmbus_connect(sc, vmbus_version[i]);
426236764b1SSepherosa Ziehau 		if (!error) {
42738d19df6SSepherosa Ziehau 			sc->vmbus_version = vmbus_version[i];
428236764b1SSepherosa Ziehau 			device_printf(sc->vmbus_dev, "version %u.%u\n",
42938d19df6SSepherosa Ziehau 			    VMBUS_VERSION_MAJOR(sc->vmbus_version),
43038d19df6SSepherosa Ziehau 			    VMBUS_VERSION_MINOR(sc->vmbus_version));
431236764b1SSepherosa Ziehau 			return 0;
432236764b1SSepherosa Ziehau 		}
433236764b1SSepherosa Ziehau 	}
434236764b1SSepherosa Ziehau 	return ENXIO;
435236764b1SSepherosa Ziehau }
436236764b1SSepherosa Ziehau 
4371ecb2466SSepherosa Ziehau static void
438f24517f0SSepherosa Ziehau vmbus_disconnect(struct vmbus_softc *sc)
4391ecb2466SSepherosa Ziehau {
440f24517f0SSepherosa Ziehau 	struct vmbus_chanmsg_disconnect *req;
4411ecb2466SSepherosa Ziehau 	struct vmbus_msghc *mh;
4421ecb2466SSepherosa Ziehau 	int error;
4431ecb2466SSepherosa Ziehau 
4441ecb2466SSepherosa Ziehau 	mh = vmbus_msghc_get(sc, sizeof(*req));
4451ecb2466SSepherosa Ziehau 	if (mh == NULL) {
4461ecb2466SSepherosa Ziehau 		device_printf(sc->vmbus_dev,
447f24517f0SSepherosa Ziehau 		    "can not get msg hypercall for disconnect\n");
4481ecb2466SSepherosa Ziehau 		return;
4491ecb2466SSepherosa Ziehau 	}
4501ecb2466SSepherosa Ziehau 
4511ecb2466SSepherosa Ziehau 	req = vmbus_msghc_dataptr(mh);
452f24517f0SSepherosa Ziehau 	req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_DISCONNECT;
4531ecb2466SSepherosa Ziehau 
4541ecb2466SSepherosa Ziehau 	error = vmbus_msghc_exec_noresult(mh);
4551ecb2466SSepherosa Ziehau 	vmbus_msghc_put(sc, mh);
4561ecb2466SSepherosa Ziehau 
4571ecb2466SSepherosa Ziehau 	if (error) {
4581ecb2466SSepherosa Ziehau 		device_printf(sc->vmbus_dev,
459f24517f0SSepherosa Ziehau 		    "disconnect msg hypercall failed\n");
4601ecb2466SSepherosa Ziehau 	}
4611ecb2466SSepherosa Ziehau }
4621ecb2466SSepherosa Ziehau 
463c1cc5bdfSSepherosa Ziehau static int
464c1cc5bdfSSepherosa Ziehau vmbus_req_channels(struct vmbus_softc *sc)
465c1cc5bdfSSepherosa Ziehau {
466f24517f0SSepherosa Ziehau 	struct vmbus_chanmsg_chrequest *req;
467c1cc5bdfSSepherosa Ziehau 	struct vmbus_msghc *mh;
468c1cc5bdfSSepherosa Ziehau 	int error;
469c1cc5bdfSSepherosa Ziehau 
470c1cc5bdfSSepherosa Ziehau 	mh = vmbus_msghc_get(sc, sizeof(*req));
471c1cc5bdfSSepherosa Ziehau 	if (mh == NULL)
472c1cc5bdfSSepherosa Ziehau 		return ENXIO;
473c1cc5bdfSSepherosa Ziehau 
474c1cc5bdfSSepherosa Ziehau 	req = vmbus_msghc_dataptr(mh);
475f24517f0SSepherosa Ziehau 	req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_CHREQUEST;
476c1cc5bdfSSepherosa Ziehau 
477c1cc5bdfSSepherosa Ziehau 	error = vmbus_msghc_exec_noresult(mh);
478c1cc5bdfSSepherosa Ziehau 	vmbus_msghc_put(sc, mh);
479c1cc5bdfSSepherosa Ziehau 
480c1cc5bdfSSepherosa Ziehau 	return error;
481c1cc5bdfSSepherosa Ziehau }
482c1cc5bdfSSepherosa Ziehau 
483796a90bfSSepherosa Ziehau void
484796a90bfSSepherosa Ziehau vmbus_scan_newchan(struct vmbus_softc *sc)
485796a90bfSSepherosa Ziehau {
486796a90bfSSepherosa Ziehau 	mtx_lock(&sc->vmbus_scan_lock);
487796a90bfSSepherosa Ziehau 	if ((sc->vmbus_scan_chcnt & VMBUS_SCAN_CHCNT_DONE) == 0)
488796a90bfSSepherosa Ziehau 		sc->vmbus_scan_chcnt++;
489796a90bfSSepherosa Ziehau 	mtx_unlock(&sc->vmbus_scan_lock);
490796a90bfSSepherosa Ziehau }
491796a90bfSSepherosa Ziehau 
492796a90bfSSepherosa Ziehau void
493796a90bfSSepherosa Ziehau vmbus_scan_done(struct vmbus_softc *sc)
494796a90bfSSepherosa Ziehau {
495796a90bfSSepherosa Ziehau 	mtx_lock(&sc->vmbus_scan_lock);
496796a90bfSSepherosa Ziehau 	sc->vmbus_scan_chcnt |= VMBUS_SCAN_CHCNT_DONE;
497796a90bfSSepherosa Ziehau 	mtx_unlock(&sc->vmbus_scan_lock);
498796a90bfSSepherosa Ziehau 	wakeup(&sc->vmbus_scan_chcnt);
499796a90bfSSepherosa Ziehau }
500796a90bfSSepherosa Ziehau 
501796a90bfSSepherosa Ziehau static void
502796a90bfSSepherosa Ziehau vmbus_scan_newdev(struct vmbus_softc *sc)
503796a90bfSSepherosa Ziehau {
504796a90bfSSepherosa Ziehau 	mtx_lock(&sc->vmbus_scan_lock);
505796a90bfSSepherosa Ziehau 	sc->vmbus_scan_devcnt++;
506796a90bfSSepherosa Ziehau 	mtx_unlock(&sc->vmbus_scan_lock);
507796a90bfSSepherosa Ziehau 	wakeup(&sc->vmbus_scan_devcnt);
508796a90bfSSepherosa Ziehau }
509796a90bfSSepherosa Ziehau 
510796a90bfSSepherosa Ziehau static void
511796a90bfSSepherosa Ziehau vmbus_scan_wait(struct vmbus_softc *sc)
512796a90bfSSepherosa Ziehau {
513796a90bfSSepherosa Ziehau 	uint32_t chancnt;
514796a90bfSSepherosa Ziehau 
515796a90bfSSepherosa Ziehau 	mtx_lock(&sc->vmbus_scan_lock);
516796a90bfSSepherosa Ziehau 	while ((sc->vmbus_scan_chcnt & VMBUS_SCAN_CHCNT_DONE) == 0) {
517796a90bfSSepherosa Ziehau 		mtx_sleep(&sc->vmbus_scan_chcnt, &sc->vmbus_scan_lock, 0,
518796a90bfSSepherosa Ziehau 		    "waitch", 0);
519796a90bfSSepherosa Ziehau 	}
520796a90bfSSepherosa Ziehau 	chancnt = sc->vmbus_scan_chcnt & ~VMBUS_SCAN_CHCNT_DONE;
521796a90bfSSepherosa Ziehau 
522796a90bfSSepherosa Ziehau 	while (sc->vmbus_scan_devcnt != chancnt) {
523796a90bfSSepherosa Ziehau 		mtx_sleep(&sc->vmbus_scan_devcnt, &sc->vmbus_scan_lock, 0,
524796a90bfSSepherosa Ziehau 		    "waitdev", 0);
525796a90bfSSepherosa Ziehau 	}
526796a90bfSSepherosa Ziehau 	mtx_unlock(&sc->vmbus_scan_lock);
527796a90bfSSepherosa Ziehau }
528796a90bfSSepherosa Ziehau 
529796a90bfSSepherosa Ziehau static int
530796a90bfSSepherosa Ziehau vmbus_scan(struct vmbus_softc *sc)
531796a90bfSSepherosa Ziehau {
532796a90bfSSepherosa Ziehau 	int error;
533796a90bfSSepherosa Ziehau 
534796a90bfSSepherosa Ziehau 	/*
535796a90bfSSepherosa Ziehau 	 * Start vmbus scanning.
536796a90bfSSepherosa Ziehau 	 */
537796a90bfSSepherosa Ziehau 	error = vmbus_req_channels(sc);
538796a90bfSSepherosa Ziehau 	if (error) {
539796a90bfSSepherosa Ziehau 		device_printf(sc->vmbus_dev, "channel request failed: %d\n",
540796a90bfSSepherosa Ziehau 		    error);
541796a90bfSSepherosa Ziehau 		return error;
542796a90bfSSepherosa Ziehau 	}
543796a90bfSSepherosa Ziehau 
544796a90bfSSepherosa Ziehau 	/*
545796a90bfSSepherosa Ziehau 	 * Wait for all devices are added to vmbus.
546796a90bfSSepherosa Ziehau 	 */
547796a90bfSSepherosa Ziehau 	vmbus_scan_wait(sc);
548796a90bfSSepherosa Ziehau 
549796a90bfSSepherosa Ziehau 	/*
550796a90bfSSepherosa Ziehau 	 * Identify, probe and attach.
551796a90bfSSepherosa Ziehau 	 */
552796a90bfSSepherosa Ziehau 	bus_generic_probe(sc->vmbus_dev);
553796a90bfSSepherosa Ziehau 	bus_generic_attach(sc->vmbus_dev);
554796a90bfSSepherosa Ziehau 
555796a90bfSSepherosa Ziehau 	if (bootverbose) {
556796a90bfSSepherosa Ziehau 		device_printf(sc->vmbus_dev, "device scan, probe and attach "
557796a90bfSSepherosa Ziehau 		    "done\n");
558796a90bfSSepherosa Ziehau 	}
559796a90bfSSepherosa Ziehau 	return 0;
560796a90bfSSepherosa Ziehau }
561796a90bfSSepherosa Ziehau 
562b7bb4816SSepherosa Ziehau static void
563b7bb4816SSepherosa Ziehau vmbus_msg_task(void *xsc, int pending __unused)
564b7bb4816SSepherosa Ziehau {
565b7bb4816SSepherosa Ziehau 	struct vmbus_softc *sc = xsc;
566b7bb4816SSepherosa Ziehau 	volatile struct vmbus_message *msg;
567b7bb4816SSepherosa Ziehau 
568b7bb4816SSepherosa Ziehau 	msg = VMBUS_PCPU_GET(sc, message, curcpu) + VMBUS_SINT_MESSAGE;
569b7bb4816SSepherosa Ziehau 	for (;;) {
570236764b1SSepherosa Ziehau 		if (msg->msg_type == HYPERV_MSGTYPE_NONE) {
571fa4828b0SSepherosa Ziehau 			/* No message */
572fa4828b0SSepherosa Ziehau 			break;
573236764b1SSepherosa Ziehau 		} else if (msg->msg_type == HYPERV_MSGTYPE_CHANNEL) {
57412ea25aeSSepherosa Ziehau 			/* Channel message */
57543926ba1SSepherosa Ziehau 			vmbus_chan_msgproc(sc,
57643926ba1SSepherosa Ziehau 			    __DEVOLATILE(const struct vmbus_message *, msg));
577fa4828b0SSepherosa Ziehau 		}
578b7bb4816SSepherosa Ziehau 
579236764b1SSepherosa Ziehau 		msg->msg_type = HYPERV_MSGTYPE_NONE;
580b7bb4816SSepherosa Ziehau 		/*
581b7bb4816SSepherosa Ziehau 		 * Make sure the write to msg_type (i.e. set to
582236764b1SSepherosa Ziehau 		 * HYPERV_MSGTYPE_NONE) happens before we read the
583b7bb4816SSepherosa Ziehau 		 * msg_flags and EOMing. Otherwise, the EOMing will
584b7bb4816SSepherosa Ziehau 		 * not deliver any more messages since there is no
585b7bb4816SSepherosa Ziehau 		 * empty slot
586b7bb4816SSepherosa Ziehau 		 *
587b7bb4816SSepherosa Ziehau 		 * NOTE:
588b7bb4816SSepherosa Ziehau 		 * mb() is used here, since atomic_thread_fence_seq_cst()
589b7bb4816SSepherosa Ziehau 		 * will become compiler fence on UP kernel.
590b7bb4816SSepherosa Ziehau 		 */
591b7bb4816SSepherosa Ziehau 		mb();
592b7bb4816SSepherosa Ziehau 		if (msg->msg_flags & VMBUS_MSGFLAG_PENDING) {
593b7bb4816SSepherosa Ziehau 			/*
594b7bb4816SSepherosa Ziehau 			 * This will cause message queue rescan to possibly
595b7bb4816SSepherosa Ziehau 			 * deliver another msg from the hypervisor
596b7bb4816SSepherosa Ziehau 			 */
597b7bb4816SSepherosa Ziehau 			wrmsr(MSR_HV_EOM, 0);
598b7bb4816SSepherosa Ziehau 		}
599b7bb4816SSepherosa Ziehau 	}
600b7bb4816SSepherosa Ziehau }
601b7bb4816SSepherosa Ziehau 
602b7bb4816SSepherosa Ziehau static __inline int
603b7bb4816SSepherosa Ziehau vmbus_handle_intr1(struct vmbus_softc *sc, struct trapframe *frame, int cpu)
604b7bb4816SSepherosa Ziehau {
605b7bb4816SSepherosa Ziehau 	volatile struct vmbus_message *msg;
606b7bb4816SSepherosa Ziehau 	struct vmbus_message *msg_base;
607b7bb4816SSepherosa Ziehau 
608b7bb4816SSepherosa Ziehau 	msg_base = VMBUS_PCPU_GET(sc, message, cpu);
609b7bb4816SSepherosa Ziehau 
610b7bb4816SSepherosa Ziehau 	/*
611b7bb4816SSepherosa Ziehau 	 * Check event timer.
612b7bb4816SSepherosa Ziehau 	 *
613b7bb4816SSepherosa Ziehau 	 * TODO: move this to independent IDT vector.
614b7bb4816SSepherosa Ziehau 	 */
615b7bb4816SSepherosa Ziehau 	msg = msg_base + VMBUS_SINT_TIMER;
616236764b1SSepherosa Ziehau 	if (msg->msg_type == HYPERV_MSGTYPE_TIMER_EXPIRED) {
617236764b1SSepherosa Ziehau 		msg->msg_type = HYPERV_MSGTYPE_NONE;
618b7bb4816SSepherosa Ziehau 
619b7bb4816SSepherosa Ziehau 		vmbus_et_intr(frame);
620b7bb4816SSepherosa Ziehau 
621b7bb4816SSepherosa Ziehau 		/*
622b7bb4816SSepherosa Ziehau 		 * Make sure the write to msg_type (i.e. set to
623236764b1SSepherosa Ziehau 		 * HYPERV_MSGTYPE_NONE) happens before we read the
624b7bb4816SSepherosa Ziehau 		 * msg_flags and EOMing. Otherwise, the EOMing will
625b7bb4816SSepherosa Ziehau 		 * not deliver any more messages since there is no
626b7bb4816SSepherosa Ziehau 		 * empty slot
627b7bb4816SSepherosa Ziehau 		 *
628b7bb4816SSepherosa Ziehau 		 * NOTE:
629b7bb4816SSepherosa Ziehau 		 * mb() is used here, since atomic_thread_fence_seq_cst()
630b7bb4816SSepherosa Ziehau 		 * will become compiler fence on UP kernel.
631b7bb4816SSepherosa Ziehau 		 */
632b7bb4816SSepherosa Ziehau 		mb();
633b7bb4816SSepherosa Ziehau 		if (msg->msg_flags & VMBUS_MSGFLAG_PENDING) {
634b7bb4816SSepherosa Ziehau 			/*
635b7bb4816SSepherosa Ziehau 			 * This will cause message queue rescan to possibly
636b7bb4816SSepherosa Ziehau 			 * deliver another msg from the hypervisor
637b7bb4816SSepherosa Ziehau 			 */
638b7bb4816SSepherosa Ziehau 			wrmsr(MSR_HV_EOM, 0);
639b7bb4816SSepherosa Ziehau 		}
640b7bb4816SSepherosa Ziehau 	}
641b7bb4816SSepherosa Ziehau 
642b7bb4816SSepherosa Ziehau 	/*
643b7bb4816SSepherosa Ziehau 	 * Check events.  Hot path for network and storage I/O data; high rate.
644b7bb4816SSepherosa Ziehau 	 *
645b7bb4816SSepherosa Ziehau 	 * NOTE:
646b7bb4816SSepherosa Ziehau 	 * As recommended by the Windows guest fellows, we check events before
647b7bb4816SSepherosa Ziehau 	 * checking messages.
648b7bb4816SSepherosa Ziehau 	 */
649b7bb4816SSepherosa Ziehau 	sc->vmbus_event_proc(sc, cpu);
650b7bb4816SSepherosa Ziehau 
651b7bb4816SSepherosa Ziehau 	/*
652b7bb4816SSepherosa Ziehau 	 * Check messages.  Mainly management stuffs; ultra low rate.
653b7bb4816SSepherosa Ziehau 	 */
654b7bb4816SSepherosa Ziehau 	msg = msg_base + VMBUS_SINT_MESSAGE;
655236764b1SSepherosa Ziehau 	if (__predict_false(msg->msg_type != HYPERV_MSGTYPE_NONE)) {
656b7bb4816SSepherosa Ziehau 		taskqueue_enqueue(VMBUS_PCPU_GET(sc, message_tq, cpu),
657b7bb4816SSepherosa Ziehau 		    VMBUS_PCPU_PTR(sc, message_task, cpu));
658b7bb4816SSepherosa Ziehau 	}
659b7bb4816SSepherosa Ziehau 
660b7bb4816SSepherosa Ziehau 	return (FILTER_HANDLED);
661b7bb4816SSepherosa Ziehau }
662b7bb4816SSepherosa Ziehau 
663b7bb4816SSepherosa Ziehau void
664b7bb4816SSepherosa Ziehau vmbus_handle_intr(struct trapframe *trap_frame)
665b7bb4816SSepherosa Ziehau {
666b7bb4816SSepherosa Ziehau 	struct vmbus_softc *sc = vmbus_get_softc();
667b7bb4816SSepherosa Ziehau 	int cpu = curcpu;
668b7bb4816SSepherosa Ziehau 
669b7bb4816SSepherosa Ziehau 	/*
670b7bb4816SSepherosa Ziehau 	 * Disable preemption.
671b7bb4816SSepherosa Ziehau 	 */
672b7bb4816SSepherosa Ziehau 	critical_enter();
673b7bb4816SSepherosa Ziehau 
674b7bb4816SSepherosa Ziehau 	/*
675b7bb4816SSepherosa Ziehau 	 * Do a little interrupt counting.
676b7bb4816SSepherosa Ziehau 	 */
677b7bb4816SSepherosa Ziehau 	(*VMBUS_PCPU_GET(sc, intr_cnt, cpu))++;
678b7bb4816SSepherosa Ziehau 
679b7bb4816SSepherosa Ziehau 	vmbus_handle_intr1(sc, trap_frame, cpu);
680b7bb4816SSepherosa Ziehau 
681b7bb4816SSepherosa Ziehau 	/*
682b7bb4816SSepherosa Ziehau 	 * Enable preemption.
683b7bb4816SSepherosa Ziehau 	 */
684b7bb4816SSepherosa Ziehau 	critical_exit();
685b7bb4816SSepherosa Ziehau }
686b7bb4816SSepherosa Ziehau 
687b7bb4816SSepherosa Ziehau static void
688b7bb4816SSepherosa Ziehau vmbus_synic_setup(void *xsc)
689b7bb4816SSepherosa Ziehau {
690b7bb4816SSepherosa Ziehau 	struct vmbus_softc *sc = xsc;
691b7bb4816SSepherosa Ziehau 	int cpu = curcpu;
692b7bb4816SSepherosa Ziehau 	uint64_t val, orig;
693b7bb4816SSepherosa Ziehau 	uint32_t sint;
694b7bb4816SSepherosa Ziehau 
695b7bb4816SSepherosa Ziehau 	if (hyperv_features & CPUID_HV_MSR_VP_INDEX) {
696b7bb4816SSepherosa Ziehau 		/*
697b7bb4816SSepherosa Ziehau 		 * Save virtual processor id.
698b7bb4816SSepherosa Ziehau 		 */
699b7bb4816SSepherosa Ziehau 		VMBUS_PCPU_GET(sc, vcpuid, cpu) = rdmsr(MSR_HV_VP_INDEX);
700b7bb4816SSepherosa Ziehau 	} else {
701b7bb4816SSepherosa Ziehau 		/*
702b7bb4816SSepherosa Ziehau 		 * XXX
703b7bb4816SSepherosa Ziehau 		 * Virtual processoor id is only used by a pretty broken
704b7bb4816SSepherosa Ziehau 		 * channel selection code from storvsc.  It's nothing
705b7bb4816SSepherosa Ziehau 		 * critical even if CPUID_HV_MSR_VP_INDEX is not set; keep
706b7bb4816SSepherosa Ziehau 		 * moving on.
707b7bb4816SSepherosa Ziehau 		 */
708b7bb4816SSepherosa Ziehau 		VMBUS_PCPU_GET(sc, vcpuid, cpu) = cpu;
709b7bb4816SSepherosa Ziehau 	}
710b7bb4816SSepherosa Ziehau 
711b7bb4816SSepherosa Ziehau 	/*
712b7bb4816SSepherosa Ziehau 	 * Setup the SynIC message.
713b7bb4816SSepherosa Ziehau 	 */
714b7bb4816SSepherosa Ziehau 	orig = rdmsr(MSR_HV_SIMP);
715b7bb4816SSepherosa Ziehau 	val = MSR_HV_SIMP_ENABLE | (orig & MSR_HV_SIMP_RSVD_MASK) |
716b7bb4816SSepherosa Ziehau 	    ((VMBUS_PCPU_GET(sc, message_dma.hv_paddr, cpu) >> PAGE_SHIFT) <<
717b7bb4816SSepherosa Ziehau 	     MSR_HV_SIMP_PGSHIFT);
718b7bb4816SSepherosa Ziehau 	wrmsr(MSR_HV_SIMP, val);
719b7bb4816SSepherosa Ziehau 
720b7bb4816SSepherosa Ziehau 	/*
721b7bb4816SSepherosa Ziehau 	 * Setup the SynIC event flags.
722b7bb4816SSepherosa Ziehau 	 */
723b7bb4816SSepherosa Ziehau 	orig = rdmsr(MSR_HV_SIEFP);
724b7bb4816SSepherosa Ziehau 	val = MSR_HV_SIEFP_ENABLE | (orig & MSR_HV_SIEFP_RSVD_MASK) |
725b7bb4816SSepherosa Ziehau 	    ((VMBUS_PCPU_GET(sc, event_flags_dma.hv_paddr, cpu)
726b7bb4816SSepherosa Ziehau 	      >> PAGE_SHIFT) << MSR_HV_SIEFP_PGSHIFT);
727b7bb4816SSepherosa Ziehau 	wrmsr(MSR_HV_SIEFP, val);
728b7bb4816SSepherosa Ziehau 
729b7bb4816SSepherosa Ziehau 
730b7bb4816SSepherosa Ziehau 	/*
731b7bb4816SSepherosa Ziehau 	 * Configure and unmask SINT for message and event flags.
732b7bb4816SSepherosa Ziehau 	 */
733b7bb4816SSepherosa Ziehau 	sint = MSR_HV_SINT0 + VMBUS_SINT_MESSAGE;
734b7bb4816SSepherosa Ziehau 	orig = rdmsr(sint);
735b7bb4816SSepherosa Ziehau 	val = sc->vmbus_idtvec | MSR_HV_SINT_AUTOEOI |
736b7bb4816SSepherosa Ziehau 	    (orig & MSR_HV_SINT_RSVD_MASK);
737b7bb4816SSepherosa Ziehau 	wrmsr(sint, val);
738b7bb4816SSepherosa Ziehau 
739b7bb4816SSepherosa Ziehau 	/*
740b7bb4816SSepherosa Ziehau 	 * Configure and unmask SINT for timer.
741b7bb4816SSepherosa Ziehau 	 */
742b7bb4816SSepherosa Ziehau 	sint = MSR_HV_SINT0 + VMBUS_SINT_TIMER;
743b7bb4816SSepherosa Ziehau 	orig = rdmsr(sint);
744b7bb4816SSepherosa Ziehau 	val = sc->vmbus_idtvec | MSR_HV_SINT_AUTOEOI |
745b7bb4816SSepherosa Ziehau 	    (orig & MSR_HV_SINT_RSVD_MASK);
746b7bb4816SSepherosa Ziehau 	wrmsr(sint, val);
747b7bb4816SSepherosa Ziehau 
748b7bb4816SSepherosa Ziehau 	/*
749b7bb4816SSepherosa Ziehau 	 * All done; enable SynIC.
750b7bb4816SSepherosa Ziehau 	 */
751b7bb4816SSepherosa Ziehau 	orig = rdmsr(MSR_HV_SCONTROL);
752b7bb4816SSepherosa Ziehau 	val = MSR_HV_SCTRL_ENABLE | (orig & MSR_HV_SCTRL_RSVD_MASK);
753b7bb4816SSepherosa Ziehau 	wrmsr(MSR_HV_SCONTROL, val);
754b7bb4816SSepherosa Ziehau }
755b7bb4816SSepherosa Ziehau 
756b7bb4816SSepherosa Ziehau static void
757b7bb4816SSepherosa Ziehau vmbus_synic_teardown(void *arg)
758b7bb4816SSepherosa Ziehau {
759b7bb4816SSepherosa Ziehau 	uint64_t orig;
760b7bb4816SSepherosa Ziehau 	uint32_t sint;
761b7bb4816SSepherosa Ziehau 
762b7bb4816SSepherosa Ziehau 	/*
763b7bb4816SSepherosa Ziehau 	 * Disable SynIC.
764b7bb4816SSepherosa Ziehau 	 */
765b7bb4816SSepherosa Ziehau 	orig = rdmsr(MSR_HV_SCONTROL);
766b7bb4816SSepherosa Ziehau 	wrmsr(MSR_HV_SCONTROL, (orig & MSR_HV_SCTRL_RSVD_MASK));
767b7bb4816SSepherosa Ziehau 
768b7bb4816SSepherosa Ziehau 	/*
769b7bb4816SSepherosa Ziehau 	 * Mask message and event flags SINT.
770b7bb4816SSepherosa Ziehau 	 */
771b7bb4816SSepherosa Ziehau 	sint = MSR_HV_SINT0 + VMBUS_SINT_MESSAGE;
772b7bb4816SSepherosa Ziehau 	orig = rdmsr(sint);
773b7bb4816SSepherosa Ziehau 	wrmsr(sint, orig | MSR_HV_SINT_MASKED);
774b7bb4816SSepherosa Ziehau 
775b7bb4816SSepherosa Ziehau 	/*
776b7bb4816SSepherosa Ziehau 	 * Mask timer SINT.
777b7bb4816SSepherosa Ziehau 	 */
778b7bb4816SSepherosa Ziehau 	sint = MSR_HV_SINT0 + VMBUS_SINT_TIMER;
779b7bb4816SSepherosa Ziehau 	orig = rdmsr(sint);
780b7bb4816SSepherosa Ziehau 	wrmsr(sint, orig | MSR_HV_SINT_MASKED);
781b7bb4816SSepherosa Ziehau 
782b7bb4816SSepherosa Ziehau 	/*
783b7bb4816SSepherosa Ziehau 	 * Teardown SynIC message.
784b7bb4816SSepherosa Ziehau 	 */
785b7bb4816SSepherosa Ziehau 	orig = rdmsr(MSR_HV_SIMP);
786b7bb4816SSepherosa Ziehau 	wrmsr(MSR_HV_SIMP, (orig & MSR_HV_SIMP_RSVD_MASK));
787b7bb4816SSepherosa Ziehau 
788b7bb4816SSepherosa Ziehau 	/*
789b7bb4816SSepherosa Ziehau 	 * Teardown SynIC event flags.
790b7bb4816SSepherosa Ziehau 	 */
791b7bb4816SSepherosa Ziehau 	orig = rdmsr(MSR_HV_SIEFP);
792b7bb4816SSepherosa Ziehau 	wrmsr(MSR_HV_SIEFP, (orig & MSR_HV_SIEFP_RSVD_MASK));
793b7bb4816SSepherosa Ziehau }
794b7bb4816SSepherosa Ziehau 
795b7bb4816SSepherosa Ziehau static int
796b7bb4816SSepherosa Ziehau vmbus_dma_alloc(struct vmbus_softc *sc)
797b7bb4816SSepherosa Ziehau {
7986523ab7eSSepherosa Ziehau 	bus_dma_tag_t parent_dtag;
7996523ab7eSSepherosa Ziehau 	uint8_t *evtflags;
800b7bb4816SSepherosa Ziehau 	int cpu;
801b7bb4816SSepherosa Ziehau 
8026523ab7eSSepherosa Ziehau 	parent_dtag = bus_get_dma_tag(sc->vmbus_dev);
803b7bb4816SSepherosa Ziehau 	CPU_FOREACH(cpu) {
804b7bb4816SSepherosa Ziehau 		void *ptr;
805b7bb4816SSepherosa Ziehau 
806b7bb4816SSepherosa Ziehau 		/*
807b7bb4816SSepherosa Ziehau 		 * Per-cpu messages and event flags.
808b7bb4816SSepherosa Ziehau 		 */
8096523ab7eSSepherosa Ziehau 		ptr = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,
8106523ab7eSSepherosa Ziehau 		    PAGE_SIZE, VMBUS_PCPU_PTR(sc, message_dma, cpu),
811b7bb4816SSepherosa Ziehau 		    BUS_DMA_WAITOK | BUS_DMA_ZERO);
812b7bb4816SSepherosa Ziehau 		if (ptr == NULL)
813b7bb4816SSepherosa Ziehau 			return ENOMEM;
814b7bb4816SSepherosa Ziehau 		VMBUS_PCPU_GET(sc, message, cpu) = ptr;
815b7bb4816SSepherosa Ziehau 
8166523ab7eSSepherosa Ziehau 		ptr = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,
8176523ab7eSSepherosa Ziehau 		    PAGE_SIZE, VMBUS_PCPU_PTR(sc, event_flags_dma, cpu),
818b7bb4816SSepherosa Ziehau 		    BUS_DMA_WAITOK | BUS_DMA_ZERO);
819b7bb4816SSepherosa Ziehau 		if (ptr == NULL)
820b7bb4816SSepherosa Ziehau 			return ENOMEM;
821b7bb4816SSepherosa Ziehau 		VMBUS_PCPU_GET(sc, event_flags, cpu) = ptr;
822b7bb4816SSepherosa Ziehau 	}
8236523ab7eSSepherosa Ziehau 
8246523ab7eSSepherosa Ziehau 	evtflags = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,
8256523ab7eSSepherosa Ziehau 	    PAGE_SIZE, &sc->vmbus_evtflags_dma, BUS_DMA_WAITOK | BUS_DMA_ZERO);
8266523ab7eSSepherosa Ziehau 	if (evtflags == NULL)
8276523ab7eSSepherosa Ziehau 		return ENOMEM;
8286523ab7eSSepherosa Ziehau 	sc->vmbus_rx_evtflags = (u_long *)evtflags;
82951a9a000SSepherosa Ziehau 	sc->vmbus_tx_evtflags = (u_long *)(evtflags + (PAGE_SIZE / 2));
8306523ab7eSSepherosa Ziehau 	sc->vmbus_evtflags = evtflags;
8316523ab7eSSepherosa Ziehau 
8326523ab7eSSepherosa Ziehau 	sc->vmbus_mnf1 = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,
8336523ab7eSSepherosa Ziehau 	    PAGE_SIZE, &sc->vmbus_mnf1_dma, BUS_DMA_WAITOK | BUS_DMA_ZERO);
8346523ab7eSSepherosa Ziehau 	if (sc->vmbus_mnf1 == NULL)
8356523ab7eSSepherosa Ziehau 		return ENOMEM;
8366523ab7eSSepherosa Ziehau 
8376523ab7eSSepherosa Ziehau 	sc->vmbus_mnf2 = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,
8388c8cf3f2SSepherosa Ziehau 	    sizeof(struct vmbus_mnf), &sc->vmbus_mnf2_dma,
8398c8cf3f2SSepherosa Ziehau 	    BUS_DMA_WAITOK | BUS_DMA_ZERO);
8406523ab7eSSepherosa Ziehau 	if (sc->vmbus_mnf2 == NULL)
8416523ab7eSSepherosa Ziehau 		return ENOMEM;
8426523ab7eSSepherosa Ziehau 
843b7bb4816SSepherosa Ziehau 	return 0;
844b7bb4816SSepherosa Ziehau }
845b7bb4816SSepherosa Ziehau 
846b7bb4816SSepherosa Ziehau static void
847b7bb4816SSepherosa Ziehau vmbus_dma_free(struct vmbus_softc *sc)
848b7bb4816SSepherosa Ziehau {
849b7bb4816SSepherosa Ziehau 	int cpu;
850b7bb4816SSepherosa Ziehau 
8516523ab7eSSepherosa Ziehau 	if (sc->vmbus_evtflags != NULL) {
8526523ab7eSSepherosa Ziehau 		hyperv_dmamem_free(&sc->vmbus_evtflags_dma, sc->vmbus_evtflags);
8536523ab7eSSepherosa Ziehau 		sc->vmbus_evtflags = NULL;
8546523ab7eSSepherosa Ziehau 		sc->vmbus_rx_evtflags = NULL;
8556523ab7eSSepherosa Ziehau 		sc->vmbus_tx_evtflags = NULL;
8566523ab7eSSepherosa Ziehau 	}
8576523ab7eSSepherosa Ziehau 	if (sc->vmbus_mnf1 != NULL) {
8586523ab7eSSepherosa Ziehau 		hyperv_dmamem_free(&sc->vmbus_mnf1_dma, sc->vmbus_mnf1);
8596523ab7eSSepherosa Ziehau 		sc->vmbus_mnf1 = NULL;
8606523ab7eSSepherosa Ziehau 	}
8616523ab7eSSepherosa Ziehau 	if (sc->vmbus_mnf2 != NULL) {
8626523ab7eSSepherosa Ziehau 		hyperv_dmamem_free(&sc->vmbus_mnf2_dma, sc->vmbus_mnf2);
8636523ab7eSSepherosa Ziehau 		sc->vmbus_mnf2 = NULL;
8646523ab7eSSepherosa Ziehau 	}
8656523ab7eSSepherosa Ziehau 
866b7bb4816SSepherosa Ziehau 	CPU_FOREACH(cpu) {
867b7bb4816SSepherosa Ziehau 		if (VMBUS_PCPU_GET(sc, message, cpu) != NULL) {
868b7bb4816SSepherosa Ziehau 			hyperv_dmamem_free(
869b7bb4816SSepherosa Ziehau 			    VMBUS_PCPU_PTR(sc, message_dma, cpu),
870b7bb4816SSepherosa Ziehau 			    VMBUS_PCPU_GET(sc, message, cpu));
871b7bb4816SSepherosa Ziehau 			VMBUS_PCPU_GET(sc, message, cpu) = NULL;
872b7bb4816SSepherosa Ziehau 		}
873b7bb4816SSepherosa Ziehau 		if (VMBUS_PCPU_GET(sc, event_flags, cpu) != NULL) {
874b7bb4816SSepherosa Ziehau 			hyperv_dmamem_free(
875b7bb4816SSepherosa Ziehau 			    VMBUS_PCPU_PTR(sc, event_flags_dma, cpu),
876b7bb4816SSepherosa Ziehau 			    VMBUS_PCPU_GET(sc, event_flags, cpu));
877b7bb4816SSepherosa Ziehau 			VMBUS_PCPU_GET(sc, event_flags, cpu) = NULL;
878b7bb4816SSepherosa Ziehau 		}
879b7bb4816SSepherosa Ziehau 	}
880b7bb4816SSepherosa Ziehau }
881b7bb4816SSepherosa Ziehau 
882b7bb4816SSepherosa Ziehau static int
883b7bb4816SSepherosa Ziehau vmbus_intr_setup(struct vmbus_softc *sc)
884b7bb4816SSepherosa Ziehau {
885b7bb4816SSepherosa Ziehau 	int cpu;
886b7bb4816SSepherosa Ziehau 
887b7bb4816SSepherosa Ziehau 	CPU_FOREACH(cpu) {
888b7bb4816SSepherosa Ziehau 		char buf[MAXCOMLEN + 1];
889b7bb4816SSepherosa Ziehau 		cpuset_t cpu_mask;
890b7bb4816SSepherosa Ziehau 
891b7bb4816SSepherosa Ziehau 		/* Allocate an interrupt counter for Hyper-V interrupt */
892b7bb4816SSepherosa Ziehau 		snprintf(buf, sizeof(buf), "cpu%d:hyperv", cpu);
893b7bb4816SSepherosa Ziehau 		intrcnt_add(buf, VMBUS_PCPU_PTR(sc, intr_cnt, cpu));
894b7bb4816SSepherosa Ziehau 
895b7bb4816SSepherosa Ziehau 		/*
896b7bb4816SSepherosa Ziehau 		 * Setup taskqueue to handle events.  Task will be per-
897b7bb4816SSepherosa Ziehau 		 * channel.
898b7bb4816SSepherosa Ziehau 		 */
899b7bb4816SSepherosa Ziehau 		VMBUS_PCPU_GET(sc, event_tq, cpu) = taskqueue_create_fast(
900b7bb4816SSepherosa Ziehau 		    "hyperv event", M_WAITOK, taskqueue_thread_enqueue,
901b7bb4816SSepherosa Ziehau 		    VMBUS_PCPU_PTR(sc, event_tq, cpu));
902b7bb4816SSepherosa Ziehau 		CPU_SETOF(cpu, &cpu_mask);
903b7bb4816SSepherosa Ziehau 		taskqueue_start_threads_cpuset(
904b7bb4816SSepherosa Ziehau 		    VMBUS_PCPU_PTR(sc, event_tq, cpu), 1, PI_NET, &cpu_mask,
905b7bb4816SSepherosa Ziehau 		    "hvevent%d", cpu);
906b7bb4816SSepherosa Ziehau 
907b7bb4816SSepherosa Ziehau 		/*
908b7bb4816SSepherosa Ziehau 		 * Setup tasks and taskqueues to handle messages.
909b7bb4816SSepherosa Ziehau 		 */
910b7bb4816SSepherosa Ziehau 		VMBUS_PCPU_GET(sc, message_tq, cpu) = taskqueue_create_fast(
911b7bb4816SSepherosa Ziehau 		    "hyperv msg", M_WAITOK, taskqueue_thread_enqueue,
912b7bb4816SSepherosa Ziehau 		    VMBUS_PCPU_PTR(sc, message_tq, cpu));
913b7bb4816SSepherosa Ziehau 		CPU_SETOF(cpu, &cpu_mask);
914b7bb4816SSepherosa Ziehau 		taskqueue_start_threads_cpuset(
915b7bb4816SSepherosa Ziehau 		    VMBUS_PCPU_PTR(sc, message_tq, cpu), 1, PI_NET, &cpu_mask,
916b7bb4816SSepherosa Ziehau 		    "hvmsg%d", cpu);
917b7bb4816SSepherosa Ziehau 		TASK_INIT(VMBUS_PCPU_PTR(sc, message_task, cpu), 0,
918b7bb4816SSepherosa Ziehau 		    vmbus_msg_task, sc);
919b7bb4816SSepherosa Ziehau 	}
920b7bb4816SSepherosa Ziehau 
921b7bb4816SSepherosa Ziehau 	/*
922b7bb4816SSepherosa Ziehau 	 * All Hyper-V ISR required resources are setup, now let's find a
923b7bb4816SSepherosa Ziehau 	 * free IDT vector for Hyper-V ISR and set it up.
924b7bb4816SSepherosa Ziehau 	 */
925b7bb4816SSepherosa Ziehau 	sc->vmbus_idtvec = lapic_ipi_alloc(IDTVEC(vmbus_isr));
926b7bb4816SSepherosa Ziehau 	if (sc->vmbus_idtvec < 0) {
927b7bb4816SSepherosa Ziehau 		device_printf(sc->vmbus_dev, "cannot find free IDT vector\n");
928b7bb4816SSepherosa Ziehau 		return ENXIO;
929b7bb4816SSepherosa Ziehau 	}
930b7bb4816SSepherosa Ziehau 	if(bootverbose) {
931b7bb4816SSepherosa Ziehau 		device_printf(sc->vmbus_dev, "vmbus IDT vector %d\n",
932b7bb4816SSepherosa Ziehau 		    sc->vmbus_idtvec);
933b7bb4816SSepherosa Ziehau 	}
934b7bb4816SSepherosa Ziehau 	return 0;
935b7bb4816SSepherosa Ziehau }
936b7bb4816SSepherosa Ziehau 
937b7bb4816SSepherosa Ziehau static void
938b7bb4816SSepherosa Ziehau vmbus_intr_teardown(struct vmbus_softc *sc)
939b7bb4816SSepherosa Ziehau {
940b7bb4816SSepherosa Ziehau 	int cpu;
941b7bb4816SSepherosa Ziehau 
942b7bb4816SSepherosa Ziehau 	if (sc->vmbus_idtvec >= 0) {
943b7bb4816SSepherosa Ziehau 		lapic_ipi_free(sc->vmbus_idtvec);
944b7bb4816SSepherosa Ziehau 		sc->vmbus_idtvec = -1;
945b7bb4816SSepherosa Ziehau 	}
946b7bb4816SSepherosa Ziehau 
947b7bb4816SSepherosa Ziehau 	CPU_FOREACH(cpu) {
948b7bb4816SSepherosa Ziehau 		if (VMBUS_PCPU_GET(sc, event_tq, cpu) != NULL) {
949b7bb4816SSepherosa Ziehau 			taskqueue_free(VMBUS_PCPU_GET(sc, event_tq, cpu));
950b7bb4816SSepherosa Ziehau 			VMBUS_PCPU_GET(sc, event_tq, cpu) = NULL;
951b7bb4816SSepherosa Ziehau 		}
952b7bb4816SSepherosa Ziehau 		if (VMBUS_PCPU_GET(sc, message_tq, cpu) != NULL) {
953b7bb4816SSepherosa Ziehau 			taskqueue_drain(VMBUS_PCPU_GET(sc, message_tq, cpu),
954b7bb4816SSepherosa Ziehau 			    VMBUS_PCPU_PTR(sc, message_task, cpu));
955b7bb4816SSepherosa Ziehau 			taskqueue_free(VMBUS_PCPU_GET(sc, message_tq, cpu));
956b7bb4816SSepherosa Ziehau 			VMBUS_PCPU_GET(sc, message_tq, cpu) = NULL;
957b7bb4816SSepherosa Ziehau 		}
958b7bb4816SSepherosa Ziehau 	}
959b7bb4816SSepherosa Ziehau }
960b7bb4816SSepherosa Ziehau 
961b7bb4816SSepherosa Ziehau static int
962b7bb4816SSepherosa Ziehau vmbus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
963b7bb4816SSepherosa Ziehau {
964b7bb4816SSepherosa Ziehau 	return (ENOENT);
965b7bb4816SSepherosa Ziehau }
966b7bb4816SSepherosa Ziehau 
967b7bb4816SSepherosa Ziehau static int
968b7bb4816SSepherosa Ziehau vmbus_child_pnpinfo_str(device_t dev, device_t child, char *buf, size_t buflen)
969b7bb4816SSepherosa Ziehau {
97047575345SSepherosa Ziehau 	const struct hv_vmbus_channel *chan;
971b7bb4816SSepherosa Ziehau 	char guidbuf[HYPERV_GUID_STRLEN];
972b7bb4816SSepherosa Ziehau 
9733b50b13bSSepherosa Ziehau 	chan = vmbus_get_channel(child);
9743b50b13bSSepherosa Ziehau 	if (chan == NULL) {
97547575345SSepherosa Ziehau 		/* Event timer device, which does not belong to a channel */
976b7bb4816SSepherosa Ziehau 		return (0);
97747575345SSepherosa Ziehau 	}
978b7bb4816SSepherosa Ziehau 
979b7bb4816SSepherosa Ziehau 	strlcat(buf, "classid=", buflen);
98047575345SSepherosa Ziehau 	hyperv_guid2str(&chan->ch_guid_type, guidbuf, sizeof(guidbuf));
981b7bb4816SSepherosa Ziehau 	strlcat(buf, guidbuf, buflen);
982b7bb4816SSepherosa Ziehau 
983b7bb4816SSepherosa Ziehau 	strlcat(buf, " deviceid=", buflen);
98447575345SSepherosa Ziehau 	hyperv_guid2str(&chan->ch_guid_inst, guidbuf, sizeof(guidbuf));
985b7bb4816SSepherosa Ziehau 	strlcat(buf, guidbuf, buflen);
986b7bb4816SSepherosa Ziehau 
987b7bb4816SSepherosa Ziehau 	return (0);
988b7bb4816SSepherosa Ziehau }
989b7bb4816SSepherosa Ziehau 
99047575345SSepherosa Ziehau int
99147575345SSepherosa Ziehau hv_vmbus_child_device_register(struct hv_vmbus_channel *chan)
992b7bb4816SSepherosa Ziehau {
99347575345SSepherosa Ziehau 	struct vmbus_softc *sc = chan->vmbus_sc;
99447575345SSepherosa Ziehau 	device_t parent = sc->vmbus_dev;
99547575345SSepherosa Ziehau 	int error = 0;
996b7bb4816SSepherosa Ziehau 
997dab4260cSSepherosa Ziehau 	/* New channel has been offered */
998dab4260cSSepherosa Ziehau 	vmbus_scan_newchan(sc);
999dab4260cSSepherosa Ziehau 
100047575345SSepherosa Ziehau 	chan->ch_dev = device_add_child(parent, NULL, -1);
100147575345SSepherosa Ziehau 	if (chan->ch_dev == NULL) {
100247575345SSepherosa Ziehau 		device_printf(parent, "device_add_child for chan%u failed\n",
100347575345SSepherosa Ziehau 		    chan->ch_id);
100447575345SSepherosa Ziehau 		error = ENXIO;
100547575345SSepherosa Ziehau 		goto done;
1006b7bb4816SSepherosa Ziehau 	}
10073b50b13bSSepherosa Ziehau 	device_set_ivars(chan->ch_dev, chan);
1008b7bb4816SSepherosa Ziehau 
100947575345SSepherosa Ziehau done:
101047575345SSepherosa Ziehau 	/* New device has been/should be added to vmbus. */
1011796a90bfSSepherosa Ziehau 	vmbus_scan_newdev(sc);
101247575345SSepherosa Ziehau 	return error;
1013b7bb4816SSepherosa Ziehau }
1014b7bb4816SSepherosa Ziehau 
1015b7bb4816SSepherosa Ziehau int
101647575345SSepherosa Ziehau hv_vmbus_child_device_unregister(struct hv_vmbus_channel *chan)
1017b7bb4816SSepherosa Ziehau {
101847575345SSepherosa Ziehau 	int error;
101947575345SSepherosa Ziehau 
102047575345SSepherosa Ziehau 	if (chan->ch_dev == NULL) {
102147575345SSepherosa Ziehau 		/* Failed to add a device. */
102247575345SSepherosa Ziehau 		return 0;
102347575345SSepherosa Ziehau 	}
102447575345SSepherosa Ziehau 
1025b7bb4816SSepherosa Ziehau 	/*
1026b7bb4816SSepherosa Ziehau 	 * XXXKYS: Ensure that this is the opposite of
1027b7bb4816SSepherosa Ziehau 	 * device_add_child()
1028b7bb4816SSepherosa Ziehau 	 */
1029b7bb4816SSepherosa Ziehau 	mtx_lock(&Giant);
103047575345SSepherosa Ziehau 	error = device_delete_child(chan->vmbus_sc->vmbus_dev, chan->ch_dev);
1031b7bb4816SSepherosa Ziehau 	mtx_unlock(&Giant);
103247575345SSepherosa Ziehau 
103347575345SSepherosa Ziehau 	return error;
1034b7bb4816SSepherosa Ziehau }
1035b7bb4816SSepherosa Ziehau 
1036b7bb4816SSepherosa Ziehau static int
103747a3ee5cSSepherosa Ziehau vmbus_sysctl_version(SYSCTL_HANDLER_ARGS)
103847a3ee5cSSepherosa Ziehau {
103938d19df6SSepherosa Ziehau 	struct vmbus_softc *sc = arg1;
104047a3ee5cSSepherosa Ziehau 	char verstr[16];
104147a3ee5cSSepherosa Ziehau 
104247a3ee5cSSepherosa Ziehau 	snprintf(verstr, sizeof(verstr), "%u.%u",
104338d19df6SSepherosa Ziehau 	    VMBUS_VERSION_MAJOR(sc->vmbus_version),
104438d19df6SSepherosa Ziehau 	    VMBUS_VERSION_MINOR(sc->vmbus_version));
104547a3ee5cSSepherosa Ziehau 	return sysctl_handle_string(oidp, verstr, sizeof(verstr), req);
104647a3ee5cSSepherosa Ziehau }
104747a3ee5cSSepherosa Ziehau 
104838d19df6SSepherosa Ziehau static uint32_t
104938d19df6SSepherosa Ziehau vmbus_get_version_method(device_t bus, device_t dev)
105038d19df6SSepherosa Ziehau {
105138d19df6SSepherosa Ziehau 	struct vmbus_softc *sc = device_get_softc(bus);
105238d19df6SSepherosa Ziehau 
105338d19df6SSepherosa Ziehau 	return sc->vmbus_version;
105438d19df6SSepherosa Ziehau }
105538d19df6SSepherosa Ziehau 
105647a3ee5cSSepherosa Ziehau static int
105771ac1309SSepherosa Ziehau vmbus_probe_guid_method(device_t bus, device_t dev,
105871ac1309SSepherosa Ziehau     const struct hyperv_guid *guid)
1059884d26c8SSepherosa Ziehau {
106047575345SSepherosa Ziehau 	const struct hv_vmbus_channel *chan = vmbus_get_channel(dev);
1061884d26c8SSepherosa Ziehau 
106271ac1309SSepherosa Ziehau 	if (memcmp(&chan->ch_guid_type, guid, sizeof(struct hyperv_guid)) == 0)
1063884d26c8SSepherosa Ziehau 		return 0;
1064884d26c8SSepherosa Ziehau 	return ENXIO;
1065884d26c8SSepherosa Ziehau }
1066884d26c8SSepherosa Ziehau 
1067884d26c8SSepherosa Ziehau static int
1068b7bb4816SSepherosa Ziehau vmbus_probe(device_t dev)
1069b7bb4816SSepherosa Ziehau {
1070b7bb4816SSepherosa Ziehau 	char *id[] = { "VMBUS", NULL };
1071b7bb4816SSepherosa Ziehau 
1072b7bb4816SSepherosa Ziehau 	if (ACPI_ID_PROBE(device_get_parent(dev), dev, id) == NULL ||
1073b7bb4816SSepherosa Ziehau 	    device_get_unit(dev) != 0 || vm_guest != VM_GUEST_HV ||
1074b7bb4816SSepherosa Ziehau 	    (hyperv_features & CPUID_HV_MSR_SYNIC) == 0)
1075b7bb4816SSepherosa Ziehau 		return (ENXIO);
1076b7bb4816SSepherosa Ziehau 
1077b7bb4816SSepherosa Ziehau 	device_set_desc(dev, "Hyper-V Vmbus");
1078b7bb4816SSepherosa Ziehau 
1079b7bb4816SSepherosa Ziehau 	return (BUS_PROBE_DEFAULT);
1080b7bb4816SSepherosa Ziehau }
1081b7bb4816SSepherosa Ziehau 
1082b7bb4816SSepherosa Ziehau /**
1083b7bb4816SSepherosa Ziehau  * @brief Main vmbus driver initialization routine.
1084b7bb4816SSepherosa Ziehau  *
1085b7bb4816SSepherosa Ziehau  * Here, we
1086b7bb4816SSepherosa Ziehau  * - initialize the vmbus driver context
1087b7bb4816SSepherosa Ziehau  * - setup various driver entry points
1088b7bb4816SSepherosa Ziehau  * - invoke the vmbus hv main init routine
1089b7bb4816SSepherosa Ziehau  * - get the irq resource
1090b7bb4816SSepherosa Ziehau  * - invoke the vmbus to add the vmbus root device
1091b7bb4816SSepherosa Ziehau  * - setup the vmbus root device
1092b7bb4816SSepherosa Ziehau  * - retrieve the channel offers
1093b7bb4816SSepherosa Ziehau  */
1094b7bb4816SSepherosa Ziehau static int
1095dd012a57SSepherosa Ziehau vmbus_doattach(struct vmbus_softc *sc)
1096b7bb4816SSepherosa Ziehau {
109747a3ee5cSSepherosa Ziehau 	struct sysctl_oid_list *child;
109847a3ee5cSSepherosa Ziehau 	struct sysctl_ctx_list *ctx;
1099b7bb4816SSepherosa Ziehau 	int ret;
1100b7bb4816SSepherosa Ziehau 
1101b7bb4816SSepherosa Ziehau 	if (sc->vmbus_flags & VMBUS_FLAG_ATTACHED)
1102b7bb4816SSepherosa Ziehau 		return (0);
1103b7bb4816SSepherosa Ziehau 	sc->vmbus_flags |= VMBUS_FLAG_ATTACHED;
1104b7bb4816SSepherosa Ziehau 
1105796a90bfSSepherosa Ziehau 	mtx_init(&sc->vmbus_scan_lock, "vmbus scan", NULL, MTX_DEF);
1106ee7e313fSSepherosa Ziehau 	sc->vmbus_gpadl = VMBUS_GPADL_START;
11077fbf0730SSepherosa Ziehau 	mtx_init(&sc->vmbus_chlist_lock, "vmbus chlist", NULL, MTX_DEF);
11087fbf0730SSepherosa Ziehau 	TAILQ_INIT(&sc->vmbus_chlist);
1109af3be0bfSSepherosa Ziehau 	sc->vmbus_chmap = malloc(
1110af3be0bfSSepherosa Ziehau 	    sizeof(struct hv_vmbus_channel *) * VMBUS_CHAN_MAX, M_DEVBUF,
1111af3be0bfSSepherosa Ziehau 	    M_WAITOK | M_ZERO);
1112796a90bfSSepherosa Ziehau 
1113b7bb4816SSepherosa Ziehau 	/*
1114236764b1SSepherosa Ziehau 	 * Create context for "post message" Hypercalls
1115236764b1SSepherosa Ziehau 	 */
1116236764b1SSepherosa Ziehau 	sc->vmbus_msg_hc = vmbus_msghc_ctx_create(
1117236764b1SSepherosa Ziehau 	    bus_get_dma_tag(sc->vmbus_dev));
1118236764b1SSepherosa Ziehau 	if (sc->vmbus_msg_hc == NULL) {
1119236764b1SSepherosa Ziehau 		ret = ENXIO;
1120236764b1SSepherosa Ziehau 		goto cleanup;
1121236764b1SSepherosa Ziehau 	}
1122236764b1SSepherosa Ziehau 
1123236764b1SSepherosa Ziehau 	/*
1124b7bb4816SSepherosa Ziehau 	 * Allocate DMA stuffs.
1125b7bb4816SSepherosa Ziehau 	 */
1126b7bb4816SSepherosa Ziehau 	ret = vmbus_dma_alloc(sc);
1127b7bb4816SSepherosa Ziehau 	if (ret != 0)
1128b7bb4816SSepherosa Ziehau 		goto cleanup;
1129b7bb4816SSepherosa Ziehau 
1130b7bb4816SSepherosa Ziehau 	/*
1131b7bb4816SSepherosa Ziehau 	 * Setup interrupt.
1132b7bb4816SSepherosa Ziehau 	 */
1133b7bb4816SSepherosa Ziehau 	ret = vmbus_intr_setup(sc);
1134b7bb4816SSepherosa Ziehau 	if (ret != 0)
1135b7bb4816SSepherosa Ziehau 		goto cleanup;
1136b7bb4816SSepherosa Ziehau 
1137b7bb4816SSepherosa Ziehau 	/*
1138b7bb4816SSepherosa Ziehau 	 * Setup SynIC.
1139b7bb4816SSepherosa Ziehau 	 */
1140b7bb4816SSepherosa Ziehau 	if (bootverbose)
1141b7bb4816SSepherosa Ziehau 		device_printf(sc->vmbus_dev, "smp_started = %d\n", smp_started);
1142b7bb4816SSepherosa Ziehau 	smp_rendezvous(NULL, vmbus_synic_setup, NULL, sc);
1143b7bb4816SSepherosa Ziehau 	sc->vmbus_flags |= VMBUS_FLAG_SYNIC;
1144b7bb4816SSepherosa Ziehau 
1145b7bb4816SSepherosa Ziehau 	/*
1146250ca4caSSepherosa Ziehau 	 * Initialize vmbus, e.g. connect to Hypervisor.
1147b7bb4816SSepherosa Ziehau 	 */
1148236764b1SSepherosa Ziehau 	ret = vmbus_init(sc);
1149236764b1SSepherosa Ziehau 	if (ret != 0)
1150236764b1SSepherosa Ziehau 		goto cleanup;
1151236764b1SSepherosa Ziehau 
115238d19df6SSepherosa Ziehau 	if (sc->vmbus_version == VMBUS_VERSION_WS2008 ||
115338d19df6SSepherosa Ziehau 	    sc->vmbus_version == VMBUS_VERSION_WIN7)
1154b7bb4816SSepherosa Ziehau 		sc->vmbus_event_proc = vmbus_event_proc_compat;
1155b7bb4816SSepherosa Ziehau 	else
1156b7bb4816SSepherosa Ziehau 		sc->vmbus_event_proc = vmbus_event_proc;
1157b7bb4816SSepherosa Ziehau 
1158796a90bfSSepherosa Ziehau 	ret = vmbus_scan(sc);
1159c1cc5bdfSSepherosa Ziehau 	if (ret != 0)
1160c1cc5bdfSSepherosa Ziehau 		goto cleanup;
1161b7bb4816SSepherosa Ziehau 
116247a3ee5cSSepherosa Ziehau 	ctx = device_get_sysctl_ctx(sc->vmbus_dev);
116347a3ee5cSSepherosa Ziehau 	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->vmbus_dev));
116447a3ee5cSSepherosa Ziehau 	SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "version",
116538d19df6SSepherosa Ziehau 	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
116647a3ee5cSSepherosa Ziehau 	    vmbus_sysctl_version, "A", "vmbus version");
116747a3ee5cSSepherosa Ziehau 
1168b7bb4816SSepherosa Ziehau 	return (ret);
1169b7bb4816SSepherosa Ziehau 
1170b7bb4816SSepherosa Ziehau cleanup:
1171b7bb4816SSepherosa Ziehau 	vmbus_intr_teardown(sc);
1172b7bb4816SSepherosa Ziehau 	vmbus_dma_free(sc);
1173236764b1SSepherosa Ziehau 	if (sc->vmbus_msg_hc != NULL) {
1174236764b1SSepherosa Ziehau 		vmbus_msghc_ctx_destroy(sc->vmbus_msg_hc);
1175236764b1SSepherosa Ziehau 		sc->vmbus_msg_hc = NULL;
1176236764b1SSepherosa Ziehau 	}
1177af3be0bfSSepherosa Ziehau 	free(sc->vmbus_chmap, M_DEVBUF);
1178796a90bfSSepherosa Ziehau 	mtx_destroy(&sc->vmbus_scan_lock);
1179283ec9dfSSepherosa Ziehau 	mtx_destroy(&sc->vmbus_chlist_lock);
1180b7bb4816SSepherosa Ziehau 
1181b7bb4816SSepherosa Ziehau 	return (ret);
1182b7bb4816SSepherosa Ziehau }
1183b7bb4816SSepherosa Ziehau 
1184b7bb4816SSepherosa Ziehau static void
1185b7bb4816SSepherosa Ziehau vmbus_event_proc_dummy(struct vmbus_softc *sc __unused, int cpu __unused)
1186b7bb4816SSepherosa Ziehau {
1187b7bb4816SSepherosa Ziehau }
1188b7bb4816SSepherosa Ziehau 
1189b7bb4816SSepherosa Ziehau static int
1190b7bb4816SSepherosa Ziehau vmbus_attach(device_t dev)
1191b7bb4816SSepherosa Ziehau {
1192b7bb4816SSepherosa Ziehau 	vmbus_sc = device_get_softc(dev);
1193b7bb4816SSepherosa Ziehau 	vmbus_sc->vmbus_dev = dev;
1194b7bb4816SSepherosa Ziehau 	vmbus_sc->vmbus_idtvec = -1;
1195b7bb4816SSepherosa Ziehau 
1196b7bb4816SSepherosa Ziehau 	/*
1197b7bb4816SSepherosa Ziehau 	 * Event processing logic will be configured:
1198b7bb4816SSepherosa Ziehau 	 * - After the vmbus protocol version negotiation.
1199b7bb4816SSepherosa Ziehau 	 * - Before we request channel offers.
1200b7bb4816SSepherosa Ziehau 	 */
1201b7bb4816SSepherosa Ziehau 	vmbus_sc->vmbus_event_proc = vmbus_event_proc_dummy;
1202b7bb4816SSepherosa Ziehau 
1203b7bb4816SSepherosa Ziehau #ifndef EARLY_AP_STARTUP
1204b7bb4816SSepherosa Ziehau 	/*
1205b7bb4816SSepherosa Ziehau 	 * If the system has already booted and thread
1206b7bb4816SSepherosa Ziehau 	 * scheduling is possible indicated by the global
1207b7bb4816SSepherosa Ziehau 	 * cold set to zero, we just call the driver
1208b7bb4816SSepherosa Ziehau 	 * initialization directly.
1209b7bb4816SSepherosa Ziehau 	 */
1210b7bb4816SSepherosa Ziehau 	if (!cold)
1211b7bb4816SSepherosa Ziehau #endif
1212dd012a57SSepherosa Ziehau 		vmbus_doattach(vmbus_sc);
1213b7bb4816SSepherosa Ziehau 
1214b7bb4816SSepherosa Ziehau 	return (0);
1215b7bb4816SSepherosa Ziehau }
1216b7bb4816SSepherosa Ziehau 
1217b7bb4816SSepherosa Ziehau static void
1218b7bb4816SSepherosa Ziehau vmbus_sysinit(void *arg __unused)
1219b7bb4816SSepherosa Ziehau {
1220dd012a57SSepherosa Ziehau 	struct vmbus_softc *sc = vmbus_get_softc();
1221dd012a57SSepherosa Ziehau 
1222dd012a57SSepherosa Ziehau 	if (vm_guest != VM_GUEST_HV || sc == NULL)
1223b7bb4816SSepherosa Ziehau 		return;
1224b7bb4816SSepherosa Ziehau 
1225b7bb4816SSepherosa Ziehau #ifndef EARLY_AP_STARTUP
1226b7bb4816SSepherosa Ziehau 	/*
1227b7bb4816SSepherosa Ziehau 	 * If the system has already booted and thread
1228b7bb4816SSepherosa Ziehau 	 * scheduling is possible, as indicated by the
1229b7bb4816SSepherosa Ziehau 	 * global cold set to zero, we just call the driver
1230b7bb4816SSepherosa Ziehau 	 * initialization directly.
1231b7bb4816SSepherosa Ziehau 	 */
1232b7bb4816SSepherosa Ziehau 	if (!cold)
1233b7bb4816SSepherosa Ziehau #endif
1234dd012a57SSepherosa Ziehau 		vmbus_doattach(sc);
1235b7bb4816SSepherosa Ziehau }
1236b7bb4816SSepherosa Ziehau 
1237b7bb4816SSepherosa Ziehau static int
1238b7bb4816SSepherosa Ziehau vmbus_detach(device_t dev)
1239b7bb4816SSepherosa Ziehau {
1240b7bb4816SSepherosa Ziehau 	struct vmbus_softc *sc = device_get_softc(dev);
1241b7bb4816SSepherosa Ziehau 
1242*77321df6SSepherosa Ziehau 	vmbus_chan_destroy_all(sc);
12431ecb2466SSepherosa Ziehau 
1244f24517f0SSepherosa Ziehau 	vmbus_disconnect(sc);
1245b7bb4816SSepherosa Ziehau 
1246b7bb4816SSepherosa Ziehau 	if (sc->vmbus_flags & VMBUS_FLAG_SYNIC) {
1247b7bb4816SSepherosa Ziehau 		sc->vmbus_flags &= ~VMBUS_FLAG_SYNIC;
1248b7bb4816SSepherosa Ziehau 		smp_rendezvous(NULL, vmbus_synic_teardown, NULL, NULL);
1249b7bb4816SSepherosa Ziehau 	}
1250b7bb4816SSepherosa Ziehau 
1251b7bb4816SSepherosa Ziehau 	vmbus_intr_teardown(sc);
1252b7bb4816SSepherosa Ziehau 	vmbus_dma_free(sc);
1253b7bb4816SSepherosa Ziehau 
1254236764b1SSepherosa Ziehau 	if (sc->vmbus_msg_hc != NULL) {
1255236764b1SSepherosa Ziehau 		vmbus_msghc_ctx_destroy(sc->vmbus_msg_hc);
1256236764b1SSepherosa Ziehau 		sc->vmbus_msg_hc = NULL;
1257236764b1SSepherosa Ziehau 	}
1258236764b1SSepherosa Ziehau 
1259af3be0bfSSepherosa Ziehau 	free(sc->vmbus_chmap, M_DEVBUF);
1260796a90bfSSepherosa Ziehau 	mtx_destroy(&sc->vmbus_scan_lock);
1261283ec9dfSSepherosa Ziehau 	mtx_destroy(&sc->vmbus_chlist_lock);
1262283ec9dfSSepherosa Ziehau 
1263b7bb4816SSepherosa Ziehau 	return (0);
1264b7bb4816SSepherosa Ziehau }
1265b7bb4816SSepherosa Ziehau 
1266b7bb4816SSepherosa Ziehau static device_method_t vmbus_methods[] = {
1267b7bb4816SSepherosa Ziehau 	/* Device interface */
1268b7bb4816SSepherosa Ziehau 	DEVMETHOD(device_probe,			vmbus_probe),
1269b7bb4816SSepherosa Ziehau 	DEVMETHOD(device_attach,		vmbus_attach),
1270b7bb4816SSepherosa Ziehau 	DEVMETHOD(device_detach,		vmbus_detach),
1271b7bb4816SSepherosa Ziehau 	DEVMETHOD(device_shutdown,		bus_generic_shutdown),
1272b7bb4816SSepherosa Ziehau 	DEVMETHOD(device_suspend,		bus_generic_suspend),
1273b7bb4816SSepherosa Ziehau 	DEVMETHOD(device_resume,		bus_generic_resume),
1274b7bb4816SSepherosa Ziehau 
1275b7bb4816SSepherosa Ziehau 	/* Bus interface */
1276b7bb4816SSepherosa Ziehau 	DEVMETHOD(bus_add_child,		bus_generic_add_child),
1277b7bb4816SSepherosa Ziehau 	DEVMETHOD(bus_print_child,		bus_generic_print_child),
1278b7bb4816SSepherosa Ziehau 	DEVMETHOD(bus_read_ivar,		vmbus_read_ivar),
1279b7bb4816SSepherosa Ziehau 	DEVMETHOD(bus_child_pnpinfo_str,	vmbus_child_pnpinfo_str),
1280b7bb4816SSepherosa Ziehau 
128138d19df6SSepherosa Ziehau 	/* Vmbus interface */
128238d19df6SSepherosa Ziehau 	DEVMETHOD(vmbus_get_version,		vmbus_get_version_method),
1283884d26c8SSepherosa Ziehau 	DEVMETHOD(vmbus_probe_guid,		vmbus_probe_guid_method),
128438d19df6SSepherosa Ziehau 
1285b7bb4816SSepherosa Ziehau 	DEVMETHOD_END
1286b7bb4816SSepherosa Ziehau };
1287b7bb4816SSepherosa Ziehau 
1288b7bb4816SSepherosa Ziehau static driver_t vmbus_driver = {
1289b7bb4816SSepherosa Ziehau 	"vmbus",
1290b7bb4816SSepherosa Ziehau 	vmbus_methods,
1291b7bb4816SSepherosa Ziehau 	sizeof(struct vmbus_softc)
1292b7bb4816SSepherosa Ziehau };
1293b7bb4816SSepherosa Ziehau 
1294b7bb4816SSepherosa Ziehau static devclass_t vmbus_devclass;
1295b7bb4816SSepherosa Ziehau 
1296b7bb4816SSepherosa Ziehau DRIVER_MODULE(vmbus, acpi, vmbus_driver, vmbus_devclass, NULL, NULL);
1297b7bb4816SSepherosa Ziehau MODULE_DEPEND(vmbus, acpi, 1, 1, 1);
1298b7bb4816SSepherosa Ziehau MODULE_VERSION(vmbus, 1);
1299b7bb4816SSepherosa Ziehau 
1300b7bb4816SSepherosa Ziehau #ifndef EARLY_AP_STARTUP
1301b7bb4816SSepherosa Ziehau /*
1302b7bb4816SSepherosa Ziehau  * NOTE:
1303b7bb4816SSepherosa Ziehau  * We have to start as the last step of SI_SUB_SMP, i.e. after SMP is
1304b7bb4816SSepherosa Ziehau  * initialized.
1305b7bb4816SSepherosa Ziehau  */
1306b7bb4816SSepherosa Ziehau SYSINIT(vmbus_initialize, SI_SUB_SMP, SI_ORDER_ANY, vmbus_sysinit, NULL);
1307b7bb4816SSepherosa Ziehau #endif
1308