Annotation of src/sys/dev/hyperv/hyperv_common.c, revision 1.2
1.2 ! nonaka 1: /* $NetBSD: hyperv_common.c,v 1.1 2019/02/15 08:54:01 nonaka Exp $ */
1.1 nonaka 2:
3: /*-
4: * Copyright (c) 2009-2012,2016-2017 Microsoft Corp.
5: * Copyright (c) 2012 NetApp Inc.
6: * Copyright (c) 2012 Citrix Inc.
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice unmodified, this list of conditions, and the following
14: * disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: *
19: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29: */
30:
31: #include <sys/cdefs.h>
1.2 ! nonaka 32: __KERNEL_RCSID(0, "$NetBSD: hyperv_common.c,v 1.1 2019/02/15 08:54:01 nonaka Exp $");
1.1 nonaka 33:
34: #include "hyperv.h"
35:
36: #include <sys/param.h>
37: #include <sys/systm.h>
38: #include <sys/kernel.h>
39: #include <sys/bus.h>
40: #include <sys/kmem.h>
41:
42: #include <dev/hyperv/hypervreg.h>
43: #include <dev/hyperv/hypervvar.h>
44:
45: hyperv_tc64_t hyperv_tc64;
46:
47: int hyperv_nullop(void);
48: void hyperv_voidop(void);
49: uint64_t hyperv_hypercall_error(uint64_t, paddr_t, paddr_t);
50:
51: __weak_alias(hyperv_hypercall, hyperv_hypercall_error);
52: __weak_alias(hyperv_hypercall_enabled, hyperv_nullop);
53: __weak_alias(hyperv_synic_supported, hyperv_nullop);
1.2 ! nonaka 54: __weak_alias(hyperv_is_gen1, hyperv_nullop);
1.1 nonaka 55: __weak_alias(hyperv_set_event_proc, hyperv_voidop);
56: __weak_alias(hyperv_set_message_proc, hyperv_voidop);
57: __weak_alias(hyperv_send_eom, hyperv_voidop);
58: __weak_alias(hyperv_intr, hyperv_voidop);
59: __weak_alias(vmbus_init_interrupts_md, hyperv_voidop);
60: __weak_alias(vmbus_deinit_interrupts_md, hyperv_voidop);
61: __weak_alias(vmbus_init_synic_md, hyperv_voidop);
62: __weak_alias(vmbus_deinit_synic_md, hyperv_voidop);
63:
64: int
65: hyperv_nullop(void)
66: {
67: return 0;
68: }
69:
70: void
71: hyperv_voidop(void)
72: {
73: }
74:
75: uint64_t
76: hyperv_hypercall_error(uint64_t control, paddr_t in_paddr, paddr_t out_paddr)
77: {
78: return ~HYPERCALL_STATUS_SUCCESS;
79: }
80:
81: uint64_t
82: hyperv_hypercall_post_message(paddr_t msg)
83: {
84:
85: return hyperv_hypercall(HYPERCALL_POST_MESSAGE, msg, 0);
86: }
87:
88: uint64_t
89: hyperv_hypercall_signal_event(paddr_t monprm)
90: {
91:
92: return hyperv_hypercall(HYPERCALL_SIGNAL_EVENT, monprm, 0);
93: }
94:
95: int
96: hyperv_guid2str(const struct hyperv_guid *guid, char *buf, size_t sz)
97: {
98: const uint8_t *d = guid->hv_guid;
99:
100: return snprintf(buf, sz, "%02x%02x%02x%02x-"
101: "%02x%02x-%02x%02x-%02x%02x-"
102: "%02x%02x%02x%02x%02x%02x",
103: d[3], d[2], d[1], d[0],
104: d[5], d[4], d[7], d[6], d[8], d[9],
105: d[10], d[11], d[12], d[13], d[14], d[15]);
106: }
107:
108: /*
109: * Hyper-V bus_dma utilities.
110: */
111: void *
112: hyperv_dma_alloc(bus_dma_tag_t dmat, struct hyperv_dma *dma, bus_size_t size,
113: bus_size_t alignment, bus_size_t boundary, int nsegs)
114: {
115: const int kmemflags = cold ? KM_NOSLEEP : KM_SLEEP;
116: const int dmaflags = cold ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
117: int rseg, error;
118:
119: KASSERT(dma != NULL);
120: KASSERT(dma->segs == NULL);
121: KASSERT(nsegs > 0);
122:
123: dma->segs = kmem_zalloc(sizeof(*dma->segs) * nsegs, kmemflags);
124: if (dma->segs == NULL)
125: return NULL;
126:
127: dma->nsegs = nsegs;
128:
129: error = bus_dmamem_alloc(dmat, size, alignment, boundary, dma->segs,
130: nsegs, &rseg, dmaflags);
131: if (error) {
132: printf("%s: bus_dmamem_alloc failed: error=%d\n",
133: __func__, error);
134: goto fail1;
135: }
136: error = bus_dmamem_map(dmat, dma->segs, rseg, size, &dma->addr,
137: dmaflags);
138: if (error) {
139: printf("%s: bus_dmamem_map failed: error=%d\n",
140: __func__, error);
141: goto fail2;
142: }
143: error = bus_dmamap_create(dmat, size, rseg, size, boundary, dmaflags,
144: &dma->map);
145: if (error) {
146: printf("%s: bus_dmamap_create failed: error=%d\n",
147: __func__, error);
148: goto fail3;
149: }
150: error = bus_dmamap_load(dmat, dma->map, dma->addr, size, NULL,
151: BUS_DMA_READ | BUS_DMA_WRITE | dmaflags);
152: if (error) {
153: printf("%s: bus_dmamap_load failed: error=%d\n",
154: __func__, error);
155: goto fail4;
156: }
157:
158: return dma->addr;
159:
160: fail4: bus_dmamap_destroy(dmat, dma->map);
161: fail3: bus_dmamem_unmap(dmat, dma->addr, size);
162: dma->addr = NULL;
163: fail2: bus_dmamem_free(dmat, dma->segs, rseg);
164: fail1: kmem_free(dma->segs, sizeof(*dma->segs) * nsegs);
165: dma->segs = NULL;
166: dma->nsegs = 0;
167: return NULL;
168: }
169:
170: void
171: hyperv_dma_free(bus_dma_tag_t dmat, struct hyperv_dma *dma)
172: {
173: bus_size_t size = dma->map->dm_mapsize;
174: int rsegs = dma->map->dm_nsegs;
175:
176: bus_dmamap_unload(dmat, dma->map);
177: bus_dmamap_destroy(dmat, dma->map);
178: bus_dmamem_unmap(dmat, dma->addr, size);
179: dma->addr = NULL;
180: bus_dmamem_free(dmat, dma->segs, rsegs);
181: kmem_free(dma->segs, sizeof(*dma->segs) * dma->nsegs);
182: dma->segs = NULL;
183: dma->nsegs = 0;
184: }
CVSweb <webmaster@jp.NetBSD.org>