// SPDX-License-Identifier: GPL-2.0 /* * V4L2 driver for the JPEG encoder/decoder from i.MX8QXP/i.MX8QM application * processors. * * The multi-planar buffers API is used. * * Baseline and extended sequential jpeg decoding is supported. * Progressive jpeg decoding is not supported by the IP. * Supports encode and decode of various formats: * YUV444, YUV422, YUV420, BGR, ABGR, Gray * YUV420 is the only multi-planar format supported. * Minimum resolution is 64 x 64, maximum 8192 x 8192. * To achieve 8192 x 8192, modify in defconfig: CONFIG_CMA_SIZE_MBYTES=320 * The alignment requirements for the resolution depend on the format, * multiple of 16 resolutions should work for all formats. * Special workarounds are made in the driver to support NV12 1080p. * When decoding, the driver detects image resolution and pixel format * from the jpeg stream, by parsing the jpeg markers. * * The IP has 4 slots available for context switching, but only slot 0 * was fully tested to work. Context switching is not used by the driver. * Each driver instance (context) allocates a slot for itself, but this * is postponed until device_run, to allow unlimited opens. * * The driver submits jobs to the IP by setting up a descriptor for the * used slot, and then validating it. The encoder has an additional descriptor * for the configuration phase. The driver expects FRM_DONE interrupt from * IP to mark the job as finished. * * The decoder IP has some limitations regarding the component ID's, * but the driver works around this by replacing them in the jpeg stream. * * A module parameter is available for debug purpose (jpeg_tracing), to enable * it, enable dynamic debug for this module and: * echo 1 > /sys/module/mxc_jpeg_encdec/parameters/jpeg_tracing * * This is inspired by the drivers/media/platform/samsung/s5p-jpeg driver * * Copyright 2018-2019 NXP #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/pm_domain.h>#include <linux/string.h>#include <media/v4l2-jpeg.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 const struct mxc_jpeg_fmt mxc_formats[] = {"JPEG" ,"BGR" , /*BGR packed format*/ "BGR 12bit" , /*12-bit BGR packed format*/ "ABGR" , /* ABGR packed format */ "ABGR 12bit" , /* 12-bit ABGR packed format */ "YUV420" , /* 1st plane = Y, 2nd plane = UV */ /* 6 bytes (4Y + UV) for 4 pixels */ /* 1 plane Y, 1 plane UV interleaved */ "YUV420" , /* 1st plane = Y, 2nd plane = UV */ /* 6 bytes (4Y + UV) for 4 pixels */ /* 1 plane Y, 1 plane UV interleaved */ "YUV420 12bit" , /* 1st plane = Y, 2nd plane = UV */ /* 6 x 12 bits (4Y + UV) for 4 pixels */ /* 1 plane Y, 1 plane UV interleaved */ "YUV420 12bit" , /* 1st plane = Y, 2nd plane = UV */ /* 6 x 12 bits (4Y + UV) for 4 pixels */ /* 1 plane Y, 1 plane UV interleaved */ "YUV422" , /* YUYV */ "YUV422 12bit" , /* YUYV */ "YUV444" , /* YUVYUV */ "YUV444 12bit" , /* YUVYUV */ "Gray" , /* Gray (Y8/Y12) or Single Comp */ "Gray 12bit" , /* Gray (Y8/Y12) or Single Comp */ #define MXC_JPEG_NUM_FORMATS ARRAY_SIZE(mxc_formats)static const int mxc_decode_mode = MXC_JPEG_DECODE;static const int mxc_encode_mode = MXC_JPEG_ENCODE;static const struct of_device_id mxc_jpeg_match[] = {"nxp,imx8qxp-jpgdec" ,"nxp,imx8qxp-jpgenc" ,/* * default configuration stream, 64x64 yuv422 * split by JPEG marker, so it's easier to modify & use static const unsigned char jpeg_soi[] = {static const unsigned char jpeg_app0[] = {static const unsigned char jpeg_app14[] = {static const unsigned char jpeg_dqt[] = {static const unsigned char jpeg_dqt_extseq[] = {static const unsigned char jpeg_sof_maximal[] = {static const unsigned char jpeg_sof_extseq[] = {static const unsigned char jpeg_dht[] = {static const unsigned char jpeg_dht_extseq[] = {static const unsigned char jpeg_dri[] = {static const unsigned char jpeg_sos_maximal[] = {static const unsigned char jpeg_image_red[] = {static const unsigned char jpeg_eoi[] = {struct mxc_jpeg_src_buf {/* common v4l buffer stuff -- must be first */ struct vb2_v4l2_buffer b;struct list_head list;/* mxc-jpeg specific */ bool dht_needed;bool jpeg_parse_error;const struct mxc_jpeg_fmt *fmt;int w;int h;static inline struct mxc_jpeg_src_buf *vb2_to_mxc_buf(struct vb2_buffer *vb)return container_of(to_vb2_v4l2_buffer(vb),struct mxc_jpeg_src_buf, b);static unsigned int debug;int , 0644);"Debug level (0-3)" );static unsigned int hw_timeout = 2000;int , 0644);"MXC JPEG hw timeout, the number of milliseconds" );static void mxc_jpeg_bytesperline(struct mxc_jpeg_q_data *q, u32 precision);static void mxc_jpeg_sizeimage(struct mxc_jpeg_q_data *q);static void _bswap16(u16 *a)static dma_addr_t mxc_jpeg_get_plane_dma_addr(struct vb2_buffer *buf, unsigned int plane_no)if (plane_no >= buf->num_planes)return 0;return vb2_dma_contig_plane_dma_addr(buf, plane_no) + buf->planes[plane_no].data_offset;static void *mxc_jpeg_get_plane_vaddr(struct vb2_buffer *buf, unsigned int plane_no)if (plane_no >= buf->num_planes)return NULL;return vb2_plane_vaddr(buf, plane_no) + buf->planes[plane_no].data_offset;static unsigned long mxc_jpeg_get_plane_payload(struct vb2_buffer *buf, unsigned int plane_no)if (plane_no >= buf->num_planes)return 0;return vb2_get_plane_payload(buf, plane_no) - buf->planes[plane_no].data_offset;static void print_mxc_buf(struct mxc_jpeg_dev *jpeg, struct vb2_buffer *buf,unsigned long len)unsigned int plane_no;void *vaddr;unsigned long payload;if (debug < 3)return ;for (plane_no = 0; plane_no < buf->num_planes; plane_no++) {if (len == 0)"plane %d (vaddr=%p dma_addr=%x payload=%ld):" ,"" , DUMP_PREFIX_OFFSET, 32, 1,false );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(const 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 searched type found ? */ if (num == f->index)break ;/* Correct type but haven't reached our index yet, * just increment per-type index /* Format not found */ if (i >= n)return -EINVAL;return 0;static const struct mxc_jpeg_fmt *mxc_jpeg_find_format(u32 pixelformat)unsigned int k;for (k = 0; k < MXC_JPEG_NUM_FORMATS; k++) {const 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:case V4L2_PIX_FMT_Y012:return MXC_JPEG_GRAY;case V4L2_PIX_FMT_YUYV:case V4L2_PIX_FMT_Y212:return MXC_JPEG_YUV422;case V4L2_PIX_FMT_NV12:case V4L2_PIX_FMT_NV12M:case V4L2_PIX_FMT_P012:case V4L2_PIX_FMT_P012M:return MXC_JPEG_YUV420;case V4L2_PIX_FMT_YUV24:case V4L2_PIX_FMT_YUV48_12:return MXC_JPEG_YUV444;case V4L2_PIX_FMT_BGR24:case V4L2_PIX_FMT_BGR48_12:return MXC_JPEG_BGR;case V4L2_PIX_FMT_ABGR32:case V4L2_PIX_FMT_ABGR64_12:return MXC_JPEG_ABGR;default :return MXC_JPEG_INVALID;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 *raw_buf,struct vb2_buffer *jpeg_buf, int offset)int img_fmt = desc->stm_ctrl & STM_CTRL_IMAGE_FORMAT_MASK;struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(raw_buf->vb2_queue);struct mxc_jpeg_q_data *q_data;if (img_fmt == STM_CTRL_IMAGE_FORMAT(MXC_JPEG_YUV420)) {if (raw_buf->num_planes == 2)else static bool mxc_jpeg_is_extended_sequential(const struct mxc_jpeg_fmt *fmt)if (!fmt || !(fmt->flags & MXC_JPEG_FMT_TYPE_RAW))return false ;if (fmt->precision > 8)return true ;return false ;static void notify_eos(struct mxc_jpeg_ctx *ctx)const struct v4l2_event ev = {"Notify app event EOS reached" );static void notify_src_chg(struct mxc_jpeg_ctx *ctx)const struct v4l2_event ev = {"Notify app event SRC_CH_RESOLUTION" );static int mxc_get_free_slot(struct mxc_jpeg_slot_data *slot_data)if (!slot_data->used)return slot_data->slot;return -1;static void mxc_jpeg_free_slot_data(struct mxc_jpeg_dev *jpeg)/* free descriptor for decoding/encoding phase */ sizeof (struct mxc_jpeg_desc),/* free descriptor for encoder configuration phase / decoder DHT */ sizeof (struct mxc_jpeg_desc),/* free configuration stream */ false ;static bool mxc_jpeg_alloc_slot_data(struct mxc_jpeg_dev *jpeg)struct mxc_jpeg_desc *desc;struct mxc_jpeg_desc *cfg_desc;void *cfg_stm;if (jpeg->slot_data.desc)goto skip_alloc; /* already allocated, reuse it */ /* allocate descriptor for decoding/encoding phase */ sizeof (struct mxc_jpeg_desc),if (!desc)goto err;/* allocate descriptor for configuration phase (encoder only) */ sizeof (struct mxc_jpeg_desc),if (!cfg_desc)goto err;/* allocate configuration stream */ if (!cfg_stm)goto err;if (!jpeg->slot_data.cfg_dec_vaddr)goto err;true ;return true ;"Could not allocate descriptors for slot %d" , jpeg->slot_data.slot);return false ;static void mxc_jpeg_check_and_set_last_buffer(struct mxc_jpeg_ctx *ctx,struct vb2_v4l2_buffer *src_buf,struct vb2_v4l2_buffer *dst_buf)if (v4l2_m2m_is_last_draining_src_buf(ctx->fh.m2m_ctx, src_buf)) {false ;static void mxc_jpeg_job_finish(struct mxc_jpeg_ctx *ctx, enum vb2_buffer_state state, bool reset)struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;void __iomem *reg = jpeg->base_reg;struct vb2_v4l2_buffer *src_buf, *dst_buf;false ;if (reset)static u32 mxc_jpeg_get_plane_size(struct mxc_jpeg_q_data *q_data, u32 plane_no)const struct mxc_jpeg_fmt *fmt = q_data->fmt;int i;if (plane_no >= fmt->mem_planes)return 0;if (fmt->mem_planes == fmt->comp_planes)return q_data->sizeimage[plane_no];if (plane_no < fmt->mem_planes - 1)return q_data->sizeimage[plane_no];/* Should be impossible given mxc_formats. */ if (WARN_ON_ONCE(fmt->comp_planes > ARRAY_SIZE(q_data->sizeimage)))return size;for (i = fmt->mem_planes; i < fmt->comp_planes; i++)return size;static bool mxc_dec_is_ongoing(struct mxc_jpeg_ctx *ctx)struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;if (curr_desc == jpeg->slot_data.cfg_desc_handle)return true ;if (slot_status & SLOT_STATUS_ONGOING)return true ;/* * The curr_desc register is updated when next_descpt_ptr is loaded, * the ongoing bit of slot_status is set when the 32 bytes descriptor is loaded. * So there will be a short time interval in between, which may cause fake false. * Consider read register is quite slow compared with IP read 32byte from memory, * read twice slot_status can avoid this situation. if (slot_status & SLOT_STATUS_ONGOING)return true ;return false ;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_v4l2_buffer *src_buf, *dst_buf;struct mxc_jpeg_src_buf *jpeg_src_buf;enum vb2_buffer_state buf_state;unsigned long payload;struct mxc_jpeg_q_data *q_data;enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;unsigned int slot;"Irq %d on slot %d.\n" , irq, slot);if (WARN_ON(!ctx))goto job_unlock;if (slot != ctx->slot) {/* TODO investigate when adding multi-instance support */ "IRQ slot %d != context slot %d.\n" ,goto job_unlock;if (!jpeg->slot_data.used)goto job_unlock;/* w1c */ if (!dst_buf || !src_buf) {"No source or destination buffer.\n" );goto job_unlock;if (dec_ret & SLOT_STATUS_ENC_CONFIG_ERR) {"Encoder/decoder error, dec_ret = 0x%08x, status=0x%08x" ,goto buffers_done;if (!(dec_ret & SLOT_STATUS_FRMDONE))goto job_unlock;if (jpeg->mode == MXC_JPEG_ENCODE &&"Encoder config finished. Start encoding...\n" );goto job_unlock;if (jpeg->mode == MXC_JPEG_DECODE && jpeg_src_buf->dht_needed &&false ;"Decoder DHT cfg finished. Start decoding...\n" );goto job_unlock;if (jpeg->mode == MXC_JPEG_ENCODE) {"Encoding finished, payload size: %ld\n" ,else {if (q_data->fmt->mem_planes == 2) {"Decoding finished, payload size: %ld + %ld\n" ,/* short preview of the results */ "src_buf preview: " );"dst_buf preview: " );false );return IRQ_HANDLED;return IRQ_HANDLED;static int mxc_jpeg_fixup_sof(struct mxc_jpeg_sof *sof,int sof_length;const struct mxc_jpeg_fmt *fmt = mxc_jpeg_find_format(fourcc);if (fmt)else /* TODO allow 8/12 bit precision*/ switch (fourcc) {case V4L2_PIX_FMT_NV12:case V4L2_PIX_FMT_NV12M:case V4L2_PIX_FMT_P012:case V4L2_PIX_FMT_P012M:break ;case V4L2_PIX_FMT_YUYV:case V4L2_PIX_FMT_Y212:break ;case V4L2_PIX_FMT_YUV24:case V4L2_PIX_FMT_YUV48_12:case V4L2_PIX_FMT_BGR24:case V4L2_PIX_FMT_BGR48_12:default :break ;case V4L2_PIX_FMT_ABGR32:case V4L2_PIX_FMT_ABGR64_12:break ;case V4L2_PIX_FMT_GREY:case V4L2_PIX_FMT_Y012:break ;return sof_length; /* not swaped */ static int mxc_jpeg_fixup_sos(struct mxc_jpeg_sos *sos,int sos_length;switch (fourcc) {case V4L2_PIX_FMT_NV12:case V4L2_PIX_FMT_NV12M:case V4L2_PIX_FMT_P012:case V4L2_PIX_FMT_P012M:break ;case V4L2_PIX_FMT_YUYV:case V4L2_PIX_FMT_Y212:break ;case V4L2_PIX_FMT_YUV24:case V4L2_PIX_FMT_YUV48_12:case V4L2_PIX_FMT_BGR24:case V4L2_PIX_FMT_BGR48_12:default :break ;case V4L2_PIX_FMT_ABGR32:case V4L2_PIX_FMT_ABGR64_12:break ;case V4L2_PIX_FMT_GREY:case V4L2_PIX_FMT_Y012:break ;/* SOS ignorable bytes, not so ignorable after all */ return sos_length; /* not swaped */ static unsigned int mxc_jpeg_setup_cfg_stream(void *cfg_stream_vaddr,/* * There is a hardware issue that first 128 bytes of configuration data * can't be loaded correctly. * To avoid this issue, we need to write the configuration from * an offset which should be no less than 0x80 (128 bytes). unsigned int offset = 0x80;struct mxc_jpeg_sof *sof;struct mxc_jpeg_sos *sos;const struct mxc_jpeg_fmt *fmt = mxc_jpeg_find_format(fourcc);if (!fmt)return 0;if (fmt->is_rgb) {sizeof (jpeg_app14));sizeof (jpeg_app14);else {sizeof (jpeg_app0));sizeof (jpeg_app0);if (mxc_jpeg_is_extended_sequential(fmt)) {sizeof (jpeg_dqt_extseq));sizeof (jpeg_dqt_extseq);sizeof (jpeg_sof_extseq));else {sizeof (jpeg_dqt));sizeof (jpeg_dqt);sizeof (jpeg_sof_maximal));/* skip marker ID */ struct mxc_jpeg_sof *)(cfg + offset);if (mxc_jpeg_is_extended_sequential(fmt)) {sizeof (jpeg_dht_extseq));sizeof (jpeg_dht_extseq);else {sizeof (jpeg_dht));sizeof (jpeg_dht);sizeof (jpeg_dri));sizeof (jpeg_dri);sizeof (jpeg_sos_maximal));/* skip marker ID */ struct mxc_jpeg_sos *)(cfg + offset);sizeof (jpeg_image_red));sizeof (jpeg_image_red);sizeof (jpeg_eoi));sizeof (jpeg_eoi);return offset;static void mxc_jpeg_config_dec_desc(struct vb2_buffer *out_buf,struct mxc_jpeg_ctx *ctx,struct vb2_buffer *src_buf,struct vb2_buffer *dst_buf)enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;struct mxc_jpeg_q_data *q_data_cap;enum mxc_jpeg_image_format img_fmt;struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;void __iomem *reg = jpeg->base_reg;unsigned int slot = ctx->slot;struct mxc_jpeg_desc *desc = jpeg->slot_data.desc;struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data.cfg_desc;unsigned int *cfg_size = &jpeg->slot_data.cfg_stream_size;void *cfg_stream_vaddr = jpeg->slot_data.cfg_stream_vaddr;struct mxc_jpeg_src_buf *jpeg_src_buf;/* setup the decoding descriptor */ /* end of chain */ /* clear image format */ if (mxc_jpeg_is_extended_sequential(jpeg_src_buf->fmt))else if (!jpeg_src_buf->dht_needed) {/* validate the decoding descriptor */ return ;/* * if a default huffman table is needed, use the config descriptor to * inject a DHT, by chaining it before the decoding descriptor /* validate the configuration descriptor */ static void mxc_jpeg_config_enc_desc(struct vb2_buffer *out_buf,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;unsigned int slot = ctx->slot;struct mxc_jpeg_desc *desc = jpeg->slot_data.desc;struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data.cfg_desc;void *cfg_stream_vaddr = jpeg->slot_data.cfg_stream_vaddr;struct mxc_jpeg_q_data *q_data;enum mxc_jpeg_image_format img_fmt;int w, h;/* chain the config descriptor with the encoding descriptor */ /* no output expected */ /* end of chain */ /* use adjusted resolution for CAST IP job */ if (img_fmt == MXC_JPEG_INVALID)"No valid image format detected\n" );if (mxc_jpeg_is_extended_sequential(q_data->fmt))else "cfg_desc:\n" );"enc desc:\n" );/* validate the configuration descriptor */ static const struct mxc_jpeg_fmt *mxc_jpeg_get_sibling_format(const struct mxc_jpeg_fmt *fmt)int i;for (i = 0; i < MXC_JPEG_NUM_FORMATS; i++) {if (mxc_formats[i].subsampling == fmt->subsampling &&return &mxc_formats[i];return NULL;static bool mxc_jpeg_compare_format(const struct mxc_jpeg_fmt *fmt1,const struct mxc_jpeg_fmt *fmt2)if (fmt1 == fmt2)return true ;if (mxc_jpeg_get_sibling_format(fmt1) == fmt2)return true ;return false ;static void mxc_jpeg_set_last_buffer(struct mxc_jpeg_ctx *ctx)struct vb2_v4l2_buffer *next_dst_buf;if (!next_dst_buf) {true ;true ;return ;static bool mxc_jpeg_source_change(struct mxc_jpeg_ctx *ctx,struct mxc_jpeg_src_buf *jpeg_src_buf)struct device *dev = ctx->mxc_jpeg->dev;struct mxc_jpeg_q_data *q_data_cap;if (!jpeg_src_buf->fmt)return false ;if (mxc_jpeg_compare_format(q_data_cap->fmt, jpeg_src_buf->fmt))if (ctx->need_initial_source_change_evt ||"Detected jpeg res=(%dx%d)->(%dx%d), pixfmt=%c%c%c%c\n" ,/* * set-up the capture queue with the pixelformat and resolution * detected from the jpeg output stream /* * align up the resolution for CAST IP, * but leave the buffer resolution unchanged /* adjust up */ /* adjust up */ /* setup bytesperline/sizeimage for capture queue */ false ;if (vb2_is_streaming(v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx)))return ctx->source_change ? true : false ;static int mxc_jpeg_job_ready(void *priv)struct mxc_jpeg_ctx *ctx = priv;return ctx->source_change ? 0 : 1;static void mxc_jpeg_device_run_timeout(struct work_struct *work)struct delayed_work *dwork = to_delayed_work(work);struct mxc_jpeg_ctx *ctx = container_of(dwork, struct mxc_jpeg_ctx, task_timer);struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;unsigned long flags;if (ctx->mxc_jpeg->slot_data.used) {"%s timeout, cancel it\n" ,"decode" : "encode" );true );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_v4l2_buffer *src_buf, *dst_buf;unsigned long flags;struct mxc_jpeg_q_data *q_data_cap, *q_data_out;struct mxc_jpeg_src_buf *jpeg_src_buf;if (!src_buf || !dst_buf) {"Null src or dst buf\n" );goto end;if (!q_data_cap)goto end;if (!q_data_out)goto end;true );if (q_data_cap->fmt->mem_planes != dst_buf->vb2_buf.num_planes) {"Capture format %s has %d planes, but capture buffer has %d planes\n" ,true ;if (jpeg_src_buf->jpeg_parse_error) {return ;if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) {if (ctx->source_change || mxc_jpeg_source_change(ctx, jpeg_src_buf)) {return ;if (ctx->slot < 0) {"No more free slots\n" );goto end;if (!mxc_jpeg_alloc_slot_data(jpeg)) {"Cannot allocate slot data\n" );goto end;if (jpeg->mode == MXC_JPEG_ENCODE) {"Encoding on slot %d\n" , ctx->slot);/* start config phase */ else {"Decoding on slot %d\n" , ctx->slot);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);unsigned long flags;int ret;if (ret < 0)return ret;if (!vb2_is_streaming(v4l2_m2m_get_src_vq(fh->m2m_ctx)))return 0;if (ret < 0)return ret;if (cmd->cmd == V4L2_DEC_CMD_STOP &&false ;if (cmd->cmd == V4L2_DEC_CMD_START &&return 0;static int mxc_jpeg_encoder_cmd(struct file *file, void *priv,struct v4l2_encoder_cmd *cmd)struct v4l2_fh *fh = file->private_data;struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);unsigned long flags;int ret;if (ret < 0)return ret;if (!vb2_is_streaming(v4l2_m2m_get_src_vq(fh->m2m_ctx)) ||return 0;if (ret < 0)return 0;if (cmd->cmd == V4L2_ENC_CMD_STOP &&if (cmd->cmd == V4L2_ENC_CMD_START &&return 0;static int mxc_jpeg_queue_setup(struct vb2_queue *q,unsigned int *nbuffers,unsigned int *nplanes,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;int i;if (!q_data)return -EINVAL;/* Handle CREATE_BUFS situation - *nplanes != 0 */ if (*nplanes) {if (*nplanes != q_data->fmt->mem_planes)return -EINVAL;for (i = 0; i < *nplanes; i++) {if (sizes[i] < mxc_jpeg_get_plane_size(q_data, i))return -EINVAL;return 0;/* Handle REQBUFS situation */ for (i = 0; i < *nplanes; i++)if (V4L2_TYPE_IS_OUTPUT(q->type))true ;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);struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, q->type);int ret;if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE && V4L2_TYPE_IS_CAPTURE(q->type))"Start streaming ctx=%p" , ctx);if (V4L2_TYPE_IS_CAPTURE(q->type))false ;if (ret < 0) {"Failed to power up jpeg\n" );return ret;return 0;static void mxc_jpeg_stop_streaming(struct vb2_queue *q)struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);struct vb2_v4l2_buffer *vbuf;"Stop streaming ctx=%p" , ctx);/* Release all active buffers */ for (;;) {if (V4L2_TYPE_IS_OUTPUT(q->type))else if (!vbuf)break ;/* if V4L2_DEC_CMD_STOP is sent before the source change triggered, * restore the is_draining flag if (V4L2_TYPE_IS_CAPTURE(q->type) && ctx->source_change && ctx->fh.m2m_ctx->last_src_buf)true ;if (V4L2_TYPE_IS_OUTPUT(q->type) &&false ;static int mxc_jpeg_valid_comp_id(struct device *dev,struct mxc_jpeg_sof *sof,struct mxc_jpeg_sos *sos)int valid = 1;int i;/* * there's a limitation in the IP that the component IDs must be * between 0..4, if they are not, let's patch them for (i = 0; i < sof->components_no; i++)if (sof->comp[i].id > MXC_JPEG_MAX_COMPONENTS) {"Component %d has invalid ID: %d" ,if (!valid)/* patch all comp IDs if at least one is invalid */ for (i = 0; i < sof->components_no; i++) {"Component %d ID patched to: %d" ,return valid;static bool mxc_jpeg_match_image_format(const struct mxc_jpeg_fmt *fmt,const struct v4l2_jpeg_header *header)if (fmt->subsampling != header->frame.subsampling ||return false ;/* * If the transform flag from APP14 marker is 0, images that are * encoded with 3 components have RGB colorspace, see Recommendation * ITU-T T.872 chapter 6.5.3 APP14 marker segment for colour encoding if (header->frame.subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_444) {if (is_rgb != fmt->is_rgb)return false ;return true ;static u32 mxc_jpeg_get_image_format(struct device *dev,const struct v4l2_jpeg_header *header)int i;for (i = 0; i < MXC_JPEG_NUM_FORMATS; i++) {if (mxc_jpeg_match_image_format(&mxc_formats[i], header)) {break ;if (fourcc == 0) {"Could not identify image format nc=%d, subsampling=%d, precision=%d\n" ,return fourcc;return fourcc;static void mxc_jpeg_bytesperline(struct mxc_jpeg_q_data *q, u32 precision)/*imx-jpeg only support the same line pitch*/ /* Bytes distance between the leftmost pixels in two adjacent lines */ if (q->fmt->fourcc == V4L2_PIX_FMT_JPEG) {/* bytesperline unused for compressed formats */ else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420) {/* When the image format is planar the bytesperline value * applies to the first plane and is divided by the same factor * as the width field for the other planes else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_422) {else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_444) {else {/* grayscale */ if (q->fmt->fourcc != V4L2_PIX_FMT_JPEG) {if (q->fmt->mem_planes > 1)static void mxc_jpeg_sizeimage(struct mxc_jpeg_q_data *q)if (q->fmt->fourcc == V4L2_PIX_FMT_JPEG) {/* if no sizeimage from user, assume worst jpeg compression */ if (!q->sizeimage[0])if (q->sizeimage[0] > MXC_JPEG_MAX_SIZEIMAGE)/* jpeg stream size must be multiple of 1K */ else {if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420)static int mxc_jpeg_parse(struct mxc_jpeg_ctx *ctx, struct vb2_buffer *vb)struct device *dev = ctx->mxc_jpeg->dev;struct mxc_jpeg_q_data *q_data_out;struct mxc_jpeg_q_data *q_data_cap;struct v4l2_jpeg_header header;struct mxc_jpeg_sof *psof = NULL;struct mxc_jpeg_sos *psos = NULL;struct mxc_jpeg_src_buf *jpeg_src_buf = vb2_to_mxc_buf(vb);int ret;sizeof (header));void *)src_addr, size, &header);if (ret < 0) {"Error parsing JPEG stream markers\n" );return ret;/* if DHT marker present, no need to inject default one */ if (header.frame.width > MXC_JPEG_MAX_WIDTH ||"JPEG width or height should be <= 8192: %dx%d\n" ,return -EINVAL;if (header.frame.width < MXC_JPEG_MIN_WIDTH ||"JPEG width or height should be > 64: %dx%d\n" ,return -EINVAL;if (header.frame.num_components > V4L2_JPEG_MAX_COMPONENTS) {"JPEG number of components should be <=%d" ,return -EINVAL;/* check and, if necessary, patch component IDs*/ struct mxc_jpeg_sof *)header.sof.start;struct mxc_jpeg_sos *)header.sos.start;if (!mxc_jpeg_valid_comp_id(dev, psof, psos))"JPEG component ids should be 0-3 or 1-4" );if (q_data_cap->fmt && mxc_jpeg_match_image_format(q_data_cap->fmt, &header))else if (fourcc == 0)return -EINVAL;true ;if (!v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx))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);struct mxc_jpeg_src_buf *jpeg_src_buf;if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type) &&struct mxc_jpeg_q_data *q_data;false ;return ;if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)goto end;/* for V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE */ if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE)goto end;false ;if (ret) {true ;/* * if the capture queue is not setup, the device_run() won't be scheduled, * need to drop the error buffer, so that the decoding can continue if (!vb2_is_streaming(v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx))) {return ;static int mxc_jpeg_buf_out_validate(struct vb2_buffer *vb)struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);return 0;static int mxc_jpeg_buf_prepare(struct vb2_buffer *vb)struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);struct mxc_jpeg_q_data *q_data = NULL;struct device *dev = ctx->mxc_jpeg->dev;unsigned long sizeimage;int i;if (!q_data)return -EINVAL;for (i = 0; i < q_data->fmt->mem_planes; i++) {if (!ctx->source_change && vb2_plane_size(vb, i) < sizeimage) {"plane %d too small (%lu < %lu)" ,return -EINVAL;if (!IS_ALIGNED(mxc_jpeg_get_plane_dma_addr(vb, i), MXC_JPEG_ADDR_ALIGNMENT)) {"planes[%d] address is not %d aligned\n" ,return -EINVAL;if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type)) {return 0;static const struct vb2_ops mxc_jpeg_qops = {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;sizeof (struct mxc_jpeg_src_buf);if (ret)return ret;sizeof (struct v4l2_m2m_buffer);return ret;static void mxc_jpeg_set_default_params(struct mxc_jpeg_ctx *ctx)struct mxc_jpeg_q_data *out_q = &ctx->out_q;struct mxc_jpeg_q_data *cap_q = &ctx->cap_q;struct mxc_jpeg_q_data *q[2] = {out_q, cap_q};int i;if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE) {else {for (i = 0; i < 2; i++) {static int mxc_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)struct mxc_jpeg_ctx *ctx =struct mxc_jpeg_ctx, ctrl_handler);switch (ctrl->id) {case V4L2_CID_JPEG_COMPRESSION_QUALITY:break ;default :
Messung V0.5 C=95 H=91 G=92
¤ Dauer der Verarbeitung: 0.28 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
