r128_state.c 41.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/* r128_state.c -- State support for r128 -*- linux-c -*-
 * Created: Thu Jan 27 02:53:43 2000 by gareth@valinux.com
 *
 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *    Gareth Hughes <gareth@valinux.com>
 */

Linus Torvalds's avatar
Linus Torvalds committed
30
#include "r128.h"
Linus Torvalds's avatar
Linus Torvalds committed
31
#include "drmP.h"
32 33
#include "drm.h"
#include "r128_drm.h"
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37 38 39 40 41 42 43 44 45
#include "r128_drv.h"


/* ================================================================
 * CCE hardware state programming functions
 */

static void r128_emit_clip_rects( drm_r128_private_t *dev_priv,
				  drm_clip_rect_t *boxes, int count )
{
	u32 aux_sc_cntl = 0x00000000;
	RING_LOCALS;
46
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
47

48
	BEGIN_RING( (count < 3? count: 3) * 5 + 2 );
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

	if ( count >= 1 ) {
		OUT_RING( CCE_PACKET0( R128_AUX1_SC_LEFT, 3 ) );
		OUT_RING( boxes[0].x1 );
		OUT_RING( boxes[0].x2 - 1 );
		OUT_RING( boxes[0].y1 );
		OUT_RING( boxes[0].y2 - 1 );

		aux_sc_cntl |= (R128_AUX1_SC_EN | R128_AUX1_SC_MODE_OR);
	}
	if ( count >= 2 ) {
		OUT_RING( CCE_PACKET0( R128_AUX2_SC_LEFT, 3 ) );
		OUT_RING( boxes[1].x1 );
		OUT_RING( boxes[1].x2 - 1 );
		OUT_RING( boxes[1].y1 );
		OUT_RING( boxes[1].y2 - 1 );

		aux_sc_cntl |= (R128_AUX2_SC_EN | R128_AUX2_SC_MODE_OR);
	}
	if ( count >= 3 ) {
		OUT_RING( CCE_PACKET0( R128_AUX3_SC_LEFT, 3 ) );
		OUT_RING( boxes[2].x1 );
		OUT_RING( boxes[2].x2 - 1 );
		OUT_RING( boxes[2].y1 );
		OUT_RING( boxes[2].y2 - 1 );

		aux_sc_cntl |= (R128_AUX3_SC_EN | R128_AUX3_SC_MODE_OR);
	}

	OUT_RING( CCE_PACKET0( R128_AUX_SC_CNTL, 0 ) );
	OUT_RING( aux_sc_cntl );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
84
static __inline__ void r128_emit_core( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
85 86 87 88
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
	RING_LOCALS;
89
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92 93 94 95 96 97 98

	BEGIN_RING( 2 );

	OUT_RING( CCE_PACKET0( R128_SCALE_3D_CNTL, 0 ) );
	OUT_RING( ctx->scale_3d_cntl );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
99
static __inline__ void r128_emit_context( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
	RING_LOCALS;
104
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

	BEGIN_RING( 13 );

	OUT_RING( CCE_PACKET0( R128_DST_PITCH_OFFSET_C, 11 ) );
	OUT_RING( ctx->dst_pitch_offset_c );
	OUT_RING( ctx->dp_gui_master_cntl_c );
	OUT_RING( ctx->sc_top_left_c );
	OUT_RING( ctx->sc_bottom_right_c );
	OUT_RING( ctx->z_offset_c );
	OUT_RING( ctx->z_pitch_c );
	OUT_RING( ctx->z_sten_cntl_c );
	OUT_RING( ctx->tex_cntl_c );
	OUT_RING( ctx->misc_3d_state_cntl_reg );
	OUT_RING( ctx->texture_clr_cmp_clr_c );
	OUT_RING( ctx->texture_clr_cmp_msk_c );
	OUT_RING( ctx->fog_color_c );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
125
static __inline__ void r128_emit_setup( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
126 127 128 129
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
	RING_LOCALS;
130
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134 135 136 137 138 139 140

	BEGIN_RING( 3 );

	OUT_RING( CCE_PACKET1( R128_SETUP_CNTL, R128_PM4_VC_FPU_SETUP ) );
	OUT_RING( ctx->setup_cntl );
	OUT_RING( ctx->pm4_vc_fpu_setup );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
141
static __inline__ void r128_emit_masks( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
142 143 144 145
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
	RING_LOCALS;
146
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
147 148 149 150 151 152 153 154 155 156 157 158 159

	BEGIN_RING( 5 );

	OUT_RING( CCE_PACKET0( R128_DP_WRITE_MASK, 0 ) );
	OUT_RING( ctx->dp_write_mask );

	OUT_RING( CCE_PACKET0( R128_STEN_REF_MASK_C, 1 ) );
	OUT_RING( ctx->sten_ref_mask_c );
	OUT_RING( ctx->plane_3d_mask_c );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
160
static __inline__ void r128_emit_window( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
161 162 163 164
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
	RING_LOCALS;
165
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169 170 171 172 173 174

	BEGIN_RING( 2 );

	OUT_RING( CCE_PACKET0( R128_WINDOW_XY_OFFSET, 0 ) );
	OUT_RING( ctx->window_xy_offset );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
175
static __inline__ void r128_emit_tex0( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179 180 181
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
	drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[0];
	int i;
	RING_LOCALS;
182
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
183

Linus Torvalds's avatar
Linus Torvalds committed
184
	BEGIN_RING( 7 + R128_MAX_TEXTURE_LEVELS );
Linus Torvalds's avatar
Linus Torvalds committed
185 186

	OUT_RING( CCE_PACKET0( R128_PRIM_TEX_CNTL_C,
Linus Torvalds's avatar
Linus Torvalds committed
187
			       2 + R128_MAX_TEXTURE_LEVELS ) );
Linus Torvalds's avatar
Linus Torvalds committed
188 189 190
	OUT_RING( tex->tex_cntl );
	OUT_RING( tex->tex_combine_cntl );
	OUT_RING( ctx->tex_size_pitch_c );
Linus Torvalds's avatar
Linus Torvalds committed
191
	for ( i = 0 ; i < R128_MAX_TEXTURE_LEVELS ; i++ ) {
Linus Torvalds's avatar
Linus Torvalds committed
192 193 194 195 196 197 198 199 200 201
		OUT_RING( tex->tex_offset[i] );
	}

	OUT_RING( CCE_PACKET0( R128_CONSTANT_COLOR_C, 1 ) );
	OUT_RING( ctx->constant_color_c );
	OUT_RING( tex->tex_border_color );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
202
static __inline__ void r128_emit_tex1( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
203 204 205 206 207
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[1];
	int i;
	RING_LOCALS;
208
	DRM_DEBUG( "    %s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
209

Linus Torvalds's avatar
Linus Torvalds committed
210
	BEGIN_RING( 5 + R128_MAX_TEXTURE_LEVELS );
Linus Torvalds's avatar
Linus Torvalds committed
211 212

	OUT_RING( CCE_PACKET0( R128_SEC_TEX_CNTL_C,
Linus Torvalds's avatar
Linus Torvalds committed
213
			       1 + R128_MAX_TEXTURE_LEVELS ) );
Linus Torvalds's avatar
Linus Torvalds committed
214 215
	OUT_RING( tex->tex_cntl );
	OUT_RING( tex->tex_combine_cntl );
Linus Torvalds's avatar
Linus Torvalds committed
216
	for ( i = 0 ; i < R128_MAX_TEXTURE_LEVELS ; i++ ) {
Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221 222 223 224 225
		OUT_RING( tex->tex_offset[i] );
	}

	OUT_RING( CCE_PACKET0( R128_SEC_TEXTURE_BORDER_COLOR_C, 0 ) );
	OUT_RING( tex->tex_border_color );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
226
static __inline__ void r128_emit_state( drm_r128_private_t *dev_priv )
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230
{
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	unsigned int dirty = sarea_priv->dirty;

231
	DRM_DEBUG( "%s: dirty=0x%08x\n", __FUNCTION__, dirty );
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312

	if ( dirty & R128_UPLOAD_CORE ) {
		r128_emit_core( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_CORE;
	}

	if ( dirty & R128_UPLOAD_CONTEXT ) {
		r128_emit_context( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_CONTEXT;
	}

	if ( dirty & R128_UPLOAD_SETUP ) {
		r128_emit_setup( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_SETUP;
	}

	if ( dirty & R128_UPLOAD_MASKS ) {
		r128_emit_masks( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_MASKS;
	}

	if ( dirty & R128_UPLOAD_WINDOW ) {
		r128_emit_window( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_WINDOW;
	}

	if ( dirty & R128_UPLOAD_TEX0 ) {
		r128_emit_tex0( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_TEX0;
	}

	if ( dirty & R128_UPLOAD_TEX1 ) {
		r128_emit_tex1( dev_priv );
		sarea_priv->dirty &= ~R128_UPLOAD_TEX1;
	}

	/* Turn off the texture cache flushing */
	sarea_priv->context_state.tex_cntl_c &= ~R128_TEX_CACHE_FLUSH;

	sarea_priv->dirty &= ~R128_REQUIRE_QUIESCENCE;
}


#if R128_PERFORMANCE_BOXES
/* ================================================================
 * Performance monitoring functions
 */

static void r128_clear_box( drm_r128_private_t *dev_priv,
			    int x, int y, int w, int h,
			    int r, int g, int b )
{
	u32 pitch, offset;
	u32 fb_bpp, color;
	RING_LOCALS;

	switch ( dev_priv->fb_bpp ) {
	case 16:
		fb_bpp = R128_GMC_DST_16BPP;
		color = (((r & 0xf8) << 8) |
			 ((g & 0xfc) << 3) |
			 ((b & 0xf8) >> 3));
		break;
	case 24:
		fb_bpp = R128_GMC_DST_24BPP;
		color = ((r << 16) | (g << 8) | b);
		break;
	case 32:
		fb_bpp = R128_GMC_DST_32BPP;
		color = (((0xff) << 24) | (r << 16) | (g <<  8) | b);
		break;
	default:
		return;
	}

	offset = dev_priv->back_offset;
	pitch = dev_priv->back_pitch >> 3;

	BEGIN_RING( 6 );

	OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
Linus Torvalds's avatar
Linus Torvalds committed
313 314 315 316 317 318 319
	OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
		  R128_GMC_BRUSH_SOLID_COLOR |
		  fb_bpp |
		  R128_GMC_SRC_DATATYPE_COLOR |
		  R128_ROP3_P |
		  R128_GMC_CLR_CMP_CNTL_DIS |
		  R128_GMC_AUX_CLIP_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362

	OUT_RING( (pitch << 21) | (offset >> 5) );
	OUT_RING( color );

	OUT_RING( (x << 16) | y );
	OUT_RING( (w << 16) | h );

	ADVANCE_RING();
}

static void r128_cce_performance_boxes( drm_r128_private_t *dev_priv )
{
	if ( atomic_read( &dev_priv->idle_count ) == 0 ) {
		r128_clear_box( dev_priv, 64, 4, 8, 8, 0, 255, 0 );
	} else {
		atomic_set( &dev_priv->idle_count, 0 );
	}
}

#endif


/* ================================================================
 * CCE command dispatch functions
 */

static void r128_print_dirty( const char *msg, unsigned int flags )
{
	DRM_INFO( "%s: (0x%x) %s%s%s%s%s%s%s%s%s\n",
		  msg,
		  flags,
		  (flags & R128_UPLOAD_CORE)        ? "core, " : "",
		  (flags & R128_UPLOAD_CONTEXT)     ? "context, " : "",
		  (flags & R128_UPLOAD_SETUP)       ? "setup, " : "",
		  (flags & R128_UPLOAD_TEX0)        ? "tex0, " : "",
		  (flags & R128_UPLOAD_TEX1)        ? "tex1, " : "",
		  (flags & R128_UPLOAD_MASKS)       ? "masks, " : "",
		  (flags & R128_UPLOAD_WINDOW)      ? "window, " : "",
		  (flags & R128_UPLOAD_CLIPRECTS)   ? "cliprects, " : "",
		  (flags & R128_REQUIRE_QUIESCENCE) ? "quiescence, " : "" );
}

static void r128_cce_dispatch_clear( drm_device_t *dev,
Linus Torvalds's avatar
Linus Torvalds committed
363
				     drm_r128_clear_t *clear )
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366 367 368
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	int nbox = sarea_priv->nbox;
	drm_clip_rect_t *pbox = sarea_priv->boxes;
Linus Torvalds's avatar
Linus Torvalds committed
369
	unsigned int flags = clear->flags;
Linus Torvalds's avatar
Linus Torvalds committed
370 371
	int i;
	RING_LOCALS;
372
	DRM_DEBUG( "%s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
373

Linus Torvalds's avatar
Linus Torvalds committed
374 375
	if ( dev_priv->page_flipping && dev_priv->current_page == 1 ) {
		unsigned int tmp = flags;
Linus Torvalds's avatar
Linus Torvalds committed
376

Linus Torvalds's avatar
Linus Torvalds committed
377 378 379
		flags &= ~(R128_FRONT | R128_BACK);
		if ( tmp & R128_FRONT ) flags |= R128_BACK;
		if ( tmp & R128_BACK )  flags |= R128_FRONT;
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
	}

	for ( i = 0 ; i < nbox ; i++ ) {
		int x = pbox[i].x1;
		int y = pbox[i].y1;
		int w = pbox[i].x2 - x;
		int h = pbox[i].y2 - y;

		DRM_DEBUG( "dispatch clear %d,%d-%d,%d flags 0x%x\n",
			   pbox[i].x1, pbox[i].y1, pbox[i].x2,
			   pbox[i].y2, flags );

		if ( flags & (R128_FRONT | R128_BACK) ) {
			BEGIN_RING( 2 );

			OUT_RING( CCE_PACKET0( R128_DP_WRITE_MASK, 0 ) );
Linus Torvalds's avatar
Linus Torvalds committed
396
			OUT_RING( clear->color_mask );
Linus Torvalds's avatar
Linus Torvalds committed
397 398 399 400 401 402 403 404

			ADVANCE_RING();
		}

		if ( flags & R128_FRONT ) {
			BEGIN_RING( 6 );

			OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
Linus Torvalds's avatar
Linus Torvalds committed
405 406 407 408 409 410 411
			OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
				  R128_GMC_BRUSH_SOLID_COLOR |
				  (dev_priv->color_fmt << 8) |
				  R128_GMC_SRC_DATATYPE_COLOR |
				  R128_ROP3_P |
				  R128_GMC_CLR_CMP_CNTL_DIS |
				  R128_GMC_AUX_CLIP_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
412 413

			OUT_RING( dev_priv->front_pitch_offset_c );
Linus Torvalds's avatar
Linus Torvalds committed
414
			OUT_RING( clear->clear_color );
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418 419 420 421 422 423 424 425

			OUT_RING( (x << 16) | y );
			OUT_RING( (w << 16) | h );

			ADVANCE_RING();
		}

		if ( flags & R128_BACK ) {
			BEGIN_RING( 6 );

			OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429 430 431 432
			OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
				  R128_GMC_BRUSH_SOLID_COLOR |
				  (dev_priv->color_fmt << 8) |
				  R128_GMC_SRC_DATATYPE_COLOR |
				  R128_ROP3_P |
				  R128_GMC_CLR_CMP_CNTL_DIS |
				  R128_GMC_AUX_CLIP_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
433 434

			OUT_RING( dev_priv->back_pitch_offset_c );
Linus Torvalds's avatar
Linus Torvalds committed
435
			OUT_RING( clear->clear_color );
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442 443 444 445 446

			OUT_RING( (x << 16) | y );
			OUT_RING( (w << 16) | h );

			ADVANCE_RING();
		}

		if ( flags & R128_DEPTH ) {
			BEGIN_RING( 6 );

			OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449 450 451 452 453 454
			OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
				  R128_GMC_BRUSH_SOLID_COLOR |
				  (dev_priv->depth_fmt << 8) |
				  R128_GMC_SRC_DATATYPE_COLOR |
				  R128_ROP3_P |
				  R128_GMC_CLR_CMP_CNTL_DIS |
				  R128_GMC_AUX_CLIP_DIS |
				  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
455 456

			OUT_RING( dev_priv->depth_pitch_offset_c );
Linus Torvalds's avatar
Linus Torvalds committed
457
			OUT_RING( clear->clear_depth );
Linus Torvalds's avatar
Linus Torvalds committed
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474

			OUT_RING( (x << 16) | y );
			OUT_RING( (w << 16) | h );

			ADVANCE_RING();
		}
	}
}

static void r128_cce_dispatch_swap( drm_device_t *dev )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	int nbox = sarea_priv->nbox;
	drm_clip_rect_t *pbox = sarea_priv->boxes;
	int i;
	RING_LOCALS;
475
	DRM_DEBUG( "%s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491

#if R128_PERFORMANCE_BOXES
	/* Do some trivial performance monitoring...
	 */
	r128_cce_performance_boxes( dev_priv );
#endif

	for ( i = 0 ; i < nbox ; i++ ) {
		int x = pbox[i].x1;
		int y = pbox[i].y1;
		int w = pbox[i].x2 - x;
		int h = pbox[i].y2 - y;

		BEGIN_RING( 7 );

		OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
Linus Torvalds's avatar
Linus Torvalds committed
492 493 494 495 496 497 498 499 500 501
		OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL |
			  R128_GMC_DST_PITCH_OFFSET_CNTL |
			  R128_GMC_BRUSH_NONE |
			  (dev_priv->color_fmt << 8) |
			  R128_GMC_SRC_DATATYPE_COLOR |
			  R128_ROP3_S |
			  R128_DP_SRC_SOURCE_MEMORY |
			  R128_GMC_CLR_CMP_CNTL_DIS |
			  R128_GMC_AUX_CLIP_DIS |
			  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
502

503 504 505 506 507 508 509 510 511 512
		/* Make this work even if front & back are flipped:
		 */
		if (dev_priv->current_page == 0) {
			OUT_RING( dev_priv->back_pitch_offset_c );
			OUT_RING( dev_priv->front_pitch_offset_c );
		} 
		else {
			OUT_RING( dev_priv->front_pitch_offset_c );
			OUT_RING( dev_priv->back_pitch_offset_c );
		}
Linus Torvalds's avatar
Linus Torvalds committed
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534

		OUT_RING( (x << 16) | y );
		OUT_RING( (x << 16) | y );
		OUT_RING( (w << 16) | h );

		ADVANCE_RING();
	}

	/* Increment the frame counter.  The client-side 3D driver must
	 * throttle the framerate by waiting for this value before
	 * performing the swapbuffer ioctl.
	 */
	dev_priv->sarea_priv->last_frame++;

	BEGIN_RING( 2 );

	OUT_RING( CCE_PACKET0( R128_LAST_FRAME_REG, 0 ) );
	OUT_RING( dev_priv->sarea_priv->last_frame );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
535 536 537 538
static void r128_cce_dispatch_flip( drm_device_t *dev )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	RING_LOCALS;
539 540 541 542
	DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n", 
		__FUNCTION__,
		dev_priv->current_page,
		dev_priv->sarea_priv->pfCurrentPage);
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567

#if R128_PERFORMANCE_BOXES
	/* Do some trivial performance monitoring...
	 */
	r128_cce_performance_boxes( dev_priv );
#endif

	BEGIN_RING( 4 );

	R128_WAIT_UNTIL_PAGE_FLIPPED();
	OUT_RING( CCE_PACKET0( R128_CRTC_OFFSET, 0 ) );

	if ( dev_priv->current_page == 0 ) {
		OUT_RING( dev_priv->back_offset );
	} else {
		OUT_RING( dev_priv->front_offset );
	}

	ADVANCE_RING();

	/* Increment the frame counter.  The client-side 3D driver must
	 * throttle the framerate by waiting for this value before
	 * performing the swapbuffer ioctl.
	 */
	dev_priv->sarea_priv->last_frame++;
568 569
	dev_priv->sarea_priv->pfCurrentPage = dev_priv->current_page =
					      1 - dev_priv->current_page;
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572 573 574 575 576 577 578

	BEGIN_RING( 2 );

	OUT_RING( CCE_PACKET0( R128_LAST_FRAME_REG, 0 ) );
	OUT_RING( dev_priv->sarea_priv->last_frame );

	ADVANCE_RING();
}

Linus Torvalds's avatar
Linus Torvalds committed
579 580 581 582 583 584 585
static void r128_cce_dispatch_vertex( drm_device_t *dev,
				      drm_buf_t *buf )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_buf_priv_t *buf_priv = buf->dev_private;
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	int format = sarea_priv->vc_format;
Linus Torvalds's avatar
Linus Torvalds committed
586
	int offset = buf->bus_address;
Linus Torvalds's avatar
Linus Torvalds committed
587 588 589 590
	int size = buf->used;
	int prim = buf_priv->prim;
	int i = 0;
	RING_LOCALS;
Linus Torvalds's avatar
Linus Torvalds committed
591
	DRM_DEBUG( "buf=%d nbox=%d\n", buf->idx, sarea_priv->nbox );
Linus Torvalds's avatar
Linus Torvalds committed
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660

	if ( 0 )
		r128_print_dirty( "dispatch_vertex", sarea_priv->dirty );

	if ( buf->used ) {
		buf_priv->dispatched = 1;

		if ( sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS ) {
			r128_emit_state( dev_priv );
		}

		do {
			/* Emit the next set of up to three cliprects */
			if ( i < sarea_priv->nbox ) {
				r128_emit_clip_rects( dev_priv,
						      &sarea_priv->boxes[i],
						      sarea_priv->nbox - i );
			}

			/* Emit the vertex buffer rendering commands */
			BEGIN_RING( 5 );

			OUT_RING( CCE_PACKET3( R128_3D_RNDR_GEN_INDX_PRIM, 3 ) );
			OUT_RING( offset );
			OUT_RING( size );
			OUT_RING( format );
			OUT_RING( prim | R128_CCE_VC_CNTL_PRIM_WALK_LIST |
				  (size << R128_CCE_VC_CNTL_NUM_SHIFT) );

			ADVANCE_RING();

			i += 3;
		} while ( i < sarea_priv->nbox );
	}

	if ( buf_priv->discard ) {
		buf_priv->age = dev_priv->sarea_priv->last_dispatch;

		/* Emit the vertex buffer age */
		BEGIN_RING( 2 );

		OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
		OUT_RING( buf_priv->age );

		ADVANCE_RING();

		buf->pending = 1;
		buf->used = 0;
		/* FIXME: Check dispatched field */
		buf_priv->dispatched = 0;
	}

	dev_priv->sarea_priv->last_dispatch++;

	sarea_priv->dirty &= ~R128_UPLOAD_CLIPRECTS;
	sarea_priv->nbox = 0;
}

static void r128_cce_dispatch_indirect( drm_device_t *dev,
					drm_buf_t *buf,
					int start, int end )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_buf_priv_t *buf_priv = buf->dev_private;
	RING_LOCALS;
	DRM_DEBUG( "indirect: buf=%d s=0x%x e=0x%x\n",
		   buf->idx, start, end );

	if ( start != end ) {
Linus Torvalds's avatar
Linus Torvalds committed
661
		int offset = buf->bus_address + start;
Linus Torvalds's avatar
Linus Torvalds committed
662 663 664 665 666 667 668 669
		int dwords = (end - start + 3) / sizeof(u32);

		/* Indirect buffer data must be an even number of
		 * dwords, so if we've been given an odd number we must
		 * pad the data with a Type-2 CCE packet.
		 */
		if ( dwords & 1 ) {
			u32 *data = (u32 *)
670
				((char *)dev->agp_buffer_map->handle
Linus Torvalds's avatar
Linus Torvalds committed
671
				 + buf->offset + start);
Linus Torvalds's avatar
Linus Torvalds committed
672
			data[dwords++] = cpu_to_le32( R128_CCE_PACKET2 );
Linus Torvalds's avatar
Linus Torvalds committed
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
		}

		buf_priv->dispatched = 1;

		/* Fire off the indirect buffer */
		BEGIN_RING( 3 );

		OUT_RING( CCE_PACKET0( R128_PM4_IW_INDOFF, 1 ) );
		OUT_RING( offset );
		OUT_RING( dwords );

		ADVANCE_RING();
	}

	if ( buf_priv->discard ) {
		buf_priv->age = dev_priv->sarea_priv->last_dispatch;

		/* Emit the indirect buffer age */
		BEGIN_RING( 2 );

		OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
		OUT_RING( buf_priv->age );

		ADVANCE_RING();

		buf->pending = 1;
		buf->used = 0;
		/* FIXME: Check dispatched field */
		buf_priv->dispatched = 0;
	}

	dev_priv->sarea_priv->last_dispatch++;
}

static void r128_cce_dispatch_indices( drm_device_t *dev,
				       drm_buf_t *buf,
				       int start, int end,
				       int count )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_buf_priv_t *buf_priv = buf->dev_private;
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	int format = sarea_priv->vc_format;
716
	int offset = dev->agp_buffer_map->offset - dev_priv->cce_buffers_offset;
Linus Torvalds's avatar
Linus Torvalds committed
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
	int prim = buf_priv->prim;
	u32 *data;
	int dwords;
	int i = 0;
	RING_LOCALS;
	DRM_DEBUG( "indices: s=%d e=%d c=%d\n", start, end, count );

	if ( 0 )
		r128_print_dirty( "dispatch_indices", sarea_priv->dirty );

	if ( start != end ) {
		buf_priv->dispatched = 1;

		if ( sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS ) {
			r128_emit_state( dev_priv );
		}

		dwords = (end - start + 3) / sizeof(u32);

736
		data = (u32 *)((char *)dev->agp_buffer_map->handle
Linus Torvalds's avatar
Linus Torvalds committed
737 738
			       + buf->offset + start);

Linus Torvalds's avatar
Linus Torvalds committed
739 740
		data[0] = cpu_to_le32( CCE_PACKET3( R128_3D_RNDR_GEN_INDX_PRIM,
						    dwords-2 ) );
Linus Torvalds's avatar
Linus Torvalds committed
741

Linus Torvalds's avatar
Linus Torvalds committed
742 743 744 745 746
		data[1] = cpu_to_le32( offset );
		data[2] = cpu_to_le32( R128_MAX_VB_VERTS );
		data[3] = cpu_to_le32( format );
		data[4] = cpu_to_le32( (prim | R128_CCE_VC_CNTL_PRIM_WALK_IND |
					(count << 16)) );
Linus Torvalds's avatar
Linus Torvalds committed
747 748

		if ( count & 0x1 ) {
Linus Torvalds's avatar
Linus Torvalds committed
749
#ifdef __LITTLE_ENDIAN
Linus Torvalds's avatar
Linus Torvalds committed
750
			data[dwords-1] &= 0x0000ffff;
Linus Torvalds's avatar
Linus Torvalds committed
751 752 753
#else
			data[dwords-1] &= 0xffff0000;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
		}

		do {
			/* Emit the next set of up to three cliprects */
			if ( i < sarea_priv->nbox ) {
				r128_emit_clip_rects( dev_priv,
						      &sarea_priv->boxes[i],
						      sarea_priv->nbox - i );
			}

			r128_cce_dispatch_indirect( dev, buf, start, end );

			i += 3;
		} while ( i < sarea_priv->nbox );
	}

	if ( buf_priv->discard ) {
		buf_priv->age = dev_priv->sarea_priv->last_dispatch;

		/* Emit the vertex buffer age */
		BEGIN_RING( 2 );

		OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
		OUT_RING( buf_priv->age );

		ADVANCE_RING();

		buf->pending = 1;
		/* FIXME: Check dispatched field */
		buf_priv->dispatched = 0;
	}

	dev_priv->sarea_priv->last_dispatch++;

	sarea_priv->dirty &= ~R128_UPLOAD_CLIPRECTS;
	sarea_priv->nbox = 0;
}

792 793
static int r128_cce_dispatch_blit( DRMFILE filp,
				   drm_device_t *dev,
Linus Torvalds's avatar
Linus Torvalds committed
794 795 796 797 798 799 800 801 802
				   drm_r128_blit_t *blit )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_device_dma_t *dma = dev->dma;
	drm_buf_t *buf;
	drm_r128_buf_priv_t *buf_priv;
	u32 *data;
	int dword_shift, dwords;
	RING_LOCALS;
Linus Torvalds's avatar
Linus Torvalds committed
803
	DRM_DEBUG( "\n" );
Linus Torvalds's avatar
Linus Torvalds committed
804 805 806 807 808 809

	/* The compiler won't optimize away a division by a variable,
	 * even if the only legal values are powers of two.  Thus, we'll
	 * use a shift instead.
	 */
	switch ( blit->format ) {
Linus Torvalds's avatar
Linus Torvalds committed
810 811 812
	case R128_DATATYPE_ARGB8888:
		dword_shift = 0;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
813 814 815
	case R128_DATATYPE_ARGB1555:
	case R128_DATATYPE_RGB565:
	case R128_DATATYPE_ARGB4444:
816 817
	case R128_DATATYPE_YVYU422:
	case R128_DATATYPE_VYUY422:
Linus Torvalds's avatar
Linus Torvalds committed
818 819
		dword_shift = 1;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
820 821 822
	case R128_DATATYPE_CI8:
	case R128_DATATYPE_RGB8:
		dword_shift = 2;
Linus Torvalds's avatar
Linus Torvalds committed
823 824 825
		break;
	default:
		DRM_ERROR( "invalid blit format %d\n", blit->format );
Linus Torvalds's avatar
Linus Torvalds committed
826
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
	}

	/* Flush the pixel cache, and mark the contents as Read Invalid.
	 * This ensures no pixel data gets mixed up with the texture
	 * data from the host data blit, otherwise part of the texture
	 * image may be corrupted.
	 */
	BEGIN_RING( 2 );

	OUT_RING( CCE_PACKET0( R128_PC_GUI_CTLSTAT, 0 ) );
	OUT_RING( R128_PC_RI_GUI | R128_PC_FLUSH_GUI );

	ADVANCE_RING();

	/* Dispatch the indirect buffer.
	 */
	buf = dma->buflist[blit->idx];
	buf_priv = buf->dev_private;

846 847 848
	if ( buf->filp != filp ) {
		DRM_ERROR( "process %d using buffer owned by %p\n",
			   DRM_CURRENTPID, buf->filp );
Linus Torvalds's avatar
Linus Torvalds committed
849
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
850 851 852
	}
	if ( buf->pending ) {
		DRM_ERROR( "sending pending buffer %d\n", blit->idx );
Linus Torvalds's avatar
Linus Torvalds committed
853
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857 858 859
	}

	buf_priv->discard = 1;

	dwords = (blit->width * blit->height) >> dword_shift;

860
	data = (u32 *)((char *)dev->agp_buffer_map->handle + buf->offset);
Linus Torvalds's avatar
Linus Torvalds committed
861

Linus Torvalds's avatar
Linus Torvalds committed
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
	data[0] = cpu_to_le32( CCE_PACKET3( R128_CNTL_HOSTDATA_BLT, dwords + 6 ) );
	data[1] = cpu_to_le32( (R128_GMC_DST_PITCH_OFFSET_CNTL |
				R128_GMC_BRUSH_NONE |
				(blit->format << 8) |
				R128_GMC_SRC_DATATYPE_COLOR |
				R128_ROP3_S |
				R128_DP_SRC_SOURCE_HOST_DATA |
				R128_GMC_CLR_CMP_CNTL_DIS |
				R128_GMC_AUX_CLIP_DIS |
				R128_GMC_WR_MSK_DIS) );

	data[2] = cpu_to_le32( (blit->pitch << 21) | (blit->offset >> 5) );
	data[3] = cpu_to_le32( 0xffffffff );
	data[4] = cpu_to_le32( 0xffffffff );
	data[5] = cpu_to_le32( (blit->y << 16) | blit->x );
	data[6] = cpu_to_le32( (blit->height << 16) | blit->width );
	data[7] = cpu_to_le32( dwords );
Linus Torvalds's avatar
Linus Torvalds committed
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912

	buf->used = (dwords + 8) * sizeof(u32);

	r128_cce_dispatch_indirect( dev, buf, 0, buf->used );

	/* Flush the pixel cache after the blit completes.  This ensures
	 * the texture data is written out to memory before rendering
	 * continues.
	 */
	BEGIN_RING( 2 );

	OUT_RING( CCE_PACKET0( R128_PC_GUI_CTLSTAT, 0 ) );
	OUT_RING( R128_PC_FLUSH_GUI );

	ADVANCE_RING();

	return 0;
}


/* ================================================================
 * Tiled depth buffer management
 *
 * FIXME: These should all set the destination write mask for when we
 * have hardware stencil support.
 */

static int r128_cce_dispatch_write_span( drm_device_t *dev,
					 drm_r128_depth_t *depth )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	int count, x, y;
	u32 *buffer;
	u8 *mask;
913
	int i, buffer_size, mask_size;
Linus Torvalds's avatar
Linus Torvalds committed
914
	RING_LOCALS;
Linus Torvalds's avatar
Linus Torvalds committed
915
	DRM_DEBUG( "\n" );
Linus Torvalds's avatar
Linus Torvalds committed
916 917

	count = depth->n;
918
	if (count > 4096 || count <= 0)
919
		return DRM_ERR(EMSGSIZE);
920

Linus Torvalds's avatar
Linus Torvalds committed
921 922
	if ( DRM_COPY_FROM_USER( &x, depth->x, sizeof(x) ) ) {
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
923
	}
Linus Torvalds's avatar
Linus Torvalds committed
924 925
	if ( DRM_COPY_FROM_USER( &y, depth->y, sizeof(y) ) ) {
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
926 927
	}

928 929
	buffer_size = depth->n * sizeof(u32);
	buffer = DRM_MALLOC( buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
930
	if ( buffer == NULL )
Linus Torvalds's avatar
Linus Torvalds committed
931
		return DRM_ERR(ENOMEM);
932 933
	if ( DRM_COPY_FROM_USER( buffer, depth->buffer, buffer_size ) ) {
		DRM_FREE( buffer, buffer_size);
Linus Torvalds's avatar
Linus Torvalds committed
934
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
935 936
	}

937
	mask_size = depth->n * sizeof(u8);
Linus Torvalds's avatar
Linus Torvalds committed
938
	if ( depth->mask ) {
939
		mask = DRM_MALLOC( mask_size );
Linus Torvalds's avatar
Linus Torvalds committed
940
		if ( mask == NULL ) {
941
			DRM_FREE( buffer, buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
942
			return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
943
		}
944 945 946
		if ( DRM_COPY_FROM_USER( mask, depth->mask, mask_size ) ) {
			DRM_FREE( buffer, buffer_size );
			DRM_FREE( mask, mask_size );
Linus Torvalds's avatar
Linus Torvalds committed
947
			return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
948 949 950 951 952 953
		}

		for ( i = 0 ; i < count ; i++, x++ ) {
			if ( mask[i] ) {
				BEGIN_RING( 6 );

Linus Torvalds's avatar
Linus Torvalds committed
954 955 956 957 958 959 960 961
				OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
				OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
					  R128_GMC_BRUSH_SOLID_COLOR |
					  (dev_priv->depth_fmt << 8) |
					  R128_GMC_SRC_DATATYPE_COLOR |
					  R128_ROP3_P |
					  R128_GMC_CLR_CMP_CNTL_DIS |
					  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
962 963 964 965 966 967 968 969 970 971 972

				OUT_RING( dev_priv->depth_pitch_offset_c );
				OUT_RING( buffer[i] );

				OUT_RING( (x << 16) | y );
				OUT_RING( (1 << 16) | 1 );

				ADVANCE_RING();
			}
		}

973
		DRM_FREE( mask, mask_size );
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976 977 978
	} else {
		for ( i = 0 ; i < count ; i++, x++ ) {
			BEGIN_RING( 6 );

			OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
Linus Torvalds's avatar
Linus Torvalds committed
979 980 981 982 983 984 985
			OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
				  R128_GMC_BRUSH_SOLID_COLOR |
				  (dev_priv->depth_fmt << 8) |
				  R128_GMC_SRC_DATATYPE_COLOR |
				  R128_ROP3_P |
				  R128_GMC_CLR_CMP_CNTL_DIS |
				  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
986 987 988 989 990 991 992 993 994 995 996

			OUT_RING( dev_priv->depth_pitch_offset_c );
			OUT_RING( buffer[i] );

			OUT_RING( (x << 16) | y );
			OUT_RING( (1 << 16) | 1 );

			ADVANCE_RING();
		}
	}

997
	DRM_FREE( buffer, buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008

	return 0;
}

static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
					   drm_r128_depth_t *depth )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	int count, *x, *y;
	u32 *buffer;
	u8 *mask;
1009
	int i, xbuf_size, ybuf_size, buffer_size, mask_size;
Linus Torvalds's avatar
Linus Torvalds committed
1010
	RING_LOCALS;
Linus Torvalds's avatar
Linus Torvalds committed
1011
	DRM_DEBUG( "\n" );
Linus Torvalds's avatar
Linus Torvalds committed
1012 1013

	count = depth->n;
1014
	if (count > 4096 || count <= 0)
1015
		return DRM_ERR(EMSGSIZE);
Linus Torvalds's avatar
Linus Torvalds committed
1016

1017 1018 1019
	xbuf_size = count * sizeof(*x);
	ybuf_size = count * sizeof(*y);
	x = DRM_MALLOC( xbuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1020
	if ( x == NULL ) {
Linus Torvalds's avatar
Linus Torvalds committed
1021
		return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1022
	}
1023
	y = DRM_MALLOC( ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1024
	if ( y == NULL ) {
1025
		DRM_FREE( x, xbuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1026
		return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1027
	}
1028 1029 1030
	if ( DRM_COPY_FROM_USER( x, depth->x, xbuf_size ) ) {
		DRM_FREE( x, xbuf_size );
		DRM_FREE( y, ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1031
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1032
	}
1033 1034 1035
	if ( DRM_COPY_FROM_USER( y, depth->y, xbuf_size ) ) {
		DRM_FREE( x, xbuf_size );
		DRM_FREE( y, ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1036
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1037 1038
	}

1039 1040
	buffer_size = depth->n * sizeof(u32);
	buffer = DRM_MALLOC( buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
1041
	if ( buffer == NULL ) {
1042 1043
		DRM_FREE( x, xbuf_size );
		DRM_FREE( y, ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1044
		return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1045
	}
1046 1047 1048 1049
	if ( DRM_COPY_FROM_USER( buffer, depth->buffer, buffer_size ) ) {
		DRM_FREE( x, xbuf_size );
		DRM_FREE( y, ybuf_size );
		DRM_FREE( buffer, buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
1050
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1051 1052 1053
	}

	if ( depth->mask ) {
1054 1055
		mask_size = depth->n * sizeof(u8);
		mask = DRM_MALLOC( mask_size );
Linus Torvalds's avatar
Linus Torvalds committed
1056
		if ( mask == NULL ) {
1057 1058 1059
			DRM_FREE( x, xbuf_size );
			DRM_FREE( y, ybuf_size );
			DRM_FREE( buffer, buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
1060
			return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1061
		}
1062 1063 1064 1065 1066
		if ( DRM_COPY_FROM_USER( mask, depth->mask, mask_size ) ) {
			DRM_FREE( x, xbuf_size );
			DRM_FREE( y, ybuf_size );
			DRM_FREE( buffer, buffer_size );
			DRM_FREE( mask, mask_size );
Linus Torvalds's avatar
Linus Torvalds committed
1067
			return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1068 1069 1070 1071 1072 1073
		}

		for ( i = 0 ; i < count ; i++ ) {
			if ( mask[i] ) {
				BEGIN_RING( 6 );

Linus Torvalds's avatar
Linus Torvalds committed
1074 1075 1076 1077 1078 1079 1080 1081
				OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
				OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
					  R128_GMC_BRUSH_SOLID_COLOR |
					  (dev_priv->depth_fmt << 8) |
					  R128_GMC_SRC_DATATYPE_COLOR |
					  R128_ROP3_P |
					  R128_GMC_CLR_CMP_CNTL_DIS |
					  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092

				OUT_RING( dev_priv->depth_pitch_offset_c );
				OUT_RING( buffer[i] );

				OUT_RING( (x[i] << 16) | y[i] );
				OUT_RING( (1 << 16) | 1 );

				ADVANCE_RING();
			}
		}

1093
		DRM_FREE( mask, mask_size );
Linus Torvalds's avatar
Linus Torvalds committed
1094 1095 1096 1097 1098
	} else {
		for ( i = 0 ; i < count ; i++ ) {
			BEGIN_RING( 6 );

			OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
Linus Torvalds's avatar
Linus Torvalds committed
1099 1100 1101 1102 1103 1104 1105
			OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
				  R128_GMC_BRUSH_SOLID_COLOR |
				  (dev_priv->depth_fmt << 8) |
				  R128_GMC_SRC_DATATYPE_COLOR |
				  R128_ROP3_P |
				  R128_GMC_CLR_CMP_CNTL_DIS |
				  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116

			OUT_RING( dev_priv->depth_pitch_offset_c );
			OUT_RING( buffer[i] );

			OUT_RING( (x[i] << 16) | y[i] );
			OUT_RING( (1 << 16) | 1 );

			ADVANCE_RING();
		}
	}

1117 1118 1119
	DRM_FREE( x, xbuf_size );
	DRM_FREE( y, ybuf_size );
	DRM_FREE( buffer, buffer_size );
Linus Torvalds's avatar
Linus Torvalds committed
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129

	return 0;
}

static int r128_cce_dispatch_read_span( drm_device_t *dev,
					drm_r128_depth_t *depth )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	int count, x, y;
	RING_LOCALS;
Linus Torvalds's avatar
Linus Torvalds committed
1130
	DRM_DEBUG( "\n" );
Linus Torvalds's avatar
Linus Torvalds committed
1131 1132

	count = depth->n;
1133
	if (count > 4096 || count <= 0)
1134
		return DRM_ERR(EMSGSIZE);
1135

Linus Torvalds's avatar
Linus Torvalds committed
1136 1137
	if ( DRM_COPY_FROM_USER( &x, depth->x, sizeof(x) ) ) {
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1138
	}
Linus Torvalds's avatar
Linus Torvalds committed
1139 1140
	if ( DRM_COPY_FROM_USER( &y, depth->y, sizeof(y) ) ) {
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1141 1142 1143 1144 1145
	}

	BEGIN_RING( 7 );

	OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
Linus Torvalds's avatar
Linus Torvalds committed
1146 1147 1148 1149 1150 1151 1152 1153 1154
	OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL |
		  R128_GMC_DST_PITCH_OFFSET_CNTL |
		  R128_GMC_BRUSH_NONE |
		  (dev_priv->depth_fmt << 8) |
		  R128_GMC_SRC_DATATYPE_COLOR |
		  R128_ROP3_S |
		  R128_DP_SRC_SOURCE_MEMORY |
		  R128_GMC_CLR_CMP_CNTL_DIS |
		  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172

	OUT_RING( dev_priv->depth_pitch_offset_c );
	OUT_RING( dev_priv->span_pitch_offset_c );

	OUT_RING( (x << 16) | y );
	OUT_RING( (0 << 16) | 0 );
	OUT_RING( (count << 16) | 1 );

	ADVANCE_RING();

	return 0;
}

static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
					  drm_r128_depth_t *depth )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	int count, *x, *y;
1173
	int i, xbuf_size, ybuf_size;
Linus Torvalds's avatar
Linus Torvalds committed
1174
	RING_LOCALS;
1175
	DRM_DEBUG( "%s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
1176 1177

	count = depth->n;
1178
	if (count > 4096 || count <= 0)
1179
		return DRM_ERR(EMSGSIZE);
1180

Linus Torvalds's avatar
Linus Torvalds committed
1181 1182 1183 1184
	if ( count > dev_priv->depth_pitch ) {
		count = dev_priv->depth_pitch;
	}

1185 1186 1187
	xbuf_size = count * sizeof(*x);
	ybuf_size = count * sizeof(*y);
	x = DRM_MALLOC( xbuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1188
	if ( x == NULL ) {
Linus Torvalds's avatar
Linus Torvalds committed
1189
		return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1190
	}
1191
	y = DRM_MALLOC( ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1192
	if ( y == NULL ) {
1193
		DRM_FREE( x, xbuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1194
		return DRM_ERR(ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1195
	}
1196 1197 1198
	if ( DRM_COPY_FROM_USER( x, depth->x, xbuf_size ) ) {
		DRM_FREE( x, xbuf_size );
		DRM_FREE( y, ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1199
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1200
	}
1201 1202 1203
	if ( DRM_COPY_FROM_USER( y, depth->y, ybuf_size ) ) {
		DRM_FREE( x, xbuf_size );
		DRM_FREE( y, ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1204
		return DRM_ERR(EFAULT);
Linus Torvalds's avatar
Linus Torvalds committed
1205 1206 1207 1208 1209 1210
	}

	for ( i = 0 ; i < count ; i++ ) {
		BEGIN_RING( 7 );

		OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
Linus Torvalds's avatar
Linus Torvalds committed
1211 1212 1213 1214 1215 1216 1217 1218 1219
		OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL |
			  R128_GMC_DST_PITCH_OFFSET_CNTL |
			  R128_GMC_BRUSH_NONE |
			  (dev_priv->depth_fmt << 8) |
			  R128_GMC_SRC_DATATYPE_COLOR |
			  R128_ROP3_S |
			  R128_DP_SRC_SOURCE_MEMORY |
			  R128_GMC_CLR_CMP_CNTL_DIS |
			  R128_GMC_WR_MSK_DIS );
Linus Torvalds's avatar
Linus Torvalds committed
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230

		OUT_RING( dev_priv->depth_pitch_offset_c );
		OUT_RING( dev_priv->span_pitch_offset_c );

		OUT_RING( (x[i] << 16) | y[i] );
		OUT_RING( (i << 16) | 0 );
		OUT_RING( (1 << 16) | 1 );

		ADVANCE_RING();
	}

1231 1232
	DRM_FREE( x, xbuf_size );
	DRM_FREE( y, ybuf_size );
Linus Torvalds's avatar
Linus Torvalds committed
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246

	return 0;
}


/* ================================================================
 * Polygon stipple
 */

static void r128_cce_dispatch_stipple( drm_device_t *dev, u32 *stipple )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	int i;
	RING_LOCALS;
1247
	DRM_DEBUG( "%s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
1248 1249 1250

	BEGIN_RING( 33 );

Linus Torvalds's avatar
Linus Torvalds committed
1251
	OUT_RING( CCE_PACKET0( R128_BRUSH_DATA0, 31 ) );
Linus Torvalds's avatar
Linus Torvalds committed
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
	for ( i = 0 ; i < 32 ; i++ ) {
		OUT_RING( stipple[i] );
	}

	ADVANCE_RING();
}


/* ================================================================
 * IOCTL functions
 */

Linus Torvalds's avatar
Linus Torvalds committed
1264
int r128_cce_clear( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1265
{
Linus Torvalds's avatar
Linus Torvalds committed
1266
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1267 1268 1269
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
	drm_r128_clear_t clear;
Linus Torvalds's avatar
Linus Torvalds committed
1270
	DRM_DEBUG( "\n" );
Linus Torvalds's avatar
Linus Torvalds committed
1271

1272
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1273

1274
	DRM_COPY_FROM_USER_IOCTL( clear, (drm_r128_clear_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1275
			     sizeof(clear) );
Linus Torvalds's avatar
Linus Torvalds committed
1276

Linus Torvalds's avatar
Linus Torvalds committed
1277 1278
	RING_SPACE_TEST_WITH_RETURN( dev_priv );

Linus Torvalds's avatar
Linus Torvalds committed
1279 1280 1281
	if ( sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS )
		sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;

Linus Torvalds's avatar
Linus Torvalds committed
1282
	r128_cce_dispatch_clear( dev, &clear );
1283
	COMMIT_RING();
Linus Torvalds's avatar
Linus Torvalds committed
1284 1285 1286 1287 1288 1289 1290 1291

	/* Make sure we restore the 3D state next time.
	 */
	dev_priv->sarea_priv->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_MASKS;

	return 0;
}

1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
static int r128_do_init_pageflip( drm_device_t *dev )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	DRM_DEBUG( "\n" );

	dev_priv->crtc_offset =      R128_READ( R128_CRTC_OFFSET );
	dev_priv->crtc_offset_cntl = R128_READ( R128_CRTC_OFFSET_CNTL );

	R128_WRITE( R128_CRTC_OFFSET, dev_priv->front_offset );
	R128_WRITE( R128_CRTC_OFFSET_CNTL,
		    dev_priv->crtc_offset_cntl | R128_CRTC_OFFSET_FLIP_CNTL );

	dev_priv->page_flipping = 1;
	dev_priv->current_page = 0;
	dev_priv->sarea_priv->pfCurrentPage = dev_priv->current_page;

	return 0;
}

int r128_do_cleanup_pageflip( drm_device_t *dev )
{
	drm_r128_private_t *dev_priv = dev->dev_private;
	DRM_DEBUG( "\n" );

	R128_WRITE( R128_CRTC_OFFSET,      dev_priv->crtc_offset );
	R128_WRITE( R128_CRTC_OFFSET_CNTL, dev_priv->crtc_offset_cntl );

1319
	if (dev_priv->current_page != 0) {
1320
		r128_cce_dispatch_flip( dev );
1321 1322
		COMMIT_RING();
	}
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346

	dev_priv->page_flipping = 0;
	return 0;
}

/* Swapping and flipping are different operations, need different ioctls.
 * They can & should be intermixed to support multiple 3d windows.  
 */

int r128_cce_flip( DRM_IOCTL_ARGS )
{
	DRM_DEVICE;
	drm_r128_private_t *dev_priv = dev->dev_private;
	DRM_DEBUG( "%s\n", __FUNCTION__ );

	LOCK_TEST_WITH_RETURN( dev, filp );

	RING_SPACE_TEST_WITH_RETURN( dev_priv );

	if (!dev_priv->page_flipping) 
		r128_do_init_pageflip( dev );

	r128_cce_dispatch_flip( dev );

1347
	COMMIT_RING();
1348 1349 1350
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1351
int r128_cce_swap( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1352
{
Linus Torvalds's avatar
Linus Torvalds committed
1353
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1354 1355
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
1356
	DRM_DEBUG( "%s\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
1357

1358
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1359 1360

	RING_SPACE_TEST_WITH_RETURN( dev_priv );
Linus Torvalds's avatar
Linus Torvalds committed
1361 1362 1363 1364

	if ( sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS )
		sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;

1365 1366 1367
	r128_cce_dispatch_swap( dev );
	dev_priv->sarea_priv->dirty |= (R128_UPLOAD_CONTEXT |
					R128_UPLOAD_MASKS);
Linus Torvalds's avatar
Linus Torvalds committed
1368

1369
	COMMIT_RING();
Linus Torvalds's avatar
Linus Torvalds committed
1370 1371 1372
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1373
int r128_cce_vertex( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1374
{
Linus Torvalds's avatar
Linus Torvalds committed
1375
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1376 1377 1378 1379 1380 1381
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_device_dma_t *dma = dev->dma;
	drm_buf_t *buf;
	drm_r128_buf_priv_t *buf_priv;
	drm_r128_vertex_t vertex;

1382
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1383 1384

	if ( !dev_priv ) {
1385
		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
1386
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1387 1388
	}

1389
	DRM_COPY_FROM_USER_IOCTL( vertex, (drm_r128_vertex_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1390
			     sizeof(vertex) );
Linus Torvalds's avatar
Linus Torvalds committed
1391

Linus Torvalds's avatar
Linus Torvalds committed
1392 1393
	DRM_DEBUG( "pid=%d index=%d count=%d discard=%d\n",
		   DRM_CURRENTPID,
Linus Torvalds's avatar
Linus Torvalds committed
1394 1395 1396 1397 1398
		   vertex.idx, vertex.count, vertex.discard );

	if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
		DRM_ERROR( "buffer index %d (of %d max)\n",
			   vertex.idx, dma->buf_count - 1 );
Linus Torvalds's avatar
Linus Torvalds committed
1399
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1400 1401 1402 1403
	}
	if ( vertex.prim < 0 ||
	     vertex.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
		DRM_ERROR( "buffer prim %d\n", vertex.prim );
Linus Torvalds's avatar
Linus Torvalds committed
1404
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1405 1406
	}

Linus Torvalds's avatar
Linus Torvalds committed
1407 1408 1409
	RING_SPACE_TEST_WITH_RETURN( dev_priv );
	VB_AGE_TEST_WITH_RETURN( dev_priv );

Linus Torvalds's avatar
Linus Torvalds committed
1410 1411 1412
	buf = dma->buflist[vertex.idx];
	buf_priv = buf->dev_private;

1413 1414 1415
	if ( buf->filp != filp ) {
		DRM_ERROR( "process %d using buffer owned by %p\n",
			   DRM_CURRENTPID, buf->filp );
Linus Torvalds's avatar
Linus Torvalds committed
1416
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1417 1418 1419
	}
	if ( buf->pending ) {
		DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
Linus Torvalds's avatar
Linus Torvalds committed
1420
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1421 1422 1423 1424 1425 1426 1427 1428
	}

	buf->used = vertex.count;
	buf_priv->prim = vertex.prim;
	buf_priv->discard = vertex.discard;

	r128_cce_dispatch_vertex( dev, buf );

1429
	COMMIT_RING();
Linus Torvalds's avatar
Linus Torvalds committed
1430 1431 1432
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1433
int r128_cce_indices( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1434
{
Linus Torvalds's avatar
Linus Torvalds committed
1435
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1436 1437 1438 1439 1440 1441 1442
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_device_dma_t *dma = dev->dma;
	drm_buf_t *buf;
	drm_r128_buf_priv_t *buf_priv;
	drm_r128_indices_t elts;
	int count;

1443
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1444 1445

	if ( !dev_priv ) {
1446
		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
1447
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1448 1449
	}

1450
	DRM_COPY_FROM_USER_IOCTL( elts, (drm_r128_indices_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1451
			     sizeof(elts) );
Linus Torvalds's avatar
Linus Torvalds committed
1452

Linus Torvalds's avatar
Linus Torvalds committed
1453
	DRM_DEBUG( "pid=%d buf=%d s=%d e=%d d=%d\n", DRM_CURRENTPID,
Linus Torvalds's avatar
Linus Torvalds committed
1454 1455 1456 1457 1458
		   elts.idx, elts.start, elts.end, elts.discard );

	if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
		DRM_ERROR( "buffer index %d (of %d max)\n",
			   elts.idx, dma->buf_count - 1 );
Linus Torvalds's avatar
Linus Torvalds committed
1459
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1460 1461 1462 1463
	}
	if ( elts.prim < 0 ||
	     elts.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
		DRM_ERROR( "buffer prim %d\n", elts.prim );
Linus Torvalds's avatar
Linus Torvalds committed
1464
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1465 1466
	}

Linus Torvalds's avatar
Linus Torvalds committed
1467 1468 1469
	RING_SPACE_TEST_WITH_RETURN( dev_priv );
	VB_AGE_TEST_WITH_RETURN( dev_priv );

Linus Torvalds's avatar
Linus Torvalds committed
1470 1471 1472
	buf = dma->buflist[elts.idx];
	buf_priv = buf->dev_private;

1473 1474 1475
	if ( buf->filp != filp ) {
		DRM_ERROR( "process %d using buffer owned by %p\n",
			   DRM_CURRENTPID, buf->filp );
Linus Torvalds's avatar
Linus Torvalds committed
1476
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1477 1478 1479
	}
	if ( buf->pending ) {
		DRM_ERROR( "sending pending buffer %d\n", elts.idx );
Linus Torvalds's avatar
Linus Torvalds committed
1480
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1481 1482 1483 1484 1485 1486 1487
	}

	count = (elts.end - elts.start) / sizeof(u16);
	elts.start -= R128_INDEX_PRIM_OFFSET;

	if ( elts.start & 0x7 ) {
		DRM_ERROR( "misaligned buffer 0x%x\n", elts.start );
Linus Torvalds's avatar
Linus Torvalds committed
1488
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1489 1490 1491
	}
	if ( elts.start < buf->used ) {
		DRM_ERROR( "no header 0x%x - 0x%x\n", elts.start, buf->used );
Linus Torvalds's avatar
Linus Torvalds committed
1492
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1493 1494 1495 1496 1497 1498 1499 1500
	}

	buf->used = elts.end;
	buf_priv->prim = elts.prim;
	buf_priv->discard = elts.discard;

	r128_cce_dispatch_indices( dev, buf, elts.start, elts.end, count );

1501
	COMMIT_RING();
Linus Torvalds's avatar
Linus Torvalds committed
1502 1503 1504
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1505
int r128_cce_blit( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1506
{
Linus Torvalds's avatar
Linus Torvalds committed
1507
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1508
	drm_device_dma_t *dma = dev->dma;
Linus Torvalds's avatar
Linus Torvalds committed
1509
	drm_r128_private_t *dev_priv = dev->dev_private;
Linus Torvalds's avatar
Linus Torvalds committed
1510
	drm_r128_blit_t blit;
1511
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1512

1513
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1514

1515
	DRM_COPY_FROM_USER_IOCTL( blit, (drm_r128_blit_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1516
			     sizeof(blit) );
Linus Torvalds's avatar
Linus Torvalds committed
1517

Linus Torvalds's avatar
Linus Torvalds committed
1518
	DRM_DEBUG( "pid=%d index=%d\n", DRM_CURRENTPID, blit.idx );
Linus Torvalds's avatar
Linus Torvalds committed
1519 1520 1521 1522

	if ( blit.idx < 0 || blit.idx >= dma->buf_count ) {
		DRM_ERROR( "buffer index %d (of %d max)\n",
			   blit.idx, dma->buf_count - 1 );
Linus Torvalds's avatar
Linus Torvalds committed
1523
		return DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1524 1525
	}

Linus Torvalds's avatar
Linus Torvalds committed
1526 1527 1528
	RING_SPACE_TEST_WITH_RETURN( dev_priv );
	VB_AGE_TEST_WITH_RETURN( dev_priv );

1529 1530 1531 1532
	ret = r128_cce_dispatch_blit( filp, dev, &blit );

	COMMIT_RING();
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1533 1534
}

Linus Torvalds's avatar
Linus Torvalds committed
1535
int r128_cce_depth( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1536
{
Linus Torvalds's avatar
Linus Torvalds committed
1537
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1538
	drm_r128_private_t *dev_priv = dev->dev_private;
Linus Torvalds's avatar
Linus Torvalds committed
1539
	drm_r128_depth_t depth;
1540
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1541

1542
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1543

1544
	DRM_COPY_FROM_USER_IOCTL( depth, (drm_r128_depth_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1545
			     sizeof(depth) );
Linus Torvalds's avatar
Linus Torvalds committed
1546

Linus Torvalds's avatar
Linus Torvalds committed
1547 1548
	RING_SPACE_TEST_WITH_RETURN( dev_priv );

1549
	ret = DRM_ERR(EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
1550 1551
	switch ( depth.func ) {
	case R128_WRITE_SPAN:
1552
		ret = r128_cce_dispatch_write_span( dev, &depth );
Linus Torvalds's avatar
Linus Torvalds committed
1553
	case R128_WRITE_PIXELS:
1554
		ret = r128_cce_dispatch_write_pixels( dev, &depth );
Linus Torvalds's avatar
Linus Torvalds committed
1555
	case R128_READ_SPAN:
1556
		ret = r128_cce_dispatch_read_span( dev, &depth );
Linus Torvalds's avatar
Linus Torvalds committed
1557
	case R128_READ_PIXELS:
1558
		ret = r128_cce_dispatch_read_pixels( dev, &depth );
Linus Torvalds's avatar
Linus Torvalds committed
1559 1560
	}

1561 1562
	COMMIT_RING();
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1563 1564
}

Linus Torvalds's avatar
Linus Torvalds committed
1565
int r128_cce_stipple( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1566
{
Linus Torvalds's avatar
Linus Torvalds committed
1567
	DRM_DEVICE;
Linus Torvalds's avatar
Linus Torvalds committed
1568
	drm_r128_private_t *dev_priv = dev->dev_private;
Linus Torvalds's avatar
Linus Torvalds committed
1569 1570 1571
	drm_r128_stipple_t stipple;
	u32 mask[32];

1572
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1573

1574
	DRM_COPY_FROM_USER_IOCTL( stipple, (drm_r128_stipple_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1575
			     sizeof(stipple) );
Linus Torvalds's avatar
Linus Torvalds committed
1576

Linus Torvalds's avatar
Linus Torvalds committed
1577
	if ( DRM_COPY_FROM_USER( &mask, stipple.mask,
Linus Torvalds's avatar
Linus Torvalds committed
1578
			     32 * sizeof(u32) ) )
Linus Torvalds's avatar
Linus Torvalds committed
1579
		return DRM_ERR( EFAULT );
Linus Torvalds's avatar
Linus Torvalds committed
1580

Linus Torvalds's avatar
Linus Torvalds committed
1581 1582
	RING_SPACE_TEST_WITH_RETURN( dev_priv );

Linus Torvalds's avatar
Linus Torvalds committed
1583 1584
	r128_cce_dispatch_stipple( dev, mask );

1585
	COMMIT_RING();
Linus Torvalds's avatar
Linus Torvalds committed
1586 1587
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
1588

Linus Torvalds's avatar
Linus Torvalds committed
1589
int r128_cce_indirect( DRM_IOCTL_ARGS )
Linus Torvalds's avatar
Linus Torvalds committed
1590
{
Linus Torvalds's avatar
Linus Torvalds committed
1591
	DRM_DEVICE;
1592 1593 1594 1595 1596 1597 1598 1599
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_device_dma_t *dma = dev->dma;
	drm_buf_t *buf;
	drm_r128_buf_priv_t *buf_priv;
	drm_r128_indirect_t indirect;
#if 0
	RING_LOCALS;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1600

1601
	LOCK_TEST_WITH_RETURN( dev, filp );
Linus Torvalds's avatar
Linus Torvalds committed
1602

1603
	if ( !dev_priv ) {
1604
		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
Linus Torvalds's avatar
Linus Torvalds committed
1605
		return DRM_ERR(EINVAL);
1606 1607
	}

1608
	DRM_COPY_FROM_USER_IOCTL( indirect, (drm_r128_indirect_t __user *) data,
Linus Torvalds's avatar
Linus Torvalds committed
1609
			     sizeof(indirect) );
1610 1611 1612 1613 1614 1615 1616 1617

	DRM_DEBUG( "indirect: idx=%d s=%d e=%d d=%d\n",
		   indirect.idx, indirect.start,
		   indirect.end, indirect.discard );

	if ( indirect.idx < 0 || indirect.idx >= dma->buf_count ) {
		DRM_ERROR( "buffer index %d (of %d max)\n",
			   indirect.idx, dma->buf_count - 1 );
Linus Torvalds's avatar
Linus Torvalds committed
1618
		return DRM_ERR(EINVAL);
1619 1620 1621 1622 1623
	}

	buf = dma->buflist[indirect.idx];
	buf_priv = buf->dev_private;

1624 1625 1626
	if ( buf->filp != filp ) {
		DRM_ERROR( "process %d using buffer owned by %p\n",
			   DRM_CURRENTPID, buf->filp );
Linus Torvalds's avatar
Linus Torvalds committed
1627
		return DRM_ERR(EINVAL);
1628 1629 1630
	}
	if ( buf->pending ) {
		DRM_ERROR( "sending pending buffer %d\n", indirect.idx );
Linus Torvalds's avatar
Linus Torvalds committed
1631
		return DRM_ERR(EINVAL);
1632 1633 1634 1635 1636
	}

	if ( indirect.start < buf->used ) {
		DRM_ERROR( "reusing indirect: start=0x%x actual=0x%x\n",
			   indirect.start, buf->used );
Linus Torvalds's avatar
Linus Torvalds committed
1637
		return DRM_ERR(EINVAL);
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
	}

	RING_SPACE_TEST_WITH_RETURN( dev_priv );
	VB_AGE_TEST_WITH_RETURN( dev_priv );

	buf->used = indirect.end;
	buf_priv->discard = indirect.discard;

#if 0
	/* Wait for the 3D stream to idle before the indirect buffer
	 * containing 2D acceleration commands is processed.
Linus Torvalds's avatar
Linus Torvalds committed
1649
	 */
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
	BEGIN_RING( 2 );
	RADEON_WAIT_UNTIL_3D_IDLE();
	ADVANCE_RING();
#endif

	/* Dispatch the indirect buffer full of commands from the
	 * X server.  This is insecure and is thus only available to
	 * privileged clients.
	 */
	r128_cce_dispatch_indirect( dev, buf, indirect.start, indirect.end );

1661
	COMMIT_RING();
1662
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1663
}
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676

int r128_getparam( DRM_IOCTL_ARGS )
{
	DRM_DEVICE;
	drm_r128_private_t *dev_priv = dev->dev_private;
	drm_r128_getparam_t param;
	int value;

	if ( !dev_priv ) {
		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
		return DRM_ERR(EINVAL);
	}

1677
	DRM_COPY_FROM_USER_IOCTL( param, (drm_r128_getparam_t __user *)data,
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696
			     sizeof(param) );

	DRM_DEBUG( "pid=%d\n", DRM_CURRENTPID );

	switch( param.param ) {
	case R128_PARAM_IRQ_NR:
		value = dev->irq;
		break;
	default:
		return DRM_ERR(EINVAL);
	}

	if ( DRM_COPY_TO_USER( param.value, &value, sizeof(int) ) ) {
		DRM_ERROR( "copy_to_user\n" );
		return DRM_ERR(EFAULT);
	}
	
	return 0;
}
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714

static void r128_driver_prerelease(drm_device_t *dev, DRMFILE filp)
{
	if ( dev->dev_private ) {
		drm_r128_private_t *dev_priv = dev->dev_private;
		if ( dev_priv->page_flipping ) {
			r128_do_cleanup_pageflip( dev );
		}
	}			
}

static void r128_driver_pretakedown(drm_device_t *dev)
{
	r128_do_cleanup_cce( dev );
}

void r128_driver_register_fns(drm_device_t *dev)
{
1715
	dev->dev_priv_size = sizeof(drm_r128_buf_priv_t);
1716 1717 1718
	dev->fn_tbl.prerelease = r128_driver_prerelease;
	dev->fn_tbl.pretakedown = r128_driver_pretakedown;
}