[mirror_ubuntu-artful-kernel.git] / drivers / media / i2c / m5mols / m5mols.h

/*
 * Header for M-5MOLS 8M Pixel camera sensor with ISP
 *
 * Copyright (C) 2011 Samsung Electronics Co., Ltd.
 * Author: HeungJun Kim <riverful.kim@samsung.com>
 *
 * Copyright (C) 2009 Samsung Electronics Co., Ltd.
 * Author: Dongsoo Nathaniel Kim <dongsoo45.kim@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#ifndef M5MOLS_H
#define M5MOLS_H

#include <media/v4l2-subdev.h>
#include "m5mols_reg.h"

extern int m5mols_debug;

enum m5mols_restype {
	M5MOLS_RESTYPE_MONITOR,
	M5MOLS_RESTYPE_CAPTURE,
	M5MOLS_RESTYPE_MAX,
};

/**
 * struct m5mols_resolution - structure for the resolution
 * @type: resolution type according to the pixel code
 * @width: width of the resolution
 * @height: height of the resolution
 * @reg: resolution preset register value
 */
struct m5mols_resolution {
	u8 reg;
	enum m5mols_restype type;
	u16 width;
	u16 height;
};

/**
 * struct m5mols_exif - structure for the EXIF information of M-5MOLS
 * @exposure_time: exposure time register value
 * @shutter_speed: speed of the shutter register value
 * @aperture: aperture register value
 * @exposure_bias: it calls also EV bias
 * @iso_speed: ISO register value
 * @flash: status register value of the flash
 * @sdr: status register value of the Subject Distance Range
 * @qval: not written exact meaning in document
 */
struct m5mols_exif {
	u32 exposure_time;
	u32 shutter_speed;
	u32 aperture;
	u32 brightness;
	u32 exposure_bias;
	u16 iso_speed;
	u16 flash;
	u16 sdr;
	u16 qval;
};

/**
 * struct m5mols_capture - Structure for the capture capability
 * @exif: EXIF information
 * @main: size in bytes of the main image
 * @thumb: size in bytes of the thumb image, if it was accompanied
 * @total: total size in bytes of the produced image
 */
struct m5mols_capture {
	struct m5mols_exif exif;
	u32 main;
	u32 thumb;
	u32 total;
};

/**
 * struct m5mols_scenemode - structure for the scenemode capability
 * @metering: metering light register value
 * @ev_bias: EV bias register value
 * @wb_mode: mode which means the WhiteBalance is Auto or Manual
 * @wb_preset: whitebalance preset register value in the Manual mode
 * @chroma_en: register value whether the Chroma capability is enabled or not
 * @chroma_lvl: chroma's level register value
 * @edge_en: register value Whether the Edge capability is enabled or not
 * @edge_lvl: edge's level register value
 * @af_range: Auto Focus's range
 * @fd_mode: Face Detection mode
 * @mcc: Multi-axis Color Conversion which means emotion color
 * @light: status of the Light
 * @flash: status of the Flash
 * @tone: Tone color which means Contrast
 * @iso: ISO register value
 * @capt_mode: Mode of the Image Stabilization while the camera capturing
 * @wdr: Wide Dynamic Range register value
 *
 * The each value according to each scenemode is recommended in the documents.
 */
struct m5mols_scenemode {
	u8 metering;
	u8 ev_bias;
	u8 wb_mode;
	u8 wb_preset;
	u8 chroma_en;
	u8 chroma_lvl;
	u8 edge_en;
	u8 edge_lvl;
	u8 af_range;
	u8 fd_mode;
	u8 mcc;
	u8 light;
	u8 flash;
	u8 tone;
	u8 iso;
	u8 capt_mode;
	u8 wdr;
};

