1/*
2 * Copyright © 2014 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 "vc4_context.h"
25
26void
27vc4_emit_state(struct pipe_context *pctx)
28{
29        struct vc4_context *vc4 = vc4_context(pctx);
30        struct vc4_job *job = vc4->job;
31
32        struct vc4_cl_out *bcl = cl_start(&job->bcl);
33        if (vc4->dirty & (VC4_DIRTY_SCISSOR | VC4_DIRTY_VIEWPORT |
34                          VC4_DIRTY_RASTERIZER)) {
35                float *vpscale = vc4->viewport.scale;
36                float *vptranslate = vc4->viewport.translate;
37                float vp_minx = -fabsf(vpscale[0]) + vptranslate[0];
38                float vp_maxx = fabsf(vpscale[0]) + vptranslate[0];
39                float vp_miny = -fabsf(vpscale[1]) + vptranslate[1];
40                float vp_maxy = fabsf(vpscale[1]) + vptranslate[1];
41
42                /* Clip to the scissor if it's enabled, but still clip to the
43                 * drawable regardless since that controls where the binner
44                 * tries to put things.
45                 *
46                 * Additionally, always clip the rendering to the viewport,
47                 * since the hardware does guardband clipping, meaning
48                 * primitives would rasterize outside of the view volume.
49                 */
50                uint32_t minx, miny, maxx, maxy;
51                if (!vc4->rasterizer->base.scissor) {
52                        minx = MAX2(vp_minx, 0);
53                        miny = MAX2(vp_miny, 0);
54                        maxx = MIN2(vp_maxx, job->draw_width);
55                        maxy = MIN2(vp_maxy, job->draw_height);
56                } else {
57                        minx = MAX2(vp_minx, vc4->scissor.minx);
58                        miny = MAX2(vp_miny, vc4->scissor.miny);
59                        maxx = MIN2(vp_maxx, vc4->scissor.maxx);
60                        maxy = MIN2(vp_maxy, vc4->scissor.maxy);
61                }
62
63                cl_u8(&bcl, VC4_PACKET_CLIP_WINDOW);
64                cl_u16(&bcl, minx);
65                cl_u16(&bcl, miny);
66                cl_u16(&bcl, maxx - minx);
67                cl_u16(&bcl, maxy - miny);
68
69                job->draw_min_x = MIN2(job->draw_min_x, minx);
70                job->draw_min_y = MIN2(job->draw_min_y, miny);
71                job->draw_max_x = MAX2(job->draw_max_x, maxx);
72                job->draw_max_y = MAX2(job->draw_max_y, maxy);
73        }
74
75        if (vc4->dirty & (VC4_DIRTY_RASTERIZER |
76                          VC4_DIRTY_ZSA |
77                          VC4_DIRTY_COMPILED_FS)) {
78                uint8_t ez_enable_mask_out = ~0;
79                uint8_t rasosm_mask_out = ~0;
80
81                /* HW-2905: If the RCL ends up doing a full-res load when
82                 * multisampling, then early Z tracking may end up with values
83                 * from the previous tile due to a HW bug.  Disable it to
84                 * avoid that.
85                 *
86                 * We should be able to skip this when the Z is cleared, but I
87                 * was seeing bad rendering on glxgears -samples 4 even in
88                 * that case.
89                 */
90                if (job->msaa || vc4->prog.fs->disable_early_z)
91                        ez_enable_mask_out &= ~VC4_CONFIG_BITS_EARLY_Z;
92
93                /* Don't set the rasterizer to oversample if we're doing our
94                 * binning and load/stores in single-sample mode.  This is for
95                 * the samples == 1 case, where vc4 doesn't do any
96                 * multisampling behavior.
97                 */
98                if (!job->msaa) {
99                        rasosm_mask_out &=
100                                ~VC4_CONFIG_BITS_RASTERIZER_OVERSAMPLE_4X;
101                }
102
103                cl_u8(&bcl, VC4_PACKET_CONFIGURATION_BITS);
104                cl_u8(&bcl,
105                      (vc4->rasterizer->config_bits[0] |
106                       vc4->zsa->config_bits[0]) & rasosm_mask_out);
107                cl_u8(&bcl,
108                      vc4->rasterizer->config_bits[1] |
109                      vc4->zsa->config_bits[1]);
110                cl_u8(&bcl,
111                      (vc4->rasterizer->config_bits[2] |
112                       vc4->zsa->config_bits[2]) & ez_enable_mask_out);
113        }
114
115        if (vc4->dirty & VC4_DIRTY_RASTERIZER) {
116                cl_u8(&bcl, VC4_PACKET_DEPTH_OFFSET);
117                cl_u16(&bcl, vc4->rasterizer->offset_factor);
118                cl_u16(&bcl, vc4->rasterizer->offset_units);
119
120                cl_u8(&bcl, VC4_PACKET_POINT_SIZE);
121                cl_f(&bcl, vc4->rasterizer->point_size);
122
123                cl_u8(&bcl, VC4_PACKET_LINE_WIDTH);
124                cl_f(&bcl, vc4->rasterizer->base.line_width);
125        }
126
127        if (vc4->dirty & VC4_DIRTY_VIEWPORT) {
128                cl_u8(&bcl, VC4_PACKET_CLIPPER_XY_SCALING);
129                cl_f(&bcl, vc4->viewport.scale[0] * 16.0f);
130                cl_f(&bcl, vc4->viewport.scale[1] * 16.0f);
131
132                cl_u8(&bcl, VC4_PACKET_CLIPPER_Z_SCALING);
133                cl_f(&bcl, vc4->viewport.translate[2]);
134                cl_f(&bcl, vc4->viewport.scale[2]);
135
136                cl_u8(&bcl, VC4_PACKET_VIEWPORT_OFFSET);
137                cl_u16(&bcl, 16 * vc4->viewport.translate[0]);
138                cl_u16(&bcl, 16 * vc4->viewport.translate[1]);
139        }
140
141        if (vc4->dirty & VC4_DIRTY_FLAT_SHADE_FLAGS) {
142                cl_u8(&bcl, VC4_PACKET_FLAT_SHADE_FLAGS);
143                cl_u32(&bcl, vc4->rasterizer->base.flatshade ?
144                       vc4->prog.fs->color_inputs : 0);
145        }
146
147        cl_end(&job->bcl, bcl);
148}
149