SSL delta.h   Interaktion und
PortierbarkeitC

/* 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 */