/**
 * struct m5mols_version - firmware version information
 * @customer:	customer information
 * @project:	version of project information according to customer
 * @fw:		firmware revision
 * @hw:		hardware revision
 * @param:	version of the parameter
 * @awb:	Auto WhiteBalance algorithm version
 * @str:	information about manufacturer and packaging vendor
 * @af:		Auto Focus version
 *
 * The register offset starts the customer version at 0x0, and it ends
 * the awb version at 0x09. The customer, project information occupies 1 bytes
 * each. And also the fw, hw, param, awb each requires 2 bytes. The str is
 * unique string associated with firmware's version. It includes information
 * about manufacturer and the vendor of the sensor's packaging. The least
 * significant 2 bytes of the string indicate packaging manufacturer.
 */
#define VERSION_STRING_SIZE	22
struct m5mols_version {
	u8	customer;
	u8	project;
	u16	fw;
	u16	hw;
	u16	param;
	u16	awb;
	u8	str[VERSION_STRING_SIZE];
	u8	af;
};

/**
 * struct m5mols_info - M-5MOLS driver data structure
 * @pdata: platform data
 * @sd: v4l-subdev instance
 * @pad: media pad
 * @irq_waitq: waitqueue for the capture
 * @irq_done: set to 1 in the interrupt handler
 * @handle: control handler
 * @auto_exposure: auto/manual exposure control
 * @exposure_bias: exposure compensation control
 * @exposure: manual exposure control
 * @metering: exposure metering control
 * @auto_iso: auto/manual ISO sensitivity control
 * @iso: manual ISO sensitivity control
 * @auto_wb: auto white balance control
 * @lock_3a: 3A lock control
 * @colorfx: color effect control
 * @saturation: saturation control
 * @zoom: zoom control
 * @wdr: wide dynamic range control
 * @stabilization: image stabilization control
 * @jpeg_quality: JPEG compression quality control
 * @set_power: optional power callback to the board code
 * @lock: mutex protecting the structure fields below
 * @ffmt: current fmt according to resolution type
 * @res_type: current resolution type
 * @ver: information of the version
 * @cap: the capture mode attributes
 * @isp_ready: 1 when the ISP controller has completed booting
 * @power: current sensor's power status
 * @ctrl_sync: 1 when the control handler state is restored in H/W
 * @resolution:	register value for current resolution
 * @mode: register value for current operation mode
 */
struct m5mols_info {
	const struct m5mols_platform_data *pdata;
	struct v4l2_subdev sd;
	struct media_pad pad;

	wait_queue_head_t irq_waitq;
	atomic_t irq_done;

	struct v4l2_ctrl_handler handle;
	struct {
		/* exposure/exposure bias/auto exposure cluster */
		struct v4l2_ctrl *auto_exposure;
		struct v4l2_ctrl *exposure_bias;
		struct v4l2_ctrl *exposure;
		struct v4l2_ctrl *metering;
	};
	struct {
		/* iso/auto iso cluster */
		struct v4l2_ctrl *auto_iso;
		struct v4l2_ctrl *iso;
	};
	struct v4l2_ctrl *auto_wb;

	struct v4l2_ctrl *lock_3a;
	struct v4l2_ctrl *colorfx;
	struct v4l2_ctrl *saturation;
	struct v4l2_ctrl *zoom;
	struct v4l2_ctrl *wdr;
	struct v4l2_ctrl *stabilization;
	struct v4l2_ctrl *jpeg_quality;

	int (*set_power)(struct device *dev, int on);

	struct mutex lock;

	struct v4l2_mbus_framefmt ffmt[M5MOLS_RESTYPE_MAX];
	int res_type;

	struct m5mols_version ver;
	struct m5mols_capture cap;

	unsigned int isp_ready:1;
	unsigned int power:1;
	unsigned int ctrl_sync:1;

	u8 resolution;
	u8 mode;
};

#define is_available_af(__info)	(__info->ver.af)
#define is_code(__code, __type) (__code == m5mols_default_ffmt[__type].code)
#define is_manufacturer(__info, __manufacturer)	\
				(__info->ver.str[0] == __manufacturer[0] && \
				 __info->ver.str[1] == __manufacturer[1])
