Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9a761e43 authored by Sylwester Nawrocki's avatar Sylwester Nawrocki Committed by Mauro Carvalho Chehab
Browse files

[media] exynos4-is: Add Exynos4x12 FIMC-IS driver 



This patch adds a set of core files of the Exynos4x12 FIMC-IS
V4L2 driver. This includes main functionality like allocating
memory, loading the firmware, FIMC-IS register interface and
host CPU <-> IS command and error code definitions.
The driver currently exposes a single subdev named FIMC-IS-ISP,
which corresponds to the FIMC-IS ISP and DRC IP blocks.
The FIMC-IS-ISP subdev currently supports only a subset of user
controls. For other controls we need several extensions at the
V4L2 API. The supported standard controls are:
brightness, contrast, saturation, hue, sharpness, 3a_lock,
exposure_time_absolute, white_balance_auto_preset,
iso_sensitivity, iso_sensitivity_auto, exposure_metering_mode.

Signed-off-by: default avatarYounghwan Joo <yhwan.joo@samsung.com>
Signed-off-by: default avatarSylwester Nawrocki <s.nawrocki@samsung.com>
Signed-off-by: default avatarKyungmin Park <kyungmin.park@samsung.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent c6e8d96d

drivers/media/platform/exynos4-is/fimc-is-command.h

0 → 100644
+137 −0
Original line number Diff line number Diff line 
/*

 * Samsung Exynos4x12 FIMC-IS (Imaging Subsystem) driver

 *

 * FIMC-IS command set definitions

 *

 * Copyright (C) 2013 Samsung Electronics Co., Ltd.

 *

 * Authors: Younghwan Joo <yhwan.joo@samsung.com>

 *          Sylwester Nawrocki <s.nawrocki@samsung.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#ifndef FIMC_IS_CMD_H_

#define FIMC_IS_CMD_H_



#define FIMC_IS_COMMAND_VER	110 /* FIMC-IS command set version 1.10 */



/* Enumeration of commands beetween the FIMC-IS and the host processor. */



/* HOST to FIMC-IS */

#define HIC_PREVIEW_STILL	0x0001

#define HIC_PREVIEW_VIDEO	0x0002

#define HIC_CAPTURE_STILL	0x0003

#define HIC_CAPTURE_VIDEO	0x0004

#define HIC_STREAM_ON		0x0005

#define HIC_STREAM_OFF		0x0006

#define HIC_SET_PARAMETER	0x0007

#define HIC_GET_PARAMETER	0x0008

#define HIC_SET_TUNE		0x0009

#define HIC_GET_STATUS		0x000b

/* Sensor part */

#define HIC_OPEN_SENSOR		0x000c

#define HIC_CLOSE_SENSOR	0x000d

#define HIC_SIMMIAN_INIT	0x000e

#define HIC_SIMMIAN_WRITE	0x000f

#define HIC_SIMMIAN_READ	0x0010

#define HIC_POWER_DOWN		0x0011

#define HIC_GET_SET_FILE_ADDR	0x0012

#define HIC_LOAD_SET_FILE	0x0013

#define HIC_MSG_CONFIG		0x0014

#define HIC_MSG_TEST		0x0015

/* FIMC-IS to HOST */

#define IHC_GET_SENSOR_NUM	0x1000

#define IHC_SET_SHOT_MARK	0x1001

/* parameter1: frame number */

/* parameter2: confidence level (smile 0~100) */

/* parameter3: confidence level (blink 0~100) */

#define IHC_SET_FACE_MARK	0x1002

/* parameter1: coordinate count */

/* parameter2: coordinate buffer address */

#define IHC_FRAME_DONE		0x1003

/* parameter1: frame start number */

/* parameter2: frame count */

#define IHC_AA_DONE		0x1004

#define IHC_NOT_READY		0x1005



#define IH_REPLY_DONE		0x2000

#define IH_REPLY_NOT_DONE	0x2001



enum fimc_is_scenario {

	IS_SC_PREVIEW_STILL,

	IS_SC_PREVIEW_VIDEO,

	IS_SC_CAPTURE_STILL,

	IS_SC_CAPTURE_VIDEO,

	IS_SC_MAX

};



enum fimc_is_sub_scenario {

	IS_SC_SUB_DEFAULT,

	IS_SC_SUB_PS_VTCALL,

	IS_SC_SUB_CS_VTCALL,

	IS_SC_SUB_PV_VTCALL,

	IS_SC_SUB_CV_VTCALL,

};



struct is_common_regs {

	u32 hicmd;

	u32 hic_sensorid;

	u32 hic_param[4];

	u32 reserved1[4];



	u32 ihcmd;

	u32 ihc_sensorid;

	u32 ihc_param[4];

