From 4a6c2bd2bedcf9f67c3e498b1411ad58cd66199c Mon Sep 17 00:00:00 2001 From: Stephane Marchesin Date: Mon, 6 Aug 2007 17:29:41 +0200 Subject: Add subchannel handling code --- src/nv30_exa.c | 112 +++++++++++++++++++++++++------------------------- src/nv_accel_common.c | 73 ++++++++++++++------------------ src/nv_dma.c | 70 +++++++++++++++++++++---------- src/nv_dma.h | 17 -------- src/nv_exa.c | 42 +++++++++---------- src/nv_video.c | 26 ++++++------ src/nv_xaa.c | 46 ++++++++++----------- 7 files changed, 192 insertions(+), 194 deletions(-) diff --git a/src/nv30_exa.c b/src/nv30_exa.c index 66901d3..816aa0b 100644 --- a/src/nv30_exa.c +++ b/src/nv30_exa.c @@ -174,12 +174,12 @@ NV30_LoadVtxProg(ScrnInfoPtr pScrn, nv_shader_t *shader) if (!shader->hw_id) { shader->hw_id = next_hw_id; - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VP_UPLOAD_FROM_ID, 1); NVDmaNext (pNv, (shader->hw_id)); for (i=0; isize; i+=4) { - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VP_UPLOAD_INST0, 4); NVDmaNext (pNv, shader->data[i + 0]); @@ -190,10 +190,10 @@ NV30_LoadVtxProg(ScrnInfoPtr pScrn, nv_shader_t *shader) } } - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VP_PROGRAM_START_ID, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VP_PROGRAM_START_ID, 1); NVDmaNext (pNv, (shader->hw_id)); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VP_IN_REG, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VP_IN_REG, 2); NVDmaNext (pNv, shader->card_priv.NV30VP.vp_in_reg); NVDmaNext (pNv, shader->card_priv.NV30VP.vp_out_reg); } @@ -226,16 +226,16 @@ NV30_LoadFragProg(ScrnInfoPtr pScrn, nv_shader_t *shader) next_hw_id_offset = (next_hw_id_offset + 63) & ~63; } - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_FP_ACTIVE_PROGRAM, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_FP_ACTIVE_PROGRAM, 1); NVDmaNext (pNv, shader->hw_id | 1); if (pNv->Architecture == NV_30) { - NVDmaStart(pNv, NvSub3D, 0x1d60, 1); + NVDmaStart(pNv, Nv3D, 0x1d60, 1); NVDmaNext (pNv, 0); /* USES_KIL (1<<7) == 0 */ - NVDmaStart(pNv, NvSub3D, 0x1450, 1); + NVDmaStart(pNv, Nv3D, 0x1450, 1); NVDmaNext (pNv, shader->card_priv.NV30FP.num_regs << 16); } else { - NVDmaStart(pNv, NvSub3D, 0x1d60, 1); + NVDmaStart(pNv, Nv3D, 0x1d60, 1); NVDmaNext (pNv, (0<<7) /* !USES_KIL */ | (shader->card_priv.NV30FP.num_regs << 24)); } @@ -266,10 +266,10 @@ NV30_SetupBlend(ScrnInfoPtr pScrn, nv_pict_op_t *blend, Bool dest_has_alpha, } if (sblend == BF(ONE) && dblend == BF(ZERO)) { - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 1); NVDmaNext (pNv, 0); } else { - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 5); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 5); NVDmaNext (pNv, 1); NVDmaNext (pNv, (sblend << 16) | sblend); NVDmaNext (pNv, (dblend << 16) | dblend); @@ -300,7 +300,7 @@ NV30EXATexture(ScrnInfoPtr pScrn, PixmapPtr pPix, PicturePtr pPict, int unit) else card_filter = 1; - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_TX_ADDRESS_UNIT(unit), 8); NVDmaNext (pNv, NVAccelGetPixmapOffset(pPix)); NVDmaNext (pNv, (2 << 4) /* 2D */ | @@ -319,7 +319,7 @@ NV30EXATexture(ScrnInfoPtr pScrn, PixmapPtr pPix, PicturePtr pPict, int unit) 0x3fd6 /* engine lock */); NVDmaNext (pNv, (pPix->drawable.width << 16) | pPix->drawable.height); NVDmaNext (pNv, 0); /* border ARGB */ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_TX_DEPTH_UNIT(unit), 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_TX_DEPTH_UNIT(unit), 1); NVDmaNext (pNv, (1 << 20) /* depth */ | (uint32_t)exaGetPixmapPitch(pPix)); @@ -342,7 +342,7 @@ NV30_SetupSurface(ScrnInfoPtr pScrn, PixmapPtr pPix, PictFormatShort format) return FALSE; } - NVDmaStart(pNv, NvSub3D, 0x208, 3); + NVDmaStart(pNv, Nv3D, 0x208, 3); NVDmaNext (pNv, fmt->card_fmt); NVDmaNext (pNv, (uint32_t)exaGetPixmapPitch(pPix)); NVDmaNext (pNv, NVAccelGetPixmapOffset(pPix)); @@ -452,12 +452,12 @@ NV30EXAPrepareComposite(int op, PicturePtr psPict, /* Appears to be some kind of cache flush, needed here at least * sometimes.. funky text rendering otherwise :) */ - NVDmaStart(pNv, NvSub3D, 0x1fd8, 1); + NVDmaStart(pNv, Nv3D, 0x1fd8, 1); NVDmaNext (pNv, 2); - NVDmaStart(pNv, NvSub3D, 0x1fd8, 1); + NVDmaStart(pNv, Nv3D, 0x1fd8, 1); NVDmaNext (pNv, 1); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_BEGIN_END, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_BEGIN_END, 1); NVDmaNext (pNv, 8); /* GL_QUADS */ return TRUE; @@ -486,16 +486,16 @@ NV30EXATransformCoord(PictTransformPtr t, int x, int y, float sx, float sy, } #define CV_OUTm(sx,sy,mx,my,dx,dy) do { \ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2F_X(8), 4); \ + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2F_X(8), 4); \ NVDmaFloat(pNv, (sx)); NVDmaFloat(pNv, (sy)); \ NVDmaFloat(pNv, (mx)); NVDmaFloat(pNv, (my)); \ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2I(0), 1); \ + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2I(0), 1); \ NVDmaNext (pNv, ((dy)<<16)|(dx)); \ } while(0) #define CV_OUT(sx,sy,dx,dy) do { \ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2F_X(8), 2); \ + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2F_X(8), 2); \ NVDmaFloat(pNv, (sx)); NVDmaFloat(pNv, (sy)); \ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2I(0), 1); \ + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VTX_ATTR_2I(0), 1); \ NVDmaNext (pNv, ((dy)<<16)|(dx)); \ } while(0) @@ -547,7 +547,7 @@ NV30EXADoneComposite(PixmapPtr pdPix) ScrnInfoPtr pScrn = xf86Screens[pdPix->drawable.pScreen->myNum]; NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_BEGIN_END, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_BEGIN_END, 1); NVDmaNext (pNv, 0); } @@ -587,42 +587,42 @@ NVAccelInitNV40TCL(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSub3D, Nv3D); + NVDmaSetObjectOnSubchannel(pNv, Nv3D, Nv3D); - NVDmaStart(pNv, NvSub3D, 0x180, 1); + NVDmaStart(pNv, Nv3D, 0x180, 1); NVDmaNext (pNv, NvDmaNotifier0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_SET_OBJECT1, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_SET_OBJECT1, 2); NVDmaNext (pNv, NvDmaFB); NVDmaNext (pNv, NvDmaFB); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_SET_OBJECT8, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_SET_OBJECT8, 1); NVDmaNext (pNv, NvDmaFB); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_SET_OBJECT4, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_SET_OBJECT4, 2); NVDmaNext (pNv, NvDmaFB); NVDmaNext (pNv, NvDmaFB); /* voodoo */ - NVDmaStart(pNv, NvSub3D, 0x1ea4, 3); + NVDmaStart(pNv, Nv3D, 0x1ea4, 3); NVDmaNext(pNv, 0x00000010); NVDmaNext(pNv, 0x01000100); NVDmaNext(pNv, 0xff800006); - NVDmaStart(pNv, NvSub3D, 0x1fc4, 1); + NVDmaStart(pNv, Nv3D, 0x1fc4, 1); NVDmaNext(pNv, 0x06144321); - NVDmaStart(pNv, NvSub3D, 0x1fc8, 2); + NVDmaStart(pNv, Nv3D, 0x1fc8, 2); NVDmaNext(pNv, 0xedcba987); NVDmaNext(pNv, 0x00000021); - NVDmaStart(pNv, NvSub3D, 0x1fd0, 1); + NVDmaStart(pNv, Nv3D, 0x1fd0, 1); NVDmaNext(pNv, 0x00171615); - NVDmaStart(pNv, NvSub3D, 0x1fd4, 1); + NVDmaStart(pNv, Nv3D, 0x1fd4, 1); NVDmaNext(pNv, 0x001b1a19); - NVDmaStart(pNv, NvSub3D, 0x1ef8, 1); + NVDmaStart(pNv, Nv3D, 0x1ef8, 1); NVDmaNext(pNv, 0x0020ffff); - NVDmaStart(pNv, NvSub3D, 0x1d64, 1); + NVDmaStart(pNv, Nv3D, 0x1d64, 1); NVDmaNext(pNv, 0x00d30000); - NVDmaStart(pNv, NvSub3D, 0x1e94, 1); + NVDmaStart(pNv, Nv3D, 0x1e94, 1); NVDmaNext(pNv, 0x00000001); /* identity viewport transform */ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_XFRM_OX, 8); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_XFRM_OX, 8); NVDmaFloat(pNv, 0.0); NVDmaFloat(pNv, 0.0); NVDmaFloat(pNv, 0.0); @@ -634,63 +634,63 @@ NVAccelInitNV40TCL(ScrnInfoPtr pScrn) /* default 3D state */ /*XXX: replace with the same state that the DRI emits on startup */ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_FRONT_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_STENCIL_FRONT_ENABLE, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_BACK_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_STENCIL_BACK_ENABLE, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_ALPHA_FUNC_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_ALPHA_FUNC_ENABLE, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_DEPTH_WRITE_ENABLE, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_DEPTH_WRITE_ENABLE, 2); NVDmaNext (pNv, 0); /* wr disable */ NVDmaNext (pNv, 0); /* test disable */ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_COLOR_MASK, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_COLOR_MASK, 1); NVDmaNext (pNv, 0x01010101); /* TR,TR,TR,TR */ - NVDmaStart(pNv, NvSub3D, NV40_TCL_PRIMITIVE_3D_COLOR_MASK_BUFFER123, 1); + NVDmaStart(pNv, Nv3D, NV40_TCL_PRIMITIVE_3D_COLOR_MASK_BUFFER123, 1); NVDmaNext (pNv, 0x0000fff0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_CULL_FACE_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_CULL_FACE_ENABLE, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_LOGIC_OP_ENABLE, 2); NVDmaNext (pNv, 0); NVDmaNext (pNv, 0x1503); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_DITHER_ENABLE, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_DITHER_ENABLE, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_SHADE_MODEL, 1); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_SHADE_MODEL, 1); NVDmaNext (pNv, 0x1d01); /* GL_SMOOTH */ - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_OFFSET_FACTOR,2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_POLYGON_OFFSET_FACTOR,2); NVDmaFloat(pNv, 0.0); NVDmaFloat(pNv, 0.0); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_MODE_FRONT, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_POLYGON_MODE_FRONT, 2); NVDmaNext (pNv, 0x1b02); /* FRONT = GL_FILL */ NVDmaNext (pNv, 0x1b02); /* BACK = GL_FILL */ - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_POLYGON_STIPPLE_PATTERN(0), 0x20); for (i=0;i<0x20;i++) NVDmaNext(pNv, 0xFFFFFFFF); for (i=0;i<16;i++) { - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_TX_ENABLE_UNIT(i), 1); NVDmaNext(pNv, 0); } - NVDmaStart(pNv, NvSub3D, 0x1d78, 1); + NVDmaStart(pNv, Nv3D, 0x1d78, 1); NVDmaNext (pNv, 0x110); - NVDmaStart(pNv, NvSub3D, 0x0220, 1); + NVDmaStart(pNv, Nv3D, 0x0220, 1); NVDmaNext (pNv, 1); - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_COLOR_BUFFER_DIM0, 2); NVDmaNext (pNv, (4096 << 16)); NVDmaNext (pNv, (4096 << 16)); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_SCISSOR_WIDTH_XPOS, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_SCISSOR_WIDTH_XPOS, 2); NVDmaNext (pNv, (4096 << 16)); NVDmaNext (pNv, (4096 << 16)); - NVDmaStart(pNv, NvSub3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_DIMS_0, 2); + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_DIMS_0, 2); NVDmaNext (pNv, (4096 << 16)); NVDmaNext (pNv, (4096 << 16)); - NVDmaStart(pNv, NvSub3D, + NVDmaStart(pNv, Nv3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_COLOR_BUFFER_OFS0, 2); NVDmaNext (pNv, (4095 << 16)); NVDmaNext (pNv, (4095 << 16)); diff --git a/src/nv_accel_common.c b/src/nv_accel_common.c index 51bb5a7..2c9070e 100644 --- a/src/nv_accel_common.c +++ b/src/nv_accel_common.c @@ -67,11 +67,9 @@ NVAccelInitContextSurfaces(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubContextSurfaces, - NvContextSurfaces); - NVDmaStart(pNv, NvSubContextSurfaces, NV04_SURFACE_DMA_NOTIFY, 1); + NVDmaStart(pNv, NvContextSurfaces, NV04_SURFACE_DMA_NOTIFY, 1); NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubContextSurfaces, NV04_SURFACE_DMA_IMAGE_SOURCE, 2); + NVDmaStart(pNv, NvContextSurfaces, NV04_SURFACE_DMA_IMAGE_SOURCE, 2); NVDmaNext (pNv, NvDmaFB); NVDmaNext (pNv, NvDmaFB); @@ -130,7 +128,7 @@ NVAccelSetCtxSurf2D(PixmapPtr psPix, PixmapPtr pdPix, int format) ScrnInfoPtr pScrn = xf86Screens[psPix->drawable.pScreen->myNum]; NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubContextSurfaces, SURFACE_FORMAT, 4); + NVDmaStart(pNv, NvContextSurfaces, SURFACE_FORMAT, 4); NVDmaNext (pNv, format); NVDmaNext (pNv, ((uint32_t)exaGetPixmapPitch(pdPix) << 16) | (uint32_t)exaGetPixmapPitch(psPix)); @@ -156,12 +154,10 @@ NVAccelInitImagePattern(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubImagePattern, - NvImagePattern); - NVDmaStart(pNv, NvSubImagePattern, + NVDmaStart(pNv, NvImagePattern, 0x180, /*NV04_IMAGE_PATTERN_SET_DMA_NOTIFY*/ 1); NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubImagePattern, NV04_IMAGE_PATTERN_MONO_FORMAT, 3); + NVDmaStart(pNv, NvImagePattern, NV04_IMAGE_PATTERN_MONO_FORMAT, 3); #if X_BYTE_ORDER == X_BIG_ENDIAN NVDmaNext (pNv, 2 /* NV04_IMAGE_PATTERN_BIGENDIAN/LE_M1 */); #else @@ -189,8 +185,7 @@ NVAccelInitRasterOp(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubRop, NvRop); - NVDmaStart(pNv, NvSubRop, NV03_PRIMITIVE_RASTER_OP_DMA_NOTIFY, 1); + NVDmaStart(pNv, NvRop, NV03_PRIMITIVE_RASTER_OP_DMA_NOTIFY, 1); NVDmaNext (pNv, NvNullObject); return TRUE; @@ -212,20 +207,19 @@ NVAccelInitRectangle(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubRectangle, NvRectangle); - NVDmaStart(pNv, NvSubRectangle, + NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_SET_DMA_NOTIFY, 1); NVDmaNext (pNv, NvDmaNotifier0); - NVDmaStart(pNv, NvSubRectangle, + NVDmaStart(pNv, NvRectangle, 0x184 /*NV04_GDI_RECTANGLE_TEXT_SET_DMA_FONTS*/, 1); NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubRectangle, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1); + NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1); NVDmaNext (pNv, NvContextSurfaces); - NVDmaStart(pNv, NvSubRectangle, NV04_GDI_RECTANGLE_TEXT_ROP5, 1); + NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_ROP5, 1); NVDmaNext (pNv, NvRop); - NVDmaStart(pNv, NvSubRectangle, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1); + NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1); NVDmaNext (pNv, NvImagePattern); - NVDmaStart(pNv, NvSubRectangle, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1); + NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1); NVDmaNext (pNv, 1 /* ROP_AND */); return TRUE; @@ -247,18 +241,17 @@ NVAccelInitImageBlit(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubImageBlit, NvImageBlit); - NVDmaStart(pNv, NvSubImageBlit, NV_IMAGE_BLIT_DMA_NOTIFY, 1); + NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_DMA_NOTIFY, 1); NVDmaNext (pNv, NvDmaNotifier0); - NVDmaStart(pNv, NvSubImageBlit, NV_IMAGE_BLIT_COLOR_KEY, 1); + NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_COLOR_KEY, 1); NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubImageBlit, NV_IMAGE_BLIT_SURFACE, 1); + NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_SURFACE, 1); NVDmaNext (pNv, NvContextSurfaces); - NVDmaStart(pNv, NvSubImageBlit, NV_IMAGE_BLIT_CLIP_RECTANGLE, 3); + NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_CLIP_RECTANGLE, 3); NVDmaNext (pNv, NvNullObject); NVDmaNext (pNv, NvImagePattern); NVDmaNext (pNv, NvRop); - NVDmaStart(pNv, NvSubImageBlit, NV_IMAGE_BLIT_OPERATION, 1); + NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_OPERATION, 1); NVDmaNext (pNv, 1 /* NV_IMAGE_BLIT_OPERATION_ROP_AND */); return TRUE; @@ -293,25 +286,24 @@ NVAccelInitScaledImage(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubScaledImage, NvScaledImage); - NVDmaStart(pNv, NvSubScaledImage, + NVDmaStart(pNv, NvScaledImage, NV04_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY, 1); NVDmaNext (pNv, NvDmaNotifier0); - NVDmaStart(pNv, NvSubScaledImage, + NVDmaStart(pNv, NvScaledImage, NV04_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE, 1); NVDmaNext (pNv, NvDmaFB); /* source object */ - NVDmaStart(pNv, NvSubScaledImage, + NVDmaStart(pNv, NvScaledImage, NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE, 1); NVDmaNext (pNv, NvContextSurfaces); - NVDmaStart(pNv, NvSubScaledImage, 0x188, 1); /* PATTERN */ + NVDmaStart(pNv, NvScaledImage, 0x188, 1); /* PATTERN */ NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubScaledImage, 0x18c, 1); /* ROP */ + NVDmaStart(pNv, NvScaledImage, 0x18c, 1); /* ROP */ NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubScaledImage, 0x190, 1); /* BETA1 */ + NVDmaStart(pNv, NvScaledImage, 0x190, 1); /* BETA1 */ NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubScaledImage, 0x194, 1); /* BETA4 */ + NVDmaStart(pNv, NvScaledImage, 0x194, 1); /* BETA4 */ NVDmaNext (pNv, NvNullObject); - NVDmaStart(pNv, NvSubScaledImage, + NVDmaStart(pNv, NvScaledImage, NV04_SCALED_IMAGE_FROM_MEMORY_OPERATION, 1); NVDmaNext (pNv, 3 /* SRCCOPY */); @@ -332,8 +324,7 @@ NVAccelInitClipRectangle(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubClipRectangle, NvClipRectangle); - NVDmaStart(pNv, NvSubClipRectangle, 0x180, 1); /* DMA_NOTIFY */ + NVDmaStart(pNv, NvClipRectangle, 0x180, 1); /* DMA_NOTIFY */ NVDmaNext (pNv, NvNullObject); return TRUE; @@ -353,14 +344,13 @@ NVAccelInitSolidLine(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubSolidLine, NvSolidLine); - NVDmaStart(pNv, NvSubSolidLine, NV04_SOLID_LINE_CLIP_RECTANGLE, 3); + NVDmaStart(pNv, NvSolidLine, NV04_SOLID_LINE_CLIP_RECTANGLE, 3); NVDmaNext (pNv, NvClipRectangle); NVDmaNext (pNv, NvImagePattern); NVDmaNext (pNv, NvRop); - NVDmaStart(pNv, NvSubSolidLine, NV04_SOLID_LINE_SURFACE, 1); + NVDmaStart(pNv, NvSolidLine, NV04_SOLID_LINE_SURFACE, 1); NVDmaNext (pNv, NvContextSurfaces); - NVDmaStart(pNv, NvSubSolidLine, NV04_SOLID_LINE_OPERATION, 1); + NVDmaStart(pNv, NvSolidLine, NV04_SOLID_LINE_OPERATION, 1); NVDmaNext (pNv, 1); /* ROP_AND */ return TRUE; @@ -382,11 +372,10 @@ NVAccelInitMemFormat(ScrnInfoPtr pScrn) have_object = TRUE; } - NVDmaSetObjectOnSubchannel(pNv, NvSubMemFormat, NvMemFormat); - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1); NVDmaNext (pNv, NvDmaNotifier0); - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_OBJECT_IN, 2); NVDmaNext (pNv, NvDmaFB); NVDmaNext (pNv, NvDmaFB); diff --git a/src/nv_dma.c b/src/nv_dma.c index ea022ee..230bdc5 100644 --- a/src/nv_dma.c +++ b/src/nv_dma.c @@ -16,6 +16,45 @@ void NVDmaKickoffCallback(NVPtr pNv) pNv->DMAKickoffCallback = NULL; } +static uint32_t subchannels[8]; + +void NVDmaStart(NVPtr pNv, uint32_t object, uint32_t tag, int size) +{ + int subchannel=-1; + int i; + /* XXX FIXME */ + ScrnInfoPtr pScrn = xf86Screens[0]; + + /* look for a subchannel already bound to that object */ + for(i=0;i<8;i++) + { + if (subchannels[i]==object) + { + subchannel=i; + break; + } + } + + /* add 2 for the potential subchannel binding */ + if((pNv)->dmaFree <= (size + 2)) + NVDmaWait(pScrn, size + 2); + + if (subchannel==-1) + { + /* bind the object */ + subchannel=rand()%8; + subchannels[subchannel]=object; + NVDEBUG("Bind object %x on subchannel %d\n", (object), (subchannel)); + NVDmaNext(pNv, (1<<18) | (subchannel<<13)); + NVDmaNext(pNv,object); + pNv->dmaFree -= (2); + } + NVDEBUG("NVDmaStart: subc=%d, cmd=%x, num=%d\n", (subchannel), (tag), (size)); + NVDmaNext(pNv, ((size) << 18) | ((subchannel) << 13) | (tag)); + pNv->dmaFree -= ((size) + 1); +} + + /* There is a HW race condition with videoram command buffers. * You can't jump to the location of your put offset. We write put * at the jump offset + SKIPS dwords with noop padding in between @@ -109,9 +148,9 @@ void NVSync(ScrnInfoPtr pScrn) /* Wait for channel to go completely idle */ NVNotifierReset(pScrn, pNv->Notifier0); - NVDmaStart(pNv, NvSubImageBlit, 0x104, 1); + NVDmaStart(pNv, NvImageBlit, 0x104, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSubImageBlit, 0x100, 1); + NVDmaStart(pNv, NvImageBlit, 0x100, 1); NVDmaNext (pNv, 0); NVDmaKickoff(pNv); if (!NVNotifierWaitStatus(pScrn, pNv->Notifier0, 0, timeout)) @@ -141,23 +180,10 @@ void NVResetGraphics(ScrnInfoPtr pScrn) } pNv->dmaFree -= SKIPS; - NVAccelCommonInit(pScrn); + for(i=0;i<8;i++) + subchannels[i]=0; - /* EXA + XAA + Xv */ - NVDmaSetObjectOnSubchannel(pNv, NvSubContextSurfaces, NvContextSurfaces); - NVDmaSetObjectOnSubchannel(pNv, NvSubRectangle , NvRectangle ); - NVDmaSetObjectOnSubchannel(pNv, NvSubScaledImage , NvScaledImage ); - /* EXA + XAA */ - NVDmaSetObjectOnSubchannel(pNv, NvSubRop , NvRop ); - NVDmaSetObjectOnSubchannel(pNv, NvSubImagePattern, NvImagePattern ); - NVDmaSetObjectOnSubchannel(pNv, NvSubImageBlit , NvImageBlit ); - if (pNv->useEXA) { - if (pNv->GARTScratch) - NVDmaSetObjectOnSubchannel(pNv, NvSubMemFormat, NvMemFormat); - } else if (!pNv->useEXA) { - NVDmaSetObjectOnSubchannel(pNv, NvSubClipRectangle, NvClipRectangle); - NVDmaSetObjectOnSubchannel(pNv, NvSubSolidLine, NvSolidLine); - } + NVAccelCommonInit(pScrn); switch(pNv->CurrentLayout.depth) { case 24: @@ -181,20 +207,20 @@ void NVResetGraphics(ScrnInfoPtr pScrn) break; } - NVDmaStart(pNv, NvSubContextSurfaces, SURFACE_FORMAT, 4); + NVDmaStart(pNv, NvContextSurfaces, SURFACE_FORMAT, 4); NVDmaNext (pNv, surfaceFormat); NVDmaNext (pNv, pitch | (pitch << 16)); NVDmaNext (pNv, (uint32_t)pNv->FB->offset); NVDmaNext (pNv, (uint32_t)pNv->FB->offset); - NVDmaStart(pNv, NvSubImagePattern, PATTERN_FORMAT, 1); + NVDmaStart(pNv, NvImagePattern, PATTERN_FORMAT, 1); NVDmaNext (pNv, patternFormat); - NVDmaStart(pNv, NvSubRectangle, RECT_FORMAT, 1); + NVDmaStart(pNv, NvRectangle, RECT_FORMAT, 1); NVDmaNext (pNv, rectFormat); if (!pNv->useEXA) { - NVDmaStart(pNv, NvSubSolidLine, LINE_FORMAT, 1); + NVDmaStart(pNv, NvSolidLine, LINE_FORMAT, 1); NVDmaNext (pNv, lineFormat); } diff --git a/src/nv_dma.h b/src/nv_dma.h index fff3dc4..8911cc4 100644 --- a/src/nv_dma.h +++ b/src/nv_dma.h @@ -110,23 +110,6 @@ enum DMASubchannel { NVDmaNext((pNv), c.u); \ } while(0) -#define NVDmaStart(pNv, subchannel, tag, size) do { \ - if((pNv)->dmaFree <= (size)) \ - NVDmaWait(pScrn, size); \ - NVDEBUG("NVDmaStart: subc=%d, cmd=%x, num=%d\n", (subchannel), (tag), (size)); \ - NVDmaNext(pNv, ((size) << 18) | ((subchannel) << 13) | (tag)); \ - (pNv)->dmaFree -= ((size) + 1); \ -} while(0) - -#define NVDmaStart_NonInc(pNv, subchannel, tag, size) do { \ - NVDmaStart((pNv), (subchannel), (tag)|0x40000000, (size)); \ -} while(0) - -#define NVDmaSetObjectOnSubchannel(pNv, subchannel, object) do { \ - NVDmaStart(pNv, subchannel, 0, 1); \ - NVDmaNext(pNv,object); \ -} while(0) - #define SURFACE_FORMAT 0x00000300 #define SURFACE_FORMAT_Y8 0x00000001 #define SURFACE_FORMAT_X1R5G5B5 0x00000002 diff --git a/src/nv_exa.c b/src/nv_exa.c index 700a49a..d62c1e8 100644 --- a/src/nv_exa.c +++ b/src/nv_exa.c @@ -55,7 +55,7 @@ static void setM2MFDirection(ScrnInfoPtr pScrn, int dir) if (pNv->M2MFDirection != dir) { - NVDmaStart(pNv, NvSubMemFormat, MEMFORMAT_DMA_OBJECT_IN, 2); + NVDmaStart(pNv, NvMemFormat, MEMFORMAT_DMA_OBJECT_IN, 2); NVDmaNext (pNv, dir ? NvDmaTT : NvDmaFB); NVDmaNext (pNv, dir ? NvDmaFB : NvDmaTT); pNv->M2MFDirection = dir; @@ -97,11 +97,11 @@ static Bool NVExaPrepareSolid(PixmapPtr pPixmap, if (planemask != ~0 || alu != GXcopy) { if (pPixmap->drawable.bitsPerPixel == 32) return FALSE; - NVDmaStart(pNv, NvSubRectangle, 0x2fc, 1); + NVDmaStart(pNv, NvRectangle, 0x2fc, 1); NVDmaNext (pNv, 1 /* ROP_AND */); NVSetRopSolid(pScrn, alu, planemask); } else { - NVDmaStart(pNv, NvSubRectangle, 0x2fc, 1); + NVDmaStart(pNv, NvRectangle, 0x2fc, 1); NVDmaNext (pNv, 3 /* SRCCOPY */); } @@ -118,9 +118,9 @@ static Bool NVExaPrepareSolid(PixmapPtr pPixmap, if (!NVAccelSetCtxSurf2D(pPixmap, pPixmap, fmt)) return FALSE; - NVDmaStart(pNv, NvSubRectangle, RECT_FORMAT, 1); + NVDmaStart(pNv, NvRectangle, RECT_FORMAT, 1); NVDmaNext (pNv, rectFormat(&pPixmap->drawable)); - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_COLOR, 1); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_COLOR, 1); NVDmaNext (pNv, fg); pNv->DMAKickoffCallback = NVDmaKickoffCallback; @@ -134,7 +134,7 @@ static void NVExaSolid (PixmapPtr pPixmap, int x1, int y1, int x2, int y2) int width = x2-x1; int height = y2-y1; - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_RECTS(0), 2); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_RECTS(0), 2); NVDmaNext (pNv, (x1 << 16) | y1); NVDmaNext (pNv, (width << 16) | height); @@ -165,11 +165,11 @@ static Bool NVExaPrepareCopy(PixmapPtr pSrcPixmap, if (planemask != ~0 || alu != GXcopy) { if (pDstPixmap->drawable.bitsPerPixel == 32) return FALSE; - NVDmaStart(pNv, NvSubImageBlit, 0x2fc, 1); + NVDmaStart(pNv, NvImageBlit, 0x2fc, 1); NVDmaNext (pNv, 1 /* ROP_AND */); NVSetRopSolid(pScrn, alu, planemask); } else { - NVDmaStart(pNv, NvSubImageBlit, 0x2fc, 1); + NVDmaStart(pNv, NvImageBlit, 0x2fc, 1); NVDmaNext (pNv, 3 /* SRCCOPY */); } @@ -221,7 +221,7 @@ static void NVExaCopy(PixmapPtr pDstPixmap, inc=-1; } for (i = 0; i < width; i++) { - NVDmaStart(pNv, NvSubImageBlit, BLIT_POINT_SRC, 3); + NVDmaStart(pNv, NvImageBlit, BLIT_POINT_SRC, 3); NVDmaNext (pNv, (srcY << 16) | (srcX+xpos)); NVDmaNext (pNv, (dstY << 16) | (dstX+xpos)); NVDmaNext (pNv, (height << 16) | 1); @@ -240,7 +240,7 @@ static void NVExaCopy(PixmapPtr pDstPixmap, inc=-1; } for (i = 0; i < height; i++) { - NVDmaStart(pNv, NvSubImageBlit, BLIT_POINT_SRC, 3); + NVDmaStart(pNv, NvImageBlit, BLIT_POINT_SRC, 3); NVDmaNext (pNv, ((srcY+ypos) << 16) | srcX); NVDmaNext (pNv, ((dstY+ypos) << 16) | dstX); NVDmaNext (pNv, (1 << 16) | width); @@ -249,7 +249,7 @@ static void NVExaCopy(PixmapPtr pDstPixmap, } } else { NVDEBUG("ExaCopy: Using default path\n"); - NVDmaStart(pNv, NvSubImageBlit, BLIT_POINT_SRC, 3); + NVDmaStart(pNv, NvImageBlit, BLIT_POINT_SRC, 3); NVDmaNext (pNv, (srcY << 16) | srcX); NVDmaNext (pNv, (dstY << 16) | dstX); NVDmaNext (pNv, (height << 16) | width); @@ -302,7 +302,7 @@ NVAccelDownloadM2MF(ScrnInfoPtr pScrn, char *dst, uint64_t src_offset, if (lc > 2047) lc = 2047; - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8); NVDmaNext (pNv, (uint32_t)src_offset); NVDmaNext (pNv, (uint32_t)pNv->GARTScratch->offset); @@ -314,10 +314,10 @@ NVAccelDownloadM2MF(ScrnInfoPtr pScrn, char *dst, uint64_t src_offset, NVDmaNext (pNv, 0); NVNotifierReset(pScrn, pNv->Notifier0); - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSubMemFormat, 0x100, 1); + NVDmaStart(pNv, NvMemFormat, 0x100, 1); NVDmaNext (pNv, 0); NVDmaKickoff(pNv); if (!NVNotifierWaitStatus(pScrn, pNv->Notifier0, 0, 0)) @@ -408,7 +408,7 @@ NVAccelUploadM2MF(ScrnInfoPtr pScrn, uint64_t dst_offset, const char *src, } /* DMA to VRAM */ - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8); NVDmaNext (pNv, (uint32_t)pNv->GARTScratch->offset); NVDmaNext (pNv, (uint32_t)dst_offset); @@ -420,10 +420,10 @@ NVAccelUploadM2MF(ScrnInfoPtr pScrn, uint64_t dst_offset, const char *src, NVDmaNext (pNv, 0); NVNotifierReset(pScrn, pNv->Notifier0); - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSubMemFormat, 0x100, 1); + NVDmaStart(pNv, NvMemFormat, 0x100, 1); NVDmaNext (pNv, 0); NVDmaKickoff(pNv); if (!NVNotifierWaitStatus(pScrn, pNv->Notifier0, 0, 0)) @@ -524,7 +524,7 @@ static Bool NVPrepareComposite(int op, if (!NVAccelSetCtxSurf2D(pDst, pDst, dstFormat)) return FALSE; - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_FORMAT, 2); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_FORMAT, 2); NVDmaNext (pNv, srcFormat); NVDmaNext (pNv, (op == PictOpSrc) ? STRETCH_BLIT_OPERATION_COPY : STRETCH_BLIT_OPERATION_BLEND); @@ -552,7 +552,7 @@ static void NVComposite(PixmapPtr pDst, ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum]; NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_CLIP_POINT, 6); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_CLIP_POINT, 6); NVDmaNext (pNv, dstX | (dstY << 16)); NVDmaNext (pNv, width | (height << 16)); NVDmaNext (pNv, dstX | (dstY << 16)); @@ -560,7 +560,7 @@ static void NVComposite(PixmapPtr pDst, NVDmaNext (pNv, 1<<20); NVDmaNext (pNv, 1<<20); - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_SRC_SIZE, 4); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_SRC_SIZE, 4); NVDmaNext (pNv, src_size); NVDmaNext (pNv, src_pitch); NVDmaNext (pNv, src_offset); @@ -582,7 +582,7 @@ static void NVDoneComposite (PixmapPtr pDst) else format = SURFACE_FORMAT_X8R8G8B8; - NVDmaStart(pNv, NvSubContextSurfaces, SURFACE_FORMAT, 1); + NVDmaStart(pNv, NvContextSurfaces, SURFACE_FORMAT, 1); NVDmaNext (pNv, format); exaMarkSync(pDst->drawable.pScreen); diff --git a/src/nv_video.c b/src/nv_video.c index 86e2e69..e6a07b9 100644 --- a/src/nv_video.c +++ b/src/nv_video.c @@ -636,7 +636,7 @@ NVPutBlitImage(ScrnInfoPtr pScrn, int src_offset, int id, #endif } else { if (pNv->CurrentLayout.depth == 15) { - NVDmaStart(pNv, NvSubContextSurfaces, + NVDmaStart(pNv, NvContextSurfaces, SURFACE_FORMAT, 1); NVDmaNext (pNv, SURFACE_FORMAT_X1R5G5B5); } @@ -674,19 +674,19 @@ NVPutBlitImage(ScrnInfoPtr pScrn, int src_offset, int id, } if(pNv->BlendingPossible) { - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_FORMAT, 2); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_FORMAT, 2); NVDmaNext (pNv, src_format); NVDmaNext (pNv, STRETCH_BLIT_OPERATION_COPY); } else { - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_FORMAT, 1); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_FORMAT, 1); NVDmaNext (pNv, src_format); } while(nbox--) { - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_COLOR, 1); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_COLOR, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_CLIP_POINT, 6); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_CLIP_POINT, 6); NVDmaNext (pNv, (pbox->y1 << 16) | pbox->x1); NVDmaNext (pNv, ((pbox->y2 - pbox->y1) << 16) | (pbox->x2 - pbox->x1)); @@ -695,7 +695,7 @@ NVPutBlitImage(ScrnInfoPtr pScrn, int src_offset, int id, NVDmaNext (pNv, dsdx); NVDmaNext (pNv, dtdy); - NVDmaStart(pNv, NvSubScaledImage, STRETCH_BLIT_SRC_SIZE, 4); + NVDmaStart(pNv, NvScaledImage, STRETCH_BLIT_SRC_SIZE, 4); NVDmaNext (pNv, (height << 16) | width); NVDmaNext (pNv, src_pitch); NVDmaNext (pNv, src_offset); @@ -705,7 +705,7 @@ NVPutBlitImage(ScrnInfoPtr pScrn, int src_offset, int id, if (!pNv->useEXA) { if(pNv->CurrentLayout.depth == 15) { - NVDmaStart(pNv, NvSubContextSurfaces, + NVDmaStart(pNv, NvContextSurfaces, SURFACE_FORMAT, 1); NVDmaNext (pNv, SURFACE_FORMAT_R5G6B5); } @@ -1338,14 +1338,14 @@ NVPutImage(ScrnInfoPtr pScrn, short src_x, short src_y, } - NVDmaStart(pNv, NvSubMemFormat, MEMFORMAT_DMA_OBJECT_IN, 2); + NVDmaStart(pNv, NvMemFormat, MEMFORMAT_DMA_OBJECT_IN, 2); NVDmaNext (pNv, NvDmaTT); NVDmaNext (pNv, NvDmaFB); pNv->M2MFDirection = 1; /* DMA to VRAM */ - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8); NVDmaNext (pNv, (uint32_t)destination_buffer->offset); NVDmaNext (pNv, (uint32_t)offset + DMAoffset); @@ -1362,21 +1362,21 @@ NVPutImage(ScrnInfoPtr pScrn, short src_x, short src_y, } else { NVNotifierReset(pScrn, pPriv->DMANotifier[pPriv->currentHostBuffer]); - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1); NVDmaNext (pNv, pPriv->DMANotifier[pPriv->currentHostBuffer]->handle); } - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1); NVDmaNext (pNv, 0); - NVDmaStart(pNv, NvSubMemFormat, 0x100, 1); + NVDmaStart(pNv, NvMemFormat, 0x100, 1); NVDmaNext (pNv, 0); //Put back NvDmaNotifier0 for EXA - NVDmaStart(pNv, NvSubMemFormat, + NVDmaStart(pNv, NvMemFormat, NV_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1); NVDmaNext (pNv, NvDmaNotifier0); diff --git a/src/nv_xaa.c b/src/nv_xaa.c index 9c32910..f5d5b09 100644 --- a/src/nv_xaa.c +++ b/src/nv_xaa.c @@ -137,7 +137,7 @@ NVSetPattern( { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubImagePattern, PATTERN_COLOR_0, 4); + NVDmaStart(pNv, NvImagePattern, PATTERN_COLOR_0, 4); NVDmaNext (pNv, clr0); NVDmaNext (pNv, clr1); NVDmaNext (pNv, pat0); @@ -152,7 +152,7 @@ NVSetRopSolid(ScrnInfoPtr pScrn, CARD32 rop, CARD32 planemask) if(planemask != ~0) { NVSetPattern(pScrn, 0, planemask, ~0, ~0); if(pNv->currentRop != (rop + 32)) { - NVDmaStart(pNv, NvSubRop, ROP_SET, 1); + NVDmaStart(pNv, NvRop, ROP_SET, 1); NVDmaNext (pNv, NVCopyROP_PM[rop]); pNv->currentRop = rop + 32; } @@ -160,7 +160,7 @@ NVSetRopSolid(ScrnInfoPtr pScrn, CARD32 rop, CARD32 planemask) if (pNv->currentRop != rop) { if(pNv->currentRop >= 16) NVSetPattern(pScrn, ~0, ~0, ~0, ~0); - NVDmaStart(pNv, NvSubRop, ROP_SET, 1); + NVDmaStart(pNv, NvRop, ROP_SET, 1); NVDmaNext (pNv, NVCopyROP[rop]); pNv->currentRop = rop; } @@ -194,7 +194,7 @@ NVSubsequentScreenToScreenCopy( { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubImageBlit, BLIT_POINT_SRC, 3); + NVDmaStart(pNv, NvImageBlit, BLIT_POINT_SRC, 3); NVDmaNext (pNv, (y1 << 16) | x1); NVDmaNext (pNv, (y2 << 16) | x2); NVDmaNext (pNv, (h << 16) | w); @@ -216,7 +216,7 @@ NVSetupForSolidFill( planemask |= ~0 << pNv->CurrentLayout.depth; NVSetRopSolid(pScrn, rop, planemask); - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_COLOR, 1); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_COLOR, 1); NVDmaNext (pNv, color); pNv->DMAKickoffCallback = NVDmaKickoffCallback; @@ -227,7 +227,7 @@ NVSubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h) { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_RECTS(0), 2); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_RECTS(0), 2); NVDmaNext (pNv, (x << 16) | y); NVDmaNext (pNv, (w << 16) | h); @@ -253,13 +253,13 @@ NVSetupForMono8x8PatternFill ( else bg |= planemask; if (pNv->currentRop != (rop + 16)) { - NVDmaStart(pNv, NvSubRop, ROP_SET, 1); + NVDmaStart(pNv, NvRop, ROP_SET, 1); NVDmaNext (pNv, NVPatternROP[rop]); pNv->currentRop = rop + 16; } NVSetPattern(pScrn, bg, fg, patternx, patterny); - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_COLOR, 1); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_COLOR, 1); NVDmaNext (pNv, fg); pNv->DMAKickoffCallback = NVDmaKickoffCallback; @@ -275,7 +275,7 @@ NVSubsequentMono8x8PatternFillRect( { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubRectangle, RECT_SOLID_RECTS(0), 2); + NVDmaStart(pNv, NvRectangle, RECT_SOLID_RECTS(0), 2); NVDmaNext (pNv, (x << 16) | y); NVDmaNext (pNv, (w << 16) | h); @@ -331,7 +331,7 @@ NVSubsequentScanlineCPUToScreenColorExpandFill ( _remaining = h; if(_transparent) { - NVDmaStart(pNv, NvSubRectangle, RECT_EXPAND_ONE_COLOR_CLIP, 5); + NVDmaStart(pNv, NvRectangle, RECT_EXPAND_ONE_COLOR_CLIP, 5); NVDmaNext (pNv, (y << 16) | ((x + skipleft) & 0xFFFF)); NVDmaNext (pNv, ((y + h) << 16) | ((x + w) & 0xFFFF)); NVDmaNext (pNv, _fg_pixel); @@ -339,7 +339,7 @@ NVSubsequentScanlineCPUToScreenColorExpandFill ( NVDmaNext (pNv, (y << 16) | (x & 0xFFFF)); _color_expand_offset = RECT_EXPAND_ONE_COLOR_DATA(0); } else { - NVDmaStart(pNv, NvSubRectangle, RECT_EXPAND_TWO_COLOR_CLIP, 7); + NVDmaStart(pNv, NvRectangle, RECT_EXPAND_TWO_COLOR_CLIP, 7); NVDmaNext (pNv, (y << 16) | ((x + skipleft) & 0xFFFF)); NVDmaNext (pNv, ((y + h) << 16) | ((x + w) & 0xFFFF)); NVDmaNext (pNv, _bg_pixel); @@ -350,7 +350,7 @@ NVSubsequentScanlineCPUToScreenColorExpandFill ( _color_expand_offset = RECT_EXPAND_TWO_COLOR_DATA(0); } - NVDmaStart(pNv, NvSubRectangle, _color_expand_offset, _color_expand_dwords); + NVDmaStart(pNv, NvRectangle, _color_expand_offset, _color_expand_dwords); _storage_buffer[0] = (unsigned char*)&pNv->dmaBase[pNv->dmaCurrent]; } @@ -362,11 +362,11 @@ NVSubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno) pNv->dmaCurrent += _color_expand_dwords; if(--_remaining) { - NVDmaStart(pNv, NvSubRectangle, _color_expand_offset, _color_expand_dwords); + NVDmaStart(pNv, NvRectangle, _color_expand_offset, _color_expand_dwords); _storage_buffer[0] = (unsigned char*)&pNv->dmaBase[pNv->dmaCurrent]; } else { /* hardware bug workaround */ - NVDmaStart(pNv, NvSubImageBlit, BLIT_POINT_SRC, 1); + NVDmaStart(pNv, NvImageBlit, BLIT_POINT_SRC, 1); NVDmaNext (pNv, 0); NVDmaKickoff(pNv); } @@ -414,7 +414,7 @@ NVSubsequentScanlineImageWriteRect( NVSync(pScrn); - NVDmaStart(pNv, NvSubContextSurfaces, SURFACE_PITCH, 2); + NVDmaStart(pNv, NvContextSurfaces, SURFACE_PITCH, 2); NVDmaNext (pNv, (_image_dstpitch << 16) | image_srcpitch); NVDmaNext (pNv, pNv->ScratchBuffer->offset); } @@ -423,7 +423,7 @@ static void NVSubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno) { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubImageBlit, BLIT_POINT_SRC, 3); + NVDmaStart(pNv, NvImageBlit, BLIT_POINT_SRC, 3); NVDmaNext (pNv, _image_srcpoint); NVDmaNext (pNv, _image_dstpoint); NVDmaNext (pNv, _image_size); @@ -433,7 +433,7 @@ static void NVSubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno) _image_dstpoint += (1 << 16); NVSync(pScrn); } else { - NVDmaStart(pNv, NvSubContextSurfaces, SURFACE_PITCH, 2); + NVDmaStart(pNv, NvContextSurfaces, SURFACE_PITCH, 2); NVDmaNext (pNv, _image_dstpitch | (_image_dstpitch << 16)); NVDmaNext (pNv, pNv->FB->offset); } @@ -458,9 +458,9 @@ NVSubsequentSolidHorVertLine(ScrnInfoPtr pScrn, int x, int y, int len, int dir) { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubSolidLine, LINE_COLOR, 1); + NVDmaStart(pNv, NvSolidLine, LINE_COLOR, 1); NVDmaNext (pNv, _fg_pixel); - NVDmaStart(pNv, NvSubSolidLine, LINE_LINES(0), 2); + NVDmaStart(pNv, NvSolidLine, LINE_LINES(0), 2); NVDmaNext (pNv, (y << 16) | ( x & 0xffff)); if(dir == DEGREES_0) { NVDmaNext (pNv, (y << 16) | ((x + len) & 0xffff)); @@ -480,9 +480,9 @@ NVSubsequentSolidTwoPointLine( NVPtr pNv = NVPTR(pScrn); Bool drawLast = !(flags & OMIT_LAST); - NVDmaStart(pNv, NvSubSolidLine, LINE_COLOR, 1); + NVDmaStart(pNv, NvSolidLine, LINE_COLOR, 1); NVDmaNext (pNv, _fg_pixel); - NVDmaStart(pNv, NvSubSolidLine, LINE_LINES(0), drawLast ? 4 : 2); + NVDmaStart(pNv, NvSolidLine, LINE_LINES(0), drawLast ? 4 : 2); NVDmaNext (pNv, (y1 << 16) | (x1 & 0xffff)); NVDmaNext (pNv, (y2 << 16) | (x2 & 0xffff)); if(drawLast) { @@ -498,7 +498,7 @@ NVSetClippingRectangle(ScrnInfoPtr pScrn, int x1, int y1, int x2, int y2) int h = y2 - y1 + 1; int w = x2 - x1 + 1; - NVDmaStart(pNv, NvSubClipRectangle, CLIP_POINT, 2); + NVDmaStart(pNv, NvClipRectangle, CLIP_POINT, 2); NVDmaNext (pNv, (y1 << 16) | x1); NVDmaNext (pNv, (h << 16) | w); } @@ -508,7 +508,7 @@ NVDisableClipping(ScrnInfoPtr pScrn) { NVPtr pNv = NVPTR(pScrn); - NVDmaStart(pNv, NvSubClipRectangle, CLIP_POINT, 2); + NVDmaStart(pNv, NvClipRectangle, CLIP_POINT, 2); NVDmaNext (pNv, 0); NVDmaNext (pNv, 0x7FFF7FFF); } -- cgit v1.2.1