pvr_stream.c

  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, 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
 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[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_size, sizeof(u8),
 83						  sizeof(u8), 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_size, sizeof(u16),
 90						  sizeof(u16), 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_size, sizeof(u32),
 97						  sizeof(u32), 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_size, sizeof(u64),
104						  sizeof(u64), 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_size,
111						  stream_def[i].array_size, sizeof(u64),
112						  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(ext_stream, &stream_offset, ext_stream_size, sizeof(u32),
144					  sizeof(ext_header), &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, ext_def->quirk))
167				return -EINVAL;
168
169			err = pvr_stream_process_1(pvr_dev, ext_def->stream, ext_def->stream_len,
170						   ext_stream, stream_offset,
171						   ext_stream_size, dest,
172						   cmd_defs->dest_size, &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_size, sizeof(u32),
218				  sizeof(u32), &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_size, sizeof(u32),
227				  sizeof(u32), &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, cmd_defs->main_stream, cmd_defs->main_stream_len,
235				   stream, stream_offset, main_stream_len, dest_out,
236				   cmd_defs->dest_size, &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, stream, stream_offset,
242						    stream_size, 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, 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, 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}