LXR linux/drivers/staging/media/hantro/hantro

   1/* SPDX-License-Identifier: GPL-2.0 */
   2/*
   3 * Hantro VPU codec driver
   4 *
   5 * Copyright 2018 Google LLC.
   6 *      Tomasz Figa <tfiga@chromium.org>
   7 */
   8
   9#ifndef HANTRO_HW_H_
  10#define HANTRO_HW_H_
  11
  12#include <linux/interrupt.h>
  13#include <linux/v4l2-controls.h>
  14#include <media/h264-ctrls.h>
  15#include <media/mpeg2-ctrls.h>
  16#include <media/vp8-ctrls.h>
  17#include <media/videobuf2-core.h>
  18
  19#define DEC_8190_ALIGN_MASK     0x07U
  20
  21#define MB_DIM                  16
  22#define MB_WIDTH(w)             DIV_ROUND_UP(w, MB_DIM)
  23#define MB_HEIGHT(h)            DIV_ROUND_UP(h, MB_DIM)
  24
  25struct hantro_dev;
  26struct hantro_ctx;
  27struct hantro_buf;
  28struct hantro_variant;
  29
  30/**
  31 * struct hantro_aux_buf - auxiliary DMA buffer for hardware data
  32 * @cpu:        CPU pointer to the buffer.
  33 * @dma:        DMA address of the buffer.
  34 * @size:       Size of the buffer.
  35 * @attrs:      Attributes of the DMA mapping.
  36 */
  37struct hantro_aux_buf {
  38        void *cpu;
  39        dma_addr_t dma;
  40        size_t size;
  41        unsigned long attrs;
  42};
  43
  44/**
  45 * struct hantro_jpeg_enc_hw_ctx
  46 * @bounce_buffer:      Bounce buffer
  47 */
  48struct hantro_jpeg_enc_hw_ctx {
  49        struct hantro_aux_buf bounce_buffer;
  50};
  51
  52/* Max. number of entries in the DPB (HW limitation). */
  53#define HANTRO_H264_DPB_SIZE            16
  54
  55/**
  56 * struct hantro_h264_dec_ctrls
  57 * @decode:     Decode params
  58 * @scaling:    Scaling info
  59 * @sps:        SPS info
  60 * @pps:        PPS info
  61 */
  62struct hantro_h264_dec_ctrls {
  63        const struct v4l2_ctrl_h264_decode_params *decode;
  64        const struct v4l2_ctrl_h264_scaling_matrix *scaling;
  65        const struct v4l2_ctrl_h264_sps *sps;
  66        const struct v4l2_ctrl_h264_pps *pps;
  67};
  68
  69/**
  70 * struct hantro_h264_dec_reflists
  71 * @p:          P reflist
  72 * @b0:         B0 reflist
  73 * @b1:         B1 reflist
  74 */
  75struct hantro_h264_dec_reflists {
  76        u8 p[HANTRO_H264_DPB_SIZE];
  77        u8 b0[HANTRO_H264_DPB_SIZE];
  78        u8 b1[HANTRO_H264_DPB_SIZE];
  79};
  80
  81/**
  82 * struct hantro_h264_dec_hw_ctx
  83 * @priv:       Private auxiliary buffer for hardware.
  84 * @dpb:        DPB
  85 * @reflists:   P/B0/B1 reflists
  86 * @ctrls:      V4L2 controls attached to a run
  87 */
  88struct hantro_h264_dec_hw_ctx {
  89        struct hantro_aux_buf priv;
  90        struct v4l2_h264_dpb_entry dpb[HANTRO_H264_DPB_SIZE];
  91        struct hantro_h264_dec_reflists reflists;
  92        struct hantro_h264_dec_ctrls ctrls;
  93};
  94
  95/**
  96 * struct hantro_mpeg2_dec_hw_ctx
  97 * @qtable:             Quantization table
  98 */
  99struct hantro_mpeg2_dec_hw_ctx {
 100        struct hantro_aux_buf qtable;
 101};
 102
 103/**
 104 * struct hantro_vp8d_hw_ctx
 105 * @segment_map:        Segment map buffer.
 106 * @prob_tbl:           Probability table buffer.
 107 */
 108struct hantro_vp8_dec_hw_ctx {
 109        struct hantro_aux_buf segment_map;
 110        struct hantro_aux_buf prob_tbl;
 111};
 112
 113/**
 114 * struct hantro_postproc_ctx
 115 *
 116 * @dec_q:              References buffers, in decoder format.
 117 */
 118struct hantro_postproc_ctx {
 119        struct hantro_aux_buf dec_q[VB2_MAX_FRAME];
 120};
 121
 122/**
 123 * struct hantro_codec_ops - codec mode specific operations
 124 *
 125 * @init:       If needed, can be used for initialization.
 126 *              Optional and called from process context.
 127 * @exit:       If needed, can be used to undo the .init phase.
 128 *              Optional and called from process context.
 129 * @run:        Start single {en,de)coding job. Called from atomic context
 130 *              to indicate that a pair of buffers is ready and the hardware
 131 *              should be programmed and started.
 132 * @done:       Read back processing results and additional data from hardware.
 133 * @reset:      Reset the hardware in case of a timeout.
 134 */
 135struct hantro_codec_ops {
 136        int (*init)(struct hantro_ctx *ctx);
 137        void (*exit)(struct hantro_ctx *ctx);
 138        void (*run)(struct hantro_ctx *ctx);
 139        void (*done)(struct hantro_ctx *ctx);
 140        void (*reset)(struct hantro_ctx *ctx);
 141};
 142
 143/**
 144 * enum hantro_enc_fmt - source format ID for hardware registers.
 145 */
 146enum hantro_enc_fmt {
 147        RK3288_VPU_ENC_FMT_YUV420P = 0,
 148        RK3288_VPU_ENC_FMT_YUV420SP = 1,
 149        RK3288_VPU_ENC_FMT_YUYV422 = 2,
 150        RK3288_VPU_ENC_FMT_UYVY422 = 3,
 151};
 152
 153extern const struct hantro_variant rk3399_vpu_variant;
 154extern const struct hantro_variant rk3328_vpu_variant;
 155extern const struct hantro_variant rk3288_vpu_variant;
 156extern const struct hantro_variant imx8mq_vpu_variant;
 157
 158extern const struct hantro_postproc_regs hantro_g1_postproc_regs;
 159
 160extern const u32 hantro_vp8_dec_mc_filter[8][6];
 161
 162void hantro_watchdog(struct work_struct *work);
 163void hantro_run(struct hantro_ctx *ctx);
 164void hantro_irq_done(struct hantro_dev *vpu,
 165                     enum vb2_buffer_state result);
 166void hantro_start_prepare_run(struct hantro_ctx *ctx);
 167void hantro_end_prepare_run(struct hantro_ctx *ctx);
 168
 169void hantro_h1_jpeg_enc_run(struct hantro_ctx *ctx);
 170void rk3399_vpu_jpeg_enc_run(struct hantro_ctx *ctx);
 171int hantro_jpeg_enc_init(struct hantro_ctx *ctx);
 172void hantro_jpeg_enc_exit(struct hantro_ctx *ctx);
 173void hantro_jpeg_enc_done(struct hantro_ctx *ctx);
 174
 175dma_addr_t hantro_h264_get_ref_buf(struct hantro_ctx *ctx,
 176                                   unsigned int dpb_idx);
 177int hantro_h264_dec_prepare_run(struct hantro_ctx *ctx);
 178void hantro_g1_h264_dec_run(struct hantro_ctx *ctx);
 179int hantro_h264_dec_init(struct hantro_ctx *ctx);
 180void hantro_h264_dec_exit(struct hantro_ctx *ctx);
 181
 182static inline size_t
 183hantro_h264_mv_size(unsigned int width, unsigned int height)
 184{
 185        /*
 186         * A decoded 8-bit 4:2:0 NV12 frame may need memory for up to
 187         * 448 bytes per macroblock with additional 32 bytes on
 188         * multi-core variants.
 189         *
 190         * The H264 decoder needs extra space on the output buffers
 191         * to store motion vectors. This is needed for reference
 192         * frames and only if the format is non-post-processed NV12.
 193         *
 194         * Memory layout is as follow:
 195         *
 196         * +---------------------------+
 197         * | Y-plane   256 bytes x MBs |
 198         * +---------------------------+
 199         * | UV-plane  128 bytes x MBs |
 200         * +---------------------------+
 201         * | MV buffer  64 bytes x MBs |
 202         * +---------------------------+
 203         * | MC sync          32 bytes |
 204         * +---------------------------+
 205         */
 206        return 64 * MB_WIDTH(width) * MB_WIDTH(height) + 32;
 207}
 208
 209void hantro_g1_mpeg2_dec_run(struct hantro_ctx *ctx);
 210void rk3399_vpu_mpeg2_dec_run(struct hantro_ctx *ctx);
 211void hantro_mpeg2_dec_copy_qtable(u8 *qtable,
 212        const struct v4l2_ctrl_mpeg2_quantization *ctrl);
 213int hantro_mpeg2_dec_init(struct hantro_ctx *ctx);
 214void hantro_mpeg2_dec_exit(struct hantro_ctx *ctx);
 215
 216void hantro_g1_vp8_dec_run(struct hantro_ctx *ctx);
 217void rk3399_vpu_vp8_dec_run(struct hantro_ctx *ctx);
 218int hantro_vp8_dec_init(struct hantro_ctx *ctx);
 219void hantro_vp8_dec_exit(struct hantro_ctx *ctx);
 220void hantro_vp8_prob_update(struct hantro_ctx *ctx,
 221                            const struct v4l2_ctrl_vp8_frame_header *hdr);
 222
 223#endif /* HANTRO_HW_H_ */
 224