modify sin led gpio

hc

2024-05-13 9d77db3c730780c8ef5ccd4b66403ff5675cfe4e

 kernel/drivers/gpu/drm/nouveau/nvc0_fbcon.c
..
..
@@ -21,11 +21,15 @@
21
21
  *
22
22
  * Authors: Ben Skeggs
23
23
  */
24
-
24
+#define NVIF_DEBUG_PRINT_DISABLE
25
25
 #include "nouveau_drv.h"
26
26
 #include "nouveau_dma.h"
27
27
 #include "nouveau_fbcon.h"
28
28
 #include "nouveau_vmm.h"
29
+
30
+#include <nvif/push906f.h>
31
+
32
+#include <nvhw/class/cl902d.h>
29
33
 
30
34
 int
31
35
 nvc0_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
..
..
@@ -33,32 +37,38 @@
33
37
 	struct nouveau_fbdev *nfbdev = info->par;
34
38
 	struct nouveau_drm *drm = nouveau_drm(nfbdev->helper.dev);
35
39
 	struct nouveau_channel *chan = drm->channel;
40
+	struct nvif_push *push = chan->chan.push;
41
+	u32 colour;
36
42
 	int ret;
37
43
 
38
-	ret = RING_SPACE(chan, rect->rop == ROP_COPY ? 7 : 11);
44
+	if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
45
+	    info->fix.visual == FB_VISUAL_DIRECTCOLOR)
46
+		colour = ((uint32_t *)info->pseudo_palette)[rect->color];
47
+	else
48
+		colour = rect->color;
49
+
50
+	ret = PUSH_WAIT(push, rect->rop == ROP_COPY ? 7 : 9);
39
51
 	if (ret)
40
52
 		return ret;
41
53
 
42
54
 	if (rect->rop != ROP_COPY) {
43
-		BEGIN_NVC0(chan, NvSub2D, 0x02ac, 1);
44
-		OUT_RING  (chan, 1);
55
+		PUSH_IMMD(push, NV902D, SET_OPERATION,
56
+			  NVDEF(NV902D, SET_OPERATION, V, ROP_AND));
45
57
 	}
46
-	BEGIN_NVC0(chan, NvSub2D, 0x0588, 1);
47
-	if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
48
-	    info->fix.visual == FB_VISUAL_DIRECTCOLOR)
49
-		OUT_RING  (chan, ((uint32_t *)info->pseudo_palette)[rect->color]);
50
-	else
51
-		OUT_RING  (chan, rect->color);
52
-	BEGIN_NVC0(chan, NvSub2D, 0x0600, 4);
53
-	OUT_RING  (chan, rect->dx);
54
-	OUT_RING  (chan, rect->dy);
55
-	OUT_RING  (chan, rect->dx + rect->width);
56
-	OUT_RING  (chan, rect->dy + rect->height);
58
+
59
+	PUSH_MTHD(push, NV902D, SET_RENDER_SOLID_PRIM_COLOR, colour);
60
+
61
+	PUSH_MTHD(push, NV902D, RENDER_SOLID_PRIM_POINT_SET_X(0), rect->dx,
62
+				RENDER_SOLID_PRIM_POINT_Y(0), rect->dy,
63
+				RENDER_SOLID_PRIM_POINT_SET_X(1), rect->dx + rect->width,
64
+				RENDER_SOLID_PRIM_POINT_Y(1), rect->dy + rect->height);
65
+
57
66
 	if (rect->rop != ROP_COPY) {
58
-		BEGIN_NVC0(chan, NvSub2D, 0x02ac, 1);
59
-		OUT_RING  (chan, 3);
67
+		PUSH_IMMD(push, NV902D, SET_OPERATION,
68
+			  NVDEF(NV902D, SET_OPERATION, V, SRCCOPY));
60
69
 	}
61
-	FIRE_RING(chan);
70
+
71
+	PUSH_KICK(push);
62
72
 	return 0;
63
73
 }
64
74
 
..
..
@@ -68,25 +78,25 @@
68
78
 	struct nouveau_fbdev *nfbdev = info->par;
69
79
 	struct nouveau_drm *drm = nouveau_drm(nfbdev->helper.dev);
70
80
 	struct nouveau_channel *chan = drm->channel;
81
+	struct nvif_push *push = chan->chan.push;
71
82
 	int ret;
72
83
 
73
-	ret = RING_SPACE(chan, 12);
84
+	ret = PUSH_WAIT(push, 11);
74
85
 	if (ret)
