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

source code of linux/drivers/gpu/drm/imagination/pvr_stream.c