linux/drivers/media/platform/coda/coda.h
<<
>>
Prefs
   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/*
   3 * Coda multi-standard codec IP
   4 *
   5 * Copyright (C) 2012 Vista Silicon S.L.
   6 *    Javier Martin, <javier.martin@vista-silicon.com>
   7 *    Xavier Duret
   8 * Copyright (C) 2012-2014 Philipp Zabel, Pengutronix
   9 */
  10
  11#ifndef __CODA_H__
  12#define __CODA_H__
  13
  14#include <linux/debugfs.h>
  15#include <linux/idr.h>
  16#include <linux/irqreturn.h>
  17#include <linux/mutex.h>
  18#include <linux/kfifo.h>
  19#include <linux/videodev2.h>
  20#include <linux/ratelimit.h>
  21
  22#include <media/v4l2-ctrls.h>
  23#include <media/v4l2-device.h>
  24#include <media/v4l2-fh.h>
  25#include <media/videobuf2-v4l2.h>
  26
  27#include "coda_regs.h"
  28
  29#define CODA_MAX_FRAMEBUFFERS   19
  30#define FMO_SLICE_SAVE_BUF_SIZE (32)
  31
  32/*
  33 * This control allows applications to read the per-stream
  34 * (i.e. per-context) Macroblocks Error Count. This value
  35 * is CODA specific.
  36 */
  37#define V4L2_CID_CODA_MB_ERR_CNT (V4L2_CID_USER_CODA_BASE + 0)
  38
  39enum {
  40        V4L2_M2M_SRC = 0,
  41        V4L2_M2M_DST = 1,
  42};
  43
  44enum coda_inst_type {
  45        CODA_INST_ENCODER,
  46        CODA_INST_DECODER,
  47};
  48
  49enum coda_product {
  50        CODA_DX6 = 0xf001,
  51        CODA_HX4 = 0xf00a,
  52        CODA_7541 = 0xf012,
  53        CODA_960 = 0xf020,
  54};
  55
  56struct coda_video_device;
  57
  58struct coda_devtype {
  59        char                    *firmware[3];
  60        enum coda_product       product;
  61        const struct coda_codec *codecs;
  62        unsigned int            num_codecs;
  63        const struct coda_video_device **vdevs;
  64        unsigned int            num_vdevs;
  65        size_t                  workbuf_size;
  66        size_t                  tempbuf_size;
  67        size_t                  iram_size;
  68};
  69
  70struct coda_aux_buf {
  71        void                    *vaddr;
  72        dma_addr_t              paddr;
  73        u32                     size;
  74        struct debugfs_blob_wrapper blob;
  75        struct dentry           *dentry;
  76};
  77
  78struct coda_dev {
  79        struct v4l2_device      v4l2_dev;
  80        struct video_device     vfd[6];
  81        struct device           *dev;
  82        const struct coda_devtype *devtype;
  83        int                     firmware;
  84        struct vdoa_data        *vdoa;
  85
  86        void __iomem            *regs_base;
  87        struct clk              *clk_per;
  88        struct clk              *clk_ahb;
  89        struct reset_control    *rstc;
  90
  91        struct coda_aux_buf     codebuf;
  92        struct coda_aux_buf     tempbuf;
  93        struct coda_aux_buf     workbuf;
  94        struct gen_pool         *iram_pool;
  95        struct coda_aux_buf     iram;
  96
  97        struct mutex            dev_mutex;
  98        struct mutex            coda_mutex;
  99        struct workqueue_struct *workqueue;
 100        struct v4l2_m2m_dev     *m2m_dev;
 101        struct ida              ida;
 102        struct dentry           *debugfs_root;
 103        struct ratelimit_state  mb_err_rs;
 104};
 105
 106struct coda_codec {
 107        u32 mode;
 108        u32 src_fourcc;
 109        u32 dst_fourcc;
 110        u32 max_w;
 111        u32 max_h;
 112};
 113
 114struct coda_huff_tab;
 115
 116struct coda_params {
 117        u8                      rot_mode;
 118        u8                      h264_intra_qp;
 119        u8                      h264_inter_qp;
 120        u8                      h264_min_qp;
 121        u8                      h264_max_qp;
 122        u8                      h264_disable_deblocking_filter_idc;
 123        s8                      h264_slice_alpha_c0_offset_div2;
 124        s8                      h264_slice_beta_offset_div2;
 125        bool                    h264_constrained_intra_pred_flag;
 126        s8                      h264_chroma_qp_index_offset;
 127        u8                      h264_profile_idc;
 128        u8                      h264_level_idc;
 129        u8                      mpeg2_profile_idc;
 130        u8                      mpeg2_level_idc;
 131        u8                      mpeg4_intra_qp;
 132        u8                      mpeg4_inter_qp;
 133        u8                      gop_size;
 134        int                     intra_refresh;
 135        enum v4l2_jpeg_chroma_subsampling jpeg_chroma_subsampling;
 136        u8                      jpeg_quality;
 137        u8                      jpeg_restart_interval;
 138        u8                      *jpeg_qmat_tab[3];
 139        int                     jpeg_qmat_index[3];
 140        int                     jpeg_huff_dc_index[3];
 141        int                     jpeg_huff_ac_index[3];
 142        u32                     *jpeg_huff_data;
 143        struct coda_huff_tab    *jpeg_huff_tab;
 144        int                     codec_mode;
 145        int                     codec_mode_aux;
 146        enum v4l2_mpeg_video_multi_slice_mode slice_mode;
 147        u32                     framerate;
 148        u16                     bitrate;
 149        u16                     vbv_delay;
 150        u32                     vbv_size;
 151        u32                     slice_max_bits;
 152        u32                     slice_max_mb;
 153        bool                    force_ipicture;
 154        bool                    gop_size_changed;
 155        bool                    bitrate_changed;
 156        bool                    framerate_changed;
 157        bool                    h264_intra_qp_changed;
 158        bool                    intra_refresh_changed;
 159        bool                    slice_mode_changed;
 160        bool                    frame_rc_enable;
 161        bool                    mb_rc_enable;
 162};
 163
 164struct coda_buffer_meta {
 165        struct list_head        list;
 166        u32                     sequence;
 167        struct v4l2_timecode    timecode;
 168        u64                     timestamp;
 169        unsigned int            start;
 170        unsigned int            end;
 171        bool                    last;
 172};
 173
 174/* Per-queue, driver-specific private data */
 175struct coda_q_data {
 176        unsigned int            width;
 177        unsigned int            height;
 178        unsigned int            bytesperline;
 179        unsigned int            sizeimage;
 180        unsigned int            fourcc;
 181        struct v4l2_rect        rect;
 182};
 183
 184struct coda_iram_info {
 185        u32             axi_sram_use;
 186        phys_addr_t     buf_bit_use;
 187        phys_addr_t     buf_ip_ac_dc_use;
 188        phys_addr_t     buf_dbk_y_use;
 189        phys_addr_t     buf_dbk_c_use;
 190        phys_addr_t     buf_ovl_use;
 191        phys_addr_t     buf_btp_use;
 192        phys_addr_t     search_ram_paddr;
 193        int             search_ram_size;
 194        int             remaining;
 195        phys_addr_t     next_paddr;
 196};
 197
 198#define GDI_LINEAR_FRAME_MAP 0
 199#define GDI_TILED_FRAME_MB_RASTER_MAP 1
 200
 201struct coda_ctx;
 202
 203struct coda_context_ops {
 204        int (*queue_init)(void *priv, struct vb2_queue *src_vq,
 205                          struct vb2_queue *dst_vq);
 206        int (*reqbufs)(struct coda_ctx *ctx, struct v4l2_requestbuffers *rb);
 207        int (*start_streaming)(struct coda_ctx *ctx);
 208        int (*prepare_run)(struct coda_ctx *ctx);
 209        void (*finish_run)(struct coda_ctx *ctx);
 210        void (*run_timeout)(struct coda_ctx *ctx);
 211        void (*seq_init_work)(struct work_struct *work);
 212        void (*seq_end_work)(struct work_struct *work);
 213        void (*release)(struct coda_ctx *ctx);
 214};
 215
 216struct coda_internal_frame {
 217        struct coda_aux_buf             buf;
 218        struct coda_buffer_meta         meta;
 219        u32                             type;
 220        u32                             error;
 221};
 222
 223struct coda_ctx {
 224        struct coda_dev                 *dev;
 225        struct mutex                    buffer_mutex;
 226        struct work_struct              pic_run_work;
 227        struct work_struct              seq_init_work;
 228        struct work_struct              seq_end_work;
 229        struct completion               completion;
 230        const struct coda_video_device  *cvd;
 231        const struct coda_context_ops   *ops;
 232        int                             aborting;
 233        int                             initialized;
 234        int                             streamon_out;
 235        int                             streamon_cap;
 236        u32                             qsequence;
 237        u32                             osequence;
 238        u32                             sequence_offset;
 239        struct coda_q_data              q_data[2];
 240        enum coda_inst_type             inst_type;
 241        const struct coda_codec         *codec;
 242        enum v4l2_colorspace            colorspace;
 243        enum v4l2_xfer_func             xfer_func;
 244        enum v4l2_ycbcr_encoding        ycbcr_enc;
 245        enum v4l2_quantization          quantization;
 246        struct coda_params              params;
 247        struct v4l2_ctrl_handler        ctrls;
 248        struct v4l2_ctrl                *h264_profile_ctrl;
 249        struct v4l2_ctrl                *h264_level_ctrl;
 250        struct v4l2_ctrl                *mpeg2_profile_ctrl;
 251        struct v4l2_ctrl                *mpeg2_level_ctrl;
 252        struct v4l2_ctrl                *mpeg4_profile_ctrl;
 253        struct v4l2_ctrl                *mpeg4_level_ctrl;
 254        struct v4l2_ctrl                *mb_err_cnt_ctrl;
 255        struct v4l2_fh                  fh;
 256        int                             gopcounter;
 257        int                             runcounter;
 258        int                             jpeg_ecs_offset;
 259        char                            vpu_header[3][64];
 260        int                             vpu_header_size[3];
 261        struct kfifo                    bitstream_fifo;
 262        struct mutex                    bitstream_mutex;
 263        struct coda_aux_buf             bitstream;
 264        bool                            hold;
 265        struct coda_aux_buf             parabuf;
 266        struct coda_aux_buf             psbuf;
 267        struct coda_aux_buf             slicebuf;
 268        struct coda_internal_frame      internal_frames[CODA_MAX_FRAMEBUFFERS];
 269        struct list_head                buffer_meta_list;
 270        spinlock_t                      buffer_meta_lock;
 271        int                             num_metas;
 272        unsigned int                    first_frame_sequence;
 273        struct coda_aux_buf             workbuf;
 274        int                             num_internal_frames;
 275        int                             idx;
 276        int                             reg_idx;
 277        struct coda_iram_info           iram_info;
 278        int                             tiled_map_type;
 279        u32                             bit_stream_param;
 280        u32                             frm_dis_flg;
 281        u32                             frame_mem_ctrl;
 282        u32                             para_change;
 283        int                             display_idx;
 284        struct dentry                   *debugfs_entry;
 285        bool                            use_bit;
 286        bool                            use_vdoa;
 287        struct vdoa_ctx                 *vdoa;
 288        /*
 289         * wakeup mutex used to serialize encoder stop command and finish_run,
 290         * ensures that finish_run always either flags the last returned buffer
 291         * or wakes up the capture queue to signal EOS afterwards.
 292         */
 293        struct mutex                    wakeup_mutex;
 294};
 295
 296extern int coda_debug;
 297
 298#define coda_dbg(level, ctx, fmt, arg...)                               \
 299        do {                                                            \
 300                if (coda_debug >= (level))                              \
 301                        v4l2_dbg((level), coda_debug, &(ctx)->dev->v4l2_dev, \
 302                         "%u: " fmt, (ctx)->idx, ##arg);                \
 303        } while (0)
 304
 305void coda_write(struct coda_dev *dev, u32 data, u32 reg);
 306unsigned int coda_read(struct coda_dev *dev, u32 reg);
 307void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data,
 308                     struct vb2_v4l2_buffer *buf, unsigned int reg_y);
 309
 310int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf,
 311                       size_t size, const char *name, struct dentry *parent);
 312void coda_free_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf);
 313
 314int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq,
 315                            struct vb2_queue *dst_vq);
 316int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq,
 317                            struct vb2_queue *dst_vq);
 318
 319int coda_hw_reset(struct coda_ctx *ctx);
 320
 321void coda_fill_bitstream(struct coda_ctx *ctx, struct list_head *buffer_list);
 322
 323void coda_set_gdi_regs(struct coda_ctx *ctx);
 324
 325static inline struct coda_q_data *get_q_data(struct coda_ctx *ctx,
 326                                             enum v4l2_buf_type type)
 327{
 328        switch (type) {
 329        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 330                return &(ctx->q_data[V4L2_M2M_SRC]);
 331        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 332                return &(ctx->q_data[V4L2_M2M_DST]);
 333        default:
 334                return NULL;
 335        }
 336}
 337
 338const char *coda_product_name(int product);
 339
 340int coda_check_firmware(struct coda_dev *dev);
 341
 342static inline unsigned int coda_get_bitstream_payload(struct coda_ctx *ctx)
 343{
 344        return kfifo_len(&ctx->bitstream_fifo);
 345}
 346
 347/*
 348 * The bitstream prefetcher needs to read at least 2 256 byte periods past
 349 * the desired bitstream position for all data to reach the decoder.
 350 */
 351static inline bool coda_bitstream_can_fetch_past(struct coda_ctx *ctx,
 352                                                 unsigned int pos)
 353{
 354        return (int)(ctx->bitstream_fifo.kfifo.in - ALIGN(pos, 256)) > 512;
 355}
 356
 357bool coda_bitstream_can_fetch_past(struct coda_ctx *ctx, unsigned int pos);
 358int coda_bitstream_flush(struct coda_ctx *ctx);
 359
 360void coda_bit_stream_end_flag(struct coda_ctx *ctx);
 361
 362void coda_m2m_buf_done(struct coda_ctx *ctx, struct vb2_v4l2_buffer *buf,
 363                       enum vb2_buffer_state state);
 364
 365int coda_h264_filler_nal(int size, char *p);
 366int coda_h264_padding(int size, char *p);
 367int coda_h264_profile(int profile_idc);
 368int coda_h264_level(int level_idc);
 369int coda_sps_parse_profile(struct coda_ctx *ctx, struct vb2_buffer *vb);
 370int coda_h264_sps_fixup(struct coda_ctx *ctx, int width, int height, char *buf,
 371                        int *size, int max_size);
 372
 373int coda_mpeg2_profile(int profile_idc);
 374int coda_mpeg2_level(int level_idc);
 375u32 coda_mpeg2_parse_headers(struct coda_ctx *ctx, u8 *buf, u32 size);
 376int coda_mpeg4_profile(int profile_idc);
 377int coda_mpeg4_level(int level_idc);
 378u32 coda_mpeg4_parse_headers(struct coda_ctx *ctx, u8 *buf, u32 size);
 379
 380void coda_update_profile_level_ctrls(struct coda_ctx *ctx, u8 profile_idc,
 381                                     u8 level_idc);
 382
 383bool coda_jpeg_check_buffer(struct coda_ctx *ctx, struct vb2_buffer *vb);
 384int coda_jpeg_decode_header(struct coda_ctx *ctx, struct vb2_buffer *vb);
 385int coda_jpeg_write_tables(struct coda_ctx *ctx);
 386void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality);
 387
 388extern const struct coda_context_ops coda_bit_encode_ops;
 389extern const struct coda_context_ops coda_bit_decode_ops;
 390extern const struct coda_context_ops coda9_jpeg_encode_ops;
 391extern const struct coda_context_ops coda9_jpeg_decode_ops;
 392
 393irqreturn_t coda_irq_handler(int irq, void *data);
 394irqreturn_t coda9_jpeg_irq_handler(int irq, void *data);
 395
 396#endif /* __CODA_H__ */
 397