	u32 reserved2[4];



	u32 isp_sensor_id;

	u32 isp_param[2];

	u32 reserved3[1];



	u32 scc_sensor_id;

	u32 scc_param[2];

	u32 reserved4[1];



	u32 dnr_sensor_id;

	u32 dnr_param[2];

	u32 reserved5[1];



	u32 scp_sensor_id;

	u32 scp_param[2];

	u32 reserved6[29];

} __packed;



struct is_mcuctl_reg {

	u32 mcuctl;

	u32 bboar;



	u32 intgr0;

	u32 intcr0;

	u32 intmr0;

	u32 intsr0;

	u32 intmsr0;



	u32 intgr1;

	u32 intcr1;

	u32 intmr1;

	u32 intsr1;

	u32 intmsr1;



	u32 intcr2;

	u32 intmr2;

	u32 intsr2;

	u32 intmsr2;



	u32 gpoctrl;

	u32 cpoenctlr;

	u32 gpictlr;



	u32 reserved[0xd];



	struct is_common_regs common;

} __packed;



#endif /* FIMC_IS_CMD_H_ */

drivers/media/platform/exynos4-is/fimc-is-errno.c

0 → 100644
+272 −0
Original line number Diff line number Diff line 
/*

 * Samsung Exynos4 SoC series FIMC-IS slave interface driver

 *

 * Error log interface functions

 *

 * Copyright (C) 2011 - 2013 Samsung Electronics Co., Ltd.

 *

 * Authors: Younghwan Joo <yhwan.joo@samsung.com>

 *          Sylwester Nawrocki <s.nawrocki@samsung.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#include "fimc-is-errno.h"



const char * const fimc_is_param_strerr(unsigned int error)

{

	switch (error) {

	case ERROR_COMMON_CMD:

		return "ERROR_COMMON_CMD: Invalid Command";

	case ERROR_COMMON_PARAMETER:

		return "ERROR_COMMON_PARAMETER: Invalid Parameter";

	case ERROR_COMMON_SETFILE_LOAD:

		return "ERROR_COMMON_SETFILE_LOAD: Illegal Setfile Loading";

	case ERROR_COMMON_SETFILE_ADJUST:

		return "ERROR_COMMON_SETFILE_ADJUST: Setfile isn't adjusted";

	case ERROR_COMMON_SETFILE_INDEX:

		return "ERROR_COMMON_SETFILE_INDEX: Invalid setfile index";

	case ERROR_COMMON_INPUT_PATH:

		return "ERROR_COMMON_INPUT_PATH: Input path can be changed in ready state";

	case ERROR_COMMON_INPUT_INIT:

		return "ERROR_COMMON_INPUT_INIT: IP can not start if input path is not set";

	case ERROR_COMMON_OUTPUT_PATH:

		return "ERROR_COMMON_OUTPUT_PATH: Output path can be changed in ready state (stop)";

	case ERROR_COMMON_OUTPUT_INIT:

		return "ERROR_COMMON_OUTPUT_INIT: IP can not start if output path is not set";

	case ERROR_CONTROL_BYPASS:

		return "ERROR_CONTROL_BYPASS";

	case ERROR_OTF_INPUT_FORMAT:

		return "ERROR_OTF_INPUT_FORMAT: Invalid format  (DRC: YUV444, FD: YUV444, 422, 420)";

	case ERROR_OTF_INPUT_WIDTH:

		return "ERROR_OTF_INPUT_WIDTH: Invalid width (DRC: 128~8192, FD: 32~8190)";

	case ERROR_OTF_INPUT_HEIGHT:

		return "ERROR_OTF_INPUT_HEIGHT: Invalid bit-width (DRC: 8~12bits, FD: 8bit)";

	case ERROR_OTF_INPUT_BIT_WIDTH:

		return "ERROR_OTF_INPUT_BIT_WIDTH: Invalid bit-width (DRC: 8~12bits, FD: 8bit)";

	case ERROR_DMA_INPUT_WIDTH:

		return "ERROR_DMA_INPUT_WIDTH: Invalid width (DRC: 128~8192, FD: 32~8190)";

	case ERROR_DMA_INPUT_HEIGHT:

		return "ERROR_DMA_INPUT_HEIGHT: Invalid height (DRC: 64~8192, FD: 16~8190)";

	case ERROR_DMA_INPUT_FORMAT:

		return "ERROR_DMA_INPUT_FORMAT: Invalid format (DRC: YUV444 or YUV422, FD: YUV444,422,420)";

	case ERROR_DMA_INPUT_BIT_WIDTH:

		return "ERROR_DMA_INPUT_BIT_WIDTH: Invalid bit-width (DRC: 8~12bits, FD: 8bit)";

	case ERROR_DMA_INPUT_ORDER:

		return "ERROR_DMA_INPUT_ORDER: Invalid order(DRC: YYCbCr,YCbYCr,FD:NO,YYCbCr,YCbYCr,CbCr,CrCb)";

	case ERROR_DMA_INPUT_PLANE:

		return "ERROR_DMA_INPUT_PLANE: Invalid palne (DRC: 3, FD: 1, 2, 3)";

	case ERROR_OTF_OUTPUT_WIDTH:

		return "ERROR_OTF_OUTPUT_WIDTH: Invalid width (DRC: 128~8192)";

	case ERROR_OTF_OUTPUT_HEIGHT:

		return "ERROR_OTF_OUTPUT_HEIGHT: Invalid height (DRC: 64~8192)";

	case ERROR_OTF_OUTPUT_FORMAT:

		return "ERROR_OTF_OUTPUT_FORMAT: Invalid format (DRC: YUV444)";

	case ERROR_OTF_OUTPUT_BIT_WIDTH:

		return "ERROR_OTF_OUTPUT_BIT_WIDTH: Invalid bit-width (DRC: 8~12bits, FD: 8bit)";

	case ERROR_DMA_OUTPUT_WIDTH:

		return "ERROR_DMA_OUTPUT_WIDTH";

	case ERROR_DMA_OUTPUT_HEIGHT:

		return "ERROR_DMA_OUTPUT_HEIGHT";

	case ERROR_DMA_OUTPUT_FORMAT:

		return "ERROR_DMA_OUTPUT_FORMAT";

	case ERROR_DMA_OUTPUT_BIT_WIDTH:

		return "ERROR_DMA_OUTPUT_BIT_WIDTH";

	case ERROR_DMA_OUTPUT_PLANE:

		return "ERROR_DMA_OUTPUT_PLANE";

	case ERROR_DMA_OUTPUT_ORDER:

		return "ERROR_DMA_OUTPUT_ORDER";



	/* Sensor Error(100~199) */

	case ERROR_SENSOR_I2C_FAIL:

		return "ERROR_SENSOR_I2C_FAIL";

	case ERROR_SENSOR_INVALID_FRAMERATE:

		return "ERROR_SENSOR_INVALID_FRAMERATE";

	case ERROR_SENSOR_INVALID_EXPOSURETIME:

		return "ERROR_SENSOR_INVALID_EXPOSURETIME";

	case ERROR_SENSOR_INVALID_SIZE:

		return "ERROR_SENSOR_INVALID_SIZE";

	case ERROR_SENSOR_INVALID_SETTING:

		return "ERROR_SENSOR_INVALID_SETTING";

	case ERROR_SENSOR_ACTURATOR_INIT_FAIL:

		return "ERROR_SENSOR_ACTURATOR_INIT_FAIL";

	case ERROR_SENSOR_INVALID_AF_POS:

		return "ERROR_SENSOR_INVALID_AF_POS";

	case ERROR_SENSOR_UNSUPPORT_FUNC:

		return "ERROR_SENSOR_UNSUPPORT_FUNC";

	case ERROR_SENSOR_UNSUPPORT_PERI:

		return "ERROR_SENSOR_UNSUPPORT_PERI";

	case ERROR_SENSOR_UNSUPPORT_AF:

		return "ERROR_SENSOR_UNSUPPORT_AF";



	/* ISP Error (200~299) */

	case ERROR_ISP_AF_BUSY:

		return "ERROR_ISP_AF_BUSY";

	case ERROR_ISP_AF_INVALID_COMMAND:

		return "ERROR_ISP_AF_INVALID_COMMAND";

	case ERROR_ISP_AF_INVALID_MODE:

		return "ERROR_ISP_AF_INVALID_MODE";



	/* DRC Error (300~399) */

	/* FD Error  (400~499) */

	case ERROR_FD_CONFIG_MAX_NUMBER_STATE:

		return "ERROR_FD_CONFIG_MAX_NUMBER_STATE";

	case ERROR_FD_CONFIG_MAX_NUMBER_INVALID:

		return "ERROR_FD_CONFIG_MAX_NUMBER_INVALID";

	case ERROR_FD_CONFIG_YAW_ANGLE_STATE:

		return "ERROR_FD_CONFIG_YAW_ANGLE_STATE";

	case ERROR_FD_CONFIG_YAW_ANGLE_INVALID:

		return "ERROR_FD_CONFIG_YAW_ANGLE_INVALID\n";

	case ERROR_FD_CONFIG_ROLL_ANGLE_STATE:

		return "ERROR_FD_CONFIG_ROLL_ANGLE_STATE";

	case ERROR_FD_CONFIG_ROLL_ANGLE_INVALID:

		return "ERROR_FD_CONFIG_ROLL_ANGLE_INVALID";

	case ERROR_FD_CONFIG_SMILE_MODE_INVALID:

		return "ERROR_FD_CONFIG_SMILE_MODE_INVALID";

	case ERROR_FD_CONFIG_BLINK_MODE_INVALID:

		return "ERROR_FD_CONFIG_BLINK_MODE_INVALID";

	case ERROR_FD_CONFIG_EYES_DETECT_INVALID:

		return "ERROR_FD_CONFIG_EYES_DETECT_INVALID";

	case ERROR_FD_CONFIG_MOUTH_DETECT_INVALID:

		return "ERROR_FD_CONFIG_MOUTH_DETECT_INVALID";

	case ERROR_FD_CONFIG_ORIENTATION_STATE:

		return "ERROR_FD_CONFIG_ORIENTATION_STATE";

	case ERROR_FD_CONFIG_ORIENTATION_INVALID:

		return "ERROR_FD_CONFIG_ORIENTATION_INVALID";

	case ERROR_FD_CONFIG_ORIENTATION_VALUE_INVALID:

		return "ERROR_FD_CONFIG_ORIENTATION_VALUE_INVALID";

	case ERROR_FD_RESULT:

		return "ERROR_FD_RESULT";

	case ERROR_FD_MODE:

		return "ERROR_FD_MODE";

	default:

		return "Unknown";

	}

}



