1 /* 2 * Copyright 2007 Stephane Marchesin 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragr) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 #include "priv.h" 25 #include "regs.h" 26 27 #include <core/client.h> 28 #include <core/gpuobj.h> 29 #include <engine/fifo.h> 30 #include <engine/fifo/chan.h> 31 #include <subdev/instmem.h> 32 #include <subdev/timer.h> 33 34 static u32 35 nv04_gr_ctx_regs[] = { 36 0x0040053c, 37 0x00400544, 38 0x00400540, 39 0x00400548, 40 NV04_PGRAPH_CTX_SWITCH1, 41 NV04_PGRAPH_CTX_SWITCH2, 42 NV04_PGRAPH_CTX_SWITCH3, 43 NV04_PGRAPH_CTX_SWITCH4, 44 NV04_PGRAPH_CTX_CACHE1, 45 NV04_PGRAPH_CTX_CACHE2, 46 NV04_PGRAPH_CTX_CACHE3, 47 NV04_PGRAPH_CTX_CACHE4, 48 0x00400184, 49 0x004001a4, 50 0x004001c4, 51 0x004001e4, 52 0x00400188, 53 0x004001a8, 54 0x004001c8, 55 0x004001e8, 56 0x0040018c, 57 0x004001ac, 58 0x004001cc, 59 0x004001ec, 60 0x00400190, 61 0x004001b0, 62 0x004001d0, 63 0x004001f0, 64 0x00400194, 65 0x004001b4, 66 0x004001d4, 67 0x004001f4, 68 0x00400198, 69 0x004001b8, 70 0x004001d8, 71 0x004001f8, 72 0x0040019c, 73 0x004001bc, 74 0x004001dc, 75 0x004001fc, 76 0x00400174, 77 NV04_PGRAPH_DMA_START_0, 78 NV04_PGRAPH_DMA_START_1, 79 NV04_PGRAPH_DMA_LENGTH, 80 NV04_PGRAPH_DMA_MISC, 81 NV04_PGRAPH_DMA_PITCH, 82 NV04_PGRAPH_BOFFSET0, 83 NV04_PGRAPH_BBASE0, 84 NV04_PGRAPH_BLIMIT0, 85 NV04_PGRAPH_BOFFSET1, 86 NV04_PGRAPH_BBASE1, 87 NV04_PGRAPH_BLIMIT1, 88 NV04_PGRAPH_BOFFSET2, 89 NV04_PGRAPH_BBASE2, 90 NV04_PGRAPH_BLIMIT2, 91 NV04_PGRAPH_BOFFSET3, 92 NV04_PGRAPH_BBASE3, 93 NV04_PGRAPH_BLIMIT3, 94 NV04_PGRAPH_BOFFSET4, 95 NV04_PGRAPH_BBASE4, 96 NV04_PGRAPH_BLIMIT4, 97 NV04_PGRAPH_BOFFSET5, 98 NV04_PGRAPH_BBASE5, 99 NV04_PGRAPH_BLIMIT5, 100 NV04_PGRAPH_BPITCH0, 101 NV04_PGRAPH_BPITCH1, 102 NV04_PGRAPH_BPITCH2, 103 NV04_PGRAPH_BPITCH3, 104 NV04_PGRAPH_BPITCH4, 105 NV04_PGRAPH_SURFACE, 106 NV04_PGRAPH_STATE, 107 NV04_PGRAPH_BSWIZZLE2, 108 NV04_PGRAPH_BSWIZZLE5, 109 NV04_PGRAPH_BPIXEL, 110 NV04_PGRAPH_NOTIFY, 111 NV04_PGRAPH_PATT_COLOR0, 112 NV04_PGRAPH_PATT_COLOR1, 113 NV04_PGRAPH_PATT_COLORRAM+0x00, 114 NV04_PGRAPH_PATT_COLORRAM+0x04, 115 NV04_PGRAPH_PATT_COLORRAM+0x08, 116 NV04_PGRAPH_PATT_COLORRAM+0x0c, 117 NV04_PGRAPH_PATT_COLORRAM+0x10, 118 NV04_PGRAPH_PATT_COLORRAM+0x14, 119 NV04_PGRAPH_PATT_COLORRAM+0x18, 120 NV04_PGRAPH_PATT_COLORRAM+0x1c, 121 NV04_PGRAPH_PATT_COLORRAM+0x20, 122 NV04_PGRAPH_PATT_COLORRAM+0x24, 123 NV04_PGRAPH_PATT_COLORRAM+0x28, 124 NV04_PGRAPH_PATT_COLORRAM+0x2c, 125 NV04_PGRAPH_PATT_COLORRAM+0x30, 126 NV04_PGRAPH_PATT_COLORRAM+0x34, 127 NV04_PGRAPH_PATT_COLORRAM+0x38, 128 NV04_PGRAPH_PATT_COLORRAM+0x3c, 129 NV04_PGRAPH_PATT_COLORRAM+0x40, 130 NV04_PGRAPH_PATT_COLORRAM+0x44, 131 NV04_PGRAPH_PATT_COLORRAM+0x48, 132 NV04_PGRAPH_PATT_COLORRAM+0x4c, 133 NV04_PGRAPH_PATT_COLORRAM+0x50, 134 NV04_PGRAPH_PATT_COLORRAM+0x54, 135 NV04_PGRAPH_PATT_COLORRAM+0x58, 136 NV04_PGRAPH_PATT_COLORRAM+0x5c, 137 NV04_PGRAPH_PATT_COLORRAM+0x60, 138 NV04_PGRAPH_PATT_COLORRAM+0x64, 139 NV04_PGRAPH_PATT_COLORRAM+0x68, 140 NV04_PGRAPH_PATT_COLORRAM+0x6c, 141 NV04_PGRAPH_PATT_COLORRAM+0x70, 142 NV04_PGRAPH_PATT_COLORRAM+0x74, 143 NV04_PGRAPH_PATT_COLORRAM+0x78, 144 NV04_PGRAPH_PATT_COLORRAM+0x7c, 145 NV04_PGRAPH_PATT_COLORRAM+0x80, 146 NV04_PGRAPH_PATT_COLORRAM+0x84, 147 NV04_PGRAPH_PATT_COLORRAM+0x88, 148 NV04_PGRAPH_PATT_COLORRAM+0x8c, 149 NV04_PGRAPH_PATT_COLORRAM+0x90, 150 NV04_PGRAPH_PATT_COLORRAM+0x94, 151 NV04_PGRAPH_PATT_COLORRAM+0x98, 152 NV04_PGRAPH_PATT_COLORRAM+0x9c, 153 NV04_PGRAPH_PATT_COLORRAM+0xa0, 154 NV04_PGRAPH_PATT_COLORRAM+0xa4, 155 NV04_PGRAPH_PATT_COLORRAM+0xa8, 156 NV04_PGRAPH_PATT_COLORRAM+0xac, 157 NV04_PGRAPH_PATT_COLORRAM+0xb0, 158 NV04_PGRAPH_PATT_COLORRAM+0xb4, 159 NV04_PGRAPH_PATT_COLORRAM+0xb8, 160 NV04_PGRAPH_PATT_COLORRAM+0xbc, 161 NV04_PGRAPH_PATT_COLORRAM+0xc0, 162 NV04_PGRAPH_PATT_COLORRAM+0xc4, 163 NV04_PGRAPH_PATT_COLORRAM+0xc8, 164 NV04_PGRAPH_PATT_COLORRAM+0xcc, 165 NV04_PGRAPH_PATT_COLORRAM+0xd0, 166 NV04_PGRAPH_PATT_COLORRAM+0xd4, 167 NV04_PGRAPH_PATT_COLORRAM+0xd8, 168 NV04_PGRAPH_PATT_COLORRAM+0xdc, 169 NV04_PGRAPH_PATT_COLORRAM+0xe0, 170 NV04_PGRAPH_PATT_COLORRAM+0xe4, 171 NV04_PGRAPH_PATT_COLORRAM+0xe8, 172 NV04_PGRAPH_PATT_COLORRAM+0xec, 173 NV04_PGRAPH_PATT_COLORRAM+0xf0, 174 NV04_PGRAPH_PATT_COLORRAM+0xf4, 175 NV04_PGRAPH_PATT_COLORRAM+0xf8, 176 NV04_PGRAPH_PATT_COLORRAM+0xfc, 177 NV04_PGRAPH_PATTERN, 178 0x0040080c, 179 NV04_PGRAPH_PATTERN_SHAPE, 180 0x00400600, 181 NV04_PGRAPH_ROP3, 182 NV04_PGRAPH_CHROMA, 183 NV04_PGRAPH_BETA_AND, 184 NV04_PGRAPH_BETA_PREMULT, 185 NV04_PGRAPH_CONTROL0, 186 NV04_PGRAPH_CONTROL1, 187 NV04_PGRAPH_CONTROL2, 188 NV04_PGRAPH_BLEND, 189 NV04_PGRAPH_STORED_FMT, 190 NV04_PGRAPH_SOURCE_COLOR, 191 0x00400560, 192 0x00400568, 193 0x00400564, 194 0x0040056c, 195 0x00400400, 196 0x00400480, 197 0x00400404, 198 0x00400484, 199 0x00400408, 200 0x00400488, 201 0x0040040c, 202 0x0040048c, 203 0x00400410, 204 0x00400490, 205 0x00400414, 206 0x00400494, 207 0x00400418, 208 0x00400498, 209 0x0040041c, 210 0x0040049c, 211 0x00400420, 212 0x004004a0, 213 0x00400424, 214 0x004004a4, 215 0x00400428, 216 0x004004a8, 217 0x0040042c, 218 0x004004ac, 219 0x00400430, 220 0x004004b0, 221 0x00400434, 222 0x004004b4, 223 0x00400438, 224 0x004004b8, 225 0x0040043c, 226 0x004004bc, 227 0x00400440, 228 0x004004c0, 229 0x00400444, 230 0x004004c4, 231 0x00400448, 232 0x004004c8, 233 0x0040044c, 234 0x004004cc, 235 0x00400450, 236 0x004004d0, 237 0x00400454, 238 0x004004d4, 239 0x00400458, 240 0x004004d8, 241 0x0040045c, 242 0x004004dc, 243 0x00400460, 244 0x004004e0, 245 0x00400464, 246 0x004004e4, 247 0x00400468, 248 0x004004e8, 249 0x0040046c, 250 0x004004ec, 251 0x00400470, 252 0x004004f0, 253 0x00400474, 254 0x004004f4, 255 0x00400478, 256 0x004004f8, 257 0x0040047c, 258 0x004004fc, 259 0x00400534, 260 0x00400538, 261 0x00400514, 262 0x00400518, 263 0x0040051c, 264 0x00400520, 265 0x00400524, 266 0x00400528, 267 0x0040052c, 268 0x00400530, 269 0x00400d00, 270 0x00400d40, 271 0x00400d80, 272 0x00400d04, 273 0x00400d44, 274 0x00400d84, 275 0x00400d08, 276 0x00400d48, 277 0x00400d88, 278 0x00400d0c, 279 0x00400d4c, 280 0x00400d8c, 281 0x00400d10, 282 0x00400d50, 283 0x00400d90, 284 0x00400d14, 285 0x00400d54, 286 0x00400d94, 287 0x00400d18, 288 0x00400d58, 289 0x00400d98, 290 0x00400d1c, 291 0x00400d5c, 292 0x00400d9c, 293 0x00400d20, 294 0x00400d60, 295 0x00400da0, 296 0x00400d24, 297 0x00400d64, 298 0x00400da4, 299 0x00400d28, 300 0x00400d68, 301 0x00400da8, 302 0x00400d2c, 303 0x00400d6c, 304 0x00400dac, 305 0x00400d30, 306 0x00400d70, 307 0x00400db0, 308 0x00400d34, 309 0x00400d74, 310 0x00400db4, 311 0x00400d38, 312 0x00400d78, 313 0x00400db8, 314 0x00400d3c, 315 0x00400d7c, 316 0x00400dbc, 317 0x00400590, 318 0x00400594, 319 0x00400598, 320 0x0040059c, 321 0x004005a8, 322 0x004005ac, 323 0x004005b0, 324 0x004005b4, 325 0x004005c0, 326 0x004005c4, 327 0x004005c8, 328 0x004005cc, 329 0x004005d0, 330 0x004005d4, 331 0x004005d8, 332 0x004005dc, 333 0x004005e0, 334 NV04_PGRAPH_PASSTHRU_0, 335 NV04_PGRAPH_PASSTHRU_1, 336 NV04_PGRAPH_PASSTHRU_2, 337 NV04_PGRAPH_DVD_COLORFMT, 338 NV04_PGRAPH_SCALED_FORMAT, 339 NV04_PGRAPH_MISC24_0, 340 NV04_PGRAPH_MISC24_1, 341 NV04_PGRAPH_MISC24_2, 342 0x00400500, 343 0x00400504, 344 NV04_PGRAPH_VALID1, 345 NV04_PGRAPH_VALID2, 346 NV04_PGRAPH_DEBUG_3 347 }; 348 349 #define nv04_gr(p) container_of((p), struct nv04_gr, base) 350 351 struct nv04_gr { 352 struct nvkm_gr base; 353 struct nv04_gr_chan *chan[16]; 354 spinlock_t lock; 355 }; 356 357 #define nv04_gr_chan(p) container_of((p), struct nv04_gr_chan, object) 358 359 struct nv04_gr_chan { 360 struct nvkm_object object; 361 struct nv04_gr *gr; 362 int chid; 363 u32 nv04[ARRAY_SIZE(nv04_gr_ctx_regs)]; 364 }; 365 366 /******************************************************************************* 367 * Graphics object classes 368 ******************************************************************************/ 369 370 /* 371 * Software methods, why they are needed, and how they all work: 372 * 373 * NV04 and NV05 keep most of the state in PGRAPH context itself, but some 374 * 2d engine settings are kept inside the grobjs themselves. The grobjs are 375 * 3 words long on both. grobj format on NV04 is: 376 * 377 * word 0: 378 * - bits 0-7: class 379 * - bit 12: color key active 380 * - bit 13: clip rect active 381 * - bit 14: if set, destination surface is swizzled and taken from buffer 5 382 * [set by NV04_SWIZZLED_SURFACE], otherwise it's linear and taken 383 * from buffer 0 [set by NV04_CONTEXT_SURFACES_2D or 384 * NV03_CONTEXT_SURFACE_DST]. 385 * - bits 15-17: 2d operation [aka patch config] 386 * - bit 24: patch valid [enables rendering using this object] 387 * - bit 25: surf3d valid [for tex_tri and multitex_tri only] 388 * word 1: 389 * - bits 0-1: mono format 390 * - bits 8-13: color format 391 * - bits 16-31: DMA_NOTIFY instance 392 * word 2: 393 * - bits 0-15: DMA_A instance 394 * - bits 16-31: DMA_B instance 395 * 396 * On NV05 it's: 397 * 398 * word 0: 399 * - bits 0-7: class 400 * - bit 12: color key active 401 * - bit 13: clip rect active 402 * - bit 14: if set, destination surface is swizzled and taken from buffer 5 403 * [set by NV04_SWIZZLED_SURFACE], otherwise it's linear and taken 404 * from buffer 0 [set by NV04_CONTEXT_SURFACES_2D or 405 * NV03_CONTEXT_SURFACE_DST]. 406 * - bits 15-17: 2d operation [aka patch config] 407 * - bits 20-22: dither mode 408 * - bit 24: patch valid [enables rendering using this object] 409 * - bit 25: surface_dst/surface_color/surf2d/surf3d valid 410 * - bit 26: surface_src/surface_zeta valid 411 * - bit 27: pattern valid 412 * - bit 28: rop valid 413 * - bit 29: beta1 valid 414 * - bit 30: beta4 valid 415 * word 1: 416 * - bits 0-1: mono format 417 * - bits 8-13: color format 418 * - bits 16-31: DMA_NOTIFY instance 419 * word 2: 420 * - bits 0-15: DMA_A instance 421 * - bits 16-31: DMA_B instance 422 * 423 * NV05 will set/unset the relevant valid bits when you poke the relevant 424 * object-binding methods with object of the proper type, or with the NULL 425 * type. It'll only allow rendering using the grobj if all needed objects 426 * are bound. The needed set of objects depends on selected operation: for 427 * example rop object is needed by ROP_AND, but not by SRCCOPY_AND. 428 * 429 * NV04 doesn't have these methods implemented at all, and doesn't have the 430 * relevant bits in grobj. Instead, it'll allow rendering whenever bit 24 431 * is set. So we have to emulate them in software, internally keeping the 432 * same bits as NV05 does. Since grobjs are aligned to 16 bytes on nv04, 433 * but the last word isn't actually used for anything, we abuse it for this 434 * purpose. 435 * 436 * Actually, NV05 can optionally check bit 24 too, but we disable this since 437 * there's no use for it. 438 * 439 * For unknown reasons, NV04 implements surf3d binding in hardware as an 440 * exception. Also for unknown reasons, NV04 doesn't implement the clipping 441 * methods on the surf3d object, so we have to emulate them too. 442 */ 443 444 static void 445 nv04_gr_set_ctx1(struct nvkm_device *device, u32 inst, u32 mask, u32 value) 446 { 447 int subc = (nvkm_rd32(device, NV04_PGRAPH_TRAPPED_ADDR) >> 13) & 0x7; 448 u32 tmp; 449 450 tmp = nvkm_rd32(device, 0x700000 + inst); 451 tmp &= ~mask; 452 tmp |= value; 453 nvkm_wr32(device, 0x700000 + inst, tmp); 454 455 nvkm_wr32(device, NV04_PGRAPH_CTX_SWITCH1, tmp); 456 nvkm_wr32(device, NV04_PGRAPH_CTX_CACHE1 + (subc << 2), tmp); 457 } 458 459 static void 460 nv04_gr_set_ctx_val(struct nvkm_device *device, u32 inst, u32 mask, u32 value) 461 { 462 int class, op, valid = 1; 463 u32 tmp, ctx1; 464 465 ctx1 = nvkm_rd32(device, 0x700000 + inst); 466 class = ctx1 & 0xff; 467 op = (ctx1 >> 15) & 7; 468 469 tmp = nvkm_rd32(device, 0x70000c + inst); 470 tmp &= ~mask; 471 tmp |= value; 472 nvkm_wr32(device, 0x70000c + inst, tmp); 473 474 /* check for valid surf2d/surf_dst/surf_color */ 475 if (!(tmp & 0x02000000)) 476 valid = 0; 477 /* check for valid surf_src/surf_zeta */ 478 if ((class == 0x1f || class == 0x48) && !(tmp & 0x04000000)) 479 valid = 0; 480 481 switch (op) { 482 /* SRCCOPY_AND, SRCCOPY: no extra objects required */ 483 case 0: 484 case 3: 485 break; 486 /* ROP_AND: requires pattern and rop */ 487 case 1: 488 if (!(tmp & 0x18000000)) 489 valid = 0; 490 break; 491 /* BLEND_AND: requires beta1 */ 492 case 2: 493 if (!(tmp & 0x20000000)) 494 valid = 0; 495 break; 496 /* SRCCOPY_PREMULT, BLEND_PREMULT: beta4 required */ 497 case 4: 498 case 5: 499 if (!(tmp & 0x40000000)) 500 valid = 0; 501 break; 502 } 503 504 nv04_gr_set_ctx1(device, inst, 0x01000000, valid << 24); 505 } 506 507 static bool 508 nv04_gr_mthd_set_operation(struct nvkm_device *device, u32 inst, u32 data) 509 { 510 u8 class = nvkm_rd32(device, 0x700000) & 0x000000ff; 511 if (data > 5) 512 return false; 513 /* Old versions of the objects only accept first three operations. */ 514 if (data > 2 && class < 0x40) 515 return false; 516 nv04_gr_set_ctx1(device, inst, 0x00038000, data << 15); 517 /* changing operation changes set of objects needed for validation */ 518 nv04_gr_set_ctx_val(device, inst, 0, 0); 519 return true; 520 } 521 522 static bool 523 nv04_gr_mthd_surf3d_clip_h(struct nvkm_device *device, u32 inst, u32 data) 524 { 525 u32 min = data & 0xffff, max; 526 u32 w = data >> 16; 527 if (min & 0x8000) 528 /* too large */ 529 return false; 530 if (w & 0x8000) 531 /* yes, it accepts negative for some reason. */ 532 w |= 0xffff0000; 533 max = min + w; 534 max &= 0x3ffff; 535 nvkm_wr32(device, 0x40053c, min); 536 nvkm_wr32(device, 0x400544, max); 537 return true; 538 } 539 540 static bool 541 nv04_gr_mthd_surf3d_clip_v(struct nvkm_device *device, u32 inst, u32 data) 542 { 543 u32 min = data & 0xffff, max; 544 u32 w = data >> 16; 545 if (min & 0x8000) 546 /* too large */ 547 return false; 548 if (w & 0x8000) 549 /* yes, it accepts negative for some reason. */ 550 w |= 0xffff0000; 551 max = min + w; 552 max &= 0x3ffff; 553 nvkm_wr32(device, 0x400540, min); 554 nvkm_wr32(device, 0x400548, max); 555 return true; 556 } 557 558 static u8 559 nv04_gr_mthd_bind_class(struct nvkm_device *device, u32 inst) 560 { 561 return nvkm_rd32(device, 0x700000 + (inst << 4)); 562 } 563 564 static bool 565 nv04_gr_mthd_bind_surf2d(struct nvkm_device *device, u32 inst, u32 data) 566 { 567 switch (nv04_gr_mthd_bind_class(device, data)) { 568 case 0x30: 569 nv04_gr_set_ctx1(device, inst, 0x00004000, 0); 570 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0); 571 return true; 572 case 0x42: 573 nv04_gr_set_ctx1(device, inst, 0x00004000, 0); 574 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0x02000000); 575 return true; 576 } 577 return false; 578 } 579 580 static bool 581 nv04_gr_mthd_bind_surf2d_swzsurf(struct nvkm_device *device, u32 inst, u32 data) 582 { 583 switch (nv04_gr_mthd_bind_class(device, data)) { 584 case 0x30: 585 nv04_gr_set_ctx1(device, inst, 0x00004000, 0); 586 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0); 587 return true; 588 case 0x42: 589 nv04_gr_set_ctx1(device, inst, 0x00004000, 0); 590 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0x02000000); 591 return true; 592 case 0x52: 593 nv04_gr_set_ctx1(device, inst, 0x00004000, 0x00004000); 594 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0x02000000); 595 return true; 596 } 597 return false; 598 } 599 600 static bool 601 nv01_gr_mthd_bind_patt(struct nvkm_device *device, u32 inst, u32 data) 602 { 603 switch (nv04_gr_mthd_bind_class(device, data)) { 604 case 0x30: 605 nv04_gr_set_ctx_val(device, inst, 0x08000000, 0); 606 return true; 607 case 0x18: 608 nv04_gr_set_ctx_val(device, inst, 0x08000000, 0x08000000); 609 return true; 610 } 611 return false; 612 } 613 614 static bool 615 nv04_gr_mthd_bind_patt(struct nvkm_device *device, u32 inst, u32 data) 616 { 617 switch (nv04_gr_mthd_bind_class(device, data)) { 618 case 0x30: 619 nv04_gr_set_ctx_val(device, inst, 0x08000000, 0); 620 return true; 621 case 0x44: 622 nv04_gr_set_ctx_val(device, inst, 0x08000000, 0x08000000); 623 return true; 624 } 625 return false; 626 } 627 628 static bool 629 nv04_gr_mthd_bind_rop(struct nvkm_device *device, u32 inst, u32 data) 630 { 631 switch (nv04_gr_mthd_bind_class(device, data)) { 632 case 0x30: 633 nv04_gr_set_ctx_val(device, inst, 0x10000000, 0); 634 return true; 635 case 0x43: 636 nv04_gr_set_ctx_val(device, inst, 0x10000000, 0x10000000); 637 return true; 638 } 639 return false; 640 } 641 642 static bool 643 nv04_gr_mthd_bind_beta1(struct nvkm_device *device, u32 inst, u32 data) 644 { 645 switch (nv04_gr_mthd_bind_class(device, data)) { 646 case 0x30: 647 nv04_gr_set_ctx_val(device, inst, 0x20000000, 0); 648 return true; 649 case 0x12: 650 nv04_gr_set_ctx_val(device, inst, 0x20000000, 0x20000000); 651 return true; 652 } 653 return false; 654 } 655 656 static bool 657 nv04_gr_mthd_bind_beta4(struct nvkm_device *device, u32 inst, u32 data) 658 { 659 switch (nv04_gr_mthd_bind_class(device, data)) { 660 case 0x30: 661 nv04_gr_set_ctx_val(device, inst, 0x40000000, 0); 662 return true; 663 case 0x72: 664 nv04_gr_set_ctx_val(device, inst, 0x40000000, 0x40000000); 665 return true; 666 } 667 return false; 668 } 669 670 static bool 671 nv04_gr_mthd_bind_surf_dst(struct nvkm_device *device, u32 inst, u32 data) 672 { 673 switch (nv04_gr_mthd_bind_class(device, data)) { 674 case 0x30: 675 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0); 676 return true; 677 case 0x58: 678 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0x02000000); 679 return true; 680 } 681 return false; 682 } 683 684 static bool 685 nv04_gr_mthd_bind_surf_src(struct nvkm_device *device, u32 inst, u32 data) 686 { 687 switch (nv04_gr_mthd_bind_class(device, data)) { 688 case 0x30: 689 nv04_gr_set_ctx_val(device, inst, 0x04000000, 0); 690 return true; 691 case 0x59: 692 nv04_gr_set_ctx_val(device, inst, 0x04000000, 0x04000000); 693 return true; 694 } 695 return false; 696 } 697 698 static bool 699 nv04_gr_mthd_bind_surf_color(struct nvkm_device *device, u32 inst, u32 data) 700 { 701 switch (nv04_gr_mthd_bind_class(device, data)) { 702 case 0x30: 703 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0); 704 return true; 705 case 0x5a: 706 nv04_gr_set_ctx_val(device, inst, 0x02000000, 0x02000000); 707 return true; 708 } 709 return false; 710 } 711 712 static bool 713 nv04_gr_mthd_bind_surf_zeta(struct nvkm_device *device, u32 inst, u32 data) 714 { 715 switch (nv04_gr_mthd_bind_class(device, data)) { 716 case 0x30: 717 nv04_gr_set_ctx_val(device, inst, 0x04000000, 0); 718 return true; 719 case 0x5b: 720 nv04_gr_set_ctx_val(device, inst, 0x04000000, 0x04000000); 721 return true; 722 } 723 return false; 724 } 725 726 static bool 727 nv01_gr_mthd_bind_clip(struct nvkm_device *device, u32 inst, u32 data) 728 { 729 switch (nv04_gr_mthd_bind_class(device, data)) { 730 case 0x30: 731 nv04_gr_set_ctx1(device, inst, 0x2000, 0); 732 return true; 733 case 0x19: 734 nv04_gr_set_ctx1(device, inst, 0x2000, 0x2000); 735 return true; 736 } 737 return false; 738 } 739 740 static bool 741 nv01_gr_mthd_bind_chroma(struct nvkm_device *device, u32 inst, u32 data) 742 { 743 switch (nv04_gr_mthd_bind_class(device, data)) { 744 case 0x30: 745 nv04_gr_set_ctx1(device, inst, 0x1000, 0); 746 return true; 747 /* Yes, for some reason even the old versions of objects 748 * accept 0x57 and not 0x17. Consistency be damned. 749 */ 750 case 0x57: 751 nv04_gr_set_ctx1(device, inst, 0x1000, 0x1000); 752 return true; 753 } 754 return false; 755 } 756 757 static bool 758 nv03_gr_mthd_gdi(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 759 { 760 bool (*func)(struct nvkm_device *, u32, u32); 761 switch (mthd) { 762 case 0x0184: func = nv01_gr_mthd_bind_patt; break; 763 case 0x0188: func = nv04_gr_mthd_bind_rop; break; 764 case 0x018c: func = nv04_gr_mthd_bind_beta1; break; 765 case 0x0190: func = nv04_gr_mthd_bind_surf_dst; break; 766 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 767 default: 768 return false; 769 } 770 return func(device, inst, data); 771 } 772 773 static bool 774 nv04_gr_mthd_gdi(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 775 { 776 bool (*func)(struct nvkm_device *, u32, u32); 777 switch (mthd) { 778 case 0x0188: func = nv04_gr_mthd_bind_patt; break; 779 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 780 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 781 case 0x0194: func = nv04_gr_mthd_bind_beta4; break; 782 case 0x0198: func = nv04_gr_mthd_bind_surf2d; break; 783 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 784 default: 785 return false; 786 } 787 return func(device, inst, data); 788 } 789 790 static bool 791 nv01_gr_mthd_blit(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 792 { 793 bool (*func)(struct nvkm_device *, u32, u32); 794 switch (mthd) { 795 case 0x0184: func = nv01_gr_mthd_bind_chroma; break; 796 case 0x0188: func = nv01_gr_mthd_bind_clip; break; 797 case 0x018c: func = nv01_gr_mthd_bind_patt; break; 798 case 0x0190: func = nv04_gr_mthd_bind_rop; break; 799 case 0x0194: func = nv04_gr_mthd_bind_beta1; break; 800 case 0x0198: func = nv04_gr_mthd_bind_surf_dst; break; 801 case 0x019c: func = nv04_gr_mthd_bind_surf_src; break; 802 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 803 default: 804 return false; 805 } 806 return func(device, inst, data); 807 } 808 809 static bool 810 nv04_gr_mthd_blit(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 811 { 812 bool (*func)(struct nvkm_device *, u32, u32); 813 switch (mthd) { 814 case 0x0184: func = nv01_gr_mthd_bind_chroma; break; 815 case 0x0188: func = nv01_gr_mthd_bind_clip; break; 816 case 0x018c: func = nv04_gr_mthd_bind_patt; break; 817 case 0x0190: func = nv04_gr_mthd_bind_rop; break; 818 case 0x0194: func = nv04_gr_mthd_bind_beta1; break; 819 case 0x0198: func = nv04_gr_mthd_bind_beta4; break; 820 case 0x019c: func = nv04_gr_mthd_bind_surf2d; break; 821 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 822 default: 823 return false; 824 } 825 return func(device, inst, data); 826 } 827 828 static bool 829 nv04_gr_mthd_iifc(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 830 { 831 bool (*func)(struct nvkm_device *, u32, u32); 832 switch (mthd) { 833 case 0x0188: func = nv01_gr_mthd_bind_chroma; break; 834 case 0x018c: func = nv01_gr_mthd_bind_clip; break; 835 case 0x0190: func = nv04_gr_mthd_bind_patt; break; 836 case 0x0194: func = nv04_gr_mthd_bind_rop; break; 837 case 0x0198: func = nv04_gr_mthd_bind_beta1; break; 838 case 0x019c: func = nv04_gr_mthd_bind_beta4; break; 839 case 0x01a0: func = nv04_gr_mthd_bind_surf2d_swzsurf; break; 840 case 0x03e4: func = nv04_gr_mthd_set_operation; break; 841 default: 842 return false; 843 } 844 return func(device, inst, data); 845 } 846 847 static bool 848 nv01_gr_mthd_ifc(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 849 { 850 bool (*func)(struct nvkm_device *, u32, u32); 851 switch (mthd) { 852 case 0x0184: func = nv01_gr_mthd_bind_chroma; break; 853 case 0x0188: func = nv01_gr_mthd_bind_clip; break; 854 case 0x018c: func = nv01_gr_mthd_bind_patt; break; 855 case 0x0190: func = nv04_gr_mthd_bind_rop; break; 856 case 0x0194: func = nv04_gr_mthd_bind_beta1; break; 857 case 0x0198: func = nv04_gr_mthd_bind_surf_dst; break; 858 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 859 default: 860 return false; 861 } 862 return func(device, inst, data); 863 } 864 865 static bool 866 nv04_gr_mthd_ifc(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 867 { 868 bool (*func)(struct nvkm_device *, u32, u32); 869 switch (mthd) { 870 case 0x0184: func = nv01_gr_mthd_bind_chroma; break; 871 case 0x0188: func = nv01_gr_mthd_bind_clip; break; 872 case 0x018c: func = nv04_gr_mthd_bind_patt; break; 873 case 0x0190: func = nv04_gr_mthd_bind_rop; break; 874 case 0x0194: func = nv04_gr_mthd_bind_beta1; break; 875 case 0x0198: func = nv04_gr_mthd_bind_beta4; break; 876 case 0x019c: func = nv04_gr_mthd_bind_surf2d; break; 877 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 878 default: 879 return false; 880 } 881 return func(device, inst, data); 882 } 883 884 static bool 885 nv03_gr_mthd_sifc(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 886 { 887 bool (*func)(struct nvkm_device *, u32, u32); 888 switch (mthd) { 889 case 0x0184: func = nv01_gr_mthd_bind_chroma; break; 890 case 0x0188: func = nv01_gr_mthd_bind_patt; break; 891 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 892 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 893 case 0x0194: func = nv04_gr_mthd_bind_surf_dst; break; 894 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 895 default: 896 return false; 897 } 898 return func(device, inst, data); 899 } 900 901 static bool 902 nv04_gr_mthd_sifc(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 903 { 904 bool (*func)(struct nvkm_device *, u32, u32); 905 switch (mthd) { 906 case 0x0184: func = nv01_gr_mthd_bind_chroma; break; 907 case 0x0188: func = nv04_gr_mthd_bind_patt; break; 908 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 909 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 910 case 0x0194: func = nv04_gr_mthd_bind_beta4; break; 911 case 0x0198: func = nv04_gr_mthd_bind_surf2d; break; 912 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 913 default: 914 return false; 915 } 916 return func(device, inst, data); 917 } 918 919 static bool 920 nv03_gr_mthd_sifm(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 921 { 922 bool (*func)(struct nvkm_device *, u32, u32); 923 switch (mthd) { 924 case 0x0188: func = nv01_gr_mthd_bind_patt; break; 925 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 926 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 927 case 0x0194: func = nv04_gr_mthd_bind_surf_dst; break; 928 case 0x0304: func = nv04_gr_mthd_set_operation; break; 929 default: 930 return false; 931 } 932 return func(device, inst, data); 933 } 934 935 static bool 936 nv04_gr_mthd_sifm(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 937 { 938 bool (*func)(struct nvkm_device *, u32, u32); 939 switch (mthd) { 940 case 0x0188: func = nv04_gr_mthd_bind_patt; break; 941 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 942 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 943 case 0x0194: func = nv04_gr_mthd_bind_beta4; break; 944 case 0x0198: func = nv04_gr_mthd_bind_surf2d; break; 945 case 0x0304: func = nv04_gr_mthd_set_operation; break; 946 default: 947 return false; 948 } 949 return func(device, inst, data); 950 } 951 952 static bool 953 nv04_gr_mthd_surf3d(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 954 { 955 bool (*func)(struct nvkm_device *, u32, u32); 956 switch (mthd) { 957 case 0x02f8: func = nv04_gr_mthd_surf3d_clip_h; break; 958 case 0x02fc: func = nv04_gr_mthd_surf3d_clip_v; break; 959 default: 960 return false; 961 } 962 return func(device, inst, data); 963 } 964 965 static bool 966 nv03_gr_mthd_ttri(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 967 { 968 bool (*func)(struct nvkm_device *, u32, u32); 969 switch (mthd) { 970 case 0x0188: func = nv01_gr_mthd_bind_clip; break; 971 case 0x018c: func = nv04_gr_mthd_bind_surf_color; break; 972 case 0x0190: func = nv04_gr_mthd_bind_surf_zeta; break; 973 default: 974 return false; 975 } 976 return func(device, inst, data); 977 } 978 979 static bool 980 nv01_gr_mthd_prim(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 981 { 982 bool (*func)(struct nvkm_device *, u32, u32); 983 switch (mthd) { 984 case 0x0184: func = nv01_gr_mthd_bind_clip; break; 985 case 0x0188: func = nv01_gr_mthd_bind_patt; break; 986 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 987 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 988 case 0x0194: func = nv04_gr_mthd_bind_surf_dst; break; 989 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 990 default: 991 return false; 992 } 993 return func(device, inst, data); 994 } 995 996 static bool 997 nv04_gr_mthd_prim(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 998 { 999 bool (*func)(struct nvkm_device *, u32, u32); 1000 switch (mthd) { 1001 case 0x0184: func = nv01_gr_mthd_bind_clip; break; 1002 case 0x0188: func = nv04_gr_mthd_bind_patt; break; 1003 case 0x018c: func = nv04_gr_mthd_bind_rop; break; 1004 case 0x0190: func = nv04_gr_mthd_bind_beta1; break; 1005 case 0x0194: func = nv04_gr_mthd_bind_beta4; break; 1006 case 0x0198: func = nv04_gr_mthd_bind_surf2d; break; 1007 case 0x02fc: func = nv04_gr_mthd_set_operation; break; 1008 default: 1009 return false; 1010 } 1011 return func(device, inst, data); 1012 } 1013 1014 static bool 1015 nv04_gr_mthd(struct nvkm_device *device, u32 inst, u32 mthd, u32 data) 1016 { 1017 bool (*func)(struct nvkm_device *, u32, u32, u32); 1018 switch (nvkm_rd32(device, 0x700000 + inst) & 0x000000ff) { 1019 case 0x1c ... 0x1e: 1020 func = nv01_gr_mthd_prim; break; 1021 case 0x1f: func = nv01_gr_mthd_blit; break; 1022 case 0x21: func = nv01_gr_mthd_ifc; break; 1023 case 0x36: func = nv03_gr_mthd_sifc; break; 1024 case 0x37: func = nv03_gr_mthd_sifm; break; 1025 case 0x48: func = nv03_gr_mthd_ttri; break; 1026 case 0x4a: func = nv04_gr_mthd_gdi; break; 1027 case 0x4b: func = nv03_gr_mthd_gdi; break; 1028 case 0x53: func = nv04_gr_mthd_surf3d; break; 1029 case 0x5c ... 0x5e: 1030 func = nv04_gr_mthd_prim; break; 1031 case 0x5f: func = nv04_gr_mthd_blit; break; 1032 case 0x60: func = nv04_gr_mthd_iifc; break; 1033 case 0x61: func = nv04_gr_mthd_ifc; break; 1034 case 0x76: func = nv04_gr_mthd_sifc; break; 1035 case 0x77: func = nv04_gr_mthd_sifm; break; 1036 default: 1037 return false; 1038 } 1039 return func(device, inst, mthd, data); 1040 } 1041 1042 static int 1043 nv04_gr_object_bind(struct nvkm_object *object, struct nvkm_gpuobj *parent, 1044 int align, struct nvkm_gpuobj **pgpuobj) 1045 { 1046 int ret = nvkm_gpuobj_new(object->engine->subdev.device, 16, align, 1047 false, parent, pgpuobj); 1048 if (ret == 0) { 1049 nvkm_kmap(*pgpuobj); 1050 nvkm_wo32(*pgpuobj, 0x00, object->oclass); 1051 #ifdef __BIG_ENDIAN 1052 nvkm_mo32(*pgpuobj, 0x00, 0x00080000, 0x00080000); 1053 #endif 1054 nvkm_wo32(*pgpuobj, 0x04, 0x00000000); 1055 nvkm_wo32(*pgpuobj, 0x08, 0x00000000); 1056 nvkm_wo32(*pgpuobj, 0x0c, 0x00000000); 1057 nvkm_done(*pgpuobj); 1058 } 1059 return ret; 1060 } 1061 1062 const struct nvkm_object_func 1063 nv04_gr_object = { 1064 .bind = nv04_gr_object_bind, 1065 }; 1066 1067 /******************************************************************************* 1068 * PGRAPH context 1069 ******************************************************************************/ 1070 1071 static struct nv04_gr_chan * 1072 nv04_gr_channel(struct nv04_gr *gr) 1073 { 1074 struct nvkm_device *device = gr->base.engine.subdev.device; 1075 struct nv04_gr_chan *chan = NULL; 1076 if (nvkm_rd32(device, NV04_PGRAPH_CTX_CONTROL) & 0x00010000) { 1077 int chid = nvkm_rd32(device, NV04_PGRAPH_CTX_USER) >> 24; 1078 if (chid < ARRAY_SIZE(gr->chan)) 1079 chan = gr->chan[chid]; 1080 } 1081 return chan; 1082 } 1083 1084 static int 1085 nv04_gr_load_context(struct nv04_gr_chan *chan, int chid) 1086 { 1087 struct nvkm_device *device = chan->gr->base.engine.subdev.device; 1088 int i; 1089 1090 for (i = 0; i < ARRAY_SIZE(nv04_gr_ctx_regs); i++) 1091 nvkm_wr32(device, nv04_gr_ctx_regs[i], chan->nv04[i]); 1092 1093 nvkm_wr32(device, NV04_PGRAPH_CTX_CONTROL, 0x10010100); 1094 nvkm_mask(device, NV04_PGRAPH_CTX_USER, 0xff000000, chid << 24); 1095 nvkm_mask(device, NV04_PGRAPH_FFINTFC_ST2, 0xfff00000, 0x00000000); 1096 return 0; 1097 } 1098 1099 static int 1100 nv04_gr_unload_context(struct nv04_gr_chan *chan) 1101 { 1102 struct nvkm_device *device = chan->gr->base.engine.subdev.device; 1103 int i; 1104 1105 for (i = 0; i < ARRAY_SIZE(nv04_gr_ctx_regs); i++) 1106 chan->nv04[i] = nvkm_rd32(device, nv04_gr_ctx_regs[i]); 1107 1108 nvkm_wr32(device, NV04_PGRAPH_CTX_CONTROL, 0x10000000); 1109 nvkm_mask(device, NV04_PGRAPH_CTX_USER, 0xff000000, 0x0f000000); 1110 return 0; 1111 } 1112 1113 static void 1114 nv04_gr_context_switch(struct nv04_gr *gr) 1115 { 1116 struct nvkm_device *device = gr->base.engine.subdev.device; 1117 struct nv04_gr_chan *prev = NULL; 1118 struct nv04_gr_chan *next = NULL; 1119 int chid; 1120 1121 nv04_gr_idle(&gr->base); 1122 1123 /* If previous context is valid, we need to save it */ 1124 prev = nv04_gr_channel(gr); 1125 if (prev) 1126 nv04_gr_unload_context(prev); 1127 1128 /* load context for next channel */ 1129 chid = (nvkm_rd32(device, NV04_PGRAPH_TRAPPED_ADDR) >> 24) & 0x0f; 1130 next = gr->chan[chid]; 1131 if (next) 1132 nv04_gr_load_context(next, chid); 1133 } 1134 1135 static u32 *ctx_reg(struct nv04_gr_chan *chan, u32 reg) 1136 { 1137 int i; 1138 1139 for (i = 0; i < ARRAY_SIZE(nv04_gr_ctx_regs); i++) { 1140 if (nv04_gr_ctx_regs[i] == reg) 1141 return &chan->nv04[i]; 1142 } 1143 1144 return NULL; 1145 } 1146 1147 static void * 1148 nv04_gr_chan_dtor(struct nvkm_object *object) 1149 { 1150 struct nv04_gr_chan *chan = nv04_gr_chan(object); 1151 struct nv04_gr *gr = chan->gr; 1152 unsigned long flags; 1153 1154 spin_lock_irqsave(&gr->lock, flags); 1155 gr->chan[chan->chid] = NULL; 1156 spin_unlock_irqrestore(&gr->lock, flags); 1157 return chan; 1158 } 1159 1160 static int 1161 nv04_gr_chan_fini(struct nvkm_object *object, bool suspend) 1162 { 1163 struct nv04_gr_chan *chan = nv04_gr_chan(object); 1164 struct nv04_gr *gr = chan->gr; 1165 struct nvkm_device *device = gr->base.engine.subdev.device; 1166 unsigned long flags; 1167 1168 spin_lock_irqsave(&gr->lock, flags); 1169 nvkm_mask(device, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000); 1170 if (nv04_gr_channel(gr) == chan) 1171 nv04_gr_unload_context(chan); 1172 nvkm_mask(device, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001); 1173 spin_unlock_irqrestore(&gr->lock, flags); 1174 return 0; 1175 } 1176 1177 static const struct nvkm_object_func 1178 nv04_gr_chan = { 1179 .dtor = nv04_gr_chan_dtor, 1180 .fini = nv04_gr_chan_fini, 1181 }; 1182 1183 static int 1184 nv04_gr_chan_new(struct nvkm_gr *base, struct nvkm_fifo_chan *fifoch, 1185 const struct nvkm_oclass *oclass, struct nvkm_object **pobject) 1186 { 1187 struct nv04_gr *gr = nv04_gr(base); 1188 struct nv04_gr_chan *chan; 1189 unsigned long flags; 1190 1191 if (!(chan = kzalloc(sizeof(*chan), GFP_KERNEL))) 1192 return -ENOMEM; 1193 nvkm_object_ctor(&nv04_gr_chan, oclass, &chan->object); 1194 chan->gr = gr; 1195 chan->chid = fifoch->chid; 1196 *pobject = &chan->object; 1197 1198 *ctx_reg(chan, NV04_PGRAPH_DEBUG_3) = 0xfad4ff31; 1199 1200 spin_lock_irqsave(&gr->lock, flags); 1201 gr->chan[chan->chid] = chan; 1202 spin_unlock_irqrestore(&gr->lock, flags); 1203 return 0; 1204 } 1205 1206 /******************************************************************************* 1207 * PGRAPH engine/subdev functions 1208 ******************************************************************************/ 1209 1210 bool 1211 nv04_gr_idle(struct nvkm_gr *gr) 1212 { 1213 struct nvkm_subdev *subdev = &gr->engine.subdev; 1214 struct nvkm_device *device = subdev->device; 1215 u32 mask = 0xffffffff; 1216 1217 if (device->card_type == NV_40) 1218 mask &= ~NV40_PGRAPH_STATUS_SYNC_STALL; 1219 1220 if (nvkm_msec(device, 2000, 1221 if (!(nvkm_rd32(device, NV04_PGRAPH_STATUS) & mask)) 1222 break; 1223 ) < 0) { 1224 nvkm_error(subdev, "idle timed out with status %08x\n", 1225 nvkm_rd32(device, NV04_PGRAPH_STATUS)); 1226 return false; 1227 } 1228 1229 return true; 1230 } 1231 1232 static const struct nvkm_bitfield 1233 nv04_gr_intr_name[] = { 1234 { NV_PGRAPH_INTR_NOTIFY, "NOTIFY" }, 1235 {} 1236 }; 1237 1238 static const struct nvkm_bitfield 1239 nv04_gr_nstatus[] = { 1240 { NV04_PGRAPH_NSTATUS_STATE_IN_USE, "STATE_IN_USE" }, 1241 { NV04_PGRAPH_NSTATUS_INVALID_STATE, "INVALID_STATE" }, 1242 { NV04_PGRAPH_NSTATUS_BAD_ARGUMENT, "BAD_ARGUMENT" }, 1243 { NV04_PGRAPH_NSTATUS_PROTECTION_FAULT, "PROTECTION_FAULT" }, 1244 {} 1245 }; 1246 1247 const struct nvkm_bitfield 1248 nv04_gr_nsource[] = { 1249 { NV03_PGRAPH_NSOURCE_NOTIFICATION, "NOTIFICATION" }, 1250 { NV03_PGRAPH_NSOURCE_DATA_ERROR, "DATA_ERROR" }, 1251 { NV03_PGRAPH_NSOURCE_PROTECTION_ERROR, "PROTECTION_ERROR" }, 1252 { NV03_PGRAPH_NSOURCE_RANGE_EXCEPTION, "RANGE_EXCEPTION" }, 1253 { NV03_PGRAPH_NSOURCE_LIMIT_COLOR, "LIMIT_COLOR" }, 1254 { NV03_PGRAPH_NSOURCE_LIMIT_ZETA, "LIMIT_ZETA" }, 1255 { NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD, "ILLEGAL_MTHD" }, 1256 { NV03_PGRAPH_NSOURCE_DMA_R_PROTECTION, "DMA_R_PROTECTION" }, 1257 { NV03_PGRAPH_NSOURCE_DMA_W_PROTECTION, "DMA_W_PROTECTION" }, 1258 { NV03_PGRAPH_NSOURCE_FORMAT_EXCEPTION, "FORMAT_EXCEPTION" }, 1259 { NV03_PGRAPH_NSOURCE_PATCH_EXCEPTION, "PATCH_EXCEPTION" }, 1260 { NV03_PGRAPH_NSOURCE_STATE_INVALID, "STATE_INVALID" }, 1261 { NV03_PGRAPH_NSOURCE_DOUBLE_NOTIFY, "DOUBLE_NOTIFY" }, 1262 { NV03_PGRAPH_NSOURCE_NOTIFY_IN_USE, "NOTIFY_IN_USE" }, 1263 { NV03_PGRAPH_NSOURCE_METHOD_CNT, "METHOD_CNT" }, 1264 { NV03_PGRAPH_NSOURCE_BFR_NOTIFICATION, "BFR_NOTIFICATION" }, 1265 { NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION, "DMA_VTX_PROTECTION" }, 1266 { NV03_PGRAPH_NSOURCE_DMA_WIDTH_A, "DMA_WIDTH_A" }, 1267 { NV03_PGRAPH_NSOURCE_DMA_WIDTH_B, "DMA_WIDTH_B" }, 1268 {} 1269 }; 1270 1271 static void 1272 nv04_gr_intr(struct nvkm_gr *base) 1273 { 1274 struct nv04_gr *gr = nv04_gr(base); 1275 struct nvkm_subdev *subdev = &gr->base.engine.subdev; 1276 struct nvkm_device *device = subdev->device; 1277 u32 stat = nvkm_rd32(device, NV03_PGRAPH_INTR); 1278 u32 nsource = nvkm_rd32(device, NV03_PGRAPH_NSOURCE); 1279 u32 nstatus = nvkm_rd32(device, NV03_PGRAPH_NSTATUS); 1280 u32 addr = nvkm_rd32(device, NV04_PGRAPH_TRAPPED_ADDR); 1281 u32 chid = (addr & 0x0f000000) >> 24; 1282 u32 subc = (addr & 0x0000e000) >> 13; 1283 u32 mthd = (addr & 0x00001ffc); 1284 u32 data = nvkm_rd32(device, NV04_PGRAPH_TRAPPED_DATA); 1285 u32 class = nvkm_rd32(device, 0x400180 + subc * 4) & 0xff; 1286 u32 inst = (nvkm_rd32(device, 0x40016c) & 0xffff) << 4; 1287 u32 show = stat; 1288 char msg[128], src[128], sta[128]; 1289 struct nv04_gr_chan *chan; 1290 unsigned long flags; 1291 1292 spin_lock_irqsave(&gr->lock, flags); 1293 chan = gr->chan[chid]; 1294 1295 if (stat & NV_PGRAPH_INTR_NOTIFY) { 1296 if (chan && (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD)) { 1297 if (!nv04_gr_mthd(device, inst, mthd, data)) 1298 show &= ~NV_PGRAPH_INTR_NOTIFY; 1299 } 1300 } 1301 1302 if (stat & NV_PGRAPH_INTR_CONTEXT_SWITCH) { 1303 nvkm_wr32(device, NV03_PGRAPH_INTR, NV_PGRAPH_INTR_CONTEXT_SWITCH); 1304 stat &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH; 1305 show &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH; 1306 nv04_gr_context_switch(gr); 1307 } 1308 1309 nvkm_wr32(device, NV03_PGRAPH_INTR, stat); 1310 nvkm_wr32(device, NV04_PGRAPH_FIFO, 0x00000001); 1311 1312 if (show) { 1313 nvkm_snprintbf(msg, sizeof(msg), nv04_gr_intr_name, show); 1314 nvkm_snprintbf(src, sizeof(src), nv04_gr_nsource, nsource); 1315 nvkm_snprintbf(sta, sizeof(sta), nv04_gr_nstatus, nstatus); 1316 nvkm_error(subdev, "intr %08x [%s] nsource %08x [%s] " 1317 "nstatus %08x [%s] ch %d [%s] subc %d " 1318 "class %04x mthd %04x data %08x\n", 1319 show, msg, nsource, src, nstatus, sta, chid, 1320 chan ? chan->object.client->name : "unknown", 1321 subc, class, mthd, data); 1322 } 1323 1324 spin_unlock_irqrestore(&gr->lock, flags); 1325 } 1326 1327 static int 1328 nv04_gr_init(struct nvkm_gr *base) 1329 { 1330 struct nv04_gr *gr = nv04_gr(base); 1331 struct nvkm_device *device = gr->base.engine.subdev.device; 1332 1333 /* Enable PGRAPH interrupts */ 1334 nvkm_wr32(device, NV03_PGRAPH_INTR, 0xFFFFFFFF); 1335 nvkm_wr32(device, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF); 1336 1337 nvkm_wr32(device, NV04_PGRAPH_VALID1, 0); 1338 nvkm_wr32(device, NV04_PGRAPH_VALID2, 0); 1339 /*nvkm_wr32(device, NV04_PGRAPH_DEBUG_0, 0x000001FF); 1340 nvkm_wr32(device, NV04_PGRAPH_DEBUG_0, 0x001FFFFF);*/ 1341 nvkm_wr32(device, NV04_PGRAPH_DEBUG_0, 0x1231c000); 1342 /*1231C000 blob, 001 haiku*/ 1343 /*V_WRITE(NV04_PGRAPH_DEBUG_1, 0xf2d91100);*/ 1344 nvkm_wr32(device, NV04_PGRAPH_DEBUG_1, 0x72111100); 1345 /*0x72111100 blob , 01 haiku*/ 1346 /*nvkm_wr32(device, NV04_PGRAPH_DEBUG_2, 0x11d5f870);*/ 1347 nvkm_wr32(device, NV04_PGRAPH_DEBUG_2, 0x11d5f071); 1348 /*haiku same*/ 1349 1350 /*nvkm_wr32(device, NV04_PGRAPH_DEBUG_3, 0xfad4ff31);*/ 1351 nvkm_wr32(device, NV04_PGRAPH_DEBUG_3, 0xf0d4ff31); 1352 /*haiku and blob 10d4*/ 1353 1354 nvkm_wr32(device, NV04_PGRAPH_STATE , 0xFFFFFFFF); 1355 nvkm_wr32(device, NV04_PGRAPH_CTX_CONTROL , 0x10000100); 1356 nvkm_mask(device, NV04_PGRAPH_CTX_USER, 0xff000000, 0x0f000000); 1357 1358 /* These don't belong here, they're part of a per-channel context */ 1359 nvkm_wr32(device, NV04_PGRAPH_PATTERN_SHAPE, 0x00000000); 1360 nvkm_wr32(device, NV04_PGRAPH_BETA_AND , 0xFFFFFFFF); 1361 return 0; 1362 } 1363 1364 static const struct nvkm_gr_func 1365 nv04_gr = { 1366 .init = nv04_gr_init, 1367 .intr = nv04_gr_intr, 1368 .chan_new = nv04_gr_chan_new, 1369 .sclass = { 1370 { -1, -1, 0x0012, &nv04_gr_object }, /* beta1 */ 1371 { -1, -1, 0x0017, &nv04_gr_object }, /* chroma */ 1372 { -1, -1, 0x0018, &nv04_gr_object }, /* pattern (nv01) */ 1373 { -1, -1, 0x0019, &nv04_gr_object }, /* clip */ 1374 { -1, -1, 0x001c, &nv04_gr_object }, /* line */ 1375 { -1, -1, 0x001d, &nv04_gr_object }, /* tri */ 1376 { -1, -1, 0x001e, &nv04_gr_object }, /* rect */ 1377 { -1, -1, 0x001f, &nv04_gr_object }, 1378 { -1, -1, 0x0021, &nv04_gr_object }, 1379 { -1, -1, 0x0030, &nv04_gr_object }, /* null */ 1380 { -1, -1, 0x0036, &nv04_gr_object }, 1381 { -1, -1, 0x0037, &nv04_gr_object }, 1382 { -1, -1, 0x0038, &nv04_gr_object }, /* dvd subpicture */ 1383 { -1, -1, 0x0039, &nv04_gr_object }, /* m2mf */ 1384 { -1, -1, 0x0042, &nv04_gr_object }, /* surf2d */ 1385 { -1, -1, 0x0043, &nv04_gr_object }, /* rop */ 1386 { -1, -1, 0x0044, &nv04_gr_object }, /* pattern */ 1387 { -1, -1, 0x0048, &nv04_gr_object }, 1388 { -1, -1, 0x004a, &nv04_gr_object }, 1389 { -1, -1, 0x004b, &nv04_gr_object }, 1390 { -1, -1, 0x0052, &nv04_gr_object }, /* swzsurf */ 1391 { -1, -1, 0x0053, &nv04_gr_object }, 1392 { -1, -1, 0x0054, &nv04_gr_object }, /* ttri */ 1393 { -1, -1, 0x0055, &nv04_gr_object }, /* mtri */ 1394 { -1, -1, 0x0057, &nv04_gr_object }, /* chroma */ 1395 { -1, -1, 0x0058, &nv04_gr_object }, /* surf_dst */ 1396 { -1, -1, 0x0059, &nv04_gr_object }, /* surf_src */ 1397 { -1, -1, 0x005a, &nv04_gr_object }, /* surf_color */ 1398 { -1, -1, 0x005b, &nv04_gr_object }, /* surf_zeta */ 1399 { -1, -1, 0x005c, &nv04_gr_object }, /* line */ 1400 { -1, -1, 0x005d, &nv04_gr_object }, /* tri */ 1401 { -1, -1, 0x005e, &nv04_gr_object }, /* rect */ 1402 { -1, -1, 0x005f, &nv04_gr_object }, 1403 { -1, -1, 0x0060, &nv04_gr_object }, 1404 { -1, -1, 0x0061, &nv04_gr_object }, 1405 { -1, -1, 0x0064, &nv04_gr_object }, /* iifc (nv05) */ 1406 { -1, -1, 0x0065, &nv04_gr_object }, /* ifc (nv05) */ 1407 { -1, -1, 0x0066, &nv04_gr_object }, /* sifc (nv05) */ 1408 { -1, -1, 0x0072, &nv04_gr_object }, /* beta4 */ 1409 { -1, -1, 0x0076, &nv04_gr_object }, 1410 { -1, -1, 0x0077, &nv04_gr_object }, 1411 {} 1412 } 1413 }; 1414 1415 int 1416 nv04_gr_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_gr **pgr) 1417 { 1418 struct nv04_gr *gr; 1419 1420 if (!(gr = kzalloc(sizeof(*gr), GFP_KERNEL))) 1421 return -ENOMEM; 1422 spin_lock_init(&gr->lock); 1423 *pgr = &gr->base; 1424 1425 return nvkm_gr_ctor(&nv04_gr, device, type, inst, true, &gr->base); 1426 } 1427