1 /* radeon_state.c -- State support for Radeon -*- linux-c -*- */
3 * Copyright 2000 VA Linux Systems, Inc., Fremont, California.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
26 * Gareth Hughes <gareth@valinux.com>
27 * Kevin E. Martin <martin@valinux.com>
32 #include "drm_sarea.h"
33 #include "radeon_drm.h"
34 #include "radeon_drv.h"
36 /* ================================================================
37 * Helper functions for client state checking and fixup
40 static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
42 struct drm_file *file_priv,
46 u32 fb_end = dev_priv->fb_location + dev_priv->fb_size - 1;
47 struct drm_radeon_driver_file_fields *radeon_priv;
49 /* Hrm ... the story of the offset ... So this function converts
50 * the various ideas of what userland clients might have for an
51 * offset in the card address space into an offset into the card
52 * address space :) So with a sane client, it should just keep
53 * the value intact and just do some boundary checking. However,
54 * not all clients are sane. Some older clients pass us 0 based
55 * offsets relative to the start of the framebuffer and some may
56 * assume the AGP aperture it appended to the framebuffer, so we
57 * try to detect those cases and fix them up.
59 * Note: It might be a good idea here to make sure the offset lands
60 * in some "allowed" area to protect things like the PCIE GART...
63 /* First, the best case, the offset already lands in either the
64 * framebuffer or the GART mapped space
66 if (radeon_check_offset(dev_priv, off))
69 /* Ok, that didn't happen... now check if we have a zero based
70 * offset that fits in the framebuffer + gart space, apply the
71 * magic offset we get from SETPARAM or calculated from fb_location
73 if (off < (dev_priv->fb_size + dev_priv->gart_size)) {
74 radeon_priv = file_priv->driver_priv;
75 off += radeon_priv->radeon_fb_delta;
78 /* Finally, assume we aimed at a GART offset if beyond the fb */
80 off = off - fb_end - 1 + dev_priv->gart_vm_start;
82 /* Now recheck and fail if out of bounds */
83 if (radeon_check_offset(dev_priv, off)) {
84 DRM_DEBUG("offset fixed up to 0x%x\n", (unsigned int)off);
91 static __inline__ int radeon_check_and_fixup_packets(drm_radeon_private_t *
93 struct drm_file *file_priv,
98 case RADEON_EMIT_PP_MISC:
99 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
100 &data[(RADEON_RB3D_DEPTHOFFSET - RADEON_PP_MISC) / 4])) {
101 DRM_ERROR("Invalid depth buffer offset\n");
106 case RADEON_EMIT_PP_CNTL:
107 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
108 &data[(RADEON_RB3D_COLOROFFSET - RADEON_PP_CNTL) / 4])) {
109 DRM_ERROR("Invalid colour buffer offset\n");
114 case R200_EMIT_PP_TXOFFSET_0:
115 case R200_EMIT_PP_TXOFFSET_1:
116 case R200_EMIT_PP_TXOFFSET_2:
117 case R200_EMIT_PP_TXOFFSET_3:
118 case R200_EMIT_PP_TXOFFSET_4:
119 case R200_EMIT_PP_TXOFFSET_5:
120 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
122 DRM_ERROR("Invalid R200 texture offset\n");
127 case RADEON_EMIT_PP_TXFILTER_0:
128 case RADEON_EMIT_PP_TXFILTER_1:
129 case RADEON_EMIT_PP_TXFILTER_2:
130 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
131 &data[(RADEON_PP_TXOFFSET_0 - RADEON_PP_TXFILTER_0) / 4])) {
132 DRM_ERROR("Invalid R100 texture offset\n");
137 case R200_EMIT_PP_CUBIC_OFFSETS_0:
138 case R200_EMIT_PP_CUBIC_OFFSETS_1:
139 case R200_EMIT_PP_CUBIC_OFFSETS_2:
140 case R200_EMIT_PP_CUBIC_OFFSETS_3:
141 case R200_EMIT_PP_CUBIC_OFFSETS_4:
142 case R200_EMIT_PP_CUBIC_OFFSETS_5:{
144 for (i = 0; i < 5; i++) {
145 if (radeon_check_and_fixup_offset(dev_priv,
149 ("Invalid R200 cubic texture offset\n");
156 case RADEON_EMIT_PP_CUBIC_OFFSETS_T0:
157 case RADEON_EMIT_PP_CUBIC_OFFSETS_T1:
158 case RADEON_EMIT_PP_CUBIC_OFFSETS_T2:{
160 for (i = 0; i < 5; i++) {
161 if (radeon_check_and_fixup_offset(dev_priv,
165 ("Invalid R100 cubic texture offset\n");
172 case R200_EMIT_VAP_CTL: {
175 OUT_RING_REG(RADEON_SE_TCL_STATE_FLUSH, 0);
180 case RADEON_EMIT_RB3D_COLORPITCH:
181 case RADEON_EMIT_RE_LINE_PATTERN:
182 case RADEON_EMIT_SE_LINE_WIDTH:
183 case RADEON_EMIT_PP_LUM_MATRIX:
184 case RADEON_EMIT_PP_ROT_MATRIX_0:
185 case RADEON_EMIT_RB3D_STENCILREFMASK:
186 case RADEON_EMIT_SE_VPORT_XSCALE:
187 case RADEON_EMIT_SE_CNTL:
188 case RADEON_EMIT_SE_CNTL_STATUS:
189 case RADEON_EMIT_RE_MISC:
190 case RADEON_EMIT_PP_BORDER_COLOR_0:
191 case RADEON_EMIT_PP_BORDER_COLOR_1:
192 case RADEON_EMIT_PP_BORDER_COLOR_2:
193 case RADEON_EMIT_SE_ZBIAS_FACTOR:
194 case RADEON_EMIT_SE_TCL_OUTPUT_VTX_FMT:
195 case RADEON_EMIT_SE_TCL_MATERIAL_EMMISSIVE_RED:
196 case R200_EMIT_PP_TXCBLEND_0:
197 case R200_EMIT_PP_TXCBLEND_1:
198 case R200_EMIT_PP_TXCBLEND_2:
199 case R200_EMIT_PP_TXCBLEND_3:
200 case R200_EMIT_PP_TXCBLEND_4:
201 case R200_EMIT_PP_TXCBLEND_5:
202 case R200_EMIT_PP_TXCBLEND_6:
203 case R200_EMIT_PP_TXCBLEND_7:
204 case R200_EMIT_TCL_LIGHT_MODEL_CTL_0:
205 case R200_EMIT_TFACTOR_0:
206 case R200_EMIT_VTX_FMT_0:
207 case R200_EMIT_MATRIX_SELECT_0:
208 case R200_EMIT_TEX_PROC_CTL_2:
209 case R200_EMIT_TCL_UCP_VERT_BLEND_CTL:
210 case R200_EMIT_PP_TXFILTER_0:
211 case R200_EMIT_PP_TXFILTER_1:
212 case R200_EMIT_PP_TXFILTER_2:
213 case R200_EMIT_PP_TXFILTER_3:
214 case R200_EMIT_PP_TXFILTER_4:
215 case R200_EMIT_PP_TXFILTER_5:
216 case R200_EMIT_VTE_CNTL:
217 case R200_EMIT_OUTPUT_VTX_COMP_SEL:
218 case R200_EMIT_PP_TAM_DEBUG3:
219 case R200_EMIT_PP_CNTL_X:
220 case R200_EMIT_RB3D_DEPTHXY_OFFSET:
221 case R200_EMIT_RE_AUX_SCISSOR_CNTL:
222 case R200_EMIT_RE_SCISSOR_TL_0:
223 case R200_EMIT_RE_SCISSOR_TL_1:
224 case R200_EMIT_RE_SCISSOR_TL_2:
225 case R200_EMIT_SE_VAP_CNTL_STATUS:
226 case R200_EMIT_SE_VTX_STATE_CNTL:
227 case R200_EMIT_RE_POINTSIZE:
228 case R200_EMIT_TCL_INPUT_VTX_VECTOR_ADDR_0:
229 case R200_EMIT_PP_CUBIC_FACES_0:
230 case R200_EMIT_PP_CUBIC_FACES_1:
231 case R200_EMIT_PP_CUBIC_FACES_2:
232 case R200_EMIT_PP_CUBIC_FACES_3:
233 case R200_EMIT_PP_CUBIC_FACES_4:
234 case R200_EMIT_PP_CUBIC_FACES_5:
235 case RADEON_EMIT_PP_TEX_SIZE_0:
236 case RADEON_EMIT_PP_TEX_SIZE_1:
237 case RADEON_EMIT_PP_TEX_SIZE_2:
238 case R200_EMIT_RB3D_BLENDCOLOR:
239 case R200_EMIT_TCL_POINT_SPRITE_CNTL:
240 case RADEON_EMIT_PP_CUBIC_FACES_0:
241 case RADEON_EMIT_PP_CUBIC_FACES_1:
242 case RADEON_EMIT_PP_CUBIC_FACES_2:
243 case R200_EMIT_PP_TRI_PERF_CNTL:
244 case R200_EMIT_PP_AFS_0:
245 case R200_EMIT_PP_AFS_1:
246 case R200_EMIT_ATF_TFACTOR:
247 case R200_EMIT_PP_TXCTLALL_0:
248 case R200_EMIT_PP_TXCTLALL_1:
249 case R200_EMIT_PP_TXCTLALL_2:
250 case R200_EMIT_PP_TXCTLALL_3:
251 case R200_EMIT_PP_TXCTLALL_4:
252 case R200_EMIT_PP_TXCTLALL_5:
253 case R200_EMIT_VAP_PVS_CNTL:
254 /* These packets don't contain memory offsets */
258 DRM_ERROR("Unknown state packet ID %d\n", id);
265 static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
267 struct drm_file *file_priv,
268 drm_radeon_kcmd_buffer_t *
272 u32 *cmd = (u32 *) cmdbuf->buf;
276 *cmdsz = 2 + ((cmd[0] & RADEON_CP_PACKET_COUNT_MASK) >> 16);
278 if ((cmd[0] & 0xc0000000) != RADEON_CP_PACKET3) {
279 DRM_ERROR("Not a type 3 packet\n");
283 if (4 * *cmdsz > cmdbuf->bufsz) {
284 DRM_ERROR("Packet size larger than size of data provided\n");
288 switch(cmd[0] & 0xff00) {
289 /* XXX Are there old drivers needing other packets? */
291 case RADEON_3D_DRAW_IMMD:
292 case RADEON_3D_DRAW_VBUF:
293 case RADEON_3D_DRAW_INDX:
294 case RADEON_WAIT_FOR_IDLE:
296 case RADEON_3D_CLEAR_ZMASK:
297 /* case RADEON_CP_NEXT_CHAR:
298 case RADEON_CP_PLY_NEXTSCAN:
299 case RADEON_CP_SET_SCISSORS: */ /* probably safe but will never need them? */
300 /* these packets are safe */
303 case RADEON_CP_3D_DRAW_IMMD_2:
304 case RADEON_CP_3D_DRAW_VBUF_2:
305 case RADEON_CP_3D_DRAW_INDX_2:
306 case RADEON_3D_CLEAR_HIZ:
307 /* safe but r200 only */
308 if ((dev_priv->chip_family < CHIP_R200) ||
309 (dev_priv->chip_family > CHIP_RV280)) {
310 DRM_ERROR("Invalid 3d packet for non r200-class chip\n");
315 case RADEON_3D_LOAD_VBPNTR:
316 count = (cmd[0] >> 16) & 0x3fff;
318 if (count > 18) { /* 12 arrays max */
319 DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
324 /* carefully check packet contents */
325 narrays = cmd[1] & ~0xc000;
328 while ((k < narrays) && (i < (count + 2))) {
329 i++; /* skip attribute field */
330 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
333 ("Invalid offset (k=%d i=%d) in 3D_LOAD_VBPNTR packet.\n",
341 /* have one more to process, they come in pairs */
342 if (radeon_check_and_fixup_offset(dev_priv,
346 ("Invalid offset (k=%d i=%d) in 3D_LOAD_VBPNTR packet.\n",
353 /* do the counts match what we expect ? */
354 if ((k != narrays) || (i != (count + 2))) {
356 ("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
357 k, i, narrays, count + 1);
362 case RADEON_3D_RNDR_GEN_INDX_PRIM:
363 if (dev_priv->chip_family > CHIP_RS200) {
364 DRM_ERROR("Invalid 3d packet for non-r100-class chip\n");
367 if (radeon_check_and_fixup_offset(dev_priv, file_priv, &cmd[1])) {
368 DRM_ERROR("Invalid rndr_gen_indx offset\n");
373 case RADEON_CP_INDX_BUFFER:
374 /* safe but r200 only */
375 if ((dev_priv->chip_family < CHIP_R200) ||
376 (dev_priv->chip_family > CHIP_RV280)) {
377 DRM_ERROR("Invalid 3d packet for non-r200-class chip\n");
380 if ((cmd[1] & 0x8000ffff) != 0x80000810) {
381 DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
384 if (radeon_check_and_fixup_offset(dev_priv, file_priv, &cmd[2])) {
385 DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
390 case RADEON_CNTL_HOSTDATA_BLT:
391 case RADEON_CNTL_PAINT_MULTI:
392 case RADEON_CNTL_BITBLT_MULTI:
393 /* MSB of opcode: next DWORD GUI_CNTL */
394 if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL
395 | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
396 offset = cmd[2] << 10;
397 if (radeon_check_and_fixup_offset
398 (dev_priv, file_priv, &offset)) {
399 DRM_ERROR("Invalid first packet offset\n");
402 cmd[2] = (cmd[2] & 0xffc00000) | offset >> 10;
405 if ((cmd[1] & RADEON_GMC_SRC_PITCH_OFFSET_CNTL) &&
406 (cmd[1] & RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
407 offset = cmd[3] << 10;
408 if (radeon_check_and_fixup_offset
409 (dev_priv, file_priv, &offset)) {
410 DRM_ERROR("Invalid second packet offset\n");
413 cmd[3] = (cmd[3] & 0xffc00000) | offset >> 10;
418 DRM_ERROR("Invalid packet type %x\n", cmd[0] & 0xff00);
425 /* ================================================================
426 * CP hardware state programming functions
429 static __inline__ void radeon_emit_clip_rect(drm_radeon_private_t * dev_priv,
430 struct drm_clip_rect * box)
434 DRM_DEBUG(" box: x1=%d y1=%d x2=%d y2=%d\n",
435 box->x1, box->y1, box->x2, box->y2);
438 OUT_RING(CP_PACKET0(RADEON_RE_TOP_LEFT, 0));
439 OUT_RING((box->y1 << 16) | box->x1);
440 OUT_RING(CP_PACKET0(RADEON_RE_WIDTH_HEIGHT, 0));
441 OUT_RING(((box->y2 - 1) << 16) | (box->x2 - 1));
447 static int radeon_emit_state(drm_radeon_private_t * dev_priv,
448 struct drm_file *file_priv,
449 drm_radeon_context_regs_t * ctx,
450 drm_radeon_texture_regs_t * tex,
454 DRM_DEBUG("dirty=0x%08x\n", dirty);
456 if (dirty & RADEON_UPLOAD_CONTEXT) {
457 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
458 &ctx->rb3d_depthoffset)) {
459 DRM_ERROR("Invalid depth buffer offset\n");
463 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
464 &ctx->rb3d_coloroffset)) {
465 DRM_ERROR("Invalid depth buffer offset\n");
470 OUT_RING(CP_PACKET0(RADEON_PP_MISC, 6));
471 OUT_RING(ctx->pp_misc);
472 OUT_RING(ctx->pp_fog_color);
473 OUT_RING(ctx->re_solid_color);
474 OUT_RING(ctx->rb3d_blendcntl);
475 OUT_RING(ctx->rb3d_depthoffset);
476 OUT_RING(ctx->rb3d_depthpitch);
477 OUT_RING(ctx->rb3d_zstencilcntl);
478 OUT_RING(CP_PACKET0(RADEON_PP_CNTL, 2));
479 OUT_RING(ctx->pp_cntl);
480 OUT_RING(ctx->rb3d_cntl);
481 OUT_RING(ctx->rb3d_coloroffset);
482 OUT_RING(CP_PACKET0(RADEON_RB3D_COLORPITCH, 0));
483 OUT_RING(ctx->rb3d_colorpitch);
487 if (dirty & RADEON_UPLOAD_VERTFMT) {
489 OUT_RING(CP_PACKET0(RADEON_SE_COORD_FMT, 0));
490 OUT_RING(ctx->se_coord_fmt);
494 if (dirty & RADEON_UPLOAD_LINE) {
496 OUT_RING(CP_PACKET0(RADEON_RE_LINE_PATTERN, 1));
497 OUT_RING(ctx->re_line_pattern);
498 OUT_RING(ctx->re_line_state);
499 OUT_RING(CP_PACKET0(RADEON_SE_LINE_WIDTH, 0));
500 OUT_RING(ctx->se_line_width);
504 if (dirty & RADEON_UPLOAD_BUMPMAP) {
506 OUT_RING(CP_PACKET0(RADEON_PP_LUM_MATRIX, 0));
507 OUT_RING(ctx->pp_lum_matrix);
508 OUT_RING(CP_PACKET0(RADEON_PP_ROT_MATRIX_0, 1));
509 OUT_RING(ctx->pp_rot_matrix_0);
510 OUT_RING(ctx->pp_rot_matrix_1);
514 if (dirty & RADEON_UPLOAD_MASKS) {
516 OUT_RING(CP_PACKET0(RADEON_RB3D_STENCILREFMASK, 2));
517 OUT_RING(ctx->rb3d_stencilrefmask);
518 OUT_RING(ctx->rb3d_ropcntl);
519 OUT_RING(ctx->rb3d_planemask);
523 if (dirty & RADEON_UPLOAD_VIEWPORT) {
525 OUT_RING(CP_PACKET0(RADEON_SE_VPORT_XSCALE, 5));
526 OUT_RING(ctx->se_vport_xscale);
527 OUT_RING(ctx->se_vport_xoffset);
528 OUT_RING(ctx->se_vport_yscale);
529 OUT_RING(ctx->se_vport_yoffset);
530 OUT_RING(ctx->se_vport_zscale);
531 OUT_RING(ctx->se_vport_zoffset);
535 if (dirty & RADEON_UPLOAD_SETUP) {
537 OUT_RING(CP_PACKET0(RADEON_SE_CNTL, 0));
538 OUT_RING(ctx->se_cntl);
539 OUT_RING(CP_PACKET0(RADEON_SE_CNTL_STATUS, 0));
540 OUT_RING(ctx->se_cntl_status);
544 if (dirty & RADEON_UPLOAD_MISC) {
546 OUT_RING(CP_PACKET0(RADEON_RE_MISC, 0));
547 OUT_RING(ctx->re_misc);
551 if (dirty & RADEON_UPLOAD_TEX0) {
552 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
553 &tex[0].pp_txoffset)) {
554 DRM_ERROR("Invalid texture offset for unit 0\n");
559 OUT_RING(CP_PACKET0(RADEON_PP_TXFILTER_0, 5));
560 OUT_RING(tex[0].pp_txfilter);
561 OUT_RING(tex[0].pp_txformat);
562 OUT_RING(tex[0].pp_txoffset);
563 OUT_RING(tex[0].pp_txcblend);
564 OUT_RING(tex[0].pp_txablend);
565 OUT_RING(tex[0].pp_tfactor);
566 OUT_RING(CP_PACKET0(RADEON_PP_BORDER_COLOR_0, 0));
567 OUT_RING(tex[0].pp_border_color);
571 if (dirty & RADEON_UPLOAD_TEX1) {
572 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
573 &tex[1].pp_txoffset)) {
574 DRM_ERROR("Invalid texture offset for unit 1\n");
579 OUT_RING(CP_PACKET0(RADEON_PP_TXFILTER_1, 5));
580 OUT_RING(tex[1].pp_txfilter);
581 OUT_RING(tex[1].pp_txformat);
582 OUT_RING(tex[1].pp_txoffset);
583 OUT_RING(tex[1].pp_txcblend);
584 OUT_RING(tex[1].pp_txablend);
585 OUT_RING(tex[1].pp_tfactor);
586 OUT_RING(CP_PACKET0(RADEON_PP_BORDER_COLOR_1, 0));
587 OUT_RING(tex[1].pp_border_color);
591 if (dirty & RADEON_UPLOAD_TEX2) {
592 if (radeon_check_and_fixup_offset(dev_priv, file_priv,
593 &tex[2].pp_txoffset)) {
594 DRM_ERROR("Invalid texture offset for unit 2\n");
599 OUT_RING(CP_PACKET0(RADEON_PP_TXFILTER_2, 5));
600 OUT_RING(tex[2].pp_txfilter);
601 OUT_RING(tex[2].pp_txformat);
602 OUT_RING(tex[2].pp_txoffset);
603 OUT_RING(tex[2].pp_txcblend);
604 OUT_RING(tex[2].pp_txablend);
605 OUT_RING(tex[2].pp_tfactor);
606 OUT_RING(CP_PACKET0(RADEON_PP_BORDER_COLOR_2, 0));
607 OUT_RING(tex[2].pp_border_color);
616 static int radeon_emit_state2(drm_radeon_private_t * dev_priv,
617 struct drm_file *file_priv,
618 drm_radeon_state_t * state)
622 if (state->dirty & RADEON_UPLOAD_ZBIAS) {
624 OUT_RING(CP_PACKET0(RADEON_SE_ZBIAS_FACTOR, 1));
625 OUT_RING(state->context2.se_zbias_factor);
626 OUT_RING(state->context2.se_zbias_constant);
630 return radeon_emit_state(dev_priv, file_priv, &state->context,
631 state->tex, state->dirty);
634 /* New (1.3) state mechanism. 3 commands (packet, scalar, vector) in
635 * 1.3 cmdbuffers allow all previous state to be updated as well as
636 * the tcl scalar and vector areas.
642 } packet[RADEON_MAX_STATE_PACKETS] = {
643 {RADEON_PP_MISC, 7, "RADEON_PP_MISC"},
644 {RADEON_PP_CNTL, 3, "RADEON_PP_CNTL"},
645 {RADEON_RB3D_COLORPITCH, 1, "RADEON_RB3D_COLORPITCH"},
646 {RADEON_RE_LINE_PATTERN, 2, "RADEON_RE_LINE_PATTERN"},
647 {RADEON_SE_LINE_WIDTH, 1, "RADEON_SE_LINE_WIDTH"},
648 {RADEON_PP_LUM_MATRIX, 1, "RADEON_PP_LUM_MATRIX"},
649 {RADEON_PP_ROT_MATRIX_0, 2, "RADEON_PP_ROT_MATRIX_0"},
650 {RADEON_RB3D_STENCILREFMASK, 3, "RADEON_RB3D_STENCILREFMASK"},
651 {RADEON_SE_VPORT_XSCALE, 6, "RADEON_SE_VPORT_XSCALE"},
652 {RADEON_SE_CNTL, 2, "RADEON_SE_CNTL"},
653 {RADEON_SE_CNTL_STATUS, 1, "RADEON_SE_CNTL_STATUS"},
654 {RADEON_RE_MISC, 1, "RADEON_RE_MISC"},
655 {RADEON_PP_TXFILTER_0, 6, "RADEON_PP_TXFILTER_0"},
656 {RADEON_PP_BORDER_COLOR_0, 1, "RADEON_PP_BORDER_COLOR_0"},
657 {RADEON_PP_TXFILTER_1, 6, "RADEON_PP_TXFILTER_1"},
658 {RADEON_PP_BORDER_COLOR_1, 1, "RADEON_PP_BORDER_COLOR_1"},
659 {RADEON_PP_TXFILTER_2, 6, "RADEON_PP_TXFILTER_2"},
660 {RADEON_PP_BORDER_COLOR_2, 1, "RADEON_PP_BORDER_COLOR_2"},
661 {RADEON_SE_ZBIAS_FACTOR, 2, "RADEON_SE_ZBIAS_FACTOR"},
662 {RADEON_SE_TCL_OUTPUT_VTX_FMT, 11, "RADEON_SE_TCL_OUTPUT_VTX_FMT"},
663 {RADEON_SE_TCL_MATERIAL_EMMISSIVE_RED, 17,
664 "RADEON_SE_TCL_MATERIAL_EMMISSIVE_RED"},
665 {R200_PP_TXCBLEND_0, 4, "R200_PP_TXCBLEND_0"},
666 {R200_PP_TXCBLEND_1, 4, "R200_PP_TXCBLEND_1"},
667 {R200_PP_TXCBLEND_2, 4, "R200_PP_TXCBLEND_2"},
668 {R200_PP_TXCBLEND_3, 4, "R200_PP_TXCBLEND_3"},
669 {R200_PP_TXCBLEND_4, 4, "R200_PP_TXCBLEND_4"},
670 {R200_PP_TXCBLEND_5, 4, "R200_PP_TXCBLEND_5"},
671 {R200_PP_TXCBLEND_6, 4, "R200_PP_TXCBLEND_6"},
672 {R200_PP_TXCBLEND_7, 4, "R200_PP_TXCBLEND_7"},
673 {R200_SE_TCL_LIGHT_MODEL_CTL_0, 6, "R200_SE_TCL_LIGHT_MODEL_CTL_0"},
674 {R200_PP_TFACTOR_0, 6, "R200_PP_TFACTOR_0"},
675 {R200_SE_VTX_FMT_0, 4, "R200_SE_VTX_FMT_0"},
676 {R200_SE_VAP_CNTL, 1, "R200_SE_VAP_CNTL"},
677 {R200_SE_TCL_MATRIX_SEL_0, 5, "R200_SE_TCL_MATRIX_SEL_0"},
678 {R200_SE_TCL_TEX_PROC_CTL_2, 5, "R200_SE_TCL_TEX_PROC_CTL_2"},
679 {R200_SE_TCL_UCP_VERT_BLEND_CTL, 1, "R200_SE_TCL_UCP_VERT_BLEND_CTL"},
680 {R200_PP_TXFILTER_0, 6, "R200_PP_TXFILTER_0"},
681 {R200_PP_TXFILTER_1, 6, "R200_PP_TXFILTER_1"},
682 {R200_PP_TXFILTER_2, 6, "R200_PP_TXFILTER_2"},
683 {R200_PP_TXFILTER_3, 6, "R200_PP_TXFILTER_3"},
684 {R200_PP_TXFILTER_4, 6, "R200_PP_TXFILTER_4"},
685 {R200_PP_TXFILTER_5, 6, "R200_PP_TXFILTER_5"},
686 {R200_PP_TXOFFSET_0, 1, "R200_PP_TXOFFSET_0"},
687 {R200_PP_TXOFFSET_1, 1, "R200_PP_TXOFFSET_1"},
688 {R200_PP_TXOFFSET_2, 1, "R200_PP_TXOFFSET_2"},
689 {R200_PP_TXOFFSET_3, 1, "R200_PP_TXOFFSET_3"},
690 {R200_PP_TXOFFSET_4, 1, "R200_PP_TXOFFSET_4"},
691 {R200_PP_TXOFFSET_5, 1, "R200_PP_TXOFFSET_5"},
692 {R200_SE_VTE_CNTL, 1, "R200_SE_VTE_CNTL"},
693 {R200_SE_TCL_OUTPUT_VTX_COMP_SEL, 1,
694 "R200_SE_TCL_OUTPUT_VTX_COMP_SEL"},
695 {R200_PP_TAM_DEBUG3, 1, "R200_PP_TAM_DEBUG3"},
696 {R200_PP_CNTL_X, 1, "R200_PP_CNTL_X"},
697 {R200_RB3D_DEPTHXY_OFFSET, 1, "R200_RB3D_DEPTHXY_OFFSET"},
698 {R200_RE_AUX_SCISSOR_CNTL, 1, "R200_RE_AUX_SCISSOR_CNTL"},
699 {R200_RE_SCISSOR_TL_0, 2, "R200_RE_SCISSOR_TL_0"},
700 {R200_RE_SCISSOR_TL_1, 2, "R200_RE_SCISSOR_TL_1"},
701 {R200_RE_SCISSOR_TL_2, 2, "R200_RE_SCISSOR_TL_2"},
702 {R200_SE_VAP_CNTL_STATUS, 1, "R200_SE_VAP_CNTL_STATUS"},
703 {R200_SE_VTX_STATE_CNTL, 1, "R200_SE_VTX_STATE_CNTL"},
704 {R200_RE_POINTSIZE, 1, "R200_RE_POINTSIZE"},
705 {R200_SE_TCL_INPUT_VTX_VECTOR_ADDR_0, 4,
706 "R200_SE_TCL_INPUT_VTX_VECTOR_ADDR_0"},
707 {R200_PP_CUBIC_FACES_0, 1, "R200_PP_CUBIC_FACES_0"}, /* 61 */
708 {R200_PP_CUBIC_OFFSET_F1_0, 5, "R200_PP_CUBIC_OFFSET_F1_0"}, /* 62 */
709 {R200_PP_CUBIC_FACES_1, 1, "R200_PP_CUBIC_FACES_1"},
710 {R200_PP_CUBIC_OFFSET_F1_1, 5, "R200_PP_CUBIC_OFFSET_F1_1"},
711 {R200_PP_CUBIC_FACES_2, 1, "R200_PP_CUBIC_FACES_2"},
712 {R200_PP_CUBIC_OFFSET_F1_2, 5, "R200_PP_CUBIC_OFFSET_F1_2"},
713 {R200_PP_CUBIC_FACES_3, 1, "R200_PP_CUBIC_FACES_3"},
714 {R200_PP_CUBIC_OFFSET_F1_3, 5, "R200_PP_CUBIC_OFFSET_F1_3"},
715 {R200_PP_CUBIC_FACES_4, 1, "R200_PP_CUBIC_FACES_4"},
716 {R200_PP_CUBIC_OFFSET_F1_4, 5, "R200_PP_CUBIC_OFFSET_F1_4"},
717 {R200_PP_CUBIC_FACES_5, 1, "R200_PP_CUBIC_FACES_5"},
718 {R200_PP_CUBIC_OFFSET_F1_5, 5, "R200_PP_CUBIC_OFFSET_F1_5"},
719 {RADEON_PP_TEX_SIZE_0, 2, "RADEON_PP_TEX_SIZE_0"},
720 {RADEON_PP_TEX_SIZE_1, 2, "RADEON_PP_TEX_SIZE_1"},
721 {RADEON_PP_TEX_SIZE_2, 2, "RADEON_PP_TEX_SIZE_2"},
722 {R200_RB3D_BLENDCOLOR, 3, "R200_RB3D_BLENDCOLOR"},
723 {R200_SE_TCL_POINT_SPRITE_CNTL, 1, "R200_SE_TCL_POINT_SPRITE_CNTL"},
724 {RADEON_PP_CUBIC_FACES_0, 1, "RADEON_PP_CUBIC_FACES_0"},
725 {RADEON_PP_CUBIC_OFFSET_T0_0, 5, "RADEON_PP_CUBIC_OFFSET_T0_0"},
726 {RADEON_PP_CUBIC_FACES_1, 1, "RADEON_PP_CUBIC_FACES_1"},
727 {RADEON_PP_CUBIC_OFFSET_T1_0, 5, "RADEON_PP_CUBIC_OFFSET_T1_0"},
728 {RADEON_PP_CUBIC_FACES_2, 1, "RADEON_PP_CUBIC_FACES_2"},
729 {RADEON_PP_CUBIC_OFFSET_T2_0, 5, "RADEON_PP_CUBIC_OFFSET_T2_0"},
730 {R200_PP_TRI_PERF, 2, "R200_PP_TRI_PERF"},
731 {R200_PP_AFS_0, 32, "R200_PP_AFS_0"}, /* 85 */
732 {R200_PP_AFS_1, 32, "R200_PP_AFS_1"},
733 {R200_PP_TFACTOR_0, 8, "R200_ATF_TFACTOR"},
734 {R200_PP_TXFILTER_0, 8, "R200_PP_TXCTLALL_0"},
735 {R200_PP_TXFILTER_1, 8, "R200_PP_TXCTLALL_1"},
736 {R200_PP_TXFILTER_2, 8, "R200_PP_TXCTLALL_2"},
737 {R200_PP_TXFILTER_3, 8, "R200_PP_TXCTLALL_3"},
738 {R200_PP_TXFILTER_4, 8, "R200_PP_TXCTLALL_4"},
739 {R200_PP_TXFILTER_5, 8, "R200_PP_TXCTLALL_5"},
740 {R200_VAP_PVS_CNTL_1, 2, "R200_VAP_PVS_CNTL"},
743 /* ================================================================
744 * Performance monitoring functions
747 static void radeon_clear_box(drm_radeon_private_t * dev_priv,
748 struct drm_radeon_master_private *master_priv,
749 int x, int y, int w, int h, int r, int g, int b)
754 x += master_priv->sarea_priv->boxes[0].x1;
755 y += master_priv->sarea_priv->boxes[0].y1;
757 switch (dev_priv->color_fmt) {
758 case RADEON_COLOR_FORMAT_RGB565:
759 color = (((r & 0xf8) << 8) |
760 ((g & 0xfc) << 3) | ((b & 0xf8) >> 3));
762 case RADEON_COLOR_FORMAT_ARGB8888:
764 color = (((0xff) << 24) | (r << 16) | (g << 8) | b);
769 RADEON_WAIT_UNTIL_3D_IDLE();
770 OUT_RING(CP_PACKET0(RADEON_DP_WRITE_MASK, 0));
771 OUT_RING(0xffffffff);
776 OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_MULTI, 4));
777 OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL |
778 RADEON_GMC_BRUSH_SOLID_COLOR |
779 (dev_priv->color_fmt << 8) |
780 RADEON_GMC_SRC_DATATYPE_COLOR |
781 RADEON_ROP3_P | RADEON_GMC_CLR_CMP_CNTL_DIS);
783 if (master_priv->sarea_priv->pfCurrentPage == 1) {
784 OUT_RING(dev_priv->front_pitch_offset);
786 OUT_RING(dev_priv->back_pitch_offset);
791 OUT_RING((x << 16) | y);
792 OUT_RING((w << 16) | h);
797 static void radeon_cp_performance_boxes(drm_radeon_private_t * dev_priv, struct drm_radeon_master_private *master_priv)
799 /* Collapse various things into a wait flag -- trying to
800 * guess if userspase slept -- better just to have them tell us.
802 if (dev_priv->stats.last_frame_reads > 1 ||
803 dev_priv->stats.last_clear_reads > dev_priv->stats.clears) {
804 dev_priv->stats.boxes |= RADEON_BOX_WAIT_IDLE;
807 if (dev_priv->stats.freelist_loops) {
808 dev_priv->stats.boxes |= RADEON_BOX_WAIT_IDLE;
811 /* Purple box for page flipping
813 if (dev_priv->stats.boxes & RADEON_BOX_FLIP)
814 radeon_clear_box(dev_priv, master_priv, 4, 4, 8, 8, 255, 0, 255);
816 /* Red box if we have to wait for idle at any point
818 if (dev_priv->stats.boxes & RADEON_BOX_WAIT_IDLE)
819 radeon_clear_box(dev_priv, master_priv, 16, 4, 8, 8, 255, 0, 0);
821 /* Blue box: lost context?
824 /* Yellow box for texture swaps
826 if (dev_priv->stats.boxes & RADEON_BOX_TEXTURE_LOAD)
827 radeon_clear_box(dev_priv, master_priv, 40, 4, 8, 8, 255, 255, 0);
829 /* Green box if hardware never idles (as far as we can tell)
831 if (!(dev_priv->stats.boxes & RADEON_BOX_DMA_IDLE))
832 radeon_clear_box(dev_priv, master_priv, 64, 4, 8, 8, 0, 255, 0);
834 /* Draw bars indicating number of buffers allocated
835 * (not a great measure, easily confused)
837 if (dev_priv->stats.requested_bufs) {
838 if (dev_priv->stats.requested_bufs > 100)
839 dev_priv->stats.requested_bufs = 100;
841 radeon_clear_box(dev_priv, master_priv, 4, 16,
842 dev_priv->stats.requested_bufs, 4,
846 memset(&dev_priv->stats, 0, sizeof(dev_priv->stats));
850 /* ================================================================
851 * CP command dispatch functions
854 static void radeon_cp_dispatch_clear(struct drm_device * dev,
855 struct drm_master *master,
856 drm_radeon_clear_t * clear,
857 drm_radeon_clear_rect_t * depth_boxes)
859 drm_radeon_private_t *dev_priv = dev->dev_private;
860 struct drm_radeon_master_private *master_priv = master->driver_priv;
861 drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
862 drm_radeon_depth_clear_t *depth_clear = &dev_priv->depth_clear;
863 int nbox = sarea_priv->nbox;
864 struct drm_clip_rect *pbox = sarea_priv->boxes;
865 unsigned int flags = clear->flags;
866 u32 rb3d_cntl = 0, rb3d_stencilrefmask = 0;
869 DRM_DEBUG("flags = 0x%x\n", flags);
871 dev_priv->stats.clears++;
873 if (sarea_priv->pfCurrentPage == 1) {
874 unsigned int tmp = flags;
876 flags &= ~(RADEON_FRONT | RADEON_BACK);
877 if (tmp & RADEON_FRONT)
878 flags |= RADEON_BACK;
879 if (tmp & RADEON_BACK)
880 flags |= RADEON_FRONT;
883 if (flags & (RADEON_FRONT | RADEON_BACK)) {
887 /* Ensure the 3D stream is idle before doing a
888 * 2D fill to clear the front or back buffer.
890 RADEON_WAIT_UNTIL_3D_IDLE();
892 OUT_RING(CP_PACKET0(RADEON_DP_WRITE_MASK, 0));
893 OUT_RING(clear->color_mask);
897 /* Make sure we restore the 3D state next time.
899 sarea_priv->ctx_owner = 0;
901 for (i = 0; i < nbox; i++) {
904 int w = pbox[i].x2 - x;
905 int h = pbox[i].y2 - y;
907 DRM_DEBUG("%d,%d-%d,%d flags 0x%x\n",
910 if (flags & RADEON_FRONT) {
914 (RADEON_CNTL_PAINT_MULTI, 4));
915 OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL |
916 RADEON_GMC_BRUSH_SOLID_COLOR |
919 RADEON_GMC_SRC_DATATYPE_COLOR |
921 RADEON_GMC_CLR_CMP_CNTL_DIS);
923 OUT_RING(dev_priv->front_pitch_offset);
924 OUT_RING(clear->clear_color);
926 OUT_RING((x << 16) | y);
927 OUT_RING((w << 16) | h);
932 if (flags & RADEON_BACK) {
936 (RADEON_CNTL_PAINT_MULTI, 4));
937 OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL |
938 RADEON_GMC_BRUSH_SOLID_COLOR |
941 RADEON_GMC_SRC_DATATYPE_COLOR |
943 RADEON_GMC_CLR_CMP_CNTL_DIS);
945 OUT_RING(dev_priv->back_pitch_offset);
946 OUT_RING(clear->clear_color);
948 OUT_RING((x << 16) | y);
949 OUT_RING((w << 16) | h);
957 /* no docs available, based on reverse engeneering by Stephane Marchesin */
958 if ((flags & (RADEON_DEPTH | RADEON_STENCIL))
959 && (flags & RADEON_CLEAR_FASTZ)) {
962 int depthpixperline =
963 dev_priv->depth_fmt ==
964 RADEON_DEPTH_FORMAT_16BIT_INT_Z ? (dev_priv->depth_pitch /
970 u32 tempRB3D_DEPTHCLEARVALUE = clear->clear_depth |
971 ((clear->depth_mask & 0xff) << 24);
973 /* Make sure we restore the 3D state next time.
974 * we haven't touched any "normal" state - still need this?
976 sarea_priv->ctx_owner = 0;
978 if ((dev_priv->flags & RADEON_HAS_HIERZ)
979 && (flags & RADEON_USE_HIERZ)) {
980 /* FIXME : reverse engineer that for Rx00 cards */
981 /* FIXME : the mask supposedly contains low-res z values. So can't set
982 just to the max (0xff? or actually 0x3fff?), need to take z clear
983 value into account? */
984 /* pattern seems to work for r100, though get slight
985 rendering errors with glxgears. If hierz is not enabled for r100,
986 only 4 bits which indicate clear (15,16,31,32, all zero) matter, the
987 other ones are ignored, and the same clear mask can be used. That's
988 very different behaviour than R200 which needs different clear mask
989 and different number of tiles to clear if hierz is enabled or not !?!
991 clearmask = (0xff << 22) | (0xff << 6) | 0x003f003f;
993 /* clear mask : chooses the clearing pattern.
994 rv250: could be used to clear only parts of macrotiles
995 (but that would get really complicated...)?
996 bit 0 and 1 (either or both of them ?!?!) are used to
997 not clear tile (or maybe one of the bits indicates if the tile is
998 compressed or not), bit 2 and 3 to not clear tile 1,...,.
999 Pattern is as follows:
1000 | 0,1 | 4,5 | 8,9 |12,13|16,17|20,21|24,25|28,29|
1001 bits -------------------------------------------------
1002 | 2,3 | 6,7 |10,11|14,15|18,19|22,23|26,27|30,31|
1003 rv100: clearmask covers 2x8 4x1 tiles, but one clear still
1004 covers 256 pixels ?!?
1010 RADEON_WAIT_UNTIL_2D_IDLE();
1011 OUT_RING_REG(RADEON_RB3D_DEPTHCLEARVALUE,
1012 tempRB3D_DEPTHCLEARVALUE);
1013 /* what offset is this exactly ? */
1014 OUT_RING_REG(RADEON_RB3D_ZMASKOFFSET, 0);
1015 /* need ctlstat, otherwise get some strange black flickering */
1016 OUT_RING_REG(RADEON_RB3D_ZCACHE_CTLSTAT,
1017 RADEON_RB3D_ZC_FLUSH_ALL);
1020 for (i = 0; i < nbox; i++) {
1021 int tileoffset, nrtilesx, nrtilesy, j;
1022 /* it looks like r200 needs rv-style clears, at least if hierz is not enabled? */
1023 if ((dev_priv->flags & RADEON_HAS_HIERZ)
1024 && (dev_priv->chip_family < CHIP_R200)) {
1025 /* FIXME : figure this out for r200 (when hierz is enabled). Or
1026 maybe r200 actually doesn't need to put the low-res z value into
1027 the tile cache like r100, but just needs to clear the hi-level z-buffer?
1028 Works for R100, both with hierz and without.
1029 R100 seems to operate on 2x1 8x8 tiles, but...
1030 odd: offset/nrtiles need to be 64 pix (4 block) aligned? Potentially
1031 problematic with resolutions which are not 64 pix aligned? */
1033 ((pbox[i].y1 >> 3) * depthpixperline +
1036 ((pbox[i].x2 & ~63) -
1037 (pbox[i].x1 & ~63)) >> 4;
1039 (pbox[i].y2 >> 3) - (pbox[i].y1 >> 3);
1040 for (j = 0; j <= nrtilesy; j++) {
1043 (RADEON_3D_CLEAR_ZMASK, 2));
1045 OUT_RING(tileoffset * 8);
1046 /* the number of tiles to clear */
1047 OUT_RING(nrtilesx + 4);
1048 /* clear mask : chooses the clearing pattern. */
1049 OUT_RING(clearmask);
1051 tileoffset += depthpixperline >> 6;
1053 } else if ((dev_priv->chip_family >= CHIP_R200) &&
1054 (dev_priv->chip_family <= CHIP_RV280)) {
1055 /* works for rv250. */
1056 /* find first macro tile (8x2 4x4 z-pixels on rv250) */
1058 ((pbox[i].y1 >> 3) * depthpixperline +
1061 (pbox[i].x2 >> 5) - (pbox[i].x1 >> 5);
1063 (pbox[i].y2 >> 3) - (pbox[i].y1 >> 3);
1064 for (j = 0; j <= nrtilesy; j++) {
1067 (RADEON_3D_CLEAR_ZMASK, 2));
1069 /* judging by the first tile offset needed, could possibly
1070 directly address/clear 4x4 tiles instead of 8x2 * 4x4
1071 macro tiles, though would still need clear mask for
1072 right/bottom if truely 4x4 granularity is desired ? */
1073 OUT_RING(tileoffset * 16);
1074 /* the number of tiles to clear */
1075 OUT_RING(nrtilesx + 1);
1076 /* clear mask : chooses the clearing pattern. */
1077 OUT_RING(clearmask);
1079 tileoffset += depthpixperline >> 5;
1081 } else { /* rv 100 */
1082 /* rv100 might not need 64 pix alignment, who knows */
1083 /* offsets are, hmm, weird */
1085 ((pbox[i].y1 >> 4) * depthpixperline +
1088 ((pbox[i].x2 & ~63) -
1089 (pbox[i].x1 & ~63)) >> 4;
1091 (pbox[i].y2 >> 4) - (pbox[i].y1 >> 4);
1092 for (j = 0; j <= nrtilesy; j++) {
1095 (RADEON_3D_CLEAR_ZMASK, 2));
1096 OUT_RING(tileoffset * 128);
1097 /* the number of tiles to clear */
1098 OUT_RING(nrtilesx + 4);
1099 /* clear mask : chooses the clearing pattern. */
1100 OUT_RING(clearmask);
1102 tileoffset += depthpixperline >> 6;
1107 /* TODO don't always clear all hi-level z tiles */
1108 if ((dev_priv->flags & RADEON_HAS_HIERZ)
1109 && ((dev_priv->chip_family >= CHIP_R200) &&
1110 (dev_priv->chip_family <= CHIP_RV280))
1111 && (flags & RADEON_USE_HIERZ))
1112 /* r100 and cards without hierarchical z-buffer have no high-level z-buffer */
1113 /* FIXME : the mask supposedly contains low-res z values. So can't set
1114 just to the max (0xff? or actually 0x3fff?), need to take z clear
1115 value into account? */
1118 OUT_RING(CP_PACKET3(RADEON_3D_CLEAR_HIZ, 2));
1119 OUT_RING(0x0); /* First tile */
1121 OUT_RING((0xff << 22) | (0xff << 6) | 0x003f003f);
1126 /* We have to clear the depth and/or stencil buffers by
1127 * rendering a quad into just those buffers. Thus, we have to
1128 * make sure the 3D engine is configured correctly.
1130 else if ((dev_priv->chip_family >= CHIP_R200) &&
1131 (dev_priv->chip_family <= CHIP_RV280) &&
1132 (flags & (RADEON_DEPTH | RADEON_STENCIL))) {
1137 int tempRB3D_ZSTENCILCNTL;
1138 int tempRB3D_STENCILREFMASK;
1139 int tempRB3D_PLANEMASK;
1141 int tempSE_VTE_CNTL;
1142 int tempSE_VTX_FMT_0;
1143 int tempSE_VTX_FMT_1;
1144 int tempSE_VAP_CNTL;
1145 int tempRE_AUX_SCISSOR_CNTL;
1150 tempRB3D_CNTL = depth_clear->rb3d_cntl;
1152 tempRB3D_ZSTENCILCNTL = depth_clear->rb3d_zstencilcntl;
1153 tempRB3D_STENCILREFMASK = 0x0;
1155 tempSE_CNTL = depth_clear->se_cntl;
1159 tempSE_VAP_CNTL = ( /* SE_VAP_CNTL__FORCE_W_TO_ONE_MASK | */
1161 SE_VAP_CNTL__VF_MAX_VTX_NUM__SHIFT));
1163 tempRB3D_PLANEMASK = 0x0;
1165 tempRE_AUX_SCISSOR_CNTL = 0x0;
1168 SE_VTE_CNTL__VTX_XY_FMT_MASK | SE_VTE_CNTL__VTX_Z_FMT_MASK;
1170 /* Vertex format (X, Y, Z, W) */
1172 SE_VTX_FMT_0__VTX_Z0_PRESENT_MASK |
1173 SE_VTX_FMT_0__VTX_W0_PRESENT_MASK;
1174 tempSE_VTX_FMT_1 = 0x0;
1177 * Depth buffer specific enables
1179 if (flags & RADEON_DEPTH) {
1180 /* Enable depth buffer */
1181 tempRB3D_CNTL |= RADEON_Z_ENABLE;
1183 /* Disable depth buffer */
1184 tempRB3D_CNTL &= ~RADEON_Z_ENABLE;
1188 * Stencil buffer specific enables
1190 if (flags & RADEON_STENCIL) {
1191 tempRB3D_CNTL |= RADEON_STENCIL_ENABLE;
1192 tempRB3D_STENCILREFMASK = clear->depth_mask;
1194 tempRB3D_CNTL &= ~RADEON_STENCIL_ENABLE;
1195 tempRB3D_STENCILREFMASK = 0x00000000;
1198 if (flags & RADEON_USE_COMP_ZBUF) {
1199 tempRB3D_ZSTENCILCNTL |= RADEON_Z_COMPRESSION_ENABLE |
1200 RADEON_Z_DECOMPRESSION_ENABLE;
1202 if (flags & RADEON_USE_HIERZ) {
1203 tempRB3D_ZSTENCILCNTL |= RADEON_Z_HIERARCHY_ENABLE;
1207 RADEON_WAIT_UNTIL_2D_IDLE();
1209 OUT_RING_REG(RADEON_PP_CNTL, tempPP_CNTL);
1210 OUT_RING_REG(R200_RE_CNTL, tempRE_CNTL);
1211 OUT_RING_REG(RADEON_RB3D_CNTL, tempRB3D_CNTL);
1212 OUT_RING_REG(RADEON_RB3D_ZSTENCILCNTL, tempRB3D_ZSTENCILCNTL);
1213 OUT_RING_REG(RADEON_RB3D_STENCILREFMASK,
1214 tempRB3D_STENCILREFMASK);
1215 OUT_RING_REG(RADEON_RB3D_PLANEMASK, tempRB3D_PLANEMASK);
1216 OUT_RING_REG(RADEON_SE_CNTL, tempSE_CNTL);
1217 OUT_RING_REG(R200_SE_VTE_CNTL, tempSE_VTE_CNTL);
1218 OUT_RING_REG(R200_SE_VTX_FMT_0, tempSE_VTX_FMT_0);
1219 OUT_RING_REG(R200_SE_VTX_FMT_1, tempSE_VTX_FMT_1);
1220 OUT_RING_REG(R200_SE_VAP_CNTL, tempSE_VAP_CNTL);
1221 OUT_RING_REG(R200_RE_AUX_SCISSOR_CNTL, tempRE_AUX_SCISSOR_CNTL);
1224 /* Make sure we restore the 3D state next time.
1226 sarea_priv->ctx_owner = 0;
1228 for (i = 0; i < nbox; i++) {
1230 /* Funny that this should be required --
1233 radeon_emit_clip_rect(dev_priv, &sarea_priv->boxes[i]);
1236 OUT_RING(CP_PACKET3(R200_3D_DRAW_IMMD_2, 12));
1237 OUT_RING((RADEON_PRIM_TYPE_RECT_LIST |
1238 RADEON_PRIM_WALK_RING |
1239 (3 << RADEON_NUM_VERTICES_SHIFT)));
1240 OUT_RING(depth_boxes[i].ui[CLEAR_X1]);
1241 OUT_RING(depth_boxes[i].ui[CLEAR_Y1]);
1242 OUT_RING(depth_boxes[i].ui[CLEAR_DEPTH]);
1243 OUT_RING(0x3f800000);
1244 OUT_RING(depth_boxes[i].ui[CLEAR_X1]);
1245 OUT_RING(depth_boxes[i].ui[CLEAR_Y2]);
1246 OUT_RING(depth_boxes[i].ui[CLEAR_DEPTH]);
1247 OUT_RING(0x3f800000);
1248 OUT_RING(depth_boxes[i].ui[CLEAR_X2]);
1249 OUT_RING(depth_boxes[i].ui[CLEAR_Y2]);
1250 OUT_RING(depth_boxes[i].ui[CLEAR_DEPTH]);
1251 OUT_RING(0x3f800000);
1254 } else if ((flags & (RADEON_DEPTH | RADEON_STENCIL))) {
1256 int tempRB3D_ZSTENCILCNTL = depth_clear->rb3d_zstencilcntl;
1258 rb3d_cntl = depth_clear->rb3d_cntl;
1260 if (flags & RADEON_DEPTH) {
1261 rb3d_cntl |= RADEON_Z_ENABLE;
1263 rb3d_cntl &= ~RADEON_Z_ENABLE;
1266 if (flags & RADEON_STENCIL) {
1267 rb3d_cntl |= RADEON_STENCIL_ENABLE;
1268 rb3d_stencilrefmask = clear->depth_mask; /* misnamed field */
1270 rb3d_cntl &= ~RADEON_STENCIL_ENABLE;
1271 rb3d_stencilrefmask = 0x00000000;
1274 if (flags & RADEON_USE_COMP_ZBUF) {
1275 tempRB3D_ZSTENCILCNTL |= RADEON_Z_COMPRESSION_ENABLE |
1276 RADEON_Z_DECOMPRESSION_ENABLE;
1278 if (flags & RADEON_USE_HIERZ) {
1279 tempRB3D_ZSTENCILCNTL |= RADEON_Z_HIERARCHY_ENABLE;
1283 RADEON_WAIT_UNTIL_2D_IDLE();
1285 OUT_RING(CP_PACKET0(RADEON_PP_CNTL, 1));
1286 OUT_RING(0x00000000);
1287 OUT_RING(rb3d_cntl);
1289 OUT_RING_REG(RADEON_RB3D_ZSTENCILCNTL, tempRB3D_ZSTENCILCNTL);
1290 OUT_RING_REG(RADEON_RB3D_STENCILREFMASK, rb3d_stencilrefmask);
1291 OUT_RING_REG(RADEON_RB3D_PLANEMASK, 0x00000000);
1292 OUT_RING_REG(RADEON_SE_CNTL, depth_clear->se_cntl);
1295 /* Make sure we restore the 3D state next time.
1297 sarea_priv->ctx_owner = 0;
1299 for (i = 0; i < nbox; i++) {
1301 /* Funny that this should be required --
1304 radeon_emit_clip_rect(dev_priv, &sarea_priv->boxes[i]);
1308 OUT_RING(CP_PACKET3(RADEON_3D_DRAW_IMMD, 13));
1309 OUT_RING(RADEON_VTX_Z_PRESENT |
1310 RADEON_VTX_PKCOLOR_PRESENT);
1311 OUT_RING((RADEON_PRIM_TYPE_RECT_LIST |
1312 RADEON_PRIM_WALK_RING |
1313 RADEON_MAOS_ENABLE |
1314 RADEON_VTX_FMT_RADEON_MODE |
1315 (3 << RADEON_NUM_VERTICES_SHIFT)));
1317 OUT_RING(depth_boxes[i].ui[CLEAR_X1]);
1318 OUT_RING(depth_boxes[i].ui[CLEAR_Y1]);
1319 OUT_RING(depth_boxes[i].ui[CLEAR_DEPTH]);
1322 OUT_RING(depth_boxes[i].ui[CLEAR_X1]);
1323 OUT_RING(depth_boxes[i].ui[CLEAR_Y2]);
1324 OUT_RING(depth_boxes[i].ui[CLEAR_DEPTH]);
1327 OUT_RING(depth_boxes[i].ui[CLEAR_X2]);
1328 OUT_RING(depth_boxes[i].ui[CLEAR_Y2]);
1329 OUT_RING(depth_boxes[i].ui[CLEAR_DEPTH]);
1336 /* Increment the clear counter. The client-side 3D driver must
1337 * wait on this value before performing the clear ioctl. We
1338 * need this because the card's so damned fast...
1340 sarea_priv->last_clear++;
1344 RADEON_CLEAR_AGE(sarea_priv->last_clear);
1345 RADEON_WAIT_UNTIL_IDLE();
1350 static void radeon_cp_dispatch_swap(struct drm_device * dev, struct drm_master *master)
1352 drm_radeon_private_t *dev_priv = dev->dev_private;
1353 struct drm_radeon_master_private *master_priv = master->driver_priv;
1354 drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
1355 int nbox = sarea_priv->nbox;
1356 struct drm_clip_rect *pbox = sarea_priv->boxes;
1361 /* Do some trivial performance monitoring...
1363 if (dev_priv->do_boxes)
1364 radeon_cp_performance_boxes(dev_priv, master_priv);
1366 /* Wait for the 3D stream to idle before dispatching the bitblt.
1367 * This will prevent data corruption between the two streams.
1371 RADEON_WAIT_UNTIL_3D_IDLE();
1375 for (i = 0; i < nbox; i++) {
1378 int w = pbox[i].x2 - x;
1379 int h = pbox[i].y2 - y;
1381 DRM_DEBUG("%d,%d-%d,%d\n", x, y, w, h);
1385 OUT_RING(CP_PACKET0(RADEON_DP_GUI_MASTER_CNTL, 0));
1386 OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL |
1387 RADEON_GMC_DST_PITCH_OFFSET_CNTL |
1388 RADEON_GMC_BRUSH_NONE |
1389 (dev_priv->color_fmt << 8) |
1390 RADEON_GMC_SRC_DATATYPE_COLOR |
1392 RADEON_DP_SRC_SOURCE_MEMORY |
1393 RADEON_GMC_CLR_CMP_CNTL_DIS | RADEON_GMC_WR_MSK_DIS);
1395 /* Make this work even if front & back are flipped:
1397 OUT_RING(CP_PACKET0(RADEON_SRC_PITCH_OFFSET, 1));
1398 if (sarea_priv->pfCurrentPage == 0) {
1399 OUT_RING(dev_priv->back_pitch_offset);
1400 OUT_RING(dev_priv->front_pitch_offset);
1402 OUT_RING(dev_priv->front_pitch_offset);
1403 OUT_RING(dev_priv->back_pitch_offset);
1406 OUT_RING(CP_PACKET0(RADEON_SRC_X_Y, 2));
1407 OUT_RING((x << 16) | y);
1408 OUT_RING((x << 16) | y);
1409 OUT_RING((w << 16) | h);
1414 /* Increment the frame counter. The client-side 3D driver must
1415 * throttle the framerate by waiting for this value before
1416 * performing the swapbuffer ioctl.
1418 sarea_priv->last_frame++;
1422 RADEON_FRAME_AGE(sarea_priv->last_frame);
1423 RADEON_WAIT_UNTIL_2D_IDLE();
1428 void radeon_cp_dispatch_flip(struct drm_device * dev, struct drm_master *master)
1430 drm_radeon_private_t *dev_priv = dev->dev_private;
1431 struct drm_radeon_master_private *master_priv = master->driver_priv;
1432 struct drm_sarea *sarea = (struct drm_sarea *) master_priv->sarea->handle;
1433 int offset = (master_priv->sarea_priv->pfCurrentPage == 1)
1434 ? dev_priv->front_offset : dev_priv->back_offset;
1436 DRM_DEBUG("pfCurrentPage=%d\n",
1437 master_priv->sarea_priv->pfCurrentPage);
1439 /* Do some trivial performance monitoring...
1441 if (dev_priv->do_boxes) {
1442 dev_priv->stats.boxes |= RADEON_BOX_FLIP;
1443 radeon_cp_performance_boxes(dev_priv, master_priv);
1446 /* Update the frame offsets for both CRTCs
1450 RADEON_WAIT_UNTIL_3D_IDLE();
1451 OUT_RING_REG(RADEON_CRTC_OFFSET,
1452 ((sarea->frame.y * dev_priv->front_pitch +
1453 sarea->frame.x * (dev_priv->color_fmt - 2)) & ~7)
1455 OUT_RING_REG(RADEON_CRTC2_OFFSET, master_priv->sarea_priv->crtc2_base
1460 /* Increment the frame counter. The client-side 3D driver must
1461 * throttle the framerate by waiting for this value before
1462 * performing the swapbuffer ioctl.
1464 master_priv->sarea_priv->last_frame++;
1465 master_priv->sarea_priv->pfCurrentPage =
1466 1 - master_priv->sarea_priv->pfCurrentPage;
1470 RADEON_FRAME_AGE(master_priv->sarea_priv->last_frame);
1475 static int bad_prim_vertex_nr(int primitive, int nr)
1477 switch (primitive & RADEON_PRIM_TYPE_MASK) {
1478 case RADEON_PRIM_TYPE_NONE:
1479 case RADEON_PRIM_TYPE_POINT:
1481 case RADEON_PRIM_TYPE_LINE:
1482 return (nr & 1) || nr == 0;
1483 case RADEON_PRIM_TYPE_LINE_STRIP:
1485 case RADEON_PRIM_TYPE_TRI_LIST:
1486 case RADEON_PRIM_TYPE_3VRT_POINT_LIST:
1487 case RADEON_PRIM_TYPE_3VRT_LINE_LIST:
1488 case RADEON_PRIM_TYPE_RECT_LIST:
1489 return nr % 3 || nr == 0;
1490 case RADEON_PRIM_TYPE_TRI_FAN:
1491 case RADEON_PRIM_TYPE_TRI_STRIP:
1500 unsigned int finish;
1502 unsigned int numverts;
1503 unsigned int offset;
1504 unsigned int vc_format;
1505 } drm_radeon_tcl_prim_t;
1507 static void radeon_cp_dispatch_vertex(struct drm_device * dev,
1508 struct drm_file *file_priv,
1509 struct drm_buf * buf,
1510 drm_radeon_tcl_prim_t * prim)
1512 drm_radeon_private_t *dev_priv = dev->dev_private;
1513 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
1514 drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
1515 int offset = dev_priv->gart_buffers_offset + buf->offset + prim->start;
1516 int numverts = (int)prim->numverts;
1517 int nbox = sarea_priv->nbox;
1521 DRM_DEBUG("hwprim 0x%x vfmt 0x%x %d..%d %d verts\n",
1523 prim->vc_format, prim->start, prim->finish, prim->numverts);
1525 if (bad_prim_vertex_nr(prim->prim, prim->numverts)) {
1526 DRM_ERROR("bad prim %x numverts %d\n",
1527 prim->prim, prim->numverts);
1532 /* Emit the next cliprect */
1534 radeon_emit_clip_rect(dev_priv, &sarea_priv->boxes[i]);
1537 /* Emit the vertex buffer rendering commands */
1540 OUT_RING(CP_PACKET3(RADEON_3D_RNDR_GEN_INDX_PRIM, 3));
1543 OUT_RING(prim->vc_format);
1544 OUT_RING(prim->prim | RADEON_PRIM_WALK_LIST |
1545 RADEON_COLOR_ORDER_RGBA |
1546 RADEON_VTX_FMT_RADEON_MODE |
1547 (numverts << RADEON_NUM_VERTICES_SHIFT));
1555 static void radeon_cp_discard_buffer(struct drm_device * dev, struct drm_master *master, struct drm_buf * buf)
1557 drm_radeon_private_t *dev_priv = dev->dev_private;
1558 struct drm_radeon_master_private *master_priv = master->driver_priv;
1559 drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
1562 buf_priv->age = ++master_priv->sarea_priv->last_dispatch;
1564 /* Emit the vertex buffer age */
1566 RADEON_DISPATCH_AGE(buf_priv->age);
1573 static void radeon_cp_dispatch_indirect(struct drm_device * dev,
1574 struct drm_buf * buf, int start, int end)
1576 drm_radeon_private_t *dev_priv = dev->dev_private;
1578 DRM_DEBUG("buf=%d s=0x%x e=0x%x\n", buf->idx, start, end);
1581 int offset = (dev_priv->gart_buffers_offset
1582 + buf->offset + start);
1583 int dwords = (end - start + 3) / sizeof(u32);
1585 /* Indirect buffer data must be an even number of
1586 * dwords, so if we've been given an odd number we must
1587 * pad the data with a Type-2 CP packet.
1591 ((char *)dev->agp_buffer_map->handle
1592 + buf->offset + start);
1593 data[dwords++] = RADEON_CP_PACKET2;
1596 /* Fire off the indirect buffer */
1599 OUT_RING(CP_PACKET0(RADEON_CP_IB_BASE, 1));
1607 static void radeon_cp_dispatch_indices(struct drm_device *dev,
1608 struct drm_master *master,
1609 struct drm_buf * elt_buf,
1610 drm_radeon_tcl_prim_t * prim)
1612 drm_radeon_private_t *dev_priv = dev->dev_private;
1613 struct drm_radeon_master_private *master_priv = master->driver_priv;
1614 drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
1615 int offset = dev_priv->gart_buffers_offset + prim->offset;
1619 int start = prim->start + RADEON_INDEX_PRIM_OFFSET;
1620 int count = (prim->finish - start) / sizeof(u16);
1621 int nbox = sarea_priv->nbox;
1623 DRM_DEBUG("hwprim 0x%x vfmt 0x%x %d..%d offset: %x nr %d\n",
1626 prim->start, prim->finish, prim->offset, prim->numverts);
1628 if (bad_prim_vertex_nr(prim->prim, count)) {
1629 DRM_ERROR("bad prim %x count %d\n", prim->prim, count);
1633 if (start >= prim->finish || (prim->start & 0x7)) {
1634 DRM_ERROR("buffer prim %d\n", prim->prim);
1638 dwords = (prim->finish - prim->start + 3) / sizeof(u32);
1640 data = (u32 *) ((char *)dev->agp_buffer_map->handle +
1641 elt_buf->offset + prim->start);
1643 data[0] = CP_PACKET3(RADEON_3D_RNDR_GEN_INDX_PRIM, dwords - 2);
1645 data[2] = prim->numverts;
1646 data[3] = prim->vc_format;
1647 data[4] = (prim->prim |
1648 RADEON_PRIM_WALK_IND |
1649 RADEON_COLOR_ORDER_RGBA |
1650 RADEON_VTX_FMT_RADEON_MODE |
1651 (count << RADEON_NUM_VERTICES_SHIFT));
1655 radeon_emit_clip_rect(dev_priv, &sarea_priv->boxes[i]);
1657 radeon_cp_dispatch_indirect(dev, elt_buf,
1658 prim->start, prim->finish);
1665 #define RADEON_MAX_TEXTURE_SIZE RADEON_BUFFER_SIZE
1667 static int radeon_cp_dispatch_texture(struct drm_device * dev,
1668 struct drm_file *file_priv,
1669 drm_radeon_texture_t * tex,
1670 drm_radeon_tex_image_t * image)
1672 drm_radeon_private_t *dev_priv = dev->dev_private;
1673 struct drm_buf *buf;
1676 const u8 __user *data;
1677 int size, dwords, tex_width, blit_width, spitch;
1680 u32 texpitch, microtile;
1681 u32 offset, byte_offset;
1684 if (radeon_check_and_fixup_offset(dev_priv, file_priv, &tex->offset)) {
1685 DRM_ERROR("Invalid destination offset\n");
1689 dev_priv->stats.boxes |= RADEON_BOX_TEXTURE_LOAD;
1691 /* Flush the pixel cache. This ensures no pixel data gets mixed
1692 * up with the texture data from the host data blit, otherwise
1693 * part of the texture image may be corrupted.
1696 RADEON_FLUSH_CACHE();
1697 RADEON_WAIT_UNTIL_IDLE();
1700 /* The compiler won't optimize away a division by a variable,
1701 * even if the only legal values are powers of two. Thus, we'll
1702 * use a shift instead.
1704 switch (tex->format) {
1705 case RADEON_TXFORMAT_ARGB8888:
1706 case RADEON_TXFORMAT_RGBA8888:
1707 format = RADEON_COLOR_FORMAT_ARGB8888;
1708 tex_width = tex->width * 4;
1709 blit_width = image->width * 4;
1711 case RADEON_TXFORMAT_AI88:
1712 case RADEON_TXFORMAT_ARGB1555:
1713 case RADEON_TXFORMAT_RGB565:
1714 case RADEON_TXFORMAT_ARGB4444:
1715 case RADEON_TXFORMAT_VYUY422:
1716 case RADEON_TXFORMAT_YVYU422:
1717 format = RADEON_COLOR_FORMAT_RGB565;
1718 tex_width = tex->width * 2;
1719 blit_width = image->width * 2;
1721 case RADEON_TXFORMAT_I8:
1722 case RADEON_TXFORMAT_RGB332:
1723 format = RADEON_COLOR_FORMAT_CI8;
1724 tex_width = tex->width * 1;
1725 blit_width = image->width * 1;
1728 DRM_ERROR("invalid texture format %d\n", tex->format);
1731 spitch = blit_width >> 6;
1732 if (spitch == 0 && image->height > 1)
1735 texpitch = tex->pitch;
1736 if ((texpitch << 22) & RADEON_DST_TILE_MICRO) {
1738 if (tex_width < 64) {
1739 texpitch &= ~(RADEON_DST_TILE_MICRO >> 22);
1740 /* we got tiled coordinates, untile them */
1746 /* this might fail for zero-sized uploads - are those illegal? */
1747 if (!radeon_check_offset(dev_priv, tex->offset + image->height *
1749 DRM_ERROR("Invalid final destination offset\n");
1753 DRM_DEBUG("tex=%dx%d blit=%d\n", tex_width, tex->height, blit_width);
1756 DRM_DEBUG("tex: ofs=0x%x p=%d f=%d x=%hd y=%hd w=%hd h=%hd\n",
1757 tex->offset >> 10, tex->pitch, tex->format,
1758 image->x, image->y, image->width, image->height);
1760 /* Make a copy of some parameters in case we have to
1761 * update them for a multi-pass texture blit.
1763 height = image->height;
1764 data = (const u8 __user *)image->data;
1766 size = height * blit_width;
1768 if (size > RADEON_MAX_TEXTURE_SIZE) {
1769 height = RADEON_MAX_TEXTURE_SIZE / blit_width;
1770 size = height * blit_width;
1771 } else if (size < 4 && size > 0) {
1773 } else if (size == 0) {
1777 buf = radeon_freelist_get(dev);
1779 radeon_do_cp_idle(dev_priv);
1780 buf = radeon_freelist_get(dev);
1783 DRM_DEBUG("EAGAIN\n");
1784 if (DRM_COPY_TO_USER(tex->image, image, sizeof(*image)))
1789 /* Dispatch the indirect buffer.
1792 (u32 *) ((char *)dev->agp_buffer_map->handle + buf->offset);
1795 #define RADEON_COPY_MT(_buf, _data, _width) \
1797 if (DRM_COPY_FROM_USER(_buf, _data, (_width))) {\
1798 DRM_ERROR("EFAULT on pad, %d bytes\n", (_width)); \
1804 /* texture micro tiling in use, minimum texture width is thus 16 bytes.
1805 however, we cannot use blitter directly for texture width < 64 bytes,
1806 since minimum tex pitch is 64 bytes and we need this to match
1807 the texture width, otherwise the blitter will tile it wrong.
1808 Thus, tiling manually in this case. Additionally, need to special
1809 case tex height = 1, since our actual image will have height 2
1810 and we need to ensure we don't read beyond the texture size
1812 if (tex->height == 1) {
1813 if (tex_width >= 64 || tex_width <= 16) {
1814 RADEON_COPY_MT(buffer, data,
1815 (int)(tex_width * sizeof(u32)));
1816 } else if (tex_width == 32) {
1817 RADEON_COPY_MT(buffer, data, 16);
1818 RADEON_COPY_MT(buffer + 8,
1821 } else if (tex_width >= 64 || tex_width == 16) {
1822 RADEON_COPY_MT(buffer, data,
1823 (int)(dwords * sizeof(u32)));
1824 } else if (tex_width < 16) {
1825 for (i = 0; i < tex->height; i++) {
1826 RADEON_COPY_MT(buffer, data, tex_width);
1830 } else if (tex_width == 32) {
1831 /* TODO: make sure this works when not fitting in one buffer
1832 (i.e. 32bytes x 2048...) */
1833 for (i = 0; i < tex->height; i += 2) {
1834 RADEON_COPY_MT(buffer, data, 16);
1836 RADEON_COPY_MT(buffer + 8, data, 16);
1838 RADEON_COPY_MT(buffer + 4, data, 16);
1840 RADEON_COPY_MT(buffer + 12, data, 16);
1846 if (tex_width >= 32) {
1847 /* Texture image width is larger than the minimum, so we
1848 * can upload it directly.
1850 RADEON_COPY_MT(buffer, data,
1851 (int)(dwords * sizeof(u32)));
1853 /* Texture image width is less than the minimum, so we
1854 * need to pad out each image scanline to the minimum
1857 for (i = 0; i < tex->height; i++) {
1858 RADEON_COPY_MT(buffer, data, tex_width);
1865 #undef RADEON_COPY_MT
1866 byte_offset = (image->y & ~2047) * blit_width;
1867 buf->file_priv = file_priv;
1869 offset = dev_priv->gart_buffers_offset + buf->offset;
1871 OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT_MULTI, 5));
1872 OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL |
1873 RADEON_GMC_DST_PITCH_OFFSET_CNTL |
1874 RADEON_GMC_BRUSH_NONE |
1876 RADEON_GMC_SRC_DATATYPE_COLOR |
1878 RADEON_DP_SRC_SOURCE_MEMORY |
1879 RADEON_GMC_CLR_CMP_CNTL_DIS | RADEON_GMC_WR_MSK_DIS);
1880 OUT_RING((spitch << 22) | (offset >> 10));
1881 OUT_RING((texpitch << 22) | ((tex->offset >> 10) + (byte_offset >> 10)));
1883 OUT_RING((image->x << 16) | (image->y % 2048));
1884 OUT_RING((image->width << 16) | height);
1885 RADEON_WAIT_UNTIL_2D_IDLE();
1889 radeon_cp_discard_buffer(dev, file_priv->master, buf);
1891 /* Update the input parameters for next time */
1893 image->height -= height;
1894 image->data = (const u8 __user *)image->data + size;
1895 } while (image->height > 0);
1897 /* Flush the pixel cache after the blit completes. This ensures
1898 * the texture data is written out to memory before rendering
1902 RADEON_FLUSH_CACHE();
1903 RADEON_WAIT_UNTIL_2D_IDLE();
1910 static void radeon_cp_dispatch_stipple(struct drm_device * dev, u32 * stipple)
1912 drm_radeon_private_t *dev_priv = dev->dev_private;
1919 OUT_RING(CP_PACKET0(RADEON_RE_STIPPLE_ADDR, 0));
1920 OUT_RING(0x00000000);
1922 OUT_RING(CP_PACKET0_TABLE(RADEON_RE_STIPPLE_DATA, 31));
1923 for (i = 0; i < 32; i++) {
1924 OUT_RING(stipple[i]);
1930 static void radeon_apply_surface_regs(int surf_index,
1931 drm_radeon_private_t *dev_priv)
1933 if (!dev_priv->mmio)
1936 radeon_do_cp_idle(dev_priv);
1938 RADEON_WRITE(RADEON_SURFACE0_INFO + 16 * surf_index,
1939 dev_priv->surfaces[surf_index].flags);
1940 RADEON_WRITE(RADEON_SURFACE0_LOWER_BOUND + 16 * surf_index,
1941 dev_priv->surfaces[surf_index].lower);
1942 RADEON_WRITE(RADEON_SURFACE0_UPPER_BOUND + 16 * surf_index,
1943 dev_priv->surfaces[surf_index].upper);
1946 /* Allocates a virtual surface
1947 * doesn't always allocate a real surface, will stretch an existing
1948 * surface when possible.
1950 * Note that refcount can be at most 2, since during a free refcount=3
1951 * might mean we have to allocate a new surface which might not always
1953 * For example : we allocate three contigous surfaces ABC. If B is
1954 * freed, we suddenly need two surfaces to store A and C, which might
1955 * not always be available.
1957 static int alloc_surface(drm_radeon_surface_alloc_t *new,
1958 drm_radeon_private_t *dev_priv,
1959 struct drm_file *file_priv)
1961 struct radeon_virt_surface *s;
1963 int virt_surface_index;
1964 uint32_t new_upper, new_lower;
1966 new_lower = new->address;
1967 new_upper = new_lower + new->size - 1;
1970 if ((new_lower >= new_upper) || (new->flags == 0) || (new->size == 0) ||
1971 ((new_upper & RADEON_SURF_ADDRESS_FIXED_MASK) !=
1972 RADEON_SURF_ADDRESS_FIXED_MASK)
1973 || ((new_lower & RADEON_SURF_ADDRESS_FIXED_MASK) != 0))
1976 /* make sure there is no overlap with existing surfaces */
1977 for (i = 0; i < RADEON_MAX_SURFACES; i++) {
1978 if ((dev_priv->surfaces[i].refcount != 0) &&
1979 (((new_lower >= dev_priv->surfaces[i].lower) &&
1980 (new_lower < dev_priv->surfaces[i].upper)) ||
1981 ((new_lower < dev_priv->surfaces[i].lower) &&
1982 (new_upper > dev_priv->surfaces[i].lower)))) {
1987 /* find a virtual surface */
1988 for (i = 0; i < 2 * RADEON_MAX_SURFACES; i++)
1989 if (dev_priv->virt_surfaces[i].file_priv == 0)
1991 if (i == 2 * RADEON_MAX_SURFACES) {
1994 virt_surface_index = i;
1996 /* try to reuse an existing surface */
1997 for (i = 0; i < RADEON_MAX_SURFACES; i++) {
1999 if ((dev_priv->surfaces[i].refcount == 1) &&
2000 (new->flags == dev_priv->surfaces[i].flags) &&
2001 (new_upper + 1 == dev_priv->surfaces[i].lower)) {
2002 s = &(dev_priv->virt_surfaces[virt_surface_index]);
2003 s->surface_index = i;
2004 s->lower = new_lower;
2005 s->upper = new_upper;
2006 s->flags = new->flags;
2007 s->file_priv = file_priv;
2008 dev_priv->surfaces[i].refcount++;
2009 dev_priv->surfaces[i].lower = s->lower;
2010 radeon_apply_surface_regs(s->surface_index, dev_priv);
2011 return virt_surface_index;
2015 if ((dev_priv->surfaces[i].refcount == 1) &&
2016 (new->flags == dev_priv->surfaces[i].flags) &&
2017 (new_lower == dev_priv->surfaces[i].upper + 1)) {
2018 s = &(dev_priv->virt_surfaces[virt_surface_index]);
2019 s->surface_index = i;
2020 s->lower = new_lower;
2021 s->upper = new_upper;
2022 s->flags = new->flags;
2023 s->file_priv = file_priv;
2024 dev_priv->surfaces[i].refcount++;
2025 dev_priv->surfaces[i].upper = s->upper;
2026 radeon_apply_surface_regs(s->surface_index, dev_priv);
2027 return virt_surface_index;
2031 /* okay, we need a new one */
2032 for (i = 0; i < RADEON_MAX_SURFACES; i++) {
2033 if (dev_priv->surfaces[i].refcount == 0) {
2034 s = &(dev_priv->virt_surfaces[virt_surface_index]);
2035 s->surface_index = i;
2036 s->lower = new_lower;
2037 s->upper = new_upper;
2038 s->flags = new->flags;
2039 s->file_priv = file_priv;
2040 dev_priv->surfaces[i].refcount = 1;
2041 dev_priv->surfaces[i].lower = s->lower;
2042 dev_priv->surfaces[i].upper = s->upper;
2043 dev_priv->surfaces[i].flags = s->flags;
2044 radeon_apply_surface_regs(s->surface_index, dev_priv);
2045 return virt_surface_index;
2049 /* we didn't find anything */
2053 static int free_surface(struct drm_file *file_priv,
2054 drm_radeon_private_t * dev_priv,
2057 struct radeon_virt_surface *s;
2059 /* find the virtual surface */
2060 for (i = 0; i < 2 * RADEON_MAX_SURFACES; i++) {
2061 s = &(dev_priv->virt_surfaces[i]);
2063 if ((lower == s->lower) && (file_priv == s->file_priv))
2065 if (dev_priv->surfaces[s->surface_index].
2067 dev_priv->surfaces[s->surface_index].
2070 if (dev_priv->surfaces[s->surface_index].
2072 dev_priv->surfaces[s->surface_index].
2075 dev_priv->surfaces[s->surface_index].refcount--;
2076 if (dev_priv->surfaces[s->surface_index].
2078 dev_priv->surfaces[s->surface_index].
2080 s->file_priv = NULL;
2081 radeon_apply_surface_regs(s->surface_index,
2090 static void radeon_surfaces_release(struct drm_file *file_priv,
2091 drm_radeon_private_t * dev_priv)
2094 for (i = 0; i < 2 * RADEON_MAX_SURFACES; i++) {
2095 if (dev_priv->virt_surfaces[i].file_priv == file_priv)
2096 free_surface(file_priv, dev_priv,
2097 dev_priv->virt_surfaces[i].lower);
2101 /* ================================================================
2104 static int radeon_surface_alloc(struct drm_device *dev, void *data, struct drm_file *file_priv)
2106 drm_radeon_private_t *dev_priv = dev->dev_private;
2107 drm_radeon_surface_alloc_t *alloc = data;
2110 DRM_ERROR("called with no initialization\n");
2114 if (alloc_surface(alloc, dev_priv, file_priv) == -1)
2120 static int radeon_surface_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
2122 drm_radeon_private_t *dev_priv = dev->dev_private;
2123 drm_radeon_surface_free_t *memfree = data;
2126 DRM_ERROR("called with no initialization\n");
2130 if (free_surface(file_priv, dev_priv, memfree->address))
2136 static int radeon_cp_clear(struct drm_device *dev, void *data, struct drm_file *file_priv)
2138 drm_radeon_private_t *dev_priv = dev->dev_private;
2139 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
2140 drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
2141 drm_radeon_clear_t *clear = data;
2142 drm_radeon_clear_rect_t depth_boxes[RADEON_NR_SAREA_CLIPRECTS];
2145 LOCK_TEST_WITH_RETURN(dev, file_priv);
2147 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2149 if (sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS)
2150 sarea_priv->nbox = RADEON_NR_SAREA_CLIPRECTS;
2152 if (DRM_COPY_FROM_USER(&depth_boxes, clear->depth_boxes,
2153 sarea_priv->nbox * sizeof(depth_boxes[0])))
2156 radeon_cp_dispatch_clear(dev, file_priv->master, clear, depth_boxes);
2162 /* Not sure why this isn't set all the time:
2164 static int radeon_do_init_pageflip(struct drm_device * dev, struct drm_master *master)
2166 drm_radeon_private_t *dev_priv = dev->dev_private;
2167 struct drm_radeon_master_private *master_priv = master->driver_priv;
2173 RADEON_WAIT_UNTIL_3D_IDLE();
2174 OUT_RING(CP_PACKET0(RADEON_CRTC_OFFSET_CNTL, 0));
2175 OUT_RING(RADEON_READ(RADEON_CRTC_OFFSET_CNTL) |
2176 RADEON_CRTC_OFFSET_FLIP_CNTL);
2177 OUT_RING(CP_PACKET0(RADEON_CRTC2_OFFSET_CNTL, 0));
2178 OUT_RING(RADEON_READ(RADEON_CRTC2_OFFSET_CNTL) |
2179 RADEON_CRTC_OFFSET_FLIP_CNTL);
2182 dev_priv->page_flipping = 1;
2184 if (master_priv->sarea_priv->pfCurrentPage != 1)
2185 master_priv->sarea_priv->pfCurrentPage = 0;
2190 /* Swapping and flipping are different operations, need different ioctls.
2191 * They can & should be intermixed to support multiple 3d windows.
2193 static int radeon_cp_flip(struct drm_device *dev, void *data, struct drm_file *file_priv)
2195 drm_radeon_private_t *dev_priv = dev->dev_private;
2198 LOCK_TEST_WITH_RETURN(dev, file_priv);
2200 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2202 if (!dev_priv->page_flipping)
2203 radeon_do_init_pageflip(dev, file_priv->master);
2205 radeon_cp_dispatch_flip(dev, file_priv->master);
2211 static int radeon_cp_swap(struct drm_device *dev, void *data, struct drm_file *file_priv)
2213 drm_radeon_private_t *dev_priv = dev->dev_private;
2214 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
2215 drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
2219 LOCK_TEST_WITH_RETURN(dev, file_priv);
2221 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2223 if (sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS)
2224 sarea_priv->nbox = RADEON_NR_SAREA_CLIPRECTS;
2226 radeon_cp_dispatch_swap(dev, file_priv->master);
2227 sarea_priv->ctx_owner = 0;
2233 static int radeon_cp_vertex(struct drm_device *dev, void *data, struct drm_file *file_priv)
2235 drm_radeon_private_t *dev_priv = dev->dev_private;
2236 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
2237 drm_radeon_sarea_t *sarea_priv;
2238 struct drm_device_dma *dma = dev->dma;
2239 struct drm_buf *buf;
2240 drm_radeon_vertex_t *vertex = data;
2241 drm_radeon_tcl_prim_t prim;
2243 LOCK_TEST_WITH_RETURN(dev, file_priv);
2246 DRM_ERROR("called with no initialization\n");
2250 sarea_priv = master_priv->sarea_priv;
2252 DRM_DEBUG("pid=%d index=%d count=%d discard=%d\n",
2253 DRM_CURRENTPID, vertex->idx, vertex->count, vertex->discard);
2255 if (vertex->idx < 0 || vertex->idx >= dma->buf_count) {
2256 DRM_ERROR("buffer index %d (of %d max)\n",
2257 vertex->idx, dma->buf_count - 1);
2260 if (vertex->prim < 0 || vertex->prim > RADEON_PRIM_TYPE_3VRT_LINE_LIST) {
2261 DRM_ERROR("buffer prim %d\n", vertex->prim);
2265 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2266 VB_AGE_TEST_WITH_RETURN(dev_priv);
2268 buf = dma->buflist[vertex->idx];
2270 if (buf->file_priv != file_priv) {
2271 DRM_ERROR("process %d using buffer owned by %p\n",
2272 DRM_CURRENTPID, buf->file_priv);
2276 DRM_ERROR("sending pending buffer %d\n", vertex->idx);
2280 /* Build up a prim_t record:
2282 if (vertex->count) {
2283 buf->used = vertex->count; /* not used? */
2285 if (sarea_priv->dirty & ~RADEON_UPLOAD_CLIPRECTS) {
2286 if (radeon_emit_state(dev_priv, file_priv,
2287 &sarea_priv->context_state,
2288 sarea_priv->tex_state,
2289 sarea_priv->dirty)) {
2290 DRM_ERROR("radeon_emit_state failed\n");
2294 sarea_priv->dirty &= ~(RADEON_UPLOAD_TEX0IMAGES |
2295 RADEON_UPLOAD_TEX1IMAGES |
2296 RADEON_UPLOAD_TEX2IMAGES |
2297 RADEON_REQUIRE_QUIESCENCE);
2301 prim.finish = vertex->count; /* unused */
2302 prim.prim = vertex->prim;
2303 prim.numverts = vertex->count;
2304 prim.vc_format = sarea_priv->vc_format;
2306 radeon_cp_dispatch_vertex(dev, file_priv, buf, &prim);
2309 if (vertex->discard) {
2310 radeon_cp_discard_buffer(dev, file_priv->master, buf);
2317 static int radeon_cp_indices(struct drm_device *dev, void *data, struct drm_file *file_priv)
2319 drm_radeon_private_t *dev_priv = dev->dev_private;
2320 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
2321 drm_radeon_sarea_t *sarea_priv;
2322 struct drm_device_dma *dma = dev->dma;
2323 struct drm_buf *buf;
2324 drm_radeon_indices_t *elts = data;
2325 drm_radeon_tcl_prim_t prim;
2328 LOCK_TEST_WITH_RETURN(dev, file_priv);
2331 DRM_ERROR("called with no initialization\n");
2334 sarea_priv = master_priv->sarea_priv;
2336 DRM_DEBUG("pid=%d index=%d start=%d end=%d discard=%d\n",
2337 DRM_CURRENTPID, elts->idx, elts->start, elts->end,
2340 if (elts->idx < 0 || elts->idx >= dma->buf_count) {
2341 DRM_ERROR("buffer index %d (of %d max)\n",
2342 elts->idx, dma->buf_count - 1);
2345 if (elts->prim < 0 || elts->prim > RADEON_PRIM_TYPE_3VRT_LINE_LIST) {
2346 DRM_ERROR("buffer prim %d\n", elts->prim);
2350 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2351 VB_AGE_TEST_WITH_RETURN(dev_priv);
2353 buf = dma->buflist[elts->idx];
2355 if (buf->file_priv != file_priv) {
2356 DRM_ERROR("process %d using buffer owned by %p\n",
2357 DRM_CURRENTPID, buf->file_priv);
2361 DRM_ERROR("sending pending buffer %d\n", elts->idx);
2365 count = (elts->end - elts->start) / sizeof(u16);
2366 elts->start -= RADEON_INDEX_PRIM_OFFSET;
2368 if (elts->start & 0x7) {
2369 DRM_ERROR("misaligned buffer 0x%x\n", elts->start);
2372 if (elts->start < buf->used) {
2373 DRM_ERROR("no header 0x%x - 0x%x\n", elts->start, buf->used);
2377 buf->used = elts->end;
2379 if (sarea_priv->dirty & ~RADEON_UPLOAD_CLIPRECTS) {
2380 if (radeon_emit_state(dev_priv, file_priv,
2381 &sarea_priv->context_state,
2382 sarea_priv->tex_state,
2383 sarea_priv->dirty)) {
2384 DRM_ERROR("radeon_emit_state failed\n");
2388 sarea_priv->dirty &= ~(RADEON_UPLOAD_TEX0IMAGES |
2389 RADEON_UPLOAD_TEX1IMAGES |
2390 RADEON_UPLOAD_TEX2IMAGES |
2391 RADEON_REQUIRE_QUIESCENCE);
2394 /* Build up a prim_t record:
2396 prim.start = elts->start;
2397 prim.finish = elts->end;
2398 prim.prim = elts->prim;
2399 prim.offset = 0; /* offset from start of dma buffers */
2400 prim.numverts = RADEON_MAX_VB_VERTS; /* duh */
2401 prim.vc_format = sarea_priv->vc_format;
2403 radeon_cp_dispatch_indices(dev, file_priv->master, buf, &prim);
2404 if (elts->discard) {
2405 radeon_cp_discard_buffer(dev, file_priv->master, buf);
2412 static int radeon_cp_texture(struct drm_device *dev, void *data, struct drm_file *file_priv)
2414 drm_radeon_private_t *dev_priv = dev->dev_private;
2415 drm_radeon_texture_t *tex = data;
2416 drm_radeon_tex_image_t image;
2419 LOCK_TEST_WITH_RETURN(dev, file_priv);
2421 if (tex->image == NULL) {
2422 DRM_ERROR("null texture image!\n");
2426 if (DRM_COPY_FROM_USER(&image,
2427 (drm_radeon_tex_image_t __user *) tex->image,
2431 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2432 VB_AGE_TEST_WITH_RETURN(dev_priv);
2434 ret = radeon_cp_dispatch_texture(dev, file_priv, tex, &image);
2439 static int radeon_cp_stipple(struct drm_device *dev, void *data, struct drm_file *file_priv)
2441 drm_radeon_private_t *dev_priv = dev->dev_private;
2442 drm_radeon_stipple_t *stipple = data;
2445 LOCK_TEST_WITH_RETURN(dev, file_priv);
2447 if (DRM_COPY_FROM_USER(&mask, stipple->mask, 32 * sizeof(u32)))
2450 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2452 radeon_cp_dispatch_stipple(dev, mask);
2458 static int radeon_cp_indirect(struct drm_device *dev, void *data, struct drm_file *file_priv)
2460 drm_radeon_private_t *dev_priv = dev->dev_private;
2461 struct drm_device_dma *dma = dev->dma;
2462 struct drm_buf *buf;
2463 drm_radeon_indirect_t *indirect = data;
2466 LOCK_TEST_WITH_RETURN(dev, file_priv);
2469 DRM_ERROR("called with no initialization\n");
2473 DRM_DEBUG("idx=%d s=%d e=%d d=%d\n",
2474 indirect->idx, indirect->start, indirect->end,
2477 if (indirect->idx < 0 || indirect->idx >= dma->buf_count) {
2478 DRM_ERROR("buffer index %d (of %d max)\n",
2479 indirect->idx, dma->buf_count - 1);
2483 buf = dma->buflist[indirect->idx];
2485 if (buf->file_priv != file_priv) {
2486 DRM_ERROR("process %d using buffer owned by %p\n",
2487 DRM_CURRENTPID, buf->file_priv);
2491 DRM_ERROR("sending pending buffer %d\n", indirect->idx);
2495 if (indirect->start < buf->used) {
2496 DRM_ERROR("reusing indirect: start=0x%x actual=0x%x\n",
2497 indirect->start, buf->used);
2501 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2502 VB_AGE_TEST_WITH_RETURN(dev_priv);
2504 buf->used = indirect->end;
2506 /* Wait for the 3D stream to idle before the indirect buffer
2507 * containing 2D acceleration commands is processed.
2511 RADEON_WAIT_UNTIL_3D_IDLE();
2515 /* Dispatch the indirect buffer full of commands from the
2516 * X server. This is insecure and is thus only available to
2517 * privileged clients.
2519 radeon_cp_dispatch_indirect(dev, buf, indirect->start, indirect->end);
2520 if (indirect->discard) {
2521 radeon_cp_discard_buffer(dev, file_priv->master, buf);
2528 static int radeon_cp_vertex2(struct drm_device *dev, void *data, struct drm_file *file_priv)
2530 drm_radeon_private_t *dev_priv = dev->dev_private;
2531 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
2532 drm_radeon_sarea_t *sarea_priv;
2533 struct drm_device_dma *dma = dev->dma;
2534 struct drm_buf *buf;
2535 drm_radeon_vertex2_t *vertex = data;
2537 unsigned char laststate;
2539 LOCK_TEST_WITH_RETURN(dev, file_priv);
2542 DRM_ERROR("called with no initialization\n");
2546 sarea_priv = master_priv->sarea_priv;
2548 DRM_DEBUG("pid=%d index=%d discard=%d\n",
2549 DRM_CURRENTPID, vertex->idx, vertex->discard);
2551 if (vertex->idx < 0 || vertex->idx >= dma->buf_count) {
2552 DRM_ERROR("buffer index %d (of %d max)\n",
2553 vertex->idx, dma->buf_count - 1);
2557 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2558 VB_AGE_TEST_WITH_RETURN(dev_priv);
2560 buf = dma->buflist[vertex->idx];
2562 if (buf->file_priv != file_priv) {
2563 DRM_ERROR("process %d using buffer owned by %p\n",
2564 DRM_CURRENTPID, buf->file_priv);
2569 DRM_ERROR("sending pending buffer %d\n", vertex->idx);
2573 if (sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS)
2576 for (laststate = 0xff, i = 0; i < vertex->nr_prims; i++) {
2577 drm_radeon_prim_t prim;
2578 drm_radeon_tcl_prim_t tclprim;
2580 if (DRM_COPY_FROM_USER(&prim, &vertex->prim[i], sizeof(prim)))
2583 if (prim.stateidx != laststate) {
2584 drm_radeon_state_t state;
2586 if (DRM_COPY_FROM_USER(&state,
2587 &vertex->state[prim.stateidx],
2591 if (radeon_emit_state2(dev_priv, file_priv, &state)) {
2592 DRM_ERROR("radeon_emit_state2 failed\n");
2596 laststate = prim.stateidx;
2599 tclprim.start = prim.start;
2600 tclprim.finish = prim.finish;
2601 tclprim.prim = prim.prim;
2602 tclprim.vc_format = prim.vc_format;
2604 if (prim.prim & RADEON_PRIM_WALK_IND) {
2605 tclprim.offset = prim.numverts * 64;
2606 tclprim.numverts = RADEON_MAX_VB_VERTS; /* duh */
2608 radeon_cp_dispatch_indices(dev, file_priv->master, buf, &tclprim);
2610 tclprim.numverts = prim.numverts;
2611 tclprim.offset = 0; /* not used */
2613 radeon_cp_dispatch_vertex(dev, file_priv, buf, &tclprim);
2616 if (sarea_priv->nbox == 1)
2617 sarea_priv->nbox = 0;
2620 if (vertex->discard) {
2621 radeon_cp_discard_buffer(dev, file_priv->master, buf);
2628 static int radeon_emit_packets(drm_radeon_private_t * dev_priv,
2629 struct drm_file *file_priv,
2630 drm_radeon_cmd_header_t header,
2631 drm_radeon_kcmd_buffer_t *cmdbuf)
2633 int id = (int)header.packet.packet_id;
2635 int *data = (int *)cmdbuf->buf;
2638 if (id >= RADEON_MAX_STATE_PACKETS)
2641 sz = packet[id].len;
2642 reg = packet[id].start;
2644 if (sz * sizeof(int) > cmdbuf->bufsz) {
2645 DRM_ERROR("Packet size provided larger than data provided\n");
2649 if (radeon_check_and_fixup_packets(dev_priv, file_priv, id, data)) {
2650 DRM_ERROR("Packet verification failed\n");
2655 OUT_RING(CP_PACKET0(reg, (sz - 1)));
2656 OUT_RING_TABLE(data, sz);
2659 cmdbuf->buf += sz * sizeof(int);
2660 cmdbuf->bufsz -= sz * sizeof(int);
2664 static __inline__ int radeon_emit_scalars(drm_radeon_private_t *dev_priv,
2665 drm_radeon_cmd_header_t header,
2666 drm_radeon_kcmd_buffer_t *cmdbuf)
2668 int sz = header.scalars.count;
2669 int start = header.scalars.offset;
2670 int stride = header.scalars.stride;
2674 OUT_RING(CP_PACKET0(RADEON_SE_TCL_SCALAR_INDX_REG, 0));
2675 OUT_RING(start | (stride << RADEON_SCAL_INDX_DWORD_STRIDE_SHIFT));
2676 OUT_RING(CP_PACKET0_TABLE(RADEON_SE_TCL_SCALAR_DATA_REG, sz - 1));
2677 OUT_RING_TABLE(cmdbuf->buf, sz);
2679 cmdbuf->buf += sz * sizeof(int);
2680 cmdbuf->bufsz -= sz * sizeof(int);
2686 static __inline__ int radeon_emit_scalars2(drm_radeon_private_t *dev_priv,
2687 drm_radeon_cmd_header_t header,
2688 drm_radeon_kcmd_buffer_t *cmdbuf)
2690 int sz = header.scalars.count;
2691 int start = ((unsigned int)header.scalars.offset) + 0x100;
2692 int stride = header.scalars.stride;
2696 OUT_RING(CP_PACKET0(RADEON_SE_TCL_SCALAR_INDX_REG, 0));
2697 OUT_RING(start | (stride << RADEON_SCAL_INDX_DWORD_STRIDE_SHIFT));
2698 OUT_RING(CP_PACKET0_TABLE(RADEON_SE_TCL_SCALAR_DATA_REG, sz - 1));
2699 OUT_RING_TABLE(cmdbuf->buf, sz);
2701 cmdbuf->buf += sz * sizeof(int);
2702 cmdbuf->bufsz -= sz * sizeof(int);
2706 static __inline__ int radeon_emit_vectors(drm_radeon_private_t *dev_priv,
2707 drm_radeon_cmd_header_t header,
2708 drm_radeon_kcmd_buffer_t *cmdbuf)
2710 int sz = header.vectors.count;
2711 int start = header.vectors.offset;
2712 int stride = header.vectors.stride;
2716 OUT_RING_REG(RADEON_SE_TCL_STATE_FLUSH, 0);
2717 OUT_RING(CP_PACKET0(RADEON_SE_TCL_VECTOR_INDX_REG, 0));
2718 OUT_RING(start | (stride << RADEON_VEC_INDX_OCTWORD_STRIDE_SHIFT));
2719 OUT_RING(CP_PACKET0_TABLE(RADEON_SE_TCL_VECTOR_DATA_REG, (sz - 1)));
2720 OUT_RING_TABLE(cmdbuf->buf, sz);
2723 cmdbuf->buf += sz * sizeof(int);
2724 cmdbuf->bufsz -= sz * sizeof(int);
2728 static __inline__ int radeon_emit_veclinear(drm_radeon_private_t *dev_priv,
2729 drm_radeon_cmd_header_t header,
2730 drm_radeon_kcmd_buffer_t *cmdbuf)
2732 int sz = header.veclinear.count * 4;
2733 int start = header.veclinear.addr_lo | (header.veclinear.addr_hi << 8);
2738 if (sz * 4 > cmdbuf->bufsz)
2742 OUT_RING_REG(RADEON_SE_TCL_STATE_FLUSH, 0);
2743 OUT_RING(CP_PACKET0(RADEON_SE_TCL_VECTOR_INDX_REG, 0));
2744 OUT_RING(start | (1 << RADEON_VEC_INDX_OCTWORD_STRIDE_SHIFT));
2745 OUT_RING(CP_PACKET0_TABLE(RADEON_SE_TCL_VECTOR_DATA_REG, (sz - 1)));
2746 OUT_RING_TABLE(cmdbuf->buf, sz);
2749 cmdbuf->buf += sz * sizeof(int);
2750 cmdbuf->bufsz -= sz * sizeof(int);
2754 static int radeon_emit_packet3(struct drm_device * dev,
2755 struct drm_file *file_priv,
2756 drm_radeon_kcmd_buffer_t *cmdbuf)
2758 drm_radeon_private_t *dev_priv = dev->dev_private;
2765 if ((ret = radeon_check_and_fixup_packet3(dev_priv, file_priv,
2767 DRM_ERROR("Packet verification failed\n");
2772 OUT_RING_TABLE(cmdbuf->buf, cmdsz);
2775 cmdbuf->buf += cmdsz * 4;
2776 cmdbuf->bufsz -= cmdsz * 4;
2780 static int radeon_emit_packet3_cliprect(struct drm_device *dev,
2781 struct drm_file *file_priv,
2782 drm_radeon_kcmd_buffer_t *cmdbuf,
2785 drm_radeon_private_t *dev_priv = dev->dev_private;
2786 struct drm_clip_rect box;
2789 struct drm_clip_rect __user *boxes = cmdbuf->boxes;
2795 if ((ret = radeon_check_and_fixup_packet3(dev_priv, file_priv,
2797 DRM_ERROR("Packet verification failed\n");
2805 if (i < cmdbuf->nbox) {
2806 if (DRM_COPY_FROM_USER(&box, &boxes[i], sizeof(box)))
2808 /* FIXME The second and subsequent times round
2809 * this loop, send a WAIT_UNTIL_3D_IDLE before
2810 * calling emit_clip_rect(). This fixes a
2811 * lockup on fast machines when sending
2812 * several cliprects with a cmdbuf, as when
2813 * waving a 2D window over a 3D
2814 * window. Something in the commands from user
2815 * space seems to hang the card when they're
2816 * sent several times in a row. That would be
2817 * the correct place to fix it but this works
2818 * around it until I can figure that out - Tim
2822 RADEON_WAIT_UNTIL_3D_IDLE();
2825 radeon_emit_clip_rect(dev_priv, &box);
2829 OUT_RING_TABLE(cmdbuf->buf, cmdsz);
2832 } while (++i < cmdbuf->nbox);
2833 if (cmdbuf->nbox == 1)
2837 cmdbuf->buf += cmdsz * 4;
2838 cmdbuf->bufsz -= cmdsz * 4;
2842 static int radeon_emit_wait(struct drm_device * dev, int flags)
2844 drm_radeon_private_t *dev_priv = dev->dev_private;
2847 DRM_DEBUG("%x\n", flags);
2849 case RADEON_WAIT_2D:
2851 RADEON_WAIT_UNTIL_2D_IDLE();
2854 case RADEON_WAIT_3D:
2856 RADEON_WAIT_UNTIL_3D_IDLE();
2859 case RADEON_WAIT_2D | RADEON_WAIT_3D:
2861 RADEON_WAIT_UNTIL_IDLE();
2871 static int radeon_cp_cmdbuf(struct drm_device *dev, void *data, struct drm_file *file_priv)
2873 drm_radeon_private_t *dev_priv = dev->dev_private;
2874 struct drm_device_dma *dma = dev->dma;
2875 struct drm_buf *buf = NULL;
2877 drm_radeon_kcmd_buffer_t *cmdbuf = data;
2878 drm_radeon_cmd_header_t header;
2879 int orig_nbox, orig_bufsz;
2882 LOCK_TEST_WITH_RETURN(dev, file_priv);
2885 DRM_ERROR("called with no initialization\n");
2889 RING_SPACE_TEST_WITH_RETURN(dev_priv);
2890 VB_AGE_TEST_WITH_RETURN(dev_priv);
2892 if (cmdbuf->bufsz > 64 * 1024 || cmdbuf->bufsz < 0) {
2896 /* Allocate an in-kernel area and copy in the cmdbuf. Do this to avoid
2897 * races between checking values and using those values in other code,
2898 * and simply to avoid a lot of function calls to copy in data.
2900 orig_bufsz = cmdbuf->bufsz;
2901 if (orig_bufsz != 0) {
2902 kbuf = drm_alloc(cmdbuf->bufsz, DRM_MEM_DRIVER);
2905 if (DRM_COPY_FROM_USER(kbuf, (void __user *)cmdbuf->buf,
2907 drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
2913 orig_nbox = cmdbuf->nbox;
2915 if (dev_priv->chip_family >= CHIP_R300) {
2917 temp = r300_do_cp_cmdbuf(dev, file_priv, cmdbuf);
2919 if (orig_bufsz != 0)
2920 drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
2925 /* microcode_version != r300 */
2926 while (cmdbuf->bufsz >= sizeof(header)) {
2928 header.i = *(int *)cmdbuf->buf;
2929 cmdbuf->buf += sizeof(header);
2930 cmdbuf->bufsz -= sizeof(header);
2932 switch (header.header.cmd_type) {
2933 case RADEON_CMD_PACKET:
2934 DRM_DEBUG("RADEON_CMD_PACKET\n");
2935 if (radeon_emit_packets
2936 (dev_priv, file_priv, header, cmdbuf)) {
2937 DRM_ERROR("radeon_emit_packets failed\n");
2942 case RADEON_CMD_SCALARS:
2943 DRM_DEBUG("RADEON_CMD_SCALARS\n");
2944 if (radeon_emit_scalars(dev_priv, header, cmdbuf)) {
2945 DRM_ERROR("radeon_emit_scalars failed\n");
2950 case RADEON_CMD_VECTORS:
2951 DRM_DEBUG("RADEON_CMD_VECTORS\n");
2952 if (radeon_emit_vectors(dev_priv, header, cmdbuf)) {
2953 DRM_ERROR("radeon_emit_vectors failed\n");
2958 case RADEON_CMD_DMA_DISCARD:
2959 DRM_DEBUG("RADEON_CMD_DMA_DISCARD\n");
2960 idx = header.dma.buf_idx;
2961 if (idx < 0 || idx >= dma->buf_count) {
2962 DRM_ERROR("buffer index %d (of %d max)\n",
2963 idx, dma->buf_count - 1);
2967 buf = dma->buflist[idx];
2968 if (buf->file_priv != file_priv || buf->pending) {
2969 DRM_ERROR("bad buffer %p %p %d\n",
2970 buf->file_priv, file_priv,
2975 radeon_cp_discard_buffer(dev, file_priv->master, buf);
2978 case RADEON_CMD_PACKET3:
2979 DRM_DEBUG("RADEON_CMD_PACKET3\n");
2980 if (radeon_emit_packet3(dev, file_priv, cmdbuf)) {
2981 DRM_ERROR("radeon_emit_packet3 failed\n");
2986 case RADEON_CMD_PACKET3_CLIP:
2987 DRM_DEBUG("RADEON_CMD_PACKET3_CLIP\n");
2988 if (radeon_emit_packet3_cliprect
2989 (dev, file_priv, cmdbuf, orig_nbox)) {
2990 DRM_ERROR("radeon_emit_packet3_clip failed\n");
2995 case RADEON_CMD_SCALARS2:
2996 DRM_DEBUG("RADEON_CMD_SCALARS2\n");
2997 if (radeon_emit_scalars2(dev_priv, header, cmdbuf)) {
2998 DRM_ERROR("radeon_emit_scalars2 failed\n");
3003 case RADEON_CMD_WAIT:
3004 DRM_DEBUG("RADEON_CMD_WAIT\n");
3005 if (radeon_emit_wait(dev, header.wait.flags)) {
3006 DRM_ERROR("radeon_emit_wait failed\n");
3010 case RADEON_CMD_VECLINEAR:
3011 DRM_DEBUG("RADEON_CMD_VECLINEAR\n");
3012 if (radeon_emit_veclinear(dev_priv, header, cmdbuf)) {
3013 DRM_ERROR("radeon_emit_veclinear failed\n");
3019 DRM_ERROR("bad cmd_type %d at %p\n",
3020 header.header.cmd_type,
3021 cmdbuf->buf - sizeof(header));
3026 if (orig_bufsz != 0)
3027 drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
3029 DRM_DEBUG("DONE\n");
3034 if (orig_bufsz != 0)
3035 drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
3039 static int radeon_cp_getparam(struct drm_device *dev, void *data, struct drm_file *file_priv)
3041 drm_radeon_private_t *dev_priv = dev->dev_private;
3042 drm_radeon_getparam_t *param = data;
3046 DRM_ERROR("called with no initialization\n");
3050 DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
3052 switch (param->param) {
3053 case RADEON_PARAM_GART_BUFFER_OFFSET:
3054 value = dev_priv->gart_buffers_offset;
3056 case RADEON_PARAM_LAST_FRAME:
3057 dev_priv->stats.last_frame_reads++;
3058 value = GET_SCRATCH(0);
3060 case RADEON_PARAM_LAST_DISPATCH:
3061 value = GET_SCRATCH(1);
3063 case RADEON_PARAM_LAST_CLEAR:
3064 dev_priv->stats.last_clear_reads++;
3065 value = GET_SCRATCH(2);
3067 case RADEON_PARAM_IRQ_NR:
3070 case RADEON_PARAM_GART_BASE:
3071 value = dev_priv->gart_vm_start;
3073 case RADEON_PARAM_REGISTER_HANDLE:
3074 value = dev_priv->mmio->offset;
3076 case RADEON_PARAM_STATUS_HANDLE:
3077 value = dev_priv->ring_rptr_offset;
3081 * This ioctl() doesn't work on 64-bit platforms because hw_lock is a
3082 * pointer which can't fit into an int-sized variable. According to
3083 * Michel Dänzer, the ioctl() is only used on embedded platforms, so
3084 * not supporting it shouldn't be a problem. If the same functionality
3085 * is needed on 64-bit platforms, a new ioctl() would have to be added,
3086 * so backwards-compatibility for the embedded platforms can be
3087 * maintained. --davidm 4-Feb-2004.
3089 case RADEON_PARAM_SAREA_HANDLE:
3090 /* The lock is the first dword in the sarea. */
3091 value = (long)dev->primary->master->lock.hw_lock;
3094 case RADEON_PARAM_GART_TEX_HANDLE:
3095 value = dev_priv->gart_textures_offset;
3097 case RADEON_PARAM_SCRATCH_OFFSET:
3098 if (!dev_priv->writeback_works)
3100 value = RADEON_SCRATCH_REG_OFFSET;
3103 case RADEON_PARAM_CARD_TYPE:
3104 if (dev_priv->flags & RADEON_IS_PCIE)
3105 value = RADEON_CARD_PCIE;
3106 else if (dev_priv->flags & RADEON_IS_AGP)
3107 value = RADEON_CARD_AGP;
3109 value = RADEON_CARD_PCI;
3111 case RADEON_PARAM_VBLANK_CRTC:
3112 value = radeon_vblank_crtc_get(dev);
3114 case RADEON_PARAM_FB_LOCATION:
3115 value = radeon_read_fb_location(dev_priv);
3117 case RADEON_PARAM_NUM_GB_PIPES:
3118 value = dev_priv->num_gb_pipes;
3120 case RADEON_PARAM_KERNEL_MM:
3125 DRM_DEBUG( "Invalid parameter %d\n", param->param );
3129 if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
3130 DRM_ERROR("copy_to_user\n");
3137 static int radeon_cp_setparam(struct drm_device *dev, void *data, struct drm_file *file_priv)
3139 drm_radeon_private_t *dev_priv = dev->dev_private;
3140 struct drm_radeon_master_private *master_priv = file_priv->master->driver_priv;
3141 drm_radeon_setparam_t *sp = data;
3142 struct drm_radeon_driver_file_fields *radeon_priv;
3145 DRM_ERROR("called with no initialization\n");
3149 switch (sp->param) {
3150 case RADEON_SETPARAM_FB_LOCATION:
3151 radeon_priv = file_priv->driver_priv;
3152 radeon_priv->radeon_fb_delta = dev_priv->fb_location -
3155 case RADEON_SETPARAM_SWITCH_TILING:
3156 if (sp->value == 0) {
3157 DRM_DEBUG("color tiling disabled\n");
3158 dev_priv->front_pitch_offset &= ~RADEON_DST_TILE_MACRO;
3159 dev_priv->back_pitch_offset &= ~RADEON_DST_TILE_MACRO;
3160 if (master_priv->sarea_priv)
3161 master_priv->sarea_priv->tiling_enabled = 0;
3162 } else if (sp->value == 1) {
3163 DRM_DEBUG("color tiling enabled\n");
3164 dev_priv->front_pitch_offset |= RADEON_DST_TILE_MACRO;
3165 dev_priv->back_pitch_offset |= RADEON_DST_TILE_MACRO;
3166 if (master_priv->sarea_priv)
3167 master_priv->sarea_priv->tiling_enabled = 1;
3170 case RADEON_SETPARAM_PCIGART_LOCATION:
3171 dev_priv->pcigart_offset = sp->value;
3172 dev_priv->pcigart_offset_set = 1;
3174 case RADEON_SETPARAM_NEW_MEMMAP:
3175 dev_priv->new_memmap = sp->value;
3177 case RADEON_SETPARAM_PCIGART_TABLE_SIZE:
3178 dev_priv->gart_info.table_size = sp->value;
3179 if (dev_priv->gart_info.table_size < RADEON_PCIGART_TABLE_SIZE)
3180 dev_priv->gart_info.table_size = RADEON_PCIGART_TABLE_SIZE;
3182 case RADEON_SETPARAM_VBLANK_CRTC:
3183 return radeon_vblank_crtc_set(dev, sp->value);
3186 DRM_DEBUG("Invalid parameter %d\n", sp->param);
3193 /* When a client dies:
3194 * - Check for and clean up flipped page state
3195 * - Free any alloced GART memory.
3196 * - Free any alloced radeon surfaces.
3198 * DRM infrastructure takes care of reclaiming dma buffers.
3200 void radeon_driver_preclose(struct drm_device *dev,
3201 struct drm_file *file_priv)
3203 if (dev->dev_private) {
3204 drm_radeon_private_t *dev_priv = dev->dev_private;
3205 dev_priv->page_flipping = 0;
3206 radeon_mem_release(file_priv, dev_priv->gart_heap);
3207 radeon_mem_release(file_priv, dev_priv->fb_heap);
3208 radeon_surfaces_release(file_priv, dev_priv);
3212 void radeon_driver_lastclose(struct drm_device *dev)
3214 radeon_do_release(dev);
3217 int radeon_driver_open(struct drm_device *dev, struct drm_file *file_priv)
3219 drm_radeon_private_t *dev_priv = dev->dev_private;
3220 struct drm_radeon_driver_file_fields *radeon_priv;
3224 (struct drm_radeon_driver_file_fields *)
3225 drm_alloc(sizeof(*radeon_priv), DRM_MEM_FILES);
3230 file_priv->driver_priv = radeon_priv;
3233 radeon_priv->radeon_fb_delta = dev_priv->fb_location;
3235 radeon_priv->radeon_fb_delta = 0;
3239 void radeon_driver_postclose(struct drm_device *dev, struct drm_file *file_priv)
3241 struct drm_radeon_driver_file_fields *radeon_priv =
3242 file_priv->driver_priv;
3244 drm_free(radeon_priv, sizeof(*radeon_priv), DRM_MEM_FILES);
3247 struct drm_ioctl_desc radeon_ioctls[] = {
3248 DRM_IOCTL_DEF(DRM_RADEON_CP_INIT, radeon_cp_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
3249 DRM_IOCTL_DEF(DRM_RADEON_CP_START, radeon_cp_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
3250 DRM_IOCTL_DEF(DRM_RADEON_CP_STOP, radeon_cp_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
3251 DRM_IOCTL_DEF(DRM_RADEON_CP_RESET, radeon_cp_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
3252 DRM_IOCTL_DEF(DRM_RADEON_CP_IDLE, radeon_cp_idle, DRM_AUTH),
3253 DRM_IOCTL_DEF(DRM_RADEON_CP_RESUME, radeon_cp_resume, DRM_AUTH),
3254 DRM_IOCTL_DEF(DRM_RADEON_RESET, radeon_engine_reset, DRM_AUTH),
3255 DRM_IOCTL_DEF(DRM_RADEON_FULLSCREEN, radeon_fullscreen, DRM_AUTH),
3256 DRM_IOCTL_DEF(DRM_RADEON_SWAP, radeon_cp_swap, DRM_AUTH),
3257 DRM_IOCTL_DEF(DRM_RADEON_CLEAR, radeon_cp_clear, DRM_AUTH),
3258 DRM_IOCTL_DEF(DRM_RADEON_VERTEX, radeon_cp_vertex, DRM_AUTH),
3259 DRM_IOCTL_DEF(DRM_RADEON_INDICES, radeon_cp_indices, DRM_AUTH),
3260 DRM_IOCTL_DEF(DRM_RADEON_TEXTURE, radeon_cp_texture, DRM_AUTH),
3261 DRM_IOCTL_DEF(DRM_RADEON_STIPPLE, radeon_cp_stipple, DRM_AUTH),
3262 DRM_IOCTL_DEF(DRM_RADEON_INDIRECT, radeon_cp_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
3263 DRM_IOCTL_DEF(DRM_RADEON_VERTEX2, radeon_cp_vertex2, DRM_AUTH),
3264 DRM_IOCTL_DEF(DRM_RADEON_CMDBUF, radeon_cp_cmdbuf, DRM_AUTH),
3265 DRM_IOCTL_DEF(DRM_RADEON_GETPARAM, radeon_cp_getparam, DRM_AUTH),
3266 DRM_IOCTL_DEF(DRM_RADEON_FLIP, radeon_cp_flip, DRM_AUTH),
3267 DRM_IOCTL_DEF(DRM_RADEON_ALLOC, radeon_mem_alloc, DRM_AUTH),
3268 DRM_IOCTL_DEF(DRM_RADEON_FREE, radeon_mem_free, DRM_AUTH),
3269 DRM_IOCTL_DEF(DRM_RADEON_INIT_HEAP, radeon_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
3270 DRM_IOCTL_DEF(DRM_RADEON_IRQ_EMIT, radeon_irq_emit, DRM_AUTH),
3271 DRM_IOCTL_DEF(DRM_RADEON_IRQ_WAIT, radeon_irq_wait, DRM_AUTH),
3272 DRM_IOCTL_DEF(DRM_RADEON_SETPARAM, radeon_cp_setparam, DRM_AUTH),
3273 DRM_IOCTL_DEF(DRM_RADEON_SURF_ALLOC, radeon_surface_alloc, DRM_AUTH),
3274 DRM_IOCTL_DEF(DRM_RADEON_SURF_FREE, radeon_surface_free, DRM_AUTH),
3276 DRM_IOCTL_DEF(DRM_RADEON_GEM_INFO, radeon_gem_info_ioctl, DRM_AUTH),
3277 DRM_IOCTL_DEF(DRM_RADEON_GEM_CREATE, radeon_gem_create_ioctl, DRM_AUTH),
3279 DRM_IOCTL_DEF(DRM_RADEON_GEM_MMAP, radeon_gem_mmap_ioctl, DRM_AUTH),
3280 DRM_IOCTL_DEF(DRM_RADEON_GEM_PIN, radeon_gem_pin_ioctl, DRM_AUTH),
3281 DRM_IOCTL_DEF(DRM_RADEON_GEM_UNPIN, radeon_gem_unpin_ioctl, DRM_AUTH),
3282 DRM_IOCTL_DEF(DRM_RADEON_GEM_PREAD, radeon_gem_pread_ioctl, DRM_AUTH),
3283 DRM_IOCTL_DEF(DRM_RADEON_GEM_PWRITE, radeon_gem_pwrite_ioctl, DRM_AUTH),
3284 DRM_IOCTL_DEF(DRM_RADEON_GEM_SET_DOMAIN, radeon_gem_set_domain_ioctl, DRM_AUTH),
3285 DRM_IOCTL_DEF(DRM_RADEON_GEM_INDIRECT, radeon_gem_indirect_ioctl, DRM_AUTH),
3286 DRM_IOCTL_DEF(DRM_RADEON_CS, radeon_cs_ioctl, DRM_AUTH),
3289 int radeon_max_ioctl = DRM_ARRAY_SIZE(radeon_ioctls);