1 /*
2  * Copyright 2012 Red Hat Inc.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Authors: Ben Skeggs
23  */
24 #include "nv50.h"
25 
26 #include <core/client.h>
27 #include <core/gpuobj.h>
28 #include <engine/fifo.h>
29 
30 #include <nvif/class.h>
31 
32 u64
33 nv50_gr_units(struct nvkm_gr *gr)
34 {
35 	return nvkm_rd32(gr->engine.subdev.device, 0x1540);
36 }
37 
38 /*******************************************************************************
39  * Graphics object classes
40  ******************************************************************************/
41 
42 static int
43 nv50_gr_object_bind(struct nvkm_object *object, struct nvkm_gpuobj *parent,
44 		    int align, struct nvkm_gpuobj **pgpuobj)
45 {
46 	int ret = nvkm_gpuobj_new(object->engine->subdev.device, 16,
47 				  align, false, parent, pgpuobj);
48 	if (ret == 0) {
49 		nvkm_kmap(*pgpuobj);
50 		nvkm_wo32(*pgpuobj, 0x00, object->oclass);
51 		nvkm_wo32(*pgpuobj, 0x04, 0x00000000);
52 		nvkm_wo32(*pgpuobj, 0x08, 0x00000000);
53 		nvkm_wo32(*pgpuobj, 0x0c, 0x00000000);
54 		nvkm_done(*pgpuobj);
55 	}
56 	return ret;
57 }
58 
59 const struct nvkm_object_func
60 nv50_gr_object = {
61 	.bind = nv50_gr_object_bind,
62 };
63 
64 /*******************************************************************************
65  * PGRAPH context
66  ******************************************************************************/
67 
68 static int
69 nv50_gr_chan_bind(struct nvkm_object *object, struct nvkm_gpuobj *parent,
70 		  int align, struct nvkm_gpuobj **pgpuobj)
71 {
72 	struct nv50_gr *gr = nv50_gr_chan(object)->gr;
73 	int ret = nvkm_gpuobj_new(gr->base.engine.subdev.device, gr->size,
74 				  align, true, parent, pgpuobj);
75 	if (ret == 0) {
76 		nvkm_kmap(*pgpuobj);
77 		nv50_grctx_fill(gr->base.engine.subdev.device, *pgpuobj);
78 		nvkm_done(*pgpuobj);
79 	}
80 	return ret;
81 }
82 
83 static const struct nvkm_object_func
84 nv50_gr_chan = {
85 	.bind = nv50_gr_chan_bind,
86 };
87 
88 int
89 nv50_gr_chan_new(struct nvkm_gr *base, struct nvkm_fifo_chan *fifoch,
90 		 const struct nvkm_oclass *oclass, struct nvkm_object **pobject)
91 {
92 	struct nv50_gr *gr = nv50_gr(base);
93 	struct nv50_gr_chan *chan;
94 
95 	if (!(chan = kzalloc(sizeof(*chan), GFP_KERNEL)))
96 		return -ENOMEM;
97 	nvkm_object_ctor(&nv50_gr_chan, oclass, &chan->object);
98 	chan->gr = gr;
99 	*pobject = &chan->object;
100 	return 0;
101 }
102 
103 /*******************************************************************************
104  * PGRAPH engine/subdev functions
105  ******************************************************************************/
106 
107 static const struct nvkm_bitfield nv50_mp_exec_errors[] = {
108 	{ 0x01, "STACK_UNDERFLOW" },
109 	{ 0x02, "STACK_MISMATCH" },
110 	{ 0x04, "QUADON_ACTIVE" },
111 	{ 0x08, "TIMEOUT" },
112 	{ 0x10, "INVALID_OPCODE" },
113 	{ 0x20, "PM_OVERFLOW" },
114 	{ 0x40, "BREAKPOINT" },
115 	{}
116 };
117 
118 static const struct nvkm_bitfield nv50_mpc_traps[] = {
119 	{ 0x0000001, "LOCAL_LIMIT_READ" },
120 	{ 0x0000010, "LOCAL_LIMIT_WRITE" },
121 	{ 0x0000040, "STACK_LIMIT" },
122 	{ 0x0000100, "GLOBAL_LIMIT_READ" },
123 	{ 0x0001000, "GLOBAL_LIMIT_WRITE" },
124 	{ 0x0010000, "MP0" },
125 	{ 0x0020000, "MP1" },
126 	{ 0x0040000, "GLOBAL_LIMIT_RED" },
127 	{ 0x0400000, "GLOBAL_LIMIT_ATOM" },
128 	{ 0x4000000, "MP2" },
129 	{}
130 };
131 
132 static const struct nvkm_bitfield nv50_tex_traps[] = {
133 	{ 0x00000001, "" }, /* any bit set? */
134 	{ 0x00000002, "FAULT" },
135 	{ 0x00000004, "STORAGE_TYPE_MISMATCH" },
136 	{ 0x00000008, "LINEAR_MISMATCH" },
137 	{ 0x00000020, "WRONG_MEMTYPE" },
138 	{}
139 };
140 
141 static const struct nvkm_bitfield nv50_gr_trap_m2mf[] = {
142 	{ 0x00000001, "NOTIFY" },
143 	{ 0x00000002, "IN" },
144 	{ 0x00000004, "OUT" },
145 	{}
146 };
147 
148 static const struct nvkm_bitfield nv50_gr_trap_vfetch[] = {
149 	{ 0x00000001, "FAULT" },
150 	{}
151 };
152 
153 static const struct nvkm_bitfield nv50_gr_trap_strmout[] = {
154 	{ 0x00000001, "FAULT" },
155 	{}
156 };
157 
158 static const struct nvkm_bitfield nv50_gr_trap_ccache[] = {
159 	{ 0x00000001, "FAULT" },
160 	{}
161 };
162 
163 /* There must be a *lot* of these. Will take some time to gather them up. */
164 const struct nvkm_enum nv50_data_error_names[] = {
165 	{ 0x00000003, "INVALID_OPERATION", NULL },
166 	{ 0x00000004, "INVALID_VALUE", NULL },
167 	{ 0x00000005, "INVALID_ENUM", NULL },
168 	{ 0x00000008, "INVALID_OBJECT", NULL },
169 	{ 0x00000009, "READ_ONLY_OBJECT", NULL },
170 	{ 0x0000000a, "SUPERVISOR_OBJECT", NULL },
171 	{ 0x0000000b, "INVALID_ADDRESS_ALIGNMENT", NULL },
172 	{ 0x0000000c, "INVALID_BITFIELD", NULL },
173 	{ 0x0000000d, "BEGIN_END_ACTIVE", NULL },
174 	{ 0x0000000e, "SEMANTIC_COLOR_BACK_OVER_LIMIT", NULL },
175 	{ 0x0000000f, "VIEWPORT_ID_NEEDS_GP", NULL },
176 	{ 0x00000010, "RT_DOUBLE_BIND", NULL },
177 	{ 0x00000011, "RT_TYPES_MISMATCH", NULL },
178 	{ 0x00000012, "RT_LINEAR_WITH_ZETA", NULL },
179 	{ 0x00000015, "FP_TOO_FEW_REGS", NULL },
180 	{ 0x00000016, "ZETA_FORMAT_CSAA_MISMATCH", NULL },
181 	{ 0x00000017, "RT_LINEAR_WITH_MSAA", NULL },
182 	{ 0x00000018, "FP_INTERPOLANT_START_OVER_LIMIT", NULL },
183 	{ 0x00000019, "SEMANTIC_LAYER_OVER_LIMIT", NULL },
184 	{ 0x0000001a, "RT_INVALID_ALIGNMENT", NULL },
185 	{ 0x0000001b, "SAMPLER_OVER_LIMIT", NULL },
186 	{ 0x0000001c, "TEXTURE_OVER_LIMIT", NULL },
187 	{ 0x0000001e, "GP_TOO_MANY_OUTPUTS", NULL },
188 	{ 0x0000001f, "RT_BPP128_WITH_MS8", NULL },
189 	{ 0x00000021, "Z_OUT_OF_BOUNDS", NULL },
190 	{ 0x00000023, "XY_OUT_OF_BOUNDS", NULL },
191 	{ 0x00000024, "VP_ZERO_INPUTS", NULL },
192 	{ 0x00000027, "CP_MORE_PARAMS_THAN_SHARED", NULL },
193 	{ 0x00000028, "CP_NO_REG_SPACE_STRIPED", NULL },
194 	{ 0x00000029, "CP_NO_REG_SPACE_PACKED", NULL },
195 	{ 0x0000002a, "CP_NOT_ENOUGH_WARPS", NULL },
196 	{ 0x0000002b, "CP_BLOCK_SIZE_MISMATCH", NULL },
197 	{ 0x0000002c, "CP_NOT_ENOUGH_LOCAL_WARPS", NULL },
198 	{ 0x0000002d, "CP_NOT_ENOUGH_STACK_WARPS", NULL },
199 	{ 0x0000002e, "CP_NO_BLOCKDIM_LATCH", NULL },
200 	{ 0x00000031, "ENG2D_FORMAT_MISMATCH", NULL },
201 	{ 0x0000003f, "PRIMITIVE_ID_NEEDS_GP", NULL },
202 	{ 0x00000044, "SEMANTIC_VIEWPORT_OVER_LIMIT", NULL },
203 	{ 0x00000045, "SEMANTIC_COLOR_FRONT_OVER_LIMIT", NULL },
204 	{ 0x00000046, "LAYER_ID_NEEDS_GP", NULL },
205 	{ 0x00000047, "SEMANTIC_CLIP_OVER_LIMIT", NULL },
206 	{ 0x00000048, "SEMANTIC_PTSZ_OVER_LIMIT", NULL },
207 	{}
208 };
209 
210 static const struct nvkm_bitfield nv50_gr_intr_name[] = {
211 	{ 0x00000001, "NOTIFY" },
212 	{ 0x00000002, "COMPUTE_QUERY" },
213 	{ 0x00000010, "ILLEGAL_MTHD" },
214 	{ 0x00000020, "ILLEGAL_CLASS" },
215 	{ 0x00000040, "DOUBLE_NOTIFY" },
216 	{ 0x00001000, "CONTEXT_SWITCH" },
217 	{ 0x00010000, "BUFFER_NOTIFY" },
218 	{ 0x00100000, "DATA_ERROR" },
219 	{ 0x00200000, "TRAP" },
220 	{ 0x01000000, "SINGLE_STEP" },
221 	{}
222 };
223 
224 static const struct nvkm_bitfield nv50_gr_trap_prop[] = {
225 	{ 0x00000004, "SURF_WIDTH_OVERRUN" },
226 	{ 0x00000008, "SURF_HEIGHT_OVERRUN" },
227 	{ 0x00000010, "DST2D_FAULT" },
228 	{ 0x00000020, "ZETA_FAULT" },
229 	{ 0x00000040, "RT_FAULT" },
230 	{ 0x00000080, "CUDA_FAULT" },
231 	{ 0x00000100, "DST2D_STORAGE_TYPE_MISMATCH" },
232 	{ 0x00000200, "ZETA_STORAGE_TYPE_MISMATCH" },
233 	{ 0x00000400, "RT_STORAGE_TYPE_MISMATCH" },
234 	{ 0x00000800, "DST2D_LINEAR_MISMATCH" },
235 	{ 0x00001000, "RT_LINEAR_MISMATCH" },
236 	{}
237 };
238 
239 static void
240 nv50_gr_prop_trap(struct nv50_gr *gr, u32 ustatus_addr, u32 ustatus, u32 tp)
241 {
242 	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
243 	struct nvkm_device *device = subdev->device;
244 	u32 e0c = nvkm_rd32(device, ustatus_addr + 0x04);
245 	u32 e10 = nvkm_rd32(device, ustatus_addr + 0x08);
246 	u32 e14 = nvkm_rd32(device, ustatus_addr + 0x0c);
247 	u32 e18 = nvkm_rd32(device, ustatus_addr + 0x10);
248 	u32 e1c = nvkm_rd32(device, ustatus_addr + 0x14);
249 	u32 e20 = nvkm_rd32(device, ustatus_addr + 0x18);
250 	u32 e24 = nvkm_rd32(device, ustatus_addr + 0x1c);
251 	char msg[128];
252 
253 	/* CUDA memory: l[], g[] or stack. */
254 	if (ustatus & 0x00000080) {
255 		if (e18 & 0x80000000) {
256 			/* g[] read fault? */
257 			nvkm_error(subdev, "TRAP_PROP - TP %d - CUDA_FAULT - Global read fault at address %02x%08x\n",
258 					 tp, e14, e10 | ((e18 >> 24) & 0x1f));
259 			e18 &= ~0x1f000000;
260 		} else if (e18 & 0xc) {
261 			/* g[] write fault? */
262 			nvkm_error(subdev, "TRAP_PROP - TP %d - CUDA_FAULT - Global write fault at address %02x%08x\n",
263 				 tp, e14, e10 | ((e18 >> 7) & 0x1f));
264 			e18 &= ~0x00000f80;
265 		} else {
266 			nvkm_error(subdev, "TRAP_PROP - TP %d - Unknown CUDA fault at address %02x%08x\n",
267 				 tp, e14, e10);
268 		}
269 		ustatus &= ~0x00000080;
270 	}
271 	if (ustatus) {
272 		nvkm_snprintbf(msg, sizeof(msg), nv50_gr_trap_prop, ustatus);
273 		nvkm_error(subdev, "TRAP_PROP - TP %d - %08x [%s] - "
274 				   "Address %02x%08x\n",
275 			   tp, ustatus, msg, e14, e10);
276 	}
277 	nvkm_error(subdev, "TRAP_PROP - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
278 		 tp, e0c, e18, e1c, e20, e24);
279 }
280 
281 static void
282 nv50_gr_mp_trap(struct nv50_gr *gr, int tpid, int display)
283 {
284 	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
285 	struct nvkm_device *device = subdev->device;
286 	u32 units = nvkm_rd32(device, 0x1540);
287 	u32 addr, mp10, status, pc, oplow, ophigh;
288 	char msg[128];
289 	int i;
290 	int mps = 0;
291 	for (i = 0; i < 4; i++) {
292 		if (!(units & 1 << (i+24)))
293 			continue;
294 		if (device->chipset < 0xa0)
295 			addr = 0x408200 + (tpid << 12) + (i << 7);
296 		else
297 			addr = 0x408100 + (tpid << 11) + (i << 7);
298 		mp10 = nvkm_rd32(device, addr + 0x10);
299 		status = nvkm_rd32(device, addr + 0x14);
300 		if (!status)
301 			continue;
302 		if (display) {
303 			nvkm_rd32(device, addr + 0x20);
304 			pc = nvkm_rd32(device, addr + 0x24);
305 			oplow = nvkm_rd32(device, addr + 0x70);
306 			ophigh = nvkm_rd32(device, addr + 0x74);
307 			nvkm_snprintbf(msg, sizeof(msg),
308 				       nv50_mp_exec_errors, status);
309 			nvkm_error(subdev, "TRAP_MP_EXEC - TP %d MP %d: "
310 					   "%08x [%s] at %06x warp %d, "
311 					   "opcode %08x %08x\n",
312 				   tpid, i, status, msg, pc & 0xffffff,
313 				   pc >> 24, oplow, ophigh);
314 		}
315 		nvkm_wr32(device, addr + 0x10, mp10);
316 		nvkm_wr32(device, addr + 0x14, 0);
317 		mps++;
318 	}
319 	if (!mps && display)
320 		nvkm_error(subdev, "TRAP_MP_EXEC - TP %d: "
321 				"No MPs claiming errors?\n", tpid);
322 }
323 
324 static void
325 nv50_gr_tp_trap(struct nv50_gr *gr, int type, u32 ustatus_old,
326 		  u32 ustatus_new, int display, const char *name)
327 {
328 	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
329 	struct nvkm_device *device = subdev->device;
330 	u32 units = nvkm_rd32(device, 0x1540);
331 	int tps = 0;
332 	int i, r;
333 	char msg[128];
334 	u32 ustatus_addr, ustatus;
335 	for (i = 0; i < 16; i++) {
336 		if (!(units & (1 << i)))
337 			continue;
338 		if (device->chipset < 0xa0)
339 			ustatus_addr = ustatus_old + (i << 12);
340 		else
341 			ustatus_addr = ustatus_new + (i << 11);
342 		ustatus = nvkm_rd32(device, ustatus_addr) & 0x7fffffff;
343 		if (!ustatus)
344 			continue;
345 		tps++;
346 		switch (type) {
347 		case 6: /* texture error... unknown for now */
348 			if (display) {
349 				nvkm_error(subdev, "magic set %d:\n", i);
350 				for (r = ustatus_addr + 4; r <= ustatus_addr + 0x10; r += 4)
351 					nvkm_error(subdev, "\t%08x: %08x\n", r,
352 						   nvkm_rd32(device, r));
353 				if (ustatus) {
354 					nvkm_snprintbf(msg, sizeof(msg),
355 						       nv50_tex_traps, ustatus);
356 					nvkm_error(subdev,
357 						   "%s - TP%d: %08x [%s]\n",
358 						   name, i, ustatus, msg);
359 					ustatus = 0;
360 				}
361 			}
362 			break;
363 		case 7: /* MP error */
364 			if (ustatus & 0x04030000) {
365 				nv50_gr_mp_trap(gr, i, display);
366 				ustatus &= ~0x04030000;
367 			}
368 			if (ustatus && display) {
369 				nvkm_snprintbf(msg, sizeof(msg),
370 					       nv50_mpc_traps, ustatus);
371 				nvkm_error(subdev, "%s - TP%d: %08x [%s]\n",
372 					   name, i, ustatus, msg);
373 				ustatus = 0;
374 			}
375 			break;
376 		case 8: /* PROP error */
377 			if (display)
378 				nv50_gr_prop_trap(
379 						gr, ustatus_addr, ustatus, i);
380 			ustatus = 0;
381 			break;
382 		}
383 		if (ustatus) {
384 			if (display)
385 				nvkm_error(subdev, "%s - TP%d: Unhandled ustatus %08x\n", name, i, ustatus);
386 		}
387 		nvkm_wr32(device, ustatus_addr, 0xc0000000);
388 	}
389 
390 	if (!tps && display)
391 		nvkm_warn(subdev, "%s - No TPs claiming errors?\n", name);
392 }
393 
394 static int
395 nv50_gr_trap_handler(struct nv50_gr *gr, u32 display,
396 		     int chid, u64 inst, const char *name)
397 {
398 	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
399 	struct nvkm_device *device = subdev->device;
400 	u32 status = nvkm_rd32(device, 0x400108);
401 	u32 ustatus;
402 	char msg[128];
403 
404 	if (!status && display) {
405 		nvkm_error(subdev, "TRAP: no units reporting traps?\n");
406 		return 1;
407 	}
408 
409 	/* DISPATCH: Relays commands to other units and handles NOTIFY,
410 	 * COND, QUERY. If you get a trap from it, the command is still stuck
411 	 * in DISPATCH and you need to do something about it. */
412 	if (status & 0x001) {
413 		ustatus = nvkm_rd32(device, 0x400804) & 0x7fffffff;
414 		if (!ustatus && display) {
415 			nvkm_error(subdev, "TRAP_DISPATCH - no ustatus?\n");
416 		}
417 
418 		nvkm_wr32(device, 0x400500, 0x00000000);
419 
420 		/* Known to be triggered by screwed up NOTIFY and COND... */
421 		if (ustatus & 0x00000001) {
422 			u32 addr = nvkm_rd32(device, 0x400808);
423 			u32 subc = (addr & 0x00070000) >> 16;
424 			u32 mthd = (addr & 0x00001ffc);
425 			u32 datal = nvkm_rd32(device, 0x40080c);
426 			u32 datah = nvkm_rd32(device, 0x400810);
427 			u32 class = nvkm_rd32(device, 0x400814);
428 			u32 r848 = nvkm_rd32(device, 0x400848);
429 
430 			nvkm_error(subdev, "TRAP DISPATCH_FAULT\n");
431 			if (display && (addr & 0x80000000)) {
432 				nvkm_error(subdev,
433 					   "ch %d [%010llx %s] subc %d "
434 					   "class %04x mthd %04x data %08x%08x "
435 					   "400808 %08x 400848 %08x\n",
436 					   chid, inst, name, subc, class, mthd,
437 					   datah, datal, addr, r848);
438 			} else
439 			if (display) {
440 				nvkm_error(subdev, "no stuck command?\n");
441 			}
442 
443 			nvkm_wr32(device, 0x400808, 0);
444 			nvkm_wr32(device, 0x4008e8, nvkm_rd32(device, 0x4008e8) & 3);
445 			nvkm_wr32(device, 0x400848, 0);
446 			ustatus &= ~0x00000001;
447 		}
448 
449 		if (ustatus & 0x00000002) {
450 			u32 addr = nvkm_rd32(device, 0x40084c);
451 			u32 subc = (addr & 0x00070000) >> 16;
452 			u32 mthd = (addr & 0x00001ffc);
453 			u32 data = nvkm_rd32(device, 0x40085c);
454 			u32 class = nvkm_rd32(device, 0x400814);
455 
456 			nvkm_error(subdev, "TRAP DISPATCH_QUERY\n");
457 			if (display && (addr & 0x80000000)) {
458 				nvkm_error(subdev,
459 					   "ch %d [%010llx %s] subc %d "
460 					   "class %04x mthd %04x data %08x "
461 					   "40084c %08x\n", chid, inst, name,
462 					   subc, class, mthd, data, addr);
463 			} else
464 			if (display) {
465 				nvkm_error(subdev, "no stuck command?\n");
466 			}
467 
468 			nvkm_wr32(device, 0x40084c, 0);
469 			ustatus &= ~0x00000002;
470 		}
471 
472 		if (ustatus && display) {
473 			nvkm_error(subdev, "TRAP_DISPATCH "
474 					   "(unknown %08x)\n", ustatus);
475 		}
476 
477 		nvkm_wr32(device, 0x400804, 0xc0000000);
478 		nvkm_wr32(device, 0x400108, 0x001);
479 		status &= ~0x001;
480 		if (!status)
481 			return 0;
482 	}
483 
484 	/* M2MF: Memory to memory copy engine. */
485 	if (status & 0x002) {
486 		u32 ustatus = nvkm_rd32(device, 0x406800) & 0x7fffffff;
487 		if (display) {
488 			nvkm_snprintbf(msg, sizeof(msg),
489 				       nv50_gr_trap_m2mf, ustatus);
490 			nvkm_error(subdev, "TRAP_M2MF %08x [%s]\n",
491 				   ustatus, msg);
492 			nvkm_error(subdev, "TRAP_M2MF %08x %08x %08x %08x\n",
493 				   nvkm_rd32(device, 0x406804),
494 				   nvkm_rd32(device, 0x406808),
495 				   nvkm_rd32(device, 0x40680c),
496 				   nvkm_rd32(device, 0x406810));
497 		}
498 
499 		/* No sane way found yet -- just reset the bugger. */
500 		nvkm_wr32(device, 0x400040, 2);
501 		nvkm_wr32(device, 0x400040, 0);
502 		nvkm_wr32(device, 0x406800, 0xc0000000);
503 		nvkm_wr32(device, 0x400108, 0x002);
504 		status &= ~0x002;
505 	}
506 
507 	/* VFETCH: Fetches data from vertex buffers. */
508 	if (status & 0x004) {
509 		u32 ustatus = nvkm_rd32(device, 0x400c04) & 0x7fffffff;
510 		if (display) {
511 			nvkm_snprintbf(msg, sizeof(msg),
512 				       nv50_gr_trap_vfetch, ustatus);
513 			nvkm_error(subdev, "TRAP_VFETCH %08x [%s]\n",
514 				   ustatus, msg);
515 			nvkm_error(subdev, "TRAP_VFETCH %08x %08x %08x %08x\n",
516 				   nvkm_rd32(device, 0x400c00),
517 				   nvkm_rd32(device, 0x400c08),
518 				   nvkm_rd32(device, 0x400c0c),
519 				   nvkm_rd32(device, 0x400c10));
520 		}
521 
522 		nvkm_wr32(device, 0x400c04, 0xc0000000);
523 		nvkm_wr32(device, 0x400108, 0x004);
524 		status &= ~0x004;
525 	}
526 
527 	/* STRMOUT: DirectX streamout / OpenGL transform feedback. */
528 	if (status & 0x008) {
529 		ustatus = nvkm_rd32(device, 0x401800) & 0x7fffffff;
530 		if (display) {
531 			nvkm_snprintbf(msg, sizeof(msg),
532 				       nv50_gr_trap_strmout, ustatus);
533 			nvkm_error(subdev, "TRAP_STRMOUT %08x [%s]\n",
534 				   ustatus, msg);
535 			nvkm_error(subdev, "TRAP_STRMOUT %08x %08x %08x %08x\n",
536 				   nvkm_rd32(device, 0x401804),
537 				   nvkm_rd32(device, 0x401808),
538 				   nvkm_rd32(device, 0x40180c),
539 				   nvkm_rd32(device, 0x401810));
540 		}
541 
542 		/* No sane way found yet -- just reset the bugger. */
543 		nvkm_wr32(device, 0x400040, 0x80);
544 		nvkm_wr32(device, 0x400040, 0);
545 		nvkm_wr32(device, 0x401800, 0xc0000000);
546 		nvkm_wr32(device, 0x400108, 0x008);
547 		status &= ~0x008;
548 	}
549 
550 	/* CCACHE: Handles code and c[] caches and fills them. */
551 	if (status & 0x010) {
552 		ustatus = nvkm_rd32(device, 0x405018) & 0x7fffffff;
553 		if (display) {
554 			nvkm_snprintbf(msg, sizeof(msg),
555 				       nv50_gr_trap_ccache, ustatus);
556 			nvkm_error(subdev, "TRAP_CCACHE %08x [%s]\n",
557 				   ustatus, msg);
558 			nvkm_error(subdev, "TRAP_CCACHE %08x %08x %08x %08x "
559 					   "%08x %08x %08x\n",
560 				   nvkm_rd32(device, 0x405000),
561 				   nvkm_rd32(device, 0x405004),
562 				   nvkm_rd32(device, 0x405008),
563 				   nvkm_rd32(device, 0x40500c),
564 				   nvkm_rd32(device, 0x405010),
565 				   nvkm_rd32(device, 0x405014),
566 				   nvkm_rd32(device, 0x40501c));
567 		}
568 
569 		nvkm_wr32(device, 0x405018, 0xc0000000);
570 		nvkm_wr32(device, 0x400108, 0x010);
571 		status &= ~0x010;
572 	}
573 
574 	/* Unknown, not seen yet... 0x402000 is the only trap status reg
575 	 * remaining, so try to handle it anyway. Perhaps related to that
576 	 * unknown DMA slot on tesla? */
577 	if (status & 0x20) {
578 		ustatus = nvkm_rd32(device, 0x402000) & 0x7fffffff;
579 		if (display)
580 			nvkm_error(subdev, "TRAP_UNKC04 %08x\n", ustatus);
581 		nvkm_wr32(device, 0x402000, 0xc0000000);
582 		/* no status modifiction on purpose */
583 	}
584 
585 	/* TEXTURE: CUDA texturing units */
586 	if (status & 0x040) {
587 		nv50_gr_tp_trap(gr, 6, 0x408900, 0x408600, display,
588 				    "TRAP_TEXTURE");
589 		nvkm_wr32(device, 0x400108, 0x040);
590 		status &= ~0x040;
591 	}
592 
593 	/* MP: CUDA execution engines. */
594 	if (status & 0x080) {
595 		nv50_gr_tp_trap(gr, 7, 0x408314, 0x40831c, display,
596 				    "TRAP_MP");
597 		nvkm_wr32(device, 0x400108, 0x080);
598 		status &= ~0x080;
599 	}
600 
601 	/* PROP:  Handles TP-initiated uncached memory accesses:
602 	 * l[], g[], stack, 2d surfaces, render targets. */
603 	if (status & 0x100) {
604 		nv50_gr_tp_trap(gr, 8, 0x408e08, 0x408708, display,
605 				    "TRAP_PROP");
606 		nvkm_wr32(device, 0x400108, 0x100);
607 		status &= ~0x100;
608 	}
609 
610 	if (status) {
611 		if (display)
612 			nvkm_error(subdev, "TRAP: unknown %08x\n", status);
613 		nvkm_wr32(device, 0x400108, status);
614 	}
615 
616 	return 1;
617 }
618 
619 void
620 nv50_gr_intr(struct nvkm_gr *base)
621 {
622 	struct nv50_gr *gr = nv50_gr(base);
623 	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
624 	struct nvkm_device *device = subdev->device;
625 	struct nvkm_fifo_chan *chan;
626 	u32 stat = nvkm_rd32(device, 0x400100);
627 	u32 inst = nvkm_rd32(device, 0x40032c) & 0x0fffffff;
628 	u32 addr = nvkm_rd32(device, 0x400704);
629 	u32 subc = (addr & 0x00070000) >> 16;
630 	u32 mthd = (addr & 0x00001ffc);
631 	u32 data = nvkm_rd32(device, 0x400708);
632 	u32 class = nvkm_rd32(device, 0x400814);
633 	u32 show = stat, show_bitfield = stat;
634 	const struct nvkm_enum *en;
635 	unsigned long flags;
636 	const char *name = "unknown";
637 	char msg[128];
638 	int chid = -1;
639 
640 	chan = nvkm_fifo_chan_inst(device->fifo, (u64)inst << 12, &flags);
641 	if (chan)  {
642 		name = chan->object.client->name;
643 		chid = chan->chid;
644 	}
645 
646 	if (show & 0x00100000) {
647 		u32 ecode = nvkm_rd32(device, 0x400110);
648 		en = nvkm_enum_find(nv50_data_error_names, ecode);
649 		nvkm_error(subdev, "DATA_ERROR %08x [%s]\n",
650 			   ecode, en ? en->name : "");
651 		show_bitfield &= ~0x00100000;
652 	}
653 
654 	if (stat & 0x00200000) {
655 		if (!nv50_gr_trap_handler(gr, show, chid, (u64)inst << 12, name))
656 			show &= ~0x00200000;
657 		show_bitfield &= ~0x00200000;
658 	}
659 
660 	nvkm_wr32(device, 0x400100, stat);
661 	nvkm_wr32(device, 0x400500, 0x00010001);
662 
663 	if (show) {
664 		show &= show_bitfield;
665 		nvkm_snprintbf(msg, sizeof(msg), nv50_gr_intr_name, show);
666 		nvkm_error(subdev, "%08x [%s] ch %d [%010llx %s] subc %d "
667 				   "class %04x mthd %04x data %08x\n",
668 			   stat, msg, chid, (u64)inst << 12, name,
669 			   subc, class, mthd, data);
670 	}
671 
672 	if (nvkm_rd32(device, 0x400824) & (1 << 31))
673 		nvkm_wr32(device, 0x400824, nvkm_rd32(device, 0x400824) & ~(1 << 31));
674 
675 	nvkm_fifo_chan_put(device->fifo, flags, &chan);
676 }
677 
678 int
679 nv50_gr_init(struct nvkm_gr *base)
680 {
681 	struct nv50_gr *gr = nv50_gr(base);
682 	struct nvkm_device *device = gr->base.engine.subdev.device;
683 	int ret, units, i;
684 
685 	/* NV_PGRAPH_DEBUG_3_HW_CTX_SWITCH_ENABLED */
686 	nvkm_wr32(device, 0x40008c, 0x00000004);
687 
688 	/* reset/enable traps and interrupts */
689 	nvkm_wr32(device, 0x400804, 0xc0000000);
690 	nvkm_wr32(device, 0x406800, 0xc0000000);
691 	nvkm_wr32(device, 0x400c04, 0xc0000000);
692 	nvkm_wr32(device, 0x401800, 0xc0000000);
693 	nvkm_wr32(device, 0x405018, 0xc0000000);
694 	nvkm_wr32(device, 0x402000, 0xc0000000);
695 
696 	units = nvkm_rd32(device, 0x001540);
697 	for (i = 0; i < 16; i++) {
698 		if (!(units & (1 << i)))
699 			continue;
700 
701 		if (device->chipset < 0xa0) {
702 			nvkm_wr32(device, 0x408900 + (i << 12), 0xc0000000);
703 			nvkm_wr32(device, 0x408e08 + (i << 12), 0xc0000000);
704 			nvkm_wr32(device, 0x408314 + (i << 12), 0xc0000000);
705 		} else {
706 			nvkm_wr32(device, 0x408600 + (i << 11), 0xc0000000);
707 			nvkm_wr32(device, 0x408708 + (i << 11), 0xc0000000);
708 			nvkm_wr32(device, 0x40831c + (i << 11), 0xc0000000);
709 		}
710 	}
711 
712 	nvkm_wr32(device, 0x400108, 0xffffffff);
713 	nvkm_wr32(device, 0x400138, 0xffffffff);
714 	nvkm_wr32(device, 0x400100, 0xffffffff);
715 	nvkm_wr32(device, 0x40013c, 0xffffffff);
716 	nvkm_wr32(device, 0x400500, 0x00010001);
717 
718 	/* upload context program, initialise ctxctl defaults */
719 	ret = nv50_grctx_init(device, &gr->size);
720 	if (ret)
721 		return ret;
722 
723 	nvkm_wr32(device, 0x400824, 0x00000000);
724 	nvkm_wr32(device, 0x400828, 0x00000000);
725 	nvkm_wr32(device, 0x40082c, 0x00000000);
726 	nvkm_wr32(device, 0x400830, 0x00000000);
727 	nvkm_wr32(device, 0x40032c, 0x00000000);
728 	nvkm_wr32(device, 0x400330, 0x00000000);
729 
730 	/* some unknown zcull magic */
731 	switch (device->chipset & 0xf0) {
732 	case 0x50:
733 	case 0x80:
734 	case 0x90:
735 		nvkm_wr32(device, 0x402ca8, 0x00000800);
736 		break;
737 	case 0xa0:
738 	default:
739 		if (device->chipset == 0xa0 ||
740 		    device->chipset == 0xaa ||
741 		    device->chipset == 0xac) {
742 			nvkm_wr32(device, 0x402ca8, 0x00000802);
743 		} else {
744 			nvkm_wr32(device, 0x402cc0, 0x00000000);
745 			nvkm_wr32(device, 0x402ca8, 0x00000002);
746 		}
747 
748 		break;
749 	}
750 
751 	/* zero out zcull regions */
752 	for (i = 0; i < 8; i++) {
753 		nvkm_wr32(device, 0x402c20 + (i * 0x10), 0x00000000);
754 		nvkm_wr32(device, 0x402c24 + (i * 0x10), 0x00000000);
755 		nvkm_wr32(device, 0x402c28 + (i * 0x10), 0x00000000);
756 		nvkm_wr32(device, 0x402c2c + (i * 0x10), 0x00000000);
757 	}
758 
759 	return 0;
760 }
761 
762 int
763 nv50_gr_new_(const struct nvkm_gr_func *func, struct nvkm_device *device,
764 	     int index, struct nvkm_gr **pgr)
765 {
766 	struct nv50_gr *gr;
767 
768 	if (!(gr = kzalloc(sizeof(*gr), GFP_KERNEL)))
769 		return -ENOMEM;
770 	spin_lock_init(&gr->lock);
771 	*pgr = &gr->base;
772 
773 	return nvkm_gr_ctor(func, device, index, true, &gr->base);
774 }
775 
776 static const struct nvkm_gr_func
777 nv50_gr = {
778 	.init = nv50_gr_init,
779 	.intr = nv50_gr_intr,
780 	.chan_new = nv50_gr_chan_new,
781 	.units = nv50_gr_units,
782 	.sclass = {
783 		{ -1, -1, NV_NULL_CLASS, &nv50_gr_object },
784 		{ -1, -1, NV50_TWOD, &nv50_gr_object },
785 		{ -1, -1, NV50_MEMORY_TO_MEMORY_FORMAT, &nv50_gr_object },
786 		{ -1, -1, NV50_TESLA, &nv50_gr_object },
787 		{ -1, -1, NV50_COMPUTE, &nv50_gr_object },
788 		{}
789 	}
790 };
791 
792 int
793 nv50_gr_new(struct nvkm_device *device, int index, struct nvkm_gr **pgr)
794 {
795 	return nv50_gr_new_(&nv50_gr, device, index, pgr);
796 }
797