~ubuntu-branches/ubuntu/karmic/xserver-xorg-video-nouveau/karmic
» Revision
1
: src/nv_accel_common.c
« back to all changes in this revision
Viewing changes to src/nv_accel_common.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Chris Lamb
- Date: 2008-07-06 20:26:53 UTC
- Revision ID: james.westby@ubuntu.com-20080706202653-e99oiii765j3a0qn
Tags: upstream-0.0.10~git+20080706+b1f3169
Import upstream version 0.0.10~git+20080706+b1f3169
- files added:
- man
- src
added
removed
src/nv_accel_common.c
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
25
static Bool
26
NVAccelInitNullObject(ScrnInfoPtr pScrn)
27
{
28
NVPtr pNv = NVPTR(pScrn);
29
30
if (!pNv->NvNull) {
31
if (nouveau_grobj_alloc(pNv->chan, NvNullObject, NV01_NULL,
32
&pNv->NvNull))
33
return FALSE;
34
}
35
36
return TRUE;
37
}
38
39
static Bool
40
NVAccelInitDmaNotifier0(ScrnInfoPtr pScrn)
41
{
42
NVPtr pNv = NVPTR(pScrn);
43
44
if (!pNv->notify0) {
45
if (nouveau_notifier_alloc(pNv->chan, NvDmaNotifier0, 1,
46
&pNv->notify0))
47
return FALSE;
48
}
49
50
return TRUE;
51
}
52
53
/* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
54
static Bool
55
NVAccelInitContextSurfaces(ScrnInfoPtr pScrn)
56
{
57
NVPtr pNv = NVPTR(pScrn);
58
uint32_t class;
59
60
class = (pNv->Architecture >= NV_10) ? NV10_CONTEXT_SURFACES_2D :
61
NV04_CONTEXT_SURFACES_2D;
62
63
if (!pNv->NvContextSurfaces) {
64
if (nouveau_grobj_alloc(pNv->chan, NvContextSurfaces, class,
65
&pNv->NvContextSurfaces))
66
return FALSE;
67
}
68
69
BEGIN_RING(NvContextSurfaces, NV04_CONTEXT_SURFACES_2D_DMA_NOTIFY, 1);
70
OUT_RING (pNv->NvNull->handle);
71
BEGIN_RING(NvContextSurfaces,
72
NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE, 2);
73
OUT_RING (pNv->chan->vram->handle);
74
OUT_RING (pNv->chan->vram->handle);
75
76
return TRUE;
77
}
78
79
/* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
80
static Bool
81
NVAccelInitContextBeta1(ScrnInfoPtr pScrn)
82
{
83
NVPtr pNv = NVPTR(pScrn);
84
uint32_t class;
85
86
class = 0x12;
87
88
if (!pNv->NvContextBeta1) {
89
if (nouveau_grobj_alloc(pNv->chan, NvContextBeta1, class,
90
&pNv->NvContextBeta1))
91
return FALSE;
92
}
93
94
BEGIN_RING(NvContextBeta1, 0x300, 1); /*alpha factor*/
95
OUT_RING (0xff << 23);
96
97
return TRUE;
98
}
99
100
101
static Bool
102
NVAccelInitContextBeta4(ScrnInfoPtr pScrn)
103
{
104
NVPtr pNv = NVPTR(pScrn);
105
uint32_t class;
106
107
class = 0x72;
108
109
if (!pNv->NvContextBeta4) {
110
if (nouveau_grobj_alloc(pNv->chan, NvContextBeta4, class,
111
&pNv->NvContextBeta4))
112
return FALSE;
113
}
114
115
BEGIN_RING(NvContextBeta4, 0x300, 1); /*RGBA factor*/
116
OUT_RING (0xffff0000);
117
return TRUE;
118
}
119
120
Bool
121
NVAccelGetCtxSurf2DFormatFromPixmap(PixmapPtr pPix, int *fmt_ret)
122
{
123
switch (pPix->drawable.bitsPerPixel) {
124
case 32:
125
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8;
126
break;
127
case 24:
128
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8;
129
break;
130
case 16:
131
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5;
132
break;
133
case 8:
134
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_Y8;
135
break;
136
default:
137
return FALSE;
138
}
139
140
return TRUE;
141
}
142
143
Bool
144
NVAccelGetCtxSurf2DFormatFromPicture(PicturePtr pPict, int *fmt_ret)
145
{
146
switch (pPict->format) {
147
case PICT_a8r8g8b8:
148
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8;
149
break;
150
case PICT_x8r8g8b8:
151
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8;
152
break;
153
case PICT_r5g6b5:
154
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5;
155
break;
156
case PICT_a8:
157
*fmt_ret = NV04_CONTEXT_SURFACES_2D_FORMAT_Y8;
158
break;
159
default:
160
return FALSE;
161
}
162
163
return TRUE;
164
}
165
166
/* A copy of exaGetOffscreenPixmap(), since it's private. */
167
PixmapPtr
168
NVGetDrawablePixmap(DrawablePtr pDraw)
169
{
170
if (pDraw->type == DRAWABLE_WINDOW)
171
return pDraw->pScreen->GetWindowPixmap ((WindowPtr) pDraw);
172
else
173
return (PixmapPtr) pDraw;
174
}
175
176
static Bool
177
NVAccelInitImagePattern(ScrnInfoPtr pScrn)
178
{
179
NVPtr pNv = NVPTR(pScrn);
180
uint32_t class;
181
182
class = NV04_IMAGE_PATTERN;
183
184
if (!pNv->NvImagePattern) {
185
if (nouveau_grobj_alloc(pNv->chan, NvImagePattern, class,
186
&pNv->NvImagePattern))
187
return FALSE;
188
}
189
190
BEGIN_RING(NvImagePattern, NV04_IMAGE_PATTERN_DMA_NOTIFY, 1);
191
OUT_RING (pNv->NvNull->handle);
192
BEGIN_RING(NvImagePattern, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT, 3);
193
#if X_BYTE_ORDER == X_BIG_ENDIAN
194
OUT_RING (NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE);
195
#else
196
OUT_RING (NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_CGA6);
197
#endif
198
OUT_RING (NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8);
199
OUT_RING (NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO);
200
201
return TRUE;
202
}
203
204
static Bool
205
NVAccelInitRasterOp(ScrnInfoPtr pScrn)
206
{
207
NVPtr pNv = NVPTR(pScrn);
208
uint32_t class;
209
210
class = NV03_CONTEXT_ROP;
211
212
if (!pNv->NvRop) {
213
if (nouveau_grobj_alloc(pNv->chan, NvRop, class,
214
&pNv->NvRop))
215
return FALSE;
216
}
217
218
BEGIN_RING(NvRop, NV03_CONTEXT_ROP_DMA_NOTIFY, 1);
219
OUT_RING (pNv->NvNull->handle);
220
221
pNv->currentRop = ~0;
222
return TRUE;
223
}
224
225
static Bool
226
NVAccelInitRectangle(ScrnInfoPtr pScrn)
227
{
228
NVPtr pNv = NVPTR(pScrn);
229
uint32_t class;
230
231
class = NV04_GDI_RECTANGLE_TEXT;
232
233
if (!pNv->NvRectangle) {
234
if (nouveau_grobj_alloc(pNv->chan, NvRectangle, class,
235
&pNv->NvRectangle))
236
return FALSE;
237
}
238
239
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY, 1);
240
OUT_RING (pNv->notify0->handle);
241
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_DMA_FONTS, 1);
242
OUT_RING (pNv->NvNull->handle);
243
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
244
OUT_RING (pNv->NvContextSurfaces->handle);
245
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_ROP, 1);
246
OUT_RING (pNv->NvRop->handle);
247
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
248
OUT_RING (pNv->NvImagePattern->handle);
249
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
250
OUT_RING (NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND);
251
BEGIN_RING(NvRectangle, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT, 1);
252
/* XXX why putting 1 like renouveau dump, swap the text */
253
#if 1 || X_BYTE_ORDER == X_BIG_ENDIAN
254
OUT_RING (NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE);
255
#else
256
OUT_RING (NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_CGA6);
257
#endif
258
259
return TRUE;
260
}
261
262
static Bool
263
NVAccelInitImageBlit(ScrnInfoPtr pScrn)
264
{
265
NVPtr pNv = NVPTR(pScrn);
266
uint32_t class;
267
268
class = (pNv->WaitVSyncPossible) ? NV12_IMAGE_BLIT : NV04_IMAGE_BLIT;
269
270
if (!pNv->NvImageBlit) {
271
if (nouveau_grobj_alloc(pNv->chan, NvImageBlit, class,
272
&pNv->NvImageBlit))
273
return FALSE;
274
}
275
276
BEGIN_RING(NvImageBlit, NV04_IMAGE_BLIT_DMA_NOTIFY, 1);
277
OUT_RING (pNv->notify0->handle);
278
BEGIN_RING(NvImageBlit, NV04_IMAGE_BLIT_COLOR_KEY, 1);
279
OUT_RING (pNv->NvNull->handle);
280
BEGIN_RING(NvImageBlit, NV04_IMAGE_BLIT_SURFACE, 1);
281
OUT_RING (pNv->NvContextSurfaces->handle);
282
BEGIN_RING(NvImageBlit, NV04_IMAGE_BLIT_CLIP_RECTANGLE, 3);
283
OUT_RING (pNv->NvNull->handle);
284
OUT_RING (pNv->NvImagePattern->handle);
285
OUT_RING (pNv->NvRop->handle);
286
BEGIN_RING(NvImageBlit, NV04_IMAGE_BLIT_OPERATION, 1);
287
OUT_RING (NV04_IMAGE_BLIT_OPERATION_ROP_AND);
288
289
if (pNv->WaitVSyncPossible) {
290
BEGIN_RING(NvImageBlit, 0x0120, 3);
291
OUT_RING (0);
292
OUT_RING (1);
293
OUT_RING (2);
294
}
295
296
return TRUE;
297
}
298
299
static Bool
300
NVAccelInitScaledImage(ScrnInfoPtr pScrn)
301
{
302
NVPtr pNv = NVPTR(pScrn);
303
uint32_t class;
304
305
switch (pNv->Architecture) {
306
case NV_ARCH_04:
307
class = NV04_SCALED_IMAGE_FROM_MEMORY;
308
break;
309
case NV_ARCH_10:
310
case NV_ARCH_20:
311
case NV_ARCH_30:
312
class = NV10_SCALED_IMAGE_FROM_MEMORY;
313
break;
314
case NV_ARCH_40:
315
default:
316
class = NV10_SCALED_IMAGE_FROM_MEMORY | 0x3000;
317
break;
318
}
319
320
if (!pNv->NvScaledImage) {
321
if (nouveau_grobj_alloc(pNv->chan, NvScaledImage, class,
322
&pNv->NvScaledImage))
323
return FALSE;
324
}
325
326
BEGIN_RING(NvScaledImage,
327
NV04_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY, 7);
328
OUT_RING (pNv->notify0->handle);
329
OUT_RING (pNv->chan->vram->handle);
330
OUT_RING (pNv->NvNull->handle);
331
OUT_RING (pNv->NvNull->handle);
332
OUT_RING (pNv->NvContextBeta1->handle);
333
OUT_RING (pNv->NvContextBeta4->handle);
334
OUT_RING (pNv->NvContextSurfaces->handle);
335
if (pNv->Architecture>=NV_ARCH_10) {
336
BEGIN_RING(NvScaledImage,
337
NV04_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 1);
338
OUT_RING (NV04_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_DITHER);
339
}
340
BEGIN_RING(NvScaledImage, NV04_SCALED_IMAGE_FROM_MEMORY_OPERATION, 1);
341
OUT_RING (NV04_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY);
342
343
return TRUE;
344
}
345
346
static Bool
347
NVAccelInitClipRectangle(ScrnInfoPtr pScrn)
348
{
349
NVPtr pNv = NVPTR(pScrn);
350
int class = NV01_CONTEXT_CLIP_RECTANGLE;
351
352
if (!pNv->NvClipRectangle) {
353
if (nouveau_grobj_alloc(pNv->chan, NvClipRectangle, class,
354
&pNv->NvClipRectangle))
355
return FALSE;
356
}
357
358
BEGIN_RING(NvClipRectangle, NV01_CONTEXT_CLIP_RECTANGLE_DMA_NOTIFY, 1);
359
OUT_RING (pNv->NvNull->handle);
360
361
return TRUE;
362
}
363
364
/* FLAGS_NONE, NvDmaFB, NvDmaAGP, NvDmaNotifier0 */
365
static Bool
366
NVAccelInitMemFormat(ScrnInfoPtr pScrn)
367
{
368
NVPtr pNv = NVPTR(pScrn);
369
uint32_t class;
370
371
if (pNv->Architecture < NV_ARCH_50)
372
class = NV04_MEMORY_TO_MEMORY_FORMAT;
373
else
374
class = NV50_MEMORY_TO_MEMORY_FORMAT;
375
376
if (!pNv->NvMemFormat) {
377
if (nouveau_grobj_alloc(pNv->chan, NvMemFormat, class,
378
&pNv->NvMemFormat))
379
return FALSE;
380
}
381
382
BEGIN_RING(NvMemFormat, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1);
383
OUT_RING (pNv->notify0->handle);
384
BEGIN_RING(NvMemFormat, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_IN, 2);
385
OUT_RING (pNv->chan->vram->handle);
386
OUT_RING (pNv->chan->vram->handle);
387
388
return TRUE;
389
}
390
391
static Bool
392
NVAccelInitImageFromCpu(ScrnInfoPtr pScrn)
393
{
394
NVPtr pNv = NVPTR(pScrn);
395
uint32_t class;
396
397
switch (pNv->Architecture) {
398
case NV_ARCH_04:
399
class = NV04_IMAGE_FROM_CPU;
400
break;
401
case NV_ARCH_10:
402
case NV_ARCH_20:
403
case NV_ARCH_30:
404
case NV_ARCH_40:
405
default:
406
class = NV10_IMAGE_FROM_CPU;
407
break;
408
}
409
410
if (!pNv->NvImageFromCpu) {
411
if (nouveau_grobj_alloc(pNv->chan, NvImageFromCpu, class,
412
&pNv->NvImageFromCpu))
413
return FALSE;
414
}
415
416
BEGIN_RING(NvImageFromCpu, NV01_IMAGE_FROM_CPU_DMA_NOTIFY, 1);
417
OUT_RING (pNv->notify0->handle);
418
BEGIN_RING(NvImageFromCpu, NV01_IMAGE_FROM_CPU_CLIP_RECTANGLE, 1);
419
OUT_RING (pNv->NvNull->handle);
420
BEGIN_RING(NvImageFromCpu, NV01_IMAGE_FROM_CPU_PATTERN, 1);
421
OUT_RING (pNv->NvNull->handle);
422
BEGIN_RING(NvImageFromCpu, NV01_IMAGE_FROM_CPU_ROP, 1);
423
OUT_RING (pNv->NvNull->handle);
424
if (pNv->Architecture >= NV_ARCH_10)
425
{
426
BEGIN_RING(NvImageFromCpu, NV01_IMAGE_FROM_CPU_BETA1, 1);
427
OUT_RING (pNv->NvNull->handle);
428
BEGIN_RING(NvImageFromCpu, NV05_IMAGE_FROM_CPU_BETA4, 1);
429
OUT_RING (pNv->NvNull->handle);
430
}
431
BEGIN_RING(NvImageFromCpu, NV05_IMAGE_FROM_CPU_SURFACE, 1);
432
OUT_RING (pNv->NvContextSurfaces->handle);
433
BEGIN_RING(NvImageFromCpu, NV01_IMAGE_FROM_CPU_OPERATION, 1);
434
OUT_RING (NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY);
435
return TRUE;
436
}
437
438
static Bool
439
NVAccelInit2D_NV50(ScrnInfoPtr pScrn)
440
{
441
NVPtr pNv = NVPTR(pScrn);
442
443
if (!pNv->Nv2D) {
444
if (nouveau_grobj_alloc(pNv->chan, Nv2D, 0x502d,
445
&pNv->Nv2D))
446
return FALSE;
447
}
448
449
BEGIN_RING(Nv2D, 0x180, 3);
450
OUT_RING (pNv->notify0->handle);
451
OUT_RING (pNv->chan->vram->handle);
452
OUT_RING (pNv->chan->vram->handle);
453
454
/* Magics from nv, no clue what they do, but at least some
455
* of them are needed to avoid crashes.
456
*/
457
BEGIN_RING(Nv2D, 0x260, 1);
458
OUT_RING (1);
459
BEGIN_RING(Nv2D, 0x290, 1);
460
OUT_RING (1);
461
BEGIN_RING(Nv2D, 0x29c, 1);
462
OUT_RING (0);
463
BEGIN_RING(Nv2D, 0x58c, 1);
464
OUT_RING (0x111);
465
466
pNv->currentRop = 0xfffffffa;
467
return TRUE;
468
}
469
470
#define INIT_CONTEXT_OBJECT(name) do { \
471
ret = NVAccelInit##name(pScrn); \
472
if (!ret) { \
473
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, \
474
"Failed to initialise context object: "#name \
475
" (%d)\n", ret); \
476
return FALSE; \
477
} \
478
} while(0)
479
480
Bool
481
NVAccelCommonInit(ScrnInfoPtr pScrn)
482
{
483
NVPtr pNv = NVPTR(pScrn);
484
Bool ret;
485
if(pNv->NoAccel) return TRUE;
486
487
/* General engine objects */
488
INIT_CONTEXT_OBJECT(NullObject);
489
INIT_CONTEXT_OBJECT(DmaNotifier0);
490
491
/* 2D engine */
492
if (pNv->Architecture < NV_ARCH_50) {
493
INIT_CONTEXT_OBJECT(ContextSurfaces);
494
INIT_CONTEXT_OBJECT(ContextBeta1);
495
INIT_CONTEXT_OBJECT(ContextBeta4);
496
INIT_CONTEXT_OBJECT(ImagePattern);
497
INIT_CONTEXT_OBJECT(RasterOp);
498
INIT_CONTEXT_OBJECT(Rectangle);
499
INIT_CONTEXT_OBJECT(ImageBlit);
500
INIT_CONTEXT_OBJECT(ScaledImage);
501
INIT_CONTEXT_OBJECT(ClipRectangle);
502
INIT_CONTEXT_OBJECT(ImageFromCpu);
503
} else {
504
INIT_CONTEXT_OBJECT(2D_NV50);
505
}
506
INIT_CONTEXT_OBJECT(MemFormat);
507
508
/* 3D init */
509
switch (pNv->Architecture) {
510
case NV_ARCH_40:
511
INIT_CONTEXT_OBJECT(NV40TCL);
512
break;
513
case NV_ARCH_30:
514
INIT_CONTEXT_OBJECT(NV30TCL);
515
break;
516
case NV_ARCH_20:
517
case NV_ARCH_10:
518
INIT_CONTEXT_OBJECT(NV10TCL);
519
break;
520
default:
521
break;
522
}
523
524
return TRUE;
525
}
526
Loggerhead is a web-based interface for Breezy
Version: 2.0.1