1 /* r300_cmdbuf.c -- Command buffer emission for R300 -*- linux-c -*-
3 * Copyright (C) The Weather Channel, Inc. 2002.
4 * Copyright (C) 2004 Nicolai Haehnle.
7 * The Weather Channel (TM) funded Tungsten Graphics to develop the
8 * initial release of the Radeon 8500 driver under the XFree86 license.
9 * This notice must be preserved.
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
18 * The above copyright notice and this permission notice (including the next
19 * paragraph) shall be included in all copies or substantial portions of the
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
26 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
27 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 * DEALINGS IN THE SOFTWARE.
31 * Nicolai Haehnle <prefect_@gmx.net>
33 * $DragonFly: src/sys/dev/drm/r300_cmdbuf.c,v 1.1 2008/04/05 18:12:29 hasso Exp $
38 #include "radeon_drm.h"
39 #include "radeon_drv.h"
42 #define R300_SIMULTANEOUS_CLIPRECTS 4
44 /* Values for R300_RE_CLIPRECT_CNTL depending on the number of cliprects
46 static const int r300_cliprect_cntl[4] = {
54 * Emit up to R300_SIMULTANEOUS_CLIPRECTS cliprects from the given command
55 * buffer, starting with index n.
57 static int r300_emit_cliprects(drm_radeon_private_t *dev_priv,
58 drm_radeon_kcmd_buffer_t *cmdbuf, int n)
60 struct drm_clip_rect box;
65 nr = cmdbuf->nbox - n;
66 if (nr > R300_SIMULTANEOUS_CLIPRECTS)
67 nr = R300_SIMULTANEOUS_CLIPRECTS;
69 DRM_DEBUG("%i cliprects\n", nr);
72 BEGIN_RING(6 + nr * 2);
73 OUT_RING(CP_PACKET0(R300_RE_CLIPRECT_TL_0, nr * 2 - 1));
75 for (i = 0; i < nr; ++i) {
76 if (DRM_COPY_FROM_USER_UNCHECKED
77 (&box, &cmdbuf->boxes[n + i], sizeof(box))) {
78 DRM_ERROR("copy cliprect faulted\n");
82 if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_RV515) {
92 box.x1 = (box.x1 + R300_CLIPRECT_OFFSET) &
94 box.y1 = (box.y1 + R300_CLIPRECT_OFFSET) &
96 box.x2 = (box.x2 + R300_CLIPRECT_OFFSET) &
98 box.y2 = (box.y2 + R300_CLIPRECT_OFFSET) &
102 OUT_RING((box.x1 << R300_CLIPRECT_X_SHIFT) |
103 (box.y1 << R300_CLIPRECT_Y_SHIFT));
104 OUT_RING((box.x2 << R300_CLIPRECT_X_SHIFT) |
105 (box.y2 << R300_CLIPRECT_Y_SHIFT));
109 OUT_RING_REG(R300_RE_CLIPRECT_CNTL, r300_cliprect_cntl[nr - 1]);
111 /* TODO/SECURITY: Force scissors to a safe value, otherwise the
112 * client might be able to trample over memory.
113 * The impact should be very limited, but I'd rather be safe than
116 OUT_RING(CP_PACKET0(R300_RE_SCISSORS_TL, 1));
118 OUT_RING(R300_SCISSORS_X_MASK | R300_SCISSORS_Y_MASK);
121 /* Why we allow zero cliprect rendering:
122 * There are some commands in a command buffer that must be submitted
123 * even when there are no cliprects, e.g. DMA buffer discard
124 * or state setting (though state setting could be avoided by
125 * simulating a loss of context).
127 * Now since the cmdbuf interface is so chaotic right now (and is
128 * bound to remain that way for a bit until things settle down),
129 * it is basically impossible to filter out the commands that are
130 * necessary and those that aren't.
132 * So I choose the safe way and don't do any filtering at all;
133 * instead, I simply set up the engine so that all rendering
134 * can't produce any fragments.
137 OUT_RING_REG(R300_RE_CLIPRECT_CNTL, 0);
144 static u8 r300_reg_flags[0x10000 >> 2];
146 void r300_init_reg_flags(struct drm_device *dev)
149 drm_radeon_private_t *dev_priv = dev->dev_private;
151 memset(r300_reg_flags, 0, 0x10000 >> 2);
152 #define ADD_RANGE_MARK(reg, count,mark) \
153 for(i=((reg)>>2);i<((reg)>>2)+(count);i++)\
154 r300_reg_flags[i]|=(mark);
157 #define MARK_CHECK_OFFSET 2
159 #define ADD_RANGE(reg, count) ADD_RANGE_MARK(reg, count, MARK_SAFE)
161 /* these match cmducs() command in r300_driver/r300/r300_cmdbuf.c */
162 ADD_RANGE(R300_SE_VPORT_XSCALE, 6);
163 ADD_RANGE(R300_VAP_CNTL, 1);
164 ADD_RANGE(R300_SE_VTE_CNTL, 2);
165 ADD_RANGE(0x2134, 2);
166 ADD_RANGE(R300_VAP_CNTL_STATUS, 1);
167 ADD_RANGE(R300_VAP_INPUT_CNTL_0, 2);
168 ADD_RANGE(0x21DC, 1);
169 ADD_RANGE(R300_VAP_UNKNOWN_221C, 1);
170 ADD_RANGE(R300_VAP_CLIP_X_0, 4);
171 ADD_RANGE(R300_VAP_PVS_WAITIDLE, 1);
172 ADD_RANGE(R300_VAP_UNKNOWN_2288, 1);
173 ADD_RANGE(R300_VAP_OUTPUT_VTX_FMT_0, 2);
174 ADD_RANGE(R300_VAP_PVS_CNTL_1, 3);
175 ADD_RANGE(R300_GB_ENABLE, 1);
176 ADD_RANGE(R300_GB_MSPOS0, 5);
177 ADD_RANGE(R300_TX_CNTL, 1);
178 ADD_RANGE(R300_TX_ENABLE, 1);
179 ADD_RANGE(0x4200, 4);
180 ADD_RANGE(0x4214, 1);
181 ADD_RANGE(R300_RE_POINTSIZE, 1);
182 ADD_RANGE(0x4230, 3);
183 ADD_RANGE(R300_RE_LINE_CNT, 1);
184 ADD_RANGE(R300_RE_UNK4238, 1);
185 ADD_RANGE(0x4260, 3);
186 ADD_RANGE(R300_RE_SHADE, 4);
187 ADD_RANGE(R300_RE_POLYGON_MODE, 5);
188 ADD_RANGE(R300_RE_ZBIAS_CNTL, 1);
189 ADD_RANGE(R300_RE_ZBIAS_T_FACTOR, 4);
190 ADD_RANGE(R300_RE_OCCLUSION_CNTL, 1);
191 ADD_RANGE(R300_RE_CULL_CNTL, 1);
192 ADD_RANGE(0x42C0, 2);
193 ADD_RANGE(R300_RS_CNTL_0, 2);
194 ADD_RANGE(R300_RS_INTERP_0, 8);
195 ADD_RANGE(R300_RS_ROUTE_0, 8);
196 ADD_RANGE(0x43A4, 2);
197 ADD_RANGE(0x43E8, 1);
198 ADD_RANGE(R300_PFS_CNTL_0, 3);
199 ADD_RANGE(R300_PFS_NODE_0, 4);
200 ADD_RANGE(R300_PFS_TEXI_0, 64);
201 ADD_RANGE(0x46A4, 5);
202 ADD_RANGE(R300_PFS_INSTR0_0, 64);
203 ADD_RANGE(R300_PFS_INSTR1_0, 64);
204 ADD_RANGE(R300_PFS_INSTR2_0, 64);
205 ADD_RANGE(R300_PFS_INSTR3_0, 64);
206 ADD_RANGE(R300_RE_FOG_STATE, 1);
207 ADD_RANGE(R300_FOG_COLOR_R, 3);
208 ADD_RANGE(R300_PP_ALPHA_TEST, 2);
209 ADD_RANGE(0x4BD8, 1);
210 ADD_RANGE(R300_PFS_PARAM_0_X, 64);
211 ADD_RANGE(0x4E00, 1);
212 ADD_RANGE(R300_RB3D_CBLEND, 2);
213 ADD_RANGE(R300_RB3D_COLORMASK, 1);
214 ADD_RANGE(R300_RB3D_BLEND_COLOR, 3);
215 ADD_RANGE_MARK(R300_RB3D_COLOROFFSET0, 1, MARK_CHECK_OFFSET); /* check offset */
216 ADD_RANGE(R300_RB3D_COLORPITCH0, 1);
217 ADD_RANGE(0x4E50, 9);
218 ADD_RANGE(0x4E88, 1);
219 ADD_RANGE(0x4EA0, 2);
220 ADD_RANGE(R300_RB3D_ZSTENCIL_CNTL_0, 3);
221 ADD_RANGE(R300_RB3D_ZSTENCIL_FORMAT, 4);
222 ADD_RANGE_MARK(R300_RB3D_DEPTHOFFSET, 1, MARK_CHECK_OFFSET); /* check offset */
223 ADD_RANGE(R300_RB3D_DEPTHPITCH, 1);
224 ADD_RANGE(0x4F28, 1);
225 ADD_RANGE(0x4F30, 2);
226 ADD_RANGE(0x4F44, 1);
227 ADD_RANGE(0x4F54, 1);
229 ADD_RANGE(R300_TX_FILTER_0, 16);
230 ADD_RANGE(R300_TX_FILTER1_0, 16);
231 ADD_RANGE(R300_TX_SIZE_0, 16);
232 ADD_RANGE(R300_TX_FORMAT_0, 16);
233 ADD_RANGE(R300_TX_PITCH_0, 16);
234 /* Texture offset is dangerous and needs more checking */
235 ADD_RANGE_MARK(R300_TX_OFFSET_0, 16, MARK_CHECK_OFFSET);
236 ADD_RANGE(R300_TX_CHROMA_KEY_0, 16);
237 ADD_RANGE(R300_TX_BORDER_COLOR_0, 16);
239 /* Sporadic registers used as primitives are emitted */
240 ADD_RANGE(R300_RB3D_ZCACHE_CTLSTAT, 1);
241 ADD_RANGE(R300_RB3D_DSTCACHE_CTLSTAT, 1);
242 ADD_RANGE(R300_VAP_INPUT_ROUTE_0_0, 8);
243 ADD_RANGE(R300_VAP_INPUT_ROUTE_1_0, 8);
245 if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_RV515) {
246 ADD_RANGE(0x4074, 16);
250 static __inline__ int r300_check_range(unsigned reg, int count)
255 for (i = (reg >> 2); i < (reg >> 2) + count; i++)
256 if (r300_reg_flags[i] != MARK_SAFE)
261 static __inline__ int r300_emit_carefully_checked_packet0(drm_radeon_private_t *
263 drm_radeon_kcmd_buffer_t
265 drm_r300_cmd_header_t
274 sz = header.packet0.count;
275 reg = (header.packet0.reghi << 8) | header.packet0.reglo;
277 if ((sz > 64) || (sz < 0)) {
279 ("Cannot emit more than 64 values at a time (reg=%04x sz=%d)\n",
283 for (i = 0; i < sz; i++) {
284 values[i] = ((int *)cmdbuf->buf)[i];
285 switch (r300_reg_flags[(reg >> 2) + i]) {
288 case MARK_CHECK_OFFSET:
289 if (!radeon_check_offset(dev_priv, (u32) values[i])) {
291 ("Offset failed range check (reg=%04x sz=%d)\n",
297 DRM_ERROR("Register %04x failed check as flag=%02x\n",
298 reg + i * 4, r300_reg_flags[(reg >> 2) + i]);
304 OUT_RING(CP_PACKET0(reg, sz - 1));
305 OUT_RING_TABLE(values, sz);
308 cmdbuf->buf += sz * 4;
309 cmdbuf->bufsz -= sz * 4;
315 * Emits a packet0 setting arbitrary registers.
316 * Called by r300_do_cp_cmdbuf.
318 * Note that checks are performed on contents and addresses of the registers
320 static __inline__ int r300_emit_packet0(drm_radeon_private_t *dev_priv,
321 drm_radeon_kcmd_buffer_t *cmdbuf,
322 drm_r300_cmd_header_t header)
328 sz = header.packet0.count;
329 reg = (header.packet0.reghi << 8) | header.packet0.reglo;
334 if (sz * 4 > cmdbuf->bufsz)
337 if (reg + sz * 4 >= 0x10000) {
338 DRM_ERROR("No such registers in hardware reg=%04x sz=%d\n", reg,
343 if (r300_check_range(reg, sz)) {
344 /* go and check everything */
345 return r300_emit_carefully_checked_packet0(dev_priv, cmdbuf,
348 /* the rest of the data is safe to emit, whatever the values the user passed */
351 OUT_RING(CP_PACKET0(reg, sz - 1));
352 OUT_RING_TABLE((int *)cmdbuf->buf, sz);
355 cmdbuf->buf += sz * 4;
356 cmdbuf->bufsz -= sz * 4;
362 * Uploads user-supplied vertex program instructions or parameters onto
364 * Called by r300_do_cp_cmdbuf.
366 static __inline__ int r300_emit_vpu(drm_radeon_private_t *dev_priv,
367 drm_radeon_kcmd_buffer_t *cmdbuf,
368 drm_r300_cmd_header_t header)
374 sz = header.vpu.count;
375 addr = (header.vpu.adrhi << 8) | header.vpu.adrlo;
379 if (sz * 16 > cmdbuf->bufsz)
382 BEGIN_RING(5 + sz * 4);
383 /* Wait for VAP to come to senses.. */
384 /* there is no need to emit it multiple times, (only once before VAP is programmed,
385 but this optimization is for later */
386 OUT_RING_REG(R300_VAP_PVS_WAITIDLE, 0);
387 OUT_RING_REG(R300_VAP_PVS_UPLOAD_ADDRESS, addr);
388 OUT_RING(CP_PACKET0_TABLE(R300_VAP_PVS_UPLOAD_DATA, sz * 4 - 1));
389 OUT_RING_TABLE((int *)cmdbuf->buf, sz * 4);
393 cmdbuf->buf += sz * 16;
394 cmdbuf->bufsz -= sz * 16;
400 * Emit a clear packet from userspace.
401 * Called by r300_emit_packet3.
403 static __inline__ int r300_emit_clear(drm_radeon_private_t *dev_priv,
404 drm_radeon_kcmd_buffer_t *cmdbuf)
408 if (8 * 4 > cmdbuf->bufsz)
412 OUT_RING(CP_PACKET3(R200_3D_DRAW_IMMD_2, 8));
413 OUT_RING(R300_PRIM_TYPE_POINT | R300_PRIM_WALK_RING |
414 (1 << R300_PRIM_NUM_VERTICES_SHIFT));
415 OUT_RING_TABLE((int *)cmdbuf->buf, 8);
418 cmdbuf->buf += 8 * 4;
419 cmdbuf->bufsz -= 8 * 4;
424 static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
425 drm_radeon_kcmd_buffer_t *cmdbuf,
429 #define MAX_ARRAY_PACKET 64
430 u32 payload[MAX_ARRAY_PACKET];
434 count = (header >> 16) & 0x3fff;
436 if ((count + 1) > MAX_ARRAY_PACKET) {
437 DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
441 memset(payload, 0, MAX_ARRAY_PACKET * 4);
442 memcpy(payload, cmdbuf->buf + 4, (count + 1) * 4);
444 /* carefully check packet contents */
446 narrays = payload[0];
449 while ((k < narrays) && (i < (count + 1))) {
450 i++; /* skip attribute field */
451 if (!radeon_check_offset(dev_priv, payload[i])) {
453 ("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
461 /* have one more to process, they come in pairs */
462 if (!radeon_check_offset(dev_priv, payload[i])) {
464 ("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
471 /* do the counts match what we expect ? */
472 if ((k != narrays) || (i != (count + 1))) {
474 ("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
475 k, i, narrays, count + 1);
479 /* all clear, output packet */
481 BEGIN_RING(count + 2);
483 OUT_RING_TABLE(payload, count + 1);
486 cmdbuf->buf += (count + 2) * 4;
487 cmdbuf->bufsz -= (count + 2) * 4;
492 static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
493 drm_radeon_kcmd_buffer_t *cmdbuf)
495 u32 *cmd = (u32 *) cmdbuf->buf;
499 count=(cmd[0]>>16) & 0x3fff;
501 if (cmd[0] & 0x8000) {
504 if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL
505 | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
506 offset = cmd[2] << 10;
507 ret = !radeon_check_offset(dev_priv, offset);
509 DRM_ERROR("Invalid bitblt first offset is %08X\n", offset);
514 if ((cmd[1] & RADEON_GMC_SRC_PITCH_OFFSET_CNTL) &&
515 (cmd[1] & RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
516 offset = cmd[3] << 10;
517 ret = !radeon_check_offset(dev_priv, offset);
519 DRM_ERROR("Invalid bitblt second offset is %08X\n", offset);
528 OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
531 cmdbuf->buf += (count+2)*4;
532 cmdbuf->bufsz -= (count+2)*4;
537 static __inline__ int r300_emit_indx_buffer(drm_radeon_private_t *dev_priv,
538 drm_radeon_kcmd_buffer_t *cmdbuf)
540 u32 *cmd = (u32 *) cmdbuf->buf;
544 count=(cmd[0]>>16) & 0x3fff;
546 if ((cmd[1] & 0x8000ffff) != 0x80000810) {
547 DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
550 ret = !radeon_check_offset(dev_priv, cmd[2]);
552 DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
558 OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
561 cmdbuf->buf += (count+2)*4;
562 cmdbuf->bufsz -= (count+2)*4;
567 static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
568 drm_radeon_kcmd_buffer_t *cmdbuf)
574 if (4 > cmdbuf->bufsz)
577 /* Fixme !! This simply emits a packet without much checking.
578 We need to be smarter. */
580 /* obtain first word - actual packet3 header */
581 header = *(u32 *) cmdbuf->buf;
583 /* Is it packet 3 ? */
584 if ((header >> 30) != 0x3) {
585 DRM_ERROR("Not a packet3 header (0x%08x)\n", header);
589 count = (header >> 16) & 0x3fff;
591 /* Check again now that we know how much data to expect */
592 if ((count + 2) * 4 > cmdbuf->bufsz) {
594 ("Expected packet3 of length %d but have only %d bytes left\n",
595 (count + 2) * 4, cmdbuf->bufsz);
599 /* Is it a packet type we know about ? */
600 switch (header & 0xff00) {
601 case RADEON_3D_LOAD_VBPNTR: /* load vertex array pointers */
602 return r300_emit_3d_load_vbpntr(dev_priv, cmdbuf, header);
604 case RADEON_CNTL_BITBLT_MULTI:
605 return r300_emit_bitblt_multi(dev_priv, cmdbuf);
607 case RADEON_CP_INDX_BUFFER: /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
608 return r300_emit_indx_buffer(dev_priv, cmdbuf);
609 case RADEON_CP_3D_DRAW_IMMD_2: /* triggers drawing using in-packet vertex data */
610 case RADEON_CP_3D_DRAW_VBUF_2: /* triggers drawing of vertex buffers setup elsewhere */
611 case RADEON_CP_3D_DRAW_INDX_2: /* triggers drawing using indices to vertex buffer */
612 case RADEON_WAIT_FOR_IDLE:
614 /* these packets are safe */
617 DRM_ERROR("Unknown packet3 header (0x%08x)\n", header);
621 BEGIN_RING(count + 2);
623 OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
626 cmdbuf->buf += (count + 2) * 4;
627 cmdbuf->bufsz -= (count + 2) * 4;
633 * Emit a rendering packet3 from userspace.
634 * Called by r300_do_cp_cmdbuf.
636 static __inline__ int r300_emit_packet3(drm_radeon_private_t *dev_priv,
637 drm_radeon_kcmd_buffer_t *cmdbuf,
638 drm_r300_cmd_header_t header)
642 char *orig_buf = cmdbuf->buf;
643 int orig_bufsz = cmdbuf->bufsz;
645 /* This is a do-while-loop so that we run the interior at least once,
646 * even if cmdbuf->nbox is 0. Compare r300_emit_cliprects for rationale.
650 if (cmdbuf->nbox > R300_SIMULTANEOUS_CLIPRECTS) {
651 ret = r300_emit_cliprects(dev_priv, cmdbuf, n);
655 cmdbuf->buf = orig_buf;
656 cmdbuf->bufsz = orig_bufsz;
659 switch (header.packet3.packet) {
660 case R300_CMD_PACKET3_CLEAR:
661 DRM_DEBUG("R300_CMD_PACKET3_CLEAR\n");
662 ret = r300_emit_clear(dev_priv, cmdbuf);
664 DRM_ERROR("r300_emit_clear failed\n");
669 case R300_CMD_PACKET3_RAW:
670 DRM_DEBUG("R300_CMD_PACKET3_RAW\n");
671 ret = r300_emit_raw_packet3(dev_priv, cmdbuf);
673 DRM_ERROR("r300_emit_raw_packet3 failed\n");
679 DRM_ERROR("bad packet3 type %i at %p\n",
680 header.packet3.packet,
681 cmdbuf->buf - sizeof(header));
685 n += R300_SIMULTANEOUS_CLIPRECTS;
686 } while (n < cmdbuf->nbox);
691 /* Some of the R300 chips seem to be extremely touchy about the two registers
692 * that are configured in r300_pacify.
693 * Among the worst offenders seems to be the R300 ND (0x4E44): When userspace
694 * sends a command buffer that contains only state setting commands and a
695 * vertex program/parameter upload sequence, this will eventually lead to a
696 * lockup, unless the sequence is bracketed by calls to r300_pacify.
697 * So we should take great care to *always* call r300_pacify before
698 * *anything* 3D related, and again afterwards. This is what the
699 * call bracket in r300_do_cp_cmdbuf is for.
703 * Emit the sequence to pacify R300.
705 static __inline__ void r300_pacify(drm_radeon_private_t *dev_priv)
710 OUT_RING(CP_PACKET0(R300_RB3D_DSTCACHE_CTLSTAT, 0));
711 OUT_RING(R300_RB3D_DSTCACHE_UNKNOWN_0A);
712 OUT_RING(CP_PACKET0(R300_RB3D_ZCACHE_CTLSTAT, 0));
713 OUT_RING(R300_RB3D_ZCACHE_UNKNOWN_03);
714 OUT_RING(CP_PACKET3(RADEON_CP_NOP, 0));
720 * Called by r300_do_cp_cmdbuf to update the internal buffer age and state.
721 * The actual age emit is done by r300_do_cp_cmdbuf, which is why you must
722 * be careful about how this function is called.
724 static void r300_discard_buffer(struct drm_device * dev, struct drm_buf * buf)
726 drm_radeon_private_t *dev_priv = dev->dev_private;
727 drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
729 buf_priv->age = ++dev_priv->sarea_priv->last_dispatch;
734 static int r300_scratch(drm_radeon_private_t *dev_priv,
735 drm_radeon_kcmd_buffer_t *cmdbuf,
736 drm_r300_cmd_header_t header)
739 u32 i, buf_idx, h_pending;
742 if (cmdbuf->bufsz < sizeof(uint64_t) + header.scratch.n_bufs * sizeof(buf_idx) ) {
746 if (header.scratch.reg >= 5) {
750 dev_priv->scratch_ages[header.scratch.reg] ++;
752 ref_age_base = (u32 *)(unsigned long)*((uint64_t *)cmdbuf->buf);
754 cmdbuf->buf += sizeof(uint64_t);
755 cmdbuf->bufsz -= sizeof(uint64_t);
757 for (i=0; i < header.scratch.n_bufs; i++) {
758 buf_idx = *(u32 *)cmdbuf->buf;
759 buf_idx *= 2; /* 8 bytes per buf */
761 if (DRM_COPY_TO_USER(ref_age_base + buf_idx, &dev_priv->scratch_ages[header.scratch.reg], sizeof(u32))) {
765 if (DRM_COPY_FROM_USER(&h_pending, ref_age_base + buf_idx + 1, sizeof(u32))) {
769 if (h_pending == 0) {
775 if (DRM_COPY_TO_USER(ref_age_base + buf_idx + 1, &h_pending, sizeof(u32))) {
779 cmdbuf->buf += sizeof(buf_idx);
780 cmdbuf->bufsz -= sizeof(buf_idx);
784 OUT_RING( CP_PACKET0( RADEON_SCRATCH_REG0 + header.scratch.reg * 4, 0 ) );
785 OUT_RING( dev_priv->scratch_ages[header.scratch.reg] );
792 * Parses and validates a user-supplied command buffer and emits appropriate
793 * commands on the DMA ring buffer.
794 * Called by the ioctl handler function radeon_cp_cmdbuf.
796 int r300_do_cp_cmdbuf(struct drm_device *dev,
797 struct drm_file *file_priv,
798 drm_radeon_kcmd_buffer_t *cmdbuf)
800 drm_radeon_private_t *dev_priv = dev->dev_private;
801 struct drm_device_dma *dma = dev->dma;
802 struct drm_buf *buf = NULL;
803 int emit_dispatch_age = 0;
808 /* See the comment above r300_emit_begin3d for why this call must be here,
809 * and what the cleanup gotos are for. */
810 r300_pacify(dev_priv);
812 if (cmdbuf->nbox <= R300_SIMULTANEOUS_CLIPRECTS) {
813 ret = r300_emit_cliprects(dev_priv, cmdbuf, 0);
818 while (cmdbuf->bufsz >= sizeof(drm_r300_cmd_header_t)) {
820 drm_r300_cmd_header_t header;
822 header.u = *(unsigned int *)cmdbuf->buf;
824 cmdbuf->buf += sizeof(header);
825 cmdbuf->bufsz -= sizeof(header);
827 switch (header.header.cmd_type) {
828 case R300_CMD_PACKET0:
829 DRM_DEBUG("R300_CMD_PACKET0\n");
830 ret = r300_emit_packet0(dev_priv, cmdbuf, header);
832 DRM_ERROR("r300_emit_packet0 failed\n");
838 DRM_DEBUG("R300_CMD_VPU\n");
839 ret = r300_emit_vpu(dev_priv, cmdbuf, header);
841 DRM_ERROR("r300_emit_vpu failed\n");
846 case R300_CMD_PACKET3:
847 DRM_DEBUG("R300_CMD_PACKET3\n");
848 ret = r300_emit_packet3(dev_priv, cmdbuf, header);
850 DRM_ERROR("r300_emit_packet3 failed\n");
856 DRM_DEBUG("R300_CMD_END3D\n");
858 Ideally userspace driver should not need to issue this call,
859 i.e. the drm driver should issue it automatically and prevent
862 In practice, we do not understand why this call is needed and what
863 it does (except for some vague guesses that it has to do with cache
864 coherence) and so the user space driver does it.
866 Once we are sure which uses prevent lockups the code could be moved
867 into the kernel and the userspace driver will not
868 need to use this command.
870 Note that issuing this command does not hurt anything
871 except, possibly, performance */
872 r300_pacify(dev_priv);
875 case R300_CMD_CP_DELAY:
876 /* simple enough, we can do it here */
877 DRM_DEBUG("R300_CMD_CP_DELAY\n");
882 BEGIN_RING(header.delay.count);
883 for (i = 0; i < header.delay.count; i++)
884 OUT_RING(RADEON_CP_PACKET2);
889 case R300_CMD_DMA_DISCARD:
890 DRM_DEBUG("RADEON_CMD_DMA_DISCARD\n");
891 idx = header.dma.buf_idx;
892 if (idx < 0 || idx >= dma->buf_count) {
893 DRM_ERROR("buffer index %d (of %d max)\n",
894 idx, dma->buf_count - 1);
899 buf = dma->buflist[idx];
900 if (buf->file_priv != file_priv || buf->pending) {
901 DRM_ERROR("bad buffer %p %p %d\n",
902 buf->file_priv, file_priv,
908 emit_dispatch_age = 1;
909 r300_discard_buffer(dev, buf);
913 /* simple enough, we can do it here */
914 DRM_DEBUG("R300_CMD_WAIT\n");
915 if (header.wait.flags == 0)
916 break; /* nothing to do */
922 OUT_RING(CP_PACKET0(RADEON_WAIT_UNTIL, 0));
923 OUT_RING((header.wait.flags & 0xf) << 14);
928 case R300_CMD_SCRATCH:
929 DRM_DEBUG("R300_CMD_SCRATCH\n");
930 ret = r300_scratch(dev_priv, cmdbuf, header);
932 DRM_ERROR("r300_scratch failed\n");
938 DRM_ERROR("bad cmd_type %i at %p\n",
939 header.header.cmd_type,
940 cmdbuf->buf - sizeof(header));
949 r300_pacify(dev_priv);
951 /* We emit the vertex buffer age here, outside the pacifier "brackets"
953 * (1) This may coalesce multiple age emissions into a single one and
954 * (2) more importantly, some chips lock up hard when scratch registers
955 * are written inside the pacifier bracket.
957 if (emit_dispatch_age) {
960 /* Emit the vertex buffer age */
962 RADEON_DISPATCH_AGE(dev_priv->sarea_priv->last_dispatch);