75
86
 		return ret;
76
87
 
77
-	BEGIN_NVC0(chan, NvSub2D, 0x0110, 1);
78
-	OUT_RING  (chan, 0);
79
-	BEGIN_NVC0(chan, NvSub2D, 0x08b0, 4);
80
-	OUT_RING  (chan, region->dx);
81
-	OUT_RING  (chan, region->dy);
82
-	OUT_RING  (chan, region->width);
83
-	OUT_RING  (chan, region->height);
84
-	BEGIN_NVC0(chan, NvSub2D, 0x08d0, 4);
85
-	OUT_RING  (chan, 0);
86
-	OUT_RING  (chan, region->sx);
87
-	OUT_RING  (chan, 0);
88
-	OUT_RING  (chan, region->sy);
89
-	FIRE_RING(chan);
88
+	PUSH_IMMD(push, NV902D, WAIT_FOR_IDLE, 0);
89
+
90
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_MEMORY_DST_X0, region->dx,
91
+				SET_PIXELS_FROM_MEMORY_DST_Y0, region->dy,
92
+				SET_PIXELS_FROM_MEMORY_DST_WIDTH, region->width,
93
+				SET_PIXELS_FROM_MEMORY_DST_HEIGHT, region->height);
94
+
95
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_MEMORY_SRC_X0_FRAC, 0,
96
+				SET_PIXELS_FROM_MEMORY_SRC_X0_INT, region->sx,
97
+				SET_PIXELS_FROM_MEMORY_SRC_Y0_FRAC, 0,
98
+				PIXELS_FROM_MEMORY_SRC_Y0_INT, region->sy);
99
+	PUSH_KICK(push);
90
100
 	return 0;
91
101
 }
92
102
 
..
..
@@ -96,52 +106,54 @@
96
106
 	struct nouveau_fbdev *nfbdev = info->par;
97
107
 	struct nouveau_drm *drm = nouveau_drm(nfbdev->helper.dev);
98
108
 	struct nouveau_channel *chan = drm->channel;
109
+	struct nvif_push *push = chan->chan.push;
99
110
 	uint32_t dwords, *data = (uint32_t *)image->data;
100
111
 	uint32_t mask = ~(~0 >> (32 - info->var.bits_per_pixel));
101
-	uint32_t *palette = info->pseudo_palette;
112
+	uint32_t *palette = info->pseudo_palette, bg, fg;
102
113
 	int ret;
103
114
 
104
115
 	if (image->depth != 1)
105
116
 		return -ENODEV;
106
117
 
107
-	ret = RING_SPACE(chan, 11);
118
+	if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
119
+	    info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
120
+		bg = palette[image->bg_color] | mask;
121
+		fg = palette[image->fg_color] | mask;
122
+	} else {
123
+		bg = image->bg_color;
124
+		fg = image->fg_color;
125
+	}
126
+
127
+	ret = PUSH_WAIT(push, 11);
108
128
 	if (ret)
109
129
 		return ret;
110
130
 
111
-	BEGIN_NVC0(chan, NvSub2D, 0x0814, 2);
112
-	if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
113
-	    info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
114
-		OUT_RING  (chan, palette[image->bg_color] | mask);
115
-		OUT_RING  (chan, palette[image->fg_color] | mask);
116
-	} else {
117
-		OUT_RING  (chan, image->bg_color);
118
-		OUT_RING  (chan, image->fg_color);
119
-	}
120
-	BEGIN_NVC0(chan, NvSub2D, 0x0838, 2);
121
-	OUT_RING  (chan, image->width);
122
-	OUT_RING  (chan, image->height);
123
-	BEGIN_NVC0(chan, NvSub2D, 0x0850, 4);
124
-	OUT_RING  (chan, 0);
125
-	OUT_RING  (chan, image->dx);
126
-	OUT_RING  (chan, 0);
127
-	OUT_RING  (chan, image->dy);
131
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_CPU_COLOR0, bg,
132
+				SET_PIXELS_FROM_CPU_COLOR1, fg);
133
+
134
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_CPU_SRC_WIDTH, image->width,
135
+				SET_PIXELS_FROM_CPU_SRC_HEIGHT, image->height);
136
+
137
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_CPU_DST_X0_FRAC, 0,
138
+				SET_PIXELS_FROM_CPU_DST_X0_INT, image->dx,
139
+				SET_PIXELS_FROM_CPU_DST_Y0_FRAC, 0,
140
+				SET_PIXELS_FROM_CPU_DST_Y0_INT, image->dy);
128
141
 
