| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Jean-Christophe Trotin | 779 | 99.62% | 4 | 66.67% |
| Benjamin Gaignard | 2 | 0.26% | 1 | 16.67% |
| Hans Verkuil | 1 | 0.13% | 1 | 16.67% |
| Total | 782 | 6 |
/* SPDX-License-Identifier: GPL-2.0 */ /* * Copyright (C) STMicroelectronics SA 2015 * Authors: Yannick Fertre <yannick.fertre@st.com> * Hugues Fruchet <hugues.fruchet@st.com> */ #ifndef HVA_H #define HVA_H #include <media/v4l2-ctrls.h> #include <media/v4l2-device.h> #include <media/videobuf2-v4l2.h> #include <media/v4l2-mem2mem.h> #define fh_to_ctx(f) (container_of(f, struct hva_ctx, fh)) #define hva_to_dev(h) (h->dev) #define ctx_to_dev(c) (c->hva_dev->dev) #define ctx_to_hdev(c) (c->hva_dev) #define HVA_NAME "st-hva" #define HVA_PREFIX "[---:----]" extern const struct hva_enc nv12h264enc; extern const struct hva_enc nv21h264enc; /** * struct hva_frameinfo - information about hva frame * * @pixelformat: fourcc code for uncompressed video format * @width: width of frame * @height: height of frame * @aligned_width: width of frame (with encoder alignment constraint) * @aligned_height: height of frame (with encoder alignment constraint) * @size: maximum size in bytes required for data */ struct hva_frameinfo { u32 pixelformat; u32 width; u32 height; u32 aligned_width; u32 aligned_height; u32 size; }; /** * struct hva_streaminfo - information about hva stream * * @streamformat: fourcc code of compressed video format (H.264...) * @width: width of stream * @height: height of stream * @profile: profile string * @level: level string */ struct hva_streaminfo { u32 streamformat; u32 width; u32 height; u8 profile[32]; u8 level[32]; }; /** * struct hva_controls - hva controls set * * @time_per_frame: time per frame in seconds * @bitrate_mode: bitrate mode (constant bitrate or variable bitrate) * @gop_size: groupe of picture size * @bitrate: bitrate (in bps) * @aspect: video aspect * @profile: H.264 profile * @level: H.264 level * @entropy_mode: H.264 entropy mode (CABAC or CVLC) * @cpb_size: coded picture buffer size (in kB) * @dct8x8: transform mode 8x8 enable * @qpmin: minimum quantizer * @qpmax: maximum quantizer * @vui_sar: pixel aspect ratio enable * @vui_sar_idc: pixel aspect ratio identifier * @sei_fp: sei frame packing arrangement enable * @sei_fp_type: sei frame packing arrangement type */ struct hva_controls { struct v4l2_fract time_per_frame; enum v4l2_mpeg_video_bitrate_mode bitrate_mode; u32 gop_size; u32 bitrate; enum v4l2_mpeg_video_aspect aspect; enum v4l2_mpeg_video_h264_profile profile; enum v4l2_mpeg_video_h264_level level; enum v4l2_mpeg_video_h264_entropy_mode entropy_mode; u32 cpb_size; bool dct8x8; u32 qpmin; u32 qpmax; bool vui_sar; enum v4l2_mpeg_video_h264_vui_sar_idc vui_sar_idc; bool sei_fp; enum v4l2_mpeg_video_h264_sei_fp_arrangement_type sei_fp_type; }; /** * struct hva_frame - hva frame buffer (output) * * @vbuf: video buffer information for V4L2 * @list: V4L2 m2m list that the frame belongs to * @info: frame information (width, height, format, alignment...) * @paddr: physical address (for hardware) * @vaddr: virtual address (kernel can read/write) * @prepared: true if vaddr/paddr are resolved */ struct hva_frame { struct vb2_v4l2_buffer vbuf; struct list_head list; struct hva_frameinfo info; dma_addr_t paddr; void *vaddr; bool prepared; }; /* * to_hva_frame() - cast struct vb2_v4l2_buffer * to struct hva_frame * */ #define to_hva_frame(vb) \ container_of(vb, struct hva_frame, vbuf) /** * struct hva_stream - hva stream buffer (capture) * * @vbuf: video buffer information for V4L2 * @list: V4L2 m2m list that the frame belongs to * @paddr: physical address (for hardware) * @vaddr: virtual address (kernel can read/write) * @prepared: true if vaddr/paddr are resolved * @size: size of the buffer in bytes * @bytesused: number of bytes occupied by data in the buffer */ struct hva_stream { struct vb2_v4l2_buffer vbuf; struct list_head list; dma_addr_t paddr; void *vaddr; bool prepared; unsigned int size; unsigned int bytesused; }; /* * to_hva_stream() - cast struct vb2_v4l2_buffer * to struct hva_stream * */ #define to_hva_stream(vb) \ container_of(vb, struct hva_stream, vbuf) #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS /** * struct hva_ctx_dbg - instance context debug info * * @debugfs_entry: debugfs entry * @is_valid_period: true if the sequence is valid for performance * @begin: start time of last HW task * @total_duration: total HW processing durations in 0.1ms * @cnt_duration: number of HW processings * @min_duration: minimum HW processing duration in 0.1ms * @max_duration: maximum HW processing duration in 0.1ms * @avg_duration: average HW processing duration in 0.1ms * @max_fps: maximum frames encoded per second (in 0.1Hz) * @total_period: total encoding periods in 0.1ms * @cnt_period: number of periods * @min_period: minimum encoding period in 0.1ms * @max_period: maximum encoding period in 0.1ms * @avg_period: average encoding period in 0.1ms * @total_stream_size: total number of encoded bytes * @avg_fps: average frames encoded per second (in 0.1Hz) * @window_duration: duration of the sampling window in 0.1ms * @cnt_window: number of samples in the window * @window_stream_size: number of encoded bytes upon the sampling window * @last_bitrate: bitrate upon the last sampling window * @min_bitrate: minimum bitrate in kbps * @max_bitrate: maximum bitrate in kbps * @avg_bitrate: average bitrate in kbps */ struct hva_ctx_dbg { struct dentry *debugfs_entry; bool is_valid_period; ktime_t begin; u32 total_duration; u32 cnt_duration; u32 min_duration; u32 max_duration; u32 avg_duration; u32 max_fps; u32 total_period; u32 cnt_period; u32 min_period; u32 max_period; u32 avg_period; u32 total_stream_size; u32 avg_fps; u32 window_duration; u32 cnt_window; u32 window_stream_size; u32 last_bitrate; u32 min_bitrate; u32 max_bitrate; u32 avg_bitrate; }; #endif struct hva_dev; struct hva_enc; /** * struct hva_ctx - context of hva instance * * @hva_dev: the device that this instance is associated with * @fh: V4L2 file handle * @ctrl_handler: V4L2 controls handler * @ctrls: hva controls set * @id: instance identifier * @aborting: true if current job aborted * @name: instance name (debug purpose) * @run_work: encode work * @lock: mutex used to lock access of this context * @flags: validity of streaminfo and frameinfo fields * @frame_num: frame number * @stream_num: stream number * @max_stream_size: maximum size in bytes required for stream data * @colorspace: colorspace identifier * @xfer_func: transfer function identifier * @ycbcr_enc: Y'CbCr encoding identifier * @quantization: quantization identifier * @streaminfo: stream properties * @frameinfo: frame properties * @enc: current encoder * @priv: private codec data for this instance, allocated * by encoder @open time * @hw_err: true if hardware error detected * @encoded_frames: number of encoded frames * @sys_errors: number of system errors (memory, resource, pm...) * @encode_errors: number of encoding errors (hw/driver errors) * @frame_errors: number of frame errors (format, size, header...) * @dbg: context debug info */ struct hva_ctx { struct hva_dev *hva_dev; struct v4l2_fh fh; struct v4l2_ctrl_handler ctrl_handler; struct hva_controls ctrls; u8 id; bool aborting; char name[100]; struct work_struct run_work; /* mutex protecting this data structure */ struct mutex lock; u32 flags; u32 frame_num; u32 stream_num; u32 max_stream_size; enum v4l2_colorspace colorspace; enum v4l2_xfer_func xfer_func; enum v4l2_ycbcr_encoding ycbcr_enc; enum v4l2_quantization quantization; struct hva_streaminfo streaminfo; struct hva_frameinfo frameinfo; struct hva_enc *enc; void *priv; bool hw_err; u32 encoded_frames; u32 sys_errors; u32 encode_errors; u32 frame_errors; #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS struct hva_ctx_dbg dbg; #endif }; #define HVA_FLAG_STREAMINFO 0x0001 #define HVA_FLAG_FRAMEINFO 0x0002 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS /** * struct hva_dev_dbg - device debug info * * @debugfs_entry: debugfs entry * @last_ctx: debug information about last running instance context */ struct hva_dev_dbg { struct dentry *debugfs_entry; struct hva_ctx last_ctx; }; #endif #define HVA_MAX_INSTANCES 16 #define HVA_MAX_ENCODERS 10 #define HVA_MAX_FORMATS HVA_MAX_ENCODERS /** * struct hva_dev - abstraction for hva entity * * @v4l2_dev: V4L2 device * @vdev: video device * @pdev: platform device * @dev: device * @lock: mutex used for critical sections & V4L2 ops * serialization * @m2m_dev: memory-to-memory V4L2 device information * @instances: opened instances * @nb_of_instances: number of opened instances * @instance_id: rolling counter identifying an instance (debug purpose) * @regs: register io memory access * @esram_addr: esram address * @esram_size: esram size * @clk: hva clock * @irq_its: status interruption * @irq_err: error interruption * @work_queue: work queue to handle the encode jobs * @protect_mutex: mutex used to lock access of hardware * @interrupt: completion interrupt * @ip_version: IP hardware version * @encoders: registered encoders * @nb_of_encoders: number of registered encoders * @pixelformats: supported uncompressed video formats * @nb_of_pixelformats: number of supported umcompressed video formats * @streamformats: supported compressed video formats * @nb_of_streamformats: number of supported compressed video formats * @sfl_reg: status fifo level register value * @sts_reg: status register value * @lmi_err_reg: local memory interface error register value * @emi_err_reg: external memory interface error register value * @hec_mif_err_reg: HEC memory interface error register value * @dbg: device debug info */ struct hva_dev { struct v4l2_device v4l2_dev; struct video_device *vdev; struct platform_device *pdev; struct device *dev; /* mutex protecting vb2_queue structure */ struct mutex lock; struct v4l2_m2m_dev *m2m_dev; struct hva_ctx *instances[HVA_MAX_INSTANCES]; unsigned int nb_of_instances; unsigned int instance_id; void __iomem *regs; u32 esram_addr; u32 esram_size; struct clk *clk; int irq_its; int irq_err; struct workqueue_struct *work_queue; /* mutex protecting hardware access */ struct mutex protect_mutex; struct completion interrupt; unsigned long int ip_version; const struct hva_enc *encoders[HVA_MAX_ENCODERS]; u32 nb_of_encoders; u32 pixelformats[HVA_MAX_FORMATS]; u32 nb_of_pixelformats; u32 streamformats[HVA_MAX_FORMATS]; u32 nb_of_streamformats; u32 sfl_reg; u32 sts_reg; u32 lmi_err_reg; u32 emi_err_reg; u32 hec_mif_err_reg; #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS struct hva_dev_dbg dbg; #endif }; /** * struct hva_enc - hva encoder * * @name: encoder name * @streamformat: fourcc code for compressed video format (H.264...) * @pixelformat: fourcc code for uncompressed video format * @max_width: maximum width of frame for this encoder * @max_height: maximum height of frame for this encoder * @open: open encoder * @close: close encoder * @encode: encode a frame (struct hva_frame) in a stream * (struct hva_stream) */ struct hva_enc { const char *name; u32 streamformat; u32 pixelformat; u32 max_width; u32 max_height; int (*open)(struct hva_ctx *ctx); int (*close)(struct hva_ctx *ctx); int (*encode)(struct hva_ctx *ctx, struct hva_frame *frame, struct hva_stream *stream); }; #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS void hva_debugfs_create(struct hva_dev *hva); void hva_debugfs_remove(struct hva_dev *hva); void hva_dbg_ctx_create(struct hva_ctx *ctx); void hva_dbg_ctx_remove(struct hva_ctx *ctx); void hva_dbg_perf_begin(struct hva_ctx *ctx); void hva_dbg_perf_end(struct hva_ctx *ctx, struct hva_stream *stream); #endif #endif /* HVA_H */
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1