| /* SPDX-License-Identifier: GPL-2.0 */ |
| /* |
| * Copyright (C) STMicroelectronics SA 2015 |
| * Author: Hugues Fruchet <hugues.fruchet@st.com> for STMicroelectronics. |
| */ |
| |
| #ifndef DELTA_H |
| #define DELTA_H |
| |
| #include <linux/rpmsg.h> |
| #include <media/v4l2-device.h> |
| #include <media/v4l2-mem2mem.h> |
| |
| #include "delta-cfg.h" |
| |
| /* |
| * enum delta_state - state of decoding instance |
| * |
| *@DELTA_STATE_WF_FORMAT: |
| * Wait for compressed format to be set by V4L2 client in order |
| * to know what is the relevant decoder to open. |
| * |
| *@DELTA_STATE_WF_STREAMINFO: |
| * Wait for stream information to be available (bitstream |
| * header parsing is done). |
| * |
| *@DELTA_STATE_READY: |
| * Decoding instance is ready to decode compressed access unit. |
| * |
| *@DELTA_STATE_WF_EOS: |
| * Decoding instance is waiting for EOS (End Of Stream) completion. |
| * |
| *@DELTA_STATE_EOS: |
| * EOS (End Of Stream) is completed (signaled to user). Decoding instance |
| * should then be closed. |
| */ |
| enum delta_state { |
| DELTA_STATE_WF_FORMAT, |
| DELTA_STATE_WF_STREAMINFO, |
| DELTA_STATE_READY, |
| DELTA_STATE_WF_EOS, |
| DELTA_STATE_EOS |
| }; |
| |
| /* |
| * struct delta_streaminfo - information about stream to decode |
| * |
| * @flags: validity of fields (crop, pixelaspect, other) |
| * @width: width of video stream |
| * @height: height "" |
| * @streamformat: fourcc compressed format of video (MJPEG, MPEG2, ...) |
| * @dpb: number of frames needed to decode a single frame |
| * (h264 dpb, up to 16) |
| * @crop: cropping window inside decoded frame (1920x1080@0,0 |
| * inside 1920x1088 frame for ex.) |
| * @pixelaspect: pixel aspect ratio of video (4/3, 5/4) |
| * @field: interlaced or not |
| * @profile: profile string |
| * @level: level string |
| * @other: other string information from codec |
| * @colorspace: colorspace identifier |
| * @xfer_func: transfer function identifier |
| * @ycbcr_enc: Y'CbCr encoding identifier |
| * @quantization: quantization identifier |
| */ |
| struct delta_streaminfo { |
| u32 flags; |
| u32 streamformat; |
| u32 width; |
| u32 height; |
| u32 dpb; |
| struct v4l2_rect crop; |
| struct v4l2_fract pixelaspect; |
| enum v4l2_field field; |
| u8 profile[32]; |
| u8 level[32]; |
| u8 other[32]; |
| enum v4l2_colorspace colorspace; |
| enum v4l2_xfer_func xfer_func; |
| enum v4l2_ycbcr_encoding ycbcr_enc; |
| enum v4l2_quantization quantization; |
| }; |
| |
| #define DELTA_STREAMINFO_FLAG_CROP 0x0001 |
| #define DELTA_STREAMINFO_FLAG_PIXELASPECT 0x0002 |
| #define DELTA_STREAMINFO_FLAG_OTHER 0x0004 |
| |
| /* |
| * struct delta_au - access unit structure. |
| * |
| * @vbuf: video buffer information for V4L2 |
| * @list: V4L2 m2m list that the frame belongs to |
| * @prepared: if set vaddr/paddr are resolved |
| * @vaddr: virtual address (kernel can read/write) |
| * @paddr: physical address (for hardware) |
| * @flags: access unit type (V4L2_BUF_FLAG_KEYFRAME/PFRAME/BFRAME) |
| * @dts: decoding timestamp of this access unit |
| */ |
| struct delta_au { |
| struct vb2_v4l2_buffer vbuf; /* keep first */ |
| struct list_head list; /* keep second */ |
| |
| bool prepared; |
| u32 size; |
| void *vaddr; |
| dma_addr_t paddr; |
| u32 flags; |
| u64 dts; |
| }; |
| |
| /* |
| * struct delta_frameinfo - information about decoded frame |
| * |
| * @flags: validity of fields (crop, pixelaspect) |
| * @pixelformat: fourcc code for uncompressed video format |
| * @width: width of frame |
| * @height: height of frame |
| * @aligned_width: width of frame (with encoder or decoder alignment |
| * constraint) |
| * @aligned_height: height of frame (with encoder or decoder alignment |
| * constraint) |
| * @size: maximum size in bytes required for data |
| * @crop: cropping window inside frame (1920x1080@0,0 |
| * inside 1920x1088 frame for ex.) |
| * @pixelaspect: pixel aspect ratio of video (4/3, 5/4) |
| * @field: interlaced mode |
| * @colorspace: colorspace identifier |
| * @xfer_func: transfer function identifier |
| * @ycbcr_enc: Y'CbCr encoding identifier |
| * @quantization: quantization identifier |
| */ |
| struct delta_frameinfo { |
| u32 flags; |
| u32 pixelformat; |
| u32 width; |
| u32 height; |
| u32 aligned_width; |
| u32 aligned_height; |
| u32 size; |
| struct v4l2_rect crop; |
| struct v4l2_fract pixelaspect; |
| enum v4l2_field field; |
| enum v4l2_colorspace colorspace; |
| enum v4l2_xfer_func xfer_func; |
| enum v4l2_ycbcr_encoding ycbcr_enc; |
| enum v4l2_quantization quantization; |
| }; |
| |
| #define DELTA_FRAMEINFO_FLAG_CROP 0x0001 |
| #define DELTA_FRAMEINFO_FLAG_PIXELASPECT 0x0002 |
| |
| /* |
| * struct delta_frame - frame structure. |
| * |
| * @vbuf: video buffer information for V4L2 |
| * @list: V4L2 m2m list that the frame belongs to |
| * @info: frame information (width, height, format, alignment...) |
| * @prepared: if set pix/vaddr/paddr are resolved |
| * @index: frame index, aligned on V4L2 wow |
| * @vaddr: virtual address (kernel can read/write) |
| * @paddr: physical address (for hardware) |
| * @state: frame state for frame lifecycle tracking |
| * (DELTA_FRAME_FREE/DEC/OUT/REC/...) |
| * @flags: frame type (V4L2_BUF_FLAG_KEYFRAME/PFRAME/BFRAME) |
| * @dts: decoding timestamp of this frame |
| * @field: field order for interlaced frame |
| */ |
| struct delta_frame { |
| struct vb2_v4l2_buffer vbuf; /* keep first */ |
| struct list_head list; /* keep second */ |
| |
| struct delta_frameinfo info; |
| bool prepared; |
| u32 index; |
| void *vaddr; |
| dma_addr_t paddr; |
| u32 state; |
| u32 flags; |
| u64 dts; |
| enum v4l2_field field; |
| }; |
| |
| /* frame state for frame lifecycle tracking */ |
| #define DELTA_FRAME_FREE 0x00 /* is free and can be used for decoding */ |
| #define DELTA_FRAME_REF 0x01 /* is a reference frame */ |
| #define DELTA_FRAME_BSY 0x02 /* is owned by decoder and busy */ |
| #define DELTA_FRAME_DEC 0x04 /* contains decoded content */ |
| #define DELTA_FRAME_OUT 0x08 /* has been given to user */ |
| #define DELTA_FRAME_RDY 0x10 /* is ready but still held by decoder */ |
| #define DELTA_FRAME_M2M 0x20 /* is owned by mem2mem framework */ |
| |
| /* |
| * struct delta_dts - decoding timestamp. |
| * |
| * @list: list to chain timestamps |
| * @val: timestamp in microseconds |
| */ |
| struct delta_dts { |
| struct list_head list; |
| u64 val; |
| }; |
| |
| struct delta_buf { |
| u32 size; |
| void *vaddr; |
| dma_addr_t paddr; |
| const char *name; |
| unsigned long attrs; |
| }; |
| |
| struct delta_ipc_ctx { |
| int cb_err; |
| u32 copro_hdl; |
| struct completion done; |
| struct delta_buf ipc_buf_struct; |
| struct delta_buf *ipc_buf; |
| }; |
| |
| struct delta_ipc_param { |
| u32 size; |
| void *data; |
| }; |
| |
| struct delta_ctx; |
| |
| /* |
| * struct delta_dec - decoder structure. |
| * |
| * @name: name of this decoder |
| * @streamformat: input stream format that this decoder support |
| * @pixelformat: pixel format of decoded frame that this decoder support |
| * @max_width: (optional) maximum width that can decode this decoder |
| * if not set, maximum width is DELTA_MAX_WIDTH |
| * @max_height: (optional) maximum height that can decode this decoder |
| * if not set, maximum height is DELTA_MAX_HEIGHT |
| * @pm: (optional) if set, decoder will manage power on its own |
| * @open: open this decoder |
| * @close: close this decoder |
| * @setup_frame: setup frame to be used by decoder, see below |
| * @get_streaminfo: get stream related infos, see below |
| * @get_frameinfo: get decoded frame related infos, see below |
| * @set_frameinfo: (optional) set decoded frame related infos, see below |
| * @setup_frame: setup frame to be used by decoder, see below |
| * @decode: decode a single access unit, see below |
| * @get_frame: get the next decoded frame available, see below |
| * @recycle: recycle the given frame, see below |
| * @flush: (optional) flush decoder, see below |
| * @drain: (optional) drain decoder, see below |
| */ |
| struct delta_dec { |
| const char *name; |
| u32 streamformat; |
| u32 pixelformat; |
| u32 max_width; |
| u32 max_height; |
| bool pm; |
| |
| /* |
| * decoder ops |
| */ |
| int (*open)(struct delta_ctx *ctx); |
| int (*close)(struct delta_ctx *ctx); |
| |
| /* |
| * setup_frame() - setup frame to be used by decoder |
| * @ctx: (in) instance |
| * @frame: (in) frame to use |
| * @frame.index (in) identifier of frame |
| * @frame.vaddr (in) virtual address (kernel can read/write) |
| * @frame.paddr (in) physical address (for hardware) |
| * |
| * Frame is to be allocated by caller, then given |
| * to decoder through this call. |
| * Several frames must be given to decoder (dpb), |
| * each frame is identified using its index. |
| */ |
| int (*setup_frame)(struct delta_ctx *ctx, struct delta_frame *frame); |
| |
| /* |
| * get_streaminfo() - get stream related infos |
| * @ctx: (in) instance |
| * @streaminfo: (out) width, height, dpb,... |
| * |
| * Precondition: stream header must have been successfully |
| * parsed to have this call successful & @streaminfo valid. |
| * Header parsing must be done using decode(), giving |
| * explicitly header access unit or first access unit of bitstream. |
| * If no valid header is found, get_streaminfo will return -ENODATA, |
| * in this case the next bitstream access unit must be decoded till |
| * get_streaminfo becomes successful. |
| */ |
| int (*get_streaminfo)(struct delta_ctx *ctx, |
| struct delta_streaminfo *streaminfo); |
| |
| /* |
| * get_frameinfo() - get decoded frame related infos |
| * @ctx: (in) instance |
| * @frameinfo: (out) width, height, alignment, crop, ... |
| * |
| * Precondition: get_streaminfo() must be successful |
| */ |
| int (*get_frameinfo)(struct delta_ctx *ctx, |
| struct delta_frameinfo *frameinfo); |
| |
| /* |
| * set_frameinfo() - set decoded frame related infos |
| * @ctx: (in) instance |
| * @frameinfo: (out) width, height, alignment, crop, ... |
| * |
| * Optional. |
| * Typically used to negotiate with decoder the output |
| * frame if decoder can do post-processing. |
| */ |
| int (*set_frameinfo)(struct delta_ctx *ctx, |
| struct delta_frameinfo *frameinfo); |
| |
| /* |
| * decode() - decode a single access unit |
| * @ctx: (in) instance |
| * @au: (in/out) access unit |
| * @au.size (in) size of au to decode |
| * @au.vaddr (in) virtual address (kernel can read/write) |
| * @au.paddr (in) physical address (for hardware) |
| * @au.flags (out) au type (V4L2_BUF_FLAG_KEYFRAME/ |
| * PFRAME/BFRAME) |
| * |
| * Decode the access unit given. Decode is synchronous; |
| * access unit memory is no more needed after this call. |
| * After this call, none, one or several frames could |
| * have been decoded, which can be retrieved using |
| * get_frame(). |
| */ |
| int (*decode)(struct delta_ctx *ctx, struct delta_au *au); |
| |
| /* |
| * get_frame() - get the next decoded frame available |
| * @ctx: (in) instance |
| * @frame: (out) frame with decoded data: |
| * @frame.index (out) identifier of frame |
| * @frame.field (out) field order for interlaced frame |
| * @frame.state (out) frame state for frame lifecycle tracking |
| * @frame.flags (out) frame type (V4L2_BUF_FLAG_KEYFRAME/ |
| * PFRAME/BFRAME) |
| * |
| * Get the next available decoded frame. |
| * If no frame is available, -ENODATA is returned. |
| * If a frame is available, frame structure is filled with |
| * relevant data, frame.index identifying this exact frame. |
| * When this frame is no more needed by upper layers, |
| * recycle() must be called giving this frame identifier. |
| */ |
| int (*get_frame)(struct delta_ctx *ctx, struct delta_frame **frame); |
| |
| /* |
| * recycle() - recycle the given frame |
| * @ctx: (in) instance |
| * @frame: (in) frame to recycle: |
| * @frame.index (in) identifier of frame |
| * |
| * recycle() is to be called by user when the decoded frame |
| * is no more needed (composition/display done). |
| * This frame will then be reused by decoder to proceed |
| * with next frame decoding. |
| * If not enough frames have been provided through setup_frame(), |
| * or recycle() is not called fast enough, the decoder can run out |
| * of available frames to proceed with decoding (starvation). |
| * This case is guarded by wq_recycle wait queue which ensures that |
| * decoder is called only if at least one frame is available. |
| */ |
| int (*recycle)(struct delta_ctx *ctx, struct delta_frame *frame); |
| |
| /* |
| * flush() - flush decoder |
| * @ctx: (in) instance |
| * |
| * Optional. |
| * Reset decoder context and discard all internal buffers. |
| * This allows implementation of seek, which leads to discontinuity |
| * of input bitstream that decoder must know to restart its internal |
| * decoding logic. |
| */ |
| int (*flush)(struct delta_ctx *ctx); |
| |
| /* |
| * drain() - drain decoder |
| * @ctx: (in) instance |
| * |
| * Optional. |
| * Mark decoder pending frames (decoded but not yet output) as ready |
| * so that they can be output to client at EOS (End Of Stream). |
| * get_frame() is to be called in a loop right after drain() to |
| * get all those pending frames. |
| */ |
| int (*drain)(struct delta_ctx *ctx); |
| }; |
| |
| struct delta_dev; |
| |
| /* |
| * struct delta_ctx - instance structure. |
| * |
| * @flags: validity of fields (streaminfo) |
| * @fh: V4L2 file handle |
| * @dev: device context |
| * @dec: selected decoder context for this instance |
| * @ipc_ctx: context of IPC communication with firmware |
| * @state: instance state |
| * @frame_num: frame number |
| * @au_num: access unit number |
| * @max_au_size: max size of an access unit |
| * @streaminfo: stream information (width, height, dpb, interlacing...) |
| * @frameinfo: frame information (width, height, format, alignment...) |
| * @nb_of_frames: number of frames available for decoding |
| * @frames: array of decoding frames to keep track of frame |
| * state and manage frame recycling |
| * @decoded_frames: nb of decoded frames from opening |
| * @output_frames: nb of output frames from opening |
| * @dropped_frames: nb of frames dropped (ie access unit not parsed |
| * or frame decoded but not output) |
| * @stream_errors: nb of stream errors (corrupted, not supported, ...) |
| * @decode_errors: nb of decode errors (firmware error) |
| * @sys_errors: nb of system errors (memory, ipc, ...) |
| * @dts: FIFO of decoding timestamp. |
| * output frames are timestamped with incoming access |
| * unit timestamps using this fifo. |
| * @name: string naming this instance (debug purpose) |
| * @run_work: decoding work |
| * @lock: lock for decoding work serialization |
| * @aborting: true if current job aborted |
| * @priv: private decoder context for this instance, allocated |
| * by decoder @open time. |
| */ |
| struct delta_ctx { |
| u32 flags; |
| struct v4l2_fh fh; |
| struct delta_dev *dev; |
| const struct delta_dec *dec; |
| struct delta_ipc_ctx ipc_ctx; |
| |
| enum delta_state state; |
| u32 frame_num; |
| u32 au_num; |
| size_t max_au_size; |
| struct delta_streaminfo streaminfo; |
| struct delta_frameinfo frameinfo; |
| u32 nb_of_frames; |
| struct delta_frame *frames[DELTA_MAX_FRAMES]; |
| u32 decoded_frames; |
| u32 output_frames; |
| u32 dropped_frames; |
| u32 stream_errors; |
| u32 decode_errors; |
| u32 sys_errors; |
| struct list_head dts; |
| char name[100]; |
| struct work_struct run_work; |
| struct mutex lock; |
| bool aborting; |
| void *priv; |
| }; |
| |
| #define DELTA_FLAG_STREAMINFO 0x0001 |
| #define DELTA_FLAG_FRAMEINFO 0x0002 |
| |
| #define DELTA_MAX_FORMATS DELTA_MAX_DECODERS |
| |
| /* |
| * struct delta_dev - device struct, 1 per probe (so single one for |
| * all platform life) |
| * |
| * @v4l2_dev: v4l2 device |
| * @vdev: v4l2 video device |
| * @pdev: platform device |
| * @dev: device |
| * @m2m_dev: memory-to-memory V4L2 device |
| * @lock: device lock, for crit section & V4L2 ops serialization. |
| * @clk_delta: delta main clock |
| * @clk_st231: st231 coprocessor main clock |
| * @clk_flash_promip: flash promip clock |
| * @decoders: list of registered decoders |
| * @nb_of_decoders: nb of registered decoders |
| * @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 |
| * @instance_id: rolling counter identifying an instance (debug purpose) |
| * @work_queue: decoding job work queue |
| * @rpmsg_driver: rpmsg IPC driver |
| * @rpmsg_device: rpmsg IPC device |
| */ |
| struct delta_dev { |
| struct v4l2_device v4l2_dev; |
| struct video_device *vdev; |
| struct platform_device *pdev; |
| struct device *dev; |
| struct v4l2_m2m_dev *m2m_dev; |
| struct mutex lock; |
| struct clk *clk_delta; |
| struct clk *clk_st231; |
| struct clk *clk_flash_promip; |
| const struct delta_dec *decoders[DELTA_MAX_DECODERS]; |
| u32 nb_of_decoders; |
| u32 pixelformats[DELTA_MAX_FORMATS]; |
| u32 nb_of_pixelformats; |
| u32 streamformats[DELTA_MAX_FORMATS]; |
| u32 nb_of_streamformats; |
| u8 instance_id; |
| struct workqueue_struct *work_queue; |
| struct rpmsg_driver rpmsg_driver; |
| struct rpmsg_device *rpmsg_device; |
| }; |
| |
| static inline char *frame_type_str(u32 flags) |
| { |
| if (flags & V4L2_BUF_FLAG_KEYFRAME) |
| return "I"; |
| if (flags & V4L2_BUF_FLAG_PFRAME) |
| return "P"; |
| if (flags & V4L2_BUF_FLAG_BFRAME) |
| return "B"; |
| if (flags & V4L2_BUF_FLAG_LAST) |
| return "EOS"; |
| return "?"; |
| } |
| |
| static inline char *frame_field_str(enum v4l2_field field) |
| { |
| if (field == V4L2_FIELD_NONE) |
| return "-"; |
| if (field == V4L2_FIELD_TOP) |
| return "T"; |
| if (field == V4L2_FIELD_BOTTOM) |
| return "B"; |
| if (field == V4L2_FIELD_INTERLACED) |
| return "I"; |
| if (field == V4L2_FIELD_INTERLACED_TB) |
| return "TB"; |
| if (field == V4L2_FIELD_INTERLACED_BT) |
| return "BT"; |
| return "?"; |
| } |
| |
| static inline char *frame_state_str(u32 state, char *str, unsigned int len) |
| { |
| snprintf(str, len, "%s %s %s %s %s %s", |
| (state & DELTA_FRAME_REF) ? "ref" : " ", |
| (state & DELTA_FRAME_BSY) ? "bsy" : " ", |
| (state & DELTA_FRAME_DEC) ? "dec" : " ", |
| (state & DELTA_FRAME_OUT) ? "out" : " ", |
| (state & DELTA_FRAME_M2M) ? "m2m" : " ", |
| (state & DELTA_FRAME_RDY) ? "rdy" : " "); |
| return str; |
| } |
| |
| int delta_get_frameinfo_default(struct delta_ctx *ctx, |
| struct delta_frameinfo *frameinfo); |
| int delta_recycle_default(struct delta_ctx *pctx, |
| struct delta_frame *frame); |
| |
| int delta_get_free_frame(struct delta_ctx *ctx, |
| struct delta_frame **pframe); |
| |
| int delta_get_sync(struct delta_ctx *ctx); |
| void delta_put_autosuspend(struct delta_ctx *ctx); |
| |
| #endif /* DELTA_H */ |