/*
 * I2C operation of the M-5MOLS
 *
 * The I2C read operation of the M-5MOLS requires 2 messages. The first
 * message sends the information about the command, command category, and total
 * message size. The second message is used to retrieve the data specifed in
 * the first message
 *
 *   1st message                                2nd message
 *   +-------+---+----------+-----+-------+     +------+------+------+------+
 *   | size1 | R | category | cmd | size2 |     | d[0] | d[1] | d[2] | d[3] |
 *   +-------+---+----------+-----+-------+     +------+------+------+------+
 *   - size1: message data size(5 in this case)
 *   - size2: desired buffer size of the 2nd message
 *   - d[0..3]: according to size2
 *
 * The I2C write operation needs just one message. The message includes
 * category, command, total size, and desired data.
 *
 *   1st message
 *   +-------+---+----------+-----+------+------+------+------+
 *   | size1 | W | category | cmd | d[0] | d[1] | d[2] | d[3] |
 *   +-------+---+----------+-----+------+------+------+------+
 *   - d[0..3]: according to size1
 */
int m5mols_read_u8(struct v4l2_subdev *sd, u32 reg_comb, u8 *val);
int m5mols_read_u16(struct v4l2_subdev *sd, u32 reg_comb, u16 *val);
int m5mols_read_u32(struct v4l2_subdev *sd, u32 reg_comb, u32 *val);
int m5mols_write(struct v4l2_subdev *sd, u32 reg_comb, u32 val);

int m5mols_busy_wait(struct v4l2_subdev *sd, u32 reg, u32 value, u32 mask,
		     int timeout);

/* Mask value for busy waiting until M-5MOLS I2C interface is initialized */
#define M5MOLS_I2C_RDY_WAIT_FL		(1 << 16)
/* ISP state transition timeout, in ms */
#define M5MOLS_MODE_CHANGE_TIMEOUT	200
#define M5MOLS_BUSY_WAIT_DEF_TIMEOUT	250

/*
 * Mode operation of the M-5MOLS
 *
 * Changing the mode of the M-5MOLS is needed right executing order.
 * There are three modes(PARAMETER, MONITOR, CAPTURE) which can be changed
 * by user. There are various categories associated with each mode.
 *
 * +============================================================+
 * | mode	| category					|
 * +============================================================+
 * | FLASH	| FLASH(only after Stand-by or Power-on)	|
 * | SYSTEM	| SYSTEM(only after sensor arm-booting)		|
 * | PARAMETER	| PARAMETER					|
 * | MONITOR	| MONITOR(preview), Auto Focus, Face Detection	|
 * | CAPTURE	| Single CAPTURE, Preview(recording)		|
 * +============================================================+
 *
 * The available executing order between each modes are as follows:
 *   PARAMETER <---> MONITOR <---> CAPTURE
 */
int m5mols_set_mode(struct m5mols_info *info, u8 mode);

int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg);
int m5mols_wait_interrupt(struct v4l2_subdev *sd, u8 condition, u32 timeout);
int m5mols_restore_controls(struct m5mols_info *info);
int m5mols_start_capture(struct m5mols_info *info);
int m5mols_do_scenemode(struct m5mols_info *info, u8 mode);
int m5mols_lock_3a(struct m5mols_info *info, bool lock);
int m5mols_set_ctrl(struct v4l2_ctrl *ctrl);
int m5mols_init_controls(struct v4l2_subdev *sd);

/* The firmware function */
int m5mols_update_fw(struct v4l2_subdev *sd,
		     int (*set_power)(struct m5mols_info *, bool));

static inline struct m5mols_info *to_m5mols(struct v4l2_subdev *subdev)
{
	return container_of(subdev, struct m5mols_info, sd);
}

static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
{
	struct m5mols_info *info = container_of(ctrl->handler,
						struct m5mols_info, handle);
	return &info->sd;
}