const char * const fimc_is_strerr(unsigned int error)

{

	error &= ~IS_ERROR_TIME_OUT_FLAG;



	switch (error) {

	/* General */

	case IS_ERROR_INVALID_COMMAND:

		return "IS_ERROR_INVALID_COMMAND";

	case IS_ERROR_REQUEST_FAIL:

		return "IS_ERROR_REQUEST_FAIL";

	case IS_ERROR_INVALID_SCENARIO:

		return "IS_ERROR_INVALID_SCENARIO";

	case IS_ERROR_INVALID_SENSORID:

		return "IS_ERROR_INVALID_SENSORID";

	case IS_ERROR_INVALID_MODE_CHANGE:

		return "IS_ERROR_INVALID_MODE_CHANGE";

	case IS_ERROR_INVALID_MAGIC_NUMBER:

		return "IS_ERROR_INVALID_MAGIC_NUMBER";

	case IS_ERROR_INVALID_SETFILE_HDR:

		return "IS_ERROR_INVALID_SETFILE_HDR";

	case IS_ERROR_BUSY:

		return "IS_ERROR_BUSY";

	case IS_ERROR_SET_PARAMETER:

		return "IS_ERROR_SET_PARAMETER";

	case IS_ERROR_INVALID_PATH:

		return "IS_ERROR_INVALID_PATH";

	case IS_ERROR_OPEN_SENSOR_FAIL:

		return "IS_ERROR_OPEN_SENSOR_FAIL";

	case IS_ERROR_ENTRY_MSG_THREAD_DOWN:

		return "IS_ERROR_ENTRY_MSG_THREAD_DOWN";

	case IS_ERROR_ISP_FRAME_END_NOT_DONE:

		return "IS_ERROR_ISP_FRAME_END_NOT_DONE";

	case IS_ERROR_DRC_FRAME_END_NOT_DONE:

		return "IS_ERROR_DRC_FRAME_END_NOT_DONE";

	case IS_ERROR_SCALERC_FRAME_END_NOT_DONE:

		return "IS_ERROR_SCALERC_FRAME_END_NOT_DONE";

	case IS_ERROR_ODC_FRAME_END_NOT_DONE:

		return "IS_ERROR_ODC_FRAME_END_NOT_DONE";

	case IS_ERROR_DIS_FRAME_END_NOT_DONE:

		return "IS_ERROR_DIS_FRAME_END_NOT_DONE";

	case IS_ERROR_TDNR_FRAME_END_NOT_DONE:

		return "IS_ERROR_TDNR_FRAME_END_NOT_DONE";

	case IS_ERROR_SCALERP_FRAME_END_NOT_DONE:

		return "IS_ERROR_SCALERP_FRAME_END_NOT_DONE";

	case IS_ERROR_WAIT_STREAM_OFF_NOT_DONE:

		return "IS_ERROR_WAIT_STREAM_OFF_NOT_DONE";

	case IS_ERROR_NO_MSG_IS_RECEIVED:

		return "IS_ERROR_NO_MSG_IS_RECEIVED";

	case IS_ERROR_SENSOR_MSG_FAIL:

		return "IS_ERROR_SENSOR_MSG_FAIL";

	case IS_ERROR_ISP_MSG_FAIL:

		return "IS_ERROR_ISP_MSG_FAIL";

	case IS_ERROR_DRC_MSG_FAIL:

		return "IS_ERROR_DRC_MSG_FAIL";

	case IS_ERROR_LHFD_MSG_FAIL:

		return "IS_ERROR_LHFD_MSG_FAIL";

	case IS_ERROR_UNKNOWN:

		return "IS_ERROR_UNKNOWN";



	/* Sensor */

	case IS_ERROR_SENSOR_PWRDN_FAIL:

		return "IS_ERROR_SENSOR_PWRDN_FAIL";



	/* ISP */

	case IS_ERROR_ISP_PWRDN_FAIL:

		return "IS_ERROR_ISP_PWRDN_FAIL";

	case IS_ERROR_ISP_MULTIPLE_INPUT:

		return "IS_ERROR_ISP_MULTIPLE_INPUT";

	case IS_ERROR_ISP_ABSENT_INPUT:

		return "IS_ERROR_ISP_ABSENT_INPUT";

	case IS_ERROR_ISP_ABSENT_OUTPUT:

		return "IS_ERROR_ISP_ABSENT_OUTPUT";

	case IS_ERROR_ISP_NONADJACENT_OUTPUT:

		return "IS_ERROR_ISP_NONADJACENT_OUTPUT";

	case IS_ERROR_ISP_FORMAT_MISMATCH:

		return "IS_ERROR_ISP_FORMAT_MISMATCH";

	case IS_ERROR_ISP_WIDTH_MISMATCH:

		return "IS_ERROR_ISP_WIDTH_MISMATCH";

	case IS_ERROR_ISP_HEIGHT_MISMATCH:

		return "IS_ERROR_ISP_HEIGHT_MISMATCH";

	case IS_ERROR_ISP_BITWIDTH_MISMATCH:

		return "IS_ERROR_ISP_BITWIDTH_MISMATCH";

	case IS_ERROR_ISP_FRAME_END_TIME_OUT:

		return "IS_ERROR_ISP_FRAME_END_TIME_OUT";



	/* DRC */

	case IS_ERROR_DRC_PWRDN_FAIL:

		return "IS_ERROR_DRC_PWRDN_FAIL";

	case IS_ERROR_DRC_MULTIPLE_INPUT:

		return "IS_ERROR_DRC_MULTIPLE_INPUT";

	case IS_ERROR_DRC_ABSENT_INPUT:

		return "IS_ERROR_DRC_ABSENT_INPUT";

	case IS_ERROR_DRC_NONADJACENT_INPUT:

		return "IS_ERROR_DRC_NONADJACENT_INPUT";

	case IS_ERROR_DRC_ABSENT_OUTPUT:

		return "IS_ERROR_DRC_ABSENT_OUTPUT";

	case IS_ERROR_DRC_NONADJACENT_OUTPUT:

		return "IS_ERROR_DRC_NONADJACENT_OUTPUT";

	case IS_ERROR_DRC_FORMAT_MISMATCH:

		return "IS_ERROR_DRC_FORMAT_MISMATCH";

	case IS_ERROR_DRC_WIDTH_MISMATCH:

		return "IS_ERROR_DRC_WIDTH_MISMATCH";

	case IS_ERROR_DRC_HEIGHT_MISMATCH:

		return "IS_ERROR_DRC_HEIGHT_MISMATCH";

	case IS_ERROR_DRC_BITWIDTH_MISMATCH:

		return "IS_ERROR_DRC_BITWIDTH_MISMATCH";

	case IS_ERROR_DRC_FRAME_END_TIME_OUT:

		return "IS_ERROR_DRC_FRAME_END_TIME_OUT";



	/* FD */

	case IS_ERROR_FD_PWRDN_FAIL:

		return "IS_ERROR_FD_PWRDN_FAIL";

	case IS_ERROR_FD_MULTIPLE_INPUT:

		return "IS_ERROR_FD_MULTIPLE_INPUT";

	case IS_ERROR_FD_ABSENT_INPUT:

		return "IS_ERROR_FD_ABSENT_INPUT";

	case IS_ERROR_FD_NONADJACENT_INPUT:

		return "IS_ERROR_FD_NONADJACENT_INPUT";

	case IS_ERROR_LHFD_FRAME_END_TIME_OUT:

		return "IS_ERROR_LHFD_FRAME_END_TIME_OUT";

	default:

		return "Unknown";

	}

}

