update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk20a.c
..
..
@@ -22,6 +22,7 @@
22
22
 #include "gf100.h"
23
23
 #include "ctxgf100.h"
24
24
 
25
+#include <core/firmware.h>
25
26
 #include <subdev/timer.h>
26
27
 
27
28
 #include <nvif/class.h>
..
..
@@ -32,22 +33,23 @@
32
33
 	u32 data;
33
34
 };
34
35
 
35
-int
36
-gk20a_gr_av_to_init(struct gf100_gr *gr, const char *fw_name,
37
-		    struct gf100_gr_pack **ppack)
36
+static int
37
+gk20a_gr_av_to_init(struct gf100_gr *gr, const char *path, const char *name,
38
+		    int ver, struct gf100_gr_pack **ppack)
38
39
 {
39
-	struct gf100_gr_fuc fuc;
40
+	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
41
+	struct nvkm_blob blob;
40
42
 	struct gf100_gr_init *init;
41
43
 	struct gf100_gr_pack *pack;
42
44
 	int nent;
43
45
 	int ret;
44
46
 	int i;
45
47
 
46
-	ret = gf100_gr_ctor_fw(gr, fw_name, &fuc);
48
+	ret = nvkm_firmware_load_blob(subdev, path, name, ver, &blob);
47
49
 	if (ret)
48
50
 		return ret;
49
51
 
50
-	nent = (fuc.size / sizeof(struct gk20a_fw_av));
52
+	nent = (blob.size / sizeof(struct gk20a_fw_av));
51
53
 	pack = vzalloc((sizeof(*pack) * 2) + (sizeof(*init) * (nent + 1)));
52
54
 	if (!pack) {
53
55
 		ret = -ENOMEM;
..
..
@@ -59,7 +61,7 @@
59
61
 
60
62
 	for (i = 0; i < nent; i++) {
61
63
 		struct gf100_gr_init *ent = &init[i];
62
-		struct gk20a_fw_av *av = &((struct gk20a_fw_av *)fuc.data)[i];
64
+		struct gk20a_fw_av *av = &((struct gk20a_fw_av *)blob.data)[i];
63
65
 
64
66
 		ent->addr = av->addr;
65
67
 		ent->data = av->data;
..
..
@@ -70,7 +72,7 @@
70
72
 	*ppack = pack;
71
73
 
72
74
 end:
73
-	gf100_gr_dtor_fw(&fuc);
75
+	nvkm_blob_dtor(&blob);
74
76
 	return ret;
75
77
 }
76
78
 
..
..
@@ -81,22 +83,23 @@
81
83
 	u32 data;
82
84
 };
83
85
 
84
-int
85
-gk20a_gr_aiv_to_init(struct gf100_gr *gr, const char *fw_name,
86
-		     struct gf100_gr_pack **ppack)
86
+static int
87
+gk20a_gr_aiv_to_init(struct gf100_gr *gr, const char *path, const char *name,
88
+		     int ver, struct gf100_gr_pack **ppack)
87
89
 {
88
-	struct gf100_gr_fuc fuc;
90
+	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
91
+	struct nvkm_blob blob;
89
92
 	struct gf100_gr_init *init;
90
93
 	struct gf100_gr_pack *pack;
91
94
 	int nent;
92
95
 	int ret;
93
96
 	int i;
94
97
 
95
-	ret = gf100_gr_ctor_fw(gr, fw_name, &fuc);
98
+	ret = nvkm_firmware_load_blob(subdev, path, name, ver, &blob);
96
99
 	if (ret)
97
100
 		return ret;
98
101
 
99
-	nent = (fuc.size / sizeof(struct gk20a_fw_aiv));
102
+	nent = (blob.size / sizeof(struct gk20a_fw_aiv));
100
103
 	pack = vzalloc((sizeof(*pack) * 2) + (sizeof(*init) * (nent + 1)));
101
104
 	if (!pack) {
102
105
 		ret = -ENOMEM;
..
..
@@ -108,7 +111,7 @@
108
111
 
109
112
 	for (i = 0; i < nent; i++) {
110
113
 		struct gf100_gr_init *ent = &init[i];
111
-		struct gk20a_fw_aiv *av = &((struct gk20a_fw_aiv *)fuc.data)[i];
114
+		struct gk20a_fw_aiv *av = &((struct gk20a_fw_aiv *)blob.data)[i];
112
115
 
113
116
 		ent->addr = av->addr;
114
117
 		ent->data = av->data;
..
..
@@ -119,15 +122,16 @@
119
122
 	*ppack = pack;
120
123
 
121
124
 end:
122
-	gf100_gr_dtor_fw(&fuc);
125
+	nvkm_blob_dtor(&blob);
123
126
 	return ret;
124
127
 }
125
128
 
126
-int
127
-gk20a_gr_av_to_method(struct gf100_gr *gr, const char *fw_name,
128
-		      struct gf100_gr_pack **ppack)
129
+static int
130
+gk20a_gr_av_to_method(struct gf100_gr *gr, const char *path, const char *name,
131
+		      int ver, struct gf100_gr_pack **ppack)
129
132
 {
130
-	struct gf100_gr_fuc fuc;
133
+	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
134
+	struct nvkm_blob blob;
131
135
 	struct gf100_gr_init *init;
132
136
 	struct gf100_gr_pack *pack;
133
137
 	/* We don't suppose we will initialize more than 16 classes here... */
..
..
@@ -137,11 +141,11 @@
137
141
 	int ret;
138
142
 	int i;
139
143
 
140
-	ret = gf100_gr_ctor_fw(gr, fw_name, &fuc);
144
+	ret = nvkm_firmware_load_blob(subdev, path, name, ver, &blob);
141
145
 	if (ret)
142
146
 		return ret;
143
147
 
144
-	nent = (fuc.size / sizeof(struct gk20a_fw_av));
148
+	nent = (blob.size / sizeof(struct gk20a_fw_av));
145
149
 
146
150
 	pack = vzalloc((sizeof(*pack) * (max_classes + 1)) +
147
151
 		       (sizeof(*init) * (nent + max_classes + 1)));
..
..
@@ -153,7 +157,7 @@
153
157
 	init = (void *)(pack + max_classes + 1);
154
158
 
155
159
 	for (i = 0; i < nent; i++, init++) {
156
-		struct gk20a_fw_av *av = &((struct gk20a_fw_av *)fuc.data)[i];
160
+		struct gk20a_fw_av *av = &((struct gk20a_fw_av *)blob.data)[i];
157
161
 		u32 class = av->addr & 0xffff;
158
162
 		u32 addr = (av->addr & 0xffff0000) >> 14;
159
163
 
..
..
@@ -179,7 +183,7 @@
179
183
 	*ppack = pack;
180
184
 
181
185
 end:
182
-	gf100_gr_dtor_fw(&fuc);
186
+	nvkm_blob_dtor(&blob);
183
187
 	return ret;
184
188
 }
185
189
 
..
..
@@ -225,7 +229,7 @@
225
229
 	/* Clear SCC RAM */
226
230
 	nvkm_wr32(device, 0x40802c, 0x1);
227
231
 
228
-	gf100_gr_mmio(gr, gr->fuc_sw_nonctx);
232
+	gf100_gr_mmio(gr, gr->sw_nonctx);
229
233
 
230
234
 	ret = gk20a_gr_wait_mem_scrubbing(gr);
231
235
 	if (ret)
..
..
@@ -304,40 +308,56 @@
304
308
 };
305
309
 
306
310
 int
307
-gk20a_gr_new(struct nvkm_device *device, int index, struct nvkm_gr **pgr)
311
+gk20a_gr_load_sw(struct gf100_gr *gr, const char *path, int ver)
308
312
 {
309
-	struct gf100_gr *gr;
310
-	int ret;
311
-
312
-	if (!(gr = kzalloc(sizeof(*gr), GFP_KERNEL)))
313
-		return -ENOMEM;
314
-	*pgr = &gr->base;
315
-
316
-	ret = gf100_gr_ctor(&gk20a_gr, device, index, gr);
317
-	if (ret)
318
-		return ret;
319
-
320
-	if (gf100_gr_ctor_fw(gr, "fecs_inst", &gr->fuc409c) ||
321
-	    gf100_gr_ctor_fw(gr, "fecs_data", &gr->fuc409d) ||
322
-	    gf100_gr_ctor_fw(gr, "gpccs_inst", &gr->fuc41ac) ||
323
-	    gf100_gr_ctor_fw(gr, "gpccs_data", &gr->fuc41ad))
324
-		return -ENODEV;
325
-
326
-	ret = gk20a_gr_av_to_init(gr, "sw_nonctx", &gr->fuc_sw_nonctx);
327
-	if (ret)
328
-		return ret;
329
-
330
-	ret = gk20a_gr_aiv_to_init(gr, "sw_ctx", &gr->fuc_sw_ctx);
331
-	if (ret)
332
-		return ret;
333
-
334
-	ret = gk20a_gr_av_to_init(gr, "sw_bundle_init", &gr->fuc_bundle);
335
-	if (ret)
336
-		return ret;
337
-
338
-	ret = gk20a_gr_av_to_method(gr, "sw_method_init", &gr->fuc_method);
339
-	if (ret)
340
-		return ret;
313
+	if (gk20a_gr_av_to_init(gr, path, "sw_nonctx", ver, &gr->sw_nonctx) ||
314
+	    gk20a_gr_aiv_to_init(gr, path, "sw_ctx", ver, &gr->sw_ctx) ||
315
+	    gk20a_gr_av_to_init(gr, path, "sw_bundle_init", ver, &gr->bundle) ||
316
+	    gk20a_gr_av_to_method(gr, path, "sw_method_init", ver, &gr->method))
317
+		return -ENOENT;
341
318
 
342
319
 	return 0;
343
320
 }
321
+
322
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_124_SOC) || IS_ENABLED(CONFIG_ARCH_TEGRA_132_SOC)
323
+MODULE_FIRMWARE("nvidia/gk20a/fecs_data.bin");
324
+MODULE_FIRMWARE("nvidia/gk20a/fecs_inst.bin");
325
+MODULE_FIRMWARE("nvidia/gk20a/gpccs_data.bin");
326
+MODULE_FIRMWARE("nvidia/gk20a/gpccs_inst.bin");
327
+MODULE_FIRMWARE("nvidia/gk20a/sw_bundle_init.bin");
328
+MODULE_FIRMWARE("nvidia/gk20a/sw_ctx.bin");
329
+MODULE_FIRMWARE("nvidia/gk20a/sw_method_init.bin");
330
+MODULE_FIRMWARE("nvidia/gk20a/sw_nonctx.bin");
331
+#endif
332
+
333
+static int
334
+gk20a_gr_load(struct gf100_gr *gr, int ver, const struct gf100_gr_fwif *fwif)
335
+{
336
+	struct nvkm_subdev *subdev = &gr->base.engine.subdev;
337
+
338
+	if (nvkm_firmware_load_blob(subdev, "", "fecs_inst", ver,
339
+				    &gr->fecs.inst) ||
340
+	    nvkm_firmware_load_blob(subdev, "", "fecs_data", ver,
341
+				    &gr->fecs.data) ||
342
+	    nvkm_firmware_load_blob(subdev, "", "gpccs_inst", ver,
343
+				    &gr->gpccs.inst) ||
344
+	    nvkm_firmware_load_blob(subdev, "", "gpccs_data", ver,
345
+				    &gr->gpccs.data))
346
+		return -ENOENT;
347
+
348
+	gr->firmware = true;
349
+
350
+	return gk20a_gr_load_sw(gr, "", ver);
351
+}
352
+
353
+static const struct gf100_gr_fwif
354
+gk20a_gr_fwif[] = {
355
+	{ 0, gk20a_gr_load, &gk20a_gr },
356
+	{}
357
+};
358
+
359
+int
360
+gk20a_gr_new(struct nvkm_device *device, int index, struct nvkm_gr **pgr)
361
+{
362
+	return gf100_gr_new_(gk20a_gr_fwif, device, index, pgr);
363
+}