[net-next-2.6.git] / drivers / staging / dream / camera / msm_vfe8x.c

/*
 * Copyright (C) 2008-2009 QUALCOMM Incorporated.
 */
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/interrupt.h>
#include <mach/irqs.h>
#include "msm_vfe8x_proc.h"

#define ON  1
#define OFF 0

struct mutex vfe_lock;
static void     *vfe_syncdata;

static int vfe_enable(struct camera_enable_cmd *enable)
{
	int rc = 0;
	return rc;
}

static int vfe_disable(struct camera_enable_cmd *enable,
	struct platform_device *dev)
{
	int rc = 0;

	vfe_stop();

	msm_camio_disable(dev);
	return rc;
}

static void vfe_release(struct platform_device *dev)
{
	msm_camio_disable(dev);
	vfe_cmd_release(dev);

	mutex_lock(&vfe_lock);
	vfe_syncdata = NULL;
	mutex_unlock(&vfe_lock);
}

static void vfe_config_axi(int mode,
	struct axidata *ad, struct vfe_cmd_axi_output_config *ao)
{
	struct msm_pmem_region *regptr;
	int i, j;
	uint32_t *p1, *p2;

	if (mode == OUTPUT_1 || mode == OUTPUT_1_AND_2) {
		regptr = ad->region;
		for (i = 0;
			i < ad->bufnum1; i++) {

			p1 = &(ao->output1.outputY.outFragments[i][0]);
			p2 = &(ao->output1.outputCbcr.outFragments[i][0]);

			for (j = 0;
				j < ao->output1.fragmentCount; j++) {

				*p1 = regptr->paddr + regptr->y_off;
				p1++;

				*p2 = regptr->paddr + regptr->cbcr_off;
				p2++;
			}
			regptr++;
		}
	} /* if OUTPUT1 or Both */

	if (mode == OUTPUT_2 || mode == OUTPUT_1_AND_2) {

		regptr = &(ad->region[ad->bufnum1]);
		CDBG("bufnum2 = %d\n", ad->bufnum2);

		for (i = 0;
			i < ad->bufnum2; i++) {

			p1 = &(ao->output2.outputY.outFragments[i][0]);
			p2 = &(ao->output2.outputCbcr.outFragments[i][0]);

		CDBG("config_axi: O2, phy = 0x%lx, y_off = %d, cbcr_off = %d\n",
			regptr->paddr, regptr->y_off, regptr->cbcr_off);

			for (j = 0;
				j < ao->output2.fragmentCount; j++) {

				*p1 = regptr->paddr + regptr->y_off;
				CDBG("vfe_config_axi: p1 = 0x%x\n", *p1);
				p1++;

				*p2 = regptr->paddr + regptr->cbcr_off;
				CDBG("vfe_config_axi: p2 = 0x%x\n", *p2);
				p2++;
			}
			regptr++;
		}
	}
}

