drivers/media/platform/omap3isp/isph3a_aewb.c - kernel/lockdown - Git at Google

 /*
  * isph3a.c
  *
  * TI OMAP3 ISP - H3A module
  *
  * Copyright (C) 2010 Nokia Corporation
  * Copyright (C) 2009 Texas Instruments, Inc.
  *
  * Contacts: David Cohen <dacohen@gmail.com>
  *	     Laurent Pinchart <laurent.pinchart@ideasonboard.com>
  *	     Sakari Ailus <sakari.ailus@iki.fi>
  *
  * 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 <linux/slab.h>
 #include <linux/uaccess.h>

 #include "isp.h"
 #include "isph3a.h"
 #include "ispstat.h"

 /*
  * h3a_aewb_update_regs - Helper function to update h3a registers.
  */
 static void h3a_aewb_setup_regs(struct ispstat *aewb, void *priv)
 {
 	struct omap3isp_h3a_aewb_config *conf = priv;
 	u32 pcr;
 	u32 win1;
 	u32 start;
 	u32 blk;
 	u32 subwin;

 	if (aewb->state == ISPSTAT_DISABLED)
 		return;

 	isp_reg_writel(aewb->isp, aewb->active_buf->dma_addr,
 		       OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWBUFST);

 	if (!aewb->update)
 		return;

 	/* Converting config metadata into reg values */
 	pcr = conf->saturation_limit << ISPH3A_PCR_AEW_AVE2LMT_SHIFT;
 	pcr |= !!conf->alaw_enable << ISPH3A_PCR_AEW_ALAW_EN_SHIFT;

 	win1 = ((conf->win_height >> 1) - 1) << ISPH3A_AEWWIN1_WINH_SHIFT;
 	win1 |= ((conf->win_width >> 1) - 1) << ISPH3A_AEWWIN1_WINW_SHIFT;
 	win1 |= (conf->ver_win_count - 1) << ISPH3A_AEWWIN1_WINVC_SHIFT;
 	win1 |= (conf->hor_win_count - 1) << ISPH3A_AEWWIN1_WINHC_SHIFT;

 	start = conf->hor_win_start << ISPH3A_AEWINSTART_WINSH_SHIFT;
 	start |= conf->ver_win_start << ISPH3A_AEWINSTART_WINSV_SHIFT;

 	blk = conf->blk_ver_win_start << ISPH3A_AEWINBLK_WINSV_SHIFT;
 	blk |= ((conf->blk_win_height >> 1) - 1) << ISPH3A_AEWINBLK_WINH_SHIFT;

 	subwin = ((conf->subsample_ver_inc >> 1) - 1) <<
 		 ISPH3A_AEWSUBWIN_AEWINCV_SHIFT;
 	subwin |= ((conf->subsample_hor_inc >> 1) - 1) <<
 		  ISPH3A_AEWSUBWIN_AEWINCH_SHIFT;

 	isp_reg_writel(aewb->isp, win1, OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWWIN1);
 	isp_reg_writel(aewb->isp, start, OMAP3_ISP_IOMEM_H3A,
 		       ISPH3A_AEWINSTART);
 	isp_reg_writel(aewb->isp, blk, OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWINBLK);
 	isp_reg_writel(aewb->isp, subwin, OMAP3_ISP_IOMEM_H3A,
 		       ISPH3A_AEWSUBWIN);
 	isp_reg_clr_set(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
 			ISPH3A_PCR_AEW_MASK, pcr);

 	aewb->update = 0;
 	aewb->config_counter += aewb->inc_config;
 	aewb->inc_config = 0;
 	aewb->buf_size = conf->buf_size;
 }

 static void h3a_aewb_enable(struct ispstat *aewb, int enable)
 {
 	if (enable) {
 		isp_reg_set(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
 			    ISPH3A_PCR_AEW_EN);
 		omap3isp_subclk_enable(aewb->isp, OMAP3_ISP_SUBCLK_AEWB);
 	} else {
 		isp_reg_clr(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
 			    ISPH3A_PCR_AEW_EN);
 		omap3isp_subclk_disable(aewb->isp, OMAP3_ISP_SUBCLK_AEWB);
 	}
 }

 static int h3a_aewb_busy(struct ispstat *aewb)
 {
 	return isp_reg_readl(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR)
 						& ISPH3A_PCR_BUSYAEAWB;
 }

 static u32 h3a_aewb_get_buf_size(struct omap3isp_h3a_aewb_config *conf)
 {
 	/* Number of configured windows + extra row for black data */
 	u32 win_count = (conf->ver_win_count + 1) * conf->hor_win_count;

 	/*
 	 * Unsaturated block counts for each 8 windows.
 	 * 1 extra for the last (win_count % 8) windows if win_count is not
 	 * divisible by 8.
 	 */
 	win_count += (win_count + 7) / 8;

 	return win_count * AEWB_PACKET_SIZE;
 }

 static int h3a_aewb_validate_params(struct ispstat *aewb, void *new_conf)
 {
 	struct omap3isp_h3a_aewb_config *user_cfg = new_conf;
 	u32 buf_size;

 	if (unlikely(user_cfg->saturation_limit >
 		     OMAP3ISP_AEWB_MAX_SATURATION_LIM))
 		return -EINVAL;

 	if (unlikely(user_cfg->win_height < OMAP3ISP_AEWB_MIN_WIN_H ||
 		     user_cfg->win_height > OMAP3ISP_AEWB_MAX_WIN_H ||
 		     user_cfg->win_height & 0x01))
 		return -EINVAL;

 	if (unlikely(user_cfg->win_width < OMAP3ISP_AEWB_MIN_WIN_W ||
 		     user_cfg->win_width > OMAP3ISP_AEWB_MAX_WIN_W ||
 		     user_cfg->win_width & 0x01))
 		return -EINVAL;

 	if (unlikely(user_cfg->ver_win_count < OMAP3ISP_AEWB_MIN_WINVC ||
 		     user_cfg->ver_win_count > OMAP3ISP_AEWB_MAX_WINVC))
 		return -EINVAL;

 	if (unlikely(user_cfg->hor_win_count < OMAP3ISP_AEWB_MIN_WINHC ||
 		     user_cfg->hor_win_count > OMAP3ISP_AEWB_MAX_WINHC))
 		return -EINVAL;

 	if (unlikely(user_cfg->ver_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
 		return -EINVAL;

 	if (unlikely(user_cfg->hor_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
 		return -EINVAL;

 	if (unlikely(user_cfg->blk_ver_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
 		return -EINVAL;

 	if (unlikely(user_cfg->blk_win_height < OMAP3ISP_AEWB_MIN_WIN_H ||
 		     user_cfg->blk_win_height > OMAP3ISP_AEWB_MAX_WIN_H ||
 		     user_cfg->blk_win_height & 0x01))
 		return -EINVAL;

 	if (unlikely(user_cfg->subsample_ver_inc < OMAP3ISP_AEWB_MIN_SUB_INC ||
 		     user_cfg->subsample_ver_inc > OMAP3ISP_AEWB_MAX_SUB_INC ||
 		     user_cfg->subsample_ver_inc & 0x01))
 		return -EINVAL;

 	if (unlikely(user_cfg->subsample_hor_inc < OMAP3ISP_AEWB_MIN_SUB_INC ||
 		     user_cfg->subsample_hor_inc > OMAP3ISP_AEWB_MAX_SUB_INC ||
 		     user_cfg->subsample_hor_inc & 0x01))
 		return -EINVAL;

 	buf_size = h3a_aewb_get_buf_size(user_cfg);
 	if (buf_size > user_cfg->buf_size)
 		user_cfg->buf_size = buf_size;
 	else if (user_cfg->buf_size > OMAP3ISP_AEWB_MAX_BUF_SIZE)
 		user_cfg->buf_size = OMAP3ISP_AEWB_MAX_BUF_SIZE;

 	return 0;
 }

 /*
  * h3a_aewb_set_params - Helper function to check & store user given params.
  * @new_conf: Pointer to AE and AWB parameters struct.
  *
  * As most of them are busy-lock registers, need to wait until AEW_BUSY = 0 to
  * program them during ISR.
  */
 static void h3a_aewb_set_params(struct ispstat *aewb, void *new_conf)
 {
 	struct omap3isp_h3a_aewb_config *user_cfg = new_conf;
 	struct omap3isp_h3a_aewb_config *cur_cfg = aewb->priv;
 	int update = 0;

 	if (cur_cfg->saturation_limit != user_cfg->saturation_limit) {
 		cur_cfg->saturation_limit = user_cfg->saturation_limit;
 		update = 1;
 	}
 	if (cur_cfg->alaw_enable != user_cfg->alaw_enable) {
 		cur_cfg->alaw_enable = user_cfg->alaw_enable;
 		update = 1;
 	}
 	if (cur_cfg->win_height != user_cfg->win_height) {
 		cur_cfg->win_height = user_cfg->win_height;
 		update = 1;
 	}
 	if (cur_cfg->win_width != user_cfg->win_width) {
 		cur_cfg->win_width = user_cfg->win_width;
 		update = 1;
 	}
 	if (cur_cfg->ver_win_count != user_cfg->ver_win_count) {
 		cur_cfg->ver_win_count = user_cfg->ver_win_count;
 		update = 1;
 	}
 	if (cur_cfg->hor_win_count != user_cfg->hor_win_count) {
 		cur_cfg->hor_win_count = user_cfg->hor_win_count;
 		update = 1;
 	}
 	if (cur_cfg->ver_win_start != user_cfg->ver_win_start) {
 		cur_cfg->ver_win_start = user_cfg->ver_win_start;
 		update = 1;
 	}
 	if (cur_cfg->hor_win_start != user_cfg->hor_win_start) {
 		cur_cfg->hor_win_start = user_cfg->hor_win_start;
 		update = 1;
 	}
 	if (cur_cfg->blk_ver_win_start != user_cfg->blk_ver_win_start) {
 		cur_cfg->blk_ver_win_start = user_cfg->blk_ver_win_start;
 		update = 1;
 	}
 	if (cur_cfg->blk_win_height != user_cfg->blk_win_height) {
 		cur_cfg->blk_win_height = user_cfg->blk_win_height;
 		update = 1;
 	}
 	if (cur_cfg->subsample_ver_inc != user_cfg->subsample_ver_inc) {
 		cur_cfg->subsample_ver_inc = user_cfg->subsample_ver_inc;
 		update = 1;
 	}
 	if (cur_cfg->subsample_hor_inc != user_cfg->subsample_hor_inc) {
 		cur_cfg->subsample_hor_inc = user_cfg->subsample_hor_inc;
 		update = 1;
 	}

 	if (update || !aewb->configured) {
 		aewb->inc_config++;
 		aewb->update = 1;
 		cur_cfg->buf_size = h3a_aewb_get_buf_size(cur_cfg);
 	}
 }

 static long h3a_aewb_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 {
 	struct ispstat *stat = v4l2_get_subdevdata(sd);

 	switch (cmd) {
 	case VIDIOC_OMAP3ISP_AEWB_CFG:
 		return omap3isp_stat_config(stat, arg);
 	case VIDIOC_OMAP3ISP_STAT_REQ:
 		return omap3isp_stat_request_statistics(stat, arg);
 	case VIDIOC_OMAP3ISP_STAT_EN: {
 		unsigned long *en = arg;
 		return omap3isp_stat_enable(stat, !!*en);
 	}
 	}

 	return -ENOIOCTLCMD;
 }

 static const struct ispstat_ops h3a_aewb_ops = {
 	.validate_params	= h3a_aewb_validate_params,
 	.set_params		= h3a_aewb_set_params,
 	.setup_regs		= h3a_aewb_setup_regs,
 	.enable			= h3a_aewb_enable,
 	.busy			= h3a_aewb_busy,
 };

 static const struct v4l2_subdev_core_ops h3a_aewb_subdev_core_ops = {
 	.ioctl = h3a_aewb_ioctl,
 	.subscribe_event = omap3isp_stat_subscribe_event,
 	.unsubscribe_event = omap3isp_stat_unsubscribe_event,
 };

 static const struct v4l2_subdev_video_ops h3a_aewb_subdev_video_ops = {
 	.s_stream = omap3isp_stat_s_stream,
 };

 static const struct v4l2_subdev_ops h3a_aewb_subdev_ops = {
 	.core = &h3a_aewb_subdev_core_ops,
 	.video = &h3a_aewb_subdev_video_ops,
 };

 /*
  * omap3isp_h3a_aewb_init - Module Initialisation.
  */
 int omap3isp_h3a_aewb_init(struct isp_device *isp)
 {
 	struct ispstat *aewb = &isp->isp_aewb;
 	struct omap3isp_h3a_aewb_config *aewb_cfg;
 	struct omap3isp_h3a_aewb_config *aewb_recover_cfg;

 	aewb_cfg = devm_kzalloc(isp->dev, sizeof(*aewb_cfg), GFP_KERNEL);
 	if (!aewb_cfg)
 		return -ENOMEM;

 	aewb->ops = &h3a_aewb_ops;
 	aewb->priv = aewb_cfg;
 	aewb->event_type = V4L2_EVENT_OMAP3ISP_AEWB;
 	aewb->isp = isp;

 	/* Set recover state configuration */
 	aewb_recover_cfg = devm_kzalloc(isp->dev, sizeof(*aewb_recover_cfg),
 					GFP_KERNEL);
 	if (!aewb_recover_cfg) {
 		dev_err(aewb->isp->dev, "AEWB: cannot allocate memory for "
 					"recover configuration.\n");
 		return -ENOMEM;
 	}

 	aewb_recover_cfg->saturation_limit = OMAP3ISP_AEWB_MAX_SATURATION_LIM;
 	aewb_recover_cfg->win_height = OMAP3ISP_AEWB_MIN_WIN_H;
 	aewb_recover_cfg->win_width = OMAP3ISP_AEWB_MIN_WIN_W;
 	aewb_recover_cfg->ver_win_count = OMAP3ISP_AEWB_MIN_WINVC;
 	aewb_recover_cfg->hor_win_count = OMAP3ISP_AEWB_MIN_WINHC;
 	aewb_recover_cfg->blk_ver_win_start = aewb_recover_cfg->ver_win_start +
 		aewb_recover_cfg->win_height * aewb_recover_cfg->ver_win_count;
 	aewb_recover_cfg->blk_win_height = OMAP3ISP_AEWB_MIN_WIN_H;
 	aewb_recover_cfg->subsample_ver_inc = OMAP3ISP_AEWB_MIN_SUB_INC;
 	aewb_recover_cfg->subsample_hor_inc = OMAP3ISP_AEWB_MIN_SUB_INC;

 	if (h3a_aewb_validate_params(aewb, aewb_recover_cfg)) {
 		dev_err(aewb->isp->dev, "AEWB: recover configuration is "
 					"invalid.\n");
 		return -EINVAL;
 	}

 	aewb_recover_cfg->buf_size = h3a_aewb_get_buf_size(aewb_recover_cfg);
 	aewb->recover_priv = aewb_recover_cfg;

 	return omap3isp_stat_init(aewb, "AEWB", &h3a_aewb_subdev_ops);
 }

 /*
  * omap3isp_h3a_aewb_cleanup - Module exit.
  */
 void omap3isp_h3a_aewb_cleanup(struct isp_device *isp)
 {
 	omap3isp_stat_cleanup(&isp->isp_aewb);
 }
	/*
	* isph3a.c
	*
	* TI OMAP3 ISP - H3A module
	*
	* Copyright (C) 2010 Nokia Corporation
	* Copyright (C) 2009 Texas Instruments, Inc.
	*
	* Contacts: David Cohen <dacohen@gmail.com>
	* Laurent Pinchart <laurent.pinchart@ideasonboard.com>
	* Sakari Ailus <sakari.ailus@iki.fi>
	*
	* 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 <linux/slab.h>
	#include <linux/uaccess.h>

	#include "isp.h"
	#include "isph3a.h"
	#include "ispstat.h"

	/*
	* h3a_aewb_update_regs - Helper function to update h3a registers.
	*/
	static void h3a_aewb_setup_regs(struct ispstat aewb, void priv)
	{
	struct omap3isp_h3a_aewb_config *conf = priv;
	u32 pcr;
	u32 win1;
	u32 start;
	u32 blk;
	u32 subwin;

	if (aewb->state == ISPSTAT_DISABLED)
	return;

	isp_reg_writel(aewb->isp, aewb->active_buf->dma_addr,
	OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWBUFST);

	if (!aewb->update)
	return;

	/* Converting config metadata into reg values */
	pcr = conf->saturation_limit << ISPH3A_PCR_AEW_AVE2LMT_SHIFT;
	pcr \|= !!conf->alaw_enable << ISPH3A_PCR_AEW_ALAW_EN_SHIFT;

	win1 = ((conf->win_height >> 1) - 1) << ISPH3A_AEWWIN1_WINH_SHIFT;
	win1 \|= ((conf->win_width >> 1) - 1) << ISPH3A_AEWWIN1_WINW_SHIFT;
	win1 \|= (conf->ver_win_count - 1) << ISPH3A_AEWWIN1_WINVC_SHIFT;
	win1 \|= (conf->hor_win_count - 1) << ISPH3A_AEWWIN1_WINHC_SHIFT;

	start = conf->hor_win_start << ISPH3A_AEWINSTART_WINSH_SHIFT;
	start \|= conf->ver_win_start << ISPH3A_AEWINSTART_WINSV_SHIFT;

	blk = conf->blk_ver_win_start << ISPH3A_AEWINBLK_WINSV_SHIFT;
	blk \|= ((conf->blk_win_height >> 1) - 1) << ISPH3A_AEWINBLK_WINH_SHIFT;

	subwin = ((conf->subsample_ver_inc >> 1) - 1) <<
	ISPH3A_AEWSUBWIN_AEWINCV_SHIFT;
	subwin \|= ((conf->subsample_hor_inc >> 1) - 1) <<
	ISPH3A_AEWSUBWIN_AEWINCH_SHIFT;

	isp_reg_writel(aewb->isp, win1, OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWWIN1);
	isp_reg_writel(aewb->isp, start, OMAP3_ISP_IOMEM_H3A,
	ISPH3A_AEWINSTART);
	isp_reg_writel(aewb->isp, blk, OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWINBLK);
	isp_reg_writel(aewb->isp, subwin, OMAP3_ISP_IOMEM_H3A,
	ISPH3A_AEWSUBWIN);
	isp_reg_clr_set(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
	ISPH3A_PCR_AEW_MASK, pcr);

	aewb->update = 0;
	aewb->config_counter += aewb->inc_config;
	aewb->inc_config = 0;
	aewb->buf_size = conf->buf_size;
	}

	static void h3a_aewb_enable(struct ispstat *aewb, int enable)
	{
	if (enable) {
	isp_reg_set(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
	ISPH3A_PCR_AEW_EN);
	omap3isp_subclk_enable(aewb->isp, OMAP3_ISP_SUBCLK_AEWB);
	} else {
	isp_reg_clr(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR,
	ISPH3A_PCR_AEW_EN);
	omap3isp_subclk_disable(aewb->isp, OMAP3_ISP_SUBCLK_AEWB);
	}
	}

	static int h3a_aewb_busy(struct ispstat *aewb)
	{
	return isp_reg_readl(aewb->isp, OMAP3_ISP_IOMEM_H3A, ISPH3A_PCR)
	& ISPH3A_PCR_BUSYAEAWB;
	}

	static u32 h3a_aewb_get_buf_size(struct omap3isp_h3a_aewb_config *conf)
	{
	/* Number of configured windows + extra row for black data */
	u32 win_count = (conf->ver_win_count + 1) * conf->hor_win_count;

	/*
	* Unsaturated block counts for each 8 windows.
	* 1 extra for the last (win_count % 8) windows if win_count is not
	* divisible by 8.
	*/
	win_count += (win_count + 7) / 8;

	return win_count * AEWB_PACKET_SIZE;
	}

	static int h3a_aewb_validate_params(struct ispstat aewb, void new_conf)
	{
	struct omap3isp_h3a_aewb_config *user_cfg = new_conf;
	u32 buf_size;

	if (unlikely(user_cfg->saturation_limit >
	OMAP3ISP_AEWB_MAX_SATURATION_LIM))
	return -EINVAL;

	if (unlikely(user_cfg->win_height < OMAP3ISP_AEWB_MIN_WIN_H \|\|
	user_cfg->win_height > OMAP3ISP_AEWB_MAX_WIN_H \|\|
	user_cfg->win_height & 0x01))
	return -EINVAL;

	if (unlikely(user_cfg->win_width < OMAP3ISP_AEWB_MIN_WIN_W \|\|
	user_cfg->win_width > OMAP3ISP_AEWB_MAX_WIN_W \|\|
	user_cfg->win_width & 0x01))
	return -EINVAL;

	if (unlikely(user_cfg->ver_win_count < OMAP3ISP_AEWB_MIN_WINVC \|\|
	user_cfg->ver_win_count > OMAP3ISP_AEWB_MAX_WINVC))
	return -EINVAL;

	if (unlikely(user_cfg->hor_win_count < OMAP3ISP_AEWB_MIN_WINHC \|\|
	user_cfg->hor_win_count > OMAP3ISP_AEWB_MAX_WINHC))
	return -EINVAL;

	if (unlikely(user_cfg->ver_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
	return -EINVAL;

	if (unlikely(user_cfg->hor_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
	return -EINVAL;

	if (unlikely(user_cfg->blk_ver_win_start > OMAP3ISP_AEWB_MAX_WINSTART))
	return -EINVAL;

	if (unlikely(user_cfg->blk_win_height < OMAP3ISP_AEWB_MIN_WIN_H \|\|
	user_cfg->blk_win_height > OMAP3ISP_AEWB_MAX_WIN_H \|\|
	user_cfg->blk_win_height & 0x01))
	return -EINVAL;

	if (unlikely(user_cfg->subsample_ver_inc < OMAP3ISP_AEWB_MIN_SUB_INC \|\|
	user_cfg->subsample_ver_inc > OMAP3ISP_AEWB_MAX_SUB_INC \|\|
	user_cfg->subsample_ver_inc & 0x01))
	return -EINVAL;

	if (unlikely(user_cfg->subsample_hor_inc < OMAP3ISP_AEWB_MIN_SUB_INC \|\|
	user_cfg->subsample_hor_inc > OMAP3ISP_AEWB_MAX_SUB_INC \|\|
	user_cfg->subsample_hor_inc & 0x01))
	return -EINVAL;

	buf_size = h3a_aewb_get_buf_size(user_cfg);
	if (buf_size > user_cfg->buf_size)
	user_cfg->buf_size = buf_size;
	else if (user_cfg->buf_size > OMAP3ISP_AEWB_MAX_BUF_SIZE)
	user_cfg->buf_size = OMAP3ISP_AEWB_MAX_BUF_SIZE;

	return 0;
	}

	/*
	* h3a_aewb_set_params - Helper function to check & store user given params.
	* @new_conf: Pointer to AE and AWB parameters struct.
	*
	* As most of them are busy-lock registers, need to wait until AEW_BUSY = 0 to
	* program them during ISR.
	*/
	static void h3a_aewb_set_params(struct ispstat aewb, void new_conf)
	{
	struct omap3isp_h3a_aewb_config *user_cfg = new_conf;
	struct omap3isp_h3a_aewb_config *cur_cfg = aewb->priv;
	int update = 0;

	if (cur_cfg->saturation_limit != user_cfg->saturation_limit) {
	cur_cfg->saturation_limit = user_cfg->saturation_limit;
	update = 1;
	}
	if (cur_cfg->alaw_enable != user_cfg->alaw_enable) {
	cur_cfg->alaw_enable = user_cfg->alaw_enable;
	update = 1;
	}
	if (cur_cfg->win_height != user_cfg->win_height) {
	cur_cfg->win_height = user_cfg->win_height;
	update = 1;
	}
	if (cur_cfg->win_width != user_cfg->win_width) {
	cur_cfg->win_width = user_cfg->win_width;
	update = 1;
	}
	if (cur_cfg->ver_win_count != user_cfg->ver_win_count) {
	cur_cfg->ver_win_count = user_cfg->ver_win_count;
	update = 1;
	}
	if (cur_cfg->hor_win_count != user_cfg->hor_win_count) {
	cur_cfg->hor_win_count = user_cfg->hor_win_count;
	update = 1;
	}
	if (cur_cfg->ver_win_start != user_cfg->ver_win_start) {
	cur_cfg->ver_win_start = user_cfg->ver_win_start;
	update = 1;
	}
	if (cur_cfg->hor_win_start != user_cfg->hor_win_start) {
	cur_cfg->hor_win_start = user_cfg->hor_win_start;
	update = 1;
	}
	if (cur_cfg->blk_ver_win_start != user_cfg->blk_ver_win_start) {
	cur_cfg->blk_ver_win_start = user_cfg->blk_ver_win_start;
	update = 1;
	}
	if (cur_cfg->blk_win_height != user_cfg->blk_win_height) {
	cur_cfg->blk_win_height = user_cfg->blk_win_height;
	update = 1;
	}
	if (cur_cfg->subsample_ver_inc != user_cfg->subsample_ver_inc) {
	cur_cfg->subsample_ver_inc = user_cfg->subsample_ver_inc;
	update = 1;
	}
	if (cur_cfg->subsample_hor_inc != user_cfg->subsample_hor_inc) {
	cur_cfg->subsample_hor_inc = user_cfg->subsample_hor_inc;
	update = 1;
	}

	if (update \|\| !aewb->configured) {
	aewb->inc_config++;
	aewb->update = 1;
	cur_cfg->buf_size = h3a_aewb_get_buf_size(cur_cfg);
	}
	}

	static long h3a_aewb_ioctl(struct v4l2_subdev sd, unsigned int cmd, void arg)
	{
	struct ispstat *stat = v4l2_get_subdevdata(sd);

	switch (cmd) {
	case VIDIOC_OMAP3ISP_AEWB_CFG:
	return omap3isp_stat_config(stat, arg);
	case VIDIOC_OMAP3ISP_STAT_REQ:
	return omap3isp_stat_request_statistics(stat, arg);
	case VIDIOC_OMAP3ISP_STAT_EN: {
	unsigned long *en = arg;
	return omap3isp_stat_enable(stat, !!*en);
	}
	}

	return -ENOIOCTLCMD;
	}

	static const struct ispstat_ops h3a_aewb_ops = {
	.validate_params = h3a_aewb_validate_params,
	.set_params = h3a_aewb_set_params,
	.setup_regs = h3a_aewb_setup_regs,
	.enable = h3a_aewb_enable,
	.busy = h3a_aewb_busy,
	};

	static const struct v4l2_subdev_core_ops h3a_aewb_subdev_core_ops = {
	.ioctl = h3a_aewb_ioctl,
	.subscribe_event = omap3isp_stat_subscribe_event,
	.unsubscribe_event = omap3isp_stat_unsubscribe_event,
	};

	static const struct v4l2_subdev_video_ops h3a_aewb_subdev_video_ops = {
	.s_stream = omap3isp_stat_s_stream,
	};

	static const struct v4l2_subdev_ops h3a_aewb_subdev_ops = {
	.core = &h3a_aewb_subdev_core_ops,
	.video = &h3a_aewb_subdev_video_ops,
	};

	/*
	* omap3isp_h3a_aewb_init - Module Initialisation.
	*/
	int omap3isp_h3a_aewb_init(struct isp_device *isp)
	{
	struct ispstat *aewb = &isp->isp_aewb;
	struct omap3isp_h3a_aewb_config *aewb_cfg;
	struct omap3isp_h3a_aewb_config *aewb_recover_cfg;

	aewb_cfg = devm_kzalloc(isp->dev, sizeof(*aewb_cfg), GFP_KERNEL);
	if (!aewb_cfg)
	return -ENOMEM;

	aewb->ops = &h3a_aewb_ops;
	aewb->priv = aewb_cfg;
	aewb->event_type = V4L2_EVENT_OMAP3ISP_AEWB;
	aewb->isp = isp;

	/* Set recover state configuration */
	aewb_recover_cfg = devm_kzalloc(isp->dev, sizeof(*aewb_recover_cfg),
	GFP_KERNEL);
	if (!aewb_recover_cfg) {
	dev_err(aewb->isp->dev, "AEWB: cannot allocate memory for "
	"recover configuration.\n");
	return -ENOMEM;
	}

	aewb_recover_cfg->saturation_limit = OMAP3ISP_AEWB_MAX_SATURATION_LIM;
	aewb_recover_cfg->win_height = OMAP3ISP_AEWB_MIN_WIN_H;
	aewb_recover_cfg->win_width = OMAP3ISP_AEWB_MIN_WIN_W;
	aewb_recover_cfg->ver_win_count = OMAP3ISP_AEWB_MIN_WINVC;
	aewb_recover_cfg->hor_win_count = OMAP3ISP_AEWB_MIN_WINHC;
	aewb_recover_cfg->blk_ver_win_start = aewb_recover_cfg->ver_win_start +
	aewb_recover_cfg->win_height * aewb_recover_cfg->ver_win_count;
	aewb_recover_cfg->blk_win_height = OMAP3ISP_AEWB_MIN_WIN_H;
	aewb_recover_cfg->subsample_ver_inc = OMAP3ISP_AEWB_MIN_SUB_INC;
	aewb_recover_cfg->subsample_hor_inc = OMAP3ISP_AEWB_MIN_SUB_INC;

	if (h3a_aewb_validate_params(aewb, aewb_recover_cfg)) {
	dev_err(aewb->isp->dev, "AEWB: recover configuration is "
	"invalid.\n");
	return -EINVAL;
	}

	aewb_recover_cfg->buf_size = h3a_aewb_get_buf_size(aewb_recover_cfg);
	aewb->recover_priv = aewb_recover_cfg;

	return omap3isp_stat_init(aewb, "AEWB", &h3a_aewb_subdev_ops);
	}

	/*
	* omap3isp_h3a_aewb_cleanup - Module exit.
	*/
	void omap3isp_h3a_aewb_cleanup(struct isp_device *isp)
	{
	omap3isp_stat_cleanup(&isp->isp_aewb);
	}