1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2018 Linaro Ltd.
4  *
5  * Author: Stanimir Varbanov <stanimir.varbanov@linaro.org>
6  */
7 #include <linux/bitops.h>
8 #include <linux/kernel.h>
9 
10 #include "core.h"
11 #include "hfi_helper.h"
12 #include "hfi_parser.h"
13 
14 typedef void (*func)(struct hfi_plat_caps *cap, const void *data,
15 		     unsigned int size);
16 
17 static void init_codecs(struct venus_core *core)
18 {
19 	struct hfi_plat_caps *caps = core->caps, *cap;
20 	unsigned long bit;
21 
22 	for_each_set_bit(bit, &core->dec_codecs, MAX_CODEC_NUM) {
23 		cap = &caps[core->codecs_count++];
24 		cap->codec = BIT(bit);
25 		cap->domain = VIDC_SESSION_TYPE_DEC;
26 		cap->valid = false;
27 	}
28 
29 	for_each_set_bit(bit, &core->enc_codecs, MAX_CODEC_NUM) {
30 		cap = &caps[core->codecs_count++];
31 		cap->codec = BIT(bit);
32 		cap->domain = VIDC_SESSION_TYPE_ENC;
33 		cap->valid = false;
34 	}
35 }
36 
37 static void for_each_codec(struct hfi_plat_caps *caps, unsigned int caps_num,
38 			   u32 codecs, u32 domain, func cb, void *data,
39 			   unsigned int size)
40 {
41 	struct hfi_plat_caps *cap;
42 	unsigned int i;
43 
44 	for (i = 0; i < caps_num; i++) {
45 		cap = &caps[i];
46 		if (cap->valid && cap->domain == domain)
47 			continue;
48 		if (cap->codec & codecs && cap->domain == domain)
49 			cb(cap, data, size);
50 	}
51 }
52 
53 static void
54 fill_buf_mode(struct hfi_plat_caps *cap, const void *data, unsigned int num)
55 {
56 	const u32 *type = data;
57 
58 	if (*type == HFI_BUFFER_MODE_DYNAMIC)
59 		cap->cap_bufs_mode_dynamic = true;
60 }
61 
62 static void
63 parse_alloc_mode(struct venus_core *core, u32 codecs, u32 domain, void *data)
64 {
65 	struct hfi_buffer_alloc_mode_supported *mode = data;
66 	u32 num_entries = mode->num_entries;
67 	u32 *type;
68 
69 	if (num_entries > MAX_ALLOC_MODE_ENTRIES)
70 		return;
71 
72 	type = mode->data;
73 
74 	while (num_entries--) {
75 		if (mode->buffer_type == HFI_BUFFER_OUTPUT ||
76 		    mode->buffer_type == HFI_BUFFER_OUTPUT2)
77 			for_each_codec(core->caps, ARRAY_SIZE(core->caps),
78 				       codecs, domain, fill_buf_mode, type, 1);
79 
80 		type++;
81 	}
82 }
83 
84 static void fill_profile_level(struct hfi_plat_caps *cap, const void *data,
85 			       unsigned int num)
86 {
87 	const struct hfi_profile_level *pl = data;
88 
89 	memcpy(&cap->pl[cap->num_pl], pl, num * sizeof(*pl));
90 	cap->num_pl += num;
91 }
92 
93 static void
94 parse_profile_level(struct venus_core *core, u32 codecs, u32 domain, void *data)
95 {
96 	struct hfi_profile_level_supported *pl = data;
97 	struct hfi_profile_level *proflevel = pl->profile_level;
98 	struct hfi_profile_level pl_arr[HFI_MAX_PROFILE_COUNT] = {};
99 
100 	if (pl->profile_count > HFI_MAX_PROFILE_COUNT)
101 		return;
102 
103 	memcpy(pl_arr, proflevel, pl->profile_count * sizeof(*proflevel));
104 
105 	for_each_codec(core->caps, ARRAY_SIZE(core->caps), codecs, domain,
106 		       fill_profile_level, pl_arr, pl->profile_count);
107 }
108 
109 static void
110 fill_caps(struct hfi_plat_caps *cap, const void *data, unsigned int num)
111 {
112 	const struct hfi_capability *caps = data;
113 
114 	memcpy(&cap->caps[cap->num_caps], caps, num * sizeof(*caps));
115 	cap->num_caps += num;
116 }
117 
118 static void
119 parse_caps(struct venus_core *core, u32 codecs, u32 domain, void *data)
120 {
121 	struct hfi_capabilities *caps = data;
122 	struct hfi_capability *cap = caps->data;
123 	u32 num_caps = caps->num_capabilities;
124 	struct hfi_capability caps_arr[MAX_CAP_ENTRIES] = {};
125 
126 	if (num_caps > MAX_CAP_ENTRIES)
127 		return;
128 
129 	memcpy(caps_arr, cap, num_caps * sizeof(*cap));
130 
131 	for_each_codec(core->caps, ARRAY_SIZE(core->caps), codecs, domain,
132 		       fill_caps, caps_arr, num_caps);
133 }
134 
135 static void fill_raw_fmts(struct hfi_plat_caps *cap, const void *fmts,
136 			  unsigned int num_fmts)
137 {
138 	const struct raw_formats *formats = fmts;
139 
140 	memcpy(&cap->fmts[cap->num_fmts], formats, num_fmts * sizeof(*formats));
141 	cap->num_fmts += num_fmts;
142 }
143 
144 static void
145 parse_raw_formats(struct venus_core *core, u32 codecs, u32 domain, void *data)
146 {
147 	struct hfi_uncompressed_format_supported *fmt = data;
148 	struct hfi_uncompressed_plane_info *pinfo = fmt->plane_info;
149 	struct hfi_uncompressed_plane_constraints *constr;
150 	struct raw_formats rawfmts[MAX_FMT_ENTRIES] = {};
151 	u32 entries = fmt->format_entries;
152 	unsigned int i = 0;
153 	u32 num_planes;
154 
155 	while (entries) {
156 		num_planes = pinfo->num_planes;
157 
158 		rawfmts[i].fmt = pinfo->format;
159 		rawfmts[i].buftype = fmt->buffer_type;
160 		i++;
161 
162 		if (pinfo->num_planes > MAX_PLANES)
163 			break;
164 
165 		pinfo = (void *)pinfo + sizeof(*constr) * num_planes +
166 			2 * sizeof(u32);
167 		entries--;
168 	}
169 
170 	for_each_codec(core->caps, ARRAY_SIZE(core->caps), codecs, domain,
171 		       fill_raw_fmts, rawfmts, i);
172 }
173 
174 static void parse_codecs(struct venus_core *core, void *data)
175 {
176 	struct hfi_codec_supported *codecs = data;
177 
178 	core->dec_codecs = codecs->dec_codecs;
179 	core->enc_codecs = codecs->enc_codecs;
180 
181 	if (IS_V1(core)) {
182 		core->dec_codecs &= ~HFI_VIDEO_CODEC_HEVC;
183 		core->dec_codecs &= ~HFI_VIDEO_CODEC_SPARK;
184 		core->enc_codecs &= ~HFI_VIDEO_CODEC_HEVC;
185 	}
186 }
187 
188 static void parse_max_sessions(struct venus_core *core, const void *data)
189 {
190 	const struct hfi_max_sessions_supported *sessions = data;
191 
192 	core->max_sessions_supported = sessions->max_sessions;
193 }
194 
195 static void parse_codecs_mask(u32 *codecs, u32 *domain, void *data)
196 {
197 	struct hfi_codec_mask_supported *mask = data;
198 
199 	*codecs = mask->codecs;
200 	*domain = mask->video_domains;
201 }
202 
203 static void parser_init(struct venus_inst *inst, u32 *codecs, u32 *domain)
204 {
205 	if (!inst || !IS_V1(inst->core))
206 		return;
207 
208 	*codecs = inst->hfi_codec;
209 	*domain = inst->session_type;
210 }
211 
212 static void parser_fini(struct venus_inst *inst, u32 codecs, u32 domain)
213 {
214 	struct hfi_plat_caps *caps, *cap;
215 	unsigned int i;
216 	u32 dom;
217 
218 	if (!inst || !IS_V1(inst->core))
219 		return;
220 
221 	caps = inst->core->caps;
222 	dom = inst->session_type;
223 
224 	for (i = 0; i < MAX_CODEC_NUM; i++) {
225 		cap = &caps[i];
226 		if (cap->codec & codecs && cap->domain == dom)
227 			cap->valid = true;
228 	}
229 }
230 
231 static int hfi_platform_parser(struct venus_core *core, struct venus_inst *inst)
232 {
233 	const struct hfi_platform *plat;
234 	const struct hfi_plat_caps *caps = NULL;
235 	u32 enc_codecs, dec_codecs, count = 0;
236 	unsigned int entries;
237 
238 	if (inst)
239 		return 0;
240 
241 	plat = hfi_platform_get(core->res->hfi_version);
242 	if (!plat)
243 		return -EINVAL;
244 
245 	if (plat->codecs)
246 		plat->codecs(&enc_codecs, &dec_codecs, &count);
247 
248 	if (plat->capabilities)
249 		caps = plat->capabilities(&entries);
250 
251 	if (!caps || !entries || !count)
252 		return -EINVAL;
253 
254 	core->enc_codecs = enc_codecs;
255 	core->dec_codecs = dec_codecs;
256 	core->codecs_count = count;
257 	core->max_sessions_supported = MAX_SESSIONS;
258 	memset(core->caps, 0, sizeof(*caps) * MAX_CODEC_NUM);
259 	memcpy(core->caps, caps, sizeof(*caps) * entries);
260 
261 	return 0;
262 }
263 
264 u32 hfi_parser(struct venus_core *core, struct venus_inst *inst, void *buf,
265 	       u32 size)
266 {
267 	unsigned int words_count = size >> 2;
268 	u32 *word = buf, *data, codecs = 0, domain = 0;
269 	int ret;
270 
271 	ret = hfi_platform_parser(core, inst);
272 	if (!ret)
273 		return HFI_ERR_NONE;
274 
275 	if (size % 4)
276 		return HFI_ERR_SYS_INSUFFICIENT_RESOURCES;
277 
278 	parser_init(inst, &codecs, &domain);
279 
280 	core->codecs_count = 0;
281 	memset(core->caps, 0, sizeof(core->caps));
282 
283 	while (words_count) {
284 		data = word + 1;
285 
286 		switch (*word) {
287 		case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
288 			parse_codecs(core, data);
289 			init_codecs(core);
290 			break;
291 		case HFI_PROPERTY_PARAM_MAX_SESSIONS_SUPPORTED:
292 			parse_max_sessions(core, data);
293 			break;
294 		case HFI_PROPERTY_PARAM_CODEC_MASK_SUPPORTED:
295 			parse_codecs_mask(&codecs, &domain, data);
296 			break;
297 		case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
298 			parse_raw_formats(core, codecs, domain, data);
299 			break;
300 		case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
301 			parse_caps(core, codecs, domain, data);
302 			break;
303 		case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
304 			parse_profile_level(core, codecs, domain, data);
305 			break;
306 		case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE_SUPPORTED:
307 			parse_alloc_mode(core, codecs, domain, data);
308 			break;
309 		default:
310 			break;
311 		}
312 
313 		word++;
314 		words_count--;
315 	}
316 
317 	if (!core->max_sessions_supported)
318 		core->max_sessions_supported = MAX_SESSIONS;
319 
320 	parser_fini(inst, codecs, domain);
321 
322 	return HFI_ERR_NONE;
323 }
324