1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (C) STMicroelectronics SA 2015
4  * Author: Hugues Fruchet <hugues.fruchet@st.com> for STMicroelectronics.
5  */
6 
7 #ifndef DELTA_H
8 #define DELTA_H
9 
10 #include <linux/rpmsg.h>
11 #include <media/v4l2-device.h>
12 #include <media/v4l2-mem2mem.h>
13 
14 #include "delta-cfg.h"
15 
16 /*
17  * enum delta_state - state of decoding instance
18  *
19  *@DELTA_STATE_WF_FORMAT:
20  *	Wait for compressed format to be set by V4L2 client in order
21  *	to know what is the relevant decoder to open.
22  *
23  *@DELTA_STATE_WF_STREAMINFO:
24  *	Wait for stream information to be available (bitstream
25  *	header parsing is done).
26  *
27  *@DELTA_STATE_READY:
28  *	Decoding instance is ready to decode compressed access unit.
29  *
30  *@DELTA_STATE_WF_EOS:
31  *	Decoding instance is waiting for EOS (End Of Stream) completion.
32  *
33  *@DELTA_STATE_EOS:
34  *	EOS (End Of Stream) is completed (signaled to user). Decoding instance
35  *	should then be closed.
36  */
37 enum delta_state {
38 	DELTA_STATE_WF_FORMAT,
39 	DELTA_STATE_WF_STREAMINFO,
40 	DELTA_STATE_READY,
41 	DELTA_STATE_WF_EOS,
42 	DELTA_STATE_EOS
43 };
44 
45 /*
46  * struct delta_streaminfo - information about stream to decode
47  *
48  * @flags:		validity of fields (crop, pixelaspect, other)
49  * @width:		width of video stream
50  * @height:		height ""
51  * @streamformat:	fourcc compressed format of video (MJPEG, MPEG2, ...)
52  * @dpb:		number of frames needed to decode a single frame
53  *			(h264 dpb, up to 16)
54  * @crop:		cropping window inside decoded frame (1920x1080@0,0
55  *			inside 1920x1088 frame for ex.)
56  * @pixelaspect:	pixel aspect ratio of video (4/3, 5/4)
57  * @field:		interlaced or not
58  * @profile:		profile string
59  * @level:		level string
60  * @other:		other string information from codec
61  * @colorspace:		colorspace identifier
62  * @xfer_func:		transfer function identifier
63  * @ycbcr_enc:		Y'CbCr encoding identifier
64  * @quantization:	quantization identifier
65  */
66 struct delta_streaminfo {
67 	u32 flags;
68 	u32 streamformat;
69 	u32 width;
70 	u32 height;
71 	u32 dpb;
72 	struct v4l2_rect crop;
73 	struct v4l2_fract pixelaspect;
74 	enum v4l2_field field;
75 	u8 profile[32];
76 	u8 level[32];
77 	u8 other[32];
78 	enum v4l2_colorspace colorspace;
79 	enum v4l2_xfer_func xfer_func;
80 	enum v4l2_ycbcr_encoding ycbcr_enc;
81 	enum v4l2_quantization quantization;
82 };
83 
84 #define DELTA_STREAMINFO_FLAG_CROP		0x0001
85 #define DELTA_STREAMINFO_FLAG_PIXELASPECT	0x0002
86 #define DELTA_STREAMINFO_FLAG_OTHER		0x0004
87 
88 /*
89  * struct delta_au - access unit structure.
90  *
91  * @vbuf:	video buffer information for V4L2
92  * @list:	V4L2 m2m list that the frame belongs to
93  * @prepared:	if set vaddr/paddr are resolved
94  * @vaddr:	virtual address (kernel can read/write)
95  * @paddr:	physical address (for hardware)
96  * @flags:	access unit type (V4L2_BUF_FLAG_KEYFRAME/PFRAME/BFRAME)
97  * @dts:	decoding timestamp of this access unit
98  */
99 struct delta_au {
100 	struct vb2_v4l2_buffer vbuf;	/* keep first */
101 	struct list_head list;	/* keep second */
102 
103 	bool prepared;
104 	u32 size;
105 	void *vaddr;
106 	dma_addr_t paddr;
107 	u32 flags;
108 	u64 dts;
109 };
110 
111 /*
112  * struct delta_frameinfo - information about decoded frame
113  *
114  * @flags:		validity of fields (crop, pixelaspect)
115  * @pixelformat:	fourcc code for uncompressed video format
116  * @width:		width of frame
117  * @height:		height of frame
118  * @aligned_width:	width of frame (with encoder or decoder alignment
119  *			constraint)
120  * @aligned_height:	height of frame (with encoder or decoder alignment
121  *			constraint)
122  * @size:		maximum size in bytes required for data
123  * @crop:		cropping window inside frame (1920x1080@0,0
124  *			inside 1920x1088 frame for ex.)
125  * @pixelaspect:	pixel aspect ratio of video (4/3, 5/4)
126  * @field:		interlaced mode
127  * @colorspace:		colorspace identifier
128  * @xfer_func:		transfer function identifier
129  * @ycbcr_enc:		Y'CbCr encoding identifier
130  * @quantization:	quantization identifier
131  */
132 struct delta_frameinfo {
133 	u32 flags;
134 	u32 pixelformat;
135 	u32 width;
136 	u32 height;
137 	u32 aligned_width;
138 	u32 aligned_height;
139 	u32 size;
140 	struct v4l2_rect crop;
141 	struct v4l2_fract pixelaspect;
142 	enum v4l2_field field;
143 	enum v4l2_colorspace colorspace;
144 	enum v4l2_xfer_func xfer_func;
145 	enum v4l2_ycbcr_encoding ycbcr_enc;
146 	enum v4l2_quantization quantization;
147 };
148 
149 #define DELTA_FRAMEINFO_FLAG_CROP		0x0001
150 #define DELTA_FRAMEINFO_FLAG_PIXELASPECT	0x0002
151 
152 /*
153  * struct delta_frame - frame structure.
154  *
155  * @vbuf:	video buffer information for V4L2
156  * @list:	V4L2 m2m list that the frame belongs to
157  * @info:	frame information (width, height, format, alignment...)
158  * @prepared:	if set pix/vaddr/paddr are resolved
159  * @index:	frame index, aligned on V4L2 wow
160  * @vaddr:	virtual address (kernel can read/write)
161  * @paddr:	physical address (for hardware)
162  * @state:	frame state for frame lifecycle tracking
163  *		(DELTA_FRAME_FREE/DEC/OUT/REC/...)
164  * @flags:	frame type (V4L2_BUF_FLAG_KEYFRAME/PFRAME/BFRAME)
165  * @dts:	decoding timestamp of this frame
166  * @field:	field order for interlaced frame
167  */
168 struct delta_frame {
169 	struct vb2_v4l2_buffer vbuf;	/* keep first */
170 	struct list_head list;	/* keep second */
171 
172 	struct delta_frameinfo info;
173 	bool prepared;
174 	u32 index;
175 	void *vaddr;
176 	dma_addr_t paddr;
177 	u32 state;
178 	u32 flags;
179 	u64 dts;
180 	enum v4l2_field field;
181 };
182 
183 /* frame state for frame lifecycle tracking */
184 #define DELTA_FRAME_FREE	0x00 /* is free and can be used for decoding */
185 #define DELTA_FRAME_REF		0x01 /* is a reference frame */
186 #define DELTA_FRAME_BSY		0x02 /* is owned by decoder and busy */
187 #define DELTA_FRAME_DEC		0x04 /* contains decoded content */
188 #define DELTA_FRAME_OUT		0x08 /* has been given to user */
189 #define DELTA_FRAME_RDY		0x10 /* is ready but still held by decoder */
190 #define DELTA_FRAME_M2M		0x20 /* is owned by mem2mem framework */
191 
192 /*
193  * struct delta_dts - decoding timestamp.
194  *
195  * @list:	list to chain timestamps
196  * @val:	timestamp in microseconds
197  */
198 struct delta_dts {
199 	struct list_head list;
200 	u64 val;
201 };
202 
203 struct delta_buf {
204 	u32 size;
205 	void *vaddr;
206 	dma_addr_t paddr;
207 	const char *name;
208 	unsigned long attrs;
209 };
210 
211 struct delta_ipc_ctx {
212 	int cb_err;
213 	u32 copro_hdl;
214 	struct completion done;
215 	struct delta_buf ipc_buf_struct;
216 	struct delta_buf *ipc_buf;
217 };
218 
219 struct delta_ipc_param {
220 	u32 size;
221 	void *data;
222 };
223 
224 struct delta_ctx;
225 
226 /*
227  * struct delta_dec - decoder structure.
228  *
229  * @name:		name of this decoder
230  * @streamformat:	input stream format that this decoder support
231  * @pixelformat:	pixel format of decoded frame that this decoder support
232  * @max_width:		(optional) maximum width that can decode this decoder
233  *			if not set, maximum width is DELTA_MAX_WIDTH
234  * @max_height:		(optional) maximum height that can decode this decoder
235  *			if not set, maximum height is DELTA_MAX_HEIGHT
236  * @pm:			(optional) if set, decoder will manage power on its own
237  * @open:		open this decoder
238  * @close:		close this decoder
239  * @setup_frame:	setup frame to be used by decoder, see below
240  * @get_streaminfo:	get stream related infos, see below
241  * @get_frameinfo:	get decoded frame related infos, see below
242  * @set_frameinfo:	(optional) set decoded frame related infos, see below
243  * @setup_frame:	setup frame to be used by decoder, see below
244  * @decode:		decode a single access unit, see below
245  * @get_frame:		get the next decoded frame available, see below
246  * @recycle:		recycle the given frame, see below
247  * @flush:		(optional) flush decoder, see below
248  * @drain:		(optional) drain decoder, see below
249  */
250 struct delta_dec {
251 	const char *name;
252 	u32 streamformat;
253 	u32 pixelformat;
254 	u32 max_width;
255 	u32 max_height;
256 	bool pm;
257 
258 	/*
259 	 * decoder ops
260 	 */
261 	int (*open)(struct delta_ctx *ctx);
262 	int (*close)(struct delta_ctx *ctx);
263 
264 	/*
265 	 * setup_frame() - setup frame to be used by decoder
266 	 * @ctx:	(in) instance
267 	 * @frame:	(in) frame to use
268 	 *  @frame.index	(in) identifier of frame
269 	 *  @frame.vaddr	(in) virtual address (kernel can read/write)
270 	 *  @frame.paddr	(in) physical address (for hardware)
271 	 *
272 	 * Frame is to be allocated by caller, then given
273 	 * to decoder through this call.
274 	 * Several frames must be given to decoder (dpb),
275 	 * each frame is identified using its index.
276 	 */
277 	int (*setup_frame)(struct delta_ctx *ctx, struct delta_frame *frame);
278 
279 	/*
280 	 * get_streaminfo() - get stream related infos
281 	 * @ctx:	(in) instance
282 	 * @streaminfo:	(out) width, height, dpb,...
283 	 *
284 	 * Precondition: stream header must have been successfully
285 	 * parsed to have this call successful & @streaminfo valid.
286 	 * Header parsing must be done using decode(), giving
287 	 * explicitly header access unit or first access unit of bitstream.
288 	 * If no valid header is found, get_streaminfo will return -ENODATA,
289 	 * in this case the next bitstream access unit must be decoded till
290 	 * get_streaminfo becomes successful.
291 	 */
292 	int (*get_streaminfo)(struct delta_ctx *ctx,
293 			      struct delta_streaminfo *streaminfo);
294 
295 	/*
296 	 * get_frameinfo() - get decoded frame related infos
297 	 * @ctx:	(in) instance
298 	 * @frameinfo:	(out) width, height, alignment, crop, ...
299 	 *
300 	 * Precondition: get_streaminfo() must be successful
301 	 */
302 	int (*get_frameinfo)(struct delta_ctx *ctx,
303 			     struct delta_frameinfo *frameinfo);
304 
305 	/*
306 	 * set_frameinfo() - set decoded frame related infos
307 	 * @ctx:	(in) instance
308 	 * @frameinfo:	(out) width, height, alignment, crop, ...
309 	 *
310 	 * Optional.
311 	 * Typically used to negotiate with decoder the output
312 	 * frame if decoder can do post-processing.
313 	 */
314 	int (*set_frameinfo)(struct delta_ctx *ctx,
315 			     struct delta_frameinfo *frameinfo);
316 
317 	/*
318 	 * decode() - decode a single access unit
319 	 * @ctx:	(in) instance
320 	 * @au:		(in/out) access unit
321 	 *  @au.size	(in) size of au to decode
322 	 *  @au.vaddr	(in) virtual address (kernel can read/write)
323 	 *  @au.paddr	(in) physical address (for hardware)
324 	 *  @au.flags	(out) au type (V4L2_BUF_FLAG_KEYFRAME/
325 	 *			PFRAME/BFRAME)
326 	 *
327 	 * Decode the access unit given. Decode is synchronous;
328 	 * access unit memory is no more needed after this call.
329 	 * After this call, none, one or several frames could
330 	 * have been decoded, which can be retrieved using
331 	 * get_frame().
332 	 */
333 	int (*decode)(struct delta_ctx *ctx, struct delta_au *au);
334 
335 	/*
336 	 * get_frame() - get the next decoded frame available
337 	 * @ctx:	(in) instance
338 	 * @frame:	(out) frame with decoded data:
339 	 *  @frame.index	(out) identifier of frame
340 	 *  @frame.field	(out) field order for interlaced frame
341 	 *  @frame.state	(out) frame state for frame lifecycle tracking
342 	 *  @frame.flags	(out) frame type (V4L2_BUF_FLAG_KEYFRAME/
343 	 *			PFRAME/BFRAME)
344 	 *
345 	 * Get the next available decoded frame.
346 	 * If no frame is available, -ENODATA is returned.
347 	 * If a frame is available, frame structure is filled with
348 	 * relevant data, frame.index identifying this exact frame.
349 	 * When this frame is no more needed by upper layers,
350 	 * recycle() must be called giving this frame identifier.
351 	 */
352 	int (*get_frame)(struct delta_ctx *ctx, struct delta_frame **frame);
353 
354 	/*
355 	 * recycle() - recycle the given frame
356 	 * @ctx:	(in) instance
357 	 * @frame:	(in) frame to recycle:
358 	 *  @frame.index	(in) identifier of frame
359 	 *
360 	 * recycle() is to be called by user when the decoded frame
361 	 * is no more needed (composition/display done).
362 	 * This frame will then be reused by decoder to proceed
363 	 * with next frame decoding.
364 	 * If not enough frames have been provided through setup_frame(),
365 	 * or recycle() is not called fast enough, the decoder can run out
366 	 * of available frames to proceed with decoding (starvation).
367 	 * This case is guarded by wq_recycle wait queue which ensures that
368 	 * decoder is called only if at least one frame is available.
369 	 */
370 	int (*recycle)(struct delta_ctx *ctx, struct delta_frame *frame);
371 
372 	/*
373 	 * flush() - flush decoder
374 	 * @ctx:	(in) instance
375 	 *
376 	 * Optional.
377 	 * Reset decoder context and discard all internal buffers.
378 	 * This allows implementation of seek, which leads to discontinuity
379 	 * of input bitstream that decoder must know to restart its internal
380 	 * decoding logic.
381 	 */
382 	int (*flush)(struct delta_ctx *ctx);
383 
384 	/*
385 	 * drain() - drain decoder
386 	 * @ctx:	(in) instance
387 	 *
388 	 * Optional.
389 	 * Mark decoder pending frames (decoded but not yet output) as ready
390 	 * so that they can be output to client at EOS (End Of Stream).
391 	 * get_frame() is to be called in a loop right after drain() to
392 	 * get all those pending frames.
393 	 */
394 	int (*drain)(struct delta_ctx *ctx);
395 };
396 
397 struct delta_dev;
398 
399 /*
400  * struct delta_ctx - instance structure.
401  *
402  * @flags:		validity of fields (streaminfo)
403  * @fh:			V4L2 file handle
404  * @dev:		device context
405  * @dec:		selected decoder context for this instance
406  * @ipc_ctx:		context of IPC communication with firmware
407  * @state:		instance state
408  * @frame_num:		frame number
409  * @au_num:		access unit number
410  * @max_au_size:	max size of an access unit
411  * @streaminfo:		stream information (width, height, dpb, interlacing...)
412  * @frameinfo:		frame information (width, height, format, alignment...)
413  * @nb_of_frames:	number of frames available for decoding
414  * @frames:		array of decoding frames to keep track of frame
415  *			state and manage frame recycling
416  * @decoded_frames:	nb of decoded frames from opening
417  * @output_frames:	nb of output frames from opening
418  * @dropped_frames:	nb of frames dropped (ie access unit not parsed
419  *			or frame decoded but not output)
420  * @stream_errors:	nb of stream errors (corrupted, not supported, ...)
421  * @decode_errors:	nb of decode errors (firmware error)
422  * @sys_errors:		nb of system errors (memory, ipc, ...)
423  * @dts:		FIFO of decoding timestamp.
424  *			output frames are timestamped with incoming access
425  *			unit timestamps using this fifo.
426  * @name:		string naming this instance (debug purpose)
427  * @run_work:		decoding work
428  * @lock:		lock for decoding work serialization
429  * @aborting:		true if current job aborted
430  * @priv:		private decoder context for this instance, allocated
431  *			by decoder @open time.
432  */
433 struct delta_ctx {
434 	u32 flags;
435 	struct v4l2_fh fh;
436 	struct delta_dev *dev;
437 	const struct delta_dec *dec;
438 	struct delta_ipc_ctx ipc_ctx;
439 
440 	enum delta_state state;
441 	u32 frame_num;
442 	u32 au_num;
443 	size_t max_au_size;
444 	struct delta_streaminfo streaminfo;
445 	struct delta_frameinfo frameinfo;
446 	u32 nb_of_frames;
447 	struct delta_frame *frames[DELTA_MAX_FRAMES];
448 	u32 decoded_frames;
449 	u32 output_frames;
450 	u32 dropped_frames;
451 	u32 stream_errors;
452 	u32 decode_errors;
453 	u32 sys_errors;
454 	struct list_head dts;
455 	char name[100];
456 	struct work_struct run_work;
457 	struct mutex lock;
458 	bool aborting;
459 	void *priv;
460 };
461 
462 #define DELTA_FLAG_STREAMINFO 0x0001
463 #define DELTA_FLAG_FRAMEINFO 0x0002
464 
465 #define DELTA_MAX_FORMATS  DELTA_MAX_DECODERS
466 
467 /*
468  * struct delta_dev - device struct, 1 per probe (so single one for
469  * all platform life)
470  *
471  * @v4l2_dev:		v4l2 device
472  * @vdev:		v4l2 video device
473  * @pdev:		platform device
474  * @dev:		device
475  * @m2m_dev:		memory-to-memory V4L2 device
476  * @lock:		device lock, for crit section & V4L2 ops serialization.
477  * @clk_delta:		delta main clock
478  * @clk_st231:		st231 coprocessor main clock
479  * @clk_flash_promip:	flash promip clock
480  * @decoders:		list of registered decoders
481  * @nb_of_decoders:	nb of registered decoders
482  * @pixelformats:	supported uncompressed video formats
483  * @nb_of_pixelformats:	number of supported umcompressed video formats
484  * @streamformats:	supported compressed video formats
485  * @nb_of_streamformats:number of supported compressed video formats
486  * @instance_id:	rolling counter identifying an instance (debug purpose)
487  * @work_queue:		decoding job work queue
488  * @rpmsg_driver:	rpmsg IPC driver
489  * @rpmsg_device:	rpmsg IPC device
490  */
491 struct delta_dev {
492 	struct v4l2_device v4l2_dev;
493 	struct video_device *vdev;
494 	struct platform_device *pdev;
495 	struct device *dev;
496 	struct v4l2_m2m_dev *m2m_dev;
497 	struct mutex lock;
498 	struct clk *clk_delta;
499 	struct clk *clk_st231;
500 	struct clk *clk_flash_promip;
501 	const struct delta_dec *decoders[DELTA_MAX_DECODERS];
502 	u32 nb_of_decoders;
503 	u32 pixelformats[DELTA_MAX_FORMATS];
504 	u32 nb_of_pixelformats;
505 	u32 streamformats[DELTA_MAX_FORMATS];
506 	u32 nb_of_streamformats;
507 	u8 instance_id;
508 	struct workqueue_struct *work_queue;
509 	struct rpmsg_driver rpmsg_driver;
510 	struct rpmsg_device *rpmsg_device;
511 };
512 
513 static inline char *frame_type_str(u32 flags)
514 {
515 	if (flags & V4L2_BUF_FLAG_KEYFRAME)
516 		return "I";
517 	if (flags & V4L2_BUF_FLAG_PFRAME)
518 		return "P";
519 	if (flags & V4L2_BUF_FLAG_BFRAME)
520 		return "B";
521 	if (flags & V4L2_BUF_FLAG_LAST)
522 		return "EOS";
523 	return "?";
524 }
525 
526 static inline char *frame_field_str(enum v4l2_field field)
527 {
528 	if (field == V4L2_FIELD_NONE)
529 		return "-";
530 	if (field == V4L2_FIELD_TOP)
531 		return "T";
532 	if (field == V4L2_FIELD_BOTTOM)
533 		return "B";
534 	if (field == V4L2_FIELD_INTERLACED)
535 		return "I";
536 	if (field == V4L2_FIELD_INTERLACED_TB)
537 		return "TB";
538 	if (field == V4L2_FIELD_INTERLACED_BT)
539 		return "BT";
540 	return "?";
541 }
542 
543 static inline char *frame_state_str(u32 state, char *str, unsigned int len)
544 {
545 	snprintf(str, len, "%s %s %s %s %s %s",
546 		 (state & DELTA_FRAME_REF)  ? "ref" : "   ",
547 		 (state & DELTA_FRAME_BSY)  ? "bsy" : "   ",
548 		 (state & DELTA_FRAME_DEC)  ? "dec" : "   ",
549 		 (state & DELTA_FRAME_OUT)  ? "out" : "   ",
550 		 (state & DELTA_FRAME_M2M)  ? "m2m" : "   ",
551 		 (state & DELTA_FRAME_RDY)  ? "rdy" : "   ");
552 	return str;
553 }
554 
555 int delta_get_frameinfo_default(struct delta_ctx *ctx,
556 				struct delta_frameinfo *frameinfo);
557 int delta_recycle_default(struct delta_ctx *pctx,
558 			  struct delta_frame *frame);
559 
560 int delta_get_free_frame(struct delta_ctx *ctx,
561 			 struct delta_frame **pframe);
562 
563 int delta_get_sync(struct delta_ctx *ctx);
564 void delta_put_autosuspend(struct delta_ctx *ctx);
565 
566 #endif /* DELTA_H */
567