Google Git
Sign in
coral / linux-imx / 27bb6b1851294273e2573c67b5c73b61092b8200 / . / drivers / media / platform / imx8 / mxc-jpeg.c
blob: 58ac99c86d5f7861c416d828dbe9e8b7c3566a2f [file] [log] [blame]
/*
* Copyright 2018 NXP
*/
/*
* The code contained herein is licensed under the GNU General Public
* License. You may obtain a copy of the GNU General Public License
* Version 2 or later at the following locations:
*
* http://www.opensource.org/licenses/gpl-license.html
* http://www.gnu.org/copyleft/gpl.html
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/clk.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/irqreturn.h>
#include <linux/interrupt.h>
#include <linux/pm_runtime.h>
#include <linux/string.h>
#include <media/v4l2-mem2mem.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-common.h>
#include <media/v4l2-event.h>
#include <media/videobuf2-dma-contig.h>
#include "mxc-jpeg-hw.h"
#include "mxc-jpeg.h"
static struct mxc_jpeg_fmt mxc_formats[] = {
{
.name = "JPEG",
.fourcc = V4L2_PIX_FMT_JPEG,
.colplanes = 1,
.flags = MXC_JPEG_FMT_TYPE_ENC,
},
{
.name = "RGB", /*RGBRGB packed format*/
.fourcc = V4L2_PIX_FMT_RGB24,
.depth = 24,
.colplanes = 1,
.h_align = 0,
.v_align = 0,
.flags = MXC_JPEG_FMT_TYPE_RAW,
},
{
.name = "ARGB", /* ARGBARGB packed format */
.fourcc = V4L2_PIX_FMT_ARGB32,
.depth = 32,
.colplanes = 1,
.h_align = 0,
.v_align = 0,
.flags = MXC_JPEG_FMT_TYPE_RAW,
},
{
.name = "YUV420", /* 1st plane = Y, 2nd plane = UV */
.fourcc = V4L2_PIX_FMT_NV12,
.depth = 12, /* 6 bytes (4Y + UV) for 4 pixels */
.colplanes = 2, /* 1 plane Y, 1 plane UV interleaved */
.h_align = 2,
.v_align = 0,
.flags = MXC_JPEG_FMT_TYPE_RAW,
},
{
.name = "YUV422", /* YUYV */
.fourcc = V4L2_PIX_FMT_YUYV,
.depth = 16,
.colplanes = 1,
.h_align = 2,
.v_align = 0,
.flags = MXC_JPEG_FMT_TYPE_RAW,
},
{
.name = "YUV444", /* YUVYUV */
.fourcc = V4L2_PIX_FMT_YUV32,
.depth = 24,
.colplanes = 1,
.h_align = 0,
.v_align = 0,
.flags = MXC_JPEG_FMT_TYPE_RAW,
},
{
.name = "Gray", /* Gray (Y8/Y12) or Single Comp */
.fourcc = V4L2_PIX_FMT_GREY,
.depth = 8,
.colplanes = 1,
.h_align = 0,
.v_align = 0,
.flags = MXC_JPEG_FMT_TYPE_RAW,
},
};
#define MXC_JPEG_NUM_FORMATS ARRAY_SIZE(mxc_formats)
static const struct of_device_id mxc_jpeg_match[] = {
{
.compatible = "fsl,imx8-jpgdec",
.data = (void *)MXC_JPEG_DECODE,
},
{
.compatible = "fsl,imx8-jpgenc",
.data = (void *)MXC_JPEG_ENCODE,
},
{ },
};
static const unsigned char hactbl[615] = {
0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A,
0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xFF,
0xDB, 0x00, 0x84, 0x00, 0x10, 0x0B, 0x0C,
0x0E, 0x0C, 0x0A, 0x10, 0x0E, 0x0D, 0x0E,
0x12, 0x11, 0x10, 0x13, 0x18, 0x28, 0x1A,
0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
0x1D, 0x28, 0x3A, 0x33, 0x3D, 0x3C, 0x39,
0x33, 0x38, 0x37, 0x40, 0x48, 0x5C, 0x4E,
0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50,
0x6D, 0x51, 0x57, 0x5F, 0x62, 0x67, 0x68,
0x67, 0x3E, 0x4D, 0x71, 0x79, 0x70, 0x64,
0x78, 0x5C, 0x65, 0x67, 0x63, 0x01, 0x11,
0x12, 0x12, 0x18, 0x15, 0x18, 0x2F, 0x1A,
0x1A, 0x2F, 0x63, 0x42, 0x38, 0x42, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x40,
0x00, 0x40, 0x03, 0x01, 0x21, 0x00, 0x02,
0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4,
0x01, 0xA2, 0x00, 0x00, 0x01, 0x05, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x10, 0x00, 0x02, 0x01,
0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05,
0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91,
0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15,
0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72,
0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19,
0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A,
0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76,
0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85,
0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93,
0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4,
0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
0x0B, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04,
0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04,
0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02,
0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06,
0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13,
0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52,
0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18,
0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A,
0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43,
0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85,
0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93,
0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4,
0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5,
0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xDD,
0x00, 0x04, 0x00, 0x20, 0xFF, 0xDA, 0x00,
0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03,
0x11, 0x00, 0x3F, 0x00, 0xFF, 0xD9
};
#define HACTBL_H_OFFSET 159
#define HACTBL_W_OFFSET 161
#define HACTBL_COMP1_SUBSAMPLING 165
#define HACTBL_COMP2_SUBSAMPLING 168
#define HACTBL_COMP3_SUBSAMPLING 171
/* Print Four-character-code (FOURCC) */
static char *fourcc_to_str(u32 format)
{
char *buf = kmalloc(32, GFP_KERNEL);
snprintf(buf, 32,
"%c%c%c%c",
format & 0xff,
(format >> 8) & 0xff,
(format >> 16) & 0xff,
(format >> 24) & 0x7f);
return buf;
}
static unsigned int mxc_jpeg_tracing;
EXPORT_SYMBOL(mxc_jpeg_tracing);
module_param_named(jpeg_tracing, mxc_jpeg_tracing, int, 0600);
static void print_buf_preview(struct device *dev, struct vb2_buffer *buf)
{
unsigned char *data;
u32 dma_addr;
if (!mxc_jpeg_tracing)
return;
dma_addr = vb2_dma_contig_plane_dma_addr(buf, 0);
data = (char *)vb2_plane_vaddr(buf, 0);
/* print just the first 4 bytes from the beginning of the buffer */
dev_dbg(dev, "vaddr=%p dma_addr=%x: %x %x %x %x ...\n",
data, dma_addr,
data[0], data[1], data[2], data[3]);
}
static void print_nbuf_to_eoi(struct device *dev, struct vb2_buffer *buf, int n)
{
unsigned char *data;
u32 dma_addr;
int i;
int items_per_line = 22;
char *bufstr, *bufptr;
if (!mxc_jpeg_tracing)
return;
if (n == 0)
n = buf->planes[0].bytesused;
dma_addr = vb2_dma_contig_plane_dma_addr(buf, 0);
data = (unsigned char *)vb2_plane_vaddr(buf, 0);
dev_dbg(dev, "vaddr=%p dma_addr=%x bytesused=%d:",
data, dma_addr, n);
bufstr = kmalloc(items_per_line * 6, GFP_ATOMIC);
bufptr = bufstr;
for (i = 0; i < n; i++) {
snprintf(bufptr, 6, "0x%02x,", data[i]);
bufptr += 5;
if ((i+1) % items_per_line == 0) {
/* print the current line */
dev_dbg(dev, "%s", bufstr);
/* back to buffer start */
bufptr = bufstr;
}
/* stop at End of Image (EOI) marker*/
if (i > 0 && data[i-1] == 0xFF && data[i] == 0xD9)
break;
}
if (bufptr != bufstr)
dev_dbg(dev, "%s", bufstr);
dev_dbg(dev, "buffer size = %d", i);
kfree(bufstr);
}
static inline u32 mxc_jpeg_align(u32 val, u32 align)
{
return (val + align - 1) & ~(align - 1);
}
static inline struct mxc_jpeg_ctx *mxc_jpeg_fh_to_ctx(struct v4l2_fh *fh)
{
return container_of(fh, struct mxc_jpeg_ctx, fh);
}
static int enum_fmt(struct mxc_jpeg_fmt *mxc_formats, int n,
struct v4l2_fmtdesc *f, u32 type)
{
int i, num = 0;
for (i = 0; i < n; ++i) {
if (mxc_formats[i].flags == type) {
/* index-th format of type type found ? */
if (num == f->index)
break;
/* Correct type but haven't reached our index yet,
* just increment per-type index
*/
++num;
}
}
/* Format not found */
if (i >= n)
return -EINVAL;
strlcpy(f->description, mxc_formats[i].name, sizeof(f->description));
f->pixelformat = mxc_formats[i].fourcc;
return 0;
}
static struct mxc_jpeg_fmt *mxc_jpeg_find_format(struct mxc_jpeg_ctx *ctx,
u32 pixelformat)
{
unsigned int k;
for (k = 0; k < MXC_JPEG_NUM_FORMATS; k++) {
struct mxc_jpeg_fmt *fmt = &mxc_formats[k];
if (fmt->fourcc == pixelformat)
return fmt;
}
return NULL;
}
static enum mxc_jpeg_image_format mxc_jpeg_fourcc_to_imgfmt(
u32 fourcc)
{
switch (fourcc) {
case V4L2_PIX_FMT_GREY:
return MXC_JPEG_GRAY;
case V4L2_PIX_FMT_YUYV:
return MXC_JPEG_YUV422;
case V4L2_PIX_FMT_NV12:
return MXC_JPEG_YUV420;
case V4L2_PIX_FMT_YUV32:
return MXC_JPEG_YUV444;
case V4L2_PIX_FMT_RGB24:
return MXC_JPEG_RGB;
case V4L2_PIX_FMT_ARGB32:
return MXC_JPEG_ARGB;
default:
return MXC_JPEG_INVALID;
}
}
static int mxc_jpeg_imgfmt_to_fourcc(enum mxc_jpeg_image_format imgfmt,
u32 *fourcc)
{
switch (imgfmt) {
case MXC_JPEG_GRAY:
*fourcc = V4L2_PIX_FMT_GREY;
return 0;
case MXC_JPEG_YUV422:
*fourcc = V4L2_PIX_FMT_YUYV;
return 0;
case MXC_JPEG_YUV420:
*fourcc = V4L2_PIX_FMT_NV12;
return 0;
case MXC_JPEG_YUV444:
*fourcc = V4L2_PIX_FMT_YUV32;
return 0;
case MXC_JPEG_RGB:
*fourcc = V4L2_PIX_FMT_RGB24;
return 0;
case MXC_JPEG_ARGB:
*fourcc = V4L2_PIX_FMT_ARGB32;
return 0;
default:
return 1;
}
}
static struct mxc_jpeg_q_data *mxc_jpeg_get_q_data(struct mxc_jpeg_ctx *ctx,
enum v4l2_buf_type type)
{
if (V4L2_TYPE_IS_OUTPUT(type))
return &ctx->out_q;
return &ctx->cap_q;
}
static void mxc_jpeg_addrs(struct mxc_jpeg_desc *desc,
struct vb2_buffer *b_base0_buf,
struct vb2_buffer *bufbase_buf, int offset)
{
int img_fmt = desc->stm_ctrl & STM_CTRL_IMAGE_FORMAT_MASK;
desc->buf_base0 = vb2_dma_contig_plane_dma_addr(b_base0_buf, 0);
desc->buf_base1 = 0;
if (img_fmt == STM_CTRL_IMAGE_FORMAT(MXC_JPEG_YUV420)) {
u32 h = desc->imgsize & 0xFFFF;
u32 w = (desc->imgsize >> 16) & 0xFFFF;
u32 luma_plane_size = w * h;
desc->buf_base1 = desc->buf_base0 + luma_plane_size;
}
desc->stm_bufbase = vb2_dma_contig_plane_dma_addr(bufbase_buf, 0) +
offset;
}
static void notify_eos(struct mxc_jpeg_ctx *ctx)
{
const struct v4l2_event ev = {
.type = V4L2_EVENT_EOS
};
dev_dbg(ctx->mxc_jpeg->dev, "Notify app event EOS reached");
v4l2_event_queue_fh(&ctx->fh, &ev);
}
static irqreturn_t mxc_jpeg_dec_irq(int irq, void *priv)
{
struct mxc_jpeg_dev *jpeg = priv;
struct mxc_jpeg_ctx *ctx;
void __iomem *reg = jpeg->base_reg;
struct device *dev = jpeg->dev;
struct vb2_buffer *src_buf, *dst_buf;
enum vb2_buffer_state buf_state;
u32 dec_ret;
unsigned long payload_size;
struct mxc_jpeg_q_data *q_data;
int slot = 0; /* TODO remove hardcoded slot 0 */
spin_lock(&jpeg->hw_lock);
dec_ret = readl(reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS));
writel(dec_ret, reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS)); /* w1c */
ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
if (!ctx) {
dev_err(dev,
"Instance released before the end of transaction 0x%x.",
dec_ret);
/* soft reset only resets internal state, not registers */
mxc_jpeg_sw_reset(reg);
/* clear all interrupts */
writel(0xFFFFFFFF, reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS));
goto job_unlock;
}
dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
if (ctx->aborting) {
dev_warn(dev, "Aborting current job\n");
mxc_jpeg_sw_reset(reg);
buf_state = VB2_BUF_STATE_ERROR;
goto buffers_done;
}
if (dec_ret & SLOTa_STATUS_ENC_CONFIG_ERR) {
u32 ret = readl(reg + CAST_STATUS12);
dev_err(dev, "Encoder/decoder error, status=0x%08x", ret);
mxc_jpeg_sw_reset(reg);
buf_state = VB2_BUF_STATE_ERROR;
goto buffers_done;
}
if (!(dec_ret & SLOTa_STATUS_FRMDONE))
goto job_unlock;
if (ctx->mode == MXC_JPEG_ENCODE
&& ctx->enc_state == MXC_JPEG_ENC_CONF) {
ctx->enc_state = MXC_JPEG_ENC_DONE;
dev_dbg(dev, "Encoder config finished. Start encoding...\n");
goto job_unlock;
}
if (ctx->mode == MXC_JPEG_ENCODE) {
payload_size = readl(reg + MXC_SLOT_OFFSET(slot, SLOT_BUF_PTR));
vb2_set_plane_payload(dst_buf, 0, payload_size);
dev_dbg(dev, "Encoding finished, payload_size: %ld\n",
payload_size);
} else {
q_data = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
payload_size = q_data->sizeimage[0];
vb2_set_plane_payload(dst_buf, 0, payload_size);
dev_dbg(dev, "Decoding finished, payload_size: %ld\n",
payload_size);
}
/* short preview of the results */
dev_dbg(dev, "src_buf preview: ");
print_buf_preview(dev, src_buf);
dev_dbg(dev, "dst_buf preview: ");
print_buf_preview(dev, dst_buf);
buf_state = VB2_BUF_STATE_DONE;
buffers_done:
v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
v4l2_m2m_buf_done(to_vb2_v4l2_buffer(src_buf), buf_state);
v4l2_m2m_buf_done(to_vb2_v4l2_buffer(dst_buf), buf_state);
spin_unlock(&jpeg->hw_lock);
v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx);
return IRQ_HANDLED;
job_unlock:
spin_unlock(&jpeg->hw_lock);
return IRQ_HANDLED;
}
static void mxc_jpeg_config_dec_desc(struct vb2_buffer *out_buf,
int slot,
struct mxc_jpeg_dev *jpeg,
struct vb2_buffer *src_buf, struct vb2_buffer *dst_buf)
{
void __iomem *reg = jpeg->base_reg;
struct mxc_jpeg_desc *desc = jpeg->slot_data[slot].desc;
dma_addr_t desc_handle = jpeg->slot_data[slot].desc_handle;
mxc_jpeg_addrs(desc, dst_buf, src_buf, 0);
mxc_jpeg_set_bufsize(desc,
mxc_jpeg_align(vb2_plane_size(src_buf, 0), 1024));
print_descriptor_info(jpeg->dev, desc);
/* validate the decoding descriptor */
mxc_jpeg_set_desc(desc_handle, reg, slot);
}
static void mxc_jpeg_fixup_cfg_stream(void *cfg_stream_vaddr,
enum mxc_jpeg_image_format img_fmt,
u16 w, u16 h)
{
u8 *hactbl = (u8 *)cfg_stream_vaddr;
hactbl[HACTBL_W_OFFSET] = w >> 8;
hactbl[HACTBL_W_OFFSET+1] = (u8)w;
hactbl[HACTBL_H_OFFSET] = h >> 8;
hactbl[HACTBL_H_OFFSET+1] = (u8)h;
switch (img_fmt) {
case MXC_JPEG_YUV420:
hactbl[HACTBL_COMP1_SUBSAMPLING] = 0x22;
hactbl[HACTBL_COMP2_SUBSAMPLING] = 0x11;
hactbl[HACTBL_COMP3_SUBSAMPLING] = 0x11;
break;
case MXC_JPEG_YUV422:
hactbl[HACTBL_COMP1_SUBSAMPLING] = 0x21;
hactbl[HACTBL_COMP2_SUBSAMPLING] = 0x11;
hactbl[HACTBL_COMP3_SUBSAMPLING] = 0x11;
break;
case MXC_JPEG_YUV444:
case MXC_JPEG_RGB:
default:
hactbl[HACTBL_COMP1_SUBSAMPLING] = 0x11;
hactbl[HACTBL_COMP2_SUBSAMPLING] = 0x11;
hactbl[HACTBL_COMP3_SUBSAMPLING] = 0x11;
break;
case MXC_JPEG_ARGB:
/* TODO: should be 4 componennts, SOF0 length should change*/
hactbl[HACTBL_COMP1_SUBSAMPLING] = 0x11;
hactbl[HACTBL_COMP2_SUBSAMPLING] = 0x11;
hactbl[HACTBL_COMP3_SUBSAMPLING] = 0x11;
break;
case MXC_JPEG_GRAY:
/* TODO: should be 1 comp only, SOF0 length should change*/
hactbl[HACTBL_COMP1_SUBSAMPLING] = 0x11;
break;
}
}
static void mxc_jpeg_config_enc_desc(struct vb2_buffer *out_buf,
int slot,
struct mxc_jpeg_ctx *ctx,
struct vb2_buffer *src_buf, struct vb2_buffer *dst_buf)
{
struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
void __iomem *reg = jpeg->base_reg;
struct mxc_jpeg_desc *desc = jpeg->slot_data[slot].desc;
struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data[slot].cfg_desc;
dma_addr_t desc_handle = jpeg->slot_data[slot].desc_handle;
dma_addr_t cfg_desc_handle = jpeg->slot_data[slot].cfg_desc_handle;
struct mxc_jpeg_q_data *q_data;
enum mxc_jpeg_image_format img_fmt;
q_data = mxc_jpeg_get_q_data(ctx, src_buf->vb2_queue->type);
/* chain the config descriptor with the encoding descriptor */
cfg_desc->next_descpt_ptr = desc_handle | MXC_NXT_DESCPT_EN;
cfg_desc->buf_base0 = jpeg->slot_data[slot].cfg_stream_handle;
cfg_desc->buf_base1 = 0;
cfg_desc->line_pitch = 0;
cfg_desc->stm_bufbase = 0;
cfg_desc->stm_bufsize = 0x2000;
cfg_desc->imgsize = 0;
cfg_desc->stm_ctrl = STM_CTRL_CONFIG_MOD(1);
desc->next_descpt_ptr = 0; /* end of chain */
mxc_jpeg_set_res(desc, q_data->w, q_data->h);
mxc_jpeg_set_line_pitch(desc, q_data->w * (q_data->fmt->depth / 8));
mxc_jpeg_set_bufsize(desc, desc->line_pitch * q_data->h);
img_fmt = mxc_jpeg_fourcc_to_imgfmt(q_data->fmt->fourcc);
if (img_fmt == MXC_JPEG_INVALID)
dev_err(jpeg->dev, "No valid image format detected\n");
desc->stm_ctrl = STM_CTRL_CONFIG_MOD(0) |
STM_CTRL_IMAGE_FORMAT(img_fmt);
mxc_jpeg_fixup_cfg_stream(jpeg->slot_data[slot].cfg_stream_vaddr,
img_fmt, q_data->w, q_data->h);
mxc_jpeg_addrs(desc, src_buf, dst_buf, 0);
dev_dbg(jpeg->dev, "cfg_desc - 0x%llx:\n", cfg_desc_handle);
print_descriptor_info(jpeg->dev, cfg_desc);
dev_dbg(jpeg->dev, "enc desc - 0x%llx:\n", desc_handle);
print_descriptor_info(jpeg->dev, desc);
print_wrapper_info(jpeg->dev, reg);
print_cast_status(jpeg->dev, reg, MXC_JPEG_ENCODE);
/* validate the configuration descriptor */
mxc_jpeg_set_desc(cfg_desc_handle, reg, slot);
}
static void mxc_jpeg_device_run(void *priv)
{
struct mxc_jpeg_ctx *ctx = priv;
struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
void __iomem *reg = jpeg->base_reg;
struct device *dev = jpeg->dev;
struct vb2_buffer *src_buf, *dst_buf;
unsigned long flags;
int slot = 0;
spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags);
src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
if (!src_buf || !dst_buf) {
dev_err(dev, "Null src or dst buf\n");
goto end;
}
mxc_jpeg_sw_reset(reg);
mxc_jpeg_enable(reg);
mxc_jpeg_set_l_endian(reg, 1);
slot = 0; /* TODO get slot */
mxc_jpeg_enable_slot(reg, slot);
mxc_jpeg_enable_irq(reg, slot);
if (ctx->mode == MXC_JPEG_ENCODE) {
dev_dbg(dev, "Encoding on slot %d\n", slot);
ctx->enc_state = MXC_JPEG_ENC_CONF;
mxc_jpeg_config_enc_desc(dst_buf, slot, ctx, src_buf, dst_buf);
mxc_jpeg_go_enc(dev, reg);
} else {
dev_dbg(dev, "Decoding on slot %d\n", slot);
print_nbuf_to_eoi(dev, src_buf, 0);
mxc_jpeg_config_dec_desc(dst_buf, slot, jpeg, src_buf, dst_buf);
mxc_jpeg_go_dec(dev, reg);
}
end:
spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
}
static int mxc_jpeg_decoder_cmd(struct file *file, void *priv,
struct v4l2_decoder_cmd *cmd)
{
struct v4l2_fh *fh = file->private_data;
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
struct device *dev = ctx->mxc_jpeg->dev;
switch (cmd->cmd) {
case V4L2_DEC_CMD_STOP:
dev_dbg(dev, "Received V4L2_DEC_CMD_STOP");
if (v4l2_m2m_num_src_bufs_ready(fh->m2m_ctx) == 0) {
/* No more src bufs, notify app EOS */
notify_eos(ctx);
} else {
/* will send EOS later*/
ctx->stopping = 1;
}
return 0;
default:
return -EINVAL;
}
return 0;
}
static int mxc_jpeg_job_ready(void *priv)
{
struct mxc_jpeg_ctx *ctx = priv;
unsigned int num_src_bufs_ready;
unsigned int num_dst_bufs_ready;
unsigned long flags;
spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags);
num_src_bufs_ready = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx);
num_dst_bufs_ready = v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx);
spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
if (num_src_bufs_ready >= 1 && num_dst_bufs_ready >= 1)
return 1;
return 0;
}
static void mxc_jpeg_job_abort(void *priv)
{
struct mxc_jpeg_ctx *ctx = priv;
ctx->aborting = 1;
dev_dbg(ctx->mxc_jpeg->dev, "Abort requested\n");
}
static int mxc_jpeg_queue_setup(struct vb2_queue *q,
unsigned int *num_buffers,
unsigned int *num_planes,
unsigned int sizes[],
struct device *alloc_ctxs[])
{
struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);
struct mxc_jpeg_q_data *q_data = NULL;
q_data = mxc_jpeg_get_q_data(ctx, q->type);
if (!q_data)
return -EINVAL;
*num_planes = 1;
/* assuming worst case jpeg compression: 6 x raw file size */
sizes[0] = q_data->w * q_data->h * 6;
if (q_data->sizeimage[0] > 0)
sizes[0] = q_data->sizeimage[0];
return 0;
}
static int mxc_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
{
struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);
int ret;
dev_dbg(ctx->mxc_jpeg->dev, "Start streaming ctx=%p", ctx);
ret = pm_runtime_get_sync(ctx->mxc_jpeg->dev);
return ret > 0 ? 0 : ret;
}
static void release_active_buffers(struct vb2_queue *q, enum vb2_buffer_state s)
{
struct vb2_buffer *vb;
if (!list_empty(&q->queued_list))
list_for_each_entry(vb, &q->queued_list, queued_entry) {
if (vb->state == VB2_BUF_STATE_ACTIVE)
vb2_buffer_done(vb, s);
}
}
static void mxc_jpeg_stop_streaming(struct vb2_queue *q)
{
struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);
dev_dbg(ctx->mxc_jpeg->dev, "Stop streaming ctx=%p", ctx);
/* Release all active buffers */
release_active_buffers(q, VB2_BUF_STATE_ERROR);
pm_runtime_put_sync(&ctx->mxc_jpeg->pdev->dev);
}
struct mxc_jpeg_stream {
u8 *addr;
u32 loc;
u32 end;
};
static u8 get_byte(struct mxc_jpeg_stream *stream)
{
u8 ret;
if (stream->loc >= stream->end)
return -1;
ret = stream->addr[stream->loc];
stream->loc++;
return ret;
}
static void _bswap16(u16 *a)
{
*a = ((*a & 0x00FF) << 8) | ((*a & 0xFF00) >> 8);
}
static int get_sof(struct device *dev,
struct mxc_jpeg_stream *stream,
struct mxc_jpeg_sof *sof)
{
int i;
if (stream->loc + sizeof(struct mxc_jpeg_sof) >= stream->end)
return -1;
memcpy(sof, &stream->addr[stream->loc], sizeof(struct mxc_jpeg_sof));
_bswap16(&sof->length);
_bswap16(&sof->height);
_bswap16(&sof->width);
dev_dbg(dev, "JPEG SOF: precision=%d\n", sof->precision);
dev_dbg(dev, "JPEG SOF: height=%d, width=%d\n",
sof->height, sof->width);
for (i = 0; i < sof->components_no; i++) {
dev_dbg(dev, "JPEG SOF: comp_id=%d, H=0x%x, V=0x%x\n",
sof->comp[i].id, sof->comp[i].v, sof->comp[i].h);
}
return 0;
}
static int mxc_jpeg_valid_comp_id(
struct device *dev,
const struct mxc_jpeg_sof *sof)
{
int valid = 1;
int i;
for (i = 0; i < sof->components_no; i++)
if (sof->comp[i].id > MXC_JPEG_MAX_COMPONENTS) {
valid = 0;
dev_err(dev, "Component %d has invalid ID: %d",
i, sof->comp[i].id);
}
return valid;
}
static enum mxc_jpeg_image_format mxc_jpeg_get_image_format(
struct device *dev,
const struct mxc_jpeg_sof *sof)
{
if (sof->components_no == 1) {
dev_dbg(dev, "IMAGE_FORMAT is: MXC_JPEG_GRAY\n");
return MXC_JPEG_GRAY;
}
if (sof->components_no == 3) {
if (sof->comp[0].h == 2 && sof->comp[0].v == 2 &&
sof->comp[1].h == 1 && sof->comp[1].v == 1 &&
sof->comp[2].h == 1 && sof->comp[2].v == 1){
dev_dbg(dev, "IMAGE_FORMAT is: MXC_JPEG_YUV420\n");
return MXC_JPEG_YUV420;
}
if (sof->comp[0].h == 2 && sof->comp[0].v == 1 &&
sof->comp[1].h == 1 && sof->comp[1].v == 1 &&
sof->comp[2].h == 1 && sof->comp[2].v == 1){
dev_dbg(dev, "IMAGE_FORMAT is: MXC_JPEG_YUV422\n");
return MXC_JPEG_YUV422;
}
if (sof->comp[0].h == 1 && sof->comp[0].v == 1 &&
sof->comp[1].h == 1 && sof->comp[1].v == 1 &&
sof->comp[2].h == 1 && sof->comp[2].v == 1){
dev_dbg(dev, "IMAGE_FORMAT is: MXC_JPEG_YUV444\n");
return MXC_JPEG_YUV444;
}
}
if (sof->components_no == 4) {
if (sof->comp[0].h == 1 && sof->comp[0].v == 1 &&
sof->comp[1].h == 1 && sof->comp[1].v == 1 &&
sof->comp[2].h == 1 && sof->comp[2].v == 1 &&
sof->comp[3].h == 1 && sof->comp[3].v == 1){
/* this is not tested */
dev_dbg(dev, "IMAGE_FORMAT is: MXC_JPEG_ARGB\n");
return MXC_JPEG_ARGB;
}
}
dev_err(dev, "Could not identify image format\n");
return MXC_JPEG_INVALID;
}
static u32 mxc_jpeg_get_line_pitch(
struct device *dev,
const struct mxc_jpeg_sof *sof,
enum mxc_jpeg_image_format img_fmt)
{
u32 line_pitch;
switch (img_fmt) {
case MXC_JPEG_YUV420:
line_pitch = sof->width * (sof->precision/8) * 1;
break;
case MXC_JPEG_YUV422:
line_pitch = sof->width * (sof->precision/8) * 2;
break;
case MXC_JPEG_RGB:
line_pitch = sof->width * (sof->precision/8) * 3;
break;
case MXC_JPEG_ARGB:
line_pitch = sof->width * (sof->precision/8) * 4;
break;
case MXC_JPEG_YUV444:
line_pitch = sof->width * (sof->precision/8) * 3;
break;
case MXC_JPEG_GRAY:
line_pitch = sof->width * (sof->precision/8) * 1;
break;
default:
line_pitch = sof->width * (sof->precision/8) * 3;
break;
}
dev_dbg(dev, "line_pitch = %d\n", line_pitch);
return line_pitch;
}
static int mxc_jpeg_parse(struct mxc_jpeg_ctx *ctx,
struct mxc_jpeg_desc *desc, u8 *src_addr, u32 size)
{
struct device *dev = ctx->mxc_jpeg->dev;
struct mxc_jpeg_q_data *q_data_out, *q_data_cap;
struct mxc_jpeg_stream stream;
bool notfound = true;
struct mxc_jpeg_sof sof;
int byte;
enum mxc_jpeg_image_format img_fmt;
u32 fourcc;
memset(&sof, 0, sizeof(struct mxc_jpeg_sof));
stream.addr = src_addr;
stream.end = size;
stream.loc = 0;
while (notfound) {
byte = get_byte(&stream);
if (byte == -1)
return -EINVAL;
if (byte != 0xff)
continue;
do {
byte = get_byte(&stream);
} while (byte == 0xff);
if (byte == -1)
return false;
if (byte == 0)
continue;
switch (byte) {
case SOF2:
case SOF0:
if (get_sof(dev, &stream, &sof) == -1)
break;
notfound = false;
break;
default:
notfound = true;
}
}
q_data_out = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
if (sof.width != q_data_out->w || sof.height != q_data_out->h) {
dev_err(dev,
"Resolution mismatch: %dx%d (JPEG) versus %dx%d(user)",
sof.width, sof.height, q_data_out->w, q_data_out->h);
return -EINVAL;
}
if (sof.width % 8 != 0 || sof.height % 8 != 0) {
dev_err(dev, "JPEG width or height not multiple of 8: %dx%d\n",
sof.width, sof.height);
return -EINVAL;
}
if (sof.width > 0x2000 || sof.height > 0x2000) {
dev_err(dev, "JPEG width or height should be <= 8192: %dx%d\n",
sof.width, sof.height);
return -EINVAL;
}
if (sof.components_no > MXC_JPEG_MAX_COMPONENTS) {
dev_err(dev, "JPEG number of components should be <=%d",
MXC_JPEG_MAX_COMPONENTS);
return -EINVAL;
}
if (!mxc_jpeg_valid_comp_id(dev, &sof)) {
dev_err(dev, "JPEG component identifiers should be 0-3 or 1-4");
return -EINVAL;
}
desc->imgsize = sof.width << 16 | sof.height;
dev_dbg(dev, "JPEG imgsize = 0x%x (%dx%d)\n", desc->imgsize,
sof.width, sof.height);
img_fmt = mxc_jpeg_get_image_format(dev, &sof);
if (img_fmt == MXC_JPEG_INVALID)
return -EINVAL;
if (mxc_jpeg_imgfmt_to_fourcc(img_fmt, &fourcc)) {
dev_err(dev, "Fourcc not found for %d", img_fmt);
return -EINVAL;
}
q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
if (q_data_cap->w == 0 && q_data_cap->h == 0) {
dev_dbg(dev, "capture queue format is not set-up yet, using output queue settings");
q_data_cap->w = q_data_out->w;
q_data_cap->h = q_data_out->h;
q_data_cap->fmt = mxc_jpeg_find_format(ctx, fourcc);
}
if (fourcc != q_data_cap->fmt->fourcc) {
char *jpeg_format_name = fourcc_to_str(fourcc);
char *user_format_name = fourcc_to_str(q_data_cap->fmt->fourcc);
dev_warn(dev,
"Pixel format mismatch: jpeg(%s) versus user (%s)",
jpeg_format_name, user_format_name);
dev_warn(dev, "Keeping user settings\n");
kfree(jpeg_format_name);
kfree(user_format_name);
img_fmt = mxc_jpeg_fourcc_to_imgfmt(q_data_cap->fmt->fourcc);
}
desc->stm_ctrl |= STM_CTRL_IMAGE_FORMAT(img_fmt);
desc->line_pitch = mxc_jpeg_get_line_pitch(dev, &sof, img_fmt);
q_data_cap->stride = desc->line_pitch;
q_data_cap->sizeimage[0] = q_data_cap->w * q_data_cap->h *
q_data_cap->fmt->depth / 8;
return 0;
}
static void mxc_jpeg_buf_queue(struct vb2_buffer *vb)
{
int ret;
struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
int slot = 0; /* TODO get slot*/
if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
goto end;
/* for V4L2_BUF_TYPE_VIDEO_OUTPUT */
if (ctx->mode != MXC_JPEG_DECODE)
goto end;
ret = mxc_jpeg_parse(ctx,
ctx->mxc_jpeg->slot_data[slot].desc,
(u8 *)vb2_plane_vaddr(vb, 0),
vb2_get_plane_payload(vb, 0));
if (ret) {
v4l2_err(&ctx->mxc_jpeg->v4l2_dev,
"driver does not support this resolution/format\n");
vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
return;
}
if (ctx->state == MXC_JPEG_INIT) {
static const struct v4l2_event ev_src_ch = {
.type = V4L2_EVENT_SOURCE_CHANGE,
.u.src_change.changes =
V4L2_EVENT_SRC_CH_RESOLUTION,
};
v4l2_event_queue_fh(&ctx->fh, &ev_src_ch);
ctx->state = MXC_JPEG_RUNNING;
}
end:
v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
}
static int mxc_jpeg_buf_prepare(struct vb2_buffer *vb)
{
struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
struct mxc_jpeg_q_data *q_data = NULL;
unsigned long sizeimage;
q_data = mxc_jpeg_get_q_data(ctx, vb->vb2_queue->type);
if (!q_data)
return -EINVAL;
sizeimage = q_data->sizeimage[0];
if (vb2_plane_size(vb, 0) < sizeimage) {
dev_err(ctx->mxc_jpeg->dev, "buffer too small (%lu < %lu)",
vb2_plane_size(vb, 0), sizeimage);
return -EINVAL;
}
vb2_set_plane_payload(vb, 0, sizeimage);
return 0;
}
static void mxc_jpeg_buf_clean(struct vb2_buffer *vb)
{
return;
}
static const struct vb2_ops mxc_jpeg_qops = {
.queue_setup = mxc_jpeg_queue_setup,
.wait_prepare = vb2_ops_wait_prepare,
.wait_finish = vb2_ops_wait_finish,
.buf_prepare = mxc_jpeg_buf_prepare,
.buf_cleanup = mxc_jpeg_buf_clean,
.start_streaming = mxc_jpeg_start_streaming,
.stop_streaming = mxc_jpeg_stop_streaming,
.buf_queue = mxc_jpeg_buf_queue,
};
static int mxc_jpeg_queue_init(void *priv, struct vb2_queue *src_vq,
struct vb2_queue *dst_vq)
{
struct mxc_jpeg_ctx *ctx = priv;
int ret;
src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
src_vq->drv_priv = ctx;
src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
src_vq->ops = &mxc_jpeg_qops;
src_vq->mem_ops = &vb2_dma_contig_memops;
src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
src_vq->lock = &ctx->mxc_jpeg->lock;
src_vq->dev = ctx->mxc_jpeg->dev;
src_vq->allow_zero_bytesused = 1; /* keep old userspace apps working */
ret = vb2_queue_init(src_vq);
if (ret)
return ret;
dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
dst_vq->drv_priv = ctx;
dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
dst_vq->ops = &mxc_jpeg_qops;
dst_vq->mem_ops = &vb2_dma_contig_memops;
dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
dst_vq->lock = &ctx->mxc_jpeg->lock;
dst_vq->dev = ctx->mxc_jpeg->dev;
ret = vb2_queue_init(dst_vq);
return ret;
}
static int mxc_jpeg_alloc_slot_data(struct mxc_jpeg_dev *jpeg)
{
int slot;
for (slot = 0; slot < MXC_MAX_SLOTS; slot++) {
/* allocate descriptor for decoding/encoding phase */
jpeg->slot_data[slot].desc = dma_zalloc_coherent(jpeg->dev,
sizeof(struct mxc_jpeg_desc),
&(jpeg->slot_data[slot].desc_handle), 0);
if (!jpeg->slot_data[slot].desc)
goto err;
dev_dbg(jpeg->dev, "Descriptor for dec/enc: %p 0x%llx\n",
jpeg->slot_data[slot].desc,
jpeg->slot_data[slot].desc_handle);
/* allocate descriptor for configuration phase (encoder only) */
jpeg->slot_data[slot].cfg_desc = dma_zalloc_coherent(jpeg->dev,
sizeof(struct mxc_jpeg_desc),
&jpeg->slot_data[slot].cfg_desc_handle, 0);
if (!jpeg->slot_data[slot].cfg_desc)
goto err;
dev_dbg(jpeg->dev, "Descriptor for config phase: %p 0x%llx\n",
jpeg->slot_data[slot].cfg_desc,
jpeg->slot_data[slot].cfg_desc_handle);
/* allocate configuration stream */
jpeg->slot_data[slot].cfg_stream_vaddr = dma_zalloc_coherent(
jpeg->dev,
sizeof(hactbl),
&jpeg->slot_data[slot].cfg_stream_handle, 0);
if (!jpeg->slot_data[slot].cfg_stream_vaddr)
goto err;
dev_dbg(jpeg->dev, "Configuration stream: %p 0x%llx\n",
jpeg->slot_data[slot].cfg_stream_vaddr,
jpeg->slot_data[slot].cfg_stream_handle);
/* initial set-up for configuration stream
* TODO: fixup the sizes, currently harcoded to 64x64)
*/
memcpy(jpeg->slot_data[slot].cfg_stream_vaddr,
&hactbl, sizeof(hactbl));
}
return 0;
err:
dev_err(jpeg->dev, "Could not allocate descriptors\n");
return 1;
}
static int mxc_jpeg_free_slot_data(struct mxc_jpeg_dev *jpeg)
{
int slot;
for (slot = 0; slot < MXC_MAX_SLOTS; slot++) {
/* free descriptor for decoding/encoding phase */
dma_free_coherent(jpeg->dev, sizeof(struct mxc_jpeg_desc),
jpeg->slot_data[slot].desc,
jpeg->slot_data[slot].desc_handle);
/* free descriptor for configuration phase (encoder only) */
dma_free_coherent(jpeg->dev, sizeof(struct mxc_jpeg_desc),
jpeg->slot_data[slot].cfg_desc,
jpeg->slot_data[slot].cfg_desc_handle);
/* free configuration stream */
dma_free_coherent(jpeg->dev, sizeof(hactbl),
jpeg->slot_data[slot].cfg_stream_vaddr,
jpeg->slot_data[slot].cfg_stream_handle);
}
return 0;
}
static int mxc_jpeg_open(struct file *file)
{
struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file);
struct video_device *mxc_vfd = video_devdata(file);
struct mxc_jpeg_ctx *ctx;
struct mxc_jpeg_fmt *out_fmt, *cap_fmt;
int ret = 0;
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx)
return -ENOMEM;
if (mutex_lock_interruptible(&mxc_jpeg->lock)) {
ret = -ERESTARTSYS;
goto free;
}
pm_runtime_get_sync(mxc_jpeg->dev);
v4l2_fh_init(&ctx->fh, mxc_vfd);
file->private_data = &ctx->fh;
v4l2_fh_add(&ctx->fh);
ctx->mxc_jpeg = mxc_jpeg;
if (mxc_jpeg->mode == MXC_JPEG_ENCODE) {
ctx->mode = MXC_JPEG_ENCODE;
out_fmt = mxc_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB24);
cap_fmt = mxc_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG);
} else {
ctx->mode = MXC_JPEG_DECODE;
out_fmt = mxc_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG);
cap_fmt = mxc_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB24);
}
ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(mxc_jpeg->m2m_dev, ctx,
mxc_jpeg_queue_init);
ctx->out_q.fmt = out_fmt;
ctx->cap_q.fmt = cap_fmt;
if (IS_ERR(ctx->fh.m2m_ctx)) {
ret = PTR_ERR(ctx->fh.m2m_ctx);
goto error;
}
if (mxc_jpeg_alloc_slot_data(mxc_jpeg))
goto error;
mutex_unlock(&mxc_jpeg->lock);
return 0;
error:
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
mutex_unlock(&mxc_jpeg->lock);
free:
kfree(ctx);
return ret;
}
static int mxc_jpeg_querycap(struct file *file, void *priv,
struct v4l2_capability *cap)
{
struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file);
strlcpy(cap->driver, MXC_JPEG_NAME " decoder", sizeof(cap->driver));
strlcpy(cap->card, MXC_JPEG_NAME " decoder", sizeof(cap->card));
snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
dev_name(mxc_jpeg->dev));
cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
return 0;
}
static int mxc_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *f)
{
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
if (ctx->mode == MXC_JPEG_ENCODE)
return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f,
MXC_IN_FORMAT);
else
return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f,
MXC_OUT_FORMAT);
}
static int mxc_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
struct v4l2_fmtdesc *f)
{
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
if (ctx->mode == MXC_JPEG_DECODE)
return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f,
MXC_IN_FORMAT);
else
return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f,
MXC_OUT_FORMAT);
}
static int mxc_jpeg_bound_align_image(u32 *w, unsigned int wmin,
unsigned int wmax, unsigned int walign,
u32 *h, unsigned int hmin,
unsigned int hmax, unsigned int halign)
{
int width, height, w_step, h_step;
width = *w;
height = *h;
w_step = 1 << walign;
h_step = 1 << halign;
v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0);
if (*w < width && (*w + w_step) <= wmax)
*w += w_step;
if (*h < height && (*h + h_step) <= hmax)
*h += h_step;
return (width != *w || height != *h);
}
static int mxc_jpeg_try_fmt(struct v4l2_format *f, struct mxc_jpeg_fmt *fmt,
struct mxc_jpeg_ctx *ctx, int q_type)
{
struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[0];
u32 w = pix_mp->width;
u32 h = pix_mp->height;
unsigned int mode = ctx->mode;
memset(pix_mp->reserved, 0, sizeof(pix_mp->reserved));
pix_mp->field = V4L2_FIELD_NONE;
pix_mp->num_planes = fmt->colplanes;
pix_mp->pixelformat = fmt->fourcc;
mxc_jpeg_bound_align_image(&w,
MXC_JPEG_MIN_WIDTH,
MXC_JPEG_MAX_WIDTH,
MXC_JPEG_W_ALIGN,
&h,
MXC_JPEG_MIN_HEIGHT,
MXC_JPEG_MAX_HEIGHT,
MXC_JPEG_H_ALIGN);
memset(pfmt->reserved, 0, sizeof(pfmt->reserved));
/* TODO try_fmt should not modify the state, move to s_fmt */
if (q_type == MXC_JPEG_FMT_TYPE_ENC && mode == MXC_JPEG_DECODE) {
pfmt->bytesperline = 0;
/* Source size must be aligned to 128 */
pfmt->sizeimage = mxc_jpeg_align(pfmt->sizeimage, 128);
if (pfmt->sizeimage == 0)
pfmt->sizeimage = MXC_JPEG_DEFAULT_SIZEIMAGE;
} else if (q_type == MXC_JPEG_FMT_TYPE_RAW && mode == MXC_JPEG_DECODE) {
pfmt->bytesperline = w * (fmt->depth / 8);
pfmt->sizeimage = w * h * fmt->depth / 8;
} else if (q_type == MXC_JPEG_FMT_TYPE_ENC && mode == MXC_JPEG_ENCODE) {
pfmt->bytesperline = 0;
/* assuming worst jpeg compression */
pfmt->sizeimage = w * h * 6;
} else { /* MXC_JPEG_FMT_TYPE_RAW && MXC_JPEG_ENCODE */
pfmt->bytesperline = w * (fmt->depth / 8);
pfmt->sizeimage = w * h * fmt->depth / 8;
}
return 0;
}
static int mxc_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
struct device *dev = jpeg->dev;
struct mxc_jpeg_fmt *fmt;
u32 fourcc = f->fmt.pix_mp.pixelformat;
int q_type = (ctx->mode == MXC_JPEG_DECODE) ?
MXC_JPEG_FMT_TYPE_RAW : MXC_JPEG_FMT_TYPE_ENC;
fmt = mxc_jpeg_find_format(ctx, f->fmt.pix_mp.pixelformat);
if (!fmt || (fmt->flags != q_type)) {
char *format_name = fourcc_to_str(fourcc);
dev_err(dev, "Format not supported: %s.\n",
format_name);
kfree(format_name);
return -1;
}
return mxc_jpeg_try_fmt(f, fmt, ctx, q_type);
}
static int mxc_jpeg_try_fmt_vid_out(struct file *file, void *priv,
struct v4l2_format *f)
{
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
struct device *dev = jpeg->dev;
struct mxc_jpeg_fmt *fmt;
u32 fourcc = f->fmt.pix_mp.pixelformat;
int q_type = (ctx->mode == MXC_JPEG_ENCODE) ?
MXC_JPEG_FMT_TYPE_RAW : MXC_JPEG_FMT_TYPE_ENC;
fmt = mxc_jpeg_find_format(ctx, fourcc);
if (!fmt || (fmt->flags != q_type)) {
char *format_name = fourcc_to_str(fourcc);
dev_err(dev, "Format not supported: %s.\n",
format_name);
kfree(format_name);
return -1;
}
return mxc_jpeg_try_fmt(f, fmt, ctx, q_type);
}
static int mxc_jpeg_s_fmt(struct mxc_jpeg_ctx *ctx,
struct v4l2_format *f)
{
struct vb2_queue *vq;
struct mxc_jpeg_q_data *q_data = NULL;
struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
if (!vq)
return -EINVAL;
q_data = mxc_jpeg_get_q_data(ctx, f->type);
if (vb2_is_busy(vq)) {
v4l2_err(&jpeg->v4l2_dev, "queue busy\n");
return -EBUSY;
}
q_data->fmt = mxc_jpeg_find_format(ctx, pix_mp->pixelformat);
q_data->w = pix_mp->width;
q_data->h = pix_mp->height;
q_data->bytesperline[0] = pix_mp->plane_fmt[0].bytesperline;
q_data->sizeimage[0] = pix_mp->plane_fmt[0].sizeimage;
return 0;
}
static int mxc_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
int ret;
ret = mxc_jpeg_try_fmt_vid_cap(file, priv, f);
if (ret)
return ret;
return mxc_jpeg_s_fmt(mxc_jpeg_fh_to_ctx(priv), f);
}
static int mxc_jpeg_s_fmt_vid_out(struct file *file, void *priv,
struct v4l2_format *f)
{
int ret;
ret = mxc_jpeg_try_fmt_vid_out(file, priv, f);
if (ret)
return ret;
return mxc_jpeg_s_fmt(mxc_jpeg_fh_to_ctx(priv), f);
}
static int mxc_jpeg_g_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
struct v4l2_pix_format *pix = &f->fmt.pix;
struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, f->type);
pix->pixelformat = q_data->fmt->fourcc;
pix->width = q_data->w;
pix->height = q_data->h;
pix->field = V4L2_FIELD_NONE;
pix->colorspace = V4L2_COLORSPACE_REC709;
pix->bytesperline = q_data->stride;
pix->sizeimage = q_data->sizeimage[0];
return 0;
}
static int mxc_jpeg_g_fmt_vid_out(struct file *file, void *priv,
struct v4l2_format *f)
{
return 0;
}
static int mxc_jpeg_subscribe_event(struct v4l2_fh *fh,
const struct v4l2_event_subscription *sub)
{
switch (sub->type) {
case V4L2_EVENT_EOS:
return v4l2_event_subscribe(fh, sub, 0, NULL);
case V4L2_EVENT_SOURCE_CHANGE:
return v4l2_src_change_event_subscribe(fh, sub);
default:
return -EINVAL;
}
}
static int mxc_jpeg_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
{
struct v4l2_fh *fh = file->private_data;
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
struct device *dev = ctx->mxc_jpeg->dev;
struct vb2_queue *vq;
dev_dbg(dev, "QBUF type=%d, index=%d", buf->type, buf->index);
vq = v4l2_m2m_get_vq(fh->m2m_ctx, buf->type);
if (buf->index >= vq->num_buffers) {
dev_err(dev, "buffer index out of range\n");
return -EINVAL;
}
return v4l2_m2m_qbuf(file, fh->m2m_ctx, buf);
}
static int mxc_jpeg_dqbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
struct v4l2_fh *fh = file->private_data;
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
struct device *dev = ctx->mxc_jpeg->dev;
int num_src_ready = v4l2_m2m_num_src_bufs_ready(fh->m2m_ctx);
int ret;
dev_dbg(dev, "DQBUF type=%d, index=%d", buf->type, buf->index);
if (ctx->stopping == 1 && num_src_ready == 0) {
/* No more src bufs, notify app EOS */
notify_eos(ctx);
ctx->stopping = 0;
}
ret = v4l2_m2m_dqbuf(file, fh->m2m_ctx, buf);
buf->field = V4L2_FIELD_NONE;
return ret;
}
static const struct v4l2_ioctl_ops mxc_jpeg_ioctl_ops = {
.vidioc_querycap = mxc_jpeg_querycap,
.vidioc_enum_fmt_vid_cap = mxc_jpeg_enum_fmt_vid_cap,
.vidioc_enum_fmt_vid_out = mxc_jpeg_enum_fmt_vid_out,
.vidioc_try_fmt_vid_cap = mxc_jpeg_try_fmt_vid_cap,
.vidioc_try_fmt_vid_out = mxc_jpeg_try_fmt_vid_out,
.vidioc_s_fmt_vid_cap = mxc_jpeg_s_fmt_vid_cap,
.vidioc_s_fmt_vid_out = mxc_jpeg_s_fmt_vid_out,
.vidioc_g_fmt_vid_cap = mxc_jpeg_g_fmt_vid_cap,
.vidioc_g_fmt_vid_out = mxc_jpeg_g_fmt_vid_out,
.vidioc_subscribe_event = mxc_jpeg_subscribe_event,
.vidioc_decoder_cmd = mxc_jpeg_decoder_cmd,
.vidioc_qbuf = mxc_jpeg_qbuf,
.vidioc_dqbuf = mxc_jpeg_dqbuf,
.vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
.vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
.vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
.vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
.vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
.vidioc_streamon = v4l2_m2m_ioctl_streamon,
.vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
};
static int mxc_jpeg_release(struct file *file)
{
struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file);
struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(file->private_data);
mutex_lock(&mxc_jpeg->lock);
mxc_jpeg_free_slot_data(mxc_jpeg);
v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
kfree(ctx);
mutex_unlock(&mxc_jpeg->lock);
pm_runtime_put_sync(mxc_jpeg->dev);
return 0;
}
static const struct v4l2_file_operations mxc_jpeg_fops = {
.owner = THIS_MODULE,
.open = mxc_jpeg_open,
.release = mxc_jpeg_release,
.poll = v4l2_m2m_fop_poll,
.unlocked_ioctl = video_ioctl2,
.mmap = v4l2_m2m_fop_mmap,
};
static struct v4l2_m2m_ops mxc_jpeg_m2m_ops = {
.device_run = mxc_jpeg_device_run,
.job_ready = mxc_jpeg_job_ready,
.job_abort = mxc_jpeg_job_abort,
};
static int mxc_jpeg_probe(struct platform_device *pdev)
{
struct mxc_jpeg_dev *jpeg;
struct device *dev = &pdev->dev;
struct resource *res;
int dec_irq;
int ret;
int mode;
const struct of_device_id *of_id;
of_id = of_match_node(mxc_jpeg_match, dev->of_node);
mode = (int)(u64) of_id->data;
jpeg = devm_kzalloc(dev, sizeof(struct mxc_jpeg_dev), GFP_KERNEL);
if (!jpeg)
return -ENOMEM;
mutex_init(&jpeg->lock);
spin_lock_init(&jpeg->hw_lock);
if (dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32))) {
dev_err(&pdev->dev, "No suitable DMA available.\n");
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
dec_irq = platform_get_irq(pdev, 0);
if (!res || dec_irq < 0) {
dev_err(&pdev->dev, "Failed to get dec_irq %d.\n", dec_irq);
ret = -EINVAL;
goto err_irq;
}
ret = devm_request_irq(&pdev->dev, dec_irq, mxc_jpeg_dec_irq, 0,
pdev->name, jpeg);
if (ret) {
dev_err(&pdev->dev, "Failed to request dec_irq %d (%d)\n",
dec_irq, ret);
ret = -EINVAL;
goto err_irq;
}
jpeg->base_reg = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(jpeg->base_reg))
return PTR_ERR(jpeg->base_reg);
jpeg->pdev = pdev;
jpeg->dev = dev;
jpeg->mode = mode;
/* Start clock */
jpeg->clk_ipg = devm_clk_get(dev, "ipg");
if (IS_ERR(jpeg->clk_ipg)) {
dev_err(dev, "failed to get clock: ipg\n");
goto err_clk;
}
jpeg->clk_per = devm_clk_get(dev, "per");
if (IS_ERR(jpeg->clk_per)) {
dev_err(dev, "failed to get clock: per\n");
goto err_clk;
}
/* v4l2 */
ret = v4l2_device_register(dev, &jpeg->v4l2_dev);
if (ret) {
dev_err(dev, "failed to register v4l2 device\n");
goto err_register;
}
jpeg->m2m_dev = v4l2_m2m_init(&mxc_jpeg_m2m_ops);
if (IS_ERR(jpeg->m2m_dev)) {
dev_err(dev, "failed to register v4l2 device\n");
goto err_m2m;
}
jpeg->dec_vdev = video_device_alloc();
if (!jpeg->dec_vdev) {
dev_err(dev, "failed to register v4l2 device\n");
goto err_vdev_alloc;
}
if (mode == MXC_JPEG_ENCODE)
snprintf(jpeg->dec_vdev->name,
sizeof(jpeg->dec_vdev->name),
"%s-enc", MXC_JPEG_M2M_NAME);
else
snprintf(jpeg->dec_vdev->name,
sizeof(jpeg->dec_vdev->name),
"%s-dec", MXC_JPEG_M2M_NAME);
jpeg->dec_vdev->fops = &mxc_jpeg_fops;
jpeg->dec_vdev->ioctl_ops = &mxc_jpeg_ioctl_ops;
jpeg->dec_vdev->minor = -1;
jpeg->dec_vdev->release = video_device_release;
jpeg->dec_vdev->lock = &jpeg->lock; /* lock for ioctl serialization*/
jpeg->dec_vdev->v4l2_dev = &jpeg->v4l2_dev;
jpeg->dec_vdev->vfl_dir = VFL_DIR_M2M;
jpeg->dec_vdev->device_caps = V4L2_CAP_STREAMING |
V4L2_CAP_VIDEO_M2M;
ret = video_register_device(jpeg->dec_vdev, VFL_TYPE_GRABBER, -1);
if (ret) {
dev_err(dev, "failed to register video device\n");
goto err_vdev_register;
}
video_set_drvdata(jpeg->dec_vdev, jpeg);
if (mode == MXC_JPEG_ENCODE)
v4l2_info(&jpeg->v4l2_dev,
"encoder device registered as /dev/video%d (%d,%d)\n",
jpeg->dec_vdev->num, VIDEO_MAJOR,
jpeg->dec_vdev->minor);
else
v4l2_info(&jpeg->v4l2_dev,
"decoder device registered as /dev/video%d (%d,%d)\n",
jpeg->dec_vdev->num, VIDEO_MAJOR,
jpeg->dec_vdev->minor);
platform_set_drvdata(pdev, jpeg);
pm_runtime_enable(dev);
return 0;
err_vdev_register:
video_device_release(jpeg->dec_vdev);
err_vdev_alloc:
v4l2_m2m_release(jpeg->m2m_dev);
err_m2m:
v4l2_device_unregister(&jpeg->v4l2_dev);
err_register:
err_irq:
err_clk:
return ret;
}
#ifdef CONFIG_PM
static int mxc_jpeg_runtime_resume(struct device *dev)
{
struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev);
int ret;
ret = clk_prepare_enable(jpeg->clk_ipg);
if (ret < 0) {
dev_err(dev, "failed to enable clock: ipg\n");
goto err_clk;
}
ret = clk_prepare_enable(jpeg->clk_per);
if (ret < 0) {
dev_err(dev, "failed to enable clock: per\n");
goto err_clk;
}
return 0;
err_clk:
return ret;
}
static int mxc_jpeg_runtime_suspend(struct device *dev)
{
struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev);
clk_disable_unprepare(jpeg->clk_ipg);
clk_disable_unprepare(jpeg->clk_per);
return 0;
}
#endif
static const struct dev_pm_ops mxc_jpeg_pm_ops = {
SET_RUNTIME_PM_OPS(mxc_jpeg_runtime_suspend,
mxc_jpeg_runtime_resume, NULL)
};
static int mxc_jpeg_remove(struct platform_device *pdev)
{
struct mxc_jpeg_dev *jpeg = platform_get_drvdata(pdev);
pm_runtime_disable(&pdev->dev);
video_unregister_device(jpeg->dec_vdev);
video_device_release(jpeg->dec_vdev);
v4l2_m2m_release(jpeg->m2m_dev);
v4l2_device_unregister(&jpeg->v4l2_dev);
return 0;
}
MODULE_DEVICE_TABLE(of, mxc_jpeg_match);
static struct platform_driver mxc_jpeg_driver = {
.probe = mxc_jpeg_probe,
.remove = mxc_jpeg_remove,
.driver = {
.name = "mxc-jpeg",
.of_match_table = mxc_jpeg_match,
.pm = &mxc_jpeg_pm_ops,
},
};
module_platform_driver(mxc_jpeg_driver);
MODULE_LICENSE("GPL v2");