129
142
 	dwords = ALIGN(ALIGN(image->width, 8) * image->height, 32) >> 5;
130
143
 	while (dwords) {
131
-		int push = dwords > 2047 ? 2047 : dwords;
144
+		int count = dwords > 2047 ? 2047 : dwords;
132
145
 
133
-		ret = RING_SPACE(chan, push + 1);
146
+		ret = PUSH_WAIT(push, count + 1);
134
147
 		if (ret)
135
148
 			return ret;
136
149
 
137
-		dwords -= push;
150
+		dwords -= count;
138
151
 
139
-		BEGIN_NIC0(chan, NvSub2D, 0x0860, push);
140
-		OUT_RINGp(chan, data, push);
141
-		data += push;
152
+		PUSH_NINC(push, NV902D, PIXELS_FROM_CPU_DATA, data, count);
153
+		data += count;
142
154
 	}
143
155
 
144
-	FIRE_RING(chan);
156
+	PUSH_KICK(push);
145
157
 	return 0;
146
158
 }
147
159
 
..
..
@@ -150,34 +162,34 @@
150
162
 {
151
163
 	struct nouveau_fbdev *nfbdev = info->par;
152
164
 	struct drm_device *dev = nfbdev->helper.dev;
153
-	struct nouveau_framebuffer *fb = nouveau_framebuffer(nfbdev->helper.fb);
154
165
 	struct nouveau_drm *drm = nouveau_drm(dev);
155
166
 	struct nouveau_channel *chan = drm->channel;
167
+	struct nvif_push *push = chan->chan.push;
156
168
 	int ret, format;
157
169
 
158
-	ret = nvif_object_init(&chan->user, 0x902d, 0x902d, NULL, 0,
159
-			       &nfbdev->twod);
170
+	ret = nvif_object_ctor(&chan->user, "fbconTwoD", 0x902d, 0x902d,
171
+			       NULL, 0, &nfbdev->twod);
160
172
 	if (ret)
161
173
 		return ret;
162
174
 
163
175
 	switch (info->var.bits_per_pixel) {
164
176
 	case 8:
165
-		format = 0xf3;
177
+		format = NV902D_SET_DST_FORMAT_V_Y8;
166
178
 		break;
167
179
 	case 15:
168
-		format = 0xf8;
180
+		format = NV902D_SET_DST_FORMAT_V_X1R5G5B5;
169
181
 		break;
170
182
 	case 16:
171
-		format = 0xe8;
183
+		format = NV902D_SET_DST_FORMAT_V_R5G6B5;
172
184
 		break;
173
185
 	case 32:
174
186
 		switch (info->var.transp.length) {
175
187
 		case 0: /* depth 24 */
176
188
 		case 8: /* depth 32, just use 24.. */
177
-			format = 0xe6;
189
+			format = NV902D_SET_DST_FORMAT_V_X8R8G8B8;
178
190
 			break;
179
191
 		case 2: /* depth 30 */
180
-			format = 0xd1;
192
+			format = NV902D_SET_DST_FORMAT_V_A2B10G10R10;
181
193
 			break;
182
194
 		default:
183
195
 			return -EINVAL;
..
..
@@ -187,74 +199,99 @@
187
199
 		return -EINVAL;
188
200
 	}
189
201
 
190
-	ret = RING_SPACE(chan, 58);
202
+	ret = PUSH_WAIT(push, 52);
191
203
 	if (ret) {
192
204
 		WARN_ON(1);
193
205
 		nouveau_fbcon_gpu_lockup(info);
194
206
 		return ret;
195
207
 	}
196
208
 
197
-	BEGIN_NVC0(chan, NvSub2D, 0x0000, 1);
198
-	OUT_RING  (chan, nfbdev->twod.handle);
199
-	BEGIN_NVC0(chan, NvSub2D, 0x0290, 1);
200
-	OUT_RING  (chan, 0);
201
-	BEGIN_NVC0(chan, NvSub2D, 0x0888, 1);
202
-	OUT_RING  (chan, 1);
203
-	BEGIN_NVC0(chan, NvSub2D, 0x02ac, 1);
204
-	OUT_RING  (chan, 3);
205
-	BEGIN_NVC0(chan, NvSub2D, 0x02a0, 1);
206
-	OUT_RING  (chan, 0x55);
207
-	BEGIN_NVC0(chan, NvSub2D, 0x08c0, 4);
208
-	OUT_RING  (chan, 0);
209
-	OUT_RING  (chan, 1);
210
-	OUT_RING  (chan, 0);
211
-	OUT_RING  (chan, 1);
212
-	BEGIN_NVC0(chan, NvSub2D, 0x0580, 2);
213
-	OUT_RING  (chan, 4);
214
-	OUT_RING  (chan, format);
215
-	BEGIN_NVC0(chan, NvSub2D, 0x02e8, 2);
216
-	OUT_RING  (chan, 2);
217
-	OUT_RING  (chan, 1);
209
+	PUSH_MTHD(push, NV902D, SET_OBJECT, nfbdev->twod.handle);
218
210
 
219
-	BEGIN_NVC0(chan, NvSub2D, 0x0804, 1);
220
-	OUT_RING  (chan, format);
221
-	BEGIN_NVC0(chan, NvSub2D, 0x0800, 1);
222
-	OUT_RING  (chan, 1);
223
-	BEGIN_NVC0(chan, NvSub2D, 0x0808, 3);
224
-	OUT_RING  (chan, 0);
225
-	OUT_RING  (chan, 0);
226
-	OUT_RING  (chan, 1);
227
-	BEGIN_NVC0(chan, NvSub2D, 0x081c, 1);
228
-	OUT_RING  (chan, 1);
229
-	BEGIN_NVC0(chan, NvSub2D, 0x0840, 4);
230
-	OUT_RING  (chan, 0);
231
-	OUT_RING  (chan, 1);
232
-	OUT_RING  (chan, 0);
233
-	OUT_RING  (chan, 1);
234
-	BEGIN_NVC0(chan, NvSub2D, 0x0200, 10);
235
-	OUT_RING  (chan, format);
236
-	OUT_RING  (chan, 1);
237
-	OUT_RING  (chan, 0);
238
-	OUT_RING  (chan, 1);
239
-	OUT_RING  (chan, 0);
240
-	OUT_RING  (chan, info->fix.line_length);
241
-	OUT_RING  (chan, info->var.xres_virtual);
242
-	OUT_RING  (chan, info->var.yres_virtual);
243
-	OUT_RING  (chan, upper_32_bits(fb->vma->addr));
244
-	OUT_RING  (chan, lower_32_bits(fb->vma->addr));
245
-	BEGIN_NVC0(chan, NvSub2D, 0x0230, 10);
246
-	OUT_RING  (chan, format);
247
-	OUT_RING  (chan, 1);
248
-	OUT_RING  (chan, 0);
249
-	OUT_RING  (chan, 1);
250
-	OUT_RING  (chan, 0);
251
-	OUT_RING  (chan, info->fix.line_length);
252
-	OUT_RING  (chan, info->var.xres_virtual);
253
-	OUT_RING  (chan, info->var.yres_virtual);
254
-	OUT_RING  (chan, upper_32_bits(fb->vma->addr));
255
-	OUT_RING  (chan, lower_32_bits(fb->vma->addr));
256
-	FIRE_RING (chan);
211
+	PUSH_MTHD(push, NV902D, SET_DST_FORMAT,
212
+		  NVVAL(NV902D, SET_DST_FORMAT, V, format),
257
213
 
214
+				SET_DST_MEMORY_LAYOUT,
215
+		  NVDEF(NV902D, SET_DST_MEMORY_LAYOUT, V, PITCH));
216
+
217
+	PUSH_MTHD(push, NV902D, SET_DST_PITCH, info->fix.line_length,
218
+				SET_DST_WIDTH, info->var.xres_virtual,
219
+				SET_DST_HEIGHT, info->var.yres_virtual,
220
+
221
+				SET_DST_OFFSET_UPPER,
222
+		  NVVAL(NV902D, SET_DST_OFFSET_UPPER, V, upper_32_bits(nfbdev->vma->addr)),
223
+
224
+				SET_DST_OFFSET_LOWER,
225
+		  NVVAL(NV902D, SET_DST_OFFSET_LOWER, V, lower_32_bits(nfbdev->vma->addr)));
226
+
227
+	PUSH_MTHD(push, NV902D, SET_SRC_FORMAT,
228
+		  NVVAL(NV902D, SET_SRC_FORMAT, V, format),
229
+
230
+				SET_SRC_MEMORY_LAYOUT,
231
+		  NVDEF(NV902D, SET_SRC_MEMORY_LAYOUT, V, PITCH));
232
+
233
+	PUSH_MTHD(push, NV902D, SET_SRC_PITCH, info->fix.line_length,
234
+				SET_SRC_WIDTH, info->var.xres_virtual,
235
+				SET_SRC_HEIGHT, info->var.yres_virtual,
236
+
237
+				SET_SRC_OFFSET_UPPER,
238
+		  NVVAL(NV902D, SET_SRC_OFFSET_UPPER, V, upper_32_bits(nfbdev->vma->addr)),
239
+
240
+				SET_SRC_OFFSET_LOWER,
241
+		  NVVAL(NV902D, SET_SRC_OFFSET_LOWER, V, lower_32_bits(nfbdev->vma->addr)));
242
+
243
+	PUSH_IMMD(push, NV902D, SET_CLIP_ENABLE,
244
+		  NVDEF(NV902D, SET_CLIP_ENABLE, V, FALSE));
245
+
246
+	PUSH_IMMD(push, NV902D, SET_ROP,
247
+		  NVVAL(NV902D, SET_ROP, V, 0x55));
248
+
249
+	PUSH_IMMD(push, NV902D, SET_OPERATION,
250
+		  NVDEF(NV902D, SET_OPERATION, V, SRCCOPY));
251
+
252
+	PUSH_MTHD(push, NV902D, SET_MONOCHROME_PATTERN_COLOR_FORMAT,
253
+		  NVDEF(NV902D, SET_MONOCHROME_PATTERN_COLOR_FORMAT, V, A8R8G8B8),
254
+
255
+				SET_MONOCHROME_PATTERN_FORMAT,
256
+		  NVDEF(NV902D, SET_MONOCHROME_PATTERN_FORMAT, V, LE_M1));
257
+
258
+	PUSH_MTHD(push, NV902D, RENDER_SOLID_PRIM_MODE,
259
+		  NVDEF(NV902D, RENDER_SOLID_PRIM_MODE, V, RECTS),
260
+
261
+				SET_RENDER_SOLID_PRIM_COLOR_FORMAT,
262
+		  NVVAL(NV902D, SET_RENDER_SOLID_PRIM_COLOR_FORMAT, V, format));
263
+
264
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_CPU_DATA_TYPE,
265
+		  NVDEF(NV902D, SET_PIXELS_FROM_CPU_DATA_TYPE, V, INDEX),
266
+
267
+				SET_PIXELS_FROM_CPU_COLOR_FORMAT,
268
+		  NVVAL(NV902D, SET_PIXELS_FROM_CPU_COLOR_FORMAT, V, format),
269
+
270
+				SET_PIXELS_FROM_CPU_INDEX_FORMAT,
271
+		  NVDEF(NV902D, SET_PIXELS_FROM_CPU_INDEX_FORMAT, V, I1),
272
+
273
+				SET_PIXELS_FROM_CPU_MONO_FORMAT,
274
+		  NVDEF(NV902D, SET_PIXELS_FROM_CPU_MONO_FORMAT, V, CGA6_M1),
275
+
276
+				SET_PIXELS_FROM_CPU_WRAP,
277
+		  NVDEF(NV902D, SET_PIXELS_FROM_CPU_WRAP, V, WRAP_BYTE));
278
+
279
+	PUSH_IMMD(push, NV902D, SET_PIXELS_FROM_CPU_MONO_OPACITY,
280
+		  NVDEF(NV902D, SET_PIXELS_FROM_CPU_MONO_OPACITY, V, OPAQUE));
281
+
282
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_CPU_DX_DU_FRAC, 0,
283
+				SET_PIXELS_FROM_CPU_DX_DU_INT, 1,
284
+				SET_PIXELS_FROM_CPU_DY_DV_FRAC, 0,
285
+				SET_PIXELS_FROM_CPU_DY_DV_INT, 1);
286
+
287
+	PUSH_IMMD(push, NV902D, SET_PIXELS_FROM_MEMORY_SAFE_OVERLAP,
288
+		  NVDEF(NV902D, SET_PIXELS_FROM_MEMORY_SAFE_OVERLAP, V, TRUE));
289
+
290
+	PUSH_MTHD(push, NV902D, SET_PIXELS_FROM_MEMORY_DU_DX_FRAC, 0,
291
+				SET_PIXELS_FROM_MEMORY_DU_DX_INT, 1,
292
+				SET_PIXELS_FROM_MEMORY_DV_DY_FRAC, 0,
293
+				SET_PIXELS_FROM_MEMORY_DV_DY_INT, 1);
294
+	PUSH_KICK(push);
258
295
 	return 0;
259
296
 }
260
297