1/*
2 * Copyright (c) 2011-2013 Luc Verhaegen <libv@skynet.be>
3 * Copyright (c) 2017-2019 Lima Project
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sub license,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * 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 NON-INFRINGEMENT. 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 "util/format/u_format.h"
27#include "util/u_debug.h"
28#include "util/u_draw.h"
29#include "util/half_float.h"
30#include "util/u_helpers.h"
31#include "util/u_inlines.h"
32#include "util/u_pack_color.h"
33#include "util/u_split_draw.h"
34#include "util/u_upload_mgr.h"
35#include "util/u_prim.h"
36#include "util/u_vbuf.h"
37#include "util/hash_table.h"
38
39#include "lima_context.h"
40#include "lima_screen.h"
41#include "lima_resource.h"
42#include "lima_program.h"
43#include "lima_bo.h"
44#include "lima_job.h"
45#include "lima_texture.h"
46#include "lima_util.h"
47#include "lima_gpu.h"
48
49#include "pan_minmax_cache.h"
50
51#include <drm-uapi/lima_drm.h>
52
53static void
54lima_clip_scissor_to_viewport(struct lima_context *ctx)
55{
56   struct lima_context_framebuffer *fb = &ctx->framebuffer;
57   struct pipe_scissor_state *cscissor = &ctx->clipped_scissor;
58   int viewport_left, viewport_right, viewport_bottom, viewport_top;
59
60   if (ctx->rasterizer && ctx->rasterizer->base.scissor) {
61      struct pipe_scissor_state *scissor = &ctx->scissor;
62      cscissor->minx = scissor->minx;
63      cscissor->maxx = scissor->maxx;
64      cscissor->miny = scissor->miny;
65      cscissor->maxy = scissor->maxy;
66   } else {
67      cscissor->minx = 0;
68      cscissor->maxx = fb->base.width;
69      cscissor->miny = 0;
70      cscissor->maxy = fb->base.height;
71   }
72
73   viewport_left = MAX2(ctx->viewport.left, 0);
74   cscissor->minx = MAX2(cscissor->minx, viewport_left);
75   viewport_right = MIN2(MAX2(ctx->viewport.right, 0), fb->base.width);
76   cscissor->maxx = MIN2(cscissor->maxx, viewport_right);
77   if (cscissor->minx > cscissor->maxx)
78      cscissor->minx = cscissor->maxx;
79
80   viewport_bottom = MAX2(ctx->viewport.bottom, 0);
81   cscissor->miny = MAX2(cscissor->miny, viewport_bottom);
82   viewport_top = MIN2(MAX2(ctx->viewport.top, 0), fb->base.height);
83   cscissor->maxy = MIN2(cscissor->maxy, viewport_top);
84   if (cscissor->miny > cscissor->maxy)
85      cscissor->miny = cscissor->maxy;
86}
87
88static void
89lima_extend_viewport(struct lima_context *ctx, const struct pipe_draw_info *info)
90{
91   /* restore the original values */
92   ctx->ext_viewport.left = ctx->viewport.left;
93   ctx->ext_viewport.right = ctx->viewport.right;
94   ctx->ext_viewport.bottom = ctx->viewport.bottom;
95   ctx->ext_viewport.top = ctx->viewport.top;
96
97   if (info->mode != PIPE_PRIM_LINES)
98      return;
99
100   if (!ctx->rasterizer)
101      return;
102
103   float line_width = ctx->rasterizer->base.line_width;
104
105   if (line_width == 1.0f)
106      return;
107
108   ctx->ext_viewport.left = ctx->viewport.left - line_width / 2;
109   ctx->ext_viewport.right = ctx->viewport.right + line_width / 2;
110   ctx->ext_viewport.bottom = ctx->viewport.bottom - line_width / 2;
111   ctx->ext_viewport.top = ctx->viewport.top + line_width / 2;
112}
113
114static bool
115lima_is_scissor_zero(struct lima_context *ctx)
116{
117   struct pipe_scissor_state *cscissor = &ctx->clipped_scissor;
118
119   return cscissor->minx == cscissor->maxx || cscissor->miny == cscissor->maxy;
120}
121
122static void
123lima_update_job_wb(struct lima_context *ctx, unsigned buffers)
124{
125   struct lima_job *job = lima_job_get(ctx);
126   struct lima_context_framebuffer *fb = &ctx->framebuffer;
127
128   /* add to job when the buffer is dirty and resolve is clear (not added before) */
129   if (fb->base.nr_cbufs && (buffers & PIPE_CLEAR_COLOR0) &&
130       !(job->resolve & PIPE_CLEAR_COLOR0)) {
131      struct lima_resource *res = lima_resource(fb->base.cbufs[0]->texture);
132      lima_flush_job_accessing_bo(ctx, res->bo, true);
133      _mesa_hash_table_insert(ctx->write_jobs, &res->base, job);
134      lima_job_add_bo(job, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
135   }
136
137   /* add to job when the buffer is dirty and resolve is clear (not added before) */
138   if (fb->base.zsbuf && (buffers & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)) &&
139       !(job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
140      struct lima_resource *res = lima_resource(fb->base.zsbuf->texture);
141      lima_flush_job_accessing_bo(ctx, res->bo, true);
142      _mesa_hash_table_insert(ctx->write_jobs, &res->base, job);
143      lima_job_add_bo(job, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
144   }
145
146   job->resolve |= buffers;
147}
148
149static void
150lima_clear(struct pipe_context *pctx, unsigned buffers, const struct pipe_scissor_state *scissor_state,
151           const union pipe_color_union *color, double depth, unsigned stencil)
152{
153   struct lima_context *ctx = lima_context(pctx);
154   struct lima_job *job = lima_job_get(ctx);
155
156   /* flush if this job already contains any draw, otherwise multi clear can be
157    * combined into a single job */
158   if (lima_job_has_draw_pending(job)) {
159      lima_do_job(job);
160      job = lima_job_get(ctx);
161   }
162
163   lima_update_job_wb(ctx, buffers);
164
165   /* no need to reload if cleared */
166   if (ctx->framebuffer.base.nr_cbufs && (buffers & PIPE_CLEAR_COLOR0)) {
167      struct lima_surface *surf = lima_surface(ctx->framebuffer.base.cbufs[0]);
168      surf->reload &= ~PIPE_CLEAR_COLOR0;
169   }
170
171   struct lima_job_clear *clear = &job->clear;
172   clear->buffers = buffers;
173
174   if (buffers & PIPE_CLEAR_COLOR0) {
175      clear->color_8pc =
176         ((uint32_t)float_to_ubyte(color->f[3]) << 24) |
177         ((uint32_t)float_to_ubyte(color->f[2]) << 16) |
178         ((uint32_t)float_to_ubyte(color->f[1]) << 8) |
179         float_to_ubyte(color->f[0]);
180
181      clear->color_16pc =
182         ((uint64_t)float_to_ushort(color->f[3]) << 48) |
183         ((uint64_t)float_to_ushort(color->f[2]) << 32) |
184         ((uint64_t)float_to_ushort(color->f[1]) << 16) |
185         float_to_ushort(color->f[0]);
186   }
187
188   struct lima_surface *zsbuf = lima_surface(ctx->framebuffer.base.zsbuf);
189
190   if (buffers & PIPE_CLEAR_DEPTH) {
191      clear->depth = util_pack_z(PIPE_FORMAT_Z24X8_UNORM, depth);
192      if (zsbuf)
193         zsbuf->reload &= ~PIPE_CLEAR_DEPTH;
194   }
195
196   if (buffers & PIPE_CLEAR_STENCIL) {
197      clear->stencil = stencil;
198      if (zsbuf)
199         zsbuf->reload &= ~PIPE_CLEAR_STENCIL;
200   }
201
202   ctx->dirty |= LIMA_CONTEXT_DIRTY_CLEAR;
203
204   lima_damage_rect_union(&job->damage_rect,
205                          0, ctx->framebuffer.base.width,
206                          0, ctx->framebuffer.base.height);
207}
208
209enum lima_attrib_type {
210   LIMA_ATTRIB_FLOAT = 0x000,
211   LIMA_ATTRIB_I32   = 0x001,
212   LIMA_ATTRIB_U32   = 0x002,
213   LIMA_ATTRIB_FP16  = 0x003,
214   LIMA_ATTRIB_I16   = 0x004,
215   LIMA_ATTRIB_U16   = 0x005,
216   LIMA_ATTRIB_I8    = 0x006,
217   LIMA_ATTRIB_U8    = 0x007,
218   LIMA_ATTRIB_I8N   = 0x008,
219   LIMA_ATTRIB_U8N   = 0x009,
220   LIMA_ATTRIB_I16N  = 0x00A,
221   LIMA_ATTRIB_U16N  = 0x00B,
222   LIMA_ATTRIB_I32N  = 0x00D,
223   LIMA_ATTRIB_U32N  = 0x00E,
224   LIMA_ATTRIB_FIXED = 0x101
225};
226
227static enum lima_attrib_type
228lima_pipe_format_to_attrib_type(enum pipe_format format)
229{
230   const struct util_format_description *desc = util_format_description(format);
231   int i = util_format_get_first_non_void_channel(format);
232   const struct util_format_channel_description *c = desc->channel + i;
233
234   switch (c->type) {
235   case UTIL_FORMAT_TYPE_FLOAT:
236      if (c->size == 16)
237         return LIMA_ATTRIB_FP16;
238      else
239         return LIMA_ATTRIB_FLOAT;
240   case UTIL_FORMAT_TYPE_FIXED:
241      return LIMA_ATTRIB_FIXED;
242   case UTIL_FORMAT_TYPE_SIGNED:
243      if (c->size == 8) {
244         if (c->normalized)
245            return LIMA_ATTRIB_I8N;
246         else
247            return LIMA_ATTRIB_I8;
248      }
249      else if (c->size == 16) {
250         if (c->normalized)
251            return LIMA_ATTRIB_I16N;
252         else
253            return LIMA_ATTRIB_I16;
254      }
255      else if (c->size == 32) {
256         if (c->normalized)
257            return LIMA_ATTRIB_I32N;
258         else
259            return LIMA_ATTRIB_I32;
260      }
261      break;
262   case UTIL_FORMAT_TYPE_UNSIGNED:
263      if (c->size == 8) {
264         if (c->normalized)
265            return LIMA_ATTRIB_U8N;
266         else
267            return LIMA_ATTRIB_U8;
268      }
269      else if (c->size == 16) {
270         if (c->normalized)
271            return LIMA_ATTRIB_U16N;
272         else
273            return LIMA_ATTRIB_U16;
274      }
275      else if (c->size == 32) {
276         if (c->normalized)
277            return LIMA_ATTRIB_U32N;
278         else
279            return LIMA_ATTRIB_U32;
280      }
281      break;
282   }
283
284   return LIMA_ATTRIB_FLOAT;
285}
286
287static void
288lima_pack_vs_cmd(struct lima_context *ctx, const struct pipe_draw_info *info,
289                 const struct pipe_draw_start_count_bias *draw)
290{
291   struct lima_context_constant_buffer *ccb =
292      ctx->const_buffer + PIPE_SHADER_VERTEX;
293   struct lima_vs_compiled_shader *vs = ctx->vs;
294   struct lima_job *job = lima_job_get(ctx);
295
296   VS_CMD_BEGIN(&job->vs_cmd_array, 24);
297
298   if (!info->index_size) {
299      VS_CMD_ARRAYS_SEMAPHORE_BEGIN_1();
300      VS_CMD_ARRAYS_SEMAPHORE_BEGIN_2();
301   }
302   int uniform_size = MIN2(vs->state.uniform_size, ccb->size);
303
304   int size = uniform_size + vs->state.constant_size + 32;
305   VS_CMD_UNIFORMS_ADDRESS(
306      lima_ctx_buff_va(ctx, lima_ctx_buff_gp_uniform),
307      align(size, 16));
308
309   VS_CMD_SHADER_ADDRESS(ctx->vs->bo->va, ctx->vs->state.shader_size);
310   VS_CMD_SHADER_INFO(ctx->vs->state.prefetch, ctx->vs->state.shader_size);
311
312   int num_outputs = ctx->vs->state.num_outputs;
313   int num_attributes = ctx->vertex_elements->num_elements;
314   VS_CMD_VARYING_ATTRIBUTE_COUNT(num_outputs, MAX2(1, num_attributes));
315
316   VS_CMD_UNKNOWN1();
317
318   VS_CMD_ATTRIBUTES_ADDRESS(
319      lima_ctx_buff_va(ctx, lima_ctx_buff_gp_attribute_info),
320      MAX2(1, num_attributes));
321
322   VS_CMD_VARYINGS_ADDRESS(
323      lima_ctx_buff_va(ctx, lima_ctx_buff_gp_varying_info),
324      num_outputs);
325
326   unsigned num = info->index_size ? (ctx->max_index - ctx->min_index + 1) : draw->count;
327   VS_CMD_DRAW(num, info->index_size);
328
329   VS_CMD_UNKNOWN2();
330
331   VS_CMD_ARRAYS_SEMAPHORE_END(info->index_size);
332
333   VS_CMD_END();
334}
335
336static void
337lima_pack_plbu_cmd(struct lima_context *ctx, const struct pipe_draw_info *info,
338                   const struct pipe_draw_start_count_bias *draw)
339{
340   struct lima_vs_compiled_shader *vs = ctx->vs;
341   struct pipe_scissor_state *cscissor = &ctx->clipped_scissor;
342   struct lima_job *job = lima_job_get(ctx);
343   PLBU_CMD_BEGIN(&job->plbu_cmd_array, 32);
344
345   PLBU_CMD_VIEWPORT_LEFT(fui(ctx->ext_viewport.left));
346   PLBU_CMD_VIEWPORT_RIGHT(fui(ctx->ext_viewport.right));
347   PLBU_CMD_VIEWPORT_BOTTOM(fui(ctx->ext_viewport.bottom));
348   PLBU_CMD_VIEWPORT_TOP(fui(ctx->ext_viewport.top));
349
350   if (!info->index_size)
351      PLBU_CMD_ARRAYS_SEMAPHORE_BEGIN();
352
353   int cf = ctx->rasterizer->base.cull_face;
354   int ccw = ctx->rasterizer->base.front_ccw;
355   uint32_t cull = 0;
356   bool force_point_size = false;
357
358   if (cf != PIPE_FACE_NONE) {
359      if (cf & PIPE_FACE_FRONT)
360         cull |= ccw ? 0x00040000 : 0x00020000;
361      if (cf & PIPE_FACE_BACK)
362         cull |= ccw ? 0x00020000 : 0x00040000;
363   }
364
365   /* Specify point size with PLBU command if shader doesn't write */
366   if (info->mode == PIPE_PRIM_POINTS && ctx->vs->state.point_size_idx == -1)
367      force_point_size = true;
368
369   /* Specify line width with PLBU command for lines */
370   if (info->mode > PIPE_PRIM_POINTS && info->mode < PIPE_PRIM_TRIANGLES)
371      force_point_size = true;
372
373   PLBU_CMD_PRIMITIVE_SETUP(force_point_size, cull, info->index_size);
374
375   PLBU_CMD_RSW_VERTEX_ARRAY(
376      lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw),
377      ctx->gp_output->va);
378
379   /* TODO
380    * - we should set it only for the first draw that enabled the scissor and for
381    *   latter draw only if scissor is dirty
382    */
383
384   assert(cscissor->minx < cscissor->maxx && cscissor->miny < cscissor->maxy);
385   PLBU_CMD_SCISSORS(cscissor->minx, cscissor->maxx, cscissor->miny, cscissor->maxy);
386
387   lima_damage_rect_union(&job->damage_rect, cscissor->minx, cscissor->maxx,
388                          cscissor->miny, cscissor->maxy);
389
390   PLBU_CMD_UNKNOWN1();
391
392   PLBU_CMD_DEPTH_RANGE_NEAR(fui(ctx->viewport.near));
393   PLBU_CMD_DEPTH_RANGE_FAR(fui(ctx->viewport.far));
394
395   if ((info->mode == PIPE_PRIM_POINTS && ctx->vs->state.point_size_idx == -1) ||
396       ((info->mode >= PIPE_PRIM_LINES) && (info->mode < PIPE_PRIM_TRIANGLES)))
397   {
398      uint32_t v = info->mode == PIPE_PRIM_POINTS ?
399         fui(ctx->rasterizer->base.point_size) : fui(ctx->rasterizer->base.line_width);
400      PLBU_CMD_LOW_PRIM_SIZE(v);
401   }
402
403   if (info->index_size) {
404      PLBU_CMD_INDEXED_DEST(ctx->gp_output->va);
405      if (vs->state.point_size_idx != -1)
406         PLBU_CMD_INDEXED_PT_SIZE(ctx->gp_output->va + ctx->gp_output_point_size_offt);
407
408      PLBU_CMD_INDICES(ctx->index_res->bo->va + draw->start * info->index_size + ctx->index_offset);
409   }
410   else {
411      /* can this make the attribute info static? */
412      PLBU_CMD_DRAW_ARRAYS(info->mode, draw->start, draw->count);
413   }
414
415   PLBU_CMD_ARRAYS_SEMAPHORE_END();
416
417   if (info->index_size)
418      PLBU_CMD_DRAW_ELEMENTS(info->mode, ctx->min_index, draw->count);
419
420   PLBU_CMD_END();
421}
422
423static int
424lima_blend_func(enum pipe_blend_func pipe)
425{
426   switch (pipe) {
427   case PIPE_BLEND_ADD:
428      return 2;
429   case PIPE_BLEND_SUBTRACT:
430      return 0;
431   case PIPE_BLEND_REVERSE_SUBTRACT:
432      return 1;
433   case PIPE_BLEND_MIN:
434      return 4;
435   case PIPE_BLEND_MAX:
436      return 5;
437   }
438   return -1;
439}
440
441static int
442lima_blend_factor(enum pipe_blendfactor pipe)
443{
444   /* Bits 0-2 indicate the blendfactor type,
445    * Bit 3 is set if blendfactor is inverted
446    * Bit 4 is set if blendfactor has alpha */
447   switch (pipe) {
448   case PIPE_BLENDFACTOR_SRC_COLOR:
449      return 0 << 4 | 0 << 3 | 0;
450   case PIPE_BLENDFACTOR_SRC_ALPHA:
451      return 1 << 4 | 0 << 3 | 0;
452   case PIPE_BLENDFACTOR_INV_SRC_COLOR:
453      return 0 << 4 | 1 << 3 | 0;
454   case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
455      return 1 << 4 | 1 << 3 | 0;
456
457   case PIPE_BLENDFACTOR_DST_COLOR:
458      return 0 << 4 | 0 << 3 | 1;
459   case PIPE_BLENDFACTOR_DST_ALPHA:
460      return 1 << 4 | 0 << 3 | 1;
461   case PIPE_BLENDFACTOR_INV_DST_COLOR:
462      return 0 << 4 | 1 << 3 | 1;
463   case PIPE_BLENDFACTOR_INV_DST_ALPHA:
464      return 1 << 4 | 1 << 3 | 1;
465
466   case PIPE_BLENDFACTOR_CONST_COLOR:
467      return 0 << 4 | 0 << 3 | 2;
468   case PIPE_BLENDFACTOR_CONST_ALPHA:
469      return 1 << 4 | 0 << 3 | 2;
470   case PIPE_BLENDFACTOR_INV_CONST_COLOR:
471      return 0 << 4 | 1 << 3 | 2;
472   case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
473      return 1 << 4 | 1 << 3 | 2;
474
475   case PIPE_BLENDFACTOR_ZERO:
476      return 0 << 4 | 0 << 3 | 3;
477   case PIPE_BLENDFACTOR_ONE:
478      return 0 << 4 | 1 << 3 | 3;
479
480   case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
481      return 0 << 4 | 0 << 3 | 4;
482
483   case PIPE_BLENDFACTOR_SRC1_COLOR:
484      return 0 << 4 | 0 << 3 | 5;
485   case PIPE_BLENDFACTOR_SRC1_ALPHA:
486      return 1 << 4 | 0 << 3 | 5;
487   case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
488      return 0 << 4 | 1 << 3 | 5;
489   case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
490      return 1 << 4 | 1 << 3 | 5;
491   }
492   return -1;
493}
494
495static int
496lima_calculate_alpha_blend(enum pipe_blend_func rgb_func, enum pipe_blend_func alpha_func,
497                           enum pipe_blendfactor rgb_src_factor, enum pipe_blendfactor rgb_dst_factor,
498                           enum pipe_blendfactor alpha_src_factor, enum pipe_blendfactor alpha_dst_factor)
499{
500   /* PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE has to be changed to PIPE_BLENDFACTOR_ONE
501    * if it is set for alpha_src or alpha_dst.
502    */
503   if (alpha_src_factor == PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE)
504      alpha_src_factor = PIPE_BLENDFACTOR_ONE;
505
506   if (alpha_dst_factor == PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE)
507      alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
508
509   /* MIN and MAX ops actually do OP(As * S + Ad * D, Ad), so
510    * we need to set S to 1 and D to 0 to get correct result */
511   if (alpha_func == PIPE_BLEND_MIN ||
512       alpha_func == PIPE_BLEND_MAX) {
513      alpha_src_factor = PIPE_BLENDFACTOR_ONE;
514      alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
515   }
516
517   /* MIN and MAX ops actually do OP(Cs * S + Cd * D, Cd), so
518    * we need to set S to 1 and D to 0 to get correct result */
519   if (rgb_func == PIPE_BLEND_MIN ||
520       rgb_func == PIPE_BLEND_MAX) {
521      rgb_src_factor = PIPE_BLENDFACTOR_ONE;
522      rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
523   }
524
525   return lima_blend_func(rgb_func) |
526      (lima_blend_func(alpha_func) << 3) |
527      (lima_blend_factor(rgb_src_factor) << 6) |
528      (lima_blend_factor(rgb_dst_factor) << 11) |
529      /* alpha_src and alpha_dst are 4 bit, so need to mask 5th bit */
530      ((lima_blend_factor(alpha_src_factor) & 0xf) << 16) |
531      ((lima_blend_factor(alpha_dst_factor) & 0xf) << 20) |
532      0x0C000000; /* need to check if this is GLESv1 glAlphaFunc */
533}
534
535static int
536lima_stencil_op(enum pipe_stencil_op pipe)
537{
538   switch (pipe) {
539   case PIPE_STENCIL_OP_KEEP:
540      return 0;
541   case PIPE_STENCIL_OP_ZERO:
542      return 2;
543   case PIPE_STENCIL_OP_REPLACE:
544      return 1;
545   case PIPE_STENCIL_OP_INCR:
546      return 6;
547   case PIPE_STENCIL_OP_DECR:
548      return 7;
549   case PIPE_STENCIL_OP_INCR_WRAP:
550      return 4;
551   case PIPE_STENCIL_OP_DECR_WRAP:
552      return 5;
553   case PIPE_STENCIL_OP_INVERT:
554      return 3;
555   }
556   return -1;
557}
558
559static unsigned
560lima_calculate_depth_test(struct pipe_depth_stencil_alpha_state *depth,
561                          struct pipe_rasterizer_state *rst)
562{
563   int offset_scale = 0, offset_units = 0;
564   enum pipe_compare_func func = (depth->depth_enabled ? depth->depth_func : PIPE_FUNC_ALWAYS);
565
566   offset_scale = CLAMP(rst->offset_scale * 4, -128, 127);
567   if (offset_scale < 0)
568      offset_scale += 0x100;
569
570   offset_units = CLAMP(rst->offset_units * 2, -128, 127);
571   if (offset_units < 0)
572      offset_units += 0x100;
573
574   return (depth->depth_enabled && depth->depth_writemask) |
575      ((int)func << 1) |
576      (offset_scale << 16) |
577      (offset_units << 24);
578}
579
580static void
581lima_pack_render_state(struct lima_context *ctx, const struct pipe_draw_info *info)
582{
583   struct lima_fs_compiled_shader *fs = ctx->fs;
584   struct lima_render_state *render =
585      lima_ctx_buff_alloc(ctx, lima_ctx_buff_pp_plb_rsw,
586                          sizeof(*render));
587   bool early_z = true;
588   bool pixel_kill = true;
589
590   /* do hw support RGBA independ blend?
591    * PIPE_CAP_INDEP_BLEND_ENABLE
592    *
593    * how to handle the no cbuf only zbuf case?
594    */
595   struct pipe_rt_blend_state *rt = ctx->blend->base.rt;
596   render->blend_color_bg = float_to_ubyte(ctx->blend_color.color[2]) |
597      (float_to_ubyte(ctx->blend_color.color[1]) << 16);
598   render->blend_color_ra = float_to_ubyte(ctx->blend_color.color[0]) |
599      (float_to_ubyte(ctx->blend_color.color[3]) << 16);
600
601   if (rt->blend_enable) {
602      render->alpha_blend = lima_calculate_alpha_blend(rt->rgb_func, rt->alpha_func,
603         rt->rgb_src_factor, rt->rgb_dst_factor,
604         rt->alpha_src_factor, rt->alpha_dst_factor);
605   }
606   else {
607      /*
608       * Special handling for blending disabled.
609       * Binary driver is generating the same alpha_value,
610       * as when we would just enable blending, without changing/setting any blend equation/params.
611       * Normaly in this case mesa would set all rt fields (func/factor) to zero.
612       */
613      render->alpha_blend = lima_calculate_alpha_blend(PIPE_BLEND_ADD, PIPE_BLEND_ADD,
614         PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ZERO,
615         PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ZERO);
616   }
617
618   render->alpha_blend |= (rt->colormask & PIPE_MASK_RGBA) << 28;
619
620   struct pipe_rasterizer_state *rst = &ctx->rasterizer->base;
621   render->depth_test = lima_calculate_depth_test(&ctx->zsa->base, rst);
622
623   if (!rst->depth_clip_near || ctx->viewport.near == 0.0f)
624      render->depth_test |= 0x10; /* don't clip depth near */
625   if (!rst->depth_clip_far || ctx->viewport.far == 1.0f)
626      render->depth_test |= 0x20; /* don't clip depth far */
627
628   if (fs->state.frag_depth_reg != -1) {
629      render->depth_test |= (fs->state.frag_depth_reg << 6);
630      /* Shader writes depth */
631      render->depth_test |= 0x801;
632   }
633
634   ushort far, near;
635
636   near = float_to_ushort(ctx->viewport.near);
637   far = float_to_ushort(ctx->viewport.far);
638
639   /* overlap with plbu? any place can remove one? */
640   render->depth_range = near | (far << 16);
641
642   struct pipe_stencil_state *stencil = ctx->zsa->base.stencil;
643   struct pipe_stencil_ref *ref = &ctx->stencil_ref;
644
645   if (stencil[0].enabled) { /* stencil is enabled */
646      render->stencil_front = stencil[0].func |
647         (lima_stencil_op(stencil[0].fail_op) << 3) |
648         (lima_stencil_op(stencil[0].zfail_op) << 6) |
649         (lima_stencil_op(stencil[0].zpass_op) << 9) |
650         (ref->ref_value[0] << 16) |
651         (stencil[0].valuemask << 24);
652      render->stencil_back = render->stencil_front;
653      render->stencil_test = (stencil[0].writemask & 0xff) | (stencil[0].writemask & 0xff) << 8;
654      if (stencil[1].enabled) { /* two-side is enabled */
655         render->stencil_back = stencil[1].func |
656            (lima_stencil_op(stencil[1].fail_op) << 3) |
657            (lima_stencil_op(stencil[1].zfail_op) << 6) |
658            (lima_stencil_op(stencil[1].zpass_op) << 9) |
659            (ref->ref_value[1] << 16) |
660            (stencil[1].valuemask << 24);
661         render->stencil_test = (stencil[0].writemask & 0xff) | (stencil[1].writemask & 0xff) << 8;
662      }
663      /* TODO: Find out, what (render->stecil_test & 0xff000000) is */
664   }
665   else {
666      /* Default values, when stencil is disabled:
667       * stencil[0|1].valuemask = 0xff
668       * stencil[0|1].func = PIPE_FUNC_ALWAYS
669       * stencil[0|1].writemask = 0xff
670       */
671      render->stencil_front = 0xff000007;
672      render->stencil_back = 0xff000007;
673      render->stencil_test = 0x0000ffff;
674   }
675
676   /* need more investigation */
677   if (info->mode == PIPE_PRIM_POINTS)
678      render->multi_sample = 0x00000000;
679   else if (info->mode < PIPE_PRIM_TRIANGLES)
680      render->multi_sample = 0x00000400;
681   else
682      render->multi_sample = 0x00000800;
683   if (ctx->framebuffer.base.samples)
684      render->multi_sample |= 0x68;
685   if (ctx->blend->base.alpha_to_coverage)
686      render->multi_sample |= (1 << 7);
687   if (ctx->blend->base.alpha_to_one)
688      render->multi_sample |= (1 << 8);
689   render->multi_sample |= (ctx->sample_mask << 12);
690
691   /* Set gl_FragColor register, need to specify it 4 times */
692   render->multi_sample |= (fs->state.frag_color0_reg << 28) |
693                           (fs->state.frag_color0_reg << 24) |
694                           (fs->state.frag_color0_reg << 20) |
695                           (fs->state.frag_color0_reg << 16);
696
697   /* alpha test */
698   if (ctx->zsa->base.alpha_enabled) {
699      render->multi_sample |= ctx->zsa->base.alpha_func;
700      render->stencil_test |= float_to_ubyte(ctx->zsa->base.alpha_ref_value) << 16;
701   } else {
702      /* func = PIPE_FUNC_ALWAYS */
703      render->multi_sample |= 0x7;
704   }
705
706   render->shader_address =
707      ctx->fs->bo->va | (((uint32_t *)ctx->fs->bo->map)[0] & 0x1F);
708
709   /* seems not needed */
710   render->uniforms_address = 0x00000000;
711
712   render->textures_address = 0x00000000;
713
714   render->aux0 = (ctx->vs->state.varying_stride >> 3);
715   render->aux1 = 0x00000000;
716   if (ctx->rasterizer->base.front_ccw)
717      render->aux1 = 0x00001000;
718
719   if (ctx->blend->base.dither)
720      render->aux1 |= 0x00002000;
721
722   if (fs->state.uses_discard ||
723       ctx->zsa->base.alpha_enabled ||
724       fs->state.frag_depth_reg != -1 ||
725       ctx->blend->base.alpha_to_coverage) {
726      early_z = false;
727      pixel_kill = false;
728   }
729
730   if (rt->blend_enable)
731      pixel_kill = false;
732
733   if ((rt->colormask & PIPE_MASK_RGBA) != PIPE_MASK_RGBA)
734      pixel_kill = false;
735
736   if (early_z)
737      render->aux0 |= 0x300;
738
739   if (pixel_kill)
740      render->aux0 |= 0x1000;
741
742   if (ctx->tex_stateobj.num_samplers) {
743      render->textures_address =
744         lima_ctx_buff_va(ctx, lima_ctx_buff_pp_tex_desc);
745      render->aux0 |= ctx->tex_stateobj.num_samplers << 14;
746      render->aux0 |= 0x20;
747   }
748
749   if (ctx->const_buffer[PIPE_SHADER_FRAGMENT].buffer) {
750      render->uniforms_address =
751         lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform_array);
752      uint32_t size = ctx->buffer_state[lima_ctx_buff_pp_uniform].size;
753      uint32_t bits = 0;
754      if (size >= 8) {
755         bits = util_last_bit(size >> 3) - 1;
756         bits += size & u_bit_consecutive(0, bits + 3) ? 1 : 0;
757      }
758      render->uniforms_address |= bits > 0xf ? 0xf : bits;
759
760      render->aux0 |= 0x80;
761      render->aux1 |= 0x10000;
762   }
763
764   /* Set secondary output color */
765   if (fs->state.frag_color1_reg != -1)
766      render->aux0 |= (fs->state.frag_color1_reg << 28);
767
768   if (ctx->vs->state.num_varyings) {
769      render->varying_types = 0x00000000;
770      render->varyings_address = ctx->gp_output->va +
771                                 ctx->gp_output_varyings_offt;
772      for (int i = 0, index = 0; i < ctx->vs->state.num_outputs; i++) {
773         int val;
774
775         if (i == ctx->vs->state.gl_pos_idx ||
776             i == ctx->vs->state.point_size_idx)
777            continue;
778
779         struct lima_varying_info *v = ctx->vs->state.varying + i;
780         if (v->component_size == 4)
781            val = v->components > 2 ? 0 : 1;
782         else
783            val = v->components > 2 ? 2 : 3;
784
785         if (index < 10)
786            render->varying_types |= val << (3 * index);
787         else if (index == 10) {
788            render->varying_types |= val << 30;
789            render->varyings_address |= val >> 2;
790         }
791         else if (index == 11)
792            render->varyings_address |= val << 1;
793
794         index++;
795      }
796   }
797   else {
798      render->varying_types = 0x00000000;
799      render->varyings_address = 0x00000000;
800   }
801
802   struct lima_job *job = lima_job_get(ctx);
803
804   lima_dump_command_stream_print(
805      job->dump, render, sizeof(*render),
806      false, "add render state at va %x\n",
807      lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw));
808
809   lima_dump_rsw_command_stream_print(
810      job->dump, render, sizeof(*render),
811      lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw));
812}
813
814static void
815lima_update_gp_attribute_info(struct lima_context *ctx, const struct pipe_draw_info *info,
816                              const struct pipe_draw_start_count_bias *draw)
817{
818   struct lima_job *job = lima_job_get(ctx);
819   struct lima_vertex_element_state *ve = ctx->vertex_elements;
820   struct lima_context_vertex_buffer *vb = &ctx->vertex_buffers;
821
822   uint32_t *attribute =
823      lima_ctx_buff_alloc(ctx, lima_ctx_buff_gp_attribute_info,
824                          MAX2(1, ve->num_elements) * 8);
825
826   int n = 0;
827   for (int i = 0; i < ve->num_elements; i++) {
828      struct pipe_vertex_element *pve = ve->pipe + i;
829
830      assert(pve->vertex_buffer_index < vb->count);
831      assert(vb->enabled_mask & (1 << pve->vertex_buffer_index));
832
833      struct pipe_vertex_buffer *pvb = vb->vb + pve->vertex_buffer_index;
834      struct lima_resource *res = lima_resource(pvb->buffer.resource);
835
836      lima_job_add_bo(job, LIMA_PIPE_GP, res->bo, LIMA_SUBMIT_BO_READ);
837
838      unsigned start = info->index_size ? (ctx->min_index + draw->index_bias) : draw->start;
839      attribute[n++] = res->bo->va + pvb->buffer_offset + pve->src_offset
840         + start * pvb->stride;
841      attribute[n++] = (pvb->stride << 11) |
842         (lima_pipe_format_to_attrib_type(pve->src_format) << 2) |
843         (util_format_get_nr_components(pve->src_format) - 1);
844   }
845
846   lima_dump_command_stream_print(
847      job->dump, attribute, n * 4, false, "update attribute info at va %x\n",
848      lima_ctx_buff_va(ctx, lima_ctx_buff_gp_attribute_info));
849}
850
851static void
852lima_update_gp_uniform(struct lima_context *ctx)
853{
854   struct lima_context_constant_buffer *ccb =
855      ctx->const_buffer + PIPE_SHADER_VERTEX;
856   struct lima_vs_compiled_shader *vs = ctx->vs;
857   int uniform_size = MIN2(vs->state.uniform_size, ccb->size);
858
859   int size = uniform_size + vs->state.constant_size + 32;
860   void *vs_const_buff =
861      lima_ctx_buff_alloc(ctx, lima_ctx_buff_gp_uniform, size);
862
863   if (ccb->buffer)
864      memcpy(vs_const_buff, ccb->buffer, uniform_size);
865
866   memcpy(vs_const_buff + uniform_size,
867          ctx->viewport.transform.scale,
868          sizeof(ctx->viewport.transform.scale));
869   memcpy(vs_const_buff + uniform_size + 16,
870          ctx->viewport.transform.translate,
871          sizeof(ctx->viewport.transform.translate));
872
873   if (vs->constant)
874      memcpy(vs_const_buff + uniform_size + 32,
875             vs->constant, vs->state.constant_size);
876
877   struct lima_job *job = lima_job_get(ctx);
878
879   if (lima_debug & LIMA_DEBUG_GP) {
880      float *vs_const_buff_f = vs_const_buff;
881      printf("gp uniforms:\n");
882      for (int i = 0; i < (size / sizeof(float)); i++) {
883         if ((i % 4) == 0)
884            printf("%4d:", i / 4);
885         printf(" %8.4f", vs_const_buff_f[i]);
886         if ((i % 4) == 3)
887            printf("\n");
888      }
889      printf("\n");
890   }
891
892   lima_dump_command_stream_print(
893      job->dump, vs_const_buff, size, true,
894      "update gp uniform at va %x\n",
895      lima_ctx_buff_va(ctx, lima_ctx_buff_gp_uniform));
896}
897
898static void
899lima_update_pp_uniform(struct lima_context *ctx)
900{
901   const float *const_buff = ctx->const_buffer[PIPE_SHADER_FRAGMENT].buffer;
902   size_t const_buff_size = ctx->const_buffer[PIPE_SHADER_FRAGMENT].size / sizeof(float);
903
904   if (!const_buff)
905      return;
906
907   uint16_t *fp16_const_buff =
908      lima_ctx_buff_alloc(ctx, lima_ctx_buff_pp_uniform,
909                          const_buff_size * sizeof(uint16_t));
910
911   uint32_t *array =
912      lima_ctx_buff_alloc(ctx, lima_ctx_buff_pp_uniform_array, 4);
913
914   for (int i = 0; i < const_buff_size; i++)
915       fp16_const_buff[i] = _mesa_float_to_half(const_buff[i]);
916
917   *array = lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform);
918
919   struct lima_job *job = lima_job_get(ctx);
920
921   lima_dump_command_stream_print(
922      job->dump, fp16_const_buff, const_buff_size * 2,
923      false, "add pp uniform data at va %x\n",
924      lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform));
925   lima_dump_command_stream_print(
926      job->dump, array, 4, false, "add pp uniform info at va %x\n",
927      lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform_array));
928}
929
930static void
931lima_update_varying(struct lima_context *ctx, const struct pipe_draw_info *info,
932                    const struct pipe_draw_start_count_bias *draw)
933{
934   struct lima_job *job = lima_job_get(ctx);
935   struct lima_screen *screen = lima_screen(ctx->base.screen);
936   struct lima_vs_compiled_shader *vs = ctx->vs;
937   uint32_t gp_output_size;
938   unsigned num = info->index_size ? (ctx->max_index - ctx->min_index + 1) : draw->count;
939
940   uint32_t *varying =
941      lima_ctx_buff_alloc(ctx, lima_ctx_buff_gp_varying_info,
942                          vs->state.num_outputs * 8);
943   int n = 0;
944
945   int offset = 0;
946
947   for (int i = 0; i < vs->state.num_outputs; i++) {
948      struct lima_varying_info *v = vs->state.varying + i;
949
950      if (i == vs->state.gl_pos_idx ||
951          i == vs->state.point_size_idx)
952         continue;
953
954      int size = v->component_size * 4;
955
956      /* does component_size == 2 need to be 16 aligned? */
957      if (v->component_size == 4)
958         offset = align(offset, 16);
959
960      v->offset = offset;
961      offset += size;
962   }
963
964   vs->state.varying_stride = align(offset, 16);
965
966   /* gl_Position is always present, allocate space for it */
967   gp_output_size = align(4 * 4 * num, 0x40);
968
969   /* Allocate space for varyings if there're any */
970   if (vs->state.num_varyings) {
971      ctx->gp_output_varyings_offt = gp_output_size;
972      gp_output_size += align(vs->state.varying_stride * num, 0x40);
973   }
974
975   /* Allocate space for gl_PointSize if it's there */
976   if (vs->state.point_size_idx != -1) {
977      ctx->gp_output_point_size_offt = gp_output_size;
978      gp_output_size += 4 * num;
979   }
980
981   /* gp_output can be too large for the suballocator, so create a
982    * separate bo for it. The bo cache should prevent performance hit.
983    */
984   ctx->gp_output = lima_bo_create(screen, gp_output_size, 0);
985   assert(ctx->gp_output);
986   lima_job_add_bo(job, LIMA_PIPE_GP, ctx->gp_output, LIMA_SUBMIT_BO_WRITE);
987   lima_job_add_bo(job, LIMA_PIPE_PP, ctx->gp_output, LIMA_SUBMIT_BO_READ);
988
989   for (int i = 0; i < vs->state.num_outputs; i++) {
990      struct lima_varying_info *v = vs->state.varying + i;
991
992      if (i == vs->state.gl_pos_idx) {
993         /* gl_Position */
994         varying[n++] = ctx->gp_output->va;
995         varying[n++] = 0x8020;
996      } else if (i == vs->state.point_size_idx) {
997         /* gl_PointSize */
998         varying[n++] = ctx->gp_output->va + ctx->gp_output_point_size_offt;
999         varying[n++] = 0x2021;
1000      } else {
1001         /* Varying */
1002         varying[n++] = ctx->gp_output->va + ctx->gp_output_varyings_offt +
1003                        v->offset;
1004         varying[n++] = (vs->state.varying_stride << 11) | (v->components - 1) |
1005            (v->component_size == 2 ? 0x0C : 0);
1006      }
1007   }
1008
1009   lima_dump_command_stream_print(
1010      job->dump, varying, n * 4, false, "update varying info at va %x\n",
1011      lima_ctx_buff_va(ctx, lima_ctx_buff_gp_varying_info));
1012}
1013
1014static void
1015lima_draw_vbo_update(struct pipe_context *pctx,
1016                     const struct pipe_draw_info *info,
1017                     const struct pipe_draw_start_count_bias *draw)
1018{
1019   struct lima_context *ctx = lima_context(pctx);
1020   struct lima_context_framebuffer *fb = &ctx->framebuffer;
1021   unsigned buffers = 0;
1022
1023   if (fb->base.zsbuf) {
1024      if (ctx->zsa->base.depth_enabled)
1025         buffers |= PIPE_CLEAR_DEPTH;
1026      if (ctx->zsa->base.stencil[0].enabled ||
1027          ctx->zsa->base.stencil[1].enabled)
1028         buffers |= PIPE_CLEAR_STENCIL;
1029   }
1030
1031   if (fb->base.nr_cbufs)
1032      buffers |= PIPE_CLEAR_COLOR0;
1033
1034   lima_update_job_wb(ctx, buffers);
1035
1036   lima_update_gp_attribute_info(ctx, info, draw);
1037
1038   if ((ctx->dirty & LIMA_CONTEXT_DIRTY_CONST_BUFF &&
1039        ctx->const_buffer[PIPE_SHADER_VERTEX].dirty) ||
1040       ctx->dirty & LIMA_CONTEXT_DIRTY_VIEWPORT ||
1041       ctx->dirty & LIMA_CONTEXT_DIRTY_COMPILED_VS) {
1042      lima_update_gp_uniform(ctx);
1043      ctx->const_buffer[PIPE_SHADER_VERTEX].dirty = false;
1044   }
1045
1046   lima_update_varying(ctx, info, draw);
1047
1048   lima_pack_vs_cmd(ctx, info, draw);
1049
1050   if (ctx->dirty & LIMA_CONTEXT_DIRTY_CONST_BUFF &&
1051       ctx->const_buffer[PIPE_SHADER_FRAGMENT].dirty) {
1052      lima_update_pp_uniform(ctx);
1053      ctx->const_buffer[PIPE_SHADER_FRAGMENT].dirty = false;
1054   }
1055
1056   lima_update_textures(ctx);
1057
1058   lima_pack_render_state(ctx, info);
1059   lima_pack_plbu_cmd(ctx, info, draw);
1060
1061   if (ctx->gp_output) {
1062      lima_bo_unreference(ctx->gp_output); /* held by job */
1063      ctx->gp_output = NULL;
1064   }
1065
1066   ctx->dirty = 0;
1067}
1068
1069static void
1070lima_draw_vbo_indexed(struct pipe_context *pctx,
1071                      const struct pipe_draw_info *info,
1072                      const struct pipe_draw_start_count_bias *draw)
1073{
1074   struct lima_context *ctx = lima_context(pctx);
1075   struct lima_job *job = lima_job_get(ctx);
1076   struct pipe_resource *indexbuf = NULL;
1077   bool needs_indices = true;
1078
1079   /* Mali Utgard GPU always need min/max index info for index draw,
1080    * compute it if upper layer does not do for us */
1081   if (info->index_bounds_valid) {
1082      ctx->min_index = info->min_index;
1083      ctx->max_index = info->max_index;
1084      needs_indices = false;
1085   }
1086
1087   if (info->has_user_indices) {
1088      util_upload_index_buffer(&ctx->base, info, draw, &indexbuf, &ctx->index_offset, 0x40);
1089      ctx->index_res = lima_resource(indexbuf);
1090   }
1091   else {
1092      ctx->index_res = lima_resource(info->index.resource);
1093      ctx->index_offset = 0;
1094      needs_indices = !panfrost_minmax_cache_get(ctx->index_res->index_cache, draw->start,
1095                                                 draw->count, &ctx->min_index, &ctx->max_index);
1096   }
1097
1098   if (needs_indices) {
1099      u_vbuf_get_minmax_index(pctx, info, draw, &ctx->min_index, &ctx->max_index);
1100      if (!info->has_user_indices)
1101         panfrost_minmax_cache_add(ctx->index_res->index_cache, draw->start, draw->count,
1102                                   ctx->min_index, ctx->max_index);
1103   }
1104
1105   lima_job_add_bo(job, LIMA_PIPE_GP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
1106   lima_job_add_bo(job, LIMA_PIPE_PP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
1107   lima_draw_vbo_update(pctx, info, draw);
1108
1109   if (indexbuf)
1110      pipe_resource_reference(&indexbuf, NULL);
1111}
1112
1113static void
1114lima_draw_vbo_count(struct pipe_context *pctx,
1115                    const struct pipe_draw_info *info,
1116                    const struct pipe_draw_start_count_bias *draw)
1117{
1118   static const uint32_t max_verts = 65535;
1119
1120   struct pipe_draw_start_count_bias local_draw = *draw;
1121   unsigned start = draw->start;
1122   unsigned count = draw->count;
1123
1124   while (count) {
1125      unsigned this_count = count;
1126      unsigned step;
1127
1128      u_split_draw(info, max_verts, &this_count, &step);
1129
1130      local_draw.start = start;
1131      local_draw.count = this_count;
1132
1133      lima_draw_vbo_update(pctx, info, &local_draw);
1134
1135      count -= step;
1136      start += step;
1137   }
1138}
1139
1140static void
1141lima_draw_vbo(struct pipe_context *pctx,
1142              const struct pipe_draw_info *info,
1143              unsigned drawid_offset,
1144              const struct pipe_draw_indirect_info *indirect,
1145              const struct pipe_draw_start_count_bias *draws,
1146              unsigned num_draws)
1147{
1148   if (num_draws > 1) {
1149      util_draw_multi(pctx, info, drawid_offset, indirect, draws, num_draws);
1150      return;
1151   }
1152
1153   /* check if draw mode and vertex/index count match,
1154    * otherwise gp will hang */
1155   if (!u_trim_pipe_prim(info->mode, (unsigned*)&draws[0].count)) {
1156      debug_printf("draw mode and vertex/index count mismatch\n");
1157      return;
1158   }
1159
1160   struct lima_context *ctx = lima_context(pctx);
1161
1162   if (!ctx->uncomp_fs || !ctx->uncomp_vs) {
1163      debug_warn_once("no shader, skip draw\n");
1164      return;
1165   }
1166
1167   lima_clip_scissor_to_viewport(ctx);
1168   if (lima_is_scissor_zero(ctx))
1169      return;
1170
1171   /* extend the viewport in case of line draws with a line_width > 1.0f,
1172    * otherwise use the original values */
1173   lima_extend_viewport(ctx, info);
1174
1175   if (!lima_update_fs_state(ctx) || !lima_update_vs_state(ctx))
1176      return;
1177
1178   struct lima_job *job = lima_job_get(ctx);
1179   job->pp_max_stack_size = MAX2(job->pp_max_stack_size, ctx->fs->state.stack_size);
1180
1181   lima_dump_command_stream_print(
1182      job->dump, ctx->vs->bo->map, ctx->vs->state.shader_size, false,
1183      "add vs at va %x\n", ctx->vs->bo->va);
1184   lima_dump_shader(job->dump, ctx->vs->bo->map, ctx->vs->state.shader_size, false);
1185
1186   lima_dump_command_stream_print(
1187      job->dump, ctx->fs->bo->map, ctx->fs->state.shader_size, false,
1188      "add fs at va %x\n", ctx->fs->bo->va);
1189   lima_dump_shader(job->dump, ctx->fs->bo->map, ctx->fs->state.shader_size, true);
1190
1191   lima_job_add_bo(job, LIMA_PIPE_GP, ctx->vs->bo, LIMA_SUBMIT_BO_READ);
1192   lima_job_add_bo(job, LIMA_PIPE_PP, ctx->fs->bo, LIMA_SUBMIT_BO_READ);
1193
1194   if (info->index_size)
1195      lima_draw_vbo_indexed(pctx, info, &draws[0]);
1196   else
1197      lima_draw_vbo_count(pctx, info, &draws[0]);
1198
1199   job->draws++;
1200   /* Flush job if we hit the limit of draws per job otherwise we may
1201    * hit tile heap size limit */
1202   if (job->draws > MAX_DRAWS_PER_JOB) {
1203      unsigned resolve = job->resolve;
1204      lima_do_job(job);
1205      /* Subsequent job will need to resolve the same buffers */
1206      lima_update_job_wb(ctx, resolve);
1207   }
1208}
1209
1210void
1211lima_draw_init(struct lima_context *ctx)
1212{
1213   ctx->base.clear = lima_clear;
1214   ctx->base.draw_vbo = lima_draw_vbo;
1215}
1216