1/*
2 * Copyright © 2014-2017 Broadcom
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24#include <xf86drm.h>
25#include <err.h>
26
27#include "pipe/p_defines.h"
28#include "util/hash_table.h"
29#include "util/ralloc.h"
30#include "util/u_inlines.h"
31#include "util/u_memory.h"
32#include "util/u_blitter.h"
33#include "util/u_upload_mgr.h"
34#include "indices/u_primconvert.h"
35#include "pipe/p_screen.h"
36
37#include "v3d_screen.h"
38#include "v3d_context.h"
39#include "v3d_resource.h"
40#include "broadcom/compiler/v3d_compiler.h"
41
42void
43v3d_flush(struct pipe_context *pctx)
44{
45        struct v3d_context *v3d = v3d_context(pctx);
46
47        hash_table_foreach(v3d->jobs, entry) {
48                struct v3d_job *job = entry->data;
49                v3d_job_submit(v3d, job);
50        }
51}
52
53static void
54v3d_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
55               unsigned flags)
56{
57        struct v3d_context *v3d = v3d_context(pctx);
58
59        v3d_flush(pctx);
60
61        if (fence) {
62                struct pipe_screen *screen = pctx->screen;
63                struct v3d_fence *f = v3d_fence_create(v3d);
64                screen->fence_reference(screen, fence, NULL);
65                *fence = (struct pipe_fence_handle *)f;
66        }
67}
68
69static void
70v3d_memory_barrier(struct pipe_context *pctx, unsigned int flags)
71{
72        struct v3d_context *v3d = v3d_context(pctx);
73
74	if (!(flags & ~PIPE_BARRIER_UPDATE))
75		return;
76
77        /* We only need to flush jobs writing to SSBOs/images. */
78        perf_debug("Flushing all jobs for glMemoryBarrier(), could do better");
79        v3d_flush(pctx);
80}
81
82static void
83v3d_set_debug_callback(struct pipe_context *pctx,
84                       const struct pipe_debug_callback *cb)
85{
86        struct v3d_context *v3d = v3d_context(pctx);
87
88        if (cb)
89                v3d->debug = *cb;
90        else
91                memset(&v3d->debug, 0, sizeof(v3d->debug));
92}
93
94static void
95v3d_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc)
96{
97        struct v3d_context *v3d = v3d_context(pctx);
98        struct v3d_resource *rsc = v3d_resource(prsc);
99
100        rsc->initialized_buffers = 0;
101
102        struct hash_entry *entry = _mesa_hash_table_search(v3d->write_jobs,
103                                                           prsc);
104        if (!entry)
105                return;
106
107        struct v3d_job *job = entry->data;
108        if (job->key.zsbuf && job->key.zsbuf->texture == prsc)
109                job->store &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL);
110}
111
112static void
113v3d_context_destroy(struct pipe_context *pctx)
114{
115        struct v3d_context *v3d = v3d_context(pctx);
116
117        v3d_flush(pctx);
118
119        if (v3d->blitter)
120                util_blitter_destroy(v3d->blitter);
121
122        if (v3d->primconvert)
123                util_primconvert_destroy(v3d->primconvert);
124
125        if (v3d->uploader)
126                u_upload_destroy(v3d->uploader);
127        if (v3d->state_uploader)
128                u_upload_destroy(v3d->state_uploader);
129
130        slab_destroy_child(&v3d->transfer_pool);
131
132        pipe_surface_reference(&v3d->framebuffer.cbufs[0], NULL);
133        pipe_surface_reference(&v3d->framebuffer.zsbuf, NULL);
134
135        v3d_program_fini(pctx);
136
137        ralloc_free(v3d);
138}
139
140static void
141v3d_get_sample_position(struct pipe_context *pctx,
142                        unsigned sample_count, unsigned sample_index,
143                        float *xy)
144{
145        struct v3d_context *v3d = v3d_context(pctx);
146
147        if (sample_count <= 1) {
148                xy[0] = 0.5;
149                xy[1] = 0.5;
150        } else {
151                static const int xoffsets_v33[] = { 1, -3, 3, -1 };
152                static const int xoffsets_v42[] = { -1, 3, -3, 1 };
153                const int *xoffsets = (v3d->screen->devinfo.ver >= 42 ?
154                                       xoffsets_v42 : xoffsets_v33);
155
156                xy[0] = 0.5 + xoffsets[sample_index] * .125;
157                xy[1] = .125 + sample_index * .25;
158        }
159}
160
161struct pipe_context *
162v3d_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags)
163{
164        struct v3d_screen *screen = v3d_screen(pscreen);
165        struct v3d_context *v3d;
166
167        /* Prevent dumping of the shaders built during context setup. */
168        uint32_t saved_shaderdb_flag = V3D_DEBUG & V3D_DEBUG_SHADERDB;
169        V3D_DEBUG &= ~V3D_DEBUG_SHADERDB;
170
171        v3d = rzalloc(NULL, struct v3d_context);
172        if (!v3d)
173                return NULL;
174        struct pipe_context *pctx = &v3d->base;
175
176        v3d->screen = screen;
177
178        int ret = drmSyncobjCreate(screen->fd, DRM_SYNCOBJ_CREATE_SIGNALED,
179                                   &v3d->out_sync);
180        if (ret) {
181                ralloc_free(v3d);
182                return NULL;
183        }
184
185        pctx->screen = pscreen;
186        pctx->priv = priv;
187        pctx->destroy = v3d_context_destroy;
188        pctx->flush = v3d_pipe_flush;
189        pctx->memory_barrier = v3d_memory_barrier;
190        pctx->set_debug_callback = v3d_set_debug_callback;
191        pctx->invalidate_resource = v3d_invalidate_resource;
192        pctx->get_sample_position = v3d_get_sample_position;
193
194        if (screen->devinfo.ver >= 41) {
195                v3d41_draw_init(pctx);
196                v3d41_state_init(pctx);
197        } else {
198                v3d33_draw_init(pctx);
199                v3d33_state_init(pctx);
200        }
201        v3d_program_init(pctx);
202        v3d_query_init(pctx);
203        v3d_resource_context_init(pctx);
204
205        v3d_job_init(v3d);
206
207        v3d->fd = screen->fd;
208
209        slab_create_child(&v3d->transfer_pool, &screen->transfer_pool);
210
211        v3d->uploader = u_upload_create_default(&v3d->base);
212        v3d->base.stream_uploader = v3d->uploader;
213        v3d->base.const_uploader = v3d->uploader;
214        v3d->state_uploader = u_upload_create(&v3d->base,
215                                              4096,
216                                              PIPE_BIND_CONSTANT_BUFFER,
217                                              PIPE_USAGE_STREAM, 0);
218
219        v3d->blitter = util_blitter_create(pctx);
220        if (!v3d->blitter)
221                goto fail;
222        v3d->blitter->use_index_buffer = true;
223
224        v3d->primconvert = util_primconvert_create(pctx,
225                                                   (1 << PIPE_PRIM_QUADS) - 1);
226        if (!v3d->primconvert)
227                goto fail;
228
229        V3D_DEBUG |= saved_shaderdb_flag;
230
231        v3d->sample_mask = (1 << V3D_MAX_SAMPLES) - 1;
232        v3d->active_queries = true;
233
234        return &v3d->base;
235
236fail:
237        pctx->destroy(pctx);
238        return NULL;
239}
240