drivers/media/platform/exynos4-is/fimc-is-errno.h

0 → 100644
+248 −0
Original line number Diff line number Diff line 
/*

 * Samsung Exynos4 SoC series FIMC-IS slave interface driver

 *

 * FIMC-IS error code definition

 *

 * Copyright (C) 2011 - 2013 Samsung Electronics Co., Ltd.

 *

 * Authors: Younghwan Joo <yhwan.joo@samsung.com>

 *          Sylwester Nawrocki <s.nawrocki@samsung.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

*/



#ifndef FIMC_IS_ERR_H_

#define FIMC_IS_ERR_H_



#define IS_ERROR_VER			011 /* IS ERROR VERSION 0.11 */



enum {

	IS_ERROR_NONE,



	/* General 1 ~ 99 */

	IS_ERROR_INVALID_COMMAND,

	IS_ERROR_REQUEST_FAIL,

	IS_ERROR_INVALID_SCENARIO,

	IS_ERROR_INVALID_SENSORID,

	IS_ERROR_INVALID_MODE_CHANGE,

	IS_ERROR_INVALID_MAGIC_NUMBER,

	IS_ERROR_INVALID_SETFILE_HDR,

	IS_ERROR_BUSY,

	IS_ERROR_SET_PARAMETER,

	IS_ERROR_INVALID_PATH,

