int jpeg_set_enc_param(struct jpeg_control *ctrl)
{
if (ctrl) {
jpeg_sw_reset(ctrl->reg_base);
} else {
jpeg_err("jpeg ctrl is NULL\n");
return -1;
}
jpeg_set_clk_power_on(ctrl->reg_base);
jpeg_set_mode(ctrl->reg_base, 0);
jpeg_set_enc_in_fmt(ctrl->reg_base, ctrl->enc_param.in_fmt);
jpeg_set_enc_out_fmt(ctrl->reg_base, ctrl->enc_param.out_fmt);
jpeg_set_enc_dri(ctrl->reg_base, 2);
jpeg_set_frame_size(ctrl->reg_base,
ctrl->enc_param.width, ctrl->enc_param.height);
jpeg_set_stream_buf(&ctrl->mem.stream_data_addr, ctrl->mem.base);
jpeg_set_stream_addr(ctrl->reg_base, ctrl->mem.stream_data_addr);
jpeg_set_frame_buf(&ctrl->mem.frame_data_addr, ctrl->mem.base);
jpeg_set_frame_addr(ctrl->reg_base, ctrl->mem.frame_data_addr);
jpeg_set_enc_coef(ctrl->reg_base);
jpeg_set_enc_qtbl(ctrl->reg_base, ctrl->enc_param.quality);
jpeg_set_enc_htbl(ctrl->reg_base);
return 0;
}
int jpeg_set_dec_param(struct jpeg_control *ctrl)
{
if (ctrl) {
jpeg_sw_reset(ctrl->reg_base);
} else {
jpeg_err("jpeg ctrl is NULL\n");
return -1;
}
jpeg_set_clk_power_on(ctrl->reg_base);
jpeg_set_mode(ctrl->reg_base, 1);
jpeg_set_dec_out_fmt(ctrl->reg_base, ctrl->dec_param.out_fmt);
jpeg_set_stream_buf(&ctrl->mem.stream_data_addr, ctrl->mem.base);
jpeg_set_stream_addr(ctrl->reg_base, ctrl->mem.stream_data_addr);
jpeg_set_frame_buf(&ctrl->mem.frame_data_addr, ctrl->mem.base);
jpeg_set_frame_addr(ctrl->reg_base, ctrl->mem.frame_data_addr);
jpeg_info("jpeg_set_dec_param fmt(%d)\
img_addr(0x%08x) jpeg_addr(0x%08x)\n",
ctrl->dec_param.out_fmt,
ctrl->mem.frame_data_addr,
ctrl->mem.stream_data_addr);
return 0;
}
static void jpeg_device_enc_run(void *priv)
{
struct jpeg_ctx *ctx = priv;
struct jpeg_dev *dev = ctx->dev;
struct jpeg_enc_param enc_param;
struct vb2_buffer *vb = NULL;
unsigned long flags;
dev = ctx->dev;
spin_lock_irqsave(&ctx->dev->slock, flags);
dev->mode = ENCODING;
enc_param = ctx->param.enc_param;
jpeg_sw_reset(dev->reg_base);
jpeg_set_interrupt(dev->reg_base);
jpeg_set_huf_table_enable(dev->reg_base, 1);
jpeg_set_enc_tbl(dev->reg_base);
jpeg_set_encode_tbl_select(dev->reg_base, enc_param.quality);
jpeg_set_stream_size(dev->reg_base,
enc_param.in_width, enc_param.in_height);
jpeg_set_enc_out_fmt(dev->reg_base, enc_param.out_fmt);
jpeg_set_enc_in_fmt(dev->reg_base, enc_param.in_fmt);
vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
jpeg_set_stream_buf_address(dev->reg_base, dev->vb2->plane_addr(vb, 0));
vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
if (enc_param.in_plane == 1)
jpeg_set_frame_buf_address(dev->reg_base,
enc_param.in_fmt, dev->vb2->plane_addr(vb, 0), 0, 0);
if (enc_param.in_plane == 2)
jpeg_set_frame_buf_address(dev->reg_base,
enc_param.in_fmt, dev->vb2->plane_addr(vb, 0),
dev->vb2->plane_addr(vb, 1), 0);
if (enc_param.in_plane == 3)
jpeg_set_frame_buf_address(dev->reg_base,
enc_param.in_fmt, dev->vb2->plane_addr(vb, 0),
dev->vb2->plane_addr(vb, 1), dev->vb2->plane_addr(vb, 2));
jpeg_set_encode_hoff_cnt(dev->reg_base, enc_param.out_fmt);
jpeg_set_enc_dec_mode(dev->reg_base, ENCODING);
spin_unlock_irqrestore(&ctx->dev->slock, flags);
}
static irqreturn_t jpeg_irq(int irq, void *priv)
{
unsigned int int_status;
struct vb2_buffer *src_vb, *dst_vb;
struct jpeg_dev *ctrl = priv;
struct jpeg_ctx *ctx;
spin_lock(&ctrl->slock);
if (ctrl->mode == ENCODING)
ctx = v4l2_m2m_get_curr_priv(ctrl->m2m_dev_enc);
else
ctx = v4l2_m2m_get_curr_priv(ctrl->m2m_dev_dec);
if (ctx == 0) {
printk(KERN_ERR "ctx is null.\n");
int_status = jpeg_int_pending(ctrl);
jpeg_sw_reset(ctrl->reg_base);
goto ctx_err;
}
src_vb = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
dst_vb = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
int_status = jpeg_int_pending(ctrl);
if (int_status) {
switch (int_status & 0x1f) {
case 0x1:
ctrl->irq_ret = ERR_PROT;
break;
case 0x2:
ctrl->irq_ret = OK_ENC_OR_DEC;
break;
case 0x4:
ctrl->irq_ret = ERR_DEC_INVALID_FORMAT;
break;
case 0x8:
ctrl->irq_ret = ERR_MULTI_SCAN;
break;
case 0x10:
ctrl->irq_ret = ERR_FRAME;
break;
default:
ctrl->irq_ret = ERR_UNKNOWN;
break;
}
} else {
ctrl->irq_ret = ERR_UNKNOWN;
}
if (ctrl->irq_ret == OK_ENC_OR_DEC) {
v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
} else {
v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
}
clear_bit(0, &ctx->dev->hw_run);
if (ctrl->mode == ENCODING)
v4l2_m2m_job_finish(ctrl->m2m_dev_enc, ctx->m2m_ctx);
else
v4l2_m2m_job_finish(ctrl->m2m_dev_dec, ctx->m2m_ctx);
ctx_err:
spin_unlock(&ctrl->slock);
return IRQ_HANDLED;
}
static void jpeg_device_dec_run(void *priv)
{
struct jpeg_ctx *ctx = priv;
struct jpeg_dev *dev = ctx->dev;
struct jpeg_dec_param dec_param;
struct vb2_buffer *vb = NULL;
unsigned long flags;
dev = ctx->dev;
spin_lock_irqsave(&ctx->dev->slock, flags);
printk(KERN_DEBUG "dec_run.\n");
if (timer_pending(&ctx->dev->watchdog_timer) == 0) {
ctx->dev->watchdog_timer.expires = jiffies +
msecs_to_jiffies(JPEG_WATCHDOG_INTERVAL);
add_timer(&ctx->dev->watchdog_timer);
}
set_bit(0, &ctx->dev->hw_run);
dev->mode = DECODING;
dec_param = ctx->param.dec_param;
jpeg_sw_reset(dev->reg_base);
jpeg_set_interrupt(dev->reg_base);
jpeg_set_encode_tbl_select(dev->reg_base, 0);
vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
jpeg_set_stream_buf_address(dev->reg_base, dev->vb2->plane_addr(vb, 0));
vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
if (dec_param.out_plane == 1)
jpeg_set_frame_buf_address(dev->reg_base,
dec_param.out_fmt, dev->vb2->plane_addr(vb, 0), 0, 0);
else if (dec_param.out_plane == 2) {
jpeg_set_frame_buf_address(dev->reg_base,
dec_param.out_fmt, dev->vb2->plane_addr(vb, 0), dev->vb2->plane_addr(vb, 1), 0);
} else if (dec_param.out_plane == 3)
jpeg_set_frame_buf_address(dev->reg_base,
dec_param.out_fmt, dev->vb2->plane_addr(vb, 0),
dev->vb2->plane_addr(vb, 1), dev->vb2->plane_addr(vb, 2));
if (dec_param.out_width > 0 && dec_param.out_height > 0) {
if ((dec_param.out_width * 2 == dec_param.in_width) &&
(dec_param.out_height * 2 == dec_param.in_height))
jpeg_set_dec_scaling(dev->reg_base, JPEG_SCALE_2, JPEG_SCALE_2);
else if ((dec_param.out_width * 4 == dec_param.in_width) &&
(dec_param.out_height * 4 == dec_param.in_height))
jpeg_set_dec_scaling(dev->reg_base, JPEG_SCALE_4, JPEG_SCALE_4);
else
jpeg_set_dec_scaling(dev->reg_base, JPEG_SCALE_NORMAL, JPEG_SCALE_NORMAL);
}
jpeg_set_dec_out_fmt(dev->reg_base, dec_param.out_fmt);
jpeg_set_dec_bitstream_size(dev->reg_base, dec_param.size);
jpeg_set_enc_dec_mode(dev->reg_base, DECODING);
spin_unlock_irqrestore(&ctx->dev->slock, flags);
}
static int jpeg_1shotdev_device_run(struct m2m1shot_context *m21ctx,
struct m2m1shot_task *task)
{
struct jpeg_ctx *ctx = m21ctx->priv;
struct jpeg_dev *jpeg = ctx->jpeg_dev;
if (!jpeg) {
pr_err("jpeg is null\n");
return -EINVAL;
}
BUG_ON(test_bit(DEV_RUN, &jpeg->state));
BUG_ON(test_bit(DEV_SUSPEND, &jpeg->state));
BUG_ON(!test_bit(DEV_RUNTIME_RESUME, &jpeg->state));
jpeg_sw_reset(jpeg->regs);
jpeg_set_interrupt(jpeg->regs);
jpeg_set_huf_table_enable(jpeg->regs, true);
jpeg_set_stream_size(jpeg->regs, ctx->width, ctx->height);
if (allow_custom_qtbl &&
!!(ctx->flags & EXYNOS_JPEG_CTX_CUSTOM_QTBL) &&
ctx->custom_qtbl) {
jpeg_set_enc_custom_tbl(jpeg->regs, ctx->custom_qtbl);
} else {
jpeg_set_enc_tbl(jpeg->regs, ctx->quality);
}
jpeg_set_encode_tbl_select(jpeg->regs);
jpeg_set_encode_huffman_table(jpeg->regs);
jpeg_set_image_fmt(jpeg->regs, ctx->in_fmt->reg_cfg |
ctx->out_fmt->reg_cfg);
if (is_jpeg_fmt(ctx->out_fmt->fourcc)) {
jpeg_set_stream_addr(jpeg->regs,
task->dma_buf_cap.plane[0].dma_addr);
jpeg_set_image_addr(jpeg->regs, &task->dma_buf_out,
ctx->in_fmt, ctx->width, ctx->height);
jpeg_set_encode_hoff_cnt(jpeg->regs, ctx->out_fmt->fourcc);
} else {
jpeg_set_stream_addr(jpeg->regs,
task->dma_buf_out.plane[0].dma_addr);
jpeg_set_image_addr(jpeg->regs, &task->dma_buf_cap,
ctx->out_fmt, ctx->width, ctx->height);
jpeg_alpha_value_set(jpeg->regs, 0xff);
jpeg_set_dec_bitstream_size(jpeg->regs,
task->task.buf_out.plane[0].len);
}
set_bit(DEV_RUN, &jpeg->state);
jpeg_set_timer_count(jpeg->regs, ctx->width * ctx->height * 8 + 0xff);
if (is_jpeg_fmt(ctx->out_fmt->fourcc))
jpeg_set_enc_dec_mode(jpeg->regs, ENCODING);
else
jpeg_set_enc_dec_mode(jpeg->regs, DECODING);
return 0;
}
