Merge by Hand
[linux-2.6] / drivers / char / drm / r300_cmdbuf.c
1 /* r300_cmdbuf.c -- Command buffer emission for R300 -*- linux-c -*-
2  *
3  * Copyright (C) The Weather Channel, Inc.  2002.
4  * Copyright (C) 2004 Nicolai Haehnle.
5  * All Rights Reserved.
6  *
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.
10  *
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:
17  *
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
20  * Software.
21  *
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.
29  *
30  * Authors:
31  *    Nicolai Haehnle <prefect_@gmx.net>
32  */
33
34 #include "drmP.h"
35 #include "drm.h"
36 #include "radeon_drm.h"
37 #include "radeon_drv.h"
38 #include "r300_reg.h"
39
40 #define R300_SIMULTANEOUS_CLIPRECTS             4
41
42 /* Values for R300_RE_CLIPRECT_CNTL depending on the number of cliprects
43  */
44 static const int r300_cliprect_cntl[4] = {
45         0xAAAA,
46         0xEEEE,
47         0xFEFE,
48         0xFFFE
49 };
50
51 /**
52  * Emit up to R300_SIMULTANEOUS_CLIPRECTS cliprects from the given command
53  * buffer, starting with index n.
54  */
55 static int r300_emit_cliprects(drm_radeon_private_t * dev_priv,
56                                drm_radeon_kcmd_buffer_t * cmdbuf, int n)
57 {
58         drm_clip_rect_t box;
59         int nr;
60         int i;
61         RING_LOCALS;
62
63         nr = cmdbuf->nbox - n;
64         if (nr > R300_SIMULTANEOUS_CLIPRECTS)
65                 nr = R300_SIMULTANEOUS_CLIPRECTS;
66
67         DRM_DEBUG("%i cliprects\n", nr);
68
69         if (nr) {
70                 BEGIN_RING(6 + nr * 2);
71                 OUT_RING(CP_PACKET0(R300_RE_CLIPRECT_TL_0, nr * 2 - 1));
72
73                 for (i = 0; i < nr; ++i) {
74                         if (DRM_COPY_FROM_USER_UNCHECKED
75                             (&box, &cmdbuf->boxes[n + i], sizeof(box))) {
76                                 DRM_ERROR("copy cliprect faulted\n");
77                                 return DRM_ERR(EFAULT);
78                         }
79
80                         box.x1 =
81                             (box.x1 +
82                              R300_CLIPRECT_OFFSET) & R300_CLIPRECT_MASK;
83                         box.y1 =
84                             (box.y1 +
85                              R300_CLIPRECT_OFFSET) & R300_CLIPRECT_MASK;
86                         box.x2 =
87                             (box.x2 +
88                              R300_CLIPRECT_OFFSET) & R300_CLIPRECT_MASK;
89                         box.y2 =
90                             (box.y2 +
91                              R300_CLIPRECT_OFFSET) & R300_CLIPRECT_MASK;
92
93                         OUT_RING((box.x1 << R300_CLIPRECT_X_SHIFT) |
94                                  (box.y1 << R300_CLIPRECT_Y_SHIFT));
95                         OUT_RING((box.x2 << R300_CLIPRECT_X_SHIFT) |
96                                  (box.y2 << R300_CLIPRECT_Y_SHIFT));
97                 }
98
99                 OUT_RING_REG(R300_RE_CLIPRECT_CNTL, r300_cliprect_cntl[nr - 1]);
100
101                 /* TODO/SECURITY: Force scissors to a safe value, otherwise the
102                  * client might be able to trample over memory.
103                  * The impact should be very limited, but I'd rather be safe than
104                  * sorry.
105                  */
106                 OUT_RING(CP_PACKET0(R300_RE_SCISSORS_TL, 1));
107                 OUT_RING(0);
108                 OUT_RING(R300_SCISSORS_X_MASK | R300_SCISSORS_Y_MASK);
109                 ADVANCE_RING();
110         } else {
111                 /* Why we allow zero cliprect rendering:
112                  * There are some commands in a command buffer that must be submitted
113                  * even when there are no cliprects, e.g. DMA buffer discard
114                  * or state setting (though state setting could be avoided by
115                  * simulating a loss of context).
116                  *
117                  * Now since the cmdbuf interface is so chaotic right now (and is
118                  * bound to remain that way for a bit until things settle down),
119                  * it is basically impossible to filter out the commands that are
120                  * necessary and those that aren't.
121                  *
122                  * So I choose the safe way and don't do any filtering at all;
123                  * instead, I simply set up the engine so that all rendering
124                  * can't produce any fragments.
125                  */
126                 BEGIN_RING(2);
127                 OUT_RING_REG(R300_RE_CLIPRECT_CNTL, 0);
128                 ADVANCE_RING();
129         }
130
131         return 0;
132 }
133
134 static u8 r300_reg_flags[0x10000 >> 2];
135
136 void r300_init_reg_flags(void)
137 {
138         int i;
139         memset(r300_reg_flags, 0, 0x10000 >> 2);
140 #define ADD_RANGE_MARK(reg, count,mark) \
141                 for(i=((reg)>>2);i<((reg)>>2)+(count);i++)\
142                         r300_reg_flags[i]|=(mark);
143
144 #define MARK_SAFE               1
145 #define MARK_CHECK_OFFSET       2
146
147 #define ADD_RANGE(reg, count)   ADD_RANGE_MARK(reg, count, MARK_SAFE)
148
149         /* these match cmducs() command in r300_driver/r300/r300_cmdbuf.c */
150         ADD_RANGE(R300_SE_VPORT_XSCALE, 6);
151         ADD_RANGE(0x2080, 1);
152         ADD_RANGE(R300_SE_VTE_CNTL, 2);
153         ADD_RANGE(0x2134, 2);
154         ADD_RANGE(0x2140, 1);
155         ADD_RANGE(R300_VAP_INPUT_CNTL_0, 2);
156         ADD_RANGE(0x21DC, 1);
157         ADD_RANGE(0x221C, 1);
158         ADD_RANGE(0x2220, 4);
159         ADD_RANGE(0x2288, 1);
160         ADD_RANGE(R300_VAP_OUTPUT_VTX_FMT_0, 2);
161         ADD_RANGE(R300_VAP_PVS_CNTL_1, 3);
162         ADD_RANGE(R300_GB_ENABLE, 1);
163         ADD_RANGE(R300_GB_MSPOS0, 5);
164         ADD_RANGE(R300_TX_ENABLE, 1);
165         ADD_RANGE(0x4200, 4);
166         ADD_RANGE(0x4214, 1);
167         ADD_RANGE(R300_RE_POINTSIZE, 1);
168         ADD_RANGE(0x4230, 3);
169         ADD_RANGE(R300_RE_LINE_CNT, 1);
170         ADD_RANGE(0x4238, 1);
171         ADD_RANGE(0x4260, 3);
172         ADD_RANGE(0x4274, 4);
173         ADD_RANGE(0x4288, 5);
174         ADD_RANGE(0x42A0, 1);
175         ADD_RANGE(R300_RE_ZBIAS_T_FACTOR, 4);
176         ADD_RANGE(0x42B4, 1);
177         ADD_RANGE(R300_RE_CULL_CNTL, 1);
178         ADD_RANGE(0x42C0, 2);
179         ADD_RANGE(R300_RS_CNTL_0, 2);
180         ADD_RANGE(R300_RS_INTERP_0, 8);
181         ADD_RANGE(R300_RS_ROUTE_0, 8);
182         ADD_RANGE(0x43A4, 2);
183         ADD_RANGE(0x43E8, 1);
184         ADD_RANGE(R300_PFS_CNTL_0, 3);
185         ADD_RANGE(R300_PFS_NODE_0, 4);
186         ADD_RANGE(R300_PFS_TEXI_0, 64);
187         ADD_RANGE(0x46A4, 5);
188         ADD_RANGE(R300_PFS_INSTR0_0, 64);
189         ADD_RANGE(R300_PFS_INSTR1_0, 64);
190         ADD_RANGE(R300_PFS_INSTR2_0, 64);
191         ADD_RANGE(R300_PFS_INSTR3_0, 64);
192         ADD_RANGE(0x4BC0, 1);
193         ADD_RANGE(0x4BC8, 3);
194         ADD_RANGE(R300_PP_ALPHA_TEST, 2);
195         ADD_RANGE(0x4BD8, 1);
196         ADD_RANGE(R300_PFS_PARAM_0_X, 64);
197         ADD_RANGE(0x4E00, 1);
198         ADD_RANGE(R300_RB3D_CBLEND, 2);
199         ADD_RANGE(R300_RB3D_COLORMASK, 1);
200         ADD_RANGE(0x4E10, 3);
201         ADD_RANGE_MARK(R300_RB3D_COLOROFFSET0, 1, MARK_CHECK_OFFSET);   /* check offset */
202         ADD_RANGE(R300_RB3D_COLORPITCH0, 1);
203         ADD_RANGE(0x4E50, 9);
204         ADD_RANGE(0x4E88, 1);
205         ADD_RANGE(0x4EA0, 2);
206         ADD_RANGE(R300_RB3D_ZSTENCIL_CNTL_0, 3);
207         ADD_RANGE(0x4F10, 4);
208         ADD_RANGE_MARK(R300_RB3D_DEPTHOFFSET, 1, MARK_CHECK_OFFSET);    /* check offset */
209         ADD_RANGE(R300_RB3D_DEPTHPITCH, 1);
210         ADD_RANGE(0x4F28, 1);
211         ADD_RANGE(0x4F30, 2);
212         ADD_RANGE(0x4F44, 1);
213         ADD_RANGE(0x4F54, 1);
214
215         ADD_RANGE(R300_TX_FILTER_0, 16);
216         ADD_RANGE(R300_TX_UNK1_0, 16);
217         ADD_RANGE(R300_TX_SIZE_0, 16);
218         ADD_RANGE(R300_TX_FORMAT_0, 16);
219         /* Texture offset is dangerous and needs more checking */
220         ADD_RANGE_MARK(R300_TX_OFFSET_0, 16, MARK_CHECK_OFFSET);
221         ADD_RANGE(R300_TX_UNK4_0, 16);
222         ADD_RANGE(R300_TX_BORDER_COLOR_0, 16);
223
224         /* Sporadic registers used as primitives are emitted */
225         ADD_RANGE(0x4f18, 1);
226         ADD_RANGE(R300_RB3D_DSTCACHE_CTLSTAT, 1);
227         ADD_RANGE(R300_VAP_INPUT_ROUTE_0_0, 8);
228         ADD_RANGE(R300_VAP_INPUT_ROUTE_1_0, 8);
229
230 }
231
232 static __inline__ int r300_check_range(unsigned reg, int count)
233 {
234         int i;
235         if (reg & ~0xffff)
236                 return -1;
237         for (i = (reg >> 2); i < (reg >> 2) + count; i++)
238                 if (r300_reg_flags[i] != MARK_SAFE)
239                         return 1;
240         return 0;
241 }
242
243   /* we expect offsets passed to the framebuffer to be either within video memory or
244      within AGP space */
245 static __inline__ int r300_check_offset(drm_radeon_private_t * dev_priv,
246                                         u32 offset)
247 {
248         /* we realy want to check against end of video aperture
249            but this value is not being kept.
250            This code is correct for now (does the same thing as the
251            code that sets MC_FB_LOCATION) in radeon_cp.c */
252         if ((offset >= dev_priv->fb_location) &&
253             (offset < dev_priv->gart_vm_start))
254                 return 0;
255         if ((offset >= dev_priv->gart_vm_start) &&
256             (offset < dev_priv->gart_vm_start + dev_priv->gart_size))
257                 return 0;
258         return 1;
259 }
260
261 static __inline__ int r300_emit_carefully_checked_packet0(drm_radeon_private_t *
262                                                           dev_priv,
263                                                           drm_radeon_kcmd_buffer_t
264                                                           * cmdbuf,
265                                                           drm_r300_cmd_header_t
266                                                           header)
267 {
268         int reg;
269         int sz;
270         int i;
271         int values[64];
272         RING_LOCALS;
273
274         sz = header.packet0.count;
275         reg = (header.packet0.reghi << 8) | header.packet0.reglo;
276
277         if ((sz > 64) || (sz < 0)) {
278                 DRM_ERROR
279                     ("Cannot emit more than 64 values at a time (reg=%04x sz=%d)\n",
280                      reg, sz);
281                 return DRM_ERR(EINVAL);
282         }
283         for (i = 0; i < sz; i++) {
284                 values[i] = ((int *)cmdbuf->buf)[i];
285                 switch (r300_reg_flags[(reg >> 2) + i]) {
286                 case MARK_SAFE:
287                         break;
288                 case MARK_CHECK_OFFSET:
289                         if (r300_check_offset(dev_priv, (u32) values[i])) {
290                                 DRM_ERROR
291                                     ("Offset failed range check (reg=%04x sz=%d)\n",
292                                      reg, sz);
293                                 return DRM_ERR(EINVAL);
294                         }
295                         break;
296                 default:
297                         DRM_ERROR("Register %04x failed check as flag=%02x\n",
298                                   reg + i * 4, r300_reg_flags[(reg >> 2) + i]);
299                         return DRM_ERR(EINVAL);
300                 }
301         }
302
303         BEGIN_RING(1 + sz);
304         OUT_RING(CP_PACKET0(reg, sz - 1));
305         OUT_RING_TABLE(values, sz);
306         ADVANCE_RING();
307
308         cmdbuf->buf += sz * 4;
309         cmdbuf->bufsz -= sz * 4;
310
311         return 0;
312 }
313
314 /**
315  * Emits a packet0 setting arbitrary registers.
316  * Called by r300_do_cp_cmdbuf.
317  *
318  * Note that checks are performed on contents and addresses of the registers
319  */
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)
323 {
324         int reg;
325         int sz;
326         RING_LOCALS;
327
328         sz = header.packet0.count;
329         reg = (header.packet0.reghi << 8) | header.packet0.reglo;
330
331         if (!sz)
332                 return 0;
333
334         if (sz * 4 > cmdbuf->bufsz)
335                 return DRM_ERR(EINVAL);
336
337         if (reg + sz * 4 >= 0x10000) {
338                 DRM_ERROR("No such registers in hardware reg=%04x sz=%d\n", reg,
339                           sz);
340                 return DRM_ERR(EINVAL);
341         }
342
343         if (r300_check_range(reg, sz)) {
344                 /* go and check everything */
345                 return r300_emit_carefully_checked_packet0(dev_priv, cmdbuf,
346                                                            header);
347         }
348         /* the rest of the data is safe to emit, whatever the values the user passed */
349
350         BEGIN_RING(1 + sz);
351         OUT_RING(CP_PACKET0(reg, sz - 1));
352         OUT_RING_TABLE((int *)cmdbuf->buf, sz);
353         ADVANCE_RING();
354
355         cmdbuf->buf += sz * 4;
356         cmdbuf->bufsz -= sz * 4;
357
358         return 0;
359 }
360
361 /**
362  * Uploads user-supplied vertex program instructions or parameters onto
363  * the graphics card.
364  * Called by r300_do_cp_cmdbuf.
365  */
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)
369 {
370         int sz;
371         int addr;
372         RING_LOCALS;
373
374         sz = header.vpu.count;
375         addr = (header.vpu.adrhi << 8) | header.vpu.adrlo;
376
377         if (!sz)
378                 return 0;
379         if (sz * 16 > cmdbuf->bufsz)
380                 return DRM_ERR(EINVAL);
381
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);
390
391         ADVANCE_RING();
392
393         cmdbuf->buf += sz * 16;
394         cmdbuf->bufsz -= sz * 16;
395
396         return 0;
397 }
398
399 /**
400  * Emit a clear packet from userspace.
401  * Called by r300_emit_packet3.
402  */
403 static __inline__ int r300_emit_clear(drm_radeon_private_t * dev_priv,
404                                       drm_radeon_kcmd_buffer_t * cmdbuf)
405 {
406         RING_LOCALS;
407
408         if (8 * 4 > cmdbuf->bufsz)
409                 return DRM_ERR(EINVAL);
410
411         BEGIN_RING(10);
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);
416         ADVANCE_RING();
417
418         cmdbuf->buf += 8 * 4;
419         cmdbuf->bufsz -= 8 * 4;
420
421         return 0;
422 }
423
424 static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t * dev_priv,
425                                                drm_radeon_kcmd_buffer_t * cmdbuf,
426                                                u32 header)
427 {
428         int count, i, k;
429 #define MAX_ARRAY_PACKET  64
430         u32 payload[MAX_ARRAY_PACKET];
431         u32 narrays;
432         RING_LOCALS;
433
434         count = (header >> 16) & 0x3fff;
435
436         if ((count + 1) > MAX_ARRAY_PACKET) {
437                 DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
438                           count);
439                 return DRM_ERR(EINVAL);
440         }
441         memset(payload, 0, MAX_ARRAY_PACKET * 4);
442         memcpy(payload, cmdbuf->buf + 4, (count + 1) * 4);
443
444         /* carefully check packet contents */
445
446         narrays = payload[0];
447         k = 0;
448         i = 1;
449         while ((k < narrays) && (i < (count + 1))) {
450                 i++;            /* skip attribute field */
451                 if (r300_check_offset(dev_priv, payload[i])) {
452                         DRM_ERROR
453                             ("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
454                              k, i);
455                         return DRM_ERR(EINVAL);
456                 }
457                 k++;
458                 i++;
459                 if (k == narrays)
460                         break;
461                 /* have one more to process, they come in pairs */
462                 if (r300_check_offset(dev_priv, payload[i])) {
463                         DRM_ERROR
464                             ("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
465                              k, i);
466                         return DRM_ERR(EINVAL);
467                 }
468                 k++;
469                 i++;
470         }
471         /* do the counts match what we expect ? */
472         if ((k != narrays) || (i != (count + 1))) {
473                 DRM_ERROR
474                     ("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
475                      k, i, narrays, count + 1);
476                 return DRM_ERR(EINVAL);
477         }
478
479         /* all clear, output packet */
480
481         BEGIN_RING(count + 2);
482         OUT_RING(header);
483         OUT_RING_TABLE(payload, count + 1);
484         ADVANCE_RING();
485
486         cmdbuf->buf += (count + 2) * 4;
487         cmdbuf->bufsz -= (count + 2) * 4;
488
489         return 0;
490 }
491
492 static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t * dev_priv,
493                                             drm_radeon_kcmd_buffer_t * cmdbuf)
494 {
495         u32 header;
496         int count;
497         RING_LOCALS;
498
499         if (4 > cmdbuf->bufsz)
500                 return DRM_ERR(EINVAL);
501
502         /* Fixme !! This simply emits a packet without much checking.
503            We need to be smarter. */
504
505         /* obtain first word - actual packet3 header */
506         header = *(u32 *) cmdbuf->buf;
507
508         /* Is it packet 3 ? */
509         if ((header >> 30) != 0x3) {
510                 DRM_ERROR("Not a packet3 header (0x%08x)\n", header);
511                 return DRM_ERR(EINVAL);
512         }
513
514         count = (header >> 16) & 0x3fff;
515
516         /* Check again now that we know how much data to expect */
517         if ((count + 2) * 4 > cmdbuf->bufsz) {
518                 DRM_ERROR
519                     ("Expected packet3 of length %d but have only %d bytes left\n",
520                      (count + 2) * 4, cmdbuf->bufsz);
521                 return DRM_ERR(EINVAL);
522         }
523
524         /* Is it a packet type we know about ? */
525         switch (header & 0xff00) {
526         case RADEON_3D_LOAD_VBPNTR:     /* load vertex array pointers */
527                 return r300_emit_3d_load_vbpntr(dev_priv, cmdbuf, header);
528
529         case RADEON_CP_3D_DRAW_IMMD_2:  /* triggers drawing using in-packet vertex data */
530         case RADEON_CP_3D_DRAW_VBUF_2:  /* triggers drawing of vertex buffers setup elsewhere */
531         case RADEON_CP_3D_DRAW_INDX_2:  /* triggers drawing using indices to vertex buffer */
532         case RADEON_CP_INDX_BUFFER:     /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
533         case RADEON_WAIT_FOR_IDLE:
534         case RADEON_CP_NOP:
535                 /* these packets are safe */
536                 break;
537         default:
538                 DRM_ERROR("Unknown packet3 header (0x%08x)\n", header);
539                 return DRM_ERR(EINVAL);
540         }
541
542         BEGIN_RING(count + 2);
543         OUT_RING(header);
544         OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
545         ADVANCE_RING();
546
547         cmdbuf->buf += (count + 2) * 4;
548         cmdbuf->bufsz -= (count + 2) * 4;
549
550         return 0;
551 }
552
553 /**
554  * Emit a rendering packet3 from userspace.
555  * Called by r300_do_cp_cmdbuf.
556  */
557 static __inline__ int r300_emit_packet3(drm_radeon_private_t * dev_priv,
558                                         drm_radeon_kcmd_buffer_t * cmdbuf,
559                                         drm_r300_cmd_header_t header)
560 {
561         int n;
562         int ret;
563         char *orig_buf = cmdbuf->buf;
564         int orig_bufsz = cmdbuf->bufsz;
565
566         /* This is a do-while-loop so that we run the interior at least once,
567          * even if cmdbuf->nbox is 0. Compare r300_emit_cliprects for rationale.
568          */
569         n = 0;
570         do {
571                 if (cmdbuf->nbox > R300_SIMULTANEOUS_CLIPRECTS) {
572                         ret = r300_emit_cliprects(dev_priv, cmdbuf, n);
573                         if (ret)
574                                 return ret;
575
576                         cmdbuf->buf = orig_buf;
577                         cmdbuf->bufsz = orig_bufsz;
578                 }
579
580                 switch (header.packet3.packet) {
581                 case R300_CMD_PACKET3_CLEAR:
582                         DRM_DEBUG("R300_CMD_PACKET3_CLEAR\n");
583                         ret = r300_emit_clear(dev_priv, cmdbuf);
584                         if (ret) {
585                                 DRM_ERROR("r300_emit_clear failed\n");
586                                 return ret;
587                         }
588                         break;
589
590                 case R300_CMD_PACKET3_RAW:
591                         DRM_DEBUG("R300_CMD_PACKET3_RAW\n");
592                         ret = r300_emit_raw_packet3(dev_priv, cmdbuf);
593                         if (ret) {
594                                 DRM_ERROR("r300_emit_raw_packet3 failed\n");
595                                 return ret;
596                         }
597                         break;
598
599                 default:
600                         DRM_ERROR("bad packet3 type %i at %p\n",
601                                   header.packet3.packet,
602                                   cmdbuf->buf - sizeof(header));
603                         return DRM_ERR(EINVAL);
604                 }
605
606                 n += R300_SIMULTANEOUS_CLIPRECTS;
607         } while (n < cmdbuf->nbox);
608
609         return 0;
610 }
611
612 /* Some of the R300 chips seem to be extremely touchy about the two registers
613  * that are configured in r300_pacify.
614  * Among the worst offenders seems to be the R300 ND (0x4E44): When userspace
615  * sends a command buffer that contains only state setting commands and a
616  * vertex program/parameter upload sequence, this will eventually lead to a
617  * lockup, unless the sequence is bracketed by calls to r300_pacify.
618  * So we should take great care to *always* call r300_pacify before
619  * *anything* 3D related, and again afterwards. This is what the
620  * call bracket in r300_do_cp_cmdbuf is for.
621  */
622
623 /**
624  * Emit the sequence to pacify R300.
625  */
626 static __inline__ void r300_pacify(drm_radeon_private_t * dev_priv)
627 {
628         RING_LOCALS;
629
630         BEGIN_RING(6);
631         OUT_RING(CP_PACKET0(R300_RB3D_DSTCACHE_CTLSTAT, 0));
632         OUT_RING(0xa);
633         OUT_RING(CP_PACKET0(0x4f18, 0));
634         OUT_RING(0x3);
635         OUT_RING(CP_PACKET3(RADEON_CP_NOP, 0));
636         OUT_RING(0x0);
637         ADVANCE_RING();
638 }
639
640 /**
641  * Called by r300_do_cp_cmdbuf to update the internal buffer age and state.
642  * The actual age emit is done by r300_do_cp_cmdbuf, which is why you must
643  * be careful about how this function is called.
644  */
645 static void r300_discard_buffer(drm_device_t * dev, drm_buf_t * buf)
646 {
647         drm_radeon_private_t *dev_priv = dev->dev_private;
648         drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
649
650         buf_priv->age = ++dev_priv->sarea_priv->last_dispatch;
651         buf->pending = 1;
652         buf->used = 0;
653 }
654
655 /**
656  * Parses and validates a user-supplied command buffer and emits appropriate
657  * commands on the DMA ring buffer.
658  * Called by the ioctl handler function radeon_cp_cmdbuf.
659  */
660 int r300_do_cp_cmdbuf(drm_device_t * dev,
661                       DRMFILE filp,
662                       drm_file_t * filp_priv, drm_radeon_kcmd_buffer_t * cmdbuf)
663 {
664         drm_radeon_private_t *dev_priv = dev->dev_private;
665         drm_device_dma_t *dma = dev->dma;
666         drm_buf_t *buf = NULL;
667         int emit_dispatch_age = 0;
668         int ret = 0;
669
670         DRM_DEBUG("\n");
671
672         /* See the comment above r300_emit_begin3d for why this call must be here,
673          * and what the cleanup gotos are for. */
674         r300_pacify(dev_priv);
675
676         if (cmdbuf->nbox <= R300_SIMULTANEOUS_CLIPRECTS) {
677                 ret = r300_emit_cliprects(dev_priv, cmdbuf, 0);
678                 if (ret)
679                         goto cleanup;
680         }
681
682         while (cmdbuf->bufsz >= sizeof(drm_r300_cmd_header_t)) {
683                 int idx;
684                 drm_r300_cmd_header_t header;
685
686                 header.u = *(unsigned int *)cmdbuf->buf;
687
688                 cmdbuf->buf += sizeof(header);
689                 cmdbuf->bufsz -= sizeof(header);
690
691                 switch (header.header.cmd_type) {
692                 case R300_CMD_PACKET0:
693                         DRM_DEBUG("R300_CMD_PACKET0\n");
694                         ret = r300_emit_packet0(dev_priv, cmdbuf, header);
695                         if (ret) {
696                                 DRM_ERROR("r300_emit_packet0 failed\n");
697                                 goto cleanup;
698                         }
699                         break;
700
701                 case R300_CMD_VPU:
702                         DRM_DEBUG("R300_CMD_VPU\n");
703                         ret = r300_emit_vpu(dev_priv, cmdbuf, header);
704                         if (ret) {
705                                 DRM_ERROR("r300_emit_vpu failed\n");
706                                 goto cleanup;
707                         }
708                         break;
709
710                 case R300_CMD_PACKET3:
711                         DRM_DEBUG("R300_CMD_PACKET3\n");
712                         ret = r300_emit_packet3(dev_priv, cmdbuf, header);
713                         if (ret) {
714                                 DRM_ERROR("r300_emit_packet3 failed\n");
715                                 goto cleanup;
716                         }
717                         break;
718
719                 case R300_CMD_END3D:
720                         DRM_DEBUG("R300_CMD_END3D\n");
721                         /* TODO:
722                            Ideally userspace driver should not need to issue this call,
723                            i.e. the drm driver should issue it automatically and prevent
724                            lockups.
725
726                            In practice, we do not understand why this call is needed and what
727                            it does (except for some vague guesses that it has to do with cache
728                            coherence) and so the user space driver does it.
729
730                            Once we are sure which uses prevent lockups the code could be moved
731                            into the kernel and the userspace driver will not
732                            need to use this command.
733
734                            Note that issuing this command does not hurt anything
735                            except, possibly, performance */
736                         r300_pacify(dev_priv);
737                         break;
738
739                 case R300_CMD_CP_DELAY:
740                         /* simple enough, we can do it here */
741                         DRM_DEBUG("R300_CMD_CP_DELAY\n");
742                         {
743                                 int i;
744                                 RING_LOCALS;
745
746                                 BEGIN_RING(header.delay.count);
747                                 for (i = 0; i < header.delay.count; i++)
748                                         OUT_RING(RADEON_CP_PACKET2);
749                                 ADVANCE_RING();
750                         }
751                         break;
752
753                 case R300_CMD_DMA_DISCARD:
754                         DRM_DEBUG("RADEON_CMD_DMA_DISCARD\n");
755                         idx = header.dma.buf_idx;
756                         if (idx < 0 || idx >= dma->buf_count) {
757                                 DRM_ERROR("buffer index %d (of %d max)\n",
758                                           idx, dma->buf_count - 1);
759                                 ret = DRM_ERR(EINVAL);
760                                 goto cleanup;
761                         }
762
763                         buf = dma->buflist[idx];
764                         if (buf->filp != filp || buf->pending) {
765                                 DRM_ERROR("bad buffer %p %p %d\n",
766                                           buf->filp, filp, buf->pending);
767                                 ret = DRM_ERR(EINVAL);
768                                 goto cleanup;
769                         }
770
771                         emit_dispatch_age = 1;
772                         r300_discard_buffer(dev, buf);
773                         break;
774
775                 case R300_CMD_WAIT:
776                         /* simple enough, we can do it here */
777                         DRM_DEBUG("R300_CMD_WAIT\n");
778                         if (header.wait.flags == 0)
779                                 break;  /* nothing to do */
780
781                         {
782                                 RING_LOCALS;
783
784                                 BEGIN_RING(2);
785                                 OUT_RING(CP_PACKET0(RADEON_WAIT_UNTIL, 0));
786                                 OUT_RING((header.wait.flags & 0xf) << 14);
787                                 ADVANCE_RING();
788                         }
789                         break;
790
791                 default:
792                         DRM_ERROR("bad cmd_type %i at %p\n",
793                                   header.header.cmd_type,
794                                   cmdbuf->buf - sizeof(header));
795                         ret = DRM_ERR(EINVAL);
796                         goto cleanup;
797                 }
798         }
799
800         DRM_DEBUG("END\n");
801
802       cleanup:
803         r300_pacify(dev_priv);
804
805         /* We emit the vertex buffer age here, outside the pacifier "brackets"
806          * for two reasons:
807          *  (1) This may coalesce multiple age emissions into a single one and
808          *  (2) more importantly, some chips lock up hard when scratch registers
809          *      are written inside the pacifier bracket.
810          */
811         if (emit_dispatch_age) {
812                 RING_LOCALS;
813
814                 /* Emit the vertex buffer age */
815                 BEGIN_RING(2);
816                 RADEON_DISPATCH_AGE(dev_priv->sarea_priv->last_dispatch);
817                 ADVANCE_RING();
818         }
819
820         COMMIT_RING();
821
822         return ret;
823 }