	IS_ERROR_OPEN_SENSOR_FAIL,

	IS_ERROR_ENTRY_MSG_THREAD_DOWN,

	IS_ERROR_ISP_FRAME_END_NOT_DONE,

	IS_ERROR_DRC_FRAME_END_NOT_DONE,

	IS_ERROR_SCALERC_FRAME_END_NOT_DONE,

	IS_ERROR_ODC_FRAME_END_NOT_DONE,

	IS_ERROR_DIS_FRAME_END_NOT_DONE,

	IS_ERROR_TDNR_FRAME_END_NOT_DONE,

	IS_ERROR_SCALERP_FRAME_END_NOT_DONE,

	IS_ERROR_WAIT_STREAM_OFF_NOT_DONE,

	IS_ERROR_NO_MSG_IS_RECEIVED,

	IS_ERROR_SENSOR_MSG_FAIL,

	IS_ERROR_ISP_MSG_FAIL,

	IS_ERROR_DRC_MSG_FAIL,

	IS_ERROR_SCALERC_MSG_FAIL,

	IS_ERROR_ODC_MSG_FAIL,

	IS_ERROR_DIS_MSG_FAIL,

	IS_ERROR_TDNR_MSG_FAIL,

	IS_ERROR_SCALERP_MSG_FAIL,

