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 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 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 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 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 125 static int 126 pvr_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 */ 205 int 206 pvr_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 */ 264 void 265 pvr_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 } 282