kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/drivers/gpu/drm/nouveau/nouveau_chan.c
..
..
@@ -21,18 +21,16 @@
21
21
  *
22
22
  * Authors: Ben Skeggs
23
23
  */
24
+#include <nvif/push006c.h>
24
25
 
25
-#include <nvif/os.h>
26
26
 #include <nvif/class.h>
27
27
 #include <nvif/cl0002.h>
28
28
 #include <nvif/cl006b.h>
29
29
 #include <nvif/cl506f.h>
30
30
 #include <nvif/cl906f.h>
31
31
 #include <nvif/cla06f.h>
32
+#include <nvif/clc36f.h>
32
33
 #include <nvif/ioctl.h>
33
-
34
-/*XXX*/
35
-#include <core/client.h>
36
34
 
37
35
 #include "nouveau_drv.h"
38
36
 #include "nouveau_dma.h"
..
..
@@ -41,6 +39,7 @@
41
39
 #include "nouveau_fence.h"
42
40
 #include "nouveau_abi16.h"
43
41
 #include "nouveau_vmm.h"
42
+#include "nouveau_svm.h"
44
43
 
45
44
 MODULE_PARM_DESC(vram_pushbuf, "Create DMA push buffers in VRAM");
46
45
 int nouveau_vram_pushbuf;
..
..
@@ -53,6 +52,8 @@
53
52
 	struct nouveau_cli *cli = (void *)chan->user.client;
54
53
 	NV_PRINTK(warn, cli, "channel %d killed!\n", chan->chid);
55
54
 	atomic_set(&chan->killed, 1);
55
+	if (chan->fence)
56
+		nouveau_fence_context_kill(chan->fence, -ENODEV);
56
57
 	return NVIF_NOTIFY_DROP;
57
58
 }
58
59
 
..
..
@@ -94,12 +95,16 @@
94
95
 
95
96
 		if (chan->fence)
96
97
 			nouveau_fence(chan->drm)->context_del(chan);
97
-		nvif_object_fini(&chan->nvsw);
98
-		nvif_object_fini(&chan->gart);
99
-		nvif_object_fini(&chan->vram);
100
-		nvif_notify_fini(&chan->kill);
101
-		nvif_object_fini(&chan->user);
102
-		nvif_object_fini(&chan->push.ctxdma);
98
+
99
+		if (cli)
100
+			nouveau_svmm_part(chan->vmm->svmm, chan->inst);
101
+
102
+		nvif_object_dtor(&chan->nvsw);
103
+		nvif_object_dtor(&chan->gart);
104
+		nvif_object_dtor(&chan->vram);
105
+		nvif_notify_dtor(&chan->kill);
106
+		nvif_object_dtor(&chan->user);
107
+		nvif_object_dtor(&chan->push.ctxdma);
103
108
 		nouveau_vma_del(&chan->push.vma);
104
109
 		nouveau_bo_unmap(chan->push.buffer);
105
110
 		if (chan->push.buffer && chan->push.buffer->pin_refcnt)
..
..
@@ -111,6 +116,31 @@
111
116
 			cli->base.super = super;
112
117
 	}
113
118
 	*pchan = NULL;
119
+}
120
+
121
+static void
122
+nouveau_channel_kick(struct nvif_push *push)
123
+{
124
+	struct nouveau_channel *chan = container_of(push, typeof(*chan), chan._push);
125
+	chan->dma.cur = chan->dma.cur + (chan->chan._push.cur - chan->chan._push.bgn);
126
+	FIRE_RING(chan);
127
+	chan->chan._push.bgn = chan->chan._push.cur;
128
+}
129
+
130
+static int
131
+nouveau_channel_wait(struct nvif_push *push, u32 size)
132
+{
133
+	struct nouveau_channel *chan = container_of(push, typeof(*chan), chan._push);
134
+	int ret;
135
+	chan->dma.cur = chan->dma.cur + (chan->chan._push.cur - chan->chan._push.bgn);
136
+	ret = RING_SPACE(chan, size);
137
+	if (ret == 0) {
138
+		chan->chan._push.bgn = chan->chan._push.mem.object.map.ptr;
139
+		chan->chan._push.bgn = chan->chan._push.bgn + chan->dma.cur;
140
+		chan->chan._push.cur = chan->chan._push.bgn;
141
+		chan->chan._push.end = chan->chan._push.bgn + size;
142
+	}
143
+	return ret;
114
144
 }
