Quelle  coda.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Coda multi-standard codec IP
 *
 * Copyright (C) 2012 Vista Silicon S.L.
 *    Javier Martin, <javier.martin@vista-silicon.com>
 *    Xavier Duret
 * Copyright (C) 2012-2014 Philipp Zabel, Pengutronix
 */

#ifndef __CODA_H__
#define __CODA_H__

#include <linux/debugfs.h>
#include <linux/idr.h>
#include <linux/irqreturn.h>
#include <linux/mutex.h>
#include <linux/kfifo.h>
#include <linux/videodev2.h>
#include <linux/ratelimit.h>

#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>
#include <media/v4l2-fh.h>
#include <media/videobuf2-v4l2.h>

#include "coda_regs.h"

#define CODA_MAX_FRAMEBUFFERS 19
#define FMO_SLICE_SAVE_BUF_SIZE (32)

/*
 * This control allows applications to read the per-stream
 * (i.e. per-context) Macroblocks Error Count. This value
 * is CODA specific.
 */
#define V4L2_CID_CODA_MB_ERR_CNT (V4L2_CID_USER_CODA_BASE + 0)

enum {
 V4L2_M2M_SRC = 0,
 V4L2_M2M_DST = 1,
};

enum coda_inst_type {
 CODA_INST_ENCODER,
 CODA_INST_DECODER,
};

enum coda_product {
 CODA_DX6 = 0xf001,
 CODA_HX4 = 0xf00a,
 CODA_7541 = 0xf012,
 CODA_960 = 0xf020,
};

struct coda_video_device;

struct coda_devtype {
 char   *firmware[3];
 enum coda_product product;
 const struct coda_codec *codecs;
 unsigned int  num_codecs;
 const struct coda_video_device **vdevs;
 unsigned int  num_vdevs;
 size_t   workbuf_size;
 size_t   tempbuf_size;
 size_t   iram_size;
};

struct coda_aux_buf {
 void   *vaddr;
 dma_addr_t  paddr;
 u32   size;
 struct debugfs_blob_wrapper blob;
 struct dentry  *dentry;
};

struct coda_dev {
 struct v4l2_device v4l2_dev;
 struct video_device vfd[6];
 struct device  *dev;
 const struct coda_devtype *devtype;
 int   firmware;
 struct vdoa_data *vdoa;

 void __iomem  *regs_base;
 struct clk  *clk_per;
 struct clk  *clk_ahb;
 struct reset_control *rstc;

 struct coda_aux_buf codebuf;
 struct coda_aux_buf tempbuf;
 struct coda_aux_buf workbuf;
 struct gen_pool  *iram_pool;
 struct coda_aux_buf iram;

 struct mutex  dev_mutex;
 struct mutex  coda_mutex;
 struct workqueue_struct *workqueue;
 struct v4l2_m2m_dev *m2m_dev;
 struct ida  ida;
 struct dentry  *debugfs_root;
 struct ratelimit_state mb_err_rs;
};

struct coda_codec {
 u32 mode;
 u32 src_fourcc;
 u32 dst_fourcc;
 u32 max_w;
 u32 max_h;
};

struct coda_huff_tab;

struct coda_params {
 u8   rot_mode;
 u8   h264_intra_qp;
 u8   h264_inter_qp;
 u8   h264_min_qp;
 u8   h264_max_qp;
 u8   h264_disable_deblocking_filter_idc;
 s8   h264_slice_alpha_c0_offset_div2;
 s8   h264_slice_beta_offset_div2;
 bool   h264_constrained_intra_pred_flag;
 s8   h264_chroma_qp_index_offset;
 u8   h264_profile_idc;
 u8   h264_level_idc;
 u8   mpeg2_profile_idc;
 u8   mpeg2_level_idc;
 u8   mpeg4_intra_qp;
 u8   mpeg4_inter_qp;
 u8   gop_size;
 int   intra_refresh;
 enum v4l2_jpeg_chroma_subsampling jpeg_chroma_subsampling;
 u8   jpeg_quality;
 u8   jpeg_restart_interval;
 u8   *jpeg_qmat_tab[3];
 int   jpeg_qmat_index[3];
 int   jpeg_huff_dc_index[3];
 int   jpeg_huff_ac_index[3];
 u32   *jpeg_huff_data;
 struct coda_huff_tab *jpeg_huff_tab;
 int   codec_mode;
 int   codec_mode_aux;
 enum v4l2_mpeg_video_multi_slice_mode slice_mode;
 u32   framerate;
 u16   bitrate;
 u16   vbv_delay;
 u32   vbv_size;
 u32   slice_max_bits;
 u32   slice_max_mb;
 bool   force_ipicture;
 bool   gop_size_changed;
 bool   bitrate_changed;
 bool   framerate_changed;
 bool   h264_intra_qp_changed;
 bool   intra_refresh_changed;
 bool   slice_mode_changed;
 bool   frame_rc_enable;
 bool   mb_rc_enable;
};

