?  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 / nv_accel_common.c
blob2ab52bb2adf0e40f550a97f518b593af5324c4c9
1 /*
2 * Copyright 2007 Ben Skeggs
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 "nv04_pushbuf.h"
25 #if defined(__AROS__)
26 #include <aros/debug.h>
27 #endif
28
29 #if !defined(__AROS__)
30 Bool
31 nouveau_allocate_surface(ScrnInfoPtr scrn, int width, int height, int bpp,
32 int usage_hint, int *pitch, struct nouveau_bo **bo)
33 {
34 NVPtr pNv = NVPTR(scrn);
35 Bool scanout = (usage_hint & NOUVEAU_CREATE_PIXMAP_SCANOUT);
36 Bool tiled = (usage_hint & NOUVEAU_CREATE_PIXMAP_TILED);
37 int tile_mode = 0, tile_flags = 0;
38 int flags = NOUVEAU_BO_MAP | (bpp >= 8 ? NOUVEAU_BO_VRAM : 0);
39 int cpp = bpp / 8, ret;
40
41 if (pNv->Architecture >= NV_ARCH_50) {
42 if (scanout) {
43 if (pNv->tiled_scanout) {
44 tiled = TRUE;
45 *pitch = NOUVEAU_ALIGN(width * cpp, 64);
46 } else {
47 *pitch = NOUVEAU_ALIGN(width * cpp, 256);
48 }
49 } else {
50 if (bpp >= 8)
51 tiled = TRUE;
52 *pitch = NOUVEAU_ALIGN(width * cpp, 64);
53 }
54 } else {
55 if (scanout && pNv->tiled_scanout)
56 tiled = TRUE;
57 *pitch = NOUVEAU_ALIGN(width * cpp, 64);
58 }
59
60 if (tiled) {
61 if (pNv->Architecture >= NV_ARCH_C0) {
62 if (height > 64)
63 tile_mode = 0x40;
64 else if (height > 32)
65 tile_mode = 0x30;
66 else if (height > 16)
67 tile_mode = 0x20;
68 else if (height > 8)
69 tile_mode = 0x10;
70 else
71 tile_mode = 0x00;
72
73 if (usage_hint & NOUVEAU_CREATE_PIXMAP_ZETA)
74 tile_flags = 0x1100; /* S8Z24 */
75 else
76 tile_flags = 0xfe00;
77
78 height = NOUVEAU_ALIGN(
79 height, NVC0_TILE_HEIGHT(tile_mode));
80 } else if (pNv->Architecture >= NV_ARCH_50) {
81 if (height > 32)
82 tile_mode = 4;
83 else if (height > 16)
84 tile_mode = 3;
85 else if (height > 8)
86 tile_mode = 2;
87 else if (height > 4)
88 tile_mode = 1;
89 else
90 tile_mode = 0;
91
92 if (usage_hint & NOUVEAU_CREATE_PIXMAP_ZETA)
93 tile_flags = 0x22800;
94 else if (usage_hint & NOUVEAU_CREATE_PIXMAP_SCANOUT)
95 tile_flags = (bpp == 16 ? 0x7000 : 0x7a00);
96 else
97 tile_flags = 0x7000;
98
99 height = NOUVEAU_ALIGN(height, 1 << (tile_mode + 2));
100 } else {
101 int pitch_align = max(
102 pNv->dev->chipset >= 0x40 ? 1024 : 256,
103 round_down_pow2(*pitch / 4));
104
105 tile_mode = *pitch =
106 NOUVEAU_ALIGN(*pitch, pitch_align);
107 }
108 }
109
110 if (bpp == 32)
111 tile_flags |= NOUVEAU_BO_TILE_32BPP;
112 else if (bpp == 16)
113 tile_flags |= NOUVEAU_BO_TILE_16BPP;
114
115 if (usage_hint & NOUVEAU_CREATE_PIXMAP_ZETA)
116 tile_flags |= NOUVEAU_BO_TILE_ZETA;
117
118 if (usage_hint & NOUVEAU_CREATE_PIXMAP_SCANOUT)
119 tile_flags |= NOUVEAU_BO_TILE_SCANOUT;
120
121 ret = nouveau_bo_new_tile(pNv->dev, flags, 0, *pitch * height,
122 tile_mode, tile_flags, bo);
123 if (ret)
124 return FALSE;
125
126 return TRUE;
127 }
128
129 void
130 NV11SyncToVBlank(PixmapPtr ppix, BoxPtr box)
131 {
132 ScrnInfoPtr pScrn = xf86Screens[ppix->drawable.pScreen->myNum];
133 NVPtr pNv = NVPTR(pScrn);
134 struct nouveau_channel *chan = pNv->chan;
135 struct nouveau_grobj *blit = pNv->NvImageBlit;
136 int crtcs;
137
138 if (!nouveau_exa_pixmap_is_onscreen(ppix))
139 return;
140
141 crtcs = nv_window_belongs_to_crtc(pScrn, box->x1, box->y1,
142 box->x2 - box->x1,
143 box->y2 - box->y1);
144 if (!crtcs)
145 return;
146
147 BEGIN_RING(chan, blit, 0x0000012C, 1);
148 OUT_RING (chan, 0);
149 BEGIN_RING(chan, blit, 0x00000134, 1);
150 OUT_RING (chan, ffs(crtcs) - 1);
151 BEGIN_RING(chan, blit, 0x00000100, 1);
152 OUT_RING (chan, 0);
153 BEGIN_RING(chan, blit, 0x00000130, 1);
154 OUT_RING (chan, 0);
155 }
156 #endif
157
158 static Bool
159 NVAccelInitDmaNotifier0(ScrnInfoPtr pScrn)
160 {
161 NVPtr pNv = NVPTR(pScrn);
162
163 if (!pNv->notify0) {
164 if (nouveau_notifier_alloc(pNv->chan, NvDmaNotifier0, 1,
165 &pNv->notify0))
166 return FALSE;
167 }
168
169 return TRUE;
170 }
171
172 /* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
173 static Bool
174 NVAccelInitContextSurfaces(ScrnInfoPtr pScrn)
175 {
176 NVPtr pNv = NVPTR(pScrn);
177 struct nouveau_channel *chan = pNv->chan;
178 struct nouveau_grobj *surf2d;
179 uint32_t class;
180
181 class = (pNv->Architecture >= NV_ARCH_10) ? NV10_CONTEXT_SURFACES_2D :
182 NV04_CONTEXT_SURFACES_2D;
183
184 if (!pNv->NvContextSurfaces) {
185 if (nouveau_grobj_alloc(chan, NvContextSurfaces, class,
186 &pNv->NvContextSurfaces))
187 return FALSE;
188 }
189 surf2d = pNv->NvContextSurfaces;
190
191 BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_DMA_NOTIFY, 1);
192 OUT_RING (chan, chan->nullobj->handle);
193 BEGIN_RING(chan, surf2d,
194 NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE, 2);
195 OUT_RING (chan, pNv->chan->vram->handle);
196 OUT_RING (chan, pNv->chan->vram->handle);
197
198 return TRUE;
199 }
200
201 #if !defined(__AROS__)
202 /* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
203 static Bool
204 NVAccelInitContextBeta1(ScrnInfoPtr pScrn)
205 {
206 NVPtr pNv = NVPTR(pScrn);
207 struct nouveau_channel *chan = pNv->chan;
208 struct nouveau_grobj *beta1;
209
210 if (!pNv->NvContextBeta1) {
211 if (nouveau_grobj_alloc(chan, NvContextBeta1, 0x12,
212 &pNv->NvContextBeta1))
213 return FALSE;
214 }
215 beta1 = pNv->NvContextBeta1;
216
217 BEGIN_RING(chan, beta1, 0x300, 1); /*alpha factor*/
218 OUT_RING (chan, 0xff << 23);
219
220 return TRUE;
221 }
222
223
224 static Bool
225 NVAccelInitContextBeta4(ScrnInfoPtr pScrn)
226 {
227 NVPtr pNv = NVPTR(pScrn);
228 struct nouveau_channel *chan = pNv->chan;
229 struct nouveau_grobj *beta4;
230
231 if (!pNv->NvContextBeta4) {
232 if (nouveau_grobj_alloc(chan, NvContextBeta4, 0x72,
233 &pNv->NvContextBeta4))
234 return FALSE;
235 }
236 beta4 = pNv->NvContextBeta4;
237
238 BEGIN_RING(chan, beta4, 0x300, 1); /*RGBA factor*/
239 OUT_RING (chan, 0xffff0000);
240 return TRUE;
241 }
242 #endif
243
244 Bool
245 NVAccelGetCtxSurf2DFormatFromPixmap(PixmapPtr pPix, int *fmt_ret)
246 {
247 #if !defined(__AROS__)
248 switch (pPix->drawable.bitsPerPixel) {
249 #else
250 switch (pPix->depth) {
251 #endif
252 case 32:
253 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8;
254 break;
255 case 24:
256 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8;
257 break;
258 case 16:
259 #if !defined(__AROS__)
260 if (pPix->drawable.depth == 16)
261 #else
262 if (pPix->depth == 16)
263 #endif
264 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5;
265 else
266 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_Z1R5G5B5;
267 break;
268 case 8:
269 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_Y8;
270 break;
271 default:
272 return FALSE;
273 }
274
275 return TRUE;
276 }
277
278 #if !defined(__AROS__)
279 Bool
280 NVAccelGetCtxSurf2DFormatFromPicture(PicturePtr pPict, int *fmt_ret)
281 {
282 switch (pPict->format) {
283 case PICT_a8r8g8b8:
284 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8;
285 break;
286 case PICT_x8r8g8b8:
287 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8;
288 break;
289 case PICT_r5g6b5:
290 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5;
291 break;
292 case PICT_a8:
293 *fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_Y8;
294 break;
295 default:
296 return FALSE;
297 }
298
299 return TRUE;
300 }
301
302 /* A copy of exaGetOffscreenPixmap(), since it's private. */
303 PixmapPtr
304 NVGetDrawablePixmap(DrawablePtr pDraw)
305 {
306 if (pDraw->type == DRAWABLE_WINDOW)
307 return pDraw->pScreen->GetWindowPixmap ((WindowPtr) pDraw);
308 else
309 return (PixmapPtr) pDraw;
310 }
311 #endif
312
313 static Bool
314 NVAccelInitImagePattern(ScrnInfoPtr pScrn)
315 {
316 NVPtr pNv = NVPTR(pScrn);
317 struct nouveau_channel *chan = pNv->chan;
318 struct nouveau_grobj *patt;
319
320 if (!pNv->NvImagePattern) {
321 if (nouveau_grobj_alloc(chan, NvImagePattern,
322 NV04_IMAGE_PATTERN,
323 &pNv->NvImagePattern))
324 return FALSE;
325 }
326 patt = pNv->NvImagePattern;
327
328 BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_DMA_NOTIFY, 1);
329 OUT_RING (chan, chan->nullobj->handle);
330 BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT, 3);
331 #if X_BYTE_ORDER == X_BIG_ENDIAN
332 OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE);
333 #else
334 OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_CGA6);
335 #endif
336 OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8);
337 OUT_RING (chan, NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO);
338
339 return TRUE;
340 }
341
342 static Bool
343 NVAccelInitRasterOp(ScrnInfoPtr pScrn)
344 {
345 NVPtr pNv = NVPTR(pScrn);
346 struct nouveau_channel *chan = pNv->chan;
347 struct nouveau_grobj *rop;
348
349 if (!pNv->NvRop) {
350 if (nouveau_grobj_alloc(chan, NvRop, NV03_CONTEXT_ROP,
351 &pNv->NvRop))
352 return FALSE;
353 }
354 rop = pNv->NvRop;
355
356 BEGIN_RING(chan, rop, NV03_CONTEXT_ROP_DMA_NOTIFY, 1);
357 OUT_RING (chan, chan->nullobj->handle);
358
359 // pNv->currentRop = ~0;
360 return TRUE;
361 }
362
363 static Bool
364 NVAccelInitRectangle(ScrnInfoPtr pScrn)
365 {
366 NVPtr pNv = NVPTR(pScrn);
367 struct nouveau_channel *chan = pNv->chan;
368 struct nouveau_grobj *rect;
369
370 if (!pNv->NvRectangle) {
371 if (nouveau_grobj_alloc(chan, NvRectangle,
372 NV04_GDI_RECTANGLE_TEXT,
373 &pNv->NvRectangle))
374 return FALSE;
375 }
376 rect = pNv->NvRectangle;
377
378 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY, 1);
379 OUT_RING (chan, pNv->notify0->handle);
380 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_DMA_FONTS, 1);
381 OUT_RING (chan, chan->nullobj->handle);
382 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
383 OUT_RING (chan, pNv->NvContextSurfaces->handle);
384 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_ROP, 1);
385 OUT_RING (chan, pNv->NvRop->handle);
386 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
387 OUT_RING (chan, pNv->NvImagePattern->handle);
388 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
389 OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND);
390 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT, 1);
391 /* XXX why putting 1 like renouveau dump, swap the text */
392 #if 1 || X_BYTE_ORDER == X_BIG_ENDIAN
393 OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE);
394 #else
395 OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_CGA6);
396 #endif
397
398 return TRUE;
399 }
400
401 static Bool
402 NVAccelInitImageBlit(ScrnInfoPtr pScrn)
403 {
404 NVPtr pNv = NVPTR(pScrn);
405 struct nouveau_channel *chan = pNv->chan;
406 struct nouveau_grobj *blit;
407 uint32_t class;
408
409 class = (pNv->dev->chipset >= 0x11) ? NV12_IMAGE_BLIT : NV04_IMAGE_BLIT;
410
411 if (!pNv->NvImageBlit) {
412 if (nouveau_grobj_alloc(chan, NvImageBlit, class,
413 &pNv->NvImageBlit))
414 return FALSE;
415 }
416 blit = pNv->NvImageBlit;
417
418 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_DMA_NOTIFY, 1);
419 OUT_RING (chan, pNv->notify0->handle);
420 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_COLOR_KEY, 1);
421 OUT_RING (chan, chan->nullobj->handle);
422 BEGIN_RING(chan, blit, NV04_IMAGE_BLIT_SURFACE, 1);
423 OUT_RING (chan, pNv->NvContextSurfaces->handle);
424 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_CLIP_RECTANGLE, 3);
425 OUT_RING (chan, chan->nullobj->handle);
426 OUT_RING (chan, pNv->NvImagePattern->handle);
427 OUT_RING (chan, pNv->NvRop->handle);
428 BEGIN_RING(chan, blit, NV01_IMAGE_BLIT_OPERATION, 1);
429 OUT_RING (chan, NV01_IMAGE_BLIT_OPERATION_ROP_AND);
430
431 if (blit->grclass == NV12_IMAGE_BLIT) {
432 BEGIN_RING(chan, blit, 0x0120, 3);
433 OUT_RING (chan, 0);
434 OUT_RING (chan, 1);
435 OUT_RING (chan, 2);
436 }
437
438 return TRUE;
439 }
440
441 #if !defined(__AROS__)
442 static Bool
443 NVAccelInitScaledImage(ScrnInfoPtr pScrn)
444 {
445 NVPtr pNv = NVPTR(pScrn);
446 struct nouveau_channel *chan = pNv->chan;
447 struct nouveau_grobj *sifm;
448 uint32_t class;
449
450 switch (pNv->Architecture) {
451 case NV_ARCH_04:
452 class = NV04_SCALED_IMAGE_FROM_MEMORY;
453 break;
454 case NV_ARCH_10:
455 case NV_ARCH_20:
456 case NV_ARCH_30:
457 class = NV10_SCALED_IMAGE_FROM_MEMORY;
458 break;
459 case NV_ARCH_40:
460 default:
461 class = NV10_SCALED_IMAGE_FROM_MEMORY | 0x3000;
462 break;
463 }
464
465 if (!pNv->NvScaledImage) {
466 if (nouveau_grobj_alloc(chan, NvScaledImage, class,
467 &pNv->NvScaledImage))
468 return FALSE;
469 }
470 sifm = pNv->NvScaledImage;
471
472 BEGIN_RING(chan, sifm,
473 NV03_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY, 7);
474 OUT_RING (chan, pNv->notify0->handle);
475 OUT_RING (chan, pNv->chan->vram->handle);
476 OUT_RING (chan, chan->nullobj->handle);
477 OUT_RING (chan, chan->nullobj->handle);
478 OUT_RING (chan, pNv->NvContextBeta1->handle);
479 OUT_RING (chan, pNv->NvContextBeta4->handle);
480 OUT_RING (chan, pNv->NvContextSurfaces->handle);
481 if (pNv->Architecture>=NV_ARCH_10) {
482 BEGIN_RING(chan, sifm,
483 NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 1);
484 OUT_RING (chan, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_DITHER);
485 }
486 BEGIN_RING(chan, sifm, NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION, 1);
487 OUT_RING (chan, NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY);
488
489 return TRUE;
490 }
491
492 static Bool
493 NVAccelInitClipRectangle(ScrnInfoPtr pScrn)
494 {
495 NVPtr pNv = NVPTR(pScrn);
496 struct nouveau_channel *chan = pNv->chan;
497 struct nouveau_grobj *clip;
498
499 if (!pNv->NvClipRectangle) {
500 if (nouveau_grobj_alloc(pNv->chan, NvClipRectangle,
501 NV01_CONTEXT_CLIP_RECTANGLE,
502 &pNv->NvClipRectangle))
503 return FALSE;
504 }
505 clip = pNv->NvClipRectangle;
506
507 BEGIN_RING(chan, clip, NV01_CONTEXT_CLIP_RECTANGLE_DMA_NOTIFY, 1);
508 OUT_RING (chan, chan->nullobj->handle);
509
510 return TRUE;
511 }
512 #endif
513
514 /* FLAGS_NONE, NvDmaFB, NvDmaAGP, NvDmaNotifier0 */
515 static Bool
516 NVAccelInitMemFormat(ScrnInfoPtr pScrn)
517 {
518 NVPtr pNv = NVPTR(pScrn);
519 struct nouveau_channel *chan = pNv->chan;
520 struct nouveau_grobj *m2mf;
521 uint32_t class;
522
523 if (pNv->Architecture < NV_ARCH_50)
524 class = NV04_MEMORY_TO_MEMORY_FORMAT;
525 else
526 class = NV50_MEMORY_TO_MEMORY_FORMAT;
527
528 if (!pNv->NvMemFormat) {
529 if (nouveau_grobj_alloc(chan, NvMemFormat, class,
530 &pNv->NvMemFormat))
531 return FALSE;
532 }
533 m2mf = pNv->NvMemFormat;
534
535 BEGIN_RING(chan, m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1);
536 OUT_RING (chan, pNv->notify0->handle);
537 BEGIN_RING(chan, m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_IN, 2);
538 OUT_RING (chan, chan->vram->handle);
539 OUT_RING (chan, chan->vram->handle);
540
541 return TRUE;
542 }
543
544 #if !defined(__AROS__)
545 static Bool
546 NVAccelInitImageFromCpu(ScrnInfoPtr pScrn)
547 {
548 NVPtr pNv = NVPTR(pScrn);
549 struct nouveau_channel *chan = pNv->chan;
550 struct nouveau_grobj *ifc;
551 uint32_t class;
552
553 switch (pNv->Architecture) {
554 case NV_ARCH_04:
555 class = NV04_IMAGE_FROM_CPU;
556 break;
557 case NV_ARCH_10:
558 case NV_ARCH_20:
559 case NV_ARCH_30:
560 case NV_ARCH_40:
561 default:
562 class = NV10_IMAGE_FROM_CPU;
563 break;
564 }
565
566 if (!pNv->NvImageFromCpu) {
567 if (nouveau_grobj_alloc(chan, NvImageFromCpu, class,
568 &pNv->NvImageFromCpu))
569 return FALSE;
570 }
571 ifc = pNv->NvImageFromCpu;
572
573 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_DMA_NOTIFY, 1);
574 OUT_RING (chan, pNv->notify0->handle);
575 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_CLIP_RECTANGLE, 1);
576 OUT_RING (chan, chan->nullobj->handle);
577 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_PATTERN, 1);
578 OUT_RING (chan, chan->nullobj->handle);
579 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_ROP, 1);
580 OUT_RING (chan, chan->nullobj->handle);
581 if (pNv->Architecture >= NV_ARCH_10) {
582 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_BETA1, 1);
583 OUT_RING (chan, chan->nullobj->handle);
584 BEGIN_RING(chan, ifc, NV04_IMAGE_FROM_CPU_BETA4, 1);
585 OUT_RING (chan, chan->nullobj->handle);
586 }
587 BEGIN_RING(chan, ifc, NV04_IMAGE_FROM_CPU_SURFACE, 1);
588 OUT_RING (chan, pNv->NvContextSurfaces->handle);
589 BEGIN_RING(chan, ifc, NV01_IMAGE_FROM_CPU_OPERATION, 1);
590 OUT_RING (chan, NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY);
591
592 return TRUE;
593 }
594 #endif
595
596 static Bool
597 NVAccelInit2D_NV50(ScrnInfoPtr pScrn)
598 {
599 NVPtr pNv = NVPTR(pScrn);
600 struct nouveau_channel *chan = pNv->chan;
601 struct nouveau_grobj *eng2d;
602
603 if (!pNv->Nv2D) {
604 if (nouveau_grobj_alloc(chan, Nv2D, NV50_2D, &pNv->Nv2D))
605 return FALSE;
606 }
607 eng2d = pNv->Nv2D;
608
609 BEGIN_RING(chan, eng2d, NV50_2D_DMA_NOTIFY, 3);
610 OUT_RING (chan, pNv->notify0->handle);
611 OUT_RING (chan, pNv->chan->vram->handle);
612 OUT_RING (chan, pNv->chan->vram->handle);
613
614 /* Magics from nv, no clue what they do, but at least some
615 * of them are needed to avoid crashes.
616 */
617 BEGIN_RING(chan, eng2d, 0x260, 1);
618 OUT_RING (chan, 1);
619 BEGIN_RING(chan, eng2d, NV50_2D_CLIP_ENABLE, 1);
620 OUT_RING (chan, 1);
621 BEGIN_RING(chan, eng2d, NV50_2D_COLOR_KEY_ENABLE, 1);
622 OUT_RING (chan, 0);
623 BEGIN_RING(chan, eng2d, 0x58c, 1);
624 OUT_RING (chan, 0x111);
625
626 // pNv->currentRop = 0xfffffffa;
627 return TRUE;
628 }
629
630 #if !defined(__AROS__)
631 #define INIT_CONTEXT_OBJECT(name) do { \
632 ret = NVAccelInit##name(pScrn); \
633 if (!ret) { \
634 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, \
635 "Failed to initialise context object: "#name \
636 " (%d)\n", ret); \
637 return FALSE; \
638 } \
639 } while(0)
640 #else
641 #define INIT_CONTEXT_OBJECT(name) do { \
642 ret = NVAccelInit##name(pScrn); \
643 if (!ret) { \
644 bug("[nouveau] Failed to initialise context object: "#name \
645 " (%d)\n", ret); \
646 return FALSE; \
647 } \
648 } while(0)
649 #endif
650
651 Bool
652 NVAccelCommonInit(ScrnInfoPtr pScrn)
653 {
654 NVPtr pNv = NVPTR(pScrn);
655 Bool ret;
656
657 #if !defined(__AROS__)
658 if (pNv->NoAccel)
659 return TRUE;
660 #endif
661
662 /* General engine objects */
663 if (pNv->Architecture < NV_ARCH_C0)
664 INIT_CONTEXT_OBJECT(DmaNotifier0);
665
666 /* 2D engine */
667 if (pNv->Architecture < NV_ARCH_50) {
668 INIT_CONTEXT_OBJECT(ContextSurfaces);
669 #if !defined(__AROS__)
670 INIT_CONTEXT_OBJECT(ContextBeta1);
671 INIT_CONTEXT_OBJECT(ContextBeta4);
672 #endif
673 INIT_CONTEXT_OBJECT(ImagePattern);
674 INIT_CONTEXT_OBJECT(RasterOp);
675 INIT_CONTEXT_OBJECT(Rectangle);
676 INIT_CONTEXT_OBJECT(ImageBlit);
677 #if !defined(__AROS__)
678 INIT_CONTEXT_OBJECT(ScaledImage);
679 INIT_CONTEXT_OBJECT(ClipRectangle);
680 INIT_CONTEXT_OBJECT(ImageFromCpu);
681 #endif
682 } else
683 if (pNv->Architecture < NV_ARCH_C0) {
684 INIT_CONTEXT_OBJECT(2D_NV50);
685 } else {
686 INIT_CONTEXT_OBJECT(2D_NVC0);
687 }
688
689 if (pNv->Architecture < NV_ARCH_C0)
690 INIT_CONTEXT_OBJECT(MemFormat);
691 else
692 INIT_CONTEXT_OBJECT(M2MF_NVC0);
693
694 /* 3D init */
695 switch (pNv->Architecture) {
696 case NV_ARCH_C0:
697 INIT_CONTEXT_OBJECT(3D_NVC0);
698 break;
699 case NV_ARCH_50:
700 INIT_CONTEXT_OBJECT(NV50TCL);
701 break;
702 case NV_ARCH_40:
703 INIT_CONTEXT_OBJECT(NV40TCL);
704 break;
705 case NV_ARCH_30:
706 INIT_CONTEXT_OBJECT(NV30TCL);
707 break;
708 case NV_ARCH_20:
709 case NV_ARCH_10:
710 INIT_CONTEXT_OBJECT(NV10TCL);
711 break;
712 default:
713 break;
714 }
715
716 return TRUE;
717 }
718
719 void NVAccelFree(ScrnInfoPtr pScrn)
720 {
721 NVPtr pNv = NVPTR(pScrn);
722
723 #if !defined(__AROS__)
724 if (pNv->NoAccel)
725 return;
726 #endif
727
728 nouveau_notifier_free(&pNv->notify0);
729 nouveau_notifier_free(&pNv->vblank_sem);
730
731 nouveau_grobj_free(&pNv->NvContextSurfaces);
732 #if !defined(__AROS__)
733 nouveau_grobj_free(&pNv->NvContextBeta1);
734 nouveau_grobj_free(&pNv->NvContextBeta4);
735 #endif
736 nouveau_grobj_free(&pNv->NvImagePattern);
737 nouveau_grobj_free(&pNv->NvRop);
738 nouveau_grobj_free(&pNv->NvRectangle);
739 nouveau_grobj_free(&pNv->NvImageBlit);
740 #if !defined(__AROS__)
741 nouveau_grobj_free(&pNv->NvScaledImage);
742 nouveau_grobj_free(&pNv->NvClipRectangle);
743 nouveau_grobj_free(&pNv->NvImageFromCpu);
744 #endif
745 nouveau_grobj_free(&pNv->Nv2D);
746 nouveau_grobj_free(&pNv->NvMemFormat);
747 nouveau_grobj_free(&pNv->NvSW);
748 nouveau_grobj_free(&pNv->Nv3D);
749
750 nouveau_bo_ref(NULL, &pNv->tesla_scratch);
751 nouveau_bo_ref(NULL, &pNv->shader_mem);
752 }
753
754
755 /* AROS CODE */
756
757 BOOL HIDDNouveauAccelCommonInit(struct CardData * carddata)
758 {
759 return NVAccelCommonInit(carddata);
760 }
761
762 VOID HIDDNouveauAccelFree(struct CardData * carddata)
763 {
764 NVAccelFree(carddata);
765 }
Mirror of AROS' svn.