?  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 / nv04_exa.c
blobea7068ad9bd5922da10e8d726659937c613e6fa2
1 /*
2 * Copyright 2003 NVIDIA, Corporation
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 shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
18 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
19 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #include "nv_include.h"
24 #include "nv_rop.h"
25
26 #include "nv04_pushbuf.h"
27
28 static void
29 NV04EXASetPattern(ScrnInfoPtr pScrn, CARD32 clr0, CARD32 clr1,
30 CARD32 pat0, CARD32 pat1)
31 {
32 NVPtr pNv = NVPTR(pScrn);
33 struct nouveau_channel *chan = pNv->chan;
34 struct nouveau_grobj *patt = pNv->NvImagePattern;
35
36 BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR0, 4);
37 OUT_RING (chan, clr0);
38 OUT_RING (chan, clr1);
39 OUT_RING (chan, pat0);
40 OUT_RING (chan, pat1);
41 }
42
43 #if !defined(__AROS__)
44 static void
45 NV04EXASetROP(ScrnInfoPtr pScrn, CARD32 alu, CARD32 planemask)
46 {
47 NVPtr pNv = NVPTR(pScrn);
48 struct nouveau_channel *chan = pNv->chan;
49 struct nouveau_grobj *rop = pNv->NvRop;
50
51 if (planemask != ~0) {
52 NV04EXASetPattern(pScrn, 0, planemask, ~0, ~0);
53 if (pNv->currentRop != (alu + 32)) {
54 BEGIN_RING(chan, rop, NV03_CONTEXT_ROP_ROP, 1);
55 OUT_RING (chan, NVROP[alu].copy_planemask);
56 pNv->currentRop = alu + 32;
57 }
58 } else
59 if (pNv->currentRop != alu) {
60 if(pNv->currentRop >= 16)
61 NV04EXASetPattern(pScrn, ~0, ~0, ~0, ~0);
62 BEGIN_RING(chan, rop, NV03_CONTEXT_ROP_ROP, 1);
63 OUT_RING (chan, NVROP[alu].copy);
64 pNv->currentRop = alu;
65 }
66 }
67 #else
68 static void
69 NV04EXASetROP(ScrnInfoPtr pScrn, CARD32 alu, CARD32 planemask)
70 {
71 NVPtr pNv = NVPTR(pScrn);
72 struct nouveau_channel *chan = pNv->chan;
73 struct nouveau_grobj *rop = pNv->NvRop;
74
75 BEGIN_RING(chan, rop, NV03_CONTEXT_ROP_ROP, 1);
76 OUT_RING (chan, NVROP[alu].copy);
77 }
78 #endif
79
80 #if !defined(__AROS__)
81 static void
82 NV04EXAStateSolidResubmit(struct nouveau_channel *chan)
83 {
84 ScrnInfoPtr pScrn = chan->user_private;
85 NVPtr pNv = NVPTR(pScrn);
86
87 NV04EXAPrepareSolid(pNv->pdpix, pNv->alu, pNv->planemask, pNv->fg_colour);
88 }
89 #endif
90
91 Bool
92 NV04EXAPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planemask, Pixel fg)
93 {
94 #if !defined(__AROS__)
95 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
96 #else
97 ScrnInfoPtr pScrn = globalcarddataptr;
98 #endif
99 NVPtr pNv = NVPTR(pScrn);
100 struct nouveau_channel *chan = pNv->chan;
101 struct nouveau_grobj *surf2d = pNv->NvContextSurfaces;
102 struct nouveau_grobj *rect = pNv->NvRectangle;
103 struct nouveau_bo *bo = nouveau_pixmap_bo(pPixmap);
104 unsigned int fmt, pitch, fmt2 = NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8;
105
106 if (MARK_RING(chan, 64, 2))
107 return FALSE;
108
109 #if !defined(__AROS__)
110 planemask |= ~0 << pPixmap->drawable.bitsPerPixel;
111 if (planemask != ~0 || alu != GXcopy) {
112 if (pPixmap->drawable.bitsPerPixel == 32)
113 return FALSE;
114 #else
115 if (alu != 0x03 /* DrawMode_Copy */) {
116 #endif
117 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
118 OUT_RING (chan, 1); /* ROP_AND */
119 NV04EXASetROP(pScrn, alu, planemask);
120 } else {
121 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
122 OUT_RING (chan, 3); /* SRCCOPY */
123 }
124
125 if (!NVAccelGetCtxSurf2DFormatFromPixmap(pPixmap, (int*)&fmt))
126 return FALSE;
127 pitch = exaGetPixmapPitch(pPixmap);
128
129 #if !defined(__AROS__)
130 if (pPixmap->drawable.bitsPerPixel == 16) {
131 if (pPixmap->drawable.depth == 16) {
132 fmt2 = NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5;
133 } else if (pPixmap->drawable.depth == 15) {
134 fmt2 = NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_X16A1R5G5B5;
135 }
136 }
137 #else
138 if (pPixmap->depth == 16)
139 fmt2 = NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5;
140 #endif
141
142 /* When SURFACE_FORMAT_A8R8G8B8 is used with GDI_RECTANGLE_TEXT, the
143 * alpha channel gets forced to 0xFF for some reason. We're using
144 * SURFACE_FORMAT_Y32 as a workaround
145 */
146 if (fmt == NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8)
147 fmt = NV04_CONTEXT_SURFACES_2D_FORMAT_Y32;
148
149 BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
150 OUT_RING (chan, fmt);
151 OUT_RING (chan, (pitch << 16) | pitch);
152 if (OUT_RELOCl(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR) ||
153 OUT_RELOCl(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR)) {
154 MARK_UNDO(chan);
155 return FALSE;
156 }
157
158 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT, 1);
159 OUT_RING (chan, fmt2);
160 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR1_A, 1);
161 OUT_RING (chan, fg);
162
163 #if !defined(__AROS__)
164 pNv->pdpix = pPixmap;
165 pNv->alu = alu;
166 pNv->planemask = planemask;
167 pNv->fg_colour = fg;
168 chan->flush_notify = NV04EXAStateSolidResubmit;
169 #else
170 chan->flush_notify = NULL;
171 #endif
172 return TRUE;
173 }
174
175 void
176 NV04EXASolid (PixmapPtr pPixmap, int x1, int y1, int x2, int y2)
177 {
178 #if !defined(__AROS__)
179 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
180 #else
181 ScrnInfoPtr pScrn = globalcarddataptr;
182 #endif
183 NVPtr pNv = NVPTR(pScrn);
184 struct nouveau_channel *chan = pNv->chan;
185 struct nouveau_grobj *rect = pNv->NvRectangle;
186 int width = x2-x1;
187 int height = y2-y1;
188
189 BEGIN_RING(chan, rect,
190 NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT(0), 2);
191 OUT_RING (chan, (x1 << 16) | y1);
192 OUT_RING (chan, (width << 16) | height);
193
194 #if !defined(__AROS__)
195 if((width * height) >= 512)
196 #endif
197 FIRE_RING (chan);
198 }
199
200 #if !defined(__AROS__)
201 void
202 NV04EXADoneSolid (PixmapPtr pPixmap)
203 {
204 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
205 NVPtr pNv = NVPTR(pScrn);
206
207 pNv->chan->flush_notify = NULL;
208 }
209
210 static void
211 NV04EXAStateCopyResubmit(struct nouveau_channel *chan)
212 {
213 ScrnInfoPtr pScrn = chan->user_private;
214 NVPtr pNv = NVPTR(pScrn);
215
216 NV04EXAPrepareCopy(pNv->pspix, pNv->pdpix, 0, 0, pNv->alu,
217 pNv->planemask);
218 }
219 #endif
220
221 Bool
222 NV04EXAPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int dx, int dy,
223 int alu, Pixel planemask)
224 {
225 #if !defined(__AROS__)
226 ScrnInfoPtr pScrn = xf86Screens[pSrcPixmap->drawable.pScreen->myNum];
227 #else
228 ScrnInfoPtr pScrn = globalcarddataptr;
229 #endif
230 NVPtr pNv = NVPTR(pScrn);
231 struct nouveau_channel *chan = pNv->chan;
232 struct nouveau_grobj *surf2d = pNv->NvContextSurfaces;
233 struct nouveau_grobj *blit = pNv->NvImageBlit;
234 struct nouveau_bo *src_bo = nouveau_pixmap_bo(pSrcPixmap);
235 struct nouveau_bo *dst_bo = nouveau_pixmap_bo(pDstPixmap);
236 int fmt;
237
238 #if !defined(__AROS__)
239 if (pSrcPixmap->drawable.bitsPerPixel !=
240 pDstPixmap->drawable.bitsPerPixel)
241 #else
242 if (pSrcPixmap->depth != pDstPixmap->depth)
243 #endif
244 return FALSE;
245
246 if (!NVAccelGetCtxSurf2DFormatFromPixmap(pDstPixmap, &fmt))
247 return FALSE;
248
249 if (MARK_RING(chan, 64, 2))
250 return FALSE;
251
252 #if !defined(__AROS__)
253 planemask |= ~0 << pDstPixmap->drawable.bitsPerPixel;
254 if (planemask != ~0 || alu != GXcopy) {
255 if (pDstPixmap->drawable.bitsPerPixel == 32) {
256 MARK_UNDO(chan);
257 return FALSE;
258 }
259 #else
260 if (alu != 0x03 /* DrawMode_Copy */) {
261 #endif
262
263 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_OPERATION, 1);
264 OUT_RING (chan, 1); /* ROP_AND */
265
266 NV04EXASetROP(pScrn, alu, planemask);
267 } else {
268 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_OPERATION, 1);
269 OUT_RING (chan, 3); /* SRCCOPY */
270 }
271
272 BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
273 OUT_RING (chan, fmt);
274 OUT_RING (chan, (exaGetPixmapPitch(pDstPixmap) << 16) |
275 (exaGetPixmapPitch(pSrcPixmap)));
276 if (OUT_RELOCl(chan, src_bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD) ||
277 OUT_RELOCl(chan, dst_bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR)) {
278 MARK_UNDO(chan);
279 return FALSE;
280 }
281
282 #if !defined(__AROS__)
283 pNv->pspix = pSrcPixmap;
284 pNv->pdpix = pDstPixmap;
285 pNv->alu = alu;
286 pNv->planemask = planemask;
287 chan->flush_notify = NV04EXAStateCopyResubmit;
288 #else
289 chan->flush_notify = NULL;
290 #endif
291 return TRUE;
292 }
293
294 void
295 NV04EXACopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
296 int width, int height)
297 {
298 #if !defined(__AROS__)
299 ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
300 #else
301 ScrnInfoPtr pScrn = globalcarddataptr;
302 #endif
303 NVPtr pNv = NVPTR(pScrn);
304 struct nouveau_channel *chan = pNv->chan;
305 struct nouveau_grobj *blit = pNv->NvImageBlit;
306 #if !defined(__AROS__)
307 int split_dstY = NOUVEAU_ALIGN(dstY + 1, 64);
308 int split_height = split_dstY - dstY;
309
310 if ((width * height) >= 200000 && pNv->pspix != pNv->pdpix &&
311 (dstY > srcY || dstX > srcX) && split_height < height) {
312 /*
313 * KLUDGE - Split the destination rectangle in an
314 * upper misaligned half and a lower tile-aligned
315 * half, then get IMAGE_BLIT to blit the lower piece
316 * downwards (required for sync-to-vblank if the area
317 * to be blitted is large enough). The blob does a
318 * different (not nicer) trick to achieve the same
319 * effect.
320 */
321 struct nouveau_grobj *surf2d = pNv->NvContextSurfaces;
322 struct nouveau_bo *dst_bo = nouveau_pixmap_bo(pNv->pdpix);
323 unsigned dst_pitch = exaGetPixmapPitch(pNv->pdpix);
324
325 if (MARK_RING(chan, 10, 1))
326 return;
327
328 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_POINT_IN, 3);
329 OUT_RING (chan, (srcY << 16) | srcX);
330 OUT_RING (chan, (dstY << 16) | dstX);
331 OUT_RING (chan, (split_height << 16) | width);
332
333 BEGIN_RING(chan, surf2d,
334 NV04_CONTEXT_SURFACES_2D_OFFSET_DESTIN, 1);
335 OUT_RELOCl(chan, dst_bo, split_dstY * dst_pitch,
336 NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
337
338 srcY += split_height;
339 height -= split_height;
340 dstY = 0;
341 }
342 #endif
343
344 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_POINT_IN, 3);
345 OUT_RING (chan, (srcY << 16) | srcX);
346 OUT_RING (chan, (dstY << 16) | dstX);
347 OUT_RING (chan, (height << 16) | width);
348
349 #if !defined(__AROS__)
350 if((width * height) >= 512)
351 #endif
352 FIRE_RING (chan);
353 }
354
355 #if !defined(__AROS__)
356 void
357 NV04EXADoneCopy(PixmapPtr pDstPixmap)
358 {
359 ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
360 NVPtr pNv = NVPTR(pScrn);
361
362 pNv->chan->flush_notify = NULL;
363 }
364
365 static Bool
366 NV04EXAStateIFCSubmit(struct nouveau_channel *chan)
367 {
368 ScrnInfoPtr pScrn = chan->user_private;
369 NVPtr pNv = NVPTR(pScrn);
370 struct nouveau_grobj *surf2d = pNv->NvContextSurfaces;
371 struct nouveau_grobj *ifc = pNv->NvImageFromCpu;
372 struct nouveau_bo *bo = nouveau_pixmap_bo(pNv->pdpix);
373 int surf_fmt;
374
375 NVAccelGetCtxSurf2DFormatFromPixmap(pNv->pdpix, &surf_fmt);
376
377 if (MARK_RING(chan, 64, 2))
378 return FALSE;
379
380 BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
381 OUT_RING (chan, surf_fmt);
382 OUT_RING (chan, (exaGetPixmapPitch(pNv->pdpix) << 16) |
383 exaGetPixmapPitch(pNv->pdpix));
384 if (OUT_RELOCl(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR) ||
385 OUT_RELOCl(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR)) {
386 MARK_UNDO(chan);
387 return FALSE;
388 }
389 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_POINT, 3);
390 OUT_RING (chan, (pNv->point_y << 16) | pNv->point_x);
391 OUT_RING (chan, (pNv->height_out << 16) | pNv->width_out);
392 OUT_RING (chan, (pNv->height_in << 16) | pNv->width_in);
393
394 return TRUE;
395 }
396
397 static void
398 NV04EXAStateIFCResubmit(struct nouveau_channel *chan)
399 {
400 NV04EXAStateIFCSubmit(chan);
401 }
402
403 Bool
404 NV04EXAUploadIFC(ScrnInfoPtr pScrn, const char *src, int src_pitch,
405 PixmapPtr pDst, int x, int y, int w, int h, int cpp)
406 {
407 NVPtr pNv = NVPTR(pScrn);
408 ScreenPtr pScreen = pDst->drawable.pScreen;
409 struct nouveau_channel *chan = pNv->chan;
410 struct nouveau_grobj *clip = pNv->NvClipRectangle;
411 struct nouveau_grobj *ifc = pNv->NvImageFromCpu;
412 int line_len = w * cpp;
413 int iw, id, surf_fmt, ifc_fmt;
414 int padbytes;
415
416 if (pNv->Architecture >= NV_ARCH_50)
417 return FALSE;
418
419 if (h > 1024)
420 return FALSE;
421
422 if (line_len<4)
423 return FALSE;
424
425 switch (cpp) {
426 case 2: ifc_fmt = 1; break;
427 case 4: ifc_fmt = 4; break;
428 default:
429 return FALSE;
430 }
431
432 if (!NVAccelGetCtxSurf2DFormatFromPixmap(pDst, &surf_fmt))
433 return FALSE;
434
435 /* Pad out input width to cover both COLORA() and COLORB() */
436 iw = (line_len + 7) & ~7;
437 padbytes = iw - line_len;
438 id = iw / 4; /* line push size */
439 iw /= cpp;
440
441 /* Don't support lines longer than max push size yet.. */
442 if (id > 1792)
443 return FALSE;
444
445 BEGIN_RING(chan, clip, NV01_CONTEXT_CLIP_RECTANGLE_POINT, 2);
446 OUT_RING (chan, (y << 16) | x);
447 OUT_RING (chan, (h << 16) | w);
448 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_OPERATION, 2);
449 OUT_RING (chan, NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY);
450 OUT_RING (chan, ifc_fmt);
451
452 pNv->point_x = x;
453 pNv->point_y = y;
454 pNv->height_in = pNv->height_out = h;
455 pNv->width_in = iw;
456 pNv->width_out = w;
457 pNv->pdpix = pDst;
458 chan->flush_notify = NV04EXAStateIFCResubmit;
459 if (!NV04EXAStateIFCSubmit(chan))
460 return FALSE;
461
462 if (padbytes)
463 h--;
464 while (h--) {
465 /* send a line */
466 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_COLOR(0), id);
467 OUT_RINGp (chan, src, id);
468
469 src += src_pitch;
470 pNv->point_y++;
471 }
472 if (padbytes) {
473 char padding[8];
474 int aux = (padbytes + 7) >> 2;
475 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_COLOR(0), id);
476 OUT_RINGp (chan, src, id - aux);
477 memcpy(padding, src + (id - aux) * 4, padbytes);
478 OUT_RINGp (chan, padding, aux);
479 }
480
481 chan->flush_notify = NULL;
482
483 if (pDst == pScreen->GetScreenPixmap(pScreen))
484 FIRE_RING(chan);
485 return TRUE;
486 }
487 #endif
488
489 /* AROS CODE */
490
491 VOID HIDDNouveauNV04SetPattern(struct CardData * carddata, LONG clr0, LONG clr1,
492 LONG pat0, LONG pat1)
493 {
494 NV04EXASetPattern(carddata, clr0, clr1, pat0, pat1);
495 }
496
497 /* NOTE: Assumes lock on bitmap is already made */
498 /* NOTE: Assumes buffer is not mapped */
499 BOOL HIDDNouveauNV04FillSolidRect(struct CardData * carddata,
500 struct HIDDNouveauBitMapData * bmdata, LONG minX, LONG minY, LONG maxX,
501 LONG maxY, ULONG drawmode, ULONG color)
502 {
503 if (NV04EXAPrepareSolid(bmdata, drawmode, ~0, color))
504 {
505 NV04EXASolid(bmdata, minX, minY, maxX + 1, maxY + 1);
506 return TRUE;
507 }
508
509 return FALSE;
510 }
511
512 /* NOTE: Assumes lock on bitmap is already made */
513 /* NOTE: Assumes buffer is not mapped */
514 BOOL HIDDNouveauNV04CopySameFormat(struct CardData * carddata,
515 struct HIDDNouveauBitMapData * srcdata, struct HIDDNouveauBitMapData * destdata,
516 LONG srcX, LONG srcY, LONG destX, LONG destY, LONG width, LONG height,
517 ULONG drawmode)
518 {
519 if (NV04EXAPrepareCopy(srcdata, destdata, 0, 0, drawmode, ~0))
520 {
521 NV04EXACopy(destdata, srcX, srcY, destX, destY, width, height);
522 return TRUE;
523 }
524
525 return FALSE;
526 }
Mirror of AROS' svn.