static inline void m5mols_set_ctrl_mode(struct v4l2_ctrl *ctrl,
					unsigned int mode)
{
	ctrl->priv = (void *)(uintptr_t)mode;
}

static inline unsigned int m5mols_get_ctrl_mode(struct v4l2_ctrl *ctrl)
{
	return (unsigned int)(uintptr_t)ctrl->priv;
}

#endif	/* M5MOLS_H */
Commit	Line	Data
bc125106 HK	1	/*
	2	* Header for M-5MOLS 8M Pixel camera sensor with ISP
	3	*
	4	* Copyright (C) 2011 Samsung Electronics Co., Ltd.
c3070113	5	* Author: HeungJun Kim <riverful.kim@samsung.com>
bc125106 HK	6	*
bc125106 HK	7	* Copyright (C) 2009 Samsung Electronics Co., Ltd.
c3070113	8	* Author: Dongsoo Nathaniel Kim <dongsoo45.kim@samsung.com>
bc125106 HK	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*/
	15
	16	#ifndef M5MOLS_H
	17	#define M5MOLS_H
	18
	19	#include <media/v4l2-subdev.h>
	20	#include "m5mols_reg.h"
	21
	22	extern int m5mols_debug;
	23
bc125106 HK	24	enum m5mols_restype {
	25	M5MOLS_RESTYPE_MONITOR,
	26	M5MOLS_RESTYPE_CAPTURE,
	27	M5MOLS_RESTYPE_MAX,
	28	};
	29
	30	/**
	31	* struct m5mols_resolution - structure for the resolution
	32	* @type: resolution type according to the pixel code
	33	* @width: width of the resolution
	34	* @height: height of the resolution
	35	* @reg: resolution preset register value
	36	*/
	37	struct m5mols_resolution {
	38	u8 reg;
	39	enum m5mols_restype type;
	40	u16 width;
	41	u16 height;
	42	};
	43
	44	/**
	45	* struct m5mols_exif - structure for the EXIF information of M-5MOLS
	46	* @exposure_time: exposure time register value
	47	* @shutter_speed: speed of the shutter register value
	48	* @aperture: aperture register value
	49	* @exposure_bias: it calls also EV bias
	50	* @iso_speed: ISO register value
	51	* @flash: status register value of the flash
	52	* @sdr: status register value of the Subject Distance Range
	53	* @qval: not written exact meaning in document
	54	*/
	55	struct m5mols_exif {
	56	u32 exposure_time;
	57	u32 shutter_speed;
	58	u32 aperture;
	59	u32 brightness;
	60	u32 exposure_bias;
	61	u16 iso_speed;
	62	u16 flash;
	63	u16 sdr;
	64	u16 qval;
	65	};
	66
	67	/**
	68	* struct m5mols_capture - Structure for the capture capability
	69	* @exif: EXIF information
	70	* @main: size in bytes of the main image
	71	* @thumb: size in bytes of the thumb image, if it was accompanied
	72	* @total: total size in bytes of the produced image
	73	*/
	74	struct m5mols_capture {
	75	struct m5mols_exif exif;
	76	u32 main;
	77	u32 thumb;
	78	u32 total;
	79	};
	80
	81	/**
	82	* struct m5mols_scenemode - structure for the scenemode capability
	83	* @metering: metering light register value
	84	* @ev_bias: EV bias register value
	85	* @wb_mode: mode which means the WhiteBalance is Auto or Manual
	86	* @wb_preset: whitebalance preset register value in the Manual mode
	87	* @chroma_en: register value whether the Chroma capability is enabled or not
88	* @chroma_lvl: chroma's level register value
89	* @edge_en: register value Whether the Edge capability is enabled or not
90	* @edge_lvl: edge's level register value
91	* @af_range: Auto Focus's range
92	* @fd_mode: Face Detection mode
93	* @mcc: Multi-axis Color Conversion which means emotion color
94	* @light: status of the Light
95	* @flash: status of the Flash
96	* @tone: Tone color which means Contrast
97	* @iso: ISO register value
98	* @capt_mode: Mode of the Image Stabilization while the camera capturing
99	* @wdr: Wide Dynamic Range register value
100	*
101	* The each value according to each scenemode is recommended in the documents.
102	*/
103	struct m5mols_scenemode {
57644f56 HK	104	u8 metering;
	105	u8 ev_bias;
	106	u8 wb_mode;
	107	u8 wb_preset;
	108	u8 chroma_en;
	109	u8 chroma_lvl;
	110	u8 edge_en;
	111	u8 edge_lvl;
	112	u8 af_range;
	113	u8 fd_mode;
	114	u8 mcc;
	115	u8 light;
	116	u8 flash;
	117	u8 tone;
	118	u8 iso;
	119	u8 capt_mode;
	120	u8 wdr;
bc125106 HK	121	};
	122
	123	/**
	124	* struct m5mols_version - firmware version information
	125	* @customer: customer information
	126	* @project: version of project information according to customer
	127	* @fw: firmware revision
	128	* @hw: hardware revision
	129	* @param: version of the parameter
	130	* @awb: Auto WhiteBalance algorithm version
	131	* @str: information about manufacturer and packaging vendor
	132	* @af: Auto Focus version
	133	*
	134	* The register offset starts the customer version at 0x0, and it ends
	135	* the awb version at 0x09. The customer, project information occupies 1 bytes
	136	* each. And also the fw, hw, param, awb each requires 2 bytes. The str is
	137	* unique string associated with firmware's version. It includes information
	138	* about manufacturer and the vendor of the sensor's packaging. The least
	139	* significant 2 bytes of the string indicate packaging manufacturer.
	140	*/
	141	#define VERSION_STRING_SIZE 22
	142	struct m5mols_version {
	143	u8 customer;
	144	u8 project;
	145	u16 fw;
	146	u16 hw;
	147	u16 param;
	148	u16 awb;
	149	u8 str[VERSION_STRING_SIZE];
	150	u8 af;
	151	};