struct coda_buffer_meta {
 struct list_head list;
 u32   sequence;
 struct v4l2_timecode timecode;
 u64   timestamp;
 unsigned int  start;
 unsigned int  end;
 bool   last;
};

/* Per-queue, driver-specific private data */
struct coda_q_data {
 unsigned int  width;
 unsigned int  height;
 unsigned int  bytesperline;
 unsigned int  sizeimage;
 unsigned int  fourcc;
 struct v4l2_rect rect;
};

struct coda_iram_info {
 u32  axi_sram_use;
 phys_addr_t buf_bit_use;
 phys_addr_t buf_ip_ac_dc_use;
 phys_addr_t buf_dbk_y_use;
 phys_addr_t buf_dbk_c_use;
 phys_addr_t buf_ovl_use;
 phys_addr_t buf_btp_use;
 phys_addr_t search_ram_paddr;
 int  search_ram_size;
 int  remaining;
 phys_addr_t next_paddr;
};

#define GDI_LINEAR_FRAME_MAP 0
#define GDI_TILED_FRAME_MB_RASTER_MAP 1

struct coda_ctx;

struct coda_context_ops {
 int (*queue_init)(void *priv, struct vb2_queue *src_vq,
     struct vb2_queue *dst_vq);
 int (*reqbufs)(struct coda_ctx *ctx, struct v4l2_requestbuffers *rb);
 int (*start_streaming)(struct coda_ctx *ctx);
 int (*prepare_run)(struct coda_ctx *ctx);
 void (*finish_run)(struct coda_ctx *ctx);
 void (*run_timeout)(struct coda_ctx *ctx);
 void (*seq_init_work)(struct work_struct *work);
 void (*seq_end_work)(struct work_struct *work);
 void (*release)(struct coda_ctx *ctx);
};

struct coda_internal_frame {
 struct coda_aux_buf  buf;
 struct coda_buffer_meta  meta;
 u32    type;
 u32    error;
};

struct coda_ctx {
 struct coda_dev   *dev;
 struct mutex   buffer_mutex;
 struct work_struct  pic_run_work;
 struct work_struct  seq_init_work;
 struct work_struct  seq_end_work;
 struct completion  completion;
 const struct coda_video_device *cvd;
 const struct coda_context_ops *ops;
 int    aborting;
 int    initialized;
 int    streamon_out;
 int    streamon_cap;
 u32    qsequence;
 u32    osequence;
 u32    sequence_offset;
 struct coda_q_data  q_data[2];
 enum coda_inst_type  inst_type;
 const struct coda_codec  *codec;
 enum v4l2_colorspace  colorspace;
 enum v4l2_xfer_func  xfer_func;
 enum v4l2_ycbcr_encoding ycbcr_enc;
 enum v4l2_quantization  quantization;
 struct coda_params  params;
 struct v4l2_ctrl_handler ctrls;
 struct v4l2_ctrl  *h264_profile_ctrl;
 struct v4l2_ctrl  *h264_level_ctrl;
 struct v4l2_ctrl  *mpeg2_profile_ctrl;
 struct v4l2_ctrl  *mpeg2_level_ctrl;
 struct v4l2_ctrl  *mpeg4_profile_ctrl;
 struct v4l2_ctrl  *mpeg4_level_ctrl;
 struct v4l2_ctrl  *mb_err_cnt_ctrl;
 struct v4l2_fh   fh;
 int    gopcounter;
 int    runcounter;
 int    jpeg_ecs_offset;
 char    vpu_header[3][64];
 int    vpu_header_size[3];
 struct kfifo   bitstream_fifo;
 struct mutex   bitstream_mutex;
 struct coda_aux_buf  bitstream;
 bool    hold;
 struct coda_aux_buf  parabuf;
 struct coda_aux_buf  psbuf;
 struct coda_aux_buf  slicebuf;
 struct coda_internal_frame internal_frames[CODA_MAX_FRAMEBUFFERS];
 struct list_head  buffer_meta_list;
 spinlock_t   buffer_meta_lock;
 int    num_metas;
 unsigned int   first_frame_sequence;
 struct coda_aux_buf  workbuf;
 int    num_internal_frames;
 int    idx;
 int    reg_idx;
 struct coda_iram_info  iram_info;
 int    tiled_map_type;
 u32    bit_stream_param;
 u32    frm_dis_flg;
 u32    frame_mem_ctrl;
 u32    para_change;
 int    display_idx;
 struct dentry   *debugfs_entry;
 bool    use_bit;
 bool    use_vdoa;
 struct vdoa_ctx   *vdoa;
 /*
 * wakeup mutex used to serialize encoder stop command and finish_run,
 * ensures that finish_run always either flags the last returned buffer
 * or wakes up the capture queue to signal EOS afterwards.
 */
 struct mutex   wakeup_mutex;
};