	IS_ERROR_LHFD_MSG_FAIL,

	IS_ERROR_LHFD_INTERNAL_STOP,



	/* Sensor 100 ~ 199 */

	IS_ERROR_SENSOR_PWRDN_FAIL	= 100,

	IS_ERROR_SENSOR_STREAM_ON_FAIL,

	IS_ERROR_SENSOR_STREAM_OFF_FAIL,



	/* ISP 200 ~ 299 */

	IS_ERROR_ISP_PWRDN_FAIL		= 200,

	IS_ERROR_ISP_MULTIPLE_INPUT,

	IS_ERROR_ISP_ABSENT_INPUT,

	IS_ERROR_ISP_ABSENT_OUTPUT,

	IS_ERROR_ISP_NONADJACENT_OUTPUT,

	IS_ERROR_ISP_FORMAT_MISMATCH,

	IS_ERROR_ISP_WIDTH_MISMATCH,

	IS_ERROR_ISP_HEIGHT_MISMATCH,

	IS_ERROR_ISP_BITWIDTH_MISMATCH,

	IS_ERROR_ISP_FRAME_END_TIME_OUT,



	/* DRC 300 ~ 399 */

	IS_ERROR_DRC_PWRDN_FAIL		= 300,

	IS_ERROR_DRC_MULTIPLE_INPUT,

	IS_ERROR_DRC_ABSENT_INPUT,

	IS_ERROR_DRC_NONADJACENT_INPUT,

	IS_ERROR_DRC_ABSENT_OUTPUT,

	IS_ERROR_DRC_NONADJACENT_OUTPUT,

	IS_ERROR_DRC_FORMAT_MISMATCH,

	IS_ERROR_DRC_WIDTH_MISMATCH,

	IS_ERROR_DRC_HEIGHT_MISMATCH,

	IS_ERROR_DRC_BITWIDTH_MISMATCH,

	IS_ERROR_DRC_FRAME_END_TIME_OUT,



	/* SCALERC 400 ~ 499 */

	IS_ERROR_SCALERC_PWRDN_FAIL	= 400,



	/* ODC 500 ~ 599 */

	IS_ERROR_ODC_PWRDN_FAIL		= 500,



	/* DIS 600 ~ 699 */

	IS_ERROR_DIS_PWRDN_FAIL		= 600,



	/* TDNR 700 ~ 799 */

	IS_ERROR_TDNR_PWRDN_FAIL	= 700,



