1 // SPDX-License-Identifier: GPL-2.0-only OR MIT
2 /* Copyright (c) 2023 Imagination Technologies Ltd. */
3
4 #include "pvr_device.h"
5 #include "pvr_rogue_fwif_stream.h"
6 #include "pvr_stream.h"
7
8 #include <linux/align.h>
9 #include <linux/slab.h>
10 #include <linux/types.h>
11 #include <uapi/drm/pvr_drm.h>
12
13 static __always_inline bool
stream_def_is_supported(struct pvr_device * pvr_dev,const struct pvr_stream_def * stream_def)14 stream_def_is_supported(struct pvr_device *pvr_dev, const struct pvr_stream_def *stream_def)
15 {
16 if (stream_def->feature == PVR_FEATURE_NONE)
17 return true;
18
19 if (!(stream_def->feature & PVR_FEATURE_NOT) &&
20 pvr_device_has_feature(pvr_dev, stream_def->feature)) {
21 return true;
22 }
23
24 if ((stream_def->feature & PVR_FEATURE_NOT) &&
25 !pvr_device_has_feature(pvr_dev, stream_def->feature & ~PVR_FEATURE_NOT)) {
26 return true;
27 }
28
29 return false;
30 }
31
32 static int
pvr_stream_get_data(u8 * stream,u32 * stream_offset,u32 stream_size,u32 data_size,u32 align_size,void * dest)33 pvr_stream_get_data(u8 *stream, u32 *stream_offset, u32 stream_size, u32 data_size, u32 align_size,
34 void *dest)
35 {
36 *stream_offset = ALIGN(*stream_offset, align_size);
37
38 if ((*stream_offset + data_size) > stream_size)
39 return -EINVAL;
40
41 memcpy(dest, stream + *stream_offset, data_size);
42
43 (*stream_offset) += data_size;
44
45 return 0;
46 }
47
48 /**
49 * pvr_stream_process_1() - Process a single stream and fill destination structure
50 * @pvr_dev: Device pointer.
51 * @stream_def: Stream definition.
52 * @nr_entries: Number of entries in &stream_def.
53 * @stream: Pointer to stream.
54 * @stream_offset: Starting offset within stream.
55 * @stream_size: Size of input stream, in bytes.
56 * @dest: Pointer to destination structure.
57 * @dest_size: Size of destination structure.
58 * @stream_offset_out: Pointer to variable to write updated stream offset to. May be NULL.
59 *
60 * Returns:
61 * * 0 on success, or
62 * * -%EINVAL on malformed stream.
63 */
64 static int
pvr_stream_process_1(struct pvr_device * pvr_dev,const struct pvr_stream_def * stream_def,u32 nr_entries,u8 * stream,u32 stream_offset,u32 stream_size,u8 * dest,u32 dest_size,u32 * stream_offset_out)65 pvr_stream_process_1(struct pvr_device *pvr_dev, const struct pvr_stream_def *stream_def,
66 u32 nr_entries, u8 *stream, u32 stream_offset, u32 stream_size,
67 u8 *dest, u32 dest_size, u32 *stream_offset_out)
68 {
69 int err = 0;
70 u32 i;
71
72 for (i = 0; i < nr_entries; i++) {
73 if (stream_def[i].offset >= dest_size) {
74 err = -EINVAL;
75 break;
76 }
77
78 if (!stream_def_is_supported(pvr_dev, &stream_def[i]))
79 continue;
80
81 switch (stream_def[i].size) {
82 case PVR_STREAM_SIZE_8:
83 err = pvr_stream_get_data(stream, &stream_offset, stream_size, sizeof(u8),
84 sizeof(u8), dest + stream_def[i].offset);
85 if (err)
86 return err;
87 break;
88
89 case PVR_STREAM_SIZE_16:
90 err = pvr_stream_get_data(stream, &stream_offset, stream_size, sizeof(u16),
91 sizeof(u16), dest + stream_def[i].offset);
92 if (err)
93 return err;
94 break;
95
96 case PVR_STREAM_SIZE_32:
97 err = pvr_stream_get_data(stream, &stream_offset, stream_size, sizeof(u32),
98 sizeof(u32), dest + stream_def[i].offset);
99 if (err)
100 return err;
101 break;
102
103 case PVR_STREAM_SIZE_64:
104 err = pvr_stream_get_data(stream, &stream_offset, stream_size, sizeof(u64),
105 sizeof(u64), dest + stream_def[i].offset);
106 if (err)
107 return err;
108 break;
109
110 case PVR_STREAM_SIZE_ARRAY:
111 err = pvr_stream_get_data(stream, &stream_offset, stream_size,
112 stream_def[i].array_size, sizeof(u64),
113 dest + stream_def[i].offset);
114 if (err)
115 return err;
116 break;
117 }
118 }
119
120 if (stream_offset_out)
121 *stream_offset_out = stream_offset;
122
123 return err;
124 }
125
126 static int
pvr_stream_process_ext_stream(struct pvr_device * pvr_dev,const struct pvr_stream_cmd_defs * cmd_defs,void * ext_stream,u32 stream_offset,u32 ext_stream_size,void * dest)127 pvr_stream_process_ext_stream(struct pvr_device *pvr_dev,
128 const struct pvr_stream_cmd_defs *cmd_defs, void *ext_stream,
129 u32 stream_offset, u32 ext_stream_size, void *dest)
130 {
131 u32 musthave_masks[PVR_STREAM_EXTHDR_TYPE_MAX];
132 u32 ext_header;
133 int err = 0;
134 u32 i;
135
136 /* Copy "must have" mask from device. We clear this as we process the stream. */
137 memcpy(musthave_masks, pvr_dev->stream_musthave_quirks[cmd_defs->type],
138 sizeof(musthave_masks));
139
140 do {
141 const struct pvr_stream_ext_header *header;
142 u32 type;
143 u32 data;
144
145 err = pvr_stream_get_data(ext_stream, &stream_offset, ext_stream_size, sizeof(u32),
146 sizeof(ext_header), &ext_header);
147 if (err)
148 return err;
149
150 type = (ext_header & PVR_STREAM_EXTHDR_TYPE_MASK) >> PVR_STREAM_EXTHDR_TYPE_SHIFT;
151 data = ext_header & PVR_STREAM_EXTHDR_DATA_MASK;
152
153 if (type >= cmd_defs->ext_nr_headers)
154 return -EINVAL;
155
156 header = &cmd_defs->ext_headers[type];
157 if (data & ~header->valid_mask)
158 return -EINVAL;
159
160 musthave_masks[type] &= ~data;
161
162 for (i = 0; i < header->ext_streams_num; i++) {
163 const struct pvr_stream_ext_def *ext_def = &header->ext_streams[i];
164
165 if (!(ext_header & ext_def->header_mask))
166 continue;
167
168 if (!pvr_device_has_uapi_quirk(pvr_dev, ext_def->quirk))
169 return -EINVAL;
170
171 err = pvr_stream_process_1(pvr_dev, ext_def->stream, ext_def->stream_len,
172 ext_stream, stream_offset,
173 ext_stream_size, dest,
174 cmd_defs->dest_size, &stream_offset);
175 if (err)
176 return err;
177 }
178 } while (ext_header & PVR_STREAM_EXTHDR_CONTINUATION);
179
180 /*
181 * Verify that "must have" mask is now zero. If it isn't then one of the "must have" quirks
182 * for this command was not present.
183 */
184 for (i = 0; i < cmd_defs->ext_nr_headers; i++) {
185 if (musthave_masks[i])
186 return -EINVAL;
187 }
188
189 return 0;
190 }
191
192 /**
193 * pvr_stream_process() - Build FW structure from stream
194 * @pvr_dev: Device pointer.
195 * @cmd_defs: Stream definition.
196 * @stream: Pointer to command stream.
197 * @stream_size: Size of command stream, in bytes.
198 * @dest_out: Pointer to destination buffer.
199 *
200 * Caller is responsible for freeing the output structure.
201 *
202 * Returns:
203 * * 0 on success,
204 * * -%ENOMEM on out of memory, or
205 * * -%EINVAL on malformed stream.
206 */
207 int
pvr_stream_process(struct pvr_device * pvr_dev,const struct pvr_stream_cmd_defs * cmd_defs,void * stream,u32 stream_size,void * dest_out)208 pvr_stream_process(struct pvr_device *pvr_dev, const struct pvr_stream_cmd_defs *cmd_defs,
209 void *stream, u32 stream_size, void *dest_out)
210 {
211 u32 stream_offset = 0;
212 u32 main_stream_len;
213 u32 padding;
214 int err;
215
216 if (!stream || !stream_size)
217 return -EINVAL;
218
219 err = pvr_stream_get_data(stream, &stream_offset, stream_size, sizeof(u32),
220 sizeof(u32), &main_stream_len);
221 if (err)
222 return err;
223
224 /*
225 * u32 after stream length is padding to ensure u64 alignment, but may be used for expansion
226 * in the future. Verify it's zero.
227 */
228 err = pvr_stream_get_data(stream, &stream_offset, stream_size, sizeof(u32),
229 sizeof(u32), &padding);
230 if (err)
231 return err;
232
233 if (main_stream_len < stream_offset || main_stream_len > stream_size || padding)
234 return -EINVAL;
235
236 err = pvr_stream_process_1(pvr_dev, cmd_defs->main_stream, cmd_defs->main_stream_len,
237 stream, stream_offset, main_stream_len, dest_out,
238 cmd_defs->dest_size, &stream_offset);
239 if (err)
240 return err;
241
242 if (stream_offset < stream_size) {
243 err = pvr_stream_process_ext_stream(pvr_dev, cmd_defs, stream, stream_offset,
244 stream_size, dest_out);
245 if (err)
246 return err;
247 } else {
248 u32 i;
249
250 /*
251 * If we don't have an extension stream then there must not be any "must have"
252 * quirks for this command.
253 */
254 for (i = 0; i < cmd_defs->ext_nr_headers; i++) {
255 if (pvr_dev->stream_musthave_quirks[cmd_defs->type][i])
256 return -EINVAL;
257 }
258 }
259
260 return 0;
261 }
262
263 /**
264 * pvr_stream_create_musthave_masks() - Create "must have" masks for streams based on current device
265 * quirks
266 * @pvr_dev: Device pointer.
267 */
268 void
pvr_stream_create_musthave_masks(struct pvr_device * pvr_dev)269 pvr_stream_create_musthave_masks(struct pvr_device *pvr_dev)
270 {
271 memset(pvr_dev->stream_musthave_quirks, 0, sizeof(pvr_dev->stream_musthave_quirks));
272
273 if (pvr_device_has_uapi_quirk(pvr_dev, 47217))
274 pvr_dev->stream_musthave_quirks[PVR_STREAM_TYPE_FRAG][0] |=
275 PVR_STREAM_EXTHDR_FRAG0_BRN47217;
276
277 if (pvr_device_has_uapi_quirk(pvr_dev, 49927)) {
278 pvr_dev->stream_musthave_quirks[PVR_STREAM_TYPE_GEOM][0] |=
279 PVR_STREAM_EXTHDR_GEOM0_BRN49927;
280 pvr_dev->stream_musthave_quirks[PVR_STREAM_TYPE_FRAG][0] |=
281 PVR_STREAM_EXTHDR_FRAG0_BRN49927;
282 pvr_dev->stream_musthave_quirks[PVR_STREAM_TYPE_COMPUTE][0] |=
283 PVR_STREAM_EXTHDR_COMPUTE0_BRN49927;
284 }
285 }
286