bc125106 HK	152
	153	/**
	154	* struct m5mols_info - M-5MOLS driver data structure
	155	* @pdata: platform data
	156	* @sd: v4l-subdev instance
	157	* @pad: media pad
bc125106	158	* @irq_waitq: waitqueue for the capture
9346459a	159	* @irq_done: set to 1 in the interrupt handler
bc125106	160	* @handle: control handler
3c5da0ba	161	* @auto_exposure: auto/manual exposure control
48311db6	162	* @exposure_bias: exposure compensation control
3c5da0ba	163	* @exposure: manual exposure control
50d3f93e	164	* @metering: exposure metering control
44b153ca SN	165	* @auto_iso: auto/manual ISO sensitivity control
44b153ca SN	166	* @iso: manual ISO sensitivity control
d7a87e4c	167	* @auto_wb: auto white balance control
9346459a	168	* @lock_3a: 3A lock control
3c5da0ba SN	169	* @colorfx: color effect control
	170	* @saturation: saturation control
	171	* @zoom: zoom control
4eb3419d	172	* @wdr: wide dynamic range control
efcb07c1	173	* @stabilization: image stabilization control
dd9c471d	174	* @jpeg_quality: JPEG compression quality control
5565a2ad SN	175	* @set_power: optional power callback to the board code
	176	* @lock: mutex protecting the structure fields below
	177	* @ffmt: current fmt according to resolution type
	178	* @res_type: current resolution type
bc125106 HK	179	* @ver: information of the version
bc125106 HK	180	* @cap: the capture mode attributes
0f2ee1dd	181	* @isp_ready: 1 when the ISP controller has completed booting
9346459a	182	* @power: current sensor's power status
0f2ee1dd	183	* @ctrl_sync: 1 when the control handler state is restored in H/W
bc125106	184	* @resolution: register value for current resolution
bc125106	185	* @mode: register value for current operation mode
bc125106 HK	186	*/
	187	struct m5mols_info {
	188	const struct m5mols_platform_data *pdata;
	189	struct v4l2_subdev sd;
	190	struct media_pad pad;
5d4294b8	191
bc125106	192	wait_queue_head_t irq_waitq;
ce808a47	193	atomic_t irq_done;
bc125106 HK	194
bc125106 HK	195	struct v4l2_ctrl_handler handle;
3c5da0ba	196	struct {
48311db6	197	/* exposure/exposure bias/auto exposure cluster */
3c5da0ba	198	struct v4l2_ctrl *auto_exposure;
48311db6	199	struct v4l2_ctrl *exposure_bias;
3c5da0ba	200	struct v4l2_ctrl *exposure;
50d3f93e	201	struct v4l2_ctrl *metering;
3c5da0ba	202	};
44b153ca SN	203	struct {
	204	/* iso/auto iso cluster */
	205	struct v4l2_ctrl *auto_iso;
	206	struct v4l2_ctrl *iso;
	207	};
3c5da0ba	208	struct v4l2_ctrl *auto_wb;
d7a87e4c	209
9346459a	210	struct v4l2_ctrl *lock_3a;
bc125106 HK	211	struct v4l2_ctrl *colorfx;
	212	struct v4l2_ctrl *saturation;
	213	struct v4l2_ctrl *zoom;
4eb3419d	214	struct v4l2_ctrl *wdr;
efcb07c1	215	struct v4l2_ctrl *stabilization;
dd9c471d	216	struct v4l2_ctrl *jpeg_quality;
bc125106	217
5565a2ad SN	218	int (set_power)(struct device dev, int on);
	219
	220	struct mutex lock;
	221
	222	struct v4l2_mbus_framefmt ffmt[M5MOLS_RESTYPE_MAX];
	223	int res_type;
	224
bc125106 HK	225	struct m5mols_version ver;
bc125106 HK	226	struct m5mols_capture cap;
0f2ee1dd HK	227
	228	unsigned int isp_ready:1;
	229	unsigned int power:1;
	230	unsigned int ctrl_sync:1;
	231
bc125106	232	u8 resolution;
57644f56	233	u8 mode;
bc125106 HK	234	};
bc125106 HK	235
bc125106 HK	236	#define is_available_af(__info) (__info->ver.af)
	237	#define is_code(__code, __type) (__code == m5mols_default_ffmt[__type].code)
	238	#define is_manufacturer(__info, __manufacturer) \
	239	(__info->ver.str[0] == __manufacturer[0] && \
	240	__info->ver.str[1] == __manufacturer[1])
	241	/*
	242	* I2C operation of the M-5MOLS
	243	*
	244	* The I2C read operation of the M-5MOLS requires 2 messages. The first
	245	* message sends the information about the command, command category, and total
	246	* message size. The second message is used to retrieve the data specifed in
	247	* the first message
	248	*
	249	* 1st message 2nd message
	250	* +-------+---+----------+-----+-------+ +------+------+------+------+
	251	* \| size1 \| R \| category \| cmd \| size2 \| \| d[0] \| d[1] \| d[2] \| d[3] \|
	252	* +-------+---+----------+-----+-------+ +------+------+------+------+
	253	* - size1: message data size(5 in this case)
	254	* - size2: desired buffer size of the 2nd message
	255	* - d[0..3]: according to size2
	256	*
	257	* The I2C write operation needs just one message. The message includes
	258	* category, command, total size, and desired data.
	259	*
	260	* 1st message
	261	* +-------+---+----------+-----+------+------+------+------+
	262	* \| size1 \| W \| category \| cmd \| d[0] \| d[1] \| d[2] \| d[3] \|
	263	* +-------+---+----------+-----+------+------+------+------+
	264	* - d[0..3]: according to size1
	265	*/