	/* SCALERC 800 ~ 899 */

	IS_ERROR_SCALERP_PWRDN_FAIL	= 800,



	/* FD 900 ~ 999 */

	IS_ERROR_FD_PWRDN_FAIL		= 900,

	IS_ERROR_FD_MULTIPLE_INPUT,

	IS_ERROR_FD_ABSENT_INPUT,

	IS_ERROR_FD_NONADJACENT_INPUT,

	IS_ERROR_LHFD_FRAME_END_TIME_OUT,



	IS_ERROR_UNKNOWN		= 1000,

};



#define IS_ERROR_TIME_OUT_FLAG	0x80000000



/* Set parameter error enum */

enum fimc_is_error {

	/* Common error (0~99) */

	ERROR_COMMON_NONE		= 0,

	ERROR_COMMON_CMD		= 1,	/* Invalid command */

	ERROR_COMMON_PARAMETER		= 2,	/* Invalid parameter */

	/* setfile is not loaded before adjusting */

	ERROR_COMMON_SETFILE_LOAD	= 3,

	/* setfile is not Adjusted before runnng. */

	ERROR_COMMON_SETFILE_ADJUST	= 4,

	/* Index of setfile is not valid (0~MAX_SETFILE_NUM-1) */

	ERROR_COMMON_SETFILE_INDEX	= 5,

	/* Input path can be changed in ready state(stop) */

	ERROR_COMMON_INPUT_PATH		= 6,

	/* IP can not start if input path is not set */

	ERROR_COMMON_INPUT_INIT		= 7,

	/* Output path can be changed in ready state (stop) */

	ERROR_COMMON_OUTPUT_PATH	= 8,

	/* IP can not start if output path is not set */

	ERROR_COMMON_OUTPUT_INIT	= 9,



	ERROR_CONTROL_NONE		= ERROR_COMMON_NONE,

	ERROR_CONTROL_BYPASS		= 11,	/* Enable or Disable */



	ERROR_OTF_INPUT_NONE		= ERROR_COMMON_NONE,

	ERROR_OTF_INPUT_CMD		= 21,

	/* invalid format  (DRC: YUV444, FD: YUV444, 422, 420) */

	ERROR_OTF_INPUT_FORMAT		= 22,

	/* invalid width (DRC: 128~8192, FD: 32~8190) */

	ERROR_OTF_INPUT_WIDTH		= 23,

	/* invalid height (DRC: 64~8192, FD: 16~8190) */

	ERROR_OTF_INPUT_HEIGHT		= 24,

	/* invalid bit-width (DRC: 8~12bits, FD: 8bit) */

	ERROR_OTF_INPUT_BIT_WIDTH	= 25,

	/* invalid FrameTime for ISP */

	ERROR_OTF_INPUT_USER_FRAMETIIME	= 26,



	ERROR_DMA_INPUT_NONE		= ERROR_COMMON_NONE,

	/* invalid width (DRC: 128~8192, FD: 32~8190) */

	ERROR_DMA_INPUT_WIDTH		= 31,

	/* invalid height (DRC: 64~8192, FD: 16~8190) */

	ERROR_DMA_INPUT_HEIGHT		= 32,

	/* invalid format (DRC: YUV444 or YUV422, FD: YUV444, 422, 420) */

	ERROR_DMA_INPUT_FORMAT		= 33,

	/* invalid bit-width (DRC: 8~12bit, FD: 8bit) */

	ERROR_DMA_INPUT_BIT_WIDTH	= 34,

	/* invalid order(DRC: YYCbCrorYCbYCr, FD:NO,YYCbCr,YCbYCr,CbCr,CrCb) */

	ERROR_DMA_INPUT_ORDER		= 35,

	/* invalid palne (DRC: 3, FD: 1, 2, 3) */

	ERROR_DMA_INPUT_PLANE		= 36,



	ERROR_OTF_OUTPUT_NONE		= ERROR_COMMON_NONE,

	/* invalid width (DRC: 128~8192) */

	ERROR_OTF_OUTPUT_WIDTH		= 41,

	/* invalid height (DRC: 64~8192) */

	ERROR_OTF_OUTPUT_HEIGHT		= 42,

	/* invalid format (DRC: YUV444) */

	ERROR_OTF_OUTPUT_FORMAT		= 43,

	/* invalid bit-width (DRC: 8~12bits) */

	ERROR_OTF_OUTPUT_BIT_WIDTH	= 44,



	ERROR_DMA_OUTPUT_NONE		= ERROR_COMMON_NONE,

	ERROR_DMA_OUTPUT_WIDTH		= 51,	/* invalid width */

	ERROR_DMA_OUTPUT_HEIGHT		= 52,	/* invalid height */