115
145
 
116
146
 static int
..
..
@@ -129,12 +159,13 @@
129
159
 
130
160
 	chan->device = device;
131
161
 	chan->drm = drm;
162
+	chan->vmm = cli->svm.cli ? &cli->svm : &cli->vmm;
132
163
 	atomic_set(&chan->killed, 0);
133
164
 
134
165
 	/* allocate memory for dma push buffer */
135
-	target = TTM_PL_FLAG_TT | TTM_PL_FLAG_UNCACHED;
166
+	target = NOUVEAU_GEM_DOMAIN_GART | NOUVEAU_GEM_DOMAIN_COHERENT;
136
167
 	if (nouveau_vram_pushbuf)
137
-		target = TTM_PL_FLAG_VRAM;
168
+		target = NOUVEAU_GEM_DOMAIN_VRAM;
138
169
 
139
170
 	ret = nouveau_bo_new(cli, size, 0, target, 0, 0, NULL, NULL,
140
171
 			    &chan->push.buffer);
..
..
@@ -149,14 +180,22 @@
149
180
 		return ret;
150
181
 	}
151
182
 
183
+	chan->chan._push.mem.object.parent = cli->base.object.parent;
184
+	chan->chan._push.mem.object.client = &cli->base;
185
+	chan->chan._push.mem.object.name = "chanPush";
186
+	chan->chan._push.mem.object.map.ptr = chan->push.buffer->kmap.virtual;
187
+	chan->chan._push.wait = nouveau_channel_wait;
188
+	chan->chan._push.kick = nouveau_channel_kick;
189
+	chan->chan.push = &chan->chan._push;
190
+
152
191
 	/* create dma object covering the *entire* memory space that the
153
192
 	 * pushbuf lives in, this is because the GEM code requires that
154
193
 	 * we be able to call out to other (indirect) push buffers
155
194
 	 */
156
-	chan->push.addr = chan->push.buffer->bo.offset;
195
+	chan->push.addr = chan->push.buffer->offset;
157
196
 
158
197
 	if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