static int vfe_proc_general(struct msm_vfe_command_8k *cmd)
{
	int rc = 0;

	CDBG("vfe_proc_general: cmdID = %d\n", cmd->id);

	switch (cmd->id) {
	case VFE_CMD_ID_RESET:
		msm_camio_vfe_blk_reset();
		msm_camio_camif_pad_reg_reset_2();
		vfe_reset();
		break;

	case VFE_CMD_ID_START: {
		struct vfe_cmd_start start;
		if (copy_from_user(&start,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		/* msm_camio_camif_pad_reg_reset_2(); */
		msm_camio_camif_pad_reg_reset();
		vfe_start(&start);
	}
		break;

	case VFE_CMD_ID_CAMIF_CONFIG: {
		struct vfe_cmd_camif_config camif;
		if (copy_from_user(&camif,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_camif_config(&camif);
	}
		break;

	case VFE_CMD_ID_BLACK_LEVEL_CONFIG: {
		struct vfe_cmd_black_level_config bl;
		if (copy_from_user(&bl,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_black_level_config(&bl);
	}
		break;

	case VFE_CMD_ID_ROLL_OFF_CONFIG: {
		struct vfe_cmd_roll_off_config rolloff;
		if (copy_from_user(&rolloff,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_roll_off_config(&rolloff);
	}
		break;

	case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG: {
		struct vfe_cmd_demux_channel_gain_config demuxc;
		if (copy_from_user(&demuxc,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		/* demux is always enabled.  */
		vfe_demux_channel_gain_config(&demuxc);
	}
		break;

	case VFE_CMD_ID_DEMOSAIC_CONFIG: {
		struct vfe_cmd_demosaic_config demosaic;
		if (copy_from_user(&demosaic,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_demosaic_config(&demosaic);
	}
		break;

	case VFE_CMD_ID_FOV_CROP_CONFIG:
	case VFE_CMD_ID_FOV_CROP_UPDATE: {
		struct vfe_cmd_fov_crop_config fov;
		if (copy_from_user(&fov,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_fov_crop_config(&fov);
	}
		break;

	case VFE_CMD_ID_MAIN_SCALER_CONFIG:
	case VFE_CMD_ID_MAIN_SCALER_UPDATE: {
		struct vfe_cmd_main_scaler_config mainds;
		if (copy_from_user(&mainds,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_main_scaler_config(&mainds);
	}
		break;

	case VFE_CMD_ID_WHITE_BALANCE_CONFIG:
	case VFE_CMD_ID_WHITE_BALANCE_UPDATE: {
		struct vfe_cmd_white_balance_config wb;
		if (copy_from_user(&wb,
			(void __user *)	cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_white_balance_config(&wb);
	}
		break;

	case VFE_CMD_ID_COLOR_CORRECTION_CONFIG:
	case VFE_CMD_ID_COLOR_CORRECTION_UPDATE: {
		struct vfe_cmd_color_correction_config cc;
		if (copy_from_user(&cc,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_color_correction_config(&cc);
	}
		break;

	case VFE_CMD_ID_LA_CONFIG: {
		struct vfe_cmd_la_config la;
		if (copy_from_user(&la,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_la_config(&la);
	}
		break;

	case VFE_CMD_ID_RGB_GAMMA_CONFIG: {
		struct vfe_cmd_rgb_gamma_config rgb;
		if (copy_from_user(&rgb,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		rc = vfe_rgb_gamma_config(&rgb);
	}
		break;

	case VFE_CMD_ID_CHROMA_ENHAN_CONFIG:
	case VFE_CMD_ID_CHROMA_ENHAN_UPDATE: {
		struct vfe_cmd_chroma_enhan_config chrom;
		if (copy_from_user(&chrom,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_chroma_enhan_config(&chrom);
	}
		break;

	case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG:
	case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE: {
		struct vfe_cmd_chroma_suppression_config chromsup;
		if (copy_from_user(&chromsup,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_chroma_sup_config(&chromsup);
	}
		break;

	case VFE_CMD_ID_ASF_CONFIG: {
		struct vfe_cmd_asf_config asf;
		if (copy_from_user(&asf,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_asf_config(&asf);
	}
		break;

	case VFE_CMD_ID_SCALER2Y_CONFIG:
	case VFE_CMD_ID_SCALER2Y_UPDATE: {
		struct vfe_cmd_scaler2_config ds2y;
		if (copy_from_user(&ds2y,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_scaler2y_config(&ds2y);
	}
		break;

	case VFE_CMD_ID_SCALER2CbCr_CONFIG:
	case VFE_CMD_ID_SCALER2CbCr_UPDATE: {
		struct vfe_cmd_scaler2_config ds2cbcr;
		if (copy_from_user(&ds2cbcr,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_scaler2cbcr_config(&ds2cbcr);
	}
		break;

	case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG: {
		struct vfe_cmd_chroma_subsample_config sub;
		if (copy_from_user(&sub,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_chroma_subsample_config(&sub);
	}
		break;

	case VFE_CMD_ID_FRAME_SKIP_CONFIG: {
		struct vfe_cmd_frame_skip_config fskip;
		if (copy_from_user(&fskip,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_frame_skip_config(&fskip);
	}
		break;

	case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG: {
		struct vfe_cmd_output_clamp_config clamp;
		if (copy_from_user(&clamp,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_output_clamp_config(&clamp);
	}
		break;

	/* module update commands */
	case VFE_CMD_ID_BLACK_LEVEL_UPDATE: {
		struct vfe_cmd_black_level_config blk;
		if (copy_from_user(&blk,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_black_level_update(&blk);
	}
		break;

	case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE: {
		struct vfe_cmd_demux_channel_gain_config dmu;
		if (copy_from_user(&dmu,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_demux_channel_gain_update(&dmu);
	}
		break;

	case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE: {
		struct vfe_cmd_demosaic_bpc_update demo_bpc;
		if (copy_from_user(&demo_bpc,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_demosaic_bpc_update(&demo_bpc);
	}
		break;

	case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE: {
		struct vfe_cmd_demosaic_abf_update demo_abf;
		if (copy_from_user(&demo_abf,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_demosaic_abf_update(&demo_abf);
	}
		break;

	case VFE_CMD_ID_LA_UPDATE: {
		struct vfe_cmd_la_config la;
		if (copy_from_user(&la,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_la_update(&la);
	}
		break;

	case VFE_CMD_ID_RGB_GAMMA_UPDATE: {
		struct vfe_cmd_rgb_gamma_config rgb;
		if (copy_from_user(&rgb,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		rc = vfe_rgb_gamma_update(&rgb);
	}
		break;

	case VFE_CMD_ID_ASF_UPDATE: {
		struct vfe_cmd_asf_update asf;
		if (copy_from_user(&asf,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_asf_update(&asf);
	}
		break;

	case VFE_CMD_ID_FRAME_SKIP_UPDATE: {
		struct vfe_cmd_frame_skip_update fskip;
		if (copy_from_user(&fskip,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_frame_skip_update(&fskip);
	}
		break;

	case VFE_CMD_ID_CAMIF_FRAME_UPDATE: {
		struct vfe_cmds_camif_frame fup;
		if (copy_from_user(&fup,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_camif_frame_update(&fup);
	}
		break;

	/* stats update commands */
	case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE: {
		struct vfe_cmd_stats_af_update afup;
		if (copy_from_user(&afup,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_stats_update_af(&afup);
	}
		break;

	case VFE_CMD_ID_STATS_WB_EXP_UPDATE: {
		struct vfe_cmd_stats_wb_exp_update wbexp;
		if (copy_from_user(&wbexp,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_stats_update_wb_exp(&wbexp);
	}
		break;

	/* control of start, stop, update, etc... */
	case VFE_CMD_ID_STOP:
		vfe_stop();
		break;

	case VFE_CMD_ID_GET_HW_VERSION:
		break;

	/* stats */
	case VFE_CMD_ID_STATS_SETTING: {
		struct vfe_cmd_stats_setting stats;
		if (copy_from_user(&stats,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_stats_setting(&stats);
	}
		break;

	case VFE_CMD_ID_STATS_AUTOFOCUS_START: {
		struct vfe_cmd_stats_af_start af;
		if (copy_from_user(&af,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_stats_start_af(&af);
	}
		break;

	case VFE_CMD_ID_STATS_AUTOFOCUS_STOP:
		vfe_stats_af_stop();
		break;

	case VFE_CMD_ID_STATS_WB_EXP_START: {
		struct vfe_cmd_stats_wb_exp_start awexp;
		if (copy_from_user(&awexp,
			(void __user *) cmd->value, cmd->length))
			rc = -EFAULT;

		vfe_stats_start_wb_exp(&awexp);
	}
		break;

	case VFE_CMD_ID_STATS_WB_EXP_STOP:
		vfe_stats_wb_exp_stop();
		break;

	case VFE_CMD_ID_ASYNC_TIMER_SETTING:
		break;

	case VFE_CMD_ID_UPDATE:
		vfe_update();
		break;

	/* test gen */
	case VFE_CMD_ID_TEST_GEN_START:
		break;

/*
  acknowledge from upper layer
	these are not in general command.

	case VFE_CMD_ID_OUTPUT1_ACK:
		break;
	case VFE_CMD_ID_OUTPUT2_ACK:
		break;
	case VFE_CMD_ID_EPOCH1_ACK:
		break;
	case VFE_CMD_ID_EPOCH2_ACK:
		break;
	case VFE_CMD_ID_STATS_AUTOFOCUS_ACK:
		break;
	case VFE_CMD_ID_STATS_WB_EXP_ACK:
		break;
*/

	default:
		break;
	} /* switch */

	return rc;
}

static int vfe_config(struct msm_vfe_cfg_cmd *cmd, void *data)
{
	struct msm_pmem_region *regptr;
	struct msm_vfe_command_8k vfecmd;

	uint32_t i;

	void *cmd_data = NULL;
	long rc = 0;

	struct vfe_cmd_axi_output_config *axio = NULL;
	struct vfe_cmd_stats_setting *scfg = NULL;

	if (cmd->cmd_type != CMD_FRAME_BUF_RELEASE &&
	    cmd->cmd_type != CMD_STATS_BUF_RELEASE) {

		if (copy_from_user(&vfecmd,
				(void __user *)(cmd->value),
				sizeof(struct msm_vfe_command_8k)))
			return -EFAULT;
	}

	CDBG("vfe_config: cmdType = %d\n", cmd->cmd_type);

	switch (cmd->cmd_type) {
	case CMD_GENERAL:
		rc = vfe_proc_general(&vfecmd);
		break;

	case CMD_STATS_ENABLE:
	case CMD_STATS_AXI_CFG: {
		struct axidata *axid;

		axid = data;
		if (!axid)
			return -EFAULT;

		scfg =
			kmalloc(sizeof(struct vfe_cmd_stats_setting),
				GFP_ATOMIC);
		if (!scfg)
			return -ENOMEM;

		if (copy_from_user(scfg,
					(void __user *)(vfecmd.value),
					vfecmd.length)) {

			kfree(scfg);
			return -EFAULT;
		}

		regptr = axid->region;
		if (axid->bufnum1 > 0) {
			for (i = 0; i < axid->bufnum1; i++) {
				scfg->awbBuffer[i] =
					(uint32_t)(regptr->paddr);
				regptr++;
			}
		}

		if (axid->bufnum2 > 0) {
			for (i = 0; i < axid->bufnum2; i++) {
				scfg->afBuffer[i] =
					(uint32_t)(regptr->paddr);
				regptr++;
			}
		}

		vfe_stats_config(scfg);
	}
		break;

	case CMD_STATS_AF_AXI_CFG: {
	}
		break;

	case CMD_FRAME_BUF_RELEASE: {
		/* preview buffer release */
		struct msm_frame *b;
		unsigned long p;
		struct vfe_cmd_output_ack fack;

		if (!data)
			return -EFAULT;

		b = (struct msm_frame *)(cmd->value);
		p = *(unsigned long *)data;

		b->path = MSM_FRAME_ENC;

		fack.ybufaddr[0] =
			(uint32_t)(p + b->y_off);

		fack.chromabufaddr[0] =
			(uint32_t)(p + b->cbcr_off);

		if (b->path == MSM_FRAME_PREV_1)
			vfe_output1_ack(&fack);

		if (b->path == MSM_FRAME_ENC ||
		    b->path == MSM_FRAME_PREV_2)
			vfe_output2_ack(&fack);
	}
		break;

	case CMD_SNAP_BUF_RELEASE: {
	}
		break;

	case CMD_STATS_BUF_RELEASE: {
		struct vfe_cmd_stats_wb_exp_ack sack;

		if (!data)
			return -EFAULT;

		sack.nextWbExpOutputBufferAddr = *(uint32_t *)data;
		vfe_stats_wb_exp_ack(&sack);
	}
		break;

	case CMD_AXI_CFG_OUT1: {
		struct axidata *axid;

		axid = data;
		if (!axid)
			return -EFAULT;

		axio = memdup_user((void __user *)(vfecmd.value),
				   sizeof(struct vfe_cmd_axi_output_config));
		if (IS_ERR(axio))
			return PTR_ERR(axio);

		vfe_config_axi(OUTPUT_1, axid, axio);
		vfe_axi_output_config(axio);
	}
		break;

	case CMD_AXI_CFG_OUT2:
	case CMD_RAW_PICT_AXI_CFG: {
		struct axidata *axid;

		axid = data;
		if (!axid)
			return -EFAULT;

		axio = memdup_user((void __user *)(vfecmd.value),
				   sizeof(struct vfe_cmd_axi_output_config));
		if (IS_ERR(axio))
			return PTR_ERR(axio);

		vfe_config_axi(OUTPUT_2, axid, axio);

		axio->outputDataSize = 0;
		vfe_axi_output_config(axio);
	}
		break;

	case CMD_AXI_CFG_SNAP_O1_AND_O2: {
		struct axidata *axid;
		axid = data;
		if (!axid)
			return -EFAULT;

		axio = memdup_user((void __user *)(vfecmd.value),
				   sizeof(struct vfe_cmd_axi_output_config));
		if (IS_ERR(axio))
			return PTR_ERR(axio);

		vfe_config_axi(OUTPUT_1_AND_2,
			axid, axio);
		vfe_axi_output_config(axio);
		cmd_data = axio;
	}
		break;

	default:
		break;
	} /* switch */

	kfree(scfg);

	kfree(axio);

/*
	if (cmd->length > 256 &&
			cmd_data &&
			(cmd->cmd_type == CMD_GENERAL ||
			 cmd->cmd_type == CMD_STATS_DISABLE)) {
		kfree(cmd_data);
	}
*/
	return rc;
}

static int vfe_init(struct msm_vfe_callback *presp,
	struct platform_device *dev)
{
	int rc = 0;

	rc = vfe_cmd_init(presp, dev, vfe_syncdata);
	if (rc < 0)
		return rc;

	/* Bring up all the required GPIOs and Clocks */
	return msm_camio_enable(dev);
}

void msm_camvfe_fn_init(struct msm_camvfe_fn *fptr, void *data)
{
	mutex_init(&vfe_lock);
	fptr->vfe_init    = vfe_init;
	fptr->vfe_enable  = vfe_enable;
	fptr->vfe_config  = vfe_config;
	fptr->vfe_disable = vfe_disable;
	fptr->vfe_release = vfe_release;
	vfe_syncdata = data;
}
Commit	Line	Data
eb7b797b BS	1	/*
	2	* Copyright (C) 2008-2009 QUALCOMM Incorporated.
	3	*/
5a0e3ad6	4	#include <linux/slab.h>
eb7b797b BS	5	#include <linux/uaccess.h>
	6	#include <linux/interrupt.h>
	7	#include <mach/irqs.h>
	8	#include "msm_vfe8x_proc.h"
	9
	10	#define ON 1
	11	#define OFF 0
	12
	13	struct mutex vfe_lock;
	14	static void *vfe_syncdata;
	15
	16	static int vfe_enable(struct camera_enable_cmd *enable)
	17	{
	18	int rc = 0;
	19	return rc;
	20	}
	21
	22	static int vfe_disable(struct camera_enable_cmd *enable,
	23	struct platform_device *dev)
	24	{
	25	int rc = 0;
	26
	27	vfe_stop();
	28
	29	msm_camio_disable(dev);
	30	return rc;
	31	}
	32
	33	static void vfe_release(struct platform_device *dev)
	34	{
	35	msm_camio_disable(dev);
	36	vfe_cmd_release(dev);
	37
	38	mutex_lock(&vfe_lock);
	39	vfe_syncdata = NULL;
	40	mutex_unlock(&vfe_lock);
	41	}
	42
	43	static void vfe_config_axi(int mode,
	44	struct axidata ad, struct vfe_cmd_axi_output_config ao)
	45	{
	46	struct msm_pmem_region *regptr;
	47	int i, j;
	48	uint32_t p1, p2;
	49
	50	if (mode == OUTPUT_1 \|\| mode == OUTPUT_1_AND_2) {
	51	regptr = ad->region;
	52	for (i = 0;
	53	i < ad->bufnum1; i++) {
	54
	55	p1 = &(ao->output1.outputY.outFragments[i][0]);
	56	p2 = &(ao->output1.outputCbcr.outFragments[i][0]);
	57
	58	for (j = 0;
	59	j < ao->output1.fragmentCount; j++) {
	60
	61	*p1 = regptr->paddr + regptr->y_off;
	62	p1++;
	63
	64	*p2 = regptr->paddr + regptr->cbcr_off;
	65	p2++;
	66	}
	67	regptr++;
	68	}
69	} /* if OUTPUT1 or Both */
70
71	if (mode == OUTPUT_2 \|\| mode == OUTPUT_1_AND_2) {
72
73	regptr = &(ad->region[ad->bufnum1]);
74	CDBG("bufnum2 = %d\n", ad->bufnum2);
75
76	for (i = 0;
77	i < ad->bufnum2; i++) {
78
79	p1 = &(ao->output2.outputY.outFragments[i][0]);
80	p2 = &(ao->output2.outputCbcr.outFragments[i][0]);
81
82	CDBG("config_axi: O2, phy = 0x%lx, y_off = %d, cbcr_off = %d\n",
83	regptr->paddr, regptr->y_off, regptr->cbcr_off);
84
85	for (j = 0;
86	j < ao->output2.fragmentCount; j++) {
87
88	*p1 = regptr->paddr + regptr->y_off;
89	CDBG("vfe_config_axi: p1 = 0x%x\n", *p1);
90	p1++;
91
92	*p2 = regptr->paddr + regptr->cbcr_off;
93	CDBG("vfe_config_axi: p2 = 0x%x\n", *p2);
94	p2++;
95	}
96	regptr++;
97	}
98	}
99	}
100
101	static int vfe_proc_general(struct msm_vfe_command_8k *cmd)
102	{
103	int rc = 0;
104
105	CDBG("vfe_proc_general: cmdID = %d\n", cmd->id);
106
107	switch (cmd->id) {
108	case VFE_CMD_ID_RESET:
109	msm_camio_vfe_blk_reset();
110	msm_camio_camif_pad_reg_reset_2();
111	vfe_reset();
112	break;
113
114	case VFE_CMD_ID_START: {
115	struct vfe_cmd_start start;
116	if (copy_from_user(&start,
117	(void __user *) cmd->value, cmd->length))
118	rc = -EFAULT;
119
120	/* msm_camio_camif_pad_reg_reset_2(); */
121	msm_camio_camif_pad_reg_reset();
122	vfe_start(&start);
123	}
124	break;
125
126	case VFE_CMD_ID_CAMIF_CONFIG: {
127	struct vfe_cmd_camif_config camif;
128	if (copy_from_user(&camif,
129	(void __user *) cmd->value, cmd->length))
130	rc = -EFAULT;
131
132	vfe_camif_config(&camif);
133	}
134	break;
135
136	case VFE_CMD_ID_BLACK_LEVEL_CONFIG: {
137	struct vfe_cmd_black_level_config bl;
138	if (copy_from_user(&bl,
139	(void __user *) cmd->value, cmd->length))
140	rc = -EFAULT;
141
142	vfe_black_level_config(&bl);
143	}
144	break;
145
146	case VFE_CMD_ID_ROLL_OFF_CONFIG: {
147	struct vfe_cmd_roll_off_config rolloff;
148	if (copy_from_user(&rolloff,
149	(void __user *) cmd->value, cmd->length))
150	rc = -EFAULT;
151
152	vfe_roll_off_config(&rolloff);
153	}
154	break;
155
156	case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG: {
157	struct vfe_cmd_demux_channel_gain_config demuxc;
158	if (copy_from_user(&demuxc,
159	(void __user *) cmd->value, cmd->length))
160	rc = -EFAULT;
161
162	/* demux is always enabled. */
163	vfe_demux_channel_gain_config(&demuxc);
164	}
165	break;
166
167	case VFE_CMD_ID_DEMOSAIC_CONFIG: {
168	struct vfe_cmd_demosaic_config demosaic;
169	if (copy_from_user(&demosaic,
170	(void __user *) cmd->value, cmd->length))
171	rc = -EFAULT;
172
173	vfe_demosaic_config(&demosaic);
174	}
175	break;
176
177	case VFE_CMD_ID_FOV_CROP_CONFIG:
178	case VFE_CMD_ID_FOV_CROP_UPDATE: {
179	struct vfe_cmd_fov_crop_config fov;
180	if (copy_from_user(&fov,
181	(void __user *) cmd->value, cmd->length))
182	rc = -EFAULT;
183
184	vfe_fov_crop_config(&fov);
185	}
186	break;
187
188	case VFE_CMD_ID_MAIN_SCALER_CONFIG:
189	case VFE_CMD_ID_MAIN_SCALER_UPDATE: {
190	struct vfe_cmd_main_scaler_config mainds;
191	if (copy_from_user(&mainds,
192	(void __user *) cmd->value, cmd->length))
193	rc = -EFAULT;
194
195	vfe_main_scaler_config(&mainds);
196	}
197	break;
198
199	case VFE_CMD_ID_WHITE_BALANCE_CONFIG:
200	case VFE_CMD_ID_WHITE_BALANCE_UPDATE: {
201	struct vfe_cmd_white_balance_config wb;
202	if (copy_from_user(&wb,
203	(void __user *) cmd->value, cmd->length))
204	rc = -EFAULT;
205
206	vfe_white_balance_config(&wb);
207	}
208	break;
209
210	case VFE_CMD_ID_COLOR_CORRECTION_CONFIG:
211	case VFE_CMD_ID_COLOR_CORRECTION_UPDATE: {
212	struct vfe_cmd_color_correction_config cc;
213	if (copy_from_user(&cc,
214	(void __user *) cmd->value, cmd->length))
215	rc = -EFAULT;
216
217	vfe_color_correction_config(&cc);
218	}
219	break;
220
221	case VFE_CMD_ID_LA_CONFIG: {
222	struct vfe_cmd_la_config la;
223	if (copy_from_user(&la,
224	(void __user *) cmd->value, cmd->length))
225	rc = -EFAULT;
226
227	vfe_la_config(&la);
228	}
229	break;
230
231	case VFE_CMD_ID_RGB_GAMMA_CONFIG: {
232	struct vfe_cmd_rgb_gamma_config rgb;
233	if (copy_from_user(&rgb,
234	(void __user *) cmd->value, cmd->length))
235	rc = -EFAULT;
236
237	rc = vfe_rgb_gamma_config(&rgb);
238	}
239	break;
240
241	case VFE_CMD_ID_CHROMA_ENHAN_CONFIG:
242	case VFE_CMD_ID_CHROMA_ENHAN_UPDATE: {
243	struct vfe_cmd_chroma_enhan_config chrom;
244	if (copy_from_user(&chrom,
245	(void __user *) cmd->value, cmd->length))
246	rc = -EFAULT;
247
248	vfe_chroma_enhan_config(&chrom);
249	}
250	break;
251
252	case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG:
253	case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE: {
254	struct vfe_cmd_chroma_suppression_config chromsup;
255	if (copy_from_user(&chromsup,
256	(void __user *) cmd->value, cmd->length))
257	rc = -EFAULT;
258
259	vfe_chroma_sup_config(&chromsup);
260	}
261	break;
262
263	case VFE_CMD_ID_ASF_CONFIG: {
264	struct vfe_cmd_asf_config asf;
265	if (copy_from_user(&asf,
266	(void __user *) cmd->value, cmd->length))
267	rc = -EFAULT;
268
269	vfe_asf_config(&asf);
270	}
271	break;
272
273	case VFE_CMD_ID_SCALER2Y_CONFIG:
274	case VFE_CMD_ID_SCALER2Y_UPDATE: {
275	struct vfe_cmd_scaler2_config ds2y;
276	if (copy_from_user(&ds2y,
277	(void __user *) cmd->value, cmd->length))
278	rc = -EFAULT;
279
280	vfe_scaler2y_config(&ds2y);
281	}
282	break;
283
284	case VFE_CMD_ID_SCALER2CbCr_CONFIG:
285	case VFE_CMD_ID_SCALER2CbCr_UPDATE: {
286	struct vfe_cmd_scaler2_config ds2cbcr;
287	if (copy_from_user(&ds2cbcr,
288	(void __user *) cmd->value, cmd->length))
289	rc = -EFAULT;
290
291	vfe_scaler2cbcr_config(&ds2cbcr);
292	}
293	break;
294
295	case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG: {
296	struct vfe_cmd_chroma_subsample_config sub;
297	if (copy_from_user(&sub,
298	(void __user *) cmd->value, cmd->length))
299	rc = -EFAULT;
300
301	vfe_chroma_subsample_config(&sub);
302	}
303	break;
304
305	case VFE_CMD_ID_FRAME_SKIP_CONFIG: {
306	struct vfe_cmd_frame_skip_config fskip;
307	if (copy_from_user(&fskip,
308	(void __user *) cmd->value, cmd->length))
309	rc = -EFAULT;
310
311	vfe_frame_skip_config(&fskip);
312	}
313	break;
314
315	case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG: {
316	struct vfe_cmd_output_clamp_config clamp;
317	if (copy_from_user(&clamp,
318	(void __user *) cmd->value, cmd->length))
319	rc = -EFAULT;
320
321	vfe_output_clamp_config(&clamp);
322	}
323	break;
324
325	/* module update commands */
326	case VFE_CMD_ID_BLACK_LEVEL_UPDATE: {
327	struct vfe_cmd_black_level_config blk;
328	if (copy_from_user(&blk,
329	(void __user *) cmd->value, cmd->length))
330	rc = -EFAULT;
331
332	vfe_black_level_update(&blk);
333	}
334	break;
335
336	case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE: {
337	struct vfe_cmd_demux_channel_gain_config dmu;
338	if (copy_from_user(&dmu,
339	(void __user *) cmd->value, cmd->length))
340	rc = -EFAULT;
341
342	vfe_demux_channel_gain_update(&dmu);
343	}
344	break;
345
346	case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE: {
347	struct vfe_cmd_demosaic_bpc_update demo_bpc;
348	if (copy_from_user(&demo_bpc,
349	(void __user *) cmd->value, cmd->length))
350	rc = -EFAULT;
351
352	vfe_demosaic_bpc_update(&demo_bpc);
353	}
354	break;
355
356	case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE: {
357	struct vfe_cmd_demosaic_abf_update demo_abf;
358	if (copy_from_user(&demo_abf,
359	(void __user *) cmd->value, cmd->length))
360	rc = -EFAULT;
361
362	vfe_demosaic_abf_update(&demo_abf);
363	}
364	break;
365
366	case VFE_CMD_ID_LA_UPDATE: {
367	struct vfe_cmd_la_config la;
368	if (copy_from_user(&la,
369	(void __user *) cmd->value, cmd->length))
370	rc = -EFAULT;
371
372	vfe_la_update(&la);
373	}
374	break;
375
376	case VFE_CMD_ID_RGB_GAMMA_UPDATE: {
377	struct vfe_cmd_rgb_gamma_config rgb;
378	if (copy_from_user(&rgb,
379	(void __user *) cmd->value, cmd->length))
380	rc = -EFAULT;
381
382	rc = vfe_rgb_gamma_update(&rgb);
383	}
384	break;
385
386	case VFE_CMD_ID_ASF_UPDATE: {
387	struct vfe_cmd_asf_update asf;
388	if (copy_from_user(&asf,
389	(void __user *) cmd->value, cmd->length))
390	rc = -EFAULT;
391
392	vfe_asf_update(&asf);
393	}
394	break;
395
396	case VFE_CMD_ID_FRAME_SKIP_UPDATE: {
397	struct vfe_cmd_frame_skip_update fskip;
398	if (copy_from_user(&fskip,
399	(void __user *) cmd->value, cmd->length))
400	rc = -EFAULT;
401
402	vfe_frame_skip_update(&fskip);
403	}
404	break;
405
406	case VFE_CMD_ID_CAMIF_FRAME_UPDATE: {
407	struct vfe_cmds_camif_frame fup;
408	if (copy_from_user(&fup,
409	(void __user *) cmd->value, cmd->length))
410	rc = -EFAULT;
411
412	vfe_camif_frame_update(&fup);
413	}
414	break;
415
416	/* stats update commands */
417	case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE: {
418	struct vfe_cmd_stats_af_update afup;
419	if (copy_from_user(&afup,
420	(void __user *) cmd->value, cmd->length))
421	rc = -EFAULT;
422
423	vfe_stats_update_af(&afup);
424	}
425	break;
426
427	case VFE_CMD_ID_STATS_WB_EXP_UPDATE: {
428	struct vfe_cmd_stats_wb_exp_update wbexp;
429	if (copy_from_user(&wbexp,
430	(void __user *) cmd->value, cmd->length))
431	rc = -EFAULT;
432
433	vfe_stats_update_wb_exp(&wbexp);
434	}
435	break;
436
437	/* control of start, stop, update, etc... */
438	case VFE_CMD_ID_STOP:
439	vfe_stop();
440	break;
441
442	case VFE_CMD_ID_GET_HW_VERSION:
443	break;
444
445	/* stats */
446	case VFE_CMD_ID_STATS_SETTING: {
447	struct vfe_cmd_stats_setting stats;
448	if (copy_from_user(&stats,
449	(void __user *) cmd->value, cmd->length))
450	rc = -EFAULT;
451
452	vfe_stats_setting(&stats);
453	}
454	break;
455
456	case VFE_CMD_ID_STATS_AUTOFOCUS_START: {
457	struct vfe_cmd_stats_af_start af;
458	if (copy_from_user(&af,
459	(void __user *) cmd->value, cmd->length))
460	rc = -EFAULT;
461
462	vfe_stats_start_af(&af);
463	}
464	break;
465
466	case VFE_CMD_ID_STATS_AUTOFOCUS_STOP:
467	vfe_stats_af_stop();
468	break;
469
470	case VFE_CMD_ID_STATS_WB_EXP_START: {
471	struct vfe_cmd_stats_wb_exp_start awexp;
472	if (copy_from_user(&awexp,
473	(void __user *) cmd->value, cmd->length))
474	rc = -EFAULT;
475
476	vfe_stats_start_wb_exp(&awexp);
477	}
478	break;
479
480	case VFE_CMD_ID_STATS_WB_EXP_STOP:
481	vfe_stats_wb_exp_stop();
482	break;
483
484	case VFE_CMD_ID_ASYNC_TIMER_SETTING:
485	break;
486
487	case VFE_CMD_ID_UPDATE:
488	vfe_update();
489	break;
490
491	/* test gen */
492	case VFE_CMD_ID_TEST_GEN_START:
493	break;
494
495	/*
496	acknowledge from upper layer
497	these are not in general command.
498
499	case VFE_CMD_ID_OUTPUT1_ACK:
500	break;
501	case VFE_CMD_ID_OUTPUT2_ACK:
502	break;
503	case VFE_CMD_ID_EPOCH1_ACK:
504	break;
505	case VFE_CMD_ID_EPOCH2_ACK:
506	break;
507	case VFE_CMD_ID_STATS_AUTOFOCUS_ACK:
508	break;
509	case VFE_CMD_ID_STATS_WB_EXP_ACK:
510	break;
511	*/
512
513	default:
514	break;
515	} /* switch */
516
517	return rc;
518	}
519
520	static int vfe_config(struct msm_vfe_cfg_cmd cmd, void data)
521	{
522	struct msm_pmem_region *regptr;
523	struct msm_vfe_command_8k vfecmd;
524
525	uint32_t i;
526
527	void *cmd_data = NULL;
528	long rc = 0;
529
530	struct vfe_cmd_axi_output_config *axio = NULL;
531	struct vfe_cmd_stats_setting *scfg = NULL;
532
533	if (cmd->cmd_type != CMD_FRAME_BUF_RELEASE &&
534	cmd->cmd_type != CMD_STATS_BUF_RELEASE) {
535
536	if (copy_from_user(&vfecmd,
537	(void __user *)(cmd->value),
538	sizeof(struct msm_vfe_command_8k)))
539	return -EFAULT;
540	}
541
542	CDBG("vfe_config: cmdType = %d\n", cmd->cmd_type);
543
544	switch (cmd->cmd_type) {
545	case CMD_GENERAL:
546	rc = vfe_proc_general(&vfecmd);
547	break;
548
549	case CMD_STATS_ENABLE:
550	case CMD_STATS_AXI_CFG: {
551	struct axidata *axid;
552
553	axid = data;
554	if (!axid)
555	return -EFAULT;
556
557	scfg =
558	kmalloc(sizeof(struct vfe_cmd_stats_setting),
559	GFP_ATOMIC);
560	if (!scfg)
561	return -ENOMEM;
562
563	if (copy_from_user(scfg,
564	(void __user *)(vfecmd.value),
565	vfecmd.length)) {
566
567	kfree(scfg);
568	return -EFAULT;
569	}
570
571	regptr = axid->region;
572	if (axid->bufnum1 > 0) {
573	for (i = 0; i < axid->bufnum1; i++) {
574	scfg->awbBuffer[i] =
575	(uint32_t)(regptr->paddr);
576	regptr++;
577	}
578	}
579
580	if (axid->bufnum2 > 0) {
581	for (i = 0; i < axid->bufnum2; i++) {
582	scfg->afBuffer[i] =
583	(uint32_t)(regptr->paddr);
584	regptr++;
585	}
586	}
587
588	vfe_stats_config(scfg);
589	}
590	break;
591
592	case CMD_STATS_AF_AXI_CFG: {
593	}
594	break;
595
596	case CMD_FRAME_BUF_RELEASE: {
597	/* preview buffer release */
598	struct msm_frame *b;
599	unsigned long p;
600	struct vfe_cmd_output_ack fack;
601
602	if (!data)
603	return -EFAULT;
604
605	b = (struct msm_frame *)(cmd->value);
606	p = (unsigned long )data;
607
608	b->path = MSM_FRAME_ENC;
609
610	fack.ybufaddr[0] =
611	(uint32_t)(p + b->y_off);
612
613	fack.chromabufaddr[0] =
614	(uint32_t)(p + b->cbcr_off);
615
616	if (b->path == MSM_FRAME_PREV_1)
617	vfe_output1_ack(&fack);
618
619	if (b->path == MSM_FRAME_ENC \|\|
620	b->path == MSM_FRAME_PREV_2)
621	vfe_output2_ack(&fack);
622	}
623	break;
624
625	case CMD_SNAP_BUF_RELEASE: {
626	}
627	break;
628
629	case CMD_STATS_BUF_RELEASE: {
630	struct vfe_cmd_stats_wb_exp_ack sack;
631
632	if (!data)
633	return -EFAULT;
634
635	sack.nextWbExpOutputBufferAddr = (uint32_t )data;
636	vfe_stats_wb_exp_ack(&sack);
637	}
638	break;
639
640	case CMD_AXI_CFG_OUT1: {
641	struct axidata *axid;
642
643	axid = data;
644	if (!axid)
645	return -EFAULT;
646
37a18632 JL	647	axio = memdup_user((void __user *)(vfecmd.value),
	648	sizeof(struct vfe_cmd_axi_output_config));
	649	if (IS_ERR(axio))
	650	return PTR_ERR(axio);
eb7b797b BS	651
	652	vfe_config_axi(OUTPUT_1, axid, axio);
	653	vfe_axi_output_config(axio);
	654	}
	655	break;
	656
	657	case CMD_AXI_CFG_OUT2:
	658	case CMD_RAW_PICT_AXI_CFG: {
	659	struct axidata *axid;
	660
	661	axid = data;
	662	if (!axid)
	663	return -EFAULT;
	664
37a18632 JL	665	axio = memdup_user((void __user *)(vfecmd.value),
	666	sizeof(struct vfe_cmd_axi_output_config));
	667	if (IS_ERR(axio))
	668	return PTR_ERR(axio);
eb7b797b BS	669
	670	vfe_config_axi(OUTPUT_2, axid, axio);
	671
	672	axio->outputDataSize = 0;
	673	vfe_axi_output_config(axio);
	674	}
	675	break;
	676
	677	case CMD_AXI_CFG_SNAP_O1_AND_O2: {
	678	struct axidata *axid;
	679	axid = data;
	680	if (!axid)
	681	return -EFAULT;
	682
37a18632 JL	683	axio = memdup_user((void __user *)(vfecmd.value),
	684	sizeof(struct vfe_cmd_axi_output_config));
	685	if (IS_ERR(axio))
	686	return PTR_ERR(axio);
eb7b797b BS	687
	688	vfe_config_axi(OUTPUT_1_AND_2,
	689	axid, axio);
	690	vfe_axi_output_config(axio);
	691	cmd_data = axio;
	692	}
	693	break;
	694
	695	default:
	696	break;
	697	} /* switch */
	698
	699	kfree(scfg);
	700
	701	kfree(axio);
	702
	703	/*
	704	if (cmd->length > 256 &&
	705	cmd_data &&
	706	(cmd->cmd_type == CMD_GENERAL \|\|
	707	cmd->cmd_type == CMD_STATS_DISABLE)) {
	708	kfree(cmd_data);
	709	}
	710	*/
	711	return rc;
	712	}
	713
	714	static int vfe_init(struct msm_vfe_callback *presp,
	715	struct platform_device *dev)
	716	{
	717	int rc = 0;
	718
	719	rc = vfe_cmd_init(presp, dev, vfe_syncdata);
	720	if (rc < 0)
	721	return rc;
	722
	723	/* Bring up all the required GPIOs and Clocks */
	724	return msm_camio_enable(dev);
	725	}
	726
	727	void msm_camvfe_fn_init(struct msm_camvfe_fn fptr, void data)
	728	{
	729	mutex_init(&vfe_lock);
	730	fptr->vfe_init = vfe_init;
	731	fptr->vfe_enable = vfe_enable;
	732	fptr->vfe_config = vfe_config;
	733	fptr->vfe_disable = vfe_disable;
	734	fptr->vfe_release = vfe_release;
	735	vfe_syncdata = data;
	736	}