	ERROR_DMA_OUTPUT_FORMAT		= 53,	/* invalid format */

	ERROR_DMA_OUTPUT_BIT_WIDTH	= 54,	/* invalid bit-width */

	ERROR_DMA_OUTPUT_PLANE		= 55,	/* invalid plane */

	ERROR_DMA_OUTPUT_ORDER		= 56,	/* invalid order */



	ERROR_GLOBAL_SHOTMODE_NONE	= ERROR_COMMON_NONE,



	/* SENSOR Error(100~199) */

	ERROR_SENSOR_NONE		= ERROR_COMMON_NONE,

	ERROR_SENSOR_I2C_FAIL		= 101,

	ERROR_SENSOR_INVALID_FRAMERATE,

	ERROR_SENSOR_INVALID_EXPOSURETIME,

	ERROR_SENSOR_INVALID_SIZE,

	ERROR_SENSOR_INVALID_SETTING,

	ERROR_SENSOR_ACTURATOR_INIT_FAIL,

	ERROR_SENSOR_INVALID_AF_POS,

	ERROR_SENSOR_UNSUPPORT_FUNC,

	ERROR_SENSOR_UNSUPPORT_PERI,

	ERROR_SENSOR_UNSUPPORT_AF,



	/* ISP Error (200~299) */

	ERROR_ISP_AF_NONE		= ERROR_COMMON_NONE,

	ERROR_ISP_AF_BUSY		= 201,

	ERROR_ISP_AF_INVALID_COMMAND	= 202,

	ERROR_ISP_AF_INVALID_MODE	= 203,

	ERROR_ISP_FLASH_NONE		= ERROR_COMMON_NONE,

	ERROR_ISP_AWB_NONE		= ERROR_COMMON_NONE,

	ERROR_ISP_IMAGE_EFFECT_NONE	= ERROR_COMMON_NONE,

	ERROR_ISP_ISO_NONE		= ERROR_COMMON_NONE,

	ERROR_ISP_ADJUST_NONE		= ERROR_COMMON_NONE,

	ERROR_ISP_METERING_NONE		= ERROR_COMMON_NONE,

	ERROR_ISP_AFC_NONE		= ERROR_COMMON_NONE,



	/* DRC Error (300~399) */



	/* FD Error  (400~499) */

	ERROR_FD_NONE					= ERROR_COMMON_NONE,

	/* Invalid max number (1~16) */

	ERROR_FD_CONFIG_MAX_NUMBER_STATE		= 401,

	ERROR_FD_CONFIG_MAX_NUMBER_INVALID		= 402,

	ERROR_FD_CONFIG_YAW_ANGLE_STATE			= 403,

	ERROR_FD_CONFIG_YAW_ANGLE_INVALID		= 404,

	ERROR_FD_CONFIG_ROLL_ANGLE_STATE		= 405,

	ERROR_FD_CONFIG_ROLL_ANGLE_INVALID		= 406,

	ERROR_FD_CONFIG_SMILE_MODE_INVALID		= 407,

	ERROR_FD_CONFIG_BLINK_MODE_INVALID		= 408,

	ERROR_FD_CONFIG_EYES_DETECT_INVALID		= 409,

	ERROR_FD_CONFIG_MOUTH_DETECT_INVALID		= 410,

	ERROR_FD_CONFIG_ORIENTATION_STATE		= 411,

	ERROR_FD_CONFIG_ORIENTATION_INVALID		= 412,

	ERROR_FD_CONFIG_ORIENTATION_VALUE_INVALID	= 413,

	/* PARAM_FdResultStr can be only applied in ready-state or stream off */

	ERROR_FD_RESULT					= 414,

	/* PARAM_FdModeStr can be only applied in ready-state or stream off */

	ERROR_FD_MODE					= 415,

	/* Scaler Error  (500 ~ 599) */

	ERROR_SCALER_NO_NONE				= ERROR_COMMON_NONE,

	ERROR_SCALER_DMA_OUTSEL				= 501,

	ERROR_SCALER_H_RATIO				= 502,

	ERROR_SCALER_V_RATIO				= 503,



	ERROR_SCALER_IMAGE_EFFECT			= 510,



	ERROR_SCALER_ROTATE				= 520,

	ERROR_SCALER_FLIP				= 521,

};



const char * const fimc_is_strerr(unsigned int error);

const char * const fimc_is_param_strerr(unsigned int error);



#endif /* FIMC_IS_ERR_H_ */

drivers/media/platform/exynos4-is/fimc-is-regs.c

0 → 100644
+242 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/media/platform/exynos4-is/fimc-is-regs.h

0 → 100644
+164 −0

File added.

Preview size limit exceeded, changes collapsed.