Lines Matching refs:ctx
41 static void coda_free_bitstream_buffer(struct coda_ctx *ctx);
64 static void coda_command_async(struct coda_ctx *ctx, int cmd)
66 struct coda_dev *dev = ctx->dev;
72 coda_write(dev, ctx->bit_stream_param,
74 coda_write(dev, ctx->frm_dis_flg,
75 CODA_REG_BIT_FRM_DIS_FLG(ctx->reg_idx));
76 coda_write(dev, ctx->frame_mem_ctrl,
78 coda_write(dev, ctx->workbuf.paddr, CODA_REG_BIT_WORK_BUF_ADDR);
88 coda_write(dev, ctx->idx, CODA_REG_BIT_RUN_INDEX);
89 coda_write(dev, ctx->params.codec_mode, CODA_REG_BIT_RUN_COD_STD);
90 coda_write(dev, ctx->params.codec_mode_aux, CODA7_REG_BIT_RUN_AUX_STD);
92 trace_coda_bit_run(ctx, cmd);
97 static int coda_command_sync(struct coda_ctx *ctx, int cmd)
99 struct coda_dev *dev = ctx->dev;
104 coda_command_async(ctx, cmd);
106 trace_coda_bit_done(ctx);
111 int coda_hw_reset(struct coda_ctx *ctx)
113 struct coda_dev *dev = ctx->dev;
149 static void coda_kfifo_sync_from_device(struct coda_ctx *ctx)
151 struct __kfifo *kfifo = &ctx->bitstream_fifo.kfifo;
152 struct coda_dev *dev = ctx->dev;
155 rd_ptr = coda_read(dev, CODA_REG_BIT_RD_PTR(ctx->reg_idx));
157 (rd_ptr - ctx->bitstream.paddr);
162 static void coda_kfifo_sync_to_device_full(struct coda_ctx *ctx)
164 struct __kfifo *kfifo = &ctx->bitstream_fifo.kfifo;
165 struct coda_dev *dev = ctx->dev;
168 rd_ptr = ctx->bitstream.paddr + (kfifo->out & kfifo->mask);
169 coda_write(dev, rd_ptr, CODA_REG_BIT_RD_PTR(ctx->reg_idx));
170 wr_ptr = ctx->bitstream.paddr + (kfifo->in & kfifo->mask);
171 coda_write(dev, wr_ptr, CODA_REG_BIT_WR_PTR(ctx->reg_idx));
174 static void coda_kfifo_sync_to_device_write(struct coda_ctx *ctx)
176 struct __kfifo *kfifo = &ctx->bitstream_fifo.kfifo;
177 struct coda_dev *dev = ctx->dev;
180 wr_ptr = ctx->bitstream.paddr + (kfifo->in & kfifo->mask);
181 coda_write(dev, wr_ptr, CODA_REG_BIT_WR_PTR(ctx->reg_idx));
184 static int coda_h264_bitstream_pad(struct coda_ctx *ctx, u32 size)
197 n = kfifo_in(&ctx->bitstream_fifo, buf, size);
203 int coda_bitstream_flush(struct coda_ctx *ctx)
207 if (ctx->inst_type != CODA_INST_DECODER || !ctx->use_bit)
210 ret = coda_command_sync(ctx, CODA_COMMAND_DEC_BUF_FLUSH);
212 v4l2_err(&ctx->dev->v4l2_dev, "failed to flush bitstream\n");
216 kfifo_init(&ctx->bitstream_fifo, ctx->bitstream.vaddr,
217 ctx->bitstream.size);
218 coda_kfifo_sync_to_device_full(ctx);
223 static int coda_bitstream_queue(struct coda_ctx *ctx, const u8 *buf, u32 size)
225 u32 n = kfifo_in(&ctx->bitstream_fifo, buf, size);
230 static u32 coda_buffer_parse_headers(struct coda_ctx *ctx,
237 switch (ctx->codec->src_fourcc) {
239 size = coda_mpeg2_parse_headers(ctx, vaddr, payload);
242 size = coda_mpeg4_parse_headers(ctx, vaddr, payload);
251 static bool coda_bitstream_try_queue(struct coda_ctx *ctx,
259 if (coda_get_bitstream_payload(ctx) + payload + 512 >=
260 ctx->bitstream.size)
264 v4l2_err(&ctx->dev->v4l2_dev, "trying to queue empty buffer\n");
268 if (ctx->qsequence == 0 && payload < 512) {
276 u32 header_size = coda_buffer_parse_headers(ctx, src_buf,
280 coda_dbg(1, ctx, "pad with %u-byte header\n",
283 ret = coda_bitstream_queue(ctx, vaddr,
286 v4l2_err(&ctx->dev->v4l2_dev,
290 if (ctx->dev->devtype->product == CODA_960)
294 coda_dbg(1, ctx,
299 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_H264)
300 coda_h264_bitstream_pad(ctx, 512 - payload);
303 ret = coda_bitstream_queue(ctx, vaddr, payload);
305 v4l2_err(&ctx->dev->v4l2_dev, "bitstream buffer overflow\n");
309 src_buf->sequence = ctx->qsequence++;
312 if (ctx == v4l2_m2m_get_curr_priv(ctx->dev->m2m_dev))
313 coda_kfifo_sync_to_device_write(ctx);
317 coda_bit_stream_end_flag(ctx);
318 ctx->hold = false;
323 void coda_fill_bitstream(struct coda_ctx *ctx, struct list_head *buffer_list)
329 lockdep_assert_held(&ctx->bitstream_mutex);
331 if (ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG)
334 while (v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) > 0) {
340 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG &&
341 ctx->num_metas > 1)
344 if (ctx->num_internal_frames &&
345 ctx->num_metas >= ctx->num_internal_frames) {
346 meta = list_first_entry(&ctx->buffer_meta_list,
357 if (coda_bitstream_can_fetch_past(ctx, meta->end))
361 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
364 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG &&
365 !coda_jpeg_check_buffer(ctx, &src_buf->vb2_buf)) {
366 v4l2_err(&ctx->dev->v4l2_dev,
368 ctx->qsequence);
369 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
385 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
391 start = ctx->bitstream_fifo.kfifo.in;
393 if (coda_bitstream_try_queue(ctx, src_buf)) {
398 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
406 meta->end = ctx->bitstream_fifo.kfifo.in;
409 coda_dbg(1, ctx, "marking last meta");
410 spin_lock(&ctx->buffer_meta_lock);
412 &ctx->buffer_meta_list);
413 ctx->num_metas++;
414 spin_unlock(&ctx->buffer_meta_lock);
416 trace_coda_bit_queue(ctx, src_buf, meta);
435 void coda_bit_stream_end_flag(struct coda_ctx *ctx)
437 struct coda_dev *dev = ctx->dev;
439 ctx->bit_stream_param |= CODA_BIT_STREAM_END_FLAG;
444 (ctx->idx == coda_read(dev, CODA_REG_BIT_RUN_INDEX))) {
445 coda_write(dev, ctx->bit_stream_param,
450 static void coda_parabuf_write(struct coda_ctx *ctx, int index, u32 value)
452 struct coda_dev *dev = ctx->dev;
453 u32 *p = ctx->parabuf.vaddr;
461 static inline int coda_alloc_context_buf(struct coda_ctx *ctx,
465 return coda_alloc_aux_buf(ctx->dev, buf, size, name, ctx->debugfs_entry);
469 static void coda_free_framebuffers(struct coda_ctx *ctx)
474 coda_free_aux_buf(ctx->dev, &ctx->internal_frames[i].buf);
477 static int coda_alloc_framebuffers(struct coda_ctx *ctx,
480 struct coda_dev *dev = ctx->dev;
485 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_H264 ||
486 ctx->codec->dst_fourcc == V4L2_PIX_FMT_H264 ||
487 ctx->codec->src_fourcc == V4L2_PIX_FMT_MPEG4 ||
488 ctx->codec->dst_fourcc == V4L2_PIX_FMT_MPEG4)
494 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP)
500 for (i = 0; i < ctx->num_internal_frames; i++) {
506 (ctx->codec->src_fourcc == V4L2_PIX_FMT_H264 ||
507 (ctx->codec->src_fourcc == V4L2_PIX_FMT_MPEG4 && i == 0)))
511 coda_free_framebuffers(ctx);
514 ret = coda_alloc_context_buf(ctx, &ctx->internal_frames[i].buf,
518 coda_free_framebuffers(ctx);
524 for (i = 0; i < ctx->num_internal_frames; i++) {
528 y = ctx->internal_frames[i].buf.paddr;
532 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP) {
541 coda_parabuf_write(ctx, i * 3 + 0, y);
542 coda_parabuf_write(ctx, i * 3 + 1, cb);
543 coda_parabuf_write(ctx, i * 3 + 2, cr);
549 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_H264)
550 coda_parabuf_write(ctx, 96 + i, mvcol);
551 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_MPEG4 && i == 0)
552 coda_parabuf_write(ctx, 97, mvcol);
558 static void coda_free_context_buffers(struct coda_ctx *ctx)
560 struct coda_dev *dev = ctx->dev;
562 coda_free_aux_buf(dev, &ctx->slicebuf);
563 coda_free_aux_buf(dev, &ctx->psbuf);
565 coda_free_aux_buf(dev, &ctx->workbuf);
566 coda_free_aux_buf(dev, &ctx->parabuf);
569 static int coda_alloc_context_buffers(struct coda_ctx *ctx,
572 struct coda_dev *dev = ctx->dev;
576 if (!ctx->parabuf.vaddr) {
577 ret = coda_alloc_context_buf(ctx, &ctx->parabuf,
586 if (!ctx->slicebuf.vaddr && q_data->fourcc == V4L2_PIX_FMT_H264) {
590 ret = coda_alloc_context_buf(ctx, &ctx->slicebuf, size,
596 if (!ctx->psbuf.vaddr && (dev->devtype->product == CODA_HX4 ||
598 ret = coda_alloc_context_buf(ctx, &ctx->psbuf,
604 if (!ctx->workbuf.vaddr) {
609 ret = coda_alloc_context_buf(ctx, &ctx->workbuf, size,
618 coda_free_context_buffers(ctx);
622 static int coda_encode_header(struct coda_ctx *ctx, struct vb2_v4l2_buffer *buf,
626 struct coda_dev *dev = ctx->dev;
643 ctx->codec->dst_fourcc == V4L2_PIX_FMT_H264 &&
645 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
660 ret = coda_command_sync(ctx, CODA_COMMAND_ENCODE_HEADER);
672 *size = coda_read(dev, CODA_REG_BIT_WR_PTR(ctx->reg_idx)) -
680 static u32 coda_slice_mode(struct coda_ctx *ctx)
684 switch (ctx->params.slice_mode) {
689 size = ctx->params.slice_max_mb;
693 size = ctx->params.slice_max_bits;
703 static int coda_enc_param_change(struct coda_ctx *ctx)
705 struct coda_dev *dev = ctx->dev;
710 if (ctx->params.gop_size_changed) {
712 coda_write(dev, ctx->params.gop_size,
714 ctx->gopcounter = ctx->params.gop_size - 1;
715 ctx->params.gop_size_changed = false;
717 if (ctx->params.h264_intra_qp_changed) {
718 coda_dbg(1, ctx, "parameter change: intra Qp %u\n",
719 ctx->params.h264_intra_qp);
721 if (ctx->params.bitrate) {
723 coda_write(dev, ctx->params.h264_intra_qp,
726 ctx->params.h264_intra_qp_changed = false;
728 if (ctx->params.bitrate_changed) {
729 coda_dbg(1, ctx, "parameter change: bitrate %u kbit/s\n",
730 ctx->params.bitrate);
732 coda_write(dev, ctx->params.bitrate,
734 ctx->params.bitrate_changed = false;
736 if (ctx->params.framerate_changed) {
737 coda_dbg(1, ctx, "parameter change: frame rate %u/%u Hz\n",
738 ctx->params.framerate & 0xffff,
739 (ctx->params.framerate >> 16) + 1);
741 coda_write(dev, ctx->params.framerate,
743 ctx->params.framerate_changed = false;
745 if (ctx->params.intra_refresh_changed) {
746 coda_dbg(1, ctx, "parameter change: intra refresh MBs %u\n",
747 ctx->params.intra_refresh);
749 coda_write(dev, ctx->params.intra_refresh,
751 ctx->params.intra_refresh_changed = false;
753 if (ctx->params.slice_mode_changed) {
755 coda_write(dev, coda_slice_mode(ctx),
757 ctx->params.slice_mode_changed = false;
765 ret = coda_command_sync(ctx, CODA_COMMAND_RC_CHANGE_PARAMETER);
771 coda_dbg(1, ctx, "parameter change failed: %u\n", success);
791 static void coda_setup_iram(struct coda_ctx *ctx)
793 struct coda_iram_info *iram_info = &ctx->iram_info;
794 struct coda_dev *dev = ctx->dev;
832 if (ctx->inst_type == CODA_INST_ENCODER) {
835 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
872 } else if (ctx->inst_type == CODA_INST_DECODER) {
875 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
900 coda_dbg(1, ctx, "IRAM smaller than needed\n");
905 if (ctx->inst_type == CODA_INST_DECODER) {
1010 static void coda9_set_frame_cache(struct coda_ctx *ctx, u32 fourcc)
1014 if (ctx->tiled_map_type == GDI_LINEAR_FRAME_MAP) {
1023 coda_write(ctx->dev, cache_size, CODA9_CMD_SET_FRAME_CACHE_SIZE);
1033 coda_write(ctx->dev, cache_config, CODA9_CMD_SET_FRAME_CACHE_CONFIG);
1040 static int coda_encoder_reqbufs(struct coda_ctx *ctx,
1050 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1051 ret = coda_alloc_context_buffers(ctx, q_data_src);
1055 coda_free_context_buffers(ctx);
1061 static int coda_start_encoding(struct coda_ctx *ctx)
1063 struct coda_dev *dev = ctx->dev;
1073 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1074 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1077 buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1087 if (!ctx->params.jpeg_qmat_tab[0]) {
1088 ctx->params.jpeg_qmat_tab[0] = kmalloc(64, GFP_KERNEL);
1089 if (!ctx->params.jpeg_qmat_tab[0])
1092 if (!ctx->params.jpeg_qmat_tab[1]) {
1093 ctx->params.jpeg_qmat_tab[1] = kmalloc(64, GFP_KERNEL);
1094 if (!ctx->params.jpeg_qmat_tab[1])
1097 coda_set_jpeg_compression_quality(ctx, ctx->params.jpeg_quality);
1102 coda_write(dev, ctx->parabuf.paddr, CODA_REG_BIT_PARA_BUF_ADDR);
1103 coda_write(dev, bitstream_buf, CODA_REG_BIT_RD_PTR(ctx->reg_idx));
1104 coda_write(dev, bitstream_buf, CODA_REG_BIT_WR_PTR(ctx->reg_idx));
1120 ctx->frame_mem_ctrl &= ~(CODA_FRAME_CHROMA_INTERLEAVE | (0x3 << 9) |
1123 ctx->frame_mem_ctrl |= CODA_FRAME_CHROMA_INTERLEAVE;
1124 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP)
1125 ctx->frame_mem_ctrl |= (0x3 << 9) | CODA9_FRAME_TILED2LINEAR;
1126 coda_write(dev, ctx->frame_mem_ctrl, CODA_REG_BIT_FRAME_MEM_CTRL);
1161 ctx->params.framerate = 0;
1162 coda_write(dev, ctx->params.framerate,
1165 ctx->params.codec_mode = ctx->codec->mode;
1183 value = ((ctx->params.h264_disable_deblocking_filter_idc &
1186 ((ctx->params.h264_slice_alpha_c0_offset_div2 &
1189 ((ctx->params.h264_slice_beta_offset_div2 &
1192 (ctx->params.h264_constrained_intra_pred_flag <<
1194 (ctx->params.h264_chroma_qp_index_offset &
1200 coda_write(dev, ctx->params.jpeg_restart_interval,
1206 coda_jpeg_write_tables(ctx);
1220 value = coda_slice_mode(ctx);
1222 value = ctx->params.gop_size;
1226 if (ctx->params.bitrate && (ctx->params.frame_rc_enable ||
1227 ctx->params.mb_rc_enable)) {
1228 ctx->params.bitrate_changed = false;
1229 ctx->params.h264_intra_qp_changed = false;
1232 value = (ctx->params.bitrate & CODA_RATECONTROL_BITRATE_MASK)
1235 value |= (ctx->params.vbv_delay &
1245 coda_write(dev, ctx->params.vbv_size, CODA_CMD_ENC_SEQ_RC_BUF_SIZE);
1246 coda_write(dev, ctx->params.intra_refresh,
1263 if (ctx->params.h264_min_qp || ctx->params.h264_max_qp) {
1265 ctx->params.h264_min_qp << CODA_QPMIN_OFFSET |
1266 ctx->params.h264_max_qp << CODA_QPMAX_OFFSET,
1270 if (ctx->params.h264_max_qp)
1281 if (ctx->params.h264_min_qp)
1283 if (ctx->params.h264_max_qp)
1288 if (ctx->params.frame_rc_enable && !ctx->params.mb_rc_enable)
1294 coda_setup_iram(ctx);
1304 coda_write(dev, ctx->iram_info.search_ram_paddr,
1306 coda_write(dev, ctx->iram_info.search_ram_size,
1315 ret = coda_command_sync(ctx, CODA_COMMAND_SEQ_INIT);
1326 ctx->initialized = 1;
1330 ctx->num_internal_frames = 4;
1332 ctx->num_internal_frames = 2;
1333 ret = coda_alloc_framebuffers(ctx, q_data_src, dst_fourcc);
1341 ctx->num_internal_frames = 0;
1354 coda_write(dev, ctx->iram_info.buf_bit_use,
1356 coda_write(dev, ctx->iram_info.buf_ip_ac_dc_use,
1358 coda_write(dev, ctx->iram_info.buf_dbk_y_use,
1360 coda_write(dev, ctx->iram_info.buf_dbk_c_use,
1362 coda_write(dev, ctx->iram_info.buf_ovl_use,
1365 coda_write(dev, ctx->iram_info.buf_btp_use,
1368 coda9_set_frame_cache(ctx, q_data_src->fourcc);
1371 coda_write(dev, ctx->internal_frames[2].buf.paddr,
1373 coda_write(dev, ctx->internal_frames[3].buf.paddr,
1378 ret = coda_command_sync(ctx, CODA_COMMAND_SET_FRAME_BUF);
1384 coda_dbg(1, ctx, "start encoding %dx%d %4.4s->%4.4s @ %d/%d Hz\n",
1386 (char *)&ctx->codec->src_fourcc, (char *)&dst_fourcc,
1387 ctx->params.framerate & 0xffff,
1388 (ctx->params.framerate >> 16) + 1);
1391 buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1398 ret = coda_encode_header(ctx, buf, CODA_HEADER_H264_SPS,
1399 &ctx->vpu_header[0][0],
1400 &ctx->vpu_header_size[0]);
1413 if (ctx->dev->devtype->product != CODA_960 &&
1416 ret = coda_h264_sps_fixup(ctx, q_data_src->rect.width,
1418 &ctx->vpu_header[0][0],
1419 &ctx->vpu_header_size[0],
1420 sizeof(ctx->vpu_header[0]));
1429 ret = coda_encode_header(ctx, buf, CODA_HEADER_H264_PPS,
1430 &ctx->vpu_header[1][0],
1431 &ctx->vpu_header_size[1]);
1440 ctx->vpu_header_size[2] = coda_h264_padding(
1441 (ctx->vpu_header_size[0] +
1442 ctx->vpu_header_size[1]),
1443 ctx->vpu_header[2]);
1450 ret = coda_encode_header(ctx, buf, CODA_HEADER_MP4V_VOS,
1451 &ctx->vpu_header[0][0],
1452 &ctx->vpu_header_size[0]);
1456 ret = coda_encode_header(ctx, buf, CODA_HEADER_MP4V_VIS,
1457 &ctx->vpu_header[1][0],
1458 &ctx->vpu_header_size[1]);
1462 ret = coda_encode_header(ctx, buf, CODA_HEADER_MP4V_VOL,
1463 &ctx->vpu_header[2][0],
1464 &ctx->vpu_header_size[2]);
1478 static int coda_prepare_encode(struct coda_ctx *ctx)
1482 struct coda_dev *dev = ctx->dev;
1491 ret = coda_enc_param_change(ctx);
1493 v4l2_warn(&ctx->dev->v4l2_dev, "parameter change failed: %d\n",
1497 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
1498 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1499 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1500 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1503 src_buf->sequence = ctx->osequence;
1504 dst_buf->sequence = ctx->osequence;
1505 ctx->osequence++;
1507 force_ipicture = ctx->params.force_ipicture;
1509 ctx->params.force_ipicture = false;
1510 else if (ctx->params.gop_size != 0 &&
1511 (src_buf->sequence % ctx->params.gop_size) == 0)
1528 coda_set_gdi_regs(ctx);
1537 ctx->vpu_header_size[0] +
1538 ctx->vpu_header_size[1] +
1539 ctx->vpu_header_size[2];
1541 ctx->vpu_header_size[0] -
1542 ctx->vpu_header_size[1] -
1543 ctx->vpu_header_size[2];
1545 &ctx->vpu_header[0][0], ctx->vpu_header_size[0]);
1547 + ctx->vpu_header_size[0], &ctx->vpu_header[1][0],
1548 ctx->vpu_header_size[1]);
1550 + ctx->vpu_header_size[0] + ctx->vpu_header_size[1],
1551 &ctx->vpu_header[2][0], ctx->vpu_header_size[2]);
1561 quant_param = ctx->params.h264_intra_qp;
1564 quant_param = ctx->params.mpeg4_intra_qp;
1570 v4l2_warn(&ctx->dev->v4l2_dev,
1577 quant_param = ctx->params.h264_inter_qp;
1580 quant_param = ctx->params.mpeg4_inter_qp;
1583 v4l2_warn(&ctx->dev->v4l2_dev,
1590 if (ctx->params.rot_mode)
1591 rot_mode = CODA_ROT_MIR_ENABLE | ctx->params.rot_mode;
1605 coda_write_base(ctx, q_data_src, src_buf, reg);
1614 if (!ctx->streamon_out) {
1616 ctx->bit_stream_param |= CODA_BIT_STREAM_END_FLAG;
1617 coda_write(dev, ctx->bit_stream_param,
1622 coda_write(dev, ctx->iram_info.axi_sram_use,
1625 trace_coda_enc_pic_run(ctx, src_buf);
1627 coda_command_async(ctx, CODA_COMMAND_PIC_RUN);
1639 static void coda_finish_encode(struct coda_ctx *ctx)
1642 struct coda_dev *dev = ctx->dev;
1645 if (ctx->aborting)
1653 mutex_lock(&ctx->wakeup_mutex);
1654 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1655 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1657 trace_coda_enc_pic_done(ctx, dst_buf);
1661 wr_ptr = coda_read(dev, CODA_REG_BIT_WR_PTR(ctx->reg_idx));
1667 ctx->vpu_header_size[0] +
1668 ctx->vpu_header_size[1] +
1669 ctx->vpu_header_size[2]);
1674 coda_dbg(1, ctx, "frame size = %u\n", wr_ptr - start_ptr);
1692 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1693 coda_m2m_buf_done(ctx, dst_buf, VB2_BUF_STATE_DONE);
1694 mutex_unlock(&ctx->wakeup_mutex);
1696 ctx->gopcounter--;
1697 if (ctx->gopcounter < 0)
1698 ctx->gopcounter = ctx->params.gop_size - 1;
1700 coda_dbg(1, ctx, "job finished: encoded %c frame (%d)%s\n",
1707 struct coda_ctx *ctx = container_of(work, struct coda_ctx, seq_end_work);
1708 struct coda_dev *dev = ctx->dev;
1710 mutex_lock(&ctx->buffer_mutex);
1713 if (ctx->initialized == 0)
1716 coda_dbg(1, ctx, "%s: sent command 'SEQ_END' to coda\n", __func__);
1717 if (coda_command_sync(ctx, CODA_COMMAND_SEQ_END)) {
1728 coda_hw_reset(ctx);
1730 kfifo_init(&ctx->bitstream_fifo,
1731 ctx->bitstream.vaddr, ctx->bitstream.size);
1733 coda_free_framebuffers(ctx);
1735 ctx->initialized = 0;
1739 mutex_unlock(&ctx->buffer_mutex);
1742 static void coda_bit_release(struct coda_ctx *ctx)
1744 mutex_lock(&ctx->buffer_mutex);
1745 coda_free_framebuffers(ctx);
1746 coda_free_context_buffers(ctx);
1747 coda_free_bitstream_buffer(ctx);
1748 mutex_unlock(&ctx->buffer_mutex);
1765 static int coda_alloc_bitstream_buffer(struct coda_ctx *ctx,
1768 if (ctx->bitstream.vaddr)
1771 ctx->bitstream.size = roundup_pow_of_two(q_data->sizeimage * 2);
1772 ctx->bitstream.vaddr = dma_alloc_wc(ctx->dev->dev, ctx->bitstream.size,
1773 &ctx->bitstream.paddr, GFP_KERNEL);
1774 if (!ctx->bitstream.vaddr) {
1775 v4l2_err(&ctx->dev->v4l2_dev,
1779 kfifo_init(&ctx->bitstream_fifo,
1780 ctx->bitstream.vaddr, ctx->bitstream.size);
1785 static void coda_free_bitstream_buffer(struct coda_ctx *ctx)
1787 if (ctx->bitstream.vaddr == NULL)
1790 dma_free_wc(ctx->dev->dev, ctx->bitstream.size, ctx->bitstream.vaddr,
1791 ctx->bitstream.paddr);
1792 ctx->bitstream.vaddr = NULL;
1793 kfifo_init(&ctx->bitstream_fifo, NULL, 0);
1796 static int coda_decoder_reqbufs(struct coda_ctx *ctx,
1806 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1807 ret = coda_alloc_context_buffers(ctx, q_data_src);
1810 ret = coda_alloc_bitstream_buffer(ctx, q_data_src);
1812 coda_free_context_buffers(ctx);
1816 coda_free_bitstream_buffer(ctx);
1817 coda_free_context_buffers(ctx);
1823 static bool coda_reorder_enable(struct coda_ctx *ctx)
1825 struct coda_dev *dev = ctx->dev;
1833 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG)
1836 if (ctx->codec->src_fourcc != V4L2_PIX_FMT_H264)
1839 profile = coda_h264_profile(ctx->params.h264_profile_idc);
1842 ctx->params.h264_profile_idc);
1848 static void coda_decoder_drop_used_metas(struct coda_ctx *ctx)
1856 spin_lock(&ctx->buffer_meta_lock);
1857 list_for_each_entry_safe(meta, tmp, &ctx->buffer_meta_list, list) {
1858 if (ctx->bitstream_fifo.kfifo.out >= meta->end) {
1859 coda_dbg(2, ctx, "releasing meta: seq=%d start=%d end=%d\n",
1863 ctx->num_metas--;
1864 ctx->first_frame_sequence++;
1868 spin_unlock(&ctx->buffer_meta_lock);
1871 static int __coda_decoder_seq_init(struct coda_ctx *ctx)
1875 struct coda_dev *dev = ctx->dev;
1883 coda_dbg(1, ctx, "Video Data Order Adapter: %s\n",
1884 ctx->use_vdoa ? "Enabled" : "Disabled");
1887 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1888 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1889 bitstream_buf = ctx->bitstream.paddr;
1890 bitstream_size = ctx->bitstream.size;
1895 coda_kfifo_sync_to_device_full(ctx);
1897 ctx->frame_mem_ctrl &= ~(CODA_FRAME_CHROMA_INTERLEAVE | (0x3 << 9) |
1900 ctx->frame_mem_ctrl |= CODA_FRAME_CHROMA_INTERLEAVE;
1901 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP)
1902 ctx->frame_mem_ctrl |= (0x3 << 9) |
1903 ((ctx->use_vdoa) ? 0 : CODA9_FRAME_TILED2LINEAR);
1904 coda_write(dev, ctx->frame_mem_ctrl, CODA_REG_BIT_FRAME_MEM_CTRL);
1906 ctx->display_idx = -1;
1907 ctx->frm_dis_flg = 0;
1908 coda_write(dev, 0, CODA_REG_BIT_FRM_DIS_FLG(ctx->reg_idx));
1913 if (coda_reorder_enable(ctx))
1915 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG)
1919 ctx->params.codec_mode = ctx->codec->mode;
1922 ctx->params.codec_mode_aux = CODA_MP4_AUX_MPEG4;
1924 ctx->params.codec_mode_aux = 0;
1932 coda_write(dev, ctx->psbuf.paddr,
1947 ctx->bit_stream_param = CODA_BIT_DEC_SEQ_INIT_ESCAPE;
1948 ret = coda_command_sync(ctx, CODA_COMMAND_SEQ_INIT);
1949 ctx->bit_stream_param = 0;
1954 ctx->sequence_offset = ~0U;
1955 ctx->initialized = 1;
1956 ctx->first_frame_sequence = 0;
1959 coda_kfifo_sync_from_device(ctx);
1965 coda_decoder_drop_used_metas(ctx);
1993 coda_dbg(1, ctx, "start decoding: %dx%d\n", width, height);
1995 ctx->num_internal_frames = coda_read(dev, CODA_RET_DEC_SEQ_FRAME_NEED);
2003 if (ctx->use_vdoa)
2004 ctx->num_internal_frames += 1;
2005 if (ctx->num_internal_frames > CODA_MAX_FRAMEBUFFERS) {
2008 CODA_MAX_FRAMEBUFFERS, ctx->num_internal_frames);
2035 coda_update_profile_level_ctrls(ctx, profile, level);
2043 struct coda_ctx *ctx = container_of(work,
2045 struct coda_dev *dev = ctx->dev;
2047 mutex_lock(&ctx->buffer_mutex);
2050 if (!ctx->initialized)
2051 __coda_decoder_seq_init(ctx);
2054 mutex_unlock(&ctx->buffer_mutex);
2057 static int __coda_start_decoding(struct coda_ctx *ctx)
2060 struct coda_dev *dev = ctx->dev;
2064 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
2065 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
2069 if (!ctx->initialized) {
2070 ret = __coda_decoder_seq_init(ctx);
2074 ctx->frame_mem_ctrl &= ~(CODA_FRAME_CHROMA_INTERLEAVE | (0x3 << 9) |
2077 ctx->frame_mem_ctrl |= CODA_FRAME_CHROMA_INTERLEAVE;
2078 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP)
2079 ctx->frame_mem_ctrl |= (0x3 << 9) |
2080 ((ctx->use_vdoa) ? 0 : CODA9_FRAME_TILED2LINEAR);
2083 coda_write(dev, ctx->parabuf.paddr, CODA_REG_BIT_PARA_BUF_ADDR);
2085 ret = coda_alloc_framebuffers(ctx, q_data_dst, src_fourcc);
2092 coda_write(dev, ctx->num_internal_frames, CODA_CMD_SET_FRAME_BUF_NUM);
2098 coda_setup_iram(ctx);
2100 coda_write(dev, ctx->iram_info.buf_bit_use,
2102 coda_write(dev, ctx->iram_info.buf_ip_ac_dc_use,
2104 coda_write(dev, ctx->iram_info.buf_dbk_y_use,
2106 coda_write(dev, ctx->iram_info.buf_dbk_c_use,
2108 coda_write(dev, ctx->iram_info.buf_ovl_use,
2111 coda_write(dev, ctx->iram_info.buf_btp_use,
2115 coda9_set_frame_cache(ctx, dst_fourcc);
2120 coda_write(dev, ctx->slicebuf.paddr,
2122 coda_write(dev, ctx->slicebuf.size / 1024,
2143 if (coda_command_sync(ctx, CODA_COMMAND_SET_FRAME_BUF)) {
2144 v4l2_err(&ctx->dev->v4l2_dev,
2152 static int coda_start_decoding(struct coda_ctx *ctx)
2154 struct coda_dev *dev = ctx->dev;
2158 ret = __coda_start_decoding(ctx);
2164 static int coda_prepare_decode(struct coda_ctx *ctx)
2167 struct coda_dev *dev = ctx->dev;
2173 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2174 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
2177 mutex_lock(&ctx->bitstream_mutex);
2178 coda_fill_bitstream(ctx, NULL);
2179 mutex_unlock(&ctx->bitstream_mutex);
2181 if (coda_get_bitstream_payload(ctx) < 512 &&
2182 (!(ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG))) {
2183 coda_dbg(1, ctx, "bitstream payload: %d, skipping\n",
2184 coda_get_bitstream_payload(ctx));
2189 if (!ctx->initialized) {
2190 int ret = __coda_start_decoding(ctx);
2196 ctx->initialized = 1;
2201 coda_set_gdi_regs(ctx);
2203 if (ctx->use_vdoa &&
2204 ctx->display_idx >= 0 &&
2205 ctx->display_idx < ctx->num_internal_frames) {
2206 vdoa_device_run(ctx->vdoa,
2208 ctx->internal_frames[ctx->display_idx].buf.paddr);
2223 * fixed value in the [ctx->num_internal_frames, 31]
2235 coda_write_base(ctx, q_data_dst, dst_buf, reg_addr);
2238 rot_mode = CODA_ROT_MIR_ENABLE | ctx->params.rot_mode;
2262 coda_write(dev, ctx->iram_info.axi_sram_use,
2265 spin_lock(&ctx->buffer_meta_lock);
2266 meta = list_first_entry_or_null(&ctx->buffer_meta_list,
2269 if (meta && ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG) {
2272 if (meta->end == ctx->bitstream_fifo.kfifo.in) {
2281 kfifo_in(&ctx->bitstream_fifo, buf, pad);
2284 spin_unlock(&ctx->buffer_meta_lock);
2286 coda_kfifo_sync_to_device_full(ctx);
2294 trace_coda_dec_pic_run(ctx, meta);
2296 coda_command_async(ctx, CODA_COMMAND_PIC_RUN);
2301 static void coda_finish_decode(struct coda_ctx *ctx)
2303 struct coda_dev *dev = ctx->dev;
2318 if (ctx->aborting)
2322 coda_kfifo_sync_from_device(ctx);
2328 if (ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG) {
2329 if (coda_get_bitstream_payload(ctx) >= ctx->bitstream.size - 512)
2330 kfifo_init(&ctx->bitstream_fifo,
2331 ctx->bitstream.vaddr, ctx->bitstream.size);
2334 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
2349 ctx->psbuf.size);
2353 ctx->slicebuf.size);
2360 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
2389 coda_dbg(1, ctx, "errors in %d macroblocks\n", err_mb);
2390 v4l2_ctrl_s_ctrl(ctx->mb_err_cnt_ctrl,
2391 v4l2_ctrl_g_ctrl(ctx->mb_err_cnt_ctrl) + err_mb);
2399 coda_dbg(1, ctx, "prescan failed: %d\n", val);
2400 ctx->hold = true;
2406 if (ctx->use_vdoa &&
2407 ctx->display_idx >= 0 &&
2408 ctx->display_idx < ctx->num_internal_frames) {
2409 err_vdoa = vdoa_wait_for_completion(ctx->vdoa);
2412 ctx->frm_dis_flg = coda_read(dev,
2413 CODA_REG_BIT_FRM_DIS_FLG(ctx->reg_idx));
2416 if (ctx->display_idx >= 0 &&
2417 ctx->display_idx < ctx->num_internal_frames) {
2418 ctx->frm_dis_flg &= ~(1 << ctx->display_idx);
2419 coda_write(dev, ctx->frm_dis_flg,
2420 CODA_REG_BIT_FRM_DIS_FLG(ctx->reg_idx));
2433 if (display_idx >= 0 && display_idx < ctx->num_internal_frames)
2434 ctx->sequence_offset++;
2435 else if (ctx->display_idx < 0)
2436 ctx->hold = true;
2438 if (ctx->display_idx >= 0 &&
2439 ctx->display_idx < ctx->num_internal_frames)
2440 ctx->sequence_offset++;
2442 } else if (decoded_idx < 0 || decoded_idx >= ctx->num_internal_frames) {
2448 decoded_frame = &ctx->internal_frames[decoded_idx];
2451 if (ctx->sequence_offset == -1)
2452 ctx->sequence_offset = val;
2454 sequence = val + ctx->first_frame_sequence
2455 - ctx->sequence_offset;
2456 spin_lock(&ctx->buffer_meta_lock);
2457 if (!list_empty(&ctx->buffer_meta_list)) {
2458 meta = list_first_entry(&ctx->buffer_meta_list,
2461 ctx->num_metas--;
2462 spin_unlock(&ctx->buffer_meta_lock);
2473 sequence, ctx->sequence_offset,
2479 spin_unlock(&ctx->buffer_meta_lock);
2485 ctx->sequence_offset++;
2488 trace_coda_dec_pic_done(ctx, &decoded_frame->meta);
2503 ctx->hold = true;
2506 } else if (display_idx < 0 || display_idx >= ctx->num_internal_frames) {
2513 if (ctx->display_idx >= 0 &&
2514 ctx->display_idx < ctx->num_internal_frames) {
2517 ready_frame = &ctx->internal_frames[ctx->display_idx];
2519 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
2520 dst_buf->sequence = ctx->osequence++;
2528 if (meta->last && !coda_reorder_enable(ctx)) {
2533 coda_dbg(1, ctx, "last meta, marking as last frame\n");
2535 } else if (ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG &&
2541 coda_dbg(1, ctx,
2548 trace_coda_dec_rot_done(ctx, dst_buf, meta);
2554 coda_m2m_buf_done(ctx, dst_buf, VB2_BUF_STATE_ERROR);
2556 coda_m2m_buf_done(ctx, dst_buf, VB2_BUF_STATE_DONE);
2559 coda_dbg(1, ctx, "job finished: decoded %c frame %u, returned %c frame %u (%u/%u)%s\n",
2564 dst_buf->sequence, ctx->qsequence,
2568 coda_dbg(1, ctx, "job finished: no frame decoded (%d), returned %c frame %u (%u/%u)%s\n",
2572 dst_buf->sequence, ctx->qsequence,
2578 coda_dbg(1, ctx, "job finished: decoded %c frame %u, no frame returned (%d)\n",
2581 ctx->display_idx);
2583 coda_dbg(1, ctx, "job finished: no frame decoded (%d) or returned (%d)\n",
2584 decoded_idx, ctx->display_idx);
2589 ctx->display_idx = display_idx;
2598 mutex_lock(&ctx->bitstream_mutex);
2599 coda_fill_bitstream(ctx, NULL);
2600 mutex_unlock(&ctx->bitstream_mutex);
2603 static void coda_decode_timeout(struct coda_ctx *ctx)
2613 if (!(ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG))
2616 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
2617 dst_buf->sequence = ctx->qsequence - 1;
2619 coda_m2m_buf_done(ctx, dst_buf, VB2_BUF_STATE_ERROR);
2637 struct coda_ctx *ctx;
2645 ctx = v4l2_m2m_get_curr_priv(dev->m2m_dev);
2646 if (ctx == NULL) {
2652 trace_coda_bit_done(ctx);
2654 if (ctx->aborting) {
2655 coda_dbg(1, ctx, "task has been aborted\n");
2658 if (coda_isbusy(ctx->dev)) {
2659 coda_dbg(1, ctx, "coda is still busy!!!!\n");
2663 complete(&ctx->completion);