1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (C) STMicroelectronics SA 2015
4  * Authors: Yannick Fertre <yannick.fertre@st.com>
5  *          Hugues Fruchet <hugues.fruchet@st.com>
6  */
7 
8 #ifndef HVA_H
9 #define HVA_H
10 
11 #include <media/v4l2-ctrls.h>
12 #include <media/v4l2-device.h>
13 #include <media/videobuf2-v4l2.h>
14 #include <media/v4l2-mem2mem.h>
15 
16 #define fh_to_ctx(f)    (container_of(f, struct hva_ctx, fh))
17 
18 #define hva_to_dev(h)   (h->dev)
19 
20 #define ctx_to_dev(c)   (c->hva_dev->dev)
21 
22 #define ctx_to_hdev(c)  (c->hva_dev)
23 
24 #define HVA_NAME	"st-hva"
25 #define HVA_PREFIX	"[---:----]"
26 
27 extern const struct hva_enc nv12h264enc;
28 extern const struct hva_enc nv21h264enc;
29 
30 /**
31  * struct hva_frameinfo - information about hva frame
32  *
33  * @pixelformat:    fourcc code for uncompressed video format
34  * @width:          width of frame
35  * @height:         height of frame
36  * @aligned_width:  width of frame (with encoder alignment constraint)
37  * @aligned_height: height of frame (with encoder alignment constraint)
38  * @size:           maximum size in bytes required for data
39 */
40 struct hva_frameinfo {
41 	u32	pixelformat;
42 	u32	width;
43 	u32	height;
44 	u32	aligned_width;
45 	u32	aligned_height;
46 	u32	size;
47 };
48 
49 /**
50  * struct hva_streaminfo - information about hva stream
51  *
52  * @streamformat: fourcc code of compressed video format (H.264...)
53  * @width:        width of stream
54  * @height:       height of stream
55  * @profile:      profile string
56  * @level:        level string
57  */
58 struct hva_streaminfo {
59 	u32	streamformat;
60 	u32	width;
61 	u32	height;
62 	u8	profile[32];
63 	u8	level[32];
64 };
65 
66 /**
67  * struct hva_controls - hva controls set
68  *
69  * @time_per_frame: time per frame in seconds
70  * @bitrate_mode:   bitrate mode (constant bitrate or variable bitrate)
71  * @gop_size:       groupe of picture size
72  * @bitrate:        bitrate (in bps)
73  * @aspect:         video aspect
74  * @profile:        H.264 profile
75  * @level:          H.264 level
76  * @entropy_mode:   H.264 entropy mode (CABAC or CVLC)
77  * @cpb_size:       coded picture buffer size (in kB)
78  * @dct8x8:         transform mode 8x8 enable
79  * @qpmin:          minimum quantizer
80  * @qpmax:          maximum quantizer
81  * @vui_sar:        pixel aspect ratio enable
82  * @vui_sar_idc:    pixel aspect ratio identifier
83  * @sei_fp:         sei frame packing arrangement enable
84  * @sei_fp_type:    sei frame packing arrangement type
85  */
86 struct hva_controls {
87 	struct v4l2_fract					time_per_frame;
88 	enum v4l2_mpeg_video_bitrate_mode			bitrate_mode;
89 	u32							gop_size;
90 	u32							bitrate;
91 	enum v4l2_mpeg_video_aspect				aspect;
92 	enum v4l2_mpeg_video_h264_profile			profile;
93 	enum v4l2_mpeg_video_h264_level				level;
94 	enum v4l2_mpeg_video_h264_entropy_mode			entropy_mode;
95 	u32							cpb_size;
96 	bool							dct8x8;
97 	u32							qpmin;
98 	u32							qpmax;
99 	bool							vui_sar;
100 	enum v4l2_mpeg_video_h264_vui_sar_idc			vui_sar_idc;
101 	bool							sei_fp;
102 	enum v4l2_mpeg_video_h264_sei_fp_arrangement_type	sei_fp_type;
103 };
104 
105 /**
106  * struct hva_frame - hva frame buffer (output)
107  *
108  * @vbuf:     video buffer information for V4L2
109  * @list:     V4L2 m2m list that the frame belongs to
110  * @info:     frame information (width, height, format, alignment...)
111  * @paddr:    physical address (for hardware)
112  * @vaddr:    virtual address (kernel can read/write)
113  * @prepared: true if vaddr/paddr are resolved
114  */
115 struct hva_frame {
116 	struct vb2_v4l2_buffer	vbuf;
117 	struct list_head	list;
118 	struct hva_frameinfo	info;
119 	dma_addr_t		paddr;
120 	void			*vaddr;
121 	bool			prepared;
122 };
123 
124 /*
125  * to_hva_frame() - cast struct vb2_v4l2_buffer * to struct hva_frame *
126  */
127 #define to_hva_frame(vb) \
128 	container_of(vb, struct hva_frame, vbuf)
129 
130 /**
131  * struct hva_stream - hva stream buffer (capture)
132  *
133  * @vbuf:       video buffer information for V4L2
134  * @list:       V4L2 m2m list that the frame belongs to
135  * @paddr:      physical address (for hardware)
136  * @vaddr:      virtual address (kernel can read/write)
137  * @prepared:   true if vaddr/paddr are resolved
138  * @size:       size of the buffer in bytes
139  * @bytesused:  number of bytes occupied by data in the buffer
140  */
141 struct hva_stream {
142 	struct vb2_v4l2_buffer	vbuf;
143 	struct list_head	list;
144 	dma_addr_t		paddr;
145 	void			*vaddr;
146 	bool			prepared;
147 	unsigned int		size;
148 	unsigned int		bytesused;
149 };
150 
151 /*
152  * to_hva_stream() - cast struct vb2_v4l2_buffer * to struct hva_stream *
153  */
154 #define to_hva_stream(vb) \
155 	container_of(vb, struct hva_stream, vbuf)
156 
157 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
158 /**
159  * struct hva_ctx_dbg - instance context debug info
160  *
161  * @debugfs_entry:      debugfs entry
162  * @is_valid_period:    true if the sequence is valid for performance
163  * @begin:              start time of last HW task
164  * @total_duration:     total HW processing durations in 0.1ms
165  * @cnt_duration:       number of HW processings
166  * @min_duration:       minimum HW processing duration in 0.1ms
167  * @max_duration:       maximum HW processing duration in 0.1ms
168  * @avg_duration:       average HW processing duration in 0.1ms
169  * @max_fps:            maximum frames encoded per second (in 0.1Hz)
170  * @total_period:       total encoding periods in 0.1ms
171  * @cnt_period:         number of periods
172  * @min_period:         minimum encoding period in 0.1ms
173  * @max_period:         maximum encoding period in 0.1ms
174  * @avg_period:         average encoding period in 0.1ms
175  * @total_stream_size:  total number of encoded bytes
176  * @avg_fps:            average frames encoded per second (in 0.1Hz)
177  * @window_duration:    duration of the sampling window in 0.1ms
178  * @cnt_window:         number of samples in the window
179  * @window_stream_size: number of encoded bytes upon the sampling window
180  * @last_bitrate:       bitrate upon the last sampling window
181  * @min_bitrate:        minimum bitrate in kbps
182  * @max_bitrate:        maximum bitrate in kbps
183  * @avg_bitrate:        average bitrate in kbps
184  */
185 struct hva_ctx_dbg {
186 	struct dentry	*debugfs_entry;
187 	bool		is_valid_period;
188 	ktime_t		begin;
189 	u32		total_duration;
190 	u32		cnt_duration;
191 	u32		min_duration;
192 	u32		max_duration;
193 	u32		avg_duration;
194 	u32		max_fps;
195 	u32		total_period;
196 	u32		cnt_period;
197 	u32		min_period;
198 	u32		max_period;
199 	u32		avg_period;
200 	u32		total_stream_size;
201 	u32		avg_fps;
202 	u32		window_duration;
203 	u32		cnt_window;
204 	u32		window_stream_size;
205 	u32		last_bitrate;
206 	u32		min_bitrate;
207 	u32		max_bitrate;
208 	u32		avg_bitrate;
209 };
210 #endif
211 
212 struct hva_dev;
213 struct hva_enc;
214 
215 /**
216  * struct hva_ctx - context of hva instance
217  *
218  * @hva_dev:         the device that this instance is associated with
219  * @fh:              V4L2 file handle
220  * @ctrl_handler:    V4L2 controls handler
221  * @ctrls:           hva controls set
222  * @id:              instance identifier
223  * @aborting:        true if current job aborted
224  * @name:            instance name (debug purpose)
225  * @run_work:        encode work
226  * @lock:            mutex used to lock access of this context
227  * @flags:           validity of streaminfo and frameinfo fields
228  * @frame_num:       frame number
229  * @stream_num:      stream number
230  * @max_stream_size: maximum size in bytes required for stream data
231  * @colorspace:      colorspace identifier
232  * @xfer_func:       transfer function identifier
233  * @ycbcr_enc:       Y'CbCr encoding identifier
234  * @quantization:    quantization identifier
235  * @streaminfo:      stream properties
236  * @frameinfo:       frame properties
237  * @enc:             current encoder
238  * @priv:            private codec data for this instance, allocated
239  *                   by encoder @open time
240  * @hw_err:          true if hardware error detected
241  * @encoded_frames:  number of encoded frames
242  * @sys_errors:      number of system errors (memory, resource, pm...)
243  * @encode_errors:   number of encoding errors (hw/driver errors)
244  * @frame_errors:    number of frame errors (format, size, header...)
245  * @dbg:             context debug info
246  */
247 struct hva_ctx {
248 	struct hva_dev			*hva_dev;
249 	struct v4l2_fh			fh;
250 	struct v4l2_ctrl_handler	ctrl_handler;
251 	struct hva_controls		ctrls;
252 	u8				id;
253 	bool				aborting;
254 	char				name[100];
255 	struct work_struct		run_work;
256 	/* mutex protecting this data structure */
257 	struct mutex			lock;
258 	u32				flags;
259 	u32				frame_num;
260 	u32				stream_num;
261 	u32				max_stream_size;
262 	enum v4l2_colorspace		colorspace;
263 	enum v4l2_xfer_func		xfer_func;
264 	enum v4l2_ycbcr_encoding	ycbcr_enc;
265 	enum v4l2_quantization		quantization;
266 	struct hva_streaminfo		streaminfo;
267 	struct hva_frameinfo		frameinfo;
268 	struct hva_enc			*enc;
269 	void				*priv;
270 	bool				hw_err;
271 	u32				encoded_frames;
272 	u32				sys_errors;
273 	u32				encode_errors;
274 	u32				frame_errors;
275 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
276 	struct hva_ctx_dbg		dbg;
277 #endif
278 };
279 
280 #define HVA_FLAG_STREAMINFO	0x0001
281 #define HVA_FLAG_FRAMEINFO	0x0002
282 
283 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
284 /**
285  * struct hva_dev_dbg - device debug info
286  *
287  * @debugfs_entry: debugfs entry
288  * @last_ctx:      debug information about last running instance context
289  */
290 struct hva_dev_dbg {
291 	struct dentry	*debugfs_entry;
292 	struct hva_ctx	last_ctx;
293 };
294 #endif
295 
296 #define HVA_MAX_INSTANCES	16
297 #define HVA_MAX_ENCODERS	10
298 #define HVA_MAX_FORMATS		HVA_MAX_ENCODERS
299 
300 /**
301  * struct hva_dev - abstraction for hva entity
302  *
303  * @v4l2_dev:            V4L2 device
304  * @vdev:                video device
305  * @pdev:                platform device
306  * @dev:                 device
307  * @lock:                mutex used for critical sections & V4L2 ops
308  *                       serialization
309  * @m2m_dev:             memory-to-memory V4L2 device information
310  * @instances:           opened instances
311  * @nb_of_instances:     number of opened instances
312  * @instance_id:         rolling counter identifying an instance (debug purpose)
313  * @regs:                register io memory access
314  * @esram_addr:          esram address
315  * @esram_size:          esram size
316  * @clk:                 hva clock
317  * @irq_its:             status interruption
318  * @irq_err:             error interruption
319  * @work_queue:          work queue to handle the encode jobs
320  * @protect_mutex:       mutex used to lock access of hardware
321  * @interrupt:           completion interrupt
322  * @ip_version:          IP hardware version
323  * @encoders:            registered encoders
324  * @nb_of_encoders:      number of registered encoders
325  * @pixelformats:        supported uncompressed video formats
326  * @nb_of_pixelformats:  number of supported umcompressed video formats
327  * @streamformats:       supported compressed video formats
328  * @nb_of_streamformats: number of supported compressed video formats
329  * @sfl_reg:             status fifo level register value
330  * @sts_reg:             status register value
331  * @lmi_err_reg:         local memory interface error register value
332  * @emi_err_reg:         external memory interface error register value
333  * @hec_mif_err_reg:     HEC memory interface error register value
334  * @dbg:                 device debug info
335  */
336 struct hva_dev {
337 	struct v4l2_device	v4l2_dev;
338 	struct video_device	*vdev;
339 	struct platform_device	*pdev;
340 	struct device		*dev;
341 	/* mutex protecting vb2_queue structure */
342 	struct mutex		lock;
343 	struct v4l2_m2m_dev	*m2m_dev;
344 	struct hva_ctx		*instances[HVA_MAX_INSTANCES];
345 	unsigned int		nb_of_instances;
346 	unsigned int		instance_id;
347 	void __iomem		*regs;
348 	u32			esram_addr;
349 	u32			esram_size;
350 	struct clk		*clk;
351 	int			irq_its;
352 	int			irq_err;
353 	struct workqueue_struct *work_queue;
354 	/* mutex protecting hardware access */
355 	struct mutex		protect_mutex;
356 	struct completion	interrupt;
357 	unsigned long int	ip_version;
358 	const struct hva_enc	*encoders[HVA_MAX_ENCODERS];
359 	u32			nb_of_encoders;
360 	u32			pixelformats[HVA_MAX_FORMATS];
361 	u32			nb_of_pixelformats;
362 	u32			streamformats[HVA_MAX_FORMATS];
363 	u32			nb_of_streamformats;
364 	u32			sfl_reg;
365 	u32			sts_reg;
366 	u32			lmi_err_reg;
367 	u32			emi_err_reg;
368 	u32			hec_mif_err_reg;
369 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
370 	struct hva_dev_dbg	dbg;
371 #endif
372 };
373 
374 /**
375  * struct hva_enc - hva encoder
376  *
377  * @name:         encoder name
378  * @streamformat: fourcc code for compressed video format (H.264...)
379  * @pixelformat:  fourcc code for uncompressed video format
380  * @max_width:    maximum width of frame for this encoder
381  * @max_height:   maximum height of frame for this encoder
382  * @open:         open encoder
383  * @close:        close encoder
384  * @encode:       encode a frame (struct hva_frame) in a stream
385  *                (struct hva_stream)
386  */
387 
388 struct hva_enc {
389 	const char	*name;
390 	u32		streamformat;
391 	u32		pixelformat;
392 	u32		max_width;
393 	u32		max_height;
394 	int		(*open)(struct hva_ctx *ctx);
395 	int		(*close)(struct hva_ctx *ctx);
396 	int		(*encode)(struct hva_ctx *ctx, struct hva_frame *frame,
397 				  struct hva_stream *stream);
398 };
399 
400 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
401 void hva_debugfs_create(struct hva_dev *hva);
402 void hva_debugfs_remove(struct hva_dev *hva);
403 void hva_dbg_ctx_create(struct hva_ctx *ctx);
404 void hva_dbg_ctx_remove(struct hva_ctx *ctx);
405 void hva_dbg_perf_begin(struct hva_ctx *ctx);
406 void hva_dbg_perf_end(struct hva_ctx *ctx, struct hva_stream *stream);
407 #endif
408 
409 #endif /* HVA_H */
410