projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'lp-offset-twoside'
[mesa.git] / src / mesa / drivers / dri / nouveau / nv04_surface.c
1 /*
2 * Copyright (C) 2007-2010 The Nouveau Project.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 */
26
27 #include "nouveau_driver.h"
28 #include "nv_object.xml.h"
29 #include "nv_m2mf.xml.h"
30 #include "nv01_2d.xml.h"
31 #include "nv04_3d.xml.h"
32 #include "nouveau_context.h"
33 #include "nouveau_util.h"
34 #include "nv04_driver.h"
35
36 static inline int
37 swzsurf_format(gl_format format)
38 {
39 switch (format) {
40 case MESA_FORMAT_A8:
41 case MESA_FORMAT_L8:
42 case MESA_FORMAT_I8:
43 case MESA_FORMAT_RGB332:
44 case MESA_FORMAT_CI8:
45 return NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y8;
46
47 case MESA_FORMAT_RGB565:
48 case MESA_FORMAT_RGB565_REV:
49 case MESA_FORMAT_ARGB4444:
50 case MESA_FORMAT_ARGB4444_REV:
51 case MESA_FORMAT_ARGB1555:
52 case MESA_FORMAT_RGBA5551:
53 case MESA_FORMAT_ARGB1555_REV:
54 case MESA_FORMAT_AL88:
55 case MESA_FORMAT_AL88_REV:
56 case MESA_FORMAT_YCBCR:
57 case MESA_FORMAT_YCBCR_REV:
58 case MESA_FORMAT_Z16:
59 return NV04_SWIZZLED_SURFACE_FORMAT_COLOR_R5G6B5;
60
61 case MESA_FORMAT_RGBA8888:
62 case MESA_FORMAT_RGBA8888_REV:
63 case MESA_FORMAT_XRGB8888:
64 case MESA_FORMAT_ARGB8888:
65 case MESA_FORMAT_ARGB8888_REV:
66 case MESA_FORMAT_S8_Z24:
67 case MESA_FORMAT_Z24_S8:
68 case MESA_FORMAT_Z32:
69 return NV04_SWIZZLED_SURFACE_FORMAT_COLOR_A8R8G8B8;
70
71 default:
72 assert(0);
73 }
74 }
75
76 static inline int
77 surf2d_format(gl_format format)
78 {
79 switch (format) {
80 case MESA_FORMAT_A8:
81 case MESA_FORMAT_L8:
82 case MESA_FORMAT_I8:
83 case MESA_FORMAT_RGB332:
84 case MESA_FORMAT_CI8:
85 return NV04_CONTEXT_SURFACES_2D_FORMAT_Y8;
86
87 case MESA_FORMAT_RGB565:
88 case MESA_FORMAT_RGB565_REV:
89 case MESA_FORMAT_ARGB4444:
90 case MESA_FORMAT_ARGB4444_REV:
91 case MESA_FORMAT_ARGB1555:
92 case MESA_FORMAT_RGBA5551:
93 case MESA_FORMAT_ARGB1555_REV:
94 case MESA_FORMAT_AL88:
95 case MESA_FORMAT_AL88_REV:
96 case MESA_FORMAT_YCBCR:
97 case MESA_FORMAT_YCBCR_REV:
98 case MESA_FORMAT_Z16:
99 return NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5;
100
101 case MESA_FORMAT_RGBA8888:
102 case MESA_FORMAT_RGBA8888_REV:
103 case MESA_FORMAT_XRGB8888:
104 case MESA_FORMAT_ARGB8888:
105 case MESA_FORMAT_ARGB8888_REV:
106 case MESA_FORMAT_S8_Z24:
107 case MESA_FORMAT_Z24_S8:
108 case MESA_FORMAT_Z32:
109 return NV04_CONTEXT_SURFACES_2D_FORMAT_Y32;
110
111 default:
112 assert(0);
113 }
114 }
115
116 static inline int
117 rect_format(gl_format format)
118 {
119 switch (format) {
120 case MESA_FORMAT_A8:
121 case MESA_FORMAT_L8:
122 case MESA_FORMAT_I8:
123 case MESA_FORMAT_RGB332:
124 case MESA_FORMAT_CI8:
125 return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8;
126
127 case MESA_FORMAT_RGB565:
128 case MESA_FORMAT_RGB565_REV:
129 case MESA_FORMAT_ARGB4444:
130 case MESA_FORMAT_ARGB4444_REV:
131 case MESA_FORMAT_ARGB1555:
132 case MESA_FORMAT_RGBA5551:
133 case MESA_FORMAT_ARGB1555_REV:
134 case MESA_FORMAT_AL88:
135 case MESA_FORMAT_AL88_REV:
136 case MESA_FORMAT_YCBCR:
137 case MESA_FORMAT_YCBCR_REV:
138 case MESA_FORMAT_Z16:
139 return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5;
140
141 case MESA_FORMAT_RGBA8888:
142 case MESA_FORMAT_RGBA8888_REV:
143 case MESA_FORMAT_XRGB8888:
144 case MESA_FORMAT_ARGB8888:
145 case MESA_FORMAT_ARGB8888_REV:
146 case MESA_FORMAT_S8_Z24:
147 case MESA_FORMAT_Z24_S8:
148 case MESA_FORMAT_Z32:
149 return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8;
150
151 default:
152 assert(0);
153 }
154 }
155
156 static inline int
157 sifm_format(gl_format format)
158 {
159 switch (format) {
160 case MESA_FORMAT_A8:
161 case MESA_FORMAT_L8:
162 case MESA_FORMAT_I8:
163 case MESA_FORMAT_RGB332:
164 case MESA_FORMAT_CI8:
165 return NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_AY8;
166
167 case MESA_FORMAT_RGB565:
168 case MESA_FORMAT_RGB565_REV:
169 case MESA_FORMAT_ARGB4444:
170 case MESA_FORMAT_ARGB4444_REV:
171 case MESA_FORMAT_ARGB1555:
172 case MESA_FORMAT_RGBA5551:
173 case MESA_FORMAT_ARGB1555_REV:
174 case MESA_FORMAT_AL88:
175 case MESA_FORMAT_AL88_REV:
176 case MESA_FORMAT_YCBCR:
177 case MESA_FORMAT_YCBCR_REV:
178 case MESA_FORMAT_Z16:
179 return NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_R5G6B5;
180
181 case MESA_FORMAT_RGBA8888:
182 case MESA_FORMAT_RGBA8888_REV:
183 case MESA_FORMAT_XRGB8888:
184 case MESA_FORMAT_ARGB8888:
185 case MESA_FORMAT_ARGB8888_REV:
186 case MESA_FORMAT_S8_Z24:
187 case MESA_FORMAT_Z24_S8:
188 case MESA_FORMAT_Z32:
189 return NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A8R8G8B8;
190
191 default:
192 assert(0);
193 }
194 }
195
196 static void
197 nv04_surface_copy_swizzle(struct gl_context *ctx,
198 struct nouveau_surface *dst,
199 struct nouveau_surface *src,
200 int dx, int dy, int sx, int sy,
201 int w, int h)
202 {
203 struct nouveau_channel *chan = context_chan(ctx);
204 struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
205 struct nouveau_grobj *swzsurf = hw->swzsurf;
206 struct nouveau_grobj *sifm = hw->sifm;
207 struct nouveau_bo_context *bctx = context_bctx(ctx, SURFACE);
208 const unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
209 /* Max width & height may not be the same on all HW, but must be POT */
210 const unsigned max_w = 1024;
211 const unsigned max_h = 1024;
212 unsigned sub_w = w > max_w ? max_w : w;
213 unsigned sub_h = h > max_h ? max_h : h;
214 unsigned x, y;
215
216 /* Swizzled surfaces must be POT */
217 assert(_mesa_is_pow_two(dst->width) &&
218 _mesa_is_pow_two(dst->height));
219
220 nouveau_bo_marko(bctx, sifm, NV03_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE,
221 src->bo, bo_flags | NOUVEAU_BO_RD);
222 nouveau_bo_marko(bctx, swzsurf, NV04_SWIZZLED_SURFACE_DMA_IMAGE,
223 dst->bo, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
224 nouveau_bo_markl(bctx, swzsurf, NV04_SWIZZLED_SURFACE_OFFSET,
225 dst->bo, dst->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
226
227 BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_FORMAT, 1);
228 OUT_RING (chan, swzsurf_format(dst->format) |
229 log2i(dst->width) << 16 |
230 log2i(dst->height) << 24);
231
232 BEGIN_RING(chan, sifm, NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE, 1);
233 OUT_RING (chan, swzsurf->handle);
234
235 for (y = 0; y < h; y += sub_h) {
236 sub_h = MIN2(sub_h, h - y);
237
238 for (x = 0; x < w; x += sub_w) {
239 sub_w = MIN2(sub_w, w - x);
240
241 MARK_RING(chan, 15, 1);
242
243 BEGIN_RING(chan, sifm,
244 NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT, 8);
245 OUT_RING(chan, sifm_format(src->format));
246 OUT_RING(chan, NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY);
247 OUT_RING(chan, (y + dy) << 16 | (x + dx));
248 OUT_RING(chan, sub_h << 16 | sub_w);
249 OUT_RING(chan, (y + dy) << 16 | (x + dx));
250 OUT_RING(chan, sub_h << 16 | sub_w);
251 OUT_RING(chan, 1 << 20);
252 OUT_RING(chan, 1 << 20);
253
254 BEGIN_RING(chan, sifm,
255 NV03_SCALED_IMAGE_FROM_MEMORY_SIZE, 4);
256 OUT_RING(chan, align(sub_h, 2) << 16 | align(sub_w, 2));
257 OUT_RING(chan, src->pitch |
258 NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER |
259 NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE);
260 OUT_RELOCl(chan, src->bo, src->offset +
261 (y + sy) * src->pitch +
262 (x + sx) * src->cpp,
263 bo_flags | NOUVEAU_BO_RD);
264 OUT_RING(chan, 0);
265 }
266 }
267
268 nouveau_bo_context_reset(bctx);
269
270 if (context_chipset(ctx) < 0x10)
271 FIRE_RING(chan);
272 }
273
274 static void
275 nv04_surface_copy_m2mf(struct gl_context *ctx,
276 struct nouveau_surface *dst,
277 struct nouveau_surface *src,
278 int dx, int dy, int sx, int sy,
279 int w, int h)
280 {
281 struct nouveau_channel *chan = context_chan(ctx);
282 struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
283 struct nouveau_grobj *m2mf = hw->m2mf;
284 struct nouveau_bo_context *bctx = context_bctx(ctx, SURFACE);
285 const unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
286 unsigned dst_offset = dst->offset + dy * dst->pitch + dx * dst->cpp;
287 unsigned src_offset = src->offset + sy * src->pitch + sx * src->cpp;
288
289 nouveau_bo_marko(bctx, m2mf, NV04_M2MF_DMA_BUFFER_IN,
290 src->bo, bo_flags | NOUVEAU_BO_RD);
291 nouveau_bo_marko(bctx, m2mf, NV04_M2MF_DMA_BUFFER_OUT,
292 dst->bo, bo_flags | NOUVEAU_BO_WR);
293
294 while (h) {
295 int count = (h > 2047) ? 2047 : h;
296
297 MARK_RING(chan, 9, 2);
298
299 BEGIN_RING(chan, m2mf, NV04_M2MF_OFFSET_IN, 8);
300 OUT_RELOCl(chan, src->bo, src_offset,
301 bo_flags | NOUVEAU_BO_RD);
302 OUT_RELOCl(chan, dst->bo, dst_offset,
303 bo_flags | NOUVEAU_BO_WR);
304 OUT_RING (chan, src->pitch);
305 OUT_RING (chan, dst->pitch);
306 OUT_RING (chan, w * src->cpp);
307 OUT_RING (chan, count);
308 OUT_RING (chan, 0x0101);
309 OUT_RING (chan, 0);
310
311 h -= count;
312 src_offset += src->pitch * count;
313 dst_offset += dst->pitch * count;
314 }
315
316 nouveau_bo_context_reset(bctx);
317
318 if (context_chipset(ctx) < 0x10)
319 FIRE_RING(chan);
320 }
321
322 typedef unsigned (*get_offset_t)(struct nouveau_surface *s,
323 unsigned x, unsigned y);
324
325 static unsigned
326 get_linear_offset(struct nouveau_surface *s, unsigned x, unsigned y)
327 {
328 return x * s->cpp + y * s->pitch;
329 }
330
331 static unsigned
332 get_swizzled_offset(struct nouveau_surface *s, unsigned x, unsigned y)
333 {
334 unsigned k = log2i(MIN2(s->width, s->height));
335
336 unsigned u = (x & 0x001) << 0 |
337 (x & 0x002) << 1 |
338 (x & 0x004) << 2 |
339 (x & 0x008) << 3 |
340 (x & 0x010) << 4 |
341 (x & 0x020) << 5 |
342 (x & 0x040) << 6 |
343 (x & 0x080) << 7 |
344 (x & 0x100) << 8 |
345 (x & 0x200) << 9 |
346 (x & 0x400) << 10 |
347 (x & 0x800) << 11;
348
349 unsigned v = (y & 0x001) << 1 |
350 (y & 0x002) << 2 |
351 (y & 0x004) << 3 |
352 (y & 0x008) << 4 |
353 (y & 0x010) << 5 |
354 (y & 0x020) << 6 |
355 (y & 0x040) << 7 |
356 (y & 0x080) << 8 |
357 (y & 0x100) << 9 |
358 (y & 0x200) << 10 |
359 (y & 0x400) << 11 |
360 (y & 0x800) << 12;
361
362 return s->cpp * (((u | v) & ~(~0 << 2*k)) |
363 (x & (~0 << k)) << k |
364 (y & (~0 << k)) << k);
365 }
366
367 static void
368 nv04_surface_copy_cpu(struct gl_context *ctx,
369 struct nouveau_surface *dst,
370 struct nouveau_surface *src,
371 int dx, int dy, int sx, int sy,
372 int w, int h)
373 {
374 int x, y;
375 get_offset_t get_dst = (dst->layout == SWIZZLED ?
376 get_swizzled_offset : get_linear_offset);
377 get_offset_t get_src = (src->layout == SWIZZLED ?
378 get_swizzled_offset : get_linear_offset);
379 void *dp, *sp;
380
381 nouveau_bo_map(dst->bo, NOUVEAU_BO_WR);
382 nouveau_bo_map(src->bo, NOUVEAU_BO_RD);
383
384 dp = dst->bo->map + dst->offset;
385 sp = src->bo->map + src->offset;
386
387 for (y = 0; y < h; y++) {
388 for (x = 0; x < w; x++) {
389 memcpy(dp + get_dst(dst, dx + x, dy + y),
390 sp + get_src(src, sx + x, sy + y), dst->cpp);
391 }
392 }
393
394 nouveau_bo_unmap(src->bo);
395 nouveau_bo_unmap(dst->bo);
396 }
397
398 void
399 nv04_surface_copy(struct gl_context *ctx,
400 struct nouveau_surface *dst,
401 struct nouveau_surface *src,
402 int dx, int dy, int sx, int sy,
403 int w, int h)
404 {
405 /* Linear texture copy. */
406 if ((src->layout == LINEAR && dst->layout == LINEAR) ||
407 dst->width <= 2 || dst->height <= 1) {
408 nv04_surface_copy_m2mf(ctx, dst, src, dx, dy, sx, sy, w, h);
409 return;
410 }
411
412 /* Swizzle using sifm+swzsurf. */
413 if (src->layout == LINEAR && dst->layout == SWIZZLED &&
414 dst->cpp != 1 && !(dst->offset & 63)) {
415 nv04_surface_copy_swizzle(ctx, dst, src, dx, dy, sx, sy, w, h);
416 return;
417 }
418
419 /* Fallback to CPU copy. */
420 nv04_surface_copy_cpu(ctx, dst, src, dx, dy, sx, sy, w, h);
421 }
422
423 void
424 nv04_surface_fill(struct gl_context *ctx,
425 struct nouveau_surface *dst,
426 unsigned mask, unsigned value,
427 int dx, int dy, int w, int h)
428 {
429 struct nouveau_channel *chan = context_chan(ctx);
430 struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
431 struct nouveau_grobj *surf2d = hw->surf2d;
432 struct nouveau_grobj *patt = hw->patt;
433 struct nouveau_grobj *rect = hw->rect;
434 unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
435
436 MARK_RING (chan, 19, 4);
437
438 BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE, 2);
439 OUT_RELOCo(chan, dst->bo, bo_flags | NOUVEAU_BO_WR);
440 OUT_RELOCo(chan, dst->bo, bo_flags | NOUVEAU_BO_WR);
441 BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
442 OUT_RING (chan, surf2d_format(dst->format));
443 OUT_RING (chan, (dst->pitch << 16) | dst->pitch);
444 OUT_RELOCl(chan, dst->bo, dst->offset, bo_flags | NOUVEAU_BO_WR);
445 OUT_RELOCl(chan, dst->bo, dst->offset, bo_flags | NOUVEAU_BO_WR);
446
447 BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_COLOR_FORMAT, 1);
448 OUT_RING (chan, rect_format(dst->format));
449 BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR1, 1);
450 OUT_RING (chan, mask | ~0ll << (8 * dst->cpp));
451
452 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT, 1);
453 OUT_RING (chan, rect_format(dst->format));
454 BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR1_A, 1);
455 OUT_RING (chan, value);
456 BEGIN_RING(chan, rect,
457 NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT(0), 2);
458 OUT_RING (chan, (dx << 16) | dy);
459 OUT_RING (chan, ( w << 16) | h);
460
461 if (context_chipset(ctx) < 0x10)
462 FIRE_RING(chan);
463 }
464
465 void
466 nv04_surface_takedown(struct gl_context *ctx)
467 {
468 struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
469
470 nouveau_grobj_free(&hw->swzsurf);
471 nouveau_grobj_free(&hw->sifm);
472 nouveau_grobj_free(&hw->rect);
473 nouveau_grobj_free(&hw->rop);
474 nouveau_grobj_free(&hw->patt);
475 nouveau_grobj_free(&hw->surf2d);
476 nouveau_grobj_free(&hw->m2mf);
477 nouveau_notifier_free(&hw->ntfy);
478 }
479
480 GLboolean
481 nv04_surface_init(struct gl_context *ctx)
482 {
483 struct nouveau_channel *chan = context_chan(ctx);
484 struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
485 unsigned handle = 0x88000000, class;
486 int ret;
487
488 /* Notifier object. */
489 ret = nouveau_notifier_alloc(chan, handle++, 1, &hw->ntfy);
490 if (ret)
491 goto fail;
492
493 /* Memory to memory format. */
494 ret = nouveau_grobj_alloc(chan, handle++, NV04_M2MF, &hw->m2mf);
495 if (ret)
496 goto fail;
497
498 BEGIN_RING(chan, hw->m2mf, NV04_M2MF_DMA_NOTIFY, 1);
499 OUT_RING (chan, hw->ntfy->handle);
500
501 /* Context surfaces 2D. */
502 if (context_chipset(ctx) < 0x10)
503 class = NV04_CONTEXT_SURFACES_2D;
504 else
505 class = NV10_CONTEXT_SURFACES_2D;
506
507 ret = nouveau_grobj_alloc(chan, handle++, class, &hw->surf2d);
508 if (ret)
509 goto fail;
510
511 /* Raster op. */
512 ret = nouveau_grobj_alloc(chan, handle++, NV03_CONTEXT_ROP, &hw->rop);
513 if (ret)
514 goto fail;
515
516 BEGIN_RING(chan, hw->rop, NV03_CONTEXT_ROP_DMA_NOTIFY, 1);
517 OUT_RING (chan, hw->ntfy->handle);
518
519 BEGIN_RING(chan, hw->rop, NV03_CONTEXT_ROP_ROP, 1);
520 OUT_RING (chan, 0xca); /* DPSDxax in the GDI speech. */
521
522 /* Image pattern. */
523 ret = nouveau_grobj_alloc(chan, handle++, NV04_IMAGE_PATTERN,
524 &hw->patt);
525 if (ret)
526 goto fail;
527
528 BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_DMA_NOTIFY, 1);
529 OUT_RING (chan, hw->ntfy->handle);
530
531 BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT, 3);
532 OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE);
533 OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8);
534 OUT_RING (chan, NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO);
535
536 BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR0, 4);
537 OUT_RING (chan, 0);
538 OUT_RING (chan, 0);
539 OUT_RING (chan, ~0);
540 OUT_RING (chan, ~0);
541
542 /* GDI rectangle text. */
543 ret = nouveau_grobj_alloc(chan, handle++, NV04_GDI_RECTANGLE_TEXT,
544 &hw->rect);
545 if (ret)
546 goto fail;
547
548 BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY, 1);
549 OUT_RING (chan, hw->ntfy->handle);
550 BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
551 OUT_RING (chan, hw->surf2d->handle);
552 BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_ROP, 1);
553 OUT_RING (chan, hw->rop->handle);
554 BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
555 OUT_RING (chan, hw->patt->handle);
556
557 BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
558 OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND);
559 BEGIN_RING(chan, hw->rect,
560 NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT, 1);
561 OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE);
562
563 /* Swizzled surface. */
564 if (context_chipset(ctx) < 0x20)
565 class = NV04_SWIZZLED_SURFACE;
566 else
567 class = NV20_SWIZZLED_SURFACE;
568
569 ret = nouveau_grobj_alloc(chan, handle++, class, &hw->swzsurf);
570 if (ret)
571 goto fail;
572
573 /* Scaled image from memory. */
574 if (context_chipset(ctx) < 0x10)
575 class = NV04_SCALED_IMAGE_FROM_MEMORY;
576 else
577 class = NV10_SCALED_IMAGE_FROM_MEMORY;
578
579 ret = nouveau_grobj_alloc(chan, handle++, class, &hw->sifm);
580 if (ret)
581 goto fail;
582
583 if (context_chipset(ctx) >= 0x10) {
584 BEGIN_RING(chan, hw->sifm,
585 NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 1);
586 OUT_RING(chan, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE);
587 }
588
589 return GL_TRUE;
590
591 fail:
592 nv04_surface_takedown(ctx);
593 return GL_FALSE;
594 }