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 struct hantro_dev; 22 struct hantro_ctx; 23 struct hantro_buf; 24 struct hantro_variant; 25 26 /** 27 * struct hantro_aux_buf - auxiliary DMA buffer for hardware data 28 * @cpu: CPU pointer to the buffer. 29 * @dma: DMA address of the buffer. 30 * @size: Size of the buffer. 31 */ 32 struct hantro_aux_buf { 33 void *cpu; 34 dma_addr_t dma; 35 size_t size; 36 }; 37 38 /** 39 * struct hantro_jpeg_enc_hw_ctx 40 * @bounce_buffer: Bounce buffer 41 */ 42 struct hantro_jpeg_enc_hw_ctx { 43 struct hantro_aux_buf bounce_buffer; 44 }; 45 46 /* Max. number of entries in the DPB (HW limitation). */ 47 #define HANTRO_H264_DPB_SIZE 16 48 49 /** 50 * struct hantro_h264_dec_ctrls 51 * @decode: Decode params 52 * @scaling: Scaling info 53 * @slice: Slice params 54 * @sps: SPS info 55 * @pps: PPS info 56 */ 57 struct hantro_h264_dec_ctrls { 58 const struct v4l2_ctrl_h264_decode_params *decode; 59 const struct v4l2_ctrl_h264_scaling_matrix *scaling; 60 const struct v4l2_ctrl_h264_slice_params *slices; 61 const struct v4l2_ctrl_h264_sps *sps; 62 const struct v4l2_ctrl_h264_pps *pps; 63 }; 64 65 /** 66 * struct hantro_h264_dec_reflists 67 * @p: P reflist 68 * @b0: B0 reflist 69 * @b1: B1 reflist 70 */ 71 struct hantro_h264_dec_reflists { 72 u8 p[HANTRO_H264_DPB_SIZE]; 73 u8 b0[HANTRO_H264_DPB_SIZE]; 74 u8 b1[HANTRO_H264_DPB_SIZE]; 75 }; 76 77 /** 78 * struct hantro_h264_dec_hw_ctx 79 * @priv: Private auxiliary buffer for hardware. 80 * @dpb: DPB 81 * @reflists: P/B0/B1 reflists 82 * @ctrls: V4L2 controls attached to a run 83 * @pic_size: Size in bytes of decoded picture, this is needed 84 * to pass the location of motion vectors. 85 */ 86 struct hantro_h264_dec_hw_ctx { 87 struct hantro_aux_buf priv; 88 struct v4l2_h264_dpb_entry dpb[HANTRO_H264_DPB_SIZE]; 89 struct hantro_h264_dec_reflists reflists; 90 struct hantro_h264_dec_ctrls ctrls; 91 size_t pic_size; 92 }; 93 94 /** 95 * struct hantro_mpeg2_dec_hw_ctx 96 * @qtable: Quantization table 97 */ 98 struct hantro_mpeg2_dec_hw_ctx { 99 struct hantro_aux_buf qtable; 100 }; 101 102 /** 103 * struct hantro_vp8d_hw_ctx 104 * @segment_map: Segment map buffer. 105 * @prob_tbl: Probability table buffer. 106 */ 107 struct hantro_vp8_dec_hw_ctx { 108 struct hantro_aux_buf segment_map; 109 struct hantro_aux_buf prob_tbl; 110 }; 111 112 /** 113 * struct hantro_codec_ops - codec mode specific operations 114 * 115 * @init: If needed, can be used for initialization. 116 * Optional and called from process context. 117 * @exit: If needed, can be used to undo the .init phase. 118 * Optional and called from process context. 119 * @run: Start single {en,de)coding job. Called from atomic context 120 * to indicate that a pair of buffers is ready and the hardware 121 * should be programmed and started. 122 * @done: Read back processing results and additional data from hardware. 123 * @reset: Reset the hardware in case of a timeout. 124 */ 125 struct hantro_codec_ops { 126 int (*init)(struct hantro_ctx *ctx); 127 void (*exit)(struct hantro_ctx *ctx); 128 void (*run)(struct hantro_ctx *ctx); 129 void (*done)(struct hantro_ctx *ctx, enum vb2_buffer_state); 130 void (*reset)(struct hantro_ctx *ctx); 131 }; 132 133 /** 134 * enum hantro_enc_fmt - source format ID for hardware registers. 135 */ 136 enum hantro_enc_fmt { 137 RK3288_VPU_ENC_FMT_YUV420P = 0, 138 RK3288_VPU_ENC_FMT_YUV420SP = 1, 139 RK3288_VPU_ENC_FMT_YUYV422 = 2, 140 RK3288_VPU_ENC_FMT_UYVY422 = 3, 141 }; 142 143 extern const struct hantro_variant rk3399_vpu_variant; 144 extern const struct hantro_variant rk3328_vpu_variant; 145 extern const struct hantro_variant rk3288_vpu_variant; 146 147 extern const u32 hantro_vp8_dec_mc_filter[8][6]; 148 149 void hantro_watchdog(struct work_struct *work); 150 void hantro_run(struct hantro_ctx *ctx); 151 void hantro_irq_done(struct hantro_dev *vpu, unsigned int bytesused, 152 enum vb2_buffer_state result); 153 void hantro_prepare_run(struct hantro_ctx *ctx); 154 void hantro_finish_run(struct hantro_ctx *ctx); 155 156 void hantro_h1_jpeg_enc_run(struct hantro_ctx *ctx); 157 void rk3399_vpu_jpeg_enc_run(struct hantro_ctx *ctx); 158 int hantro_jpeg_enc_init(struct hantro_ctx *ctx); 159 void hantro_jpeg_enc_exit(struct hantro_ctx *ctx); 160 161 struct vb2_buffer *hantro_h264_get_ref_buf(struct hantro_ctx *ctx, 162 unsigned int dpb_idx); 163 int hantro_h264_dec_prepare_run(struct hantro_ctx *ctx); 164 void hantro_g1_h264_dec_run(struct hantro_ctx *ctx); 165 int hantro_h264_dec_init(struct hantro_ctx *ctx); 166 void hantro_h264_dec_exit(struct hantro_ctx *ctx); 167 168 void hantro_g1_mpeg2_dec_run(struct hantro_ctx *ctx); 169 void rk3399_vpu_mpeg2_dec_run(struct hantro_ctx *ctx); 170 void hantro_mpeg2_dec_copy_qtable(u8 *qtable, 171 const struct v4l2_ctrl_mpeg2_quantization *ctrl); 172 int hantro_mpeg2_dec_init(struct hantro_ctx *ctx); 173 void hantro_mpeg2_dec_exit(struct hantro_ctx *ctx); 174 175 void hantro_g1_vp8_dec_run(struct hantro_ctx *ctx); 176 void rk3399_vpu_vp8_dec_run(struct hantro_ctx *ctx); 177 int hantro_vp8_dec_init(struct hantro_ctx *ctx); 178 void hantro_vp8_dec_exit(struct hantro_ctx *ctx); 179 void hantro_vp8_prob_update(struct hantro_ctx *ctx, 180 const struct v4l2_ctrl_vp8_frame_header *hdr); 181 182 #endif /* HANTRO_HW_H_ */ 183