drivers/media/platform/mediatek/jpeg/mtk_jpeg_core.h - linux - Git at Google

 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * Copyright (c) 2016 MediaTek Inc.
  * Author: Ming Hsiu Tsai <minghsiu.tsai@mediatek.com>
  *         Rick Chang <rick.chang@mediatek.com>
  *         Xia Jiang <xia.jiang@mediatek.com>
  */

 #ifndef _MTK_JPEG_CORE_H
 #define _MTK_JPEG_CORE_H

 #include <linux/clk.h>
 #include <linux/interrupt.h>
 #include <media/v4l2-ctrls.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-fh.h>
 #include <media/videobuf2-v4l2.h>

 #include "mtk_jpeg_dec_hw.h"

 #define MTK_JPEG_NAME		"mtk-jpeg"

 #define MTK_JPEG_FMT_FLAG_OUTPUT	BIT(0)
 #define MTK_JPEG_FMT_FLAG_CAPTURE	BIT(1)

 #define MTK_JPEG_MIN_WIDTH	32U
 #define MTK_JPEG_MIN_HEIGHT	32U
 #define MTK_JPEG_MAX_WIDTH	65535U
 #define MTK_JPEG_MAX_HEIGHT	65535U

 #define MTK_JPEG_DEFAULT_SIZEIMAGE	(1 * 1024 * 1024)

 #define MTK_JPEG_HW_TIMEOUT_MSEC 1000

 #define MTK_JPEG_MAX_EXIF_SIZE	(64 * 1024)

 /**
  * enum mtk_jpeg_ctx_state - states of the context state machine
  * @MTK_JPEG_INIT:		current state is initialized
  * @MTK_JPEG_RUNNING:		current state is running
  * @MTK_JPEG_SOURCE_CHANGE:	current state is source resolution change
  */
 enum mtk_jpeg_ctx_state {
 	MTK_JPEG_INIT = 0,
 	MTK_JPEG_RUNNING,
 	MTK_JPEG_SOURCE_CHANGE,
 };

 /**
  * struct mtk_jpeg_variant - mtk jpeg driver variant
  * @clks:			clock names
  * @num_clks:			numbers of clock
  * @formats:			jpeg driver's internal color format
  * @num_formats:		number of formats
  * @qops:			the callback of jpeg vb2_ops
  * @irq_handler:		jpeg irq handler callback
  * @hw_reset:			jpeg hardware reset callback
  * @m2m_ops:			the callback of jpeg v4l2_m2m_ops
  * @dev_name:			jpeg device name
  * @ioctl_ops:			the callback of jpeg v4l2_ioctl_ops
  * @out_q_default_fourcc:	output queue default fourcc
  * @cap_q_default_fourcc:	capture queue default fourcc
  * @multi_core:		mark jpeg hw is multi_core or not
  * @jpeg_worker:		jpeg dec or enc worker
  */
 struct mtk_jpeg_variant {
 	struct clk_bulk_data *clks;
 	int num_clks;
 	struct mtk_jpeg_fmt *formats;
 	int num_formats;
 	const struct vb2_ops *qops;
 	irqreturn_t (*irq_handler)(int irq, void *priv);
 	void (*hw_reset)(void __iomem *base);
 	const struct v4l2_m2m_ops *m2m_ops;
 	const char *dev_name;
 	const struct v4l2_ioctl_ops *ioctl_ops;
 	u32 out_q_default_fourcc;
 	u32 cap_q_default_fourcc;
 	bool multi_core;
 	void (*jpeg_worker)(struct work_struct *work);
 };

 struct mtk_jpeg_src_buf {
 	u32 frame_num;
 	struct vb2_v4l2_buffer b;
 	struct list_head list;
 	u32 bs_size;
 	struct mtk_jpeg_dec_param dec_param;

 	struct mtk_jpeg_ctx *curr_ctx;
 };

 enum mtk_jpeg_hw_state {
 	MTK_JPEG_HW_IDLE = 0,
 	MTK_JPEG_HW_BUSY = 1,
 };

 struct mtk_jpeg_hw_param {
 	struct vb2_v4l2_buffer *src_buffer;
 	struct vb2_v4l2_buffer *dst_buffer;
 	struct mtk_jpeg_ctx *curr_ctx;
 };

 enum mtk_jpegenc_hw_id {
 	MTK_JPEGENC_HW0,
 	MTK_JPEGENC_HW1,
 	MTK_JPEGENC_HW_MAX,
 };

 enum mtk_jpegdec_hw_id {
 	MTK_JPEGDEC_HW0,
 	MTK_JPEGDEC_HW1,
 	MTK_JPEGDEC_HW2,
 	MTK_JPEGDEC_HW_MAX,
 };

 /**
  * struct mtk_jpegenc_clk - Structure used to store vcodec clock information
  * @clks:		JPEG encode clock
  * @clk_num:		JPEG encode clock numbers
  */
 struct mtk_jpegenc_clk {
 	struct clk_bulk_data *clks;
 	int clk_num;
 };

 /**
  * struct mtk_jpegdec_clk - Structure used to store vcodec clock information
  * @clks:		JPEG decode clock
  * @clk_num:		JPEG decode clock numbers
  */
 struct mtk_jpegdec_clk {
 	struct clk_bulk_data *clks;
 	int clk_num;
 };

 /**
  * struct mtk_jpegenc_comp_dev - JPEG COREX abstraction
  * @dev:		JPEG device
  * @plat_dev:		platform device data
  * @reg_base:		JPEG registers mapping
  * @master_dev:		mtk_jpeg_dev device
  * @venc_clk:		jpeg encode clock
  * @jpegenc_irq:	jpeg encode irq num
  * @job_timeout_work:	encode timeout workqueue
  * @hw_param:		jpeg encode hw parameters
  * @hw_state:		record hw state
  * @hw_lock:		spinlock protecting the hw device resource
  */
 struct mtk_jpegenc_comp_dev {
 	struct device *dev;
 	struct platform_device *plat_dev;
 	void __iomem *reg_base;
 	struct mtk_jpeg_dev *master_dev;
 	struct mtk_jpegenc_clk venc_clk;
 	int jpegenc_irq;
 	struct delayed_work job_timeout_work;
 	struct mtk_jpeg_hw_param hw_param;
 	enum mtk_jpeg_hw_state hw_state;
 	/* spinlock protecting the hw device resource */
 	spinlock_t hw_lock;
 };

 /**
  * struct mtk_jpegdec_comp_dev - JPEG COREX abstraction
  * @dev:			JPEG device
  * @plat_dev:			platform device data
  * @reg_base:			JPEG registers mapping
  * @master_dev:			mtk_jpeg_dev device
  * @jdec_clk:			mtk_jpegdec_clk
  * @jpegdec_irq:		jpeg decode irq num
  * @job_timeout_work:		decode timeout workqueue
  * @hw_param:			jpeg decode hw parameters
  * @hw_state:			record hw state
  * @hw_lock:			spinlock protecting hw
  */
 struct mtk_jpegdec_comp_dev {
 	struct device *dev;
 	struct platform_device *plat_dev;
 	void __iomem *reg_base;
 	struct mtk_jpeg_dev *master_dev;
 	struct mtk_jpegdec_clk jdec_clk;
 	int jpegdec_irq;
 	struct delayed_work job_timeout_work;
 	struct mtk_jpeg_hw_param hw_param;
 	enum mtk_jpeg_hw_state hw_state;
 	/* spinlock protecting the hw device resource */
 	spinlock_t hw_lock;
 };

 /**
  * struct mtk_jpeg_dev - JPEG IP abstraction
  * @lock:		the mutex protecting this structure
  * @hw_lock:		spinlock protecting the hw device resource
  * @workqueue:		decode work queue
  * @dev:		JPEG device
  * @v4l2_dev:		v4l2 device for mem2mem mode
  * @m2m_dev:		v4l2 mem2mem device data
  * @alloc_ctx:		videobuf2 memory allocator's context
  * @vdev:		video device node for jpeg mem2mem mode
  * @reg_base:		JPEG registers mapping
  * @job_timeout_work:	IRQ timeout structure
  * @variant:		driver variant to be used
  * @reg_encbase:	jpg encode register base addr
  * @enc_hw_dev:	jpg encode hardware device
  * @hw_wq:		jpg wait queue
  * @hw_rdy:		jpg hw ready flag
  * @reg_decbase:	jpg decode register base addr
  * @dec_hw_dev:	jpg decode hardware device
  * @hw_index:		jpg hw index
  */
 struct mtk_jpeg_dev {
 	struct mutex		lock;
 	spinlock_t		hw_lock;
 	struct workqueue_struct	*workqueue;
 	struct device		*dev;
 	struct v4l2_device	v4l2_dev;
 	struct v4l2_m2m_dev	*m2m_dev;
 	void			*alloc_ctx;
 	struct video_device	*vdev;
 	void __iomem		*reg_base;
 	struct delayed_work job_timeout_work;
 	const struct mtk_jpeg_variant *variant;

 	void __iomem *reg_encbase[MTK_JPEGENC_HW_MAX];
 	struct mtk_jpegenc_comp_dev *enc_hw_dev[MTK_JPEGENC_HW_MAX];
 	wait_queue_head_t hw_wq;
 	atomic_t hw_rdy;

 	void __iomem *reg_decbase[MTK_JPEGDEC_HW_MAX];
 	struct mtk_jpegdec_comp_dev *dec_hw_dev[MTK_JPEGDEC_HW_MAX];
 	atomic_t hw_index;
 };

 /**
  * struct mtk_jpeg_fmt - driver's internal color format data
  * @fourcc:	the fourcc code, 0 if not applicable
  * @hw_format:	hardware format value
  * @h_sample:	horizontal sample count of plane in 4 * 4 pixel image
  * @v_sample:	vertical sample count of plane in 4 * 4 pixel image
  * @colplanes:	number of color planes (1 for packed formats)
  * @h_align:	horizontal alignment order (align to 2^h_align)
  * @v_align:	vertical alignment order (align to 2^v_align)
  * @flags:	flags describing format applicability
  */
 struct mtk_jpeg_fmt {
 	u32	fourcc;
 	u32	hw_format;
 	int	h_sample[VIDEO_MAX_PLANES];
 	int	v_sample[VIDEO_MAX_PLANES];
 	int	colplanes;
 	int	h_align;
 	int	v_align;
 	u32	flags;
 };

 /**
  * struct mtk_jpeg_q_data - parameters of one queue
  * @fmt:	  driver-specific format of this queue
  * @pix_mp:	  multiplanar format
  * @enc_crop_rect:	jpeg encoder crop information
  */
 struct mtk_jpeg_q_data {
 	struct mtk_jpeg_fmt	*fmt;
 	struct v4l2_pix_format_mplane pix_mp;
 	struct v4l2_rect enc_crop_rect;
 };

 /**
  * struct mtk_jpeg_ctx - the device context data
  * @jpeg:			JPEG IP device for this context
  * @out_q:			source (output) queue information
  * @cap_q:			destination queue information
  * @fh:				V4L2 file handle
  * @state:			state of the context
  * @enable_exif:		enable exif mode of jpeg encoder
  * @enc_quality:		jpeg encoder quality
  * @restart_interval:		jpeg encoder restart interval
  * @ctrl_hdl:			controls handler
  * @jpeg_work:			jpeg encoder workqueue
  * @total_frame_num:		encoded frame number
  * @dst_done_queue:		encoded frame buffer queue
  * @done_queue_lock:		encoded frame operation spinlock
  * @last_done_frame_num:	the last encoded frame number
  */
 struct mtk_jpeg_ctx {
 	struct mtk_jpeg_dev		*jpeg;
 	struct mtk_jpeg_q_data		out_q;
 	struct mtk_jpeg_q_data		cap_q;
 	struct v4l2_fh			fh;
 	enum mtk_jpeg_ctx_state		state;
 	bool enable_exif;
 	u8 enc_quality;
 	u8 restart_interval;
 	struct v4l2_ctrl_handler ctrl_hdl;

 	struct work_struct jpeg_work;
 	u32 total_frame_num;
 	struct list_head dst_done_queue;
 	/* spinlock protecting the encode done buffer */
 	spinlock_t done_queue_lock;
 	u32 last_done_frame_num;
 };

 #endif /* _MTK_JPEG_CORE_H */
	/* SPDX-License-Identifier: GPL-2.0-only */
	/*
	* Copyright (c) 2016 MediaTek Inc.
	* Author: Ming Hsiu Tsai <minghsiu.tsai@mediatek.com>
	* Rick Chang <rick.chang@mediatek.com>
	* Xia Jiang <xia.jiang@mediatek.com>
	*/

	#ifndef _MTK_JPEG_CORE_H
	#define _MTK_JPEG_CORE_H

	#include <linux/clk.h>
	#include <linux/interrupt.h>
	#include <media/v4l2-ctrls.h>
	#include <media/v4l2-device.h>
	#include <media/v4l2-fh.h>
	#include <media/videobuf2-v4l2.h>

	#include "mtk_jpeg_dec_hw.h"

	#define MTK_JPEG_NAME "mtk-jpeg"

	#define MTK_JPEG_FMT_FLAG_OUTPUT BIT(0)
	#define MTK_JPEG_FMT_FLAG_CAPTURE BIT(1)

	#define MTK_JPEG_MIN_WIDTH 32U
	#define MTK_JPEG_MIN_HEIGHT 32U
	#define MTK_JPEG_MAX_WIDTH 65535U
	#define MTK_JPEG_MAX_HEIGHT 65535U

	#define MTK_JPEG_DEFAULT_SIZEIMAGE (1 * 1024 * 1024)

	#define MTK_JPEG_HW_TIMEOUT_MSEC 1000

	#define MTK_JPEG_MAX_EXIF_SIZE (64 * 1024)

	/**
	* enum mtk_jpeg_ctx_state - states of the context state machine
	* @MTK_JPEG_INIT: current state is initialized
	* @MTK_JPEG_RUNNING: current state is running
	* @MTK_JPEG_SOURCE_CHANGE: current state is source resolution change
	*/
	enum mtk_jpeg_ctx_state {
	MTK_JPEG_INIT = 0,
	MTK_JPEG_RUNNING,
	MTK_JPEG_SOURCE_CHANGE,
	};

	/**
	* struct mtk_jpeg_variant - mtk jpeg driver variant
	* @clks: clock names
	* @num_clks: numbers of clock
	* @formats: jpeg driver's internal color format
	* @num_formats: number of formats
	* @qops: the callback of jpeg vb2_ops
	* @irq_handler: jpeg irq handler callback
	* @hw_reset: jpeg hardware reset callback
	* @m2m_ops: the callback of jpeg v4l2_m2m_ops
	* @dev_name: jpeg device name
	* @ioctl_ops: the callback of jpeg v4l2_ioctl_ops
	* @out_q_default_fourcc: output queue default fourcc
	* @cap_q_default_fourcc: capture queue default fourcc
	* @multi_core: mark jpeg hw is multi_core or not
	* @jpeg_worker: jpeg dec or enc worker
	*/
	struct mtk_jpeg_variant {
	struct clk_bulk_data *clks;
	int num_clks;
	struct mtk_jpeg_fmt *formats;
	int num_formats;
	const struct vb2_ops *qops;
	irqreturn_t (irq_handler)(int irq, void priv);
	void (hw_reset)(void __iomem base);
	const struct v4l2_m2m_ops *m2m_ops;
	const char *dev_name;
	const struct v4l2_ioctl_ops *ioctl_ops;
	u32 out_q_default_fourcc;
	u32 cap_q_default_fourcc;
	bool multi_core;
	void (jpeg_worker)(struct work_struct work);
	};

	struct mtk_jpeg_src_buf {
	u32 frame_num;
	struct vb2_v4l2_buffer b;
	struct list_head list;
	u32 bs_size;
	struct mtk_jpeg_dec_param dec_param;

	struct mtk_jpeg_ctx *curr_ctx;
	};

	enum mtk_jpeg_hw_state {
	MTK_JPEG_HW_IDLE = 0,
	MTK_JPEG_HW_BUSY = 1,
	};

	struct mtk_jpeg_hw_param {
	struct vb2_v4l2_buffer *src_buffer;
	struct vb2_v4l2_buffer *dst_buffer;
	struct mtk_jpeg_ctx *curr_ctx;
	};

	enum mtk_jpegenc_hw_id {
	MTK_JPEGENC_HW0,
	MTK_JPEGENC_HW1,
	MTK_JPEGENC_HW_MAX,
	};

	enum mtk_jpegdec_hw_id {
	MTK_JPEGDEC_HW0,
	MTK_JPEGDEC_HW1,
	MTK_JPEGDEC_HW2,
	MTK_JPEGDEC_HW_MAX,
	};

	/**
	* struct mtk_jpegenc_clk - Structure used to store vcodec clock information
	* @clks: JPEG encode clock
	* @clk_num: JPEG encode clock numbers
	*/
	struct mtk_jpegenc_clk {
	struct clk_bulk_data *clks;
	int clk_num;
	};

	/**
	* struct mtk_jpegdec_clk - Structure used to store vcodec clock information
	* @clks: JPEG decode clock
	* @clk_num: JPEG decode clock numbers
	*/
	struct mtk_jpegdec_clk {
	struct clk_bulk_data *clks;
	int clk_num;
	};

	/**
	* struct mtk_jpegenc_comp_dev - JPEG COREX abstraction
	* @dev: JPEG device
	* @plat_dev: platform device data
	* @reg_base: JPEG registers mapping
	* @master_dev: mtk_jpeg_dev device
	* @venc_clk: jpeg encode clock
	* @jpegenc_irq: jpeg encode irq num
	* @job_timeout_work: encode timeout workqueue
	* @hw_param: jpeg encode hw parameters
	* @hw_state: record hw state
	* @hw_lock: spinlock protecting the hw device resource
	*/
	struct mtk_jpegenc_comp_dev {
	struct device *dev;
	struct platform_device *plat_dev;
	void __iomem *reg_base;
	struct mtk_jpeg_dev *master_dev;
	struct mtk_jpegenc_clk venc_clk;
	int jpegenc_irq;
	struct delayed_work job_timeout_work;
	struct mtk_jpeg_hw_param hw_param;
	enum mtk_jpeg_hw_state hw_state;
	/* spinlock protecting the hw device resource */
	spinlock_t hw_lock;
	};

	/**
	* struct mtk_jpegdec_comp_dev - JPEG COREX abstraction
	* @dev: JPEG device
	* @plat_dev: platform device data
	* @reg_base: JPEG registers mapping
	* @master_dev: mtk_jpeg_dev device
	* @jdec_clk: mtk_jpegdec_clk
	* @jpegdec_irq: jpeg decode irq num
	* @job_timeout_work: decode timeout workqueue
	* @hw_param: jpeg decode hw parameters
	* @hw_state: record hw state
	* @hw_lock: spinlock protecting hw
	*/
	struct mtk_jpegdec_comp_dev {
	struct device *dev;
	struct platform_device *plat_dev;
	void __iomem *reg_base;
	struct mtk_jpeg_dev *master_dev;
	struct mtk_jpegdec_clk jdec_clk;
	int jpegdec_irq;
	struct delayed_work job_timeout_work;
	struct mtk_jpeg_hw_param hw_param;
	enum mtk_jpeg_hw_state hw_state;
	/* spinlock protecting the hw device resource */
	spinlock_t hw_lock;
	};

	/**
	* struct mtk_jpeg_dev - JPEG IP abstraction
	* @lock: the mutex protecting this structure
	* @hw_lock: spinlock protecting the hw device resource
	* @workqueue: decode work queue
	* @dev: JPEG device
	* @v4l2_dev: v4l2 device for mem2mem mode
	* @m2m_dev: v4l2 mem2mem device data
	* @alloc_ctx: videobuf2 memory allocator's context
	* @vdev: video device node for jpeg mem2mem mode
	* @reg_base: JPEG registers mapping
	* @job_timeout_work: IRQ timeout structure
	* @variant: driver variant to be used
	* @reg_encbase: jpg encode register base addr
	* @enc_hw_dev: jpg encode hardware device
	* @hw_wq: jpg wait queue
	* @hw_rdy: jpg hw ready flag
	* @reg_decbase: jpg decode register base addr
	* @dec_hw_dev: jpg decode hardware device
	* @hw_index: jpg hw index
	*/
	struct mtk_jpeg_dev {
	struct mutex lock;
	spinlock_t hw_lock;
	struct workqueue_struct *workqueue;
	struct device *dev;
	struct v4l2_device v4l2_dev;
	struct v4l2_m2m_dev *m2m_dev;
	void *alloc_ctx;
	struct video_device *vdev;
	void __iomem *reg_base;
	struct delayed_work job_timeout_work;
	const struct mtk_jpeg_variant *variant;

	void __iomem *reg_encbase[MTK_JPEGENC_HW_MAX];
	struct mtk_jpegenc_comp_dev *enc_hw_dev[MTK_JPEGENC_HW_MAX];
	wait_queue_head_t hw_wq;
	atomic_t hw_rdy;

	void __iomem *reg_decbase[MTK_JPEGDEC_HW_MAX];
	struct mtk_jpegdec_comp_dev *dec_hw_dev[MTK_JPEGDEC_HW_MAX];
	atomic_t hw_index;
	};

	/**
	* struct mtk_jpeg_fmt - driver's internal color format data
	* @fourcc: the fourcc code, 0 if not applicable
	* @hw_format: hardware format value
	* @h_sample: horizontal sample count of plane in 4 * 4 pixel image
	* @v_sample: vertical sample count of plane in 4 * 4 pixel image
	* @colplanes: number of color planes (1 for packed formats)
	* @h_align: horizontal alignment order (align to 2^h_align)
	* @v_align: vertical alignment order (align to 2^v_align)
	* @flags: flags describing format applicability
	*/
	struct mtk_jpeg_fmt {
	u32 fourcc;
	u32 hw_format;
	int h_sample[VIDEO_MAX_PLANES];
	int v_sample[VIDEO_MAX_PLANES];
	int colplanes;
	int h_align;
	int v_align;
	u32 flags;
	};

	/**
	* struct mtk_jpeg_q_data - parameters of one queue
	* @fmt: driver-specific format of this queue
	* @pix_mp: multiplanar format
	* @enc_crop_rect: jpeg encoder crop information
	*/
	struct mtk_jpeg_q_data {
	struct mtk_jpeg_fmt *fmt;
	struct v4l2_pix_format_mplane pix_mp;
	struct v4l2_rect enc_crop_rect;
	};

	/**
	* struct mtk_jpeg_ctx - the device context data
	* @jpeg: JPEG IP device for this context
	* @out_q: source (output) queue information
	* @cap_q: destination queue information
	* @fh: V4L2 file handle
	* @state: state of the context
	* @enable_exif: enable exif mode of jpeg encoder
	* @enc_quality: jpeg encoder quality
	* @restart_interval: jpeg encoder restart interval
	* @ctrl_hdl: controls handler
	* @jpeg_work: jpeg encoder workqueue
	* @total_frame_num: encoded frame number
	* @dst_done_queue: encoded frame buffer queue
	* @done_queue_lock: encoded frame operation spinlock
	* @last_done_frame_num: the last encoded frame number
	*/
	struct mtk_jpeg_ctx {
	struct mtk_jpeg_dev *jpeg;
	struct mtk_jpeg_q_data out_q;
	struct mtk_jpeg_q_data cap_q;
	struct v4l2_fh fh;
	enum mtk_jpeg_ctx_state state;
	bool enable_exif;
	u8 enc_quality;
	u8 restart_interval;
	struct v4l2_ctrl_handler ctrl_hdl;

	struct work_struct jpeg_work;
	u32 total_frame_num;
	struct list_head dst_done_queue;
	/* spinlock protecting the encode done buffer */
	spinlock_t done_queue_lock;
	u32 last_done_frame_num;
	};

	#endif /* _MTK_JPEG_CORE_H */