57644f56 HK	266	int m5mols_read_u8(struct v4l2_subdev sd, u32 reg_comb, u8 val);
	267	int m5mols_read_u16(struct v4l2_subdev sd, u32 reg_comb, u16 val);
	268	int m5mols_read_u32(struct v4l2_subdev sd, u32 reg_comb, u32 val);
bc125106	269	int m5mols_write(struct v4l2_subdev *sd, u32 reg_comb, u32 val);
575d6252 HK	270
	271	int m5mols_busy_wait(struct v4l2_subdev *sd, u32 reg, u32 value, u32 mask,
	272	int timeout);
	273
	274	/* Mask value for busy waiting until M-5MOLS I2C interface is initialized */
	275	#define M5MOLS_I2C_RDY_WAIT_FL (1 << 16)
	276	/* ISP state transition timeout, in ms */
	277	#define M5MOLS_MODE_CHANGE_TIMEOUT 200
	278	#define M5MOLS_BUSY_WAIT_DEF_TIMEOUT 250
bc125106 HK	279
	280	/*
	281	* Mode operation of the M-5MOLS
	282	*
	283	* Changing the mode of the M-5MOLS is needed right executing order.
	284	* There are three modes(PARAMETER, MONITOR, CAPTURE) which can be changed
	285	* by user. There are various categories associated with each mode.
	286	*
	287	* +============================================================+
	288	* \| mode \| category \|
	289	* +============================================================+
	290	* \| FLASH \| FLASH(only after Stand-by or Power-on) \|
	291	* \| SYSTEM \| SYSTEM(only after sensor arm-booting) \|
	292	* \| PARAMETER \| PARAMETER \|
	293	* \| MONITOR \| MONITOR(preview), Auto Focus, Face Detection \|
	294	* \| CAPTURE \| Single CAPTURE, Preview(recording) \|
	295	* +============================================================+
	296	*
	297	* The available executing order between each modes are as follows:
	298	* PARAMETER <---> MONITOR <---> CAPTURE
	299	*/
