Debian Codegraph @

src/gallium/winsys/svga/drm/vmw_buffer.c

raw
1 /*
2 * Copyright (c) 2009-2024 Broadcom. All Rights Reserved.
3 * The term “Broadcom” refers to Broadcom Inc.
4 * and/or its subsidiaries.
5 * SPDX-License-Identifier: MIT
6 */
7
8 /**
9 * @file
10 * SVGA buffer manager for DMA buffers.
11 *
12 * DMA buffers are used for pixel and vertex data upload/download to/from
13 * the virtual SVGA hardware.
14 *
15 * This file implements a pipebuffer library's buffer manager, so that we can
16 * use pipepbuffer's suballocation, fencing, and debugging facilities with
17 * DMA buffers.
18 *
19 * @author Jose Fonseca <[email protected]>
20 */
21
22
23 #include "svga_cmd.h"
24
25 #include "util/u_inlines.h"
26 #include "util/u_memory.h"
27 #include "pipebuffer/pb_buffer.h"
28 #include "pipebuffer/pb_bufmgr.h"
29
30 #include "svga_winsys.h"
31
32 #include "vmw_screen.h"
33 #include "vmw_buffer.h"
34
35 struct vmw_dma_bufmgr;
36
37
38 struct vmw_dma_buffer
39 {
40 struct pb_buffer base;
41
42 struct vmw_dma_bufmgr *mgr;
43
44 struct vmw_region *region;
45 void *map;
46 unsigned map_flags;
47 unsigned map_count;
48 };
49
50
51 extern const struct pb_vtbl vmw_dma_buffer_vtbl;
52
53
54 static inline struct vmw_dma_buffer *
55 vmw_pb_to_dma_buffer(struct pb_buffer *buf)
56 {
57 assert(buf);
58 assert(buf->vtbl == &vmw_dma_buffer_vtbl);
59 return container_of(buf, struct vmw_dma_buffer, base);
60 }
61
62
63 struct vmw_dma_bufmgr
64 {
65 struct pb_manager base;
66
67 struct vmw_winsys_screen *vws;
68 };
69
70
71 static inline struct vmw_dma_bufmgr *
72 vmw_pb_to_dma_bufmgr(struct pb_manager *mgr)
73 {
74 assert(mgr);
75
76 /* Make sure our extra flags don't collide with pipebuffer's flags */
77 STATIC_ASSERT((VMW_BUFFER_USAGE_SHARED & PB_USAGE_ALL) == 0);
78 STATIC_ASSERT((VMW_BUFFER_USAGE_SYNC & PB_USAGE_ALL) == 0);
79
80 return container_of(mgr, struct vmw_dma_bufmgr, base);
81 }
82
83
84 static void
85 vmw_dma_buffer_destroy(void *winsys, struct pb_buffer *_buf)
86 {
87 struct vmw_dma_buffer *buf = vmw_pb_to_dma_buffer(_buf);
88
89 assert(buf->map_count == 0);
90 if (buf->map) {
91 assert(buf->mgr->vws->cache_maps);
92 vmw_ioctl_region_unmap(buf->region);
93 }
94
95 vmw_ioctl_region_destroy(buf->region);
96
97 FREE(buf);
98 }
99
100
101 static void *
102 vmw_dma_buffer_map(struct pb_buffer *_buf,
103 enum pb_usage_flags flags,
104 void *flush_ctx)
105 {
106 struct vmw_dma_buffer *buf = vmw_pb_to_dma_buffer(_buf);
107 int ret;
108
109 if (!buf->map)
110 buf->map = vmw_ioctl_region_map(buf->region);
111
112 if (!buf->map)
113 return NULL;
114
115 if ((_buf->base.usage & VMW_BUFFER_USAGE_SYNC) &&
116 !(flags & PB_USAGE_UNSYNCHRONIZED)) {
117 ret = vmw_ioctl_syncforcpu(buf->region,
118 !!(flags & PB_USAGE_DONTBLOCK),
119 !(flags & PB_USAGE_CPU_WRITE),
120 false);
121 if (ret)
122 return NULL;
123 }
124
125 buf->map_count++;
126 return buf->map;
127 }
128
129
130 static void
131 vmw_dma_buffer_unmap(struct pb_buffer *_buf)
132 {
133 struct vmw_dma_buffer *buf = vmw_pb_to_dma_buffer(_buf);
134 enum pb_usage_flags flags = buf->map_flags;
135
136 if ((_buf->base.usage & VMW_BUFFER_USAGE_SYNC) &&
137 !(flags & PB_USAGE_UNSYNCHRONIZED)) {
138 vmw_ioctl_releasefromcpu(buf->region,
139 !(flags & PB_USAGE_CPU_WRITE),
140 false);
141 }
142
143 assert(buf->map_count > 0);
144 if (!--buf->map_count && !buf->mgr->vws->cache_maps) {
145 vmw_ioctl_region_unmap(buf->region);
146 buf->map = NULL;
147 }
148 }
149
150
151 static void
152 vmw_dma_buffer_get_base_buffer(struct pb_buffer *buf,
153 struct pb_buffer **base_buf,
154 pb_size *offset)
155 {
156 *base_buf = buf;
157 *offset = 0;
158 }
159
160
161 static enum pipe_error
162 vmw_dma_buffer_validate( struct pb_buffer *_buf,
163 struct pb_validate *vl,
164 enum pb_usage_flags flags )
165 {
166 /* Always pinned */
167 return PIPE_OK;
168 }
169
170
171 static void
172 vmw_dma_buffer_fence( struct pb_buffer *_buf,
173 struct pipe_fence_handle *fence )
174 {
175 /* We don't need to do anything, as the pipebuffer library
176 * will take care of delaying the destruction of fenced buffers
177 */
178 }
179
180
181 const struct pb_vtbl vmw_dma_buffer_vtbl = {
182 .destroy = vmw_dma_buffer_destroy,
183 .map = vmw_dma_buffer_map,
184 .unmap = vmw_dma_buffer_unmap,
185 .validate = vmw_dma_buffer_validate,
186 .fence = vmw_dma_buffer_fence,
187 .get_base_buffer = vmw_dma_buffer_get_base_buffer
188 };
189
190
191 static struct pb_buffer *
192 vmw_dma_bufmgr_create_buffer(struct pb_manager *_mgr,
193 pb_size size,
194 const struct pb_desc *pb_desc)
195 {
196 struct vmw_dma_bufmgr *mgr = vmw_pb_to_dma_bufmgr(_mgr);
197 struct vmw_winsys_screen *vws = mgr->vws;
198 struct vmw_dma_buffer *buf;
199 const struct vmw_buffer_desc *desc =
200 (const struct vmw_buffer_desc *) pb_desc;
201
202 buf = CALLOC_STRUCT(vmw_dma_buffer);
203 if (!buf)
204 goto error1;
205
206 pipe_reference_init(&buf->base.base.reference, 1);
207 buf->base.base.alignment_log2 = util_logbase2(pb_desc->alignment);
208 buf->base.base.usage = pb_desc->usage & ~VMW_BUFFER_USAGE_SHARED;
209 buf->base.vtbl = &vmw_dma_buffer_vtbl;
210 buf->mgr = mgr;
211 buf->base.base.size = size;
212 if ((pb_desc->usage & VMW_BUFFER_USAGE_SHARED) && desc->region) {
213 buf->region = desc->region;
214 } else {
215 buf->region = vmw_ioctl_region_create(vws, size);
216 if (!buf->region)
217 goto error2;
218 }
219
220 return &buf->base;
221 error2:
222 FREE(buf);
223 error1:
224 return NULL;
225 }
226
227
228 static void
229 vmw_dma_bufmgr_flush(struct pb_manager *mgr)
230 {
231 /* No-op */
232 }
233
234
235 static void
236 vmw_dma_bufmgr_destroy(struct pb_manager *_mgr)
237 {
238 struct vmw_dma_bufmgr *mgr = vmw_pb_to_dma_bufmgr(_mgr);
239 FREE(mgr);
240 }
241
242
243 struct pb_manager *
244 vmw_dma_bufmgr_create(struct vmw_winsys_screen *vws)
245 {
246 struct vmw_dma_bufmgr *mgr;
247
248 mgr = CALLOC_STRUCT(vmw_dma_bufmgr);
249 if (!mgr)
250 return NULL;
251
252 mgr->base.destroy = vmw_dma_bufmgr_destroy;
253 mgr->base.create_buffer = vmw_dma_bufmgr_create_buffer;
254 mgr->base.flush = vmw_dma_bufmgr_flush;
255
256 mgr->vws = vws;
257
258 return &mgr->base;
259 }
260
261
262 bool
263 vmw_dma_bufmgr_region_ptr(struct pb_buffer *buf,
264 struct SVGAGuestPtr *ptr)
265 {
266 struct pb_buffer *base_buf;
267 pb_size offset = 0;
268 struct vmw_dma_buffer *dma_buf;
269
270 pb_get_base_buffer( buf, &base_buf, &offset );
271
272 dma_buf = vmw_pb_to_dma_buffer(base_buf);
273 if (!dma_buf)
274 return false;
275
276 *ptr = vmw_ioctl_region_ptr(dma_buf->region);
277
278 ptr->offset += offset;
279
280 return true;
281 }
282
283 #if MESA_DEBUG
284 struct svga_winsys_buffer {
285 struct pb_buffer *pb_buf;
286 struct debug_flush_buf *fbuf;
287 };
288
289 struct pb_buffer *
290 vmw_pb_buffer(struct svga_winsys_buffer *buffer)
291 {
292 assert(buffer);
293 return buffer->pb_buf;
294 }
295
296 struct svga_winsys_buffer *
297 vmw_svga_winsys_buffer_wrap(struct pb_buffer *buffer)
298 {
299 struct svga_winsys_buffer *buf;
300
301 if (!buffer)
302 return NULL;
303
304 buf = CALLOC_STRUCT(svga_winsys_buffer);
305 if (!buf) {
306 pb_reference(&buffer, NULL);
307 return NULL;
308 }
309
310 buf->pb_buf = buffer;
311 buf->fbuf = debug_flush_buf_create(false, VMW_DEBUG_FLUSH_STACK);
312 return buf;
313 }
314
315 struct debug_flush_buf *
316 vmw_debug_flush_buf(struct svga_winsys_buffer *buffer)
317 {
318 return buffer->fbuf;
319 }
320
321 #endif
322
323 void
324 vmw_svga_winsys_buffer_destroy(struct svga_winsys_screen *sws,
325 struct svga_winsys_buffer *buf)
326 {
327 struct pb_buffer *pbuf = vmw_pb_buffer(buf);
328 (void)sws;
329 pb_reference(&pbuf, NULL);
330 #if MESA_DEBUG
331 debug_flush_buf_reference(&buf->fbuf, NULL);
332 FREE(buf);
333 #endif
334 }
335
336 void *
337 vmw_svga_winsys_buffer_map(struct svga_winsys_screen *sws,
338 struct svga_winsys_buffer *buf,
339 enum pipe_map_flags flags)
340 {
341 void *map;
342 enum pb_usage_flags pb_flags = 0;
343
344 (void)sws;
345 if (flags & PIPE_MAP_UNSYNCHRONIZED)
346 flags &= ~PIPE_MAP_DONTBLOCK;
347
348 if (flags & PIPE_MAP_READ)
349 pb_flags |= PB_USAGE_CPU_READ;
350 if (flags & PIPE_MAP_WRITE)
351 pb_flags |= PB_USAGE_CPU_WRITE;
352 if (flags & PIPE_MAP_DIRECTLY)
353 pb_flags |= PB_USAGE_GPU_READ;
354 if (flags & PIPE_MAP_DONTBLOCK)
355 pb_flags |= PB_USAGE_DONTBLOCK;
356 if (flags & PIPE_MAP_UNSYNCHRONIZED)
357 pb_flags |= PB_USAGE_UNSYNCHRONIZED;
358 if (flags & PIPE_MAP_PERSISTENT)
359 pb_flags |= PB_USAGE_PERSISTENT;
360
361 map = pb_map(vmw_pb_buffer(buf), pb_flags, NULL);
362
363 #if MESA_DEBUG
364 if (map != NULL)
365 debug_flush_map(buf->fbuf, pb_flags);
366 #endif
367
368 return map;
369 }
370
371
372 void
373 vmw_svga_winsys_buffer_unmap(struct svga_winsys_screen *sws,
374 struct svga_winsys_buffer *buf)
375 {
376 (void)sws;
377
378 #if MESA_DEBUG
379 debug_flush_unmap(buf->fbuf);
380 #endif
381
382 pb_unmap(vmw_pb_buffer(buf));
383 }