159
-		ret = nouveau_vma_new(chan->push.buffer, &cli->vmm,
198
+		ret = nouveau_vma_new(chan->push.buffer, chan->vmm,
160
199
 				      &chan->push.vma);
161
200
 		if (ret) {
162
201
 			nouveau_channel_del(pchan);
..
..
@@ -171,7 +210,7 @@
171
210
 		args.target = NV_DMA_V0_TARGET_VM;
172
211
 		args.access = NV_DMA_V0_ACCESS_VM;
173
212
 		args.start = 0;
174
-		args.limit = cli->vmm.vmm.limit - 1;
213
+		args.limit = chan->vmm->vmm.limit - 1;
175
214
 	} else
176
215
 	if (chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM) {
177
216
 		if (device->info.family == NV_DEVICE_INFO_V0_TNT) {
..
..
@@ -201,12 +240,13 @@
201
240
 			args.target = NV_DMA_V0_TARGET_VM;
202
241
 			args.access = NV_DMA_V0_ACCESS_RDWR;
203
242
 			args.start = 0;
204
-			args.limit = cli->vmm.vmm.limit - 1;
243
+			args.limit = chan->vmm->vmm.limit - 1;
205
244
 		}
206
245
 	}
207
246
 
208
-	ret = nvif_object_init(&device->object, 0, NV_DMA_FROM_MEMORY,
209
-			       &args, sizeof(args), &chan->push.ctxdma);
247
+	ret = nvif_object_ctor(&device->object, "abi16PushCtxDma", 0,
248
+			       NV_DMA_FROM_MEMORY, &args, sizeof(args),
249
+			       &chan->push.ctxdma);
210
250
 	if (ret) {
211
251
 		nouveau_channel_del(pchan);
212
252
 		return ret;
..
..
@@ -217,10 +257,10 @@
217
257
 
218
258
 static int
219
259
 nouveau_channel_ind(struct nouveau_drm *drm, struct nvif_device *device,
220
-		    u64 runlist, struct nouveau_channel **pchan)
260
+		    u64 runlist, bool priv, struct nouveau_channel **pchan)
221
261
 {
222
-	struct nouveau_cli *cli = (void *)device->object.client;
223
-	static const u16 oclasses[] = { VOLTA_CHANNEL_GPFIFO_A,
262
+	static const u16 oclasses[] = { TURING_CHANNEL_GPFIFO_A,
263
+					VOLTA_CHANNEL_GPFIFO_A,
224
264
 					PASCAL_CHANNEL_GPFIFO_A,
225
265
 					MAXWELL_CHANNEL_GPFIFO_A,
226
266
 					KEPLER_CHANNEL_GPFIFO_B,
..
..
@@ -234,6 +274,7 @@
234
274
 		struct nv50_channel_gpfifo_v0 nv50;
235
275
 		struct fermi_channel_gpfifo_v0 fermi;
236
276
 		struct kepler_channel_gpfifo_a_v0 kepler;
277
+		struct volta_channel_gpfifo_a_v0 volta;
237
278
 	} args;
238
279
 	struct nouveau_channel *chan;
239
280
 	u32 size;
..
..
@@ -247,39 +288,56 @@
247
288
 
248
289
 	/* create channel object */
249
290
 	do {
291
+		if (oclass[0] >= VOLTA_CHANNEL_GPFIFO_A) {
292
+			args.volta.version = 0;
293
+			args.volta.ilength = 0x02000;
294
+			args.volta.ioffset = 0x10000 + chan->push.addr;
295
+			args.volta.runlist = runlist;
296
+			args.volta.vmm = nvif_handle(&chan->vmm->vmm.object);
297
+			args.volta.priv = priv;
298
+			size = sizeof(args.volta);
299
+		} else
250
300
 		if (oclass[0] >= KEPLER_CHANNEL_GPFIFO_A) {
251
301
 			args.kepler.version = 0;
252
302
 			args.kepler.ilength = 0x02000;
253
303
 			args.kepler.ioffset = 0x10000 + chan->push.addr;
254
304
 			args.kepler.runlist = runlist;
255
-			args.kepler.vmm = nvif_handle(&cli->vmm.vmm.object);
305
+			args.kepler.vmm = nvif_handle(&chan->vmm->vmm.object);
306
+			args.kepler.priv = priv;
256
307
 			size = sizeof(args.kepler);
257
308
 		} else
258
309
 		if (oclass[0] >= FERMI_CHANNEL_GPFIFO) {
259
310
 			args.fermi.version = 0;
260
311
 			args.fermi.ilength = 0x02000;
261
312
 			args.fermi.ioffset = 0x10000 + chan->push.addr;
262
-			args.fermi.vmm = nvif_handle(&cli->vmm.vmm.object);
313
+			args.fermi.vmm = nvif_handle(&chan->vmm->vmm.object);
263
314
 			size = sizeof(args.fermi);
264
315
 		} else {
265
316
 			args.nv50.version = 0;
266
317
 			args.nv50.ilength = 0x02000;
267
318
 			args.nv50.ioffset = 0x10000 + chan->push.addr;
268
319
 			args.nv50.pushbuf = nvif_handle(&chan->push.ctxdma);
269
-			args.nv50.vmm = nvif_handle(&cli->vmm.vmm.object);
320
+			args.nv50.vmm = nvif_handle(&chan->vmm->vmm.object);
270
321
 			size = sizeof(args.nv50);
271
322
 		}
272
323
 
273
-		ret = nvif_object_init(&device->object, 0, *oclass++,
274
-				       &args, size, &chan->user);
324
+		ret = nvif_object_ctor(&device->object, "abi16ChanUser", 0,
325
+				       *oclass++, &args, size, &chan->user);
275
326
 		if (ret == 0) {
276
-			if (chan->user.oclass >= KEPLER_CHANNEL_GPFIFO_A)
327
+			if (chan->user.oclass >= VOLTA_CHANNEL_GPFIFO_A) {
328
+				chan->chid = args.volta.chid;
329
+				chan->inst = args.volta.inst;
330
+				chan->token = args.volta.token;
331
+			} else
332
+			if (chan->user.oclass >= KEPLER_CHANNEL_GPFIFO_A) {
277
333
 				chan->chid = args.kepler.chid;
278
-			else
279
-			if (chan->user.oclass >= FERMI_CHANNEL_GPFIFO)
334
+				chan->inst = args.kepler.inst;
335
+			} else
336
+			if (chan->user.oclass >= FERMI_CHANNEL_GPFIFO) {
280
337
 				chan->chid = args.fermi.chid;
281
-			else
338
+			} else {
282
339
 				chan->chid = args.nv50.chid;
340
+			}
283
341
 			return ret;
284
342
 		}
285
343
 	} while (*oclass);
..
..
@@ -314,8 +372,9 @@
314
372
 	args.offset = chan->push.addr;
315
373
 
316
374
 	do {
317
-		ret = nvif_object_init(&device->object, 0, *oclass++,
318
-				       &args, sizeof(args), &chan->user);
375
+		ret = nvif_object_ctor(&device->object, "abi16ChanUser", 0,
376
+				       *oclass++, &args, sizeof(args),
377
+				       &chan->user);
319
378
 		if (ret == 0) {
320
379
 			chan->chid = args.chid;
321
380
 			return ret;
..
..
@@ -330,7 +389,6 @@
330
389
 nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
331
390
 {
332
391
 	struct nvif_device *device = chan->device;
333
-	struct nouveau_cli *cli = (void *)chan->user.client;
334
392
 	struct nouveau_drm *drm = chan->drm;
335
393
 	struct nv_dma_v0 args = {};
336
394
 	int ret, i;
..
..
@@ -338,7 +396,8 @@
338
396
 	nvif_object_map(&chan->user, NULL, 0);
339
397
 
340
398
 	if (chan->user.oclass >= FERMI_CHANNEL_GPFIFO) {
341
-		ret = nvif_notify_init(&chan->user, nouveau_channel_killed,
399
+		ret = nvif_notify_ctor(&chan->user, "abi16ChanKilled",
400
+				       nouveau_channel_killed,
342
401
 				       true, NV906F_V0_NTFY_KILLED,
343
402
 				       NULL, 0, 0, &chan->kill);
344
403
 		if (ret == 0)
..
..
@@ -356,7 +415,7 @@
356
415
 			args.target = NV_DMA_V0_TARGET_VM;
357
416
 			args.access = NV_DMA_V0_ACCESS_VM;
358
417
 			args.start = 0;
359
-			args.limit = cli->vmm.vmm.limit - 1;
418
+			args.limit = chan->vmm->vmm.limit - 1;
360
419
 		} else {
361
420
 			args.target = NV_DMA_V0_TARGET_VRAM;
362
421
 			args.access = NV_DMA_V0_ACCESS_RDWR;
..
..
@@ -364,8 +423,9 @@
364
423
 			args.limit = device->info.ram_user - 1;
365
424
 		}
366
425
 
367
-		ret = nvif_object_init(&chan->user, vram, NV_DMA_IN_MEMORY,
368
-				       &args, sizeof(args), &chan->vram);
426
+		ret = nvif_object_ctor(&chan->user, "abi16ChanVramCtxDma", vram,
427
+				       NV_DMA_IN_MEMORY, &args, sizeof(args),
428
+				       &chan->vram);
369
429
 		if (ret)
370
430
 			return ret;
371
431
 
..
..
@@ -373,7 +433,7 @@
373
433
 			args.target = NV_DMA_V0_TARGET_VM;
374
434
 			args.access = NV_DMA_V0_ACCESS_VM;
375
435
 			args.start = 0;
376
-			args.limit = cli->vmm.vmm.limit - 1;
436
+			args.limit = chan->vmm->vmm.limit - 1;
377
437
 		} else
378
438
 		if (chan->drm->agp.bridge) {
379
439
 			args.target = NV_DMA_V0_TARGET_AGP;
..
..
@@ -385,11 +445,12 @@
385
445
 			args.target = NV_DMA_V0_TARGET_VM;
386
446
 			args.access = NV_DMA_V0_ACCESS_RDWR;
387
447
 			args.start = 0;
388
-			args.limit = cli->vmm.vmm.limit - 1;
448
+			args.limit = chan->vmm->vmm.limit - 1;
389
449
 		}
390
450
 
391
-		ret = nvif_object_init(&chan->user, gart, NV_DMA_IN_MEMORY,
392
-				       &args, sizeof(args), &chan->gart);
451
+		ret = nvif_object_ctor(&chan->user, "abi16ChanGartCtxDma", gart,
452
+				       NV_DMA_IN_MEMORY, &args, sizeof(args),
453
+				       &chan->gart);
393
454
 		if (ret)
394
455
 			return ret;
395
456
 	}
..
..
@@ -418,28 +479,27 @@
418
479
 	chan->dma.cur = chan->dma.put;
419
480
 	chan->dma.free = chan->dma.max - chan->dma.cur;
420
481
 
421
-	ret = RING_SPACE(chan, NOUVEAU_DMA_SKIPS);
482
+	ret = PUSH_WAIT(chan->chan.push, NOUVEAU_DMA_SKIPS);
422
483
 	if (ret)
423
484
 		return ret;
424
485
 
425
486
 	for (i = 0; i < NOUVEAU_DMA_SKIPS; i++)
426
-		OUT_RING(chan, 0x00000000);
487
+		PUSH_DATA(chan->chan.push, 0x00000000);
427
488
 
428
489
 	/* allocate software object class (used for fences on <= nv05) */
429
490
 	if (device->info.family < NV_DEVICE_INFO_V0_CELSIUS) {
430
-		ret = nvif_object_init(&chan->user, 0x006e,
491
+		ret = nvif_object_ctor(&chan->user, "abi16NvswFence", 0x006e,
431
492
 				       NVIF_CLASS_SW_NV04,
432
493
 				       NULL, 0, &chan->nvsw);
433
494
 		if (ret)
434
495
 			return ret;
435
496
 
436
-		ret = RING_SPACE(chan, 2);
497
+		ret = PUSH_WAIT(chan->chan.push, 2);
437
498
 		if (ret)
438
499
 			return ret;
439
500
 
440
-		BEGIN_NV04(chan, NvSubSw, 0x0000, 1);
441
-		OUT_RING  (chan, chan->nvsw.handle);
442
-		FIRE_RING (chan);
501
+		PUSH_NVSQ(chan->chan.push, NV_SW, 0x0000, chan->nvsw.handle);
502
+		PUSH_KICK(chan->chan.push);
443
503
 	}
444
504
 
445
505
 	/* initialise synchronisation */
..
..
@@ -448,7 +508,8 @@
448
508
 
449
509
 int
450
510
 nouveau_channel_new(struct nouveau_drm *drm, struct nvif_device *device,
451
-		    u32 arg0, u32 arg1, struct nouveau_channel **pchan)
511
+		    u32 arg0, u32 arg1, bool priv,
512
+		    struct nouveau_channel **pchan)
452
513
 {
453
514
 	struct nouveau_cli *cli = (void *)device->object.client;
454
515
 	bool super;
..
..
@@ -458,7 +519,7 @@
458
519
 	super = cli->base.super;
459
520
 	cli->base.super = true;
460
521
 
461
-	ret = nouveau_channel_ind(drm, device, arg0, pchan);
522
+	ret = nouveau_channel_ind(drm, device, arg0, priv, pchan);
462
523
 	if (ret) {
463
524
 		NV_PRINTK(dbg, cli, "ib channel create, %d\n", ret);
464
525
 		ret = nouveau_channel_dma(drm, device, pchan);
..
..
@@ -472,8 +533,13 @@
472
533
 	if (ret) {
473
534
 		NV_PRINTK(err, cli, "channel failed to initialise, %d\n", ret);
474
535
 		nouveau_channel_del(pchan);
536
+		goto done;
475
537
 	}
476
538
 
539
+	ret = nouveau_svmm_join((*pchan)->vmm->svmm, (*pchan)->inst);
540
+	if (ret)
541
+		nouveau_channel_del(pchan);
542
+
477
543
 done:
478
544
 	cli->base.super = super;
479
545
 	return ret;