Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 0257fbf81f12ebbfe53579cd61754934d183f380 / . / icd / nulldrv / nulldrv.c
blob: cfada537496962a6ecabc14b656fe340355f115b [file] [log] [blame]
David Pinedo0257fbf2015-02-02 18:02:40 -0700[diff] [blame^]1/*
2 * XGL null driver
3 *
4 * Copyright (C) 2015 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 */
25
26#include "nulldrv.h"
27
28static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
29#ifdef ENABLE_WSI_X11
30 [NULLDRV_EXT_WSI_X11] = "XGL_WSI_X11",
31#endif
32#ifdef ENABLE_WSI_WINDOWS
33 [NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS",
34#endif
35};
36
37static struct nulldrv_base *nulldrv_base(XGL_BASE_OBJECT base)
38{
39 return (struct nulldrv_base *) base;
40}
41
42static XGL_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type,
43 size_t *size, void *data)
44{
45 XGL_RESULT ret = XGL_SUCCESS;
46 size_t s;
47 uint32_t *count;
48
49 switch (type) {
50 case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
51 {
52 XGL_MEMORY_REQUIREMENTS *mem_req = data;
53 s = sizeof(XGL_MEMORY_REQUIREMENTS);
54 *size = s;
55 if (data == NULL)
56 return ret;
57 memset(data, 0, s);
58 mem_req->memType = XGL_MEMORY_TYPE_OTHER;
59 break;
60 }
61 case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
62 *size = sizeof(uint32_t);
63 if (data == NULL)
64 return ret;
65 count = (uint32_t *) data;
66 *count = 1;
67 break;
68 case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
69 s = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
70 *size = s;
71 if (data == NULL)
72 return ret;
73 memset(data, 0, s);
74 break;
75 case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
76 s = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
77 *size = s;
78 if (data == NULL)
79 return ret;
80 memset(data, 0, s);
81 break;
82 default:
83 ret = XGL_ERROR_INVALID_VALUE;
84 break;
85 }
86
87 return ret;
88}
89
90static struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
91 size_t obj_size,
92 XGL_DBG_OBJECT_TYPE type)
93{
94 struct nulldrv_base *base;
95
96 if (!obj_size)
97 obj_size = sizeof(*base);
98
99 assert(obj_size >= sizeof(*base));
100
101 base = (struct nulldrv_base*)icd_alloc(obj_size, 0, XGL_SYSTEM_ALLOC_API_OBJECT);
102 if (!base)
103 return NULL;
104
105 memset(base, 0, obj_size);
106
107 // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
108 set_loader_magic_value(base);
109
110 if (dev == NULL) {
111 /*
112 * dev is NULL when we are creating the base device object
113 * Set dev now so that debug setup happens correctly
114 */
115 dev = (struct nulldrv_dev *) base;
116 }
117
118
119 base->get_info = NULL;
120
121 return base;
122}
123
124static XGL_RESULT nulldrv_gpu_add(int devid, const char *primary_node,
125 const char *render_node, struct nulldrv_gpu **gpu_ret)
126{
127 struct nulldrv_gpu *gpu;
128
129 gpu = icd_alloc(sizeof(*gpu), 0, XGL_SYSTEM_ALLOC_API_OBJECT);
130 if (!gpu)
131 return XGL_ERROR_OUT_OF_MEMORY;
132 memset(gpu, 0, sizeof(*gpu));
133
134 // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
135 set_loader_magic_value(gpu);
136
137 *gpu_ret = gpu;
138
139 return XGL_SUCCESS;
140}
141
142static XGL_RESULT nulldrv_queue_create(struct nulldrv_dev *dev,
143 enum nulldrv_gpu_engine_type engine,
144 struct nulldrv_queue **queue_ret)
145{
146 struct nulldrv_queue *queue;
147
148 queue = (struct nulldrv_queue *) nulldrv_base_create(dev, sizeof(*queue),
149 XGL_DBG_OBJECT_QUEUE);
150 if (!queue)
151 return XGL_ERROR_OUT_OF_MEMORY;
152
153 queue->dev = dev;
154
155 *queue_ret = queue;
156
157 return XGL_SUCCESS;
158}
159
160static XGL_RESULT dev_create_queues(struct nulldrv_dev *dev,
161 const XGL_DEVICE_QUEUE_CREATE_INFO *queues,
162 uint32_t count)
163{
164 uint32_t i;
165
166 if (!count)
167 return XGL_ERROR_INVALID_POINTER;
168
169 for (i = 0; i < count; i++) {
170 const XGL_DEVICE_QUEUE_CREATE_INFO *q = &queues[i];
171 XGL_RESULT ret = XGL_SUCCESS;
172
173 if (q->queueCount == 1 && !dev->queues[q->queueNodeIndex]) {
174 ret = nulldrv_queue_create(dev, q->queueNodeIndex,
175 &dev->queues[q->queueNodeIndex]);
176 }
177 else {
178 ret = XGL_ERROR_INVALID_POINTER;
179 }
180
181 if (ret != XGL_SUCCESS) {
182 return ret;
183 }
184 }
185
186 return XGL_SUCCESS;
187}
188
189static enum nulldrv_ext_type nulldrv_gpu_lookup_extension(const struct nulldrv_gpu *gpu,
190 const char *ext)
191{
192 enum nulldrv_ext_type type;
193
194 for (type = 0; type < ARRAY_SIZE(nulldrv_gpu_exts); type++) {
195 if (nulldrv_gpu_exts[type] && strcmp(nulldrv_gpu_exts[type], ext) == 0)
196 break;
197 }
198
199 assert(type < NULLDRV_EXT_COUNT || type == NULLDRV_EXT_INVALID);
200
201 return type;
202}
203
204static XGL_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev,
205 struct nulldrv_desc_pool **pool_ret)
206{
207 const uint32_t surface_count = 1;
208 const uint32_t sampler_count = 1;
209 struct nulldrv_desc_pool *pool;
210
211 pool = malloc(sizeof(*pool));
212 if (!pool)
213 return XGL_ERROR_OUT_OF_MEMORY;
214
215 memset(pool, 0, sizeof(*pool));
216
217 pool->surface_desc_size = 0;
218 pool->sampler_desc_size = 0;
219
220 *pool_ret = pool;
221
222 return XGL_SUCCESS;
223}
224
225static XGL_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu,
226 const XGL_DEVICE_CREATE_INFO *info,
227 struct nulldrv_dev **dev_ret)
228{
229 struct nulldrv_dev *dev;
230 uint32_t i;
231 XGL_RESULT ret;
232
233 dev = (struct nulldrv_dev *) nulldrv_base_create(NULL, sizeof(*dev),
234 XGL_DBG_OBJECT_DEVICE);
235 if (!dev)
236 return XGL_ERROR_OUT_OF_MEMORY;
237
238 for (i = 0; i < info->extensionCount; i++) {
239 const enum nulldrv_ext_type ext = nulldrv_gpu_lookup_extension(gpu,
240 info->ppEnabledExtensionNames[i]);
241
242 if (ext == NULLDRV_EXT_INVALID)
243 return XGL_ERROR_INVALID_EXTENSION;
244
245 dev->exts[ext] = true;
246 }
247
248 ret = nulldrv_desc_pool_create(dev, &dev->desc_pool);
249 if (ret != XGL_SUCCESS) {
250 return ret;
251 }
252
253 ret = dev_create_queues(dev, info->pRequestedQueues,
254 info->queueRecordCount);
255 if (ret != XGL_SUCCESS) {
256 return ret;
257 }
258
259 *dev_ret = dev;
260
261 return XGL_SUCCESS;
262}
263
264static struct nulldrv_gpu *nulldrv_gpu(XGL_PHYSICAL_GPU gpu)
265{
266 return (struct nulldrv_gpu *) gpu;
267}
268
269static XGL_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev,
270 const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO *info,
271 struct nulldrv_rt_view **view_ret)
272{
273 struct nulldrv_rt_view *view;
274
275 view = (struct nulldrv_rt_view *) nulldrv_base_create(dev, sizeof(*view),
276 XGL_DBG_OBJECT_COLOR_TARGET_VIEW);
277 if (!view)
278 return XGL_ERROR_OUT_OF_MEMORY;
279
280 *view_ret = view;
281
282 return XGL_SUCCESS;
283}
284
285static XGL_RESULT nulldrv_fence_create(struct nulldrv_dev *dev,
286 const XGL_FENCE_CREATE_INFO *info,
287 struct nulldrv_fence **fence_ret)
288{
289 struct nulldrv_fence *fence;
290
291 fence = (struct nulldrv_fence *) nulldrv_base_create(dev, sizeof(*fence),
292 XGL_DBG_OBJECT_FENCE);
293 if (!fence)
294 return XGL_ERROR_OUT_OF_MEMORY;
295
296 *fence_ret = fence;
297
298 return XGL_SUCCESS;
299}
300
301static struct nulldrv_dev *nulldrv_dev(XGL_DEVICE dev)
302{
303 return (struct nulldrv_dev *) dev;
304}
305
306static struct nulldrv_img *nulldrv_img_from_base(struct nulldrv_base *base)
307{
308 return (struct nulldrv_img *) base;
309}
310
311
312static XGL_RESULT img_get_info(struct nulldrv_base *base, int type,
313 size_t *size, void *data)
314{
315 struct nulldrv_img *img = nulldrv_img_from_base(base);
316 XGL_RESULT ret = XGL_SUCCESS;
317
318 switch (type) {
319 case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
320 {
321 XGL_MEMORY_REQUIREMENTS *mem_req = data;
322
323 *size = sizeof(XGL_MEMORY_REQUIREMENTS);
324 if (data == NULL)
325 return ret;
326 mem_req->size = img->total_size;
327 mem_req->alignment = 4096;
328 mem_req->memType = XGL_MEMORY_TYPE_IMAGE;
329 }
330 break;
331 case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
332 {
333 XGL_IMAGE_MEMORY_REQUIREMENTS *img_req = data;
334
335 *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
336 if (data == NULL)
337 return ret;
338 img_req->usage = img->usage;
339 img_req->formatClass = img->format_class;
340 img_req->samples = img->samples;
341 }
342 break;
343 case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
344 {
345 XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
346
347 *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
348 if (data == NULL)
349 return ret;
350 buf_req->usage = img->usage;
351 }
352 break;
353 default:
354 ret = nulldrv_base_get_info(base, type, size, data);
355 break;
356 }
357
358 return ret;
359}
360
361static XGL_RESULT nulldrv_img_create(struct nulldrv_dev *dev,
362 const XGL_IMAGE_CREATE_INFO *info,
363 bool scanout,
364 struct nulldrv_img **img_ret)
365{
366 struct nulldrv_img *img;
367
368 img = (struct nulldrv_img *) nulldrv_base_create(dev, sizeof(*img),
369 XGL_DBG_OBJECT_IMAGE);
370 if (!img)
371 return XGL_ERROR_OUT_OF_MEMORY;
372
373 img->type = info->imageType;
374 img->depth = info->extent.depth;
375 img->mip_levels = info->mipLevels;
376 img->array_size = info->arraySize;
377 img->usage = info->usage;
378 if (info->tiling == XGL_LINEAR_TILING)
379 img->format_class = XGL_IMAGE_FORMAT_CLASS_LINEAR;
380 else
381 img->format_class = icd_format_get_class(info->format);
382 img->samples = info->samples;
383
384 img->obj.base.get_info = img_get_info;
385
386 *img_ret = img;
387
388 return XGL_SUCCESS;
389}
390
391static struct nulldrv_img *nulldrv_img(XGL_IMAGE image)
392{
393 return (struct nulldrv_img *) image;
394}
395
396static XGL_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev,
397 const XGL_MEMORY_ALLOC_INFO *info,
398 struct nulldrv_mem **mem_ret)
399{
400 struct nulldrv_mem *mem;
401
402 mem = (struct nulldrv_mem *) nulldrv_base_create(dev, sizeof(*mem),
403 XGL_DBG_OBJECT_GPU_MEMORY);
404 if (!mem)
405 return XGL_ERROR_OUT_OF_MEMORY;
406
407 mem->bo = _aligned_malloc(info->allocationSize, 4096);
408 if (!mem->bo) {
409 return XGL_ERROR_OUT_OF_MEMORY;
410 }
411
412 mem->size = info->allocationSize;
413
414 *mem_ret = mem;
415
416 return XGL_SUCCESS;
417}
418
419static XGL_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev,
420 const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO *info,
421 struct nulldrv_ds_view **view_ret)
422{
423 struct nulldrv_img *img = nulldrv_img(info->image);
424 struct nulldrv_ds_view *view;
425
426 view = (struct nulldrv_ds_view *) nulldrv_base_create(dev, sizeof(*view),
427 XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW);
428 if (!view)
429 return XGL_ERROR_OUT_OF_MEMORY;
430
431 view->img = img;
432
433 view->array_size = info->arraySize;
434
435 *view_ret = view;
436
437 return XGL_SUCCESS;
438}
439
440static XGL_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev,
441 const XGL_SAMPLER_CREATE_INFO *info,
442 struct nulldrv_sampler **sampler_ret)
443{
444 struct nulldrv_sampler *sampler;
445
446 sampler = (struct nulldrv_sampler *) nulldrv_base_create(dev,
447 sizeof(*sampler), XGL_DBG_OBJECT_SAMPLER);
448 if (!sampler)
449 return XGL_ERROR_OUT_OF_MEMORY;
450
451 *sampler_ret = sampler;
452
453 return XGL_SUCCESS;
454}
455
456static XGL_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev,
457 const XGL_IMAGE_VIEW_CREATE_INFO *info,
458 struct nulldrv_img_view **view_ret)
459{
460 struct nulldrv_img *img = nulldrv_img(info->image);
461 struct nulldrv_img_view *view;
462 uint32_t mip_levels, array_size;
463 XGL_CHANNEL_MAPPING state_swizzles;
464
465 mip_levels = info->subresourceRange.mipLevels;
466
467 array_size = info->subresourceRange.arraySize;
468
469 view = (struct nulldrv_img_view *) nulldrv_base_create(dev, sizeof(*view),
470 XGL_DBG_OBJECT_IMAGE_VIEW);
471 if (!view)
472 return XGL_ERROR_OUT_OF_MEMORY;
473
474 view->img = img;
475 view->min_lod = info->minLod;
476
477 state_swizzles = info->channels;
478
479 view->cmd_len = 8;
480
481 *view_ret = view;
482
483 return XGL_SUCCESS;
484}
485
486static void *nulldrv_mem_map(struct nulldrv_mem *mem, XGL_FLAGS flags)
487{
488 return mem->bo;
489}
490
491static struct nulldrv_mem *nulldrv_mem(XGL_GPU_MEMORY mem)
492{
493 return (struct nulldrv_mem *) mem;
494}
495
496static struct nulldrv_buf *nulldrv_buf_from_base(struct nulldrv_base *base)
497{
498 return (struct nulldrv_buf *) base;
499}
500
501static XGL_RESULT buf_get_info(struct nulldrv_base *base, int type,
502 size_t *size, void *data)
503{
504 struct nulldrv_buf *buf = nulldrv_buf_from_base(base);
505 XGL_RESULT ret = XGL_SUCCESS;
506
507 switch (type) {
508 case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
509 {
510 XGL_MEMORY_REQUIREMENTS *mem_req = data;
511
512 *size = sizeof(XGL_MEMORY_REQUIREMENTS);
513 if (data == NULL)
514 return ret;
515
516 mem_req->size = buf->size;
517 mem_req->alignment = 4096;
518 mem_req->memType = XGL_MEMORY_TYPE_BUFFER;
519
520 }
521 break;
522 case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
523 {
524 XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
525
526 *size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
527 if (data == NULL)
528 return ret;
529 buf_req->usage = buf->usage;
530 }
531 break;
532 default:
533 ret = nulldrv_base_get_info(base, type, size, data);
534 break;
535 }
536
537 return ret;
538}
539
540static XGL_RESULT nulldrv_buf_create(struct nulldrv_dev *dev,
541 const XGL_BUFFER_CREATE_INFO *info,
542 struct nulldrv_buf **buf_ret)
543{
544 struct nulldrv_buf *buf;
545
546 buf = (struct nulldrv_buf *) nulldrv_base_create(dev, sizeof(*buf),
547 XGL_DBG_OBJECT_BUFFER);
548 if (!buf)
549 return XGL_ERROR_OUT_OF_MEMORY;
550
551 buf->size = info->size;
552 buf->usage = info->usage;
553
554 buf->obj.base.get_info = buf_get_info;
555
556 *buf_ret = buf;
557
558 return XGL_SUCCESS;
559}
560
561static XGL_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev,
562 XGL_FLAGS stage_flags,
563 const uint32_t *bind_points,
564 const struct nulldrv_desc_layout *prior_layout,
565 const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
566 struct nulldrv_desc_layout **layout_ret)
567{
568 struct nulldrv_desc_layout *layout;
569
570 layout = (struct nulldrv_desc_layout *)
571 nulldrv_base_create(dev, sizeof(*layout),
572 XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT);
573 if (!layout)
574 return XGL_ERROR_OUT_OF_MEMORY;
575
576 *layout_ret = layout;
577
578 return XGL_SUCCESS;
579}
580
581static struct nulldrv_desc_layout *nulldrv_desc_layout(XGL_DESCRIPTOR_SET_LAYOUT layout)
582{
583 return (struct nulldrv_desc_layout *) layout;
584}
585
586static XGL_RESULT shader_create(struct nulldrv_dev *dev,
587 const XGL_SHADER_CREATE_INFO *info,
588 struct nulldrv_shader **sh_ret)
589{
590 const struct icd_bil_header *bil =
591 (const struct icd_bil_header *) info->pCode;
592 struct nulldrv_shader *sh;
593
594 sh = (struct nulldrv_shader *) nulldrv_base_create(dev, sizeof(*sh),
595 XGL_DBG_OBJECT_SHADER);
596 if (!sh)
597 return XGL_ERROR_OUT_OF_MEMORY;
598
599 *sh_ret = sh;
600
601 return XGL_SUCCESS;
602}
603
604static XGL_RESULT graphics_pipeline_create(struct nulldrv_dev *dev,
605 const XGL_GRAPHICS_PIPELINE_CREATE_INFO *info_,
606 struct nulldrv_pipeline **pipeline_ret)
607{
608 struct nulldrv_pipeline *pipeline;
609
610 pipeline = (struct nulldrv_pipeline *)
611 nulldrv_base_create(dev, sizeof(*pipeline),
612 XGL_DBG_OBJECT_GRAPHICS_PIPELINE);
613 if (!pipeline)
614 return XGL_ERROR_OUT_OF_MEMORY;
615
616 *pipeline_ret = pipeline;
617
618 return XGL_SUCCESS;
619}
620
621static XGL_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev,
622 const XGL_DYNAMIC_VP_STATE_CREATE_INFO *info,
623 struct nulldrv_dynamic_vp **state_ret)
624{
625 struct nulldrv_dynamic_vp *state;
626
627 state = (struct nulldrv_dynamic_vp *) nulldrv_base_create(dev,
628 sizeof(*state), XGL_DBG_OBJECT_VIEWPORT_STATE);
629 if (!state)
630 return XGL_ERROR_OUT_OF_MEMORY;
631
632 *state_ret = state;
633
634 return XGL_SUCCESS;
635}
636
637static XGL_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev,
638 const XGL_DYNAMIC_RS_STATE_CREATE_INFO *info,
639 struct nulldrv_dynamic_rs **state_ret)
640{
641 struct nulldrv_dynamic_rs *state;
642
643 state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev,
644 sizeof(*state), XGL_DBG_OBJECT_RASTER_STATE);
645 if (!state)
646 return XGL_ERROR_OUT_OF_MEMORY;
647
648 *state_ret = state;
649
650 return XGL_SUCCESS;
651}
652
653static XGL_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev,
654 const XGL_DYNAMIC_CB_STATE_CREATE_INFO *info,
655 struct nulldrv_dynamic_cb **state_ret)
656{
657 struct nulldrv_dynamic_cb *state;
658
659 state = (struct nulldrv_dynamic_cb *) nulldrv_base_create(dev,
660 sizeof(*state), XGL_DBG_OBJECT_COLOR_BLEND_STATE);
661 if (!state)
662 return XGL_ERROR_OUT_OF_MEMORY;
663
664 *state_ret = state;
665
666 return XGL_SUCCESS;
667}
668
669static XGL_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev,
670 const XGL_DYNAMIC_DS_STATE_CREATE_INFO *info,
671 struct nulldrv_dynamic_ds **state_ret)
672{
673 struct nulldrv_dynamic_ds *state;
674
675 state = (struct nulldrv_dynamic_ds *) nulldrv_base_create(dev,
676 sizeof(*state), XGL_DBG_OBJECT_DEPTH_STENCIL_STATE);
677 if (!state)
678 return XGL_ERROR_OUT_OF_MEMORY;
679
680 *state_ret = state;
681
682 return XGL_SUCCESS;
683}
684
685
686static XGL_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev,
687 const XGL_CMD_BUFFER_CREATE_INFO *info,
688 struct nulldrv_cmd **cmd_ret)
689{
690 int pipeline_select;
691 struct nulldrv_cmd *cmd;
692
693 pipeline_select = 0;
694
695 cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
696 XGL_DBG_OBJECT_CMD_BUFFER);
697 if (!cmd)
698 return XGL_ERROR_OUT_OF_MEMORY;
699
700 *cmd_ret = cmd;
701
702 return XGL_SUCCESS;
703}
704
705static XGL_RESULT nulldrv_desc_region_create(struct nulldrv_dev *dev,
706 XGL_DESCRIPTOR_REGION_USAGE usage,
707 uint32_t max_sets,
708 const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
709 struct nulldrv_desc_region **region_ret)
710{
711 struct nulldrv_desc_region *region;
712
713 region = (struct nulldrv_desc_region *)
714 nulldrv_base_create(dev, sizeof(*region),
715 XGL_DBG_OBJECT_DESCRIPTOR_REGION);
716 if (!region)
717 return XGL_ERROR_OUT_OF_MEMORY;
718
719 region->dev = dev;
720
721 *region_ret = region;
722
723 return XGL_SUCCESS;
724}
725
726static XGL_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev,
727 struct nulldrv_desc_region *region,
728 XGL_DESCRIPTOR_SET_USAGE usage,
729 const struct nulldrv_desc_layout *layout,
730 struct nulldrv_desc_set **set_ret)
731{
732 struct nulldrv_desc_set *set;
733
734 set = (struct nulldrv_desc_set *)
735 nulldrv_base_create(dev, sizeof(*set),
736 XGL_DBG_OBJECT_DESCRIPTOR_SET);
737 if (!set)
738 return XGL_ERROR_OUT_OF_MEMORY;
739
740 set->pool = dev->desc_pool;
741 set->layout = layout;
742 *set_ret = set;
743
744 return XGL_SUCCESS;
745}
746
747static struct nulldrv_desc_region *nulldrv_desc_region(XGL_DESCRIPTOR_REGION region)
748{
749 return (struct nulldrv_desc_region *) region;
750}
751
752static XGL_RESULT nulldrv_fb_create(struct nulldrv_dev *dev,
753 const XGL_FRAMEBUFFER_CREATE_INFO* info,
754 struct nulldrv_framebuffer ** fb_ret)
755{
756
757 struct nulldrv_framebuffer *fb;
758 fb = (struct nulldrv_framebuffer *) nulldrv_base_create(dev, sizeof(*fb),
759 XGL_DBG_OBJECT_FRAMEBUFFER);
760 if (!fb)
761 return XGL_ERROR_OUT_OF_MEMORY;
762
763 *fb_ret = fb;
764
765 return XGL_SUCCESS;
766
767}
768
769static XGL_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev,
770 const XGL_RENDER_PASS_CREATE_INFO* info,
771 struct nulldrv_render_pass** rp_ret)
772{
773 struct nulldrv_render_pass *rp;
774 rp = (struct nulldrv_render_pass *) nulldrv_base_create(dev, sizeof(*rp),
775 XGL_DBG_OBJECT_RENDER_PASS);
776 if (!rp)
777 return XGL_ERROR_OUT_OF_MEMORY;
778
779 *rp_ret = rp;
780
781 return XGL_SUCCESS;
782}
783
784
785//*********************************************
786// Driver entry points
787//*********************************************
788
789ICD_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(
790 XGL_DEVICE device,
791 const XGL_BUFFER_CREATE_INFO* pCreateInfo,
792 XGL_BUFFER* pBuffer)
793{
794 struct nulldrv_dev *dev = nulldrv_dev(device);
795
796 return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer);
797}
798
799ICD_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(
800 XGL_DEVICE device,
801 const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
802 XGL_CMD_BUFFER* pCmdBuffer)
803{
804 struct nulldrv_dev *dev = nulldrv_dev(device);
805
806 return nulldrv_cmd_create(dev, pCreateInfo,
807 (struct nulldrv_cmd **) pCmdBuffer);
808}
809
810ICD_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(
811 XGL_CMD_BUFFER cmdBuffer,
812 const XGL_CMD_BUFFER_BEGIN_INFO *info)
813{
814 return XGL_SUCCESS;
815}
816
817ICD_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(
818 XGL_CMD_BUFFER cmdBuffer)
819{
820 return XGL_SUCCESS;
821}
822
823ICD_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(
824 XGL_CMD_BUFFER cmdBuffer)
825{
826 return XGL_SUCCESS;
827}
828
829ICD_EXPORT void XGLAPI xglCmdInitAtomicCounters(
830 XGL_CMD_BUFFER cmdBuffer,
831 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
832 uint32_t startCounter,
833 uint32_t counterCount,
834 const uint32_t* pData)
835{
836}
837
838ICD_EXPORT void XGLAPI xglCmdLoadAtomicCounters(
839 XGL_CMD_BUFFER cmdBuffer,
840 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
841 uint32_t startCounter,
842 uint32_t counterCount,
843 XGL_BUFFER srcBuffer,
844 XGL_GPU_SIZE srcOffset)
845{
846}
847
848ICD_EXPORT void XGLAPI xglCmdSaveAtomicCounters(
849 XGL_CMD_BUFFER cmdBuffer,
850 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
851 uint32_t startCounter,
852 uint32_t counterCount,
853 XGL_BUFFER destBuffer,
854 XGL_GPU_SIZE destOffset)
855{
856}
857
858ICD_EXPORT void XGLAPI xglCmdDbgMarkerBegin(
859 XGL_CMD_BUFFER cmdBuffer,
860 const char* pMarker)
861{
862}
863
864ICD_EXPORT void XGLAPI xglCmdDbgMarkerEnd(
865 XGL_CMD_BUFFER cmdBuffer)
866{
867}
868
869ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
870 XGL_CMD_BUFFER cmdBuffer,
871 XGL_BUFFER srcBuffer,
872 XGL_BUFFER destBuffer,
873 uint32_t regionCount,
874 const XGL_BUFFER_COPY* pRegions)
875{
876}
877
878ICD_EXPORT void XGLAPI xglCmdCopyImage(
879 XGL_CMD_BUFFER cmdBuffer,
880 XGL_IMAGE srcImage,
881 XGL_IMAGE destImage,
882 uint32_t regionCount,
883 const XGL_IMAGE_COPY* pRegions)
884{
885}
886
887ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
888 XGL_CMD_BUFFER cmdBuffer,
889 XGL_BUFFER srcBuffer,
890 XGL_IMAGE destImage,
891 uint32_t regionCount,
892 const XGL_BUFFER_IMAGE_COPY* pRegions)
893{
894}
895
896ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
897 XGL_CMD_BUFFER cmdBuffer,
898 XGL_IMAGE srcImage,
899 XGL_BUFFER destBuffer,
900 uint32_t regionCount,
901 const XGL_BUFFER_IMAGE_COPY* pRegions)
902{
903}
904
905ICD_EXPORT void XGLAPI xglCmdCloneImageData(
906 XGL_CMD_BUFFER cmdBuffer,
907 XGL_IMAGE srcImage,
908 XGL_IMAGE_LAYOUT srcImageLayout,
909 XGL_IMAGE destImage,
910 XGL_IMAGE_LAYOUT destImageLayout)
911{
912}
913
914ICD_EXPORT void XGLAPI xglCmdUpdateBuffer(
915 XGL_CMD_BUFFER cmdBuffer,
916 XGL_BUFFER destBuffer,
917 XGL_GPU_SIZE destOffset,
918 XGL_GPU_SIZE dataSize,
919 const uint32_t* pData)
920{
921}
922
923ICD_EXPORT void XGLAPI xglCmdFillBuffer(
924 XGL_CMD_BUFFER cmdBuffer,
925 XGL_BUFFER destBuffer,
926 XGL_GPU_SIZE destOffset,
927 XGL_GPU_SIZE fillSize,
928 uint32_t data)
929{
930}
931
932ICD_EXPORT void XGLAPI xglCmdClearColorImage(
933 XGL_CMD_BUFFER cmdBuffer,
934 XGL_IMAGE image,
935 const float color[4],
936 uint32_t rangeCount,
937 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
938{
939}
940
941ICD_EXPORT void XGLAPI xglCmdClearColorImageRaw(
942 XGL_CMD_BUFFER cmdBuffer,
943 XGL_IMAGE image,
944 const uint32_t color[4],
945 uint32_t rangeCount,
946 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
947{
948}
949
950ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
951 XGL_CMD_BUFFER cmdBuffer,
952 XGL_IMAGE image,
953 float depth,
954 uint32_t stencil,
955 uint32_t rangeCount,
956 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
957{
958}
959
960ICD_EXPORT void XGLAPI xglCmdResolveImage(
961 XGL_CMD_BUFFER cmdBuffer,
962 XGL_IMAGE srcImage,
963 XGL_IMAGE destImage,
964 uint32_t rectCount,
965 const XGL_IMAGE_RESOLVE* pRects)
966{
967}
968
969ICD_EXPORT void XGLAPI xglCmdBeginQuery(
970 XGL_CMD_BUFFER cmdBuffer,
971 XGL_QUERY_POOL queryPool,
972 uint32_t slot,
973 XGL_FLAGS flags)
974{
975}
976
977ICD_EXPORT void XGLAPI xglCmdEndQuery(
978 XGL_CMD_BUFFER cmdBuffer,
979 XGL_QUERY_POOL queryPool,
980 uint32_t slot)
981{
982}
983
984ICD_EXPORT void XGLAPI xglCmdResetQueryPool(
985 XGL_CMD_BUFFER cmdBuffer,
986 XGL_QUERY_POOL queryPool,
987 uint32_t startQuery,
988 uint32_t queryCount)
989{
990}
991
992ICD_EXPORT void XGLAPI xglCmdSetEvent(
993 XGL_CMD_BUFFER cmdBuffer,
994 XGL_EVENT event_,
995 XGL_SET_EVENT pipeEvent)
996{
997}
998
999ICD_EXPORT void XGLAPI xglCmdResetEvent(
1000 XGL_CMD_BUFFER cmdBuffer,
1001 XGL_EVENT event_)
1002{
1003}
1004
1005ICD_EXPORT void XGLAPI xglCmdWriteTimestamp(
1006 XGL_CMD_BUFFER cmdBuffer,
1007 XGL_TIMESTAMP_TYPE timestampType,
1008 XGL_BUFFER destBuffer,
1009 XGL_GPU_SIZE destOffset)
1010{
1011}
1012
1013ICD_EXPORT void XGLAPI xglCmdBindPipeline(
1014 XGL_CMD_BUFFER cmdBuffer,
1015 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
1016 XGL_PIPELINE pipeline)
1017{
1018}
1019
1020ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
1021 XGL_CMD_BUFFER cmdBuffer,
1022 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
1023 XGL_PIPELINE_DELTA delta)
1024{
1025}
1026
1027ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
1028 XGL_CMD_BUFFER cmdBuffer,
1029 XGL_STATE_BIND_POINT stateBindPoint,
1030 XGL_DYNAMIC_STATE_OBJECT state)
1031{
1032}
1033
1034ICD_EXPORT void XGLAPI xglCmdBindDescriptorSet(
1035 XGL_CMD_BUFFER cmdBuffer,
1036 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
1037 XGL_DESCRIPTOR_SET descriptorSet,
1038 const uint32_t* pUserData)
1039{
1040}
1041
1042ICD_EXPORT void XGLAPI xglCmdBindVertexBuffer(
1043 XGL_CMD_BUFFER cmdBuffer,
1044 XGL_BUFFER buffer,
1045 XGL_GPU_SIZE offset,
1046 uint32_t binding)
1047{
1048}
1049
1050ICD_EXPORT void XGLAPI xglCmdBindIndexBuffer(
1051 XGL_CMD_BUFFER cmdBuffer,
1052 XGL_BUFFER buffer,
1053 XGL_GPU_SIZE offset,
1054 XGL_INDEX_TYPE indexType)
1055{
1056}
1057
1058ICD_EXPORT void XGLAPI xglCmdDraw(
1059 XGL_CMD_BUFFER cmdBuffer,
1060 uint32_t firstVertex,
1061 uint32_t vertexCount,
1062 uint32_t firstInstance,
1063 uint32_t instanceCount)
1064{
1065}
1066
1067ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
1068 XGL_CMD_BUFFER cmdBuffer,
1069 uint32_t firstIndex,
1070 uint32_t indexCount,
1071 int32_t vertexOffset,
1072 uint32_t firstInstance,
1073 uint32_t instanceCount)
1074{
1075}
1076
1077ICD_EXPORT void XGLAPI xglCmdDrawIndirect(
1078 XGL_CMD_BUFFER cmdBuffer,
1079 XGL_BUFFER buffer,
1080 XGL_GPU_SIZE offset,
1081 uint32_t count,
1082 uint32_t stride)
1083{
1084}
1085
1086ICD_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(
1087 XGL_CMD_BUFFER cmdBuffer,
1088 XGL_BUFFER buffer,
1089 XGL_GPU_SIZE offset,
1090 uint32_t count,
1091 uint32_t stride)
1092{
1093}
1094
1095ICD_EXPORT void XGLAPI xglCmdDispatch(
1096 XGL_CMD_BUFFER cmdBuffer,
1097 uint32_t x,
1098 uint32_t y,
1099 uint32_t z)
1100{
1101}
1102
1103ICD_EXPORT void XGLAPI xglCmdDispatchIndirect(
1104 XGL_CMD_BUFFER cmdBuffer,
1105 XGL_BUFFER buffer,
1106 XGL_GPU_SIZE offset)
1107{
1108}
1109
1110ICD_EXPORT void XGLAPI xglCmdWaitEvents(
1111 XGL_CMD_BUFFER cmdBuffer,
1112 const XGL_EVENT_WAIT_INFO* pWaitInfo)
1113{
1114}
1115
1116ICD_EXPORT void XGLAPI xglCmdPipelineBarrier(
1117 XGL_CMD_BUFFER cmdBuffer,
1118 const XGL_PIPELINE_BARRIER* pBarrier)
1119{
1120}
1121
1122ICD_EXPORT XGL_RESULT XGLAPI xglCreateDevice(
1123 XGL_PHYSICAL_GPU gpu_,
1124 const XGL_DEVICE_CREATE_INFO* pCreateInfo,
1125 XGL_DEVICE* pDevice)
1126{
1127 struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_);
1128 return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice);
1129}
1130
1131ICD_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(
1132 XGL_DEVICE device)
1133{
1134 return XGL_SUCCESS;
1135}
1136
1137ICD_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(
1138 XGL_DEVICE device,
1139 XGL_QUEUE_TYPE queueType,
1140 uint32_t queueIndex,
1141 XGL_QUEUE* pQueue)
1142{
1143 struct nulldrv_dev *dev = nulldrv_dev(device);
1144 *pQueue = dev->queues[0];
1145 return XGL_SUCCESS;
1146}
1147
1148ICD_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(
1149 XGL_DEVICE device)
1150{
1151 return XGL_SUCCESS;
1152}
1153
1154ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(
1155 XGL_DEVICE device,
1156 XGL_VALIDATION_LEVEL validationLevel)
1157{
1158 return XGL_SUCCESS;
1159}
1160
1161ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(
1162 XGL_DEVICE device,
1163 int32_t msgCode,
1164 XGL_DBG_MSG_FILTER filter)
1165{
1166 return XGL_SUCCESS;
1167}
1168
1169ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(
1170 XGL_DEVICE device,
1171 XGL_DBG_DEVICE_OPTION dbgOption,
1172 size_t dataSize,
1173 const void* pData)
1174{
1175 return XGL_SUCCESS;
1176}
1177
1178ICD_EXPORT XGL_RESULT XGLAPI xglCreateEvent(
1179 XGL_DEVICE device,
1180 const XGL_EVENT_CREATE_INFO* pCreateInfo,
1181 XGL_EVENT* pEvent)
1182{
1183 return XGL_SUCCESS;
1184}
1185
1186ICD_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(
1187 XGL_EVENT event_)
1188{
1189 return XGL_SUCCESS;
1190}
1191
1192ICD_EXPORT XGL_RESULT XGLAPI xglSetEvent(
1193 XGL_EVENT event_)
1194{
1195 return XGL_SUCCESS;
1196}
1197
1198ICD_EXPORT XGL_RESULT XGLAPI xglResetEvent(
1199 XGL_EVENT event_)
1200{
1201 return XGL_SUCCESS;
1202}
1203
1204ICD_EXPORT XGL_RESULT XGLAPI xglCreateFence(
1205 XGL_DEVICE device,
1206 const XGL_FENCE_CREATE_INFO* pCreateInfo,
1207 XGL_FENCE* pFence)
1208{
1209 struct nulldrv_dev *dev = nulldrv_dev(device);
1210
1211 return nulldrv_fence_create(dev, pCreateInfo,
1212 (struct nulldrv_fence **) pFence);
1213}
1214
1215ICD_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(
1216 XGL_FENCE fence_)
1217{
1218 return XGL_SUCCESS;
1219}
1220
1221ICD_EXPORT XGL_RESULT XGLAPI xglWaitForFences(
1222 XGL_DEVICE device,
1223 uint32_t fenceCount,
1224 const XGL_FENCE* pFences,
1225 bool32_t waitAll,
1226 uint64_t timeout)
1227{
1228 return XGL_SUCCESS;
1229}
1230
1231ICD_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(
1232 XGL_DEVICE device,
1233 XGL_FORMAT format,
1234 XGL_FORMAT_INFO_TYPE infoType,
1235 size_t* pDataSize,
1236 void* pData)
1237{
1238 return XGL_SUCCESS;
1239}
1240
1241ICD_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(
1242 XGL_PHYSICAL_GPU gpu_,
1243 XGL_PHYSICAL_GPU_INFO_TYPE infoType,
1244 size_t* pDataSize,
1245 void* pData)
1246{
1247 return XGL_SUCCESS;
1248}
1249
1250ICD_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(
1251 XGL_PHYSICAL_GPU gpu_,
1252 const char* pExtName)
1253{
1254 return XGL_SUCCESS;
1255}
1256
1257ICD_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
1258 XGL_PHYSICAL_GPU gpu0_,
1259 XGL_PHYSICAL_GPU gpu1_,
1260 XGL_GPU_COMPATIBILITY_INFO* pInfo)
1261{
1262 return XGL_SUCCESS;
1263}
1264
1265ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(
1266 XGL_DEVICE device,
1267 const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
1268 XGL_IMAGE* pImage,
1269 XGL_GPU_MEMORY* pMem)
1270{
1271 return XGL_SUCCESS;
1272}
1273
1274ICD_EXPORT XGL_RESULT XGLAPI xglCreateImage(
1275 XGL_DEVICE device,
1276 const XGL_IMAGE_CREATE_INFO* pCreateInfo,
1277 XGL_IMAGE* pImage)
1278{
1279 struct nulldrv_dev *dev = nulldrv_dev(device);
1280
1281 return nulldrv_img_create(dev, pCreateInfo, false,
1282 (struct nulldrv_img **) pImage);
1283}
1284
1285ICD_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
1286 XGL_IMAGE image,
1287 const XGL_IMAGE_SUBRESOURCE* pSubresource,
1288 XGL_SUBRESOURCE_INFO_TYPE infoType,
1289 size_t* pDataSize,
1290 void* pData)
1291{
1292 const struct nulldrv_img *img = nulldrv_img(image);
1293 XGL_RESULT ret = XGL_SUCCESS;
1294
1295 switch (infoType) {
1296 case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
1297 {
1298 XGL_SUBRESOURCE_LAYOUT *layout = (XGL_SUBRESOURCE_LAYOUT *) pData;
1299
1300 *pDataSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
1301
1302 if (pData == NULL)
1303 return ret;
1304 layout->offset = 0;
1305 layout->size = 1;
1306 layout->rowPitch = 4;
1307 layout->depthPitch = 4;
1308 }
1309 break;
1310 default:
1311 ret = XGL_ERROR_INVALID_VALUE;
1312 break;
1313 }
1314
1315 return ret;
1316}
1317
1318ICD_EXPORT XGL_RESULT XGLAPI xglSetFastClearColor(
1319 XGL_IMAGE image,
1320 const float color[4])
1321{
1322 return XGL_SUCCESS;
1323}
1324
1325ICD_EXPORT XGL_RESULT XGLAPI xglSetFastClearDepth(
1326 XGL_IMAGE image,
1327 float depth)
1328{
1329 return XGL_SUCCESS;
1330}
1331
1332ICD_EXPORT XGL_RESULT XGLAPI xglAllocMemory(
1333 XGL_DEVICE device,
1334 const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
1335 XGL_GPU_MEMORY* pMem)
1336{
1337 struct nulldrv_dev *dev = nulldrv_dev(device);
1338
1339 return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem);
1340}
1341
1342ICD_EXPORT XGL_RESULT XGLAPI xglFreeMemory(
1343 XGL_GPU_MEMORY mem_)
1344{
1345 return XGL_SUCCESS;
1346}
1347
1348ICD_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(
1349 XGL_GPU_MEMORY mem_,
1350 XGL_MEMORY_PRIORITY priority)
1351{
1352 return XGL_SUCCESS;
1353}
1354
1355ICD_EXPORT XGL_RESULT XGLAPI xglMapMemory(
1356 XGL_GPU_MEMORY mem_,
1357 XGL_FLAGS flags,
1358 void** ppData)
1359{
1360 struct nulldrv_mem *mem = nulldrv_mem(mem_);
1361 void *ptr = nulldrv_mem_map(mem, flags);
1362
1363 *ppData = ptr;
1364
1365 return (ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
1366}
1367
1368ICD_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(
1369 XGL_GPU_MEMORY mem_)
1370{
1371 return XGL_SUCCESS;
1372}
1373
1374ICD_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(
1375 XGL_DEVICE device,
1376 const void* pSysMem,
1377 size_t memSize,
1378 XGL_GPU_MEMORY* pMem)
1379{
1380 return XGL_SUCCESS;
1381}
1382
1383ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(
1384 XGL_DEVICE device,
1385 const XGL_MEMORY_OPEN_INFO* pOpenInfo,
1386 XGL_GPU_MEMORY* pMem)
1387{
1388 return XGL_SUCCESS;
1389}
1390
1391ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(
1392 XGL_DEVICE device,
1393 const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
1394 XGL_GPU_MEMORY* pMem)
1395{
1396 return XGL_SUCCESS;
1397}
1398
1399ICD_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
1400 const XGL_APPLICATION_INFO* pAppInfo,
1401 const XGL_ALLOC_CALLBACKS* pAllocCb,
1402 XGL_INSTANCE* pInstance)
1403{
1404 struct nulldrv_instance *inst;
1405
1406 inst = (struct nulldrv_instance *) nulldrv_base_create(NULL, sizeof(*inst),
1407 XGL_DBG_OBJECT_INSTANCE);
1408 if (!inst)
1409 return XGL_ERROR_OUT_OF_MEMORY;
1410
1411 inst->obj.base.get_info = NULL;
1412
1413 *pInstance = (XGL_INSTANCE*)inst;
1414
1415 return icd_allocator_init(pAllocCb);
1416}
1417
1418ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
1419 XGL_INSTANCE pInstance)
1420{
1421 return XGL_SUCCESS;
1422}
1423
1424ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(
1425 XGL_INSTANCE instance,
1426 uint32_t maxGpus,
1427 uint32_t* pGpuCount,
1428 XGL_PHYSICAL_GPU* pGpus)
1429{
1430 XGL_RESULT ret;
1431 struct nulldrv_gpu *gpu;
1432 *pGpuCount = 1;
1433 ret = nulldrv_gpu_add(0, 0, 0, &gpu);
1434 if (ret == XGL_SUCCESS)
1435 pGpus[0] = (XGL_PHYSICAL_GPU) gpu;
1436 return ret;
1437}
1438
1439ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(
1440 XGL_PHYSICAL_GPU gpu,
1441 size_t maxLayerCount,
1442 size_t maxStringSize,
1443 size_t* pOutLayerCount,
1444 char* const* pOutLayers,
1445 void* pReserved)
1446{
1447 return XGL_SUCCESS;
1448}
1449
1450ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
1451 XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
1452 void* pUserData)
1453{
1454 return XGL_SUCCESS;
1455}
1456
1457ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
1458 XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
1459{
1460 return XGL_SUCCESS;
1461}
1462
1463ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(
1464 XGL_DBG_GLOBAL_OPTION dbgOption,
1465 size_t dataSize,
1466 const void* pData)
1467{
1468 return XGL_SUCCESS;
1469}
1470
1471ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
1472 XGL_OBJECT object)
1473{
1474 return XGL_SUCCESS;
1475}
1476
1477ICD_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(
1478 XGL_BASE_OBJECT object,
1479 XGL_OBJECT_INFO_TYPE infoType,
1480 size_t* pDataSize,
1481 void* pData)
1482{
1483 struct nulldrv_base *base = nulldrv_base(object);
1484
1485 return base->get_info(base, infoType, pDataSize, pData);
1486}
1487
1488ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(
1489 XGL_OBJECT object,
1490 uint32_t allocationIdx,
1491 XGL_GPU_MEMORY mem_,
1492 XGL_GPU_SIZE memOffset)
1493{
1494 return XGL_SUCCESS;
1495}
1496
1497ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemoryRange(
1498 XGL_OBJECT object,
1499 uint32_t allocationIdx,
1500 XGL_GPU_SIZE rangeOffset,
1501 XGL_GPU_SIZE rangeSize,
1502 XGL_GPU_MEMORY mem,
1503 XGL_GPU_SIZE memOffset)
1504{
1505 return XGL_SUCCESS;
1506}
1507
1508ICD_EXPORT XGL_RESULT XGLAPI xglBindImageMemoryRange(
1509 XGL_IMAGE image,
1510 uint32_t allocationIdx,
1511 const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo,
1512 XGL_GPU_MEMORY mem,
1513 XGL_GPU_SIZE memOffset)
1514{
1515 return XGL_SUCCESS;
1516}
1517
1518ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(
1519 XGL_BASE_OBJECT object,
1520 size_t tagSize,
1521 const void* pTag)
1522{
1523 return XGL_SUCCESS;
1524}
1525
1526ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
1527 XGL_DEVICE device,
1528 const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
1529 XGL_PIPELINE* pPipeline)
1530{
1531 struct nulldrv_dev *dev = nulldrv_dev(device);
1532
1533 return graphics_pipeline_create(dev, pCreateInfo,
1534 (struct nulldrv_pipeline **) pPipeline);
1535}
1536
1537ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
1538 XGL_DEVICE device,
1539 const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
1540 XGL_PIPELINE* pPipeline)
1541{
1542 return XGL_SUCCESS;
1543}
1544
1545ICD_EXPORT XGL_RESULT XGLAPI xglStorePipeline(
1546 XGL_PIPELINE pipeline,
1547 size_t* pDataSize,
1548 void* pData)
1549{
1550 return XGL_SUCCESS;
1551}
1552
1553ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
1554 XGL_DEVICE device,
1555 size_t dataSize,
1556 const void* pData,
1557 XGL_PIPELINE* pPipeline)
1558{
1559 return XGL_SUCCESS;
1560}
1561
1562ICD_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(
1563 XGL_DEVICE device,
1564 XGL_PIPELINE p1,
1565 XGL_PIPELINE p2,
1566 XGL_PIPELINE_DELTA* delta)
1567{
1568 return XGL_SUCCESS;
1569}
1570
1571ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(
1572 XGL_DEVICE device,
1573 const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
1574 XGL_QUERY_POOL* pQueryPool)
1575{
1576 return XGL_SUCCESS;
1577}
1578
1579ICD_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(
1580 XGL_QUERY_POOL queryPool,
1581 uint32_t startQuery,
1582 uint32_t queryCount,
1583 size_t* pDataSize,
1584 void* pData)
1585{
1586 return XGL_SUCCESS;
1587}
1588
1589ICD_EXPORT XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
1590 XGL_QUEUE queue,
1591 uint32_t memRefCount,
1592 const XGL_MEMORY_REF* pMemRefs)
1593{
1594 return XGL_SUCCESS;
1595}
1596
1597ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(
1598 XGL_QUEUE queue_)
1599{
1600 return XGL_SUCCESS;
1601}
1602
1603ICD_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(
1604 XGL_QUEUE queue_,
1605 uint32_t cmdBufferCount,
1606 const XGL_CMD_BUFFER* pCmdBuffers,
1607 uint32_t memRefCount,
1608 const XGL_MEMORY_REF* pMemRefs,
1609 XGL_FENCE fence_)
1610{
1611 return XGL_SUCCESS;
1612}
1613
1614ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
1615 XGL_DEVICE device,
1616 const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
1617 XGL_QUEUE_SEMAPHORE* pSemaphore)
1618{
1619 return XGL_SUCCESS;
1620}
1621
1622ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueueSemaphore(
1623 XGL_DEVICE device,
1624 const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
1625 XGL_QUEUE_SEMAPHORE* pSemaphore)
1626{
1627 return XGL_SUCCESS;
1628}
1629
1630ICD_EXPORT XGL_RESULT XGLAPI xglSignalQueueSemaphore(
1631 XGL_QUEUE queue,
1632 XGL_QUEUE_SEMAPHORE semaphore)
1633{
1634 return XGL_SUCCESS;
1635}
1636
1637ICD_EXPORT XGL_RESULT XGLAPI xglWaitQueueSemaphore(
1638 XGL_QUEUE queue,
1639 XGL_QUEUE_SEMAPHORE semaphore)
1640{
1641 return XGL_SUCCESS;
1642}
1643
1644ICD_EXPORT XGL_RESULT XGLAPI xglCreateSampler(
1645 XGL_DEVICE device,
1646 const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
1647 XGL_SAMPLER* pSampler)
1648{
1649 struct nulldrv_dev *dev = nulldrv_dev(device);
1650
1651 return nulldrv_sampler_create(dev, pCreateInfo,
1652 (struct nulldrv_sampler **) pSampler);
1653}
1654
1655ICD_EXPORT XGL_RESULT XGLAPI xglCreateShader(
1656 XGL_DEVICE device,
1657 const XGL_SHADER_CREATE_INFO* pCreateInfo,
1658 XGL_SHADER* pShader)
1659{
1660 struct nulldrv_dev *dev = nulldrv_dev(device);
1661
1662 return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader);
1663}
1664
1665ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(
1666 XGL_DEVICE device,
1667 const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
1668 XGL_DYNAMIC_VP_STATE_OBJECT* pState)
1669{
1670 struct nulldrv_dev *dev = nulldrv_dev(device);
1671
1672 return nulldrv_viewport_state_create(dev, pCreateInfo,
1673 (struct nulldrv_dynamic_vp **) pState);
1674}
1675
1676ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(
1677 XGL_DEVICE device,
1678 const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
1679 XGL_DYNAMIC_RS_STATE_OBJECT* pState)
1680{
1681 struct nulldrv_dev *dev = nulldrv_dev(device);
1682
1683 return nulldrv_raster_state_create(dev, pCreateInfo,
1684 (struct nulldrv_dynamic_rs **) pState);
1685}
1686
1687ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
1688 XGL_DEVICE device,
1689 const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
1690 XGL_DYNAMIC_CB_STATE_OBJECT* pState)
1691{
1692 struct nulldrv_dev *dev = nulldrv_dev(device);
1693
1694 return nulldrv_blend_state_create(dev, pCreateInfo,
1695 (struct nulldrv_dynamic_cb **) pState);
1696}
1697
1698ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
1699 XGL_DEVICE device,
1700 const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
1701 XGL_DYNAMIC_DS_STATE_OBJECT* pState)
1702{
1703 struct nulldrv_dev *dev = nulldrv_dev(device);
1704
1705 return nulldrv_ds_state_create(dev, pCreateInfo,
1706 (struct nulldrv_dynamic_ds **) pState);
1707}
1708
1709ICD_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(
1710 XGL_DEVICE device,
1711 const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
1712 XGL_BUFFER_VIEW* pView)
1713{
1714 return XGL_SUCCESS;
1715}
1716
1717ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
1718 XGL_DEVICE device,
1719 const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
1720 XGL_IMAGE_VIEW* pView)
1721{
1722 struct nulldrv_dev *dev = nulldrv_dev(device);
1723
1724 return nulldrv_img_view_create(dev, pCreateInfo,
1725 (struct nulldrv_img_view **) pView);
1726}
1727
1728ICD_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(
1729 XGL_DEVICE device,
1730 const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
1731 XGL_COLOR_ATTACHMENT_VIEW* pView)
1732{
1733 struct nulldrv_dev *dev = nulldrv_dev(device);
1734
1735 return nulldrv_rt_view_create(dev, pCreateInfo,
1736 (struct nulldrv_rt_view **) pView);
1737}
1738
1739ICD_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(
1740 XGL_DEVICE device,
1741 const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
1742 XGL_DEPTH_STENCIL_VIEW* pView)
1743{
1744 struct nulldrv_dev *dev = nulldrv_dev(device);
1745
1746 return nulldrv_ds_view_create(dev, pCreateInfo,
1747 (struct nulldrv_ds_view **) pView);
1748
1749}
1750
1751ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
1752 XGL_DEVICE device,
1753 XGL_FLAGS stageFlags,
1754 const uint32_t* pSetBindPoints,
1755 XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout,
1756 const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
1757 XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
1758{
1759 struct nulldrv_dev *dev = nulldrv_dev(device);
1760 struct nulldrv_desc_layout *prior_layout = nulldrv_desc_layout(priorSetLayout);
1761
1762 return nulldrv_desc_layout_create(dev, stageFlags, pSetBindPoints,
1763 prior_layout, pSetLayoutInfoList,
1764 (struct nulldrv_desc_layout **) pSetLayout);
1765}
1766
1767ICD_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorRegionUpdate(
1768 XGL_DEVICE device,
1769 XGL_DESCRIPTOR_UPDATE_MODE updateMode)
1770{
1771 return XGL_SUCCESS;
1772}
1773
1774ICD_EXPORT XGL_RESULT XGLAPI xglEndDescriptorRegionUpdate(
1775 XGL_DEVICE device,
1776 XGL_CMD_BUFFER cmd_)
1777{
1778 return XGL_SUCCESS;
1779}
1780
1781ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorRegion(
1782 XGL_DEVICE device,
1783 XGL_DESCRIPTOR_REGION_USAGE regionUsage,
1784 uint32_t maxSets,
1785 const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo,
1786 XGL_DESCRIPTOR_REGION* pDescriptorRegion)
1787{
1788 struct nulldrv_dev *dev = nulldrv_dev(device);
1789
1790 return nulldrv_desc_region_create(dev, regionUsage, maxSets, pCreateInfo,
1791 (struct nulldrv_desc_region **) pDescriptorRegion);
1792}
1793
1794ICD_EXPORT XGL_RESULT XGLAPI xglClearDescriptorRegion(
1795 XGL_DESCRIPTOR_REGION descriptorRegion)
1796{
1797 return XGL_SUCCESS;
1798}
1799
1800ICD_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(
1801 XGL_DESCRIPTOR_REGION descriptorRegion,
1802 XGL_DESCRIPTOR_SET_USAGE setUsage,
1803 uint32_t count,
1804 const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
1805 XGL_DESCRIPTOR_SET* pDescriptorSets,
1806 uint32_t* pCount)
1807{
1808 struct nulldrv_desc_region *region = nulldrv_desc_region(descriptorRegion);
1809 struct nulldrv_dev *dev = region->dev;
1810 XGL_RESULT ret = XGL_SUCCESS;
1811 uint32_t i;
1812
1813 for (i = 0; i < count; i++) {
1814 const struct nulldrv_desc_layout *layout =
1815 nulldrv_desc_layout((XGL_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]);
1816
1817 ret = nulldrv_desc_set_create(dev, region, setUsage, layout,
1818 (struct nulldrv_desc_set **) &pDescriptorSets[i]);
1819 if (ret != XGL_SUCCESS)
1820 break;
1821 }
1822
1823 if (pCount)
1824 *pCount = i;
1825
1826 return ret;
1827}
1828
1829ICD_EXPORT void XGLAPI xglClearDescriptorSets(
1830 XGL_DESCRIPTOR_REGION descriptorRegion,
1831 uint32_t count,
1832 const XGL_DESCRIPTOR_SET* pDescriptorSets)
1833{
1834}
1835
1836ICD_EXPORT void XGLAPI xglUpdateDescriptors(
1837 XGL_DESCRIPTOR_SET descriptorSet,
1838 const void* pUpdateChain)
1839{
1840}
1841
1842ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
1843 XGL_DEVICE device,
1844 const XGL_FRAMEBUFFER_CREATE_INFO* info,
1845 XGL_FRAMEBUFFER* fb_ret)
1846{
1847 struct nulldrv_dev *dev = nulldrv_dev(device);
1848
1849 return nulldrv_fb_create(dev, info, (struct nulldrv_framebuffer **) fb_ret);
1850}
1851
1852
1853ICD_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(
1854 XGL_DEVICE device,
1855 const XGL_RENDER_PASS_CREATE_INFO* info,
1856 XGL_RENDER_PASS* rp_ret)
1857{
1858 struct nulldrv_dev *dev = nulldrv_dev(device);
1859
1860 return nulldrv_render_pass_create(dev, info, (struct nulldrv_render_pass **) rp_ret);
1861}
1862
1863ICD_EXPORT void XGLAPI xglCmdBeginRenderPass(
1864 XGL_CMD_BUFFER cmdBuffer,
1865 XGL_RENDER_PASS renderPass)
1866{
1867}
1868
1869ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
1870 XGL_CMD_BUFFER cmdBuffer,
1871 XGL_RENDER_PASS renderPass)
1872{
1873}