Add subchannel handling code

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; i<shader->size; 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);
 }