3c5da0ba	300	int m5mols_set_mode(struct m5mols_info *info, u8 mode);
bc125106	301
57644f56	302	int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg);
ce808a47	303	int m5mols_wait_interrupt(struct v4l2_subdev *sd, u8 condition, u32 timeout);
5d4294b8	304	int m5mols_restore_controls(struct m5mols_info *info);
bc125106	305	int m5mols_start_capture(struct m5mols_info *info);
57644f56	306	int m5mols_do_scenemode(struct m5mols_info *info, u8 mode);
bc125106 HK	307	int m5mols_lock_3a(struct m5mols_info *info, bool lock);
bc125106 HK	308	int m5mols_set_ctrl(struct v4l2_ctrl *ctrl);
3c5da0ba	309	int m5mols_init_controls(struct v4l2_subdev *sd);
bc125106 HK	310
	311	/* The firmware function */
	312	int m5mols_update_fw(struct v4l2_subdev *sd,
	313	int (set_power)(struct m5mols_info , bool));
	314
91f4eb0a SN	315	static inline struct m5mols_info to_m5mols(struct v4l2_subdev subdev)
	316	{
	317	return container_of(subdev, struct m5mols_info, sd);
	318	}
	319
	320	static inline struct v4l2_subdev to_sd(struct v4l2_ctrl ctrl)
	321	{
	322	struct m5mols_info *info = container_of(ctrl->handler,
	323	struct m5mols_info, handle);
	324	return &info->sd;
	325	}
	326
0373e974 SN	327	static inline void m5mols_set_ctrl_mode(struct v4l2_ctrl *ctrl,
	328	unsigned int mode)
	329	{
e169c9ba	330	ctrl->priv = (void *)(uintptr_t)mode;
0373e974 SN	331	}
	332
	333	static inline unsigned int m5mols_get_ctrl_mode(struct v4l2_ctrl *ctrl)
	334	{
e169c9ba	335	return (unsigned int)(uintptr_t)ctrl->priv;
0373e974 SN	336	}
0373e974 SN	337
bc125106	338	#endif /* M5MOLS_H */