extern int coda_debug;

#define coda_dbg(level, ctx, fmt, arg...)    \
 do {        \
  if (coda_debug >= (level))    \
   v4l2_dbg((level), coda_debug, &(ctx)->dev->v4l2_dev, \
    "%u: " fmt, (ctx)->idx, ##arg);  \
 } while (0)

void coda_write(struct coda_dev *dev, u32 data, u32 reg);
unsigned int coda_read(struct coda_dev *dev, u32 reg);
void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data,
       struct vb2_v4l2_buffer *buf, unsigned int reg_y);

int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf,
         size_t size, const char *name, struct dentry *parent);
void coda_free_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf);

int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq,
       struct vb2_queue *dst_vq);
int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq,
       struct vb2_queue *dst_vq);

int coda_hw_reset(struct coda_ctx *ctx);

void coda_fill_bitstream(struct coda_ctx *ctx, struct list_head *buffer_list);

void coda_set_gdi_regs(struct coda_ctx *ctx);

static inline struct coda_q_data *get_q_data(struct coda_ctx *ctx,
          enum v4l2_buf_type type)
{
 switch (type) {
 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
  return &(ctx->q_data[V4L2_M2M_SRC]);
 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
  return &(ctx->q_data[V4L2_M2M_DST]);
 default:
  return NULL;
 }
}

const char *coda_product_name(int product);

int coda_check_firmware(struct coda_dev *dev);

static inline unsigned int coda_get_bitstream_payload(struct coda_ctx *ctx)
{
 return kfifo_len(&ctx->bitstream_fifo);
}

/*
 * The bitstream prefetcher needs to read at least 2 256 byte periods past
 * the desired bitstream position for all data to reach the decoder.
 */
static inline bool coda_bitstream_can_fetch_past(struct coda_ctx *ctx,
       unsigned int pos)
{
 return (int)(ctx->bitstream_fifo.kfifo.in - ALIGN(pos, 256)) > 512;
}

bool coda_bitstream_can_fetch_past(struct coda_ctx *ctx, unsigned int pos);
int coda_bitstream_flush(struct coda_ctx *ctx);

void coda_bit_stream_end_flag(struct coda_ctx *ctx);

void coda_m2m_buf_done(struct coda_ctx *ctx, struct vb2_v4l2_buffer *buf,
         enum vb2_buffer_state state);

int coda_h264_filler_nal(int size, char *p);
int coda_h264_padding(int size, char *p);
int coda_h264_profile(int profile_idc);
int coda_h264_level(int level_idc);
int coda_sps_parse_profile(struct coda_ctx *ctx, struct vb2_buffer *vb);
int coda_h264_sps_fixup(struct coda_ctx *ctx, int width, int height, char *buf,
   int *size, int max_size);

int coda_mpeg2_profile(int profile_idc);
int coda_mpeg2_level(int level_idc);
u32 coda_mpeg2_parse_headers(struct coda_ctx *ctx, u8 *buf, u32 size);
int coda_mpeg4_profile(int profile_idc);
int coda_mpeg4_level(int level_idc);
u32 coda_mpeg4_parse_headers(struct coda_ctx *ctx, u8 *buf, u32 size);

void coda_update_profile_level_ctrls(struct coda_ctx *ctx, u8 profile_idc,
         u8 level_idc);

static inline int coda_jpeg_scale(int src, int dst)
{
 return (dst <= src / 8) ? 3 :
        (dst <= src / 4) ? 2 :
        (dst <= src / 2) ? 1 : 0;
}

bool coda_jpeg_check_buffer(struct coda_ctx *ctx, struct vb2_buffer *vb);
int coda_jpeg_decode_header(struct coda_ctx *ctx, struct vb2_buffer *vb);
int coda_jpeg_write_tables(struct coda_ctx *ctx);
void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality);

extern const struct coda_context_ops coda_bit_encode_ops;
extern const struct coda_context_ops coda_bit_decode_ops;
extern const struct coda_context_ops coda9_jpeg_encode_ops;
extern const struct coda_context_ops coda9_jpeg_decode_ops;

irqreturn_t coda_irq_handler(int irq, void *data);
irqreturn_t coda9_jpeg_irq_handler(int irq, void *data);

#endif /* __CODA_H__ */