?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Hint added.
[AROS.git] / workbench / hidds / nouveau / xf86-video-nouveau / nv10_exa.c
blob8441528d62c31d487665f506372703bf6060e9f1
1 /*
2 * Copyright 2007 Stephane Marchesin
3 * Copyright 2007 Arthur Huillet
4 * Copyright 2007 Peter Winters
5 * Copyright 2009 Francisco Jerez
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 */
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "nv_include.h"
31 #include "nv04_pushbuf.h"
32
33 /* Texture/Render target formats. */
34 static struct pict_format {
35 int exa;
36 int hw;
37 } nv10_tex_format_pot[] = {
38 { PICT_a8, 0x80 },
39 { PICT_r5g6b5, 0x280 },
40 { PICT_x8r8g8b8, 0x300 },
41 { PICT_a8r8g8b8, 0x300 },
42 {},
43
44 }, nv10_tex_format_rect[] = {
45 { PICT_a8, 0x980 },
46 { PICT_r5g6b5, 0x880 },
47 { PICT_x8r8g8b8, 0x900 },
48 { PICT_a8r8g8b8, 0x900 },
49 {},
50
51 }, nv20_tex_format_rect[] = {
52 { PICT_a8, 0xd80 },
53 { PICT_r5g6b5, 0x880 },
54 { PICT_x8r8g8b8, 0x900 },
55 { PICT_a8r8g8b8, 0x900 },
56 {},
57
58 }, nv10_rt_format[] = {
59 { PICT_r5g6b5, 0x103 },
60 { PICT_x8r8g8b8, 0x108 },
61 { PICT_a8r8g8b8, 0x108 },
62 {},
63 };
64
65 static int
66 get_tex_format(PicturePtr pict)
67 {
68 #if !defined(__AROS__)
69 ScrnInfoPtr pScrn = xf86Screens[pict->pDrawable->pScreen->myNum];
70 #else
71 ScrnInfoPtr pScrn = globalcarddataptr;
72 #endif
73 NVPtr pNv = NVPTR(pScrn);
74
75 /* If repeat is set we're always handling a 1x1 texture with
76 * ARGB/XRGB destination, in that case we change the format to
77 * use the POT (swizzled) matching format.
78 */
79 struct pict_format *format =
80 pict->repeat != RepeatNone ? nv10_tex_format_pot :
81 pNv->Architecture == NV_ARCH_20 ? nv20_tex_format_rect :
82 nv10_tex_format_rect;
83
84 for (; format->hw; format++) {
85 if (format->exa == pict->format)
86 return format->hw;
87 }
88
89 return 0;
90 }
91
92 static int
93 get_rt_format(PicturePtr pict)
94 {
95 struct pict_format *format = nv10_rt_format;
96
97 for (; format->hw; format++) {
98 if (format->exa == pict->format)
99 return format->hw;
100 }
101
102 return 0;
103 }
104
105 /* Blending functions. */
106 #define SF(x) NV10TCL_BLEND_FUNC_SRC_##x
107 #define DF(x) NV10TCL_BLEND_FUNC_DST_##x
108
109 static struct pict_op {
110 int src;
111 int dst;
112
113 } nv10_pict_op[] = {
114 { SF(ZERO), DF(ZERO) }, /* Clear */
115 { SF(ONE), DF(ZERO) }, /* Src */
116 { SF(ZERO), DF(ONE) }, /* Dst */
117 { SF(ONE), DF(ONE_MINUS_SRC_ALPHA) }, /* Over */
118 { SF(ONE_MINUS_DST_ALPHA), DF(ONE) }, /* OverReverse */
119 { SF(DST_ALPHA), DF(ZERO) }, /* In */
120 { SF(ZERO), DF(SRC_ALPHA) }, /* InReverse */
121 { SF(ONE_MINUS_DST_ALPHA), DF(ZERO) }, /* Out */
122 { SF(ZERO), DF(ONE_MINUS_SRC_ALPHA) }, /* OutReverse */
123 { SF(DST_ALPHA), DF(ONE_MINUS_SRC_ALPHA) }, /* Atop */
124 { SF(ONE_MINUS_DST_ALPHA), DF(SRC_ALPHA) }, /* AtopReverse */
125 { SF(ONE_MINUS_DST_ALPHA), DF(ONE_MINUS_SRC_ALPHA) }, /* Xor */
126 { SF(ONE), DF(ONE) }, /* Add */
127 { SF(SRC_ALPHA), DF(ONE_MINUS_SRC_ALPHA) }, /* OverAlpha */
128 };
129
130 static inline Bool
131 needs_src_alpha(int op)
132 {
133 return nv10_pict_op[op].dst == DF(ONE_MINUS_SRC_ALPHA)
134 || nv10_pict_op[op].dst == DF(SRC_ALPHA);
135 }
136
137 static inline Bool
138 needs_src(int op)
139 {
140 return nv10_pict_op[op].src != DF(ZERO);
141 }
142
143 static inline Bool
144 effective_component_alpha(PicturePtr mask)
145 {
146 return mask && mask->componentAlpha && PICT_FORMAT_RGB(mask->format);
147 }
148
149 #if !defined(__AROS__)
150 static Bool
151 check_texture(PicturePtr pict)
152 {
153 int w, h;
154
155 if (!pict->pDrawable)
156 NOUVEAU_FALLBACK("Solid and gradient pictures unsupported\n");
157
158 w = pict->pDrawable->width;
159 h = pict->pDrawable->height;
160
161 if (w > 2046 || h > 2046)
162 NOUVEAU_FALLBACK("picture too large, %dx%d\n", w, h);
163
164 if (!get_tex_format(pict))
165 return FALSE;
166
167 if (pict->filter != PictFilterNearest &&
168 pict->filter != PictFilterBilinear)
169 return FALSE;
170
171 /* We cannot repeat on NV10 because NPOT textures do not
172 * support this. unfortunately. */
173 if (pict->repeat != RepeatNone)
174 /* we can repeat 1x1 textures */
175 if (!(w == 1 && h == 1))
176 return FALSE;
177
178 return TRUE;
179 }
180
181 static Bool
182 check_render_target(PicturePtr pict)
183 {
184 int w = pict->pDrawable->width;
185 int h = pict->pDrawable->height;
186
187 if (w > 4096 || h > 4096)
188 return FALSE;
189
190 if (!get_rt_format(pict))
191 return FALSE;
192
193 return TRUE;
194 }
195
196 static Bool
197 check_pict_op(int op)
198 {
199 /* We do no saturate, disjoint, conjoint, though we
200 * could do e.g. DisjointClear which really is
201 * Clear. */
202 return op < PictOpSaturate;
203 }
204
205 #if 0
206 static void
207 print_fallback_info(char *reason, int op, PicturePtr src, PicturePtr mask,
208 PicturePtr dst)
209 {
210 char out2[4096];
211 char *out = out2;
212
213 sprintf(out, "%s ", reason);
214 out += strlen(out);
215
216 switch (op) {
217 case PictOpClear:
218 sprintf(out, "PictOpClear ");
219 break;
220 case PictOpSrc:
221 sprintf(out, "PictOpSrc ");
222 break;
223 case PictOpDst:
224 sprintf(out, "PictOpDst ");
225 break;
226 case PictOpOver:
227 sprintf(out, "PictOpOver ");
228 break;
229 case PictOpOutReverse:
230 sprintf(out, "PictOpOutReverse ");
231 break;
232 case PictOpAdd:
233 sprintf(out, "PictOpAdd ");
234 break;
235 default:
236 sprintf(out, "PictOp%d ", op);
237 }
238 out += strlen(out);
239
240 switch (src->format) {
241 case PICT_a8r8g8b8:
242 sprintf(out, "A8R8G8B8 ");
243 break;
244 case PICT_x8r8g8b8:
245 sprintf(out, "X8R8G8B8 ");
246 break;
247 case PICT_x8b8g8r8:
248 sprintf(out, "X8B8G8R8 ");
249 break;
250 case PICT_r5g6b5:
251 sprintf(out, "R5G6B5 ");
252 break;
253 case PICT_a8:
254 sprintf(out, "A8 ");
255 break;
256 case PICT_a1:
257 sprintf(out, "A1 ");
258 break;
259 default:
260 sprintf(out, "%x ", src->format);
261 }
262 out += strlen(out);
263
264 sprintf(out, "(%dx%d) ", src->pDrawable->width,
265 src->pDrawable->height);
266 if (src->repeat != RepeatNone)
267 strcat(out, "R ");
268 strcat(out, "-> ");
269 out += strlen(out);
270
271 switch (dst->format) {
272 case PICT_a8r8g8b8:
273 sprintf(out, "A8R8G8B8 ");
274 break;
275 case PICT_x8r8g8b8:
276 sprintf(out, "X8R8G8B8 ");
277 break;
278 case PICT_x8b8g8r8:
279 sprintf(out, "X8B8G8R8 ");
280 break;
281 case PICT_r5g6b5:
282 sprintf(out, "R5G6B5 ");
283 break;
284 case PICT_a8:
285 sprintf(out, "A8 ");
286 break;
287 case PICT_a1:
288 sprintf(out, "A1 ");
289 break;
290 default:
291 sprintf(out, "%x ", dst->format);
292 }
293 out += strlen(out);
294
295 sprintf(out, "(%dx%d) ", dst->pDrawable->width,
296 dst->pDrawable->height);
297 if (dst->repeat != RepeatNone)
298 strcat(out, "R ");
299 out += strlen(out);
300
301 if (!mask)
302 sprintf(out, "& NONE");
303 else {
304 switch (mask->format) {
305 case PICT_a8r8g8b8:
306 sprintf(out, "& A8R8G8B8 ");
307 break;
308 case PICT_x8r8g8b8:
309 sprintf(out, "& X8R8G8B8 ");
310 break;
311 case PICT_x8b8g8r8:
312 sprintf(out, "& X8B8G8R8 ");
313 break;
314 case PICT_a8:
315 sprintf(out, "& A8 ");
316 break;
317 case PICT_a1:
318 sprintf(out, "& A1 ");
319 break;
320 default:
321 sprintf(out, "& %x ", mask->format);
322 }
323 out += strlen(out);
324
325 sprintf(out, "(%dx%d) ", mask->pDrawable->width,
326 mask->pDrawable->height);
327 if (mask->repeat != RepeatNone)
328 strcat(out, "R ");
329 if (mask->componentAlpha)
330 strcat(out, "C ");
331 out += strlen(out);
332 }
333 strcat(out, "\n");
334
335 xf86DrvMsg(0, X_INFO, "%s", out2);
336 }
337 #else
338 #define print_fallback_info(...)
339 #endif
340
341 Bool
342 NV10EXACheckComposite(int op, PicturePtr src, PicturePtr mask, PicturePtr dst)
343 {
344 if (!check_pict_op(op)) {
345 print_fallback_info("pictop", op, src, mask, dst);
346 return FALSE;
347 }
348
349 if (!check_render_target(dst)) {
350 print_fallback_info("dst", op, src, mask, dst);
351 return FALSE;
352 }
353
354 if (!check_texture(src)) {
355 print_fallback_info("src", op, src, mask, dst);
356 return FALSE;
357 }
358
359 if (mask) {
360 if (!check_texture(mask)) {
361 print_fallback_info("mask", op, src,
362 mask, dst);
363 return FALSE;
364 }
365
366 if (effective_component_alpha(mask) &&
367 needs_src(op) && needs_src_alpha(op)) {
368 print_fallback_info("ca-mask", op, src,
369 mask, dst);
370 return FALSE;
371 }
372 }
373
374 print_fallback_info("Accelerating", op, src, mask, dst);
375 return TRUE;
376 }
377 #endif
378
379 static Bool
380 setup_texture(NVPtr pNv, int unit, PicturePtr pict, PixmapPtr pixmap)
381 {
382 struct nouveau_channel *chan = pNv->chan;
383 struct nouveau_grobj *celsius = pNv->Nv3D;
384 struct nouveau_bo *bo = nouveau_pixmap_bo(pixmap);
385 unsigned tex_reloc = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD;
386 #if !defined(__AROS__)
387 long w = pict->pDrawable->width,
388 h = pict->pDrawable->height;
389 #else
390 long w = pixmap->width,
391 h = pixmap->height;
392 #endif
393 unsigned int txfmt =
394 NV10TCL_TX_FORMAT_WRAP_T_CLAMP_TO_EDGE |
395 NV10TCL_TX_FORMAT_WRAP_S_CLAMP_TO_EDGE |
396 log2i(w) << 20 | log2i(h) << 16 |
397 1 << 12 | /* lod == 1 */
398 get_tex_format(pict) |
399 0x50 /* UNK */;
400
401 BEGIN_RING(chan, celsius, NV10TCL_TX_OFFSET(unit), 1);
402 if (OUT_RELOCl(chan, bo, 0, tex_reloc))
403 return FALSE;
404
405 if (pict->repeat == RepeatNone) {
406 /* NPOT_SIZE expects an even number for width, we can
407 * round up uneven numbers here because EXA always
408 * gives 64 byte aligned pixmaps and for all formats
409 * we support 64 bytes represents an even number of
410 * pixels
411 */
412 w = (w + 1) &~ 1;
413
414 BEGIN_RING(chan, celsius, NV10TCL_TX_NPOT_PITCH(unit), 1);
415 OUT_RING (chan, exaGetPixmapPitch(pixmap) << 16);
416
417 BEGIN_RING(chan, celsius, NV10TCL_TX_NPOT_SIZE(unit), 1);
418 OUT_RING (chan, w << 16 | h);
419 }
420
421 BEGIN_RING(chan, celsius, NV10TCL_TX_FORMAT(unit), 1 );
422 if (OUT_RELOCd(chan, bo, txfmt, tex_reloc | NOUVEAU_BO_OR,
423 NV10TCL_TX_FORMAT_DMA0, NV10TCL_TX_FORMAT_DMA1))
424 return FALSE;
425
426 BEGIN_RING(chan, celsius, NV10TCL_TX_ENABLE(unit), 1 );
427 OUT_RING (chan, NV10TCL_TX_ENABLE_ENABLE);
428
429 BEGIN_RING(chan, celsius, NV10TCL_TX_FILTER(unit), 1);
430 if (pict->filter == PictFilterNearest)
431 OUT_RING(chan, (NV10TCL_TX_FILTER_MAGNIFY_NEAREST |
432 NV10TCL_TX_FILTER_MINIFY_NEAREST));
433 else
434 OUT_RING(chan, (NV10TCL_TX_FILTER_MAGNIFY_LINEAR |
435 NV10TCL_TX_FILTER_MINIFY_LINEAR));
436
437 return TRUE;
438 }
439
440 static Bool
441 setup_render_target(NVPtr pNv, PicturePtr pict, PixmapPtr pixmap)
442 {
443 struct nouveau_channel *chan = pNv->chan;
444 struct nouveau_grobj *celsius = pNv->Nv3D;
445 struct nouveau_bo *bo = nouveau_pixmap_bo(pixmap);
446
447 BEGIN_RING(chan, celsius, NV10TCL_RT_FORMAT, 2);
448 OUT_RING (chan, get_rt_format(pict));
449 OUT_RING (chan, (exaGetPixmapPitch(pixmap) << 16 |
450 exaGetPixmapPitch(pixmap)));
451
452 BEGIN_RING(chan, celsius, NV10TCL_COLOR_OFFSET, 1);
453 if (OUT_RELOCl(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR))
454 return FALSE;
455
456 return TRUE;
457 }
458
459 /*
460 * This can be a bit difficult to understand at first glance. Reg
461 * combiners are described here:
462 * http://icps.u-strasbg.fr/~marchesin/perso/extensions/NV/register_combiners.html
463 *
464 * Single texturing setup, without honoring vertex colors (non default
465 * setup) is: Alpha RC 0 : a_0 * 1 + 0 * 0 RGB RC 0 : rgb_0 * 1 + 0 *
466 * 0 RC 1s are unused Final combiner uses default setup
467 *
468 * Default setup uses vertex rgb/alpha in place of 1s above, but we
469 * don't need that in 2D.
470 *
471 * Multi texturing setup, where we do TEX0 in TEX1 (masking) is:
472 * Alpha RC 0 : a_0 * a_1 + 0 * 0
473 * RGB RC0 : rgb_0 * a_1 + 0 * 0
474 * RC 1s are unused
475 * Final combiner uses default setup
476 */
477
478 /* Bind the combiner variable <input> to a constant 1. */
479 #define RC_IN_ONE(input) \
480 (NV10TCL_RC_IN_RGB_##input##_INPUT_ZERO | \
481 NV10TCL_RC_IN_RGB_##input##_COMPONENT_USAGE_ALPHA | \
482 NV10TCL_RC_IN_RGB_##input##_MAPPING_UNSIGNED_INVERT)
483
484 /* Bind the combiner variable <input> to the specified channel from
485 * the texture unit <unit>. */
486 #define RC_IN_TEX(input, chan, unit) \
487 (NV10TCL_RC_IN_RGB_##input##_INPUT_TEXTURE##unit | \
488 NV10TCL_RC_IN_RGB_##input##_COMPONENT_USAGE_##chan)
489
490 /* Bind the combiner variable <input> to the specified channel from
491 * the constant color <unit>. */
492 #define RC_IN_COLOR(input, chan, unit) \
493 (NV10TCL_RC_IN_RGB_##input##_INPUT_CONSTANT_COLOR##unit | \
494 NV10TCL_RC_IN_RGB_##input##_COMPONENT_USAGE_##chan)
495
496 #if !defined(__AROS__)
497 static void
498 setup_combiners(NVPtr pNv, PicturePtr src, PicturePtr mask)
499 #else
500 static void
501 setup_combiners(NVPtr pNv, PicturePtr src, PicturePtr mask, int op)
502 #endif
503 {
504 struct nouveau_channel *chan = pNv->chan;
505 struct nouveau_grobj *celsius = pNv->Nv3D;
506 uint32_t rc_in_alpha = 0, rc_in_rgb = 0;
507
508 if (PICT_FORMAT_A(src->format))
509 rc_in_alpha |= RC_IN_TEX(A, ALPHA, 0);
510 else
511 rc_in_alpha |= RC_IN_ONE(A);
512
513 if (mask && PICT_FORMAT_A(mask->format))
514 rc_in_alpha |= RC_IN_TEX(B, ALPHA, 1);
515 else
516 rc_in_alpha |= RC_IN_ONE(B);
517
518 if (effective_component_alpha(mask)) {
519 #if !defined(__AROS__)
520 if (!needs_src_alpha(pNv->alu)) {
521 #else
522 if (!needs_src_alpha(op)) {
523 #endif
524 /* The alpha channels won't be used for blending. Drop
525 * them, as our pixels only have 4 components...
526 * output_i = src_i * mask_i
527 */
528 if (PICT_FORMAT_RGB(src->format))
529 rc_in_rgb |= RC_IN_TEX(A, RGB, 0);
530 } else {
531 /* The RGB channels won't be used for blending. Drop
532 * them.
533 * output_i = src_alpha * mask_i
534 */
535 if (PICT_FORMAT_A(src->format))
536 rc_in_rgb |= RC_IN_TEX(A, ALPHA, 0);
537 else
538 rc_in_rgb |= RC_IN_ONE(A);
539 }
540
541 rc_in_rgb |= RC_IN_TEX(B, RGB, 1);
542
543 } else {
544 if (PICT_FORMAT_RGB(src->format))
545 rc_in_rgb |= RC_IN_TEX(A, RGB, 0);
546
547 if (mask && PICT_FORMAT_A(mask->format))
548 rc_in_rgb |= RC_IN_TEX(B, ALPHA, 1);
549 else
550 rc_in_rgb |= RC_IN_ONE(B);
551 }
552
553 BEGIN_RING(chan, celsius, NV10TCL_RC_IN_ALPHA(0), 1);
554 OUT_RING (chan, rc_in_alpha);
555 BEGIN_RING(chan, celsius, NV10TCL_RC_IN_RGB(0), 1);
556 OUT_RING (chan, rc_in_rgb);
557 }
558
559 #if !defined(__AROS__)
560 static void
561 setup_blend_function(NVPtr pNv)
562 #else
563 static void
564 setup_blend_function(NVPtr pNv, PicturePtr dst, PicturePtr mask, int blendop)
565 #endif
566 {
567 struct nouveau_channel *chan = pNv->chan;
568 struct nouveau_grobj *celsius = pNv->Nv3D;
569 #if !defined(__AROS__)
570 struct pict_op *op = &nv10_pict_op[pNv->alu];
571 #else
572 struct pict_op *op = &nv10_pict_op[blendop];
573 #endif
574 int src_factor = op->src;
575 int dst_factor = op->dst;
576
577 if (src_factor == SF(ONE_MINUS_DST_ALPHA) &&
578 #if !defined(__AROS__)
579 !PICT_FORMAT_A(pNv->pdpict->format))
580 #else
581 !PICT_FORMAT_A(dst->format))
582 #endif
583 /* ONE_MINUS_DST_ALPHA doesn't always do the right thing for
584 * framebuffers without alpha channel. But it's the same as
585 * ZERO in that case.
586 */
587 src_factor = SF(ZERO);
588
589 #if !defined(__AROS__)
590 if (effective_component_alpha(pNv->pmpict)) {
591 #else
592 if (effective_component_alpha(mask)) {
593 #endif
594 if (dst_factor == DF(SRC_ALPHA))
595 dst_factor = DF(SRC_COLOR);
596 else if (dst_factor == DF(ONE_MINUS_SRC_ALPHA))
597 dst_factor = DF(ONE_MINUS_SRC_COLOR);
598 }
599
600 BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_SRC, 2);
601 OUT_RING (chan, src_factor);
602 OUT_RING (chan, dst_factor);
603 BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_ENABLE, 1);
604 OUT_RING (chan, 1);
605 }
606
607 #if !defined(__AROS__)
608 static void
609 NV10StateCompositeReemit(struct nouveau_channel *chan)
610 {
611 ScrnInfoPtr pScrn = chan->user_private;
612 NVPtr pNv = NVPTR(pScrn);
613
614 NV10EXAPrepareComposite(pNv->alu, pNv->pspict, pNv->pmpict, pNv->pdpict,
615 pNv->pspix, pNv->pmpix, pNv->pdpix);
616 }
617 #endif
618
619 Bool
620 NV10EXAPrepareComposite(int op,
621 PicturePtr pict_src,
622 PicturePtr pict_mask,
623 PicturePtr pict_dst,
624 PixmapPtr src,
625 PixmapPtr mask,
626 PixmapPtr dst)
627 {
628 #if !defined(__AROS__)
629 ScrnInfoPtr pScrn = xf86Screens[dst->drawable.pScreen->myNum];
630 #else
631 ScrnInfoPtr pScrn = globalcarddataptr;
632 #endif
633 NVPtr pNv = NVPTR(pScrn);
634 struct nouveau_channel *chan = pNv->chan;
635
636 if (MARK_RING(chan, 128, 5))
637 return FALSE;
638
639 #if !defined(__AROS__)
640 pNv->alu = op;
641 pNv->pspict = pict_src;
642 pNv->pmpict = pict_mask;
643 pNv->pdpict = pict_dst;
644 pNv->pspix = src;
645 pNv->pmpix = mask;
646 pNv->pdpix = dst;
647 #endif
648
649 /* Set dst format */
650 if (!setup_render_target(pNv, pict_dst, dst))
651 goto fail;
652
653 /* Set src format */
654 if (!setup_texture(pNv, 0, pict_src, src))
655 goto fail;
656
657 /* Set mask format */
658 if (mask &&
659 !setup_texture(pNv, 1, pict_mask, mask))
660 goto fail;
661
662 #if !defined(__AROS__)
663 /* Set the register combiners up. */
664 setup_combiners(pNv, pict_src, pict_mask);
665
666 /* Set PictOp */
667 setup_blend_function(pNv);
668
669 chan->flush_notify = NV10StateCompositeReemit;
670 #else
671 /* Set the register combiners up. */
672 setup_combiners(pNv, pict_src, pict_mask, op);
673
674 /* Set PictOp */
675 setup_blend_function(pNv, pict_dst, pict_mask, op);
676
677 chan->flush_notify = NULL;
678 #endif
679
680 return TRUE;
681
682 fail:
683 MARK_UNDO(chan);
684
685 return FALSE;
686 }
687
688 #if defined(__AROS__)
689 /* WARNING: These defines are only used to hack QUAD/MAP/OUT_RINGi defines
690 in this use case. They WILL NOT work in generic case. DO NOT reuse them. */
691 struct _PictVector
692 {
693 float vector[3];
694 };
695 typedef struct _PictVector PictVector;
696 #define xFixed1 0.0f
697 #define xFixedFrac(x) 0
698 #define xFixedToInt(x) (x)
699 #define IntToxFixed(x) (float)(x)
700 #endif
701
702 #define QUAD(x, y, w, h) \
703 {{{ IntToxFixed(x), IntToxFixed(y), xFixed1 }}, \
704 {{ IntToxFixed(x + w), IntToxFixed(y), xFixed1 }}, \
705 {{ IntToxFixed(x + w), IntToxFixed(y + h), xFixed1 }}, \
706 {{ IntToxFixed(x), IntToxFixed(y + h), xFixed1 }}}
707
708 #define MAP(f, p, v, ...) do { \
709 int __i; \
710 for (__i = 0; __i < sizeof(v)/sizeof((v)[0]); __i++) \
711 f(p, __i, v, ## __VA_ARGS__); \
712 } while (0);
713
714 #define xFixedToFloat(v) \
715 ((float)xFixedToInt((v)) + ((float)xFixedFrac(v) / 65536.0))
716
717 #define OUT_RINGi(chan, v, i) \
718 OUT_RINGf(chan, xFixedToFloat((v).vector[i]))
719
720 static inline void
721 emit_vertex(NVPtr pNv, int i, PictVector pos[],
722 PictVector tex0[], PictVector tex1[])
723 {
724 struct nouveau_channel *chan = pNv->chan;
725 struct nouveau_grobj *celsius = pNv->Nv3D;
726
727 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_TX0_2F_S, 2);
728 OUT_RINGi (chan, tex0[i], 0);
729 OUT_RINGi (chan, tex0[i], 1);
730
731 if (tex1) {
732 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_TX1_2F_S, 2);
733 OUT_RINGi (chan, tex1[i], 0);
734 OUT_RINGi (chan, tex1[i], 1);
735 }
736
737 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_POS_3F_X, 3);
738 OUT_RINGi (chan, pos[i], 0);
739 OUT_RINGi (chan, pos[i], 1);
740 OUT_RINGf (chan, 0);
741 }
742
743 #if !defined(__AROS__)
744 static inline void
745 transform_vertex(PictTransformPtr t, int i, PictVector vs[])
746 {
747 if (t)
748 PictureTransformPoint(t, &vs[i]);
749 }
750
751 void
752 NV10EXAComposite(PixmapPtr pix_dst,
753 int srcX, int srcY,
754 int maskX, int maskY,
755 int dstX, int dstY,
756 int width, int height)
757 {
758 ScrnInfoPtr pScrn = xf86Screens[pix_dst->drawable.pScreen->myNum];
759 #else
760 static void
761 NV10EXAComposite(PixmapPtr pix_dst,
762 int srcX, int srcY,
763 int maskX, int maskY,
764 int dstX, int dstY,
765 int width, int height,
766 PicturePtr src, PicturePtr mask)
767 {
768 ScrnInfoPtr pScrn = globalcarddataptr;
769 #endif
770 NVPtr pNv = NVPTR(pScrn);
771 struct nouveau_channel *chan = pNv->chan;
772 struct nouveau_grobj *celsius = pNv->Nv3D;
773 #if !defined(__AROS__)
774 PicturePtr mask = pNv->pmpict,
775 src = pNv->pspict;
776 #endif
777 PictVector dstq[4] = QUAD(dstX, dstY, width, height),
778 maskq[4] = QUAD(maskX, maskY, width, height),
779 srcq[4] = QUAD(srcX, srcY, width, height);
780
781 #if !defined(__AROS__)
782 /* We are not doing any transformations */
783 MAP(transform_vertex, src->transform, srcq);
784 if (mask)
785 MAP(transform_vertex, mask->transform, maskq);
786 #endif
787
788 WAIT_RING (chan, 64);
789 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_BEGIN_END, 1);
790 OUT_RING (chan, NV10TCL_VERTEX_BEGIN_END_QUADS);
791
792 MAP(emit_vertex, pNv, dstq, srcq, mask ? maskq : NULL);
793
794 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_BEGIN_END, 1);
795 OUT_RING (chan, NV10TCL_VERTEX_BEGIN_END_STOP);
796 }
797
798 #if !defined(__AROS__)
799 void
800 NV10EXADoneComposite(PixmapPtr dst)
801 {
802 ScrnInfoPtr pScrn = xf86Screens[dst->drawable.pScreen->myNum];
803 NVPtr pNv = NVPTR(pScrn);
804 struct nouveau_channel *chan = pNv->chan;
805
806 chan->flush_notify = NULL;
807 }
808 #endif
809
810 Bool
811 NVAccelInitNV10TCL(ScrnInfoPtr pScrn)
812 {
813 NVPtr pNv = NVPTR(pScrn);
814 struct nouveau_channel *chan = pNv->chan;
815 struct nouveau_grobj *celsius;
816 uint32_t class = 0;
817 int i;
818
819 if (((pNv->dev->chipset & 0xf0) != NV_ARCH_10) &&
820 ((pNv->dev->chipset & 0xf0) != NV_ARCH_20))
821 return FALSE;
822
823 if (pNv->dev->chipset >= 0x20 || pNv->dev->chipset == 0x1a)
824 class = NV11TCL;
825 else if (pNv->dev->chipset >= 0x17)
826 class = NV17TCL;
827 else if (pNv->dev->chipset >= 0x11)
828 class = NV11TCL;
829 else
830 class = NV10TCL;
831
832 if (!pNv->Nv3D) {
833 if (nouveau_grobj_alloc(pNv->chan, Nv3D, class, &pNv->Nv3D))
834 return FALSE;
835 }
836 celsius = pNv->Nv3D;
837
838 BEGIN_RING(chan, celsius, NV10TCL_DMA_NOTIFY, 1);
839 OUT_RING (chan, chan->nullobj->handle);
840
841 BEGIN_RING(chan, celsius, NV10TCL_DMA_IN_MEMORY0, 2);
842 OUT_RING (chan, pNv->chan->vram->handle);
843 OUT_RING (chan, pNv->chan->gart->handle);
844
845 BEGIN_RING(chan, celsius, NV10TCL_DMA_IN_MEMORY2, 2);
846 OUT_RING (chan, pNv->chan->vram->handle);
847 OUT_RING (chan, pNv->chan->vram->handle);
848
849 BEGIN_RING(chan, celsius, NV10TCL_NOP, 1);
850 OUT_RING (chan, 0);
851
852 BEGIN_RING(chan, celsius, NV10TCL_RT_HORIZ, 2);
853 OUT_RING (chan, 2048 << 16 | 0);
854 OUT_RING (chan, 2048 << 16 | 0);
855
856 BEGIN_RING(chan, celsius, NV10TCL_ZETA_OFFSET, 1);
857 OUT_RING (chan, 0);
858
859 BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_MODE, 1);
860 OUT_RING (chan, 0);
861
862 BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_HORIZ(0), 1);
863 OUT_RING (chan, 0x7ff << 16 | 0x800800);
864 BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_VERT(0), 1);
865 OUT_RING (chan, 0x7ff << 16 | 0x800800);
866
867 for (i = 1; i < 8; i++) {
868 BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_HORIZ(i), 1);
869 OUT_RING (chan, 0);
870 BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_CLIP_VERT(i), 1);
871 OUT_RING (chan, 0);
872 }
873
874 BEGIN_RING(chan, celsius, 0x290, 1);
875 OUT_RING (chan, (0x10<<16)|1);
876 BEGIN_RING(chan, celsius, 0x3f4, 1);
877 OUT_RING (chan, 0);
878
879 BEGIN_RING(chan, celsius, NV10TCL_NOP, 1);
880 OUT_RING (chan, 0);
881
882 if (class != NV10TCL) {
883 /* For nv11, nv17 */
884 BEGIN_RING(chan, celsius, 0x120, 3);
885 OUT_RING (chan, 0);
886 OUT_RING (chan, 1);
887 OUT_RING (chan, 2);
888
889 BEGIN_RING(chan, pNv->NvImageBlit, 0x120, 3);
890 OUT_RING (chan, 0);
891 OUT_RING (chan, 1);
892 OUT_RING (chan, 2);
893
894 BEGIN_RING(chan, celsius, NV10TCL_NOP, 1);
895 OUT_RING (chan, 0);
896 }
897
898 BEGIN_RING(chan, celsius, NV10TCL_NOP, 1);
899 OUT_RING (chan, 0);
900
901 /* Set state */
902 BEGIN_RING(chan, celsius, NV10TCL_FOG_ENABLE, 1);
903 OUT_RING (chan, 0);
904 BEGIN_RING(chan, celsius, NV10TCL_ALPHA_FUNC_ENABLE, 1);
905 OUT_RING (chan, 0);
906 BEGIN_RING(chan, celsius, NV10TCL_ALPHA_FUNC_FUNC, 2);
907 OUT_RING (chan, 0x207);
908 OUT_RING (chan, 0);
909 BEGIN_RING(chan, celsius, NV10TCL_TX_ENABLE(0), 2);
910 OUT_RING (chan, 0);
911 OUT_RING (chan, 0);
912 BEGIN_RING(chan, celsius, NV10TCL_RC_IN_ALPHA(0), 6);
913 OUT_RING (chan, 0);
914 OUT_RING (chan, 0);
915 OUT_RING (chan, 0);
916 OUT_RING (chan, 0);
917 OUT_RING (chan, 0);
918 OUT_RING (chan, 0);
919 BEGIN_RING(chan, celsius, NV10TCL_RC_OUT_ALPHA(0), 6);
920 OUT_RING (chan, 0x00000c00);
921 OUT_RING (chan, 0);
922 OUT_RING (chan, 0x00000c00);
923 OUT_RING (chan, 0x18000000);
924 OUT_RING (chan, 0x300c0000);
925 OUT_RING (chan, 0x00001c80);
926 BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_ENABLE, 1);
927 OUT_RING (chan, 0);
928 BEGIN_RING(chan, celsius, NV10TCL_DITHER_ENABLE, 2);
929 OUT_RING (chan, 1);
930 OUT_RING (chan, 0);
931 BEGIN_RING(chan, celsius, NV10TCL_LINE_SMOOTH_ENABLE, 1);
932 OUT_RING (chan, 0);
933 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_WEIGHT_ENABLE, 2);
934 OUT_RING (chan, 0);
935 OUT_RING (chan, 0);
936 BEGIN_RING(chan, celsius, NV10TCL_BLEND_FUNC_SRC, 4);
937 OUT_RING (chan, 1);
938 OUT_RING (chan, 0);
939 OUT_RING (chan, 0);
940 OUT_RING (chan, 0x8006);
941 BEGIN_RING(chan, celsius, NV10TCL_STENCIL_MASK, 8);
942 OUT_RING (chan, 0xff);
943 OUT_RING (chan, 0x207);
944 OUT_RING (chan, 0);
945 OUT_RING (chan, 0xff);
946 OUT_RING (chan, 0x1e00);
947 OUT_RING (chan, 0x1e00);
948 OUT_RING (chan, 0x1e00);
949 OUT_RING (chan, 0x1d01);
950 BEGIN_RING(chan, celsius, NV10TCL_NORMALIZE_ENABLE, 1);
951 OUT_RING (chan, 0);
952 BEGIN_RING(chan, celsius, NV10TCL_FOG_ENABLE, 2);
953 OUT_RING (chan, 0);
954 OUT_RING (chan, 0);
955 BEGIN_RING(chan, celsius, NV10TCL_LIGHT_MODEL, 1);
956 OUT_RING (chan, 0);
957 BEGIN_RING(chan, celsius, NV10TCL_SEPARATE_SPECULAR_ENABLE, 1);
958 OUT_RING (chan, 0);
959 BEGIN_RING(chan, celsius, NV10TCL_ENABLED_LIGHTS, 1);
960 OUT_RING (chan, 0);
961 BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
962 OUT_RING (chan, 0);
963 OUT_RING (chan, 0);
964 OUT_RING (chan, 0);
965 BEGIN_RING(chan, celsius, NV10TCL_DEPTH_FUNC, 1);
966 OUT_RING (chan, 0x201);
967 BEGIN_RING(chan, celsius, NV10TCL_DEPTH_WRITE_ENABLE, 1);
968 OUT_RING (chan, 0);
969 BEGIN_RING(chan, celsius, NV10TCL_DEPTH_TEST_ENABLE, 1);
970 OUT_RING (chan, 0);
971 BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_FACTOR, 2);
972 OUT_RING (chan, 0);
973 OUT_RING (chan, 0);
974 BEGIN_RING(chan, celsius, NV10TCL_POINT_SIZE, 1);
975 OUT_RING (chan, 8);
976 BEGIN_RING(chan, celsius, NV10TCL_POINT_PARAMETERS_ENABLE, 2);
977 OUT_RING (chan, 0);
978 OUT_RING (chan, 0);
979 BEGIN_RING(chan, celsius, NV10TCL_LINE_WIDTH, 1);
980 OUT_RING (chan, 8);
981 BEGIN_RING(chan, celsius, NV10TCL_LINE_SMOOTH_ENABLE, 1);
982 OUT_RING (chan, 0);
983 BEGIN_RING(chan, celsius, NV10TCL_POLYGON_MODE_FRONT, 2);
984 OUT_RING (chan, 0x1b02);
985 OUT_RING (chan, 0x1b02);
986 BEGIN_RING(chan, celsius, NV10TCL_CULL_FACE, 2);
987 OUT_RING (chan, 0x405);
988 OUT_RING (chan, 0x901);
989 BEGIN_RING(chan, celsius, NV10TCL_POLYGON_SMOOTH_ENABLE, 1);
990 OUT_RING (chan, 0);
991 BEGIN_RING(chan, celsius, NV10TCL_CULL_FACE_ENABLE, 1);
992 OUT_RING (chan, 0);
993 BEGIN_RING(chan, celsius, NV10TCL_TX_GEN_MODE_S(0), 8);
994 for (i = 0; i < 8; i++)
995 OUT_RING (chan, 0);
996
997 BEGIN_RING(chan, celsius, NV10TCL_FOG_EQUATION_CONSTANT, 3);
998 OUT_RING (chan, 0x3fc00000); /* -1.50 */
999 OUT_RING (chan, 0xbdb8aa0a); /* -0.09 */
1000 OUT_RING (chan, 0); /* 0.00 */
1001
1002 BEGIN_RING(chan, celsius, NV10TCL_NOP, 1);
1003 OUT_RING (chan, 0);
1004
1005 BEGIN_RING(chan, celsius, NV10TCL_FOG_MODE, 2);
1006 OUT_RING (chan, 0x802);
1007 OUT_RING (chan, 2);
1008 /* for some reason VIEW_MATRIX_ENABLE need to be 6 instead of 4 when
1009 * using texturing, except when using the texture matrix
1010 */
1011 BEGIN_RING(chan, celsius, NV10TCL_VIEW_MATRIX_ENABLE, 1);
1012 OUT_RING (chan, 6);
1013 BEGIN_RING(chan, celsius, NV10TCL_COLOR_MASK, 1);
1014 OUT_RING (chan, 0x01010101);
1015
1016 BEGIN_RING(chan, celsius, NV10TCL_PROJECTION_MATRIX(0), 16);
1017 for(i = 0; i < 16; i++)
1018 OUT_RINGf(chan, i/4 == i%4 ? 1.0 : 0.0);
1019
1020 BEGIN_RING(chan, celsius, NV10TCL_DEPTH_RANGE_NEAR, 2);
1021 OUT_RING (chan, 0);
1022 OUT_RINGf (chan, 65536.0);
1023
1024 BEGIN_RING(chan, celsius, NV10TCL_VIEWPORT_TRANSLATE_X, 4);
1025 OUT_RINGf (chan, -2048.0);
1026 OUT_RINGf (chan, -2048.0);
1027 OUT_RINGf (chan, 0);
1028 OUT_RING (chan, 0);
1029
1030 /* Set vertex component */
1031 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_COL_4F_R, 4);
1032 OUT_RINGf (chan, 1.0);
1033 OUT_RINGf (chan, 1.0);
1034 OUT_RINGf (chan, 1.0);
1035 OUT_RINGf (chan, 1.0);
1036 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_COL2_3F_R, 3);
1037 OUT_RING (chan, 0);
1038 OUT_RING (chan, 0);
1039 OUT_RING (chan, 0);
1040 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_NOR_3F_X, 3);
1041 OUT_RING (chan, 0);
1042 OUT_RING (chan, 0);
1043 OUT_RINGf (chan, 1.0);
1044 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_TX0_4F_S, 4);
1045 OUT_RINGf (chan, 0.0);
1046 OUT_RINGf (chan, 0.0);
1047 OUT_RINGf (chan, 0.0);
1048 OUT_RINGf (chan, 1.0);
1049 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_TX1_4F_S, 4);
1050 OUT_RINGf (chan, 0.0);
1051 OUT_RINGf (chan, 0.0);
1052 OUT_RINGf (chan, 0.0);
1053 OUT_RINGf (chan, 1.0);
1054 BEGIN_RING(chan, celsius, NV10TCL_VERTEX_FOG_1F, 1);
1055 OUT_RINGf (chan, 0.0);
1056 BEGIN_RING(chan, celsius, NV10TCL_EDGEFLAG_ENABLE, 1);
1057 OUT_RING (chan, 1);
1058
1059 return TRUE;
1060 }
1061
1062 /* AROS CODE */
1063
1064 /* NOTE: Assumes lock on bitmap is already made */
1065 /* NOTE: Assumes buffer is not mapped */
1066 /* NOTE: Allows different formats of source and destination */
1067 BOOL HIDDNouveauNV103DCopyBox(struct CardData * carddata,
1068 struct HIDDNouveauBitMapData * srcdata, struct HIDDNouveauBitMapData * destdata,
1069 LONG srcX, LONG srcY, LONG destX, LONG destY, LONG width, LONG height,
1070 ULONG blendop)
1071 {
1072 struct Picture sPict, dPict;
1073 LONG maskX = 0; LONG maskY = 0;
1074
1075 HIDDNouveauFillPictureFromBitMapData(&sPict, srcdata);
1076 HIDDNouveauFillPictureFromBitMapData(&dPict, destdata);
1077
1078 if (NV10EXAPrepareComposite(blendop,
1079 &sPict, NULL, &dPict, srcdata, NULL, destdata))
1080 {
1081 NV10EXAComposite(destdata, srcX, srcY,
1082 maskX, maskY,
1083 destX , destY,
1084 width, height, &sPict, NULL);
1085 return TRUE;
1086 }
1087
1088 return FALSE;
1089 }
Mirror of AROS' svn.