SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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_CNTL, 1);
 165         ADD_RANGE(R300_TX_ENABLE, 1);
 166         ADD_RANGE(0x4200, 4);
 167         ADD_RANGE(0x4214, 1);
 168         ADD_RANGE(R300_RE_POINTSIZE, 1);
 169         ADD_RANGE(0x4230, 3);
 170         ADD_RANGE(R300_RE_LINE_CNT, 1);
 171         ADD_RANGE(0x4238, 1);
 172         ADD_RANGE(0x4260, 3);
 173         ADD_RANGE(0x4274, 4);
 174         ADD_RANGE(0x4288, 5);
 175         ADD_RANGE(0x42A0, 1);
 176         ADD_RANGE(R300_RE_ZBIAS_T_FACTOR, 4);
 177         ADD_RANGE(0x42B4, 1);
 178         ADD_RANGE(R300_RE_CULL_CNTL, 1);
 179         ADD_RANGE(0x42C0, 2);
 180         ADD_RANGE(R300_RS_CNTL_0, 2);
 181         ADD_RANGE(R300_RS_INTERP_0, 8);
 182         ADD_RANGE(R300_RS_ROUTE_0, 8);
 183         ADD_RANGE(0x43A4, 2);
 184         ADD_RANGE(0x43E8, 1);
 185         ADD_RANGE(R300_PFS_CNTL_0, 3);
 186         ADD_RANGE(R300_PFS_NODE_0, 4);
 187         ADD_RANGE(R300_PFS_TEXI_0, 64);
 188         ADD_RANGE(0x46A4, 5);
 189         ADD_RANGE(R300_PFS_INSTR0_0, 64);
 190         ADD_RANGE(R300_PFS_INSTR1_0, 64);
 191         ADD_RANGE(R300_PFS_INSTR2_0, 64);
 192         ADD_RANGE(R300_PFS_INSTR3_0, 64);
 193         ADD_RANGE(0x4BC0, 1);
 194         ADD_RANGE(0x4BC8, 3);
 195         ADD_RANGE(R300_PP_ALPHA_TEST, 2);
 196         ADD_RANGE(0x4BD8, 1);
 197         ADD_RANGE(R300_PFS_PARAM_0_X, 64);
 198         ADD_RANGE(0x4E00, 1);
 199         ADD_RANGE(R300_RB3D_CBLEND, 2);
 200         ADD_RANGE(R300_RB3D_COLORMASK, 1);
 201         ADD_RANGE(0x4E10, 3);
 202         ADD_RANGE_MARK(R300_RB3D_COLOROFFSET0, 1, MARK_CHECK_OFFSET);   /* check offset */
 203         ADD_RANGE(R300_RB3D_COLORPITCH0, 1);
 204         ADD_RANGE(0x4E50, 9);
 205         ADD_RANGE(0x4E88, 1);
 206         ADD_RANGE(0x4EA0, 2);
 207         ADD_RANGE(R300_RB3D_ZSTENCIL_CNTL_0, 3);
 208         ADD_RANGE(0x4F10, 4);
 209         ADD_RANGE_MARK(R300_RB3D_DEPTHOFFSET, 1, MARK_CHECK_OFFSET);    /* check offset */
 210         ADD_RANGE(R300_RB3D_DEPTHPITCH, 1);
 211         ADD_RANGE(0x4F28, 1);
 212         ADD_RANGE(0x4F30, 2);
 213         ADD_RANGE(0x4F44, 1);
 214         ADD_RANGE(0x4F54, 1);
 215
 216         ADD_RANGE(R300_TX_FILTER_0, 16);
 217         ADD_RANGE(R300_TX_UNK1_0, 16);
 218         ADD_RANGE(R300_TX_SIZE_0, 16);
 219         ADD_RANGE(R300_TX_FORMAT_0, 16);
 220         ADD_RANGE(R300_TX_PITCH_0, 16);
 221         /* Texture offset is dangerous and needs more checking */
 222         ADD_RANGE_MARK(R300_TX_OFFSET_0, 16, MARK_CHECK_OFFSET);
 223         ADD_RANGE(R300_TX_UNK4_0, 16);
 224         ADD_RANGE(R300_TX_BORDER_COLOR_0, 16);
 225
 226         /* Sporadic registers used as primitives are emitted */
 227         ADD_RANGE(0x4f18, 1);
 228         ADD_RANGE(R300_RB3D_DSTCACHE_CTLSTAT, 1);
 229         ADD_RANGE(R300_VAP_INPUT_ROUTE_0_0, 8);
 230         ADD_RANGE(R300_VAP_INPUT_ROUTE_1_0, 8);
 231
 232 }
 233
 234 static __inline__ int r300_check_range(unsigned reg, int count)
 235 {
 236         int i;
 237         if (reg & ~0xffff)
 238                 return -1;
 239         for (i = (reg >> 2); i < (reg >> 2) + count; i++)
 240                 if (r300_reg_flags[i] != MARK_SAFE)
 241                         return 1;
 242         return 0;
 243 }
 244
 245   /* we expect offsets passed to the framebuffer to be either within video memory or
 246      within AGP space */
 247 static __inline__ int r300_check_offset(drm_radeon_private_t *dev_priv,
 248                                         u32 offset)
 249 {
 250         /* we realy want to check against end of video aperture
 251            but this value is not being kept.
 252            This code is correct for now (does the same thing as the
 253            code that sets MC_FB_LOCATION) in radeon_cp.c */
 254         if ((offset >= dev_priv->fb_location) &&
 255             (offset < dev_priv->gart_vm_start))
 256                 return 0;
 257         if ((offset >= dev_priv->gart_vm_start) &&
 258             (offset < dev_priv->gart_vm_start + dev_priv->gart_size))
 259                 return 0;
 260         return 1;
 261 }
 262
 263 static __inline__ int r300_emit_carefully_checked_packet0(drm_radeon_private_t *
 264                                                           dev_priv,
 265                                                           drm_radeon_kcmd_buffer_t
 266                                                           * cmdbuf,
 267                                                           drm_r300_cmd_header_t
 268                                                           header)
 269 {
 270         int reg;
 271         int sz;
 272         int i;
 273         int values[64];
 274         RING_LOCALS;
 275
 276         sz = header.packet0.count;
 277         reg = (header.packet0.reghi << 8) | header.packet0.reglo;
 278
 279         if ((sz > 64) || (sz < 0)) {
 280                 DRM_ERROR
 281                     ("Cannot emit more than 64 values at a time (reg=%04x sz=%d)\n",
 282                      reg, sz);
 283                 return DRM_ERR(EINVAL);
 284         }
 285         for (i = 0; i < sz; i++) {
 286                 values[i] = ((int *)cmdbuf->buf)[i];
 287                 switch (r300_reg_flags[(reg >> 2) + i]) {
 288                 case MARK_SAFE:
 289                         break;
 290                 case MARK_CHECK_OFFSET:
 291                         if (r300_check_offset(dev_priv, (u32) values[i])) {
 292                                 DRM_ERROR
 293                                     ("Offset failed range check (reg=%04x sz=%d)\n",
 294                                      reg, sz);
 295                                 return DRM_ERR(EINVAL);
 296                         }
 297                         break;
 298                 default:
 299                         DRM_ERROR("Register %04x failed check as flag=%02x\n",
 300                                   reg + i * 4, r300_reg_flags[(reg >> 2) + i]);
 301                         return DRM_ERR(EINVAL);
 302                 }
 303         }
 304
 305         BEGIN_RING(1 + sz);
 306         OUT_RING(CP_PACKET0(reg, sz - 1));
 307         OUT_RING_TABLE(values, sz);
 308         ADVANCE_RING();
 309
 310         cmdbuf->buf += sz * 4;
 311         cmdbuf->bufsz -= sz * 4;
 312
 313         return 0;
 314 }
 315
 316 /**
 317  * Emits a packet0 setting arbitrary registers.
 318  * Called by r300_do_cp_cmdbuf.
 319  *
 320  * Note that checks are performed on contents and addresses of the registers
 321  */
 322 static __inline__ int r300_emit_packet0(drm_radeon_private_t *dev_priv,
 323                                         drm_radeon_kcmd_buffer_t *cmdbuf,
 324                                         drm_r300_cmd_header_t header)
 325 {
 326         int reg;
 327         int sz;
 328         RING_LOCALS;
 329
 330         sz = header.packet0.count;
 331         reg = (header.packet0.reghi << 8) | header.packet0.reglo;
 332
 333         if (!sz)
 334                 return 0;
 335
 336         if (sz * 4 > cmdbuf->bufsz)
 337                 return DRM_ERR(EINVAL);
 338
 339         if (reg + sz * 4 >= 0x10000) {
 340                 DRM_ERROR("No such registers in hardware reg=%04x sz=%d\n", reg,
 341                           sz);
 342                 return DRM_ERR(EINVAL);
 343         }
 344
 345         if (r300_check_range(reg, sz)) {
 346                 /* go and check everything */
 347                 return r300_emit_carefully_checked_packet0(dev_priv, cmdbuf,
 348                                                            header);
 349         }
 350         /* the rest of the data is safe to emit, whatever the values the user passed */
 351
 352         BEGIN_RING(1 + sz);
 353         OUT_RING(CP_PACKET0(reg, sz - 1));
 354         OUT_RING_TABLE((int *)cmdbuf->buf, sz);
 355         ADVANCE_RING();
 356
 357         cmdbuf->buf += sz * 4;
 358         cmdbuf->bufsz -= sz * 4;
 359
 360         return 0;
 361 }
 362
 363 /**
 364  * Uploads user-supplied vertex program instructions or parameters onto
 365  * the graphics card.
 366  * Called by r300_do_cp_cmdbuf.
 367  */
 368 static __inline__ int r300_emit_vpu(drm_radeon_private_t *dev_priv,
 369                                     drm_radeon_kcmd_buffer_t *cmdbuf,
 370                                     drm_r300_cmd_header_t header)
 371 {
 372         int sz;
 373         int addr;
 374         RING_LOCALS;
 375
 376         sz = header.vpu.count;
 377         addr = (header.vpu.adrhi << 8) | header.vpu.adrlo;
 378
 379         if (!sz)
 380                 return 0;
 381         if (sz * 16 > cmdbuf->bufsz)
 382                 return DRM_ERR(EINVAL);
 383
 384         BEGIN_RING(5 + sz * 4);
 385         /* Wait for VAP to come to senses.. */
 386         /* there is no need to emit it multiple times, (only once before VAP is programmed,
 387            but this optimization is for later */
 388         OUT_RING_REG(R300_VAP_PVS_WAITIDLE, 0);
 389         OUT_RING_REG(R300_VAP_PVS_UPLOAD_ADDRESS, addr);
 390         OUT_RING(CP_PACKET0_TABLE(R300_VAP_PVS_UPLOAD_DATA, sz * 4 - 1));
 391         OUT_RING_TABLE((int *)cmdbuf->buf, sz * 4);
 392
 393         ADVANCE_RING();
 394
 395         cmdbuf->buf += sz * 16;
 396         cmdbuf->bufsz -= sz * 16;
 397
 398         return 0;
 399 }
 400
 401 /**
 402  * Emit a clear packet from userspace.
 403  * Called by r300_emit_packet3.
 404  */
 405 static __inline__ int r300_emit_clear(drm_radeon_private_t *dev_priv,
 406                                       drm_radeon_kcmd_buffer_t *cmdbuf)
 407 {
 408         RING_LOCALS;
 409
 410         if (8 * 4 > cmdbuf->bufsz)
 411                 return DRM_ERR(EINVAL);
 412
 413         BEGIN_RING(10);
 414         OUT_RING(CP_PACKET3(R200_3D_DRAW_IMMD_2, 8));
 415         OUT_RING(R300_PRIM_TYPE_POINT | R300_PRIM_WALK_RING |
 416                  (1 << R300_PRIM_NUM_VERTICES_SHIFT));
 417         OUT_RING_TABLE((int *)cmdbuf->buf, 8);
 418         ADVANCE_RING();
 419
 420         cmdbuf->buf += 8 * 4;
 421         cmdbuf->bufsz -= 8 * 4;
 422
 423         return 0;
 424 }
 425
 426 static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
 427                                                drm_radeon_kcmd_buffer_t *cmdbuf,
 428                                                u32 header)
 429 {
 430         int count, i, k;
 431 #define MAX_ARRAY_PACKET  64
 432         u32 payload[MAX_ARRAY_PACKET];
 433         u32 narrays;
 434         RING_LOCALS;
 435
 436         count = (header >> 16) & 0x3fff;
 437
 438         if ((count + 1) > MAX_ARRAY_PACKET) {
 439                 DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
 440                           count);
 441                 return DRM_ERR(EINVAL);
 442         }
 443         memset(payload, 0, MAX_ARRAY_PACKET * 4);
 444         memcpy(payload, cmdbuf->buf + 4, (count + 1) * 4);
 445
 446         /* carefully check packet contents */
 447
 448         narrays = payload[0];
 449         k = 0;
 450         i = 1;
 451         while ((k < narrays) && (i < (count + 1))) {
 452                 i++;            /* skip attribute field */
 453                 if (r300_check_offset(dev_priv, payload[i])) {
 454                         DRM_ERROR
 455                             ("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
 456                              k, i);
 457                         return DRM_ERR(EINVAL);
 458                 }
 459                 k++;
 460                 i++;
 461                 if (k == narrays)
 462                         break;
 463                 /* have one more to process, they come in pairs */
 464                 if (r300_check_offset(dev_priv, payload[i])) {
 465                         DRM_ERROR
 466                             ("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
 467                              k, i);
 468                         return DRM_ERR(EINVAL);
 469                 }
 470                 k++;
 471                 i++;
 472         }
 473         /* do the counts match what we expect ? */
 474         if ((k != narrays) || (i != (count + 1))) {
 475                 DRM_ERROR
 476                     ("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
 477                      k, i, narrays, count + 1);
 478                 return DRM_ERR(EINVAL);
 479         }
 480
 481         /* all clear, output packet */
 482
 483         BEGIN_RING(count + 2);
 484         OUT_RING(header);
 485         OUT_RING_TABLE(payload, count + 1);
 486         ADVANCE_RING();
 487
 488         cmdbuf->buf += (count + 2) * 4;
 489         cmdbuf->bufsz -= (count + 2) * 4;
 490
 491         return 0;
 492 }
 493 static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
 494                                              drm_radeon_kcmd_buffer_t *cmdbuf)
 495 {
 496         u32 *cmd = (u32 *) cmdbuf->buf;
 497         int count, ret;
 498         RING_LOCALS;
 499
 500         count=(cmd[0]>>16) & 0x3fff;
 501
 502         if (cmd[0] & 0x8000) {
 503                 u32 offset;
 504
 505                 if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL
 506                               | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
 507                         offset = cmd[2] << 10;
 508                         ret = r300_check_offset(dev_priv, offset);
 509                         if (ret)
 510                         {
 511                                 DRM_ERROR("Invalid bitblt first offset is %08X\n", offset);
 512                                 return DRM_ERR(EINVAL);
 513                         }
 514                 }
 515
 516                 if ((cmd[1] & RADEON_GMC_SRC_PITCH_OFFSET_CNTL) &&
 517                     (cmd[1] & RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
 518                         offset = cmd[3] << 10;
 519                         ret = r300_check_offset(dev_priv, offset);
 520                         if (ret)
 521                         {
 522                                 DRM_ERROR("Invalid bitblt second offset is %08X\n", offset);
 523                                 return DRM_ERR(EINVAL);
 524                         }
 525
 526                 }
 527         }
 528
 529         BEGIN_RING(count+2);
 530         OUT_RING(cmd[0]);
 531         OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
 532         ADVANCE_RING();
 533
 534         cmdbuf->buf += (count+2)*4;
 535         cmdbuf->bufsz -= (count+2)*4;
 536
 537         return 0;
 538 }
 539
 540 static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
 541                                             drm_radeon_kcmd_buffer_t *cmdbuf)
 542 {
 543         u32 header;
 544         int count;
 545         RING_LOCALS;
 546
 547         if (4 > cmdbuf->bufsz)
 548                 return DRM_ERR(EINVAL);
 549
 550         /* Fixme !! This simply emits a packet without much checking.
 551            We need to be smarter. */
 552
 553         /* obtain first word - actual packet3 header */
 554         header = *(u32 *) cmdbuf->buf;
 555
 556         /* Is it packet 3 ? */
 557         if ((header >> 30) != 0x3) {
 558                 DRM_ERROR("Not a packet3 header (0x%08x)\n", header);
 559                 return DRM_ERR(EINVAL);
 560         }
 561
 562         count = (header >> 16) & 0x3fff;
 563
 564         /* Check again now that we know how much data to expect */
 565         if ((count + 2) * 4 > cmdbuf->bufsz) {
 566                 DRM_ERROR
 567                     ("Expected packet3 of length %d but have only %d bytes left\n",
 568                      (count + 2) * 4, cmdbuf->bufsz);
 569                 return DRM_ERR(EINVAL);
 570         }
 571
 572         /* Is it a packet type we know about ? */
 573         switch (header & 0xff00) {
 574         case RADEON_3D_LOAD_VBPNTR:     /* load vertex array pointers */
 575                 return r300_emit_3d_load_vbpntr(dev_priv, cmdbuf, header);
 576
 577         case RADEON_CNTL_BITBLT_MULTI:
 578                 return r300_emit_bitblt_multi(dev_priv, cmdbuf);
 579
 580         case RADEON_CP_3D_DRAW_IMMD_2:  /* triggers drawing using in-packet vertex data */
 581         case RADEON_CP_3D_DRAW_VBUF_2:  /* triggers drawing of vertex buffers setup elsewhere */
 582         case RADEON_CP_3D_DRAW_INDX_2:  /* triggers drawing using indices to vertex buffer */
 583         case RADEON_CP_INDX_BUFFER:     /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
 584         case RADEON_WAIT_FOR_IDLE:
 585         case RADEON_CP_NOP:
 586                 /* these packets are safe */
 587                 break;
 588         default:
 589                 DRM_ERROR("Unknown packet3 header (0x%08x)\n", header);
 590                 return DRM_ERR(EINVAL);
 591         }
 592
 593         BEGIN_RING(count + 2);
 594         OUT_RING(header);
 595         OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
 596         ADVANCE_RING();
 597
 598         cmdbuf->buf += (count + 2) * 4;
 599         cmdbuf->bufsz -= (count + 2) * 4;
 600
 601         return 0;
 602 }
 603
 604 /**
 605  * Emit a rendering packet3 from userspace.
 606  * Called by r300_do_cp_cmdbuf.
 607  */
 608 static __inline__ int r300_emit_packet3(drm_radeon_private_t *dev_priv,
 609                                         drm_radeon_kcmd_buffer_t *cmdbuf,
 610                                         drm_r300_cmd_header_t header)
 611 {
 612         int n;
 613         int ret;
 614         char *orig_buf = cmdbuf->buf;
 615         int orig_bufsz = cmdbuf->bufsz;
 616
 617         /* This is a do-while-loop so that we run the interior at least once,
 618          * even if cmdbuf->nbox is 0. Compare r300_emit_cliprects for rationale.
 619          */
 620         n = 0;
 621         do {
 622                 if (cmdbuf->nbox > R300_SIMULTANEOUS_CLIPRECTS) {
 623                         ret = r300_emit_cliprects(dev_priv, cmdbuf, n);
 624                         if (ret)
 625                                 return ret;
 626
 627                         cmdbuf->buf = orig_buf;
 628                         cmdbuf->bufsz = orig_bufsz;
 629                 }
 630
 631                 switch (header.packet3.packet) {
 632                 case R300_CMD_PACKET3_CLEAR:
 633                         DRM_DEBUG("R300_CMD_PACKET3_CLEAR\n");
 634                         ret = r300_emit_clear(dev_priv, cmdbuf);
 635                         if (ret) {
 636                                 DRM_ERROR("r300_emit_clear failed\n");
 637                                 return ret;
 638                         }
 639                         break;
 640
 641                 case R300_CMD_PACKET3_RAW:
 642                         DRM_DEBUG("R300_CMD_PACKET3_RAW\n");
 643                         ret = r300_emit_raw_packet3(dev_priv, cmdbuf);
 644                         if (ret) {
 645                                 DRM_ERROR("r300_emit_raw_packet3 failed\n");
 646                                 return ret;
 647                         }
 648                         break;
 649
 650                 default:
 651                         DRM_ERROR("bad packet3 type %i at %p\n",
 652                                   header.packet3.packet,
 653                                   cmdbuf->buf - sizeof(header));
 654                         return DRM_ERR(EINVAL);
 655                 }
 656
 657                 n += R300_SIMULTANEOUS_CLIPRECTS;
 658         } while (n < cmdbuf->nbox);
 659
 660         return 0;
 661 }
 662
 663 /* Some of the R300 chips seem to be extremely touchy about the two registers
 664  * that are configured in r300_pacify.
 665  * Among the worst offenders seems to be the R300 ND (0x4E44): When userspace
 666  * sends a command buffer that contains only state setting commands and a
 667  * vertex program/parameter upload sequence, this will eventually lead to a
 668  * lockup, unless the sequence is bracketed by calls to r300_pacify.
 669  * So we should take great care to *always* call r300_pacify before
 670  * *anything* 3D related, and again afterwards. This is what the
 671  * call bracket in r300_do_cp_cmdbuf is for.
 672  */
 673
 674 /**
 675  * Emit the sequence to pacify R300.
 676  */
 677 static __inline__ void r300_pacify(drm_radeon_private_t *dev_priv)
 678 {
 679         RING_LOCALS;
 680
 681         BEGIN_RING(6);
 682         OUT_RING(CP_PACKET0(R300_RB3D_DSTCACHE_CTLSTAT, 0));
 683         OUT_RING(0xa);
 684         OUT_RING(CP_PACKET0(0x4f18, 0));
 685         OUT_RING(0x3);
 686         OUT_RING(CP_PACKET3(RADEON_CP_NOP, 0));
 687         OUT_RING(0x0);
 688         ADVANCE_RING();
 689 }
 690
 691 /**
 692  * Called by r300_do_cp_cmdbuf to update the internal buffer age and state.
 693  * The actual age emit is done by r300_do_cp_cmdbuf, which is why you must
 694  * be careful about how this function is called.
 695  */
 696 static void r300_discard_buffer(drm_device_t * dev, drm_buf_t * buf)
 697 {
 698         drm_radeon_private_t *dev_priv = dev->dev_private;
 699         drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
 700
 701         buf_priv->age = ++dev_priv->sarea_priv->last_dispatch;
 702         buf->pending = 1;
 703         buf->used = 0;
 704 }
 705
 706 /**
 707  * Parses and validates a user-supplied command buffer and emits appropriate
 708  * commands on the DMA ring buffer.
 709  * Called by the ioctl handler function radeon_cp_cmdbuf.
 710  */
 711 int r300_do_cp_cmdbuf(drm_device_t *dev,
 712                       DRMFILE filp,
 713                       drm_file_t *filp_priv,
 714                       drm_radeon_kcmd_buffer_t *cmdbuf)
 715 {
 716         drm_radeon_private_t *dev_priv = dev->dev_private;
 717         drm_device_dma_t *dma = dev->dma;
 718         drm_buf_t *buf = NULL;
 719         int emit_dispatch_age = 0;
 720         int ret = 0;
 721
 722         DRM_DEBUG("\n");
 723
 724         /* See the comment above r300_emit_begin3d for why this call must be here,
 725          * and what the cleanup gotos are for. */
 726         r300_pacify(dev_priv);
 727
 728         if (cmdbuf->nbox <= R300_SIMULTANEOUS_CLIPRECTS) {
 729                 ret = r300_emit_cliprects(dev_priv, cmdbuf, 0);
 730                 if (ret)
 731                         goto cleanup;
 732         }
 733
 734         while (cmdbuf->bufsz >= sizeof(drm_r300_cmd_header_t)) {
 735                 int idx;
 736                 drm_r300_cmd_header_t header;
 737
 738                 header.u = *(unsigned int *)cmdbuf->buf;
 739
 740                 cmdbuf->buf += sizeof(header);
 741                 cmdbuf->bufsz -= sizeof(header);
 742
 743                 switch (header.header.cmd_type) {
 744                 case R300_CMD_PACKET0:
 745                         DRM_DEBUG("R300_CMD_PACKET0\n");
 746                         ret = r300_emit_packet0(dev_priv, cmdbuf, header);
 747                         if (ret) {
 748                                 DRM_ERROR("r300_emit_packet0 failed\n");
 749                                 goto cleanup;
 750                         }
 751                         break;
 752
 753                 case R300_CMD_VPU:
 754                         DRM_DEBUG("R300_CMD_VPU\n");
 755                         ret = r300_emit_vpu(dev_priv, cmdbuf, header);
 756                         if (ret) {
 757                                 DRM_ERROR("r300_emit_vpu failed\n");
 758                                 goto cleanup;
 759                         }
 760                         break;
 761
 762                 case R300_CMD_PACKET3:
 763                         DRM_DEBUG("R300_CMD_PACKET3\n");
 764                         ret = r300_emit_packet3(dev_priv, cmdbuf, header);
 765                         if (ret) {
 766                                 DRM_ERROR("r300_emit_packet3 failed\n");
 767                                 goto cleanup;
 768                         }
 769                         break;
 770
 771                 case R300_CMD_END3D:
 772                         DRM_DEBUG("R300_CMD_END3D\n");
 773                         /* TODO:
 774                            Ideally userspace driver should not need to issue this call,
 775                            i.e. the drm driver should issue it automatically and prevent
 776                            lockups.
 777
 778                            In practice, we do not understand why this call is needed and what
 779                            it does (except for some vague guesses that it has to do with cache
 780                            coherence) and so the user space driver does it.
 781
 782                            Once we are sure which uses prevent lockups the code could be moved
 783                            into the kernel and the userspace driver will not
 784                            need to use this command.
 785
 786                            Note that issuing this command does not hurt anything
 787                            except, possibly, performance */
 788                         r300_pacify(dev_priv);
 789                         break;
 790
 791                 case R300_CMD_CP_DELAY:
 792                         /* simple enough, we can do it here */
 793                         DRM_DEBUG("R300_CMD_CP_DELAY\n");
 794                         {
 795                                 int i;
 796                                 RING_LOCALS;
 797
 798                                 BEGIN_RING(header.delay.count);
 799                                 for (i = 0; i < header.delay.count; i++)
 800                                         OUT_RING(RADEON_CP_PACKET2);
 801                                 ADVANCE_RING();
 802                         }
 803                         break;
 804
 805                 case R300_CMD_DMA_DISCARD:
 806                         DRM_DEBUG("RADEON_CMD_DMA_DISCARD\n");
 807                         idx = header.dma.buf_idx;
 808                         if (idx < 0 || idx >= dma->buf_count) {
 809                                 DRM_ERROR("buffer index %d (of %d max)\n",
 810                                           idx, dma->buf_count - 1);
 811                                 ret = DRM_ERR(EINVAL);
 812                                 goto cleanup;
 813                         }
 814
 815                         buf = dma->buflist[idx];
 816                         if (buf->filp != filp || buf->pending) {
 817                                 DRM_ERROR("bad buffer %p %p %d\n",
 818                                           buf->filp, filp, buf->pending);
 819                                 ret = DRM_ERR(EINVAL);
 820                                 goto cleanup;
 821                         }
 822
 823                         emit_dispatch_age = 1;
 824                         r300_discard_buffer(dev, buf);
 825                         break;
 826
 827                 case R300_CMD_WAIT:
 828                         /* simple enough, we can do it here */
 829                         DRM_DEBUG("R300_CMD_WAIT\n");
 830                         if (header.wait.flags == 0)
 831                                 break;  /* nothing to do */
 832
 833                         {
 834                                 RING_LOCALS;
 835
 836                                 BEGIN_RING(2);
 837                                 OUT_RING(CP_PACKET0(RADEON_WAIT_UNTIL, 0));
 838                                 OUT_RING((header.wait.flags & 0xf) << 14);
 839                                 ADVANCE_RING();
 840                         }
 841                         break;
 842
 843                 default:
 844                         DRM_ERROR("bad cmd_type %i at %p\n",
 845                                   header.header.cmd_type,
 846                                   cmdbuf->buf - sizeof(header));
 847                         ret = DRM_ERR(EINVAL);
 848                         goto cleanup;
 849                 }
 850         }
 851
 852         DRM_DEBUG("END\n");
 853
 854       cleanup:
 855         r300_pacify(dev_priv);
 856
 857         /* We emit the vertex buffer age here, outside the pacifier "brackets"
 858          * for two reasons:
 859          *  (1) This may coalesce multiple age emissions into a single one and
 860          *  (2) more importantly, some chips lock up hard when scratch registers
 861          *      are written inside the pacifier bracket.
 862          */
 863         if (emit_dispatch_age) {
 864                 RING_LOCALS;
 865
 866                 /* Emit the vertex buffer age */
 867                 BEGIN_RING(2);
 868                 RADEON_DISPATCH_AGE(dev_priv->sarea_priv->last_dispatch);
 869                 ADVANCE_RING();
 870         }
 871
 872         COMMIT_RING();
 873
 874         return ret;
 875 }