From 8e4bff4cab0ddac6060645b0715210484d02ff40 Mon Sep 17 00:00:00 2001
From: Yuval Adam <_@yuv.al>
Date: Wed, 30 Aug 2017 08:25:59 +0000
Subject: Initial file dump from open source release

---
 drivers/media/sprd_scale/common/compat_img_scale.c |  95 +++
 drivers/media/sprd_scale/common/compat_img_scale.h |  25 +
 drivers/media/sprd_scale/common/gen_scale_coef.c   | 644 +++++++++++++++++++++
 drivers/media/sprd_scale/common/gen_scale_coef.h   |  34 ++
 drivers/media/sprd_scale/common/img_scale.c        | 388 +++++++++++++
 drivers/media/sprd_scale/common/img_scale.h        |  43 ++
 drivers/media/sprd_scale/common/sin_cos.c          | 152 +++++
 drivers/media/sprd_scale/common/sin_cos.h          |  24 +
 8 files changed, 1405 insertions(+)
 create mode 100644 drivers/media/sprd_scale/common/compat_img_scale.c
 create mode 100644 drivers/media/sprd_scale/common/compat_img_scale.h
 create mode 100644 drivers/media/sprd_scale/common/gen_scale_coef.c
 create mode 100644 drivers/media/sprd_scale/common/gen_scale_coef.h
 create mode 100644 drivers/media/sprd_scale/common/img_scale.c
 create mode 100644 drivers/media/sprd_scale/common/img_scale.h
 create mode 100644 drivers/media/sprd_scale/common/sin_cos.c
 create mode 100644 drivers/media/sprd_scale/common/sin_cos.h

(limited to 'drivers/media/sprd_scale/common')

diff --git a/drivers/media/sprd_scale/common/compat_img_scale.c b/drivers/media/sprd_scale/common/compat_img_scale.c
new file mode 100644
index 00000000..f7b72a81
--- /dev/null
+++ b/drivers/media/sprd_scale/common/compat_img_scale.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/compat.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <video/sprd_scale_k.h>
+#include "img_scale.h"
+#include "compat_img_scale.h"
+
+struct compat_scale_frame_param_t {
+	struct scale_size_t input_size;
+	struct scale_rect_t input_rect;
+	enum scale_fmt_e input_format;
+	struct scale_addr_t input_addr;
+	struct scale_endian_sel_t input_endian;
+	struct scale_size_t output_size;
+	enum scale_fmt_e output_format;
+	struct scale_addr_t output_addr;
+	struct scale_endian_sel_t output_endian;
+	enum scale_mode_e scale_mode;
+	uint32_t slice_height;
+	compat_caddr_t coeff_addr;
+};
+
+#define COMPAT_SCALE_IO_START     _IOW(SCALE_IO_MAGIC, 0, struct compat_scale_frame_param_t)
+
+static long compat_get_scale_frame_param(
+			struct scale_frame_param_t *kp,
+			struct compat_scale_frame_param_t __user *up)
+{
+	compat_caddr_t tmp;
+
+	if (!access_ok(VERIFY_READ, up, sizeof(struct compat_scale_frame_param_t)) ||
+		copy_from_user(&kp->input_size, &up->input_size, sizeof(struct scale_size_t)) ||
+		copy_from_user(&kp->input_rect, &up->input_rect, sizeof(struct scale_rect_t)) ||
+		get_user(kp->input_format, &up->input_format) ||
+		copy_from_user(&kp->input_addr, &up->input_addr, sizeof(struct scale_addr_t)) ||
+		copy_from_user(&kp->input_endian, &up->input_endian, sizeof(struct scale_endian_sel_t)) ||
+		copy_from_user(&kp->output_size, &up->output_size, sizeof(struct scale_size_t)) ||
+		get_user(kp->output_format, &up->output_format) ||
+		copy_from_user(&kp->output_addr, &up->output_addr, sizeof(struct scale_addr_t)) ||
+		copy_from_user(&kp->output_endian, &up->output_endian, sizeof(struct scale_endian_sel_t)) ||
+		get_user(kp->scale_mode, &up->scale_mode) ||
+		get_user(kp->slice_height, &up->slice_height) ||
+		get_user(tmp, &up->coeff_addr))
+			return -EFAULT;
+	kp->coeff_addr = compat_ptr(tmp);
+	return 0;
+}
+
+long compat_scale_k_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+	struct scale_frame_param_t karg;
+	void __user *up = compat_ptr(arg);
+	int compatible_arg = 1;
+	long err = 0;
+
+	if (!filp->f_op || !filp->f_op->unlocked_ioctl)
+		return -ENOTTY;
+
+	switch (cmd) {
+	case COMPAT_SCALE_IO_START:
+		err = compat_get_scale_frame_param(&karg, up);
+		cmd = SCALE_IO_START;
+		compatible_arg = 0;
+		break;
+
+	default:
+		break;
+	}
+	if (err)
+		return err;
+
+	if (compatible_arg)
+		err = filp->f_op->unlocked_ioctl(filp, cmd, (unsigned long)up);
+	else {
+		mm_segment_t old_fs = get_fs();
+
+		set_fs(KERNEL_DS);
+		err = filp->f_op->unlocked_ioctl(filp, cmd, (unsigned long)&karg);
+		set_fs(old_fs);
+	}
+	return err;
+}
diff --git a/drivers/media/sprd_scale/common/compat_img_scale.h b/drivers/media/sprd_scale/common/compat_img_scale.h
new file mode 100644
index 00000000..5e61b88d
--- /dev/null
+++ b/drivers/media/sprd_scale/common/compat_img_scale.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _COMPAT_IMG_SCALE_H_
+#define _COMPAT_IMG_SCALE_H_
+
+#if IS_ENABLED(CONFIG_COMPAT)
+
+long compat_scale_k_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
+
+#else
+
+#define compat_scale_k_ioctl  NULL
+
+#endif /* CONFIG_COMPAT */
+#endif
diff --git a/drivers/media/sprd_scale/common/gen_scale_coef.c b/drivers/media/sprd_scale/common/gen_scale_coef.c
new file mode 100644
index 00000000..e2287766
--- /dev/null
+++ b/drivers/media/sprd_scale/common/gen_scale_coef.c
@@ -0,0 +1,644 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include "sin_cos.h"
+#include "gen_scale_coef.h"
+#include <linux/mm.h>
+#include <linux/math64.h>
+
+#define GSC_FIX         24
+#define GSC_COUNT 256
+
+#define GSC_ABS(_a)                                   ((_a) < 0 ? -(_a) : (_a))
+#define GSC_SIGN2(input, p)                     {if (p>=0) input = 1; if (p < 0) input = -1;}
+#define COEF_ARR_ROWS                           9
+#define COEF_ARR_COLUMNS                   8
+#define COEF_ARR_COL_MAX                    16
+#define MIN_POOL_SIZE                            (6 * 1024)
+#define TRUE                                                1
+#define FALSE                                               0
+#define SCI_MEMSET                                   memset
+#define  MAX( _x, _y )                                  ( ((_x) > (_y)) ? (_x) : (_y) )
+
+typedef struct {
+	unsigned long begin_addr;
+	uint32_t total_size;
+	uint32_t used_size;
+} GSC_MEM_POOL;
+
+
+static uint8_t _InitPool(void *buffer_ptr,
+			 uint32_t buffer_size, GSC_MEM_POOL * pool_ptr)
+{
+	if (NULL == buffer_ptr || 0 == buffer_size || NULL == pool_ptr)
+		return FALSE;
+
+	if (buffer_size < MIN_POOL_SIZE)
+		return FALSE;
+
+	pool_ptr->begin_addr = (unsigned long) buffer_ptr;
+	pool_ptr->total_size = buffer_size;
+	pool_ptr->used_size = 0;
+	return TRUE;
+}
+
+static void *_Allocate(uint32_t size,
+		uint32_t align_shift, GSC_MEM_POOL * pool_ptr)
+{
+	unsigned long begin_addr = 0;
+	unsigned long temp_addr = 0;
+
+	if (NULL == pool_ptr)
+		return NULL;
+
+	begin_addr = pool_ptr->begin_addr;
+	temp_addr = begin_addr + pool_ptr->used_size;
+	temp_addr =((temp_addr + (1 << align_shift) -1) >> align_shift) << align_shift;
+	if (temp_addr + size > begin_addr + pool_ptr->total_size)
+		return NULL;
+
+	pool_ptr->used_size = (temp_addr + size) - begin_addr;
+	SCI_MEMSET((void *)temp_addr, 0, size);
+	return (void *)temp_addr;
+}
+
+s64 dcam_div64_s64(s64 dividend, s64 divisor, s64 *ret)
+{
+	s64 quot, t;
+
+	quot = div64_u64(abs64(dividend), abs64(divisor));
+	t = (dividend ^ divisor) >> 63;
+
+	*ret = (quot ^ t) - t;
+	return div64_s64(dividend, divisor);;
+}
+static int64_t div64_s64_s64(int64_t dividend, int64_t divisor)
+{
+	int8_t sign = 1;
+	int64_t dividend_tmp = dividend;
+	int64_t divisor_tmp = divisor;
+	int64_t ret = 0;
+
+	if (0 == divisor)
+		return 0;
+
+	if ((dividend >> 63) & 0x1) {
+		sign *= -1;
+		dividend_tmp = dividend * (-1);
+	}
+	if ((divisor >> 63) & 0x1) {
+		sign *= -1;
+		divisor_tmp = divisor * (-1);
+	}
+	ret = div64_s64(dividend_tmp, divisor_tmp);
+
+	ret *= sign;
+	return ret;
+}
+
+static void normalize_inter(int64_t * data, int16_t * int_data, uint8_t ilen)
+{
+	uint8_t it;
+	int64_t tmp_d = 0;
+	int64_t *tmp_data = NULL;
+	int64_t tmp_sum_val = 0;
+	tmp_data = data;
+	tmp_sum_val = 0;
+	for (it = 0; it < ilen; it++) {
+		tmp_sum_val += tmp_data[it];
+	}
+	if (0 == tmp_sum_val) {
+		uint8_t value = 256 / ilen;
+		for (it = 0; it < ilen; it++) {
+			tmp_d = value;
+			int_data[it] = (int16_t) tmp_d;
+		}
+	} else {
+		for (it = 0; it < ilen; it++) {
+			tmp_d =
+			div64_s64_s64(tmp_data[it] * (int64_t) 256,tmp_sum_val);
+			int_data[it] = (uint16_t) tmp_d;
+		}
+	}
+}
+
+static int16_t sum_fun(int16_t * data, int8_t ilen)
+{
+	int8_t i;
+	int16_t tmp_sum;
+	tmp_sum = 0;
+
+	for (i = 0; i < ilen; i++)
+		tmp_sum += *data++;
+	return tmp_sum;
+}
+
+static void adjust_filter_inter(int16_t * filter, uint8_t ilen)
+{
+	int32_t i, midi;
+	int32_t tmpi, tmp_S;
+	int32_t tmp_val = 0;
+
+	tmpi = sum_fun(filter, ilen) - 256;
+	midi = ilen >> 1;
+	GSC_SIGN2(tmp_val, tmpi);
+
+	if ((tmpi & 1) == 1) {
+		filter[midi] = filter[midi] - tmp_val;
+		tmpi -= tmp_val;
+	}
+	tmp_S = GSC_ABS(tmpi / 2);
+	if ((ilen & 1) == 1) {
+		for (i = 0; i < tmp_S; i++) {
+			filter[midi - (i + 1)] =
+			filter[midi - (i + 1)] - tmp_val;
+			filter[midi + (i + 1)] =
+			filter[midi + (i + 1)] - tmp_val;
+		}
+	} else {
+		for (i = 0; i < tmp_S; i++) {
+			filter[midi - (i + 1)] =
+			filter[midi - (i + 1)] - tmp_val;
+			filter[midi + i] = filter[midi + i] - tmp_val;
+		}
+	}
+	if (filter[midi] > 255) {
+		tmp_val = filter[midi];
+		filter[midi] = 255;
+		filter[midi - 1] = filter[midi - 1] + tmp_val - 255;
+	}
+}
+
+static int16_t CalYmodelCoef(int16_t coef_lenght,
+			int16_t * coef_data_ptr,
+			int16_t N, int16_t M, GSC_MEM_POOL * pool_ptr)
+{
+	int8_t mount;
+	int16_t i, mid_i, kk, j, sum_val;
+	int64_t *filter = _Allocate(GSC_COUNT * sizeof(int64_t), 3, pool_ptr);
+	int64_t *tmp_filter =
+	_Allocate(GSC_COUNT * sizeof(int64_t), 3, pool_ptr);
+	int16_t *normal_filter =
+	_Allocate(GSC_COUNT * sizeof(int16_t), 2, pool_ptr);
+
+	if (NULL == filter || NULL == tmp_filter || NULL == normal_filter)
+		return 1;
+
+	mid_i = coef_lenght >> 1;
+	filter[mid_i] =
+	div64_s64_s64((int64_t) ((int64_t) N << GSC_FIX), (int64_t) MAX(M, N));
+	for (i = 0; i < mid_i; i++) {
+		int64_t angle_x =
+		div64_s64_s64(ARC_32_COEF * (int64_t) (i + 1) *
+				(int64_t) N, (int64_t) MAX(M,N) * (int64_t) 8);
+		int64_t angle_y =
+		div64_s64_s64(ARC_32_COEF * (int64_t) (i + 1) *
+				(int64_t) N, (int64_t) (M * N) * (int64_t) 8);
+		int32_t value_x = sin_32((int32_t) angle_x);
+		int32_t value_y = sin_32((int32_t) angle_y);
+		filter[mid_i + i + 1] =
+		div64_s64_s64((int64_t)
+			((int64_t) value_x *
+			(int64_t) (1 << GSC_FIX)),
+			(int64_t) ((int64_t) M * (int64_t) value_y));
+		filter[mid_i - (i + 1)] = filter[mid_i + i + 1];
+	}
+	for (i = -1; i < mid_i; i++) {
+		int32_t angle_32 =
+		(int32_t)div64_s64_s64((int64_t)
+					((int64_t) 2 * (int64_t) (mid_i - i - 1) *
+					ARC_32_COEF),
+					(int64_t) coef_lenght);
+		int64_t a = (int64_t) 9059697;
+		int64_t b = (int64_t) 7717519;
+		int64_t t = a - ((b * cos_32(angle_32)) >> 30);
+		filter[mid_i + i + 1] = (t * filter[mid_i + i + 1]) >> GSC_FIX;
+		filter[mid_i - (i + 1)] = filter[mid_i + i + 1];
+	}
+	for (i = 0; i < 8; i++) {
+		mount = 0;
+		for (j = i; j < coef_lenght; j += 8) {
+			tmp_filter[mount] = filter[j];
+			mount++;
+		}
+		normalize_inter(tmp_filter, normal_filter, (int8_t) mount);
+		sum_val = sum_fun(normal_filter, mount);
+		if (256 != sum_val) {
+			adjust_filter_inter(normal_filter, mount);
+		}
+		mount = 0;
+		for (kk = i; kk < coef_lenght; kk += 8) {
+			coef_data_ptr[kk] = normal_filter[mount];
+			mount++;
+		}
+	}
+	return 0;
+}
+
+static int16_t CalY_ScalingCoef(int16_t tap,
+			int16_t D,
+			int16_t I,
+			int16_t * y_coef_data_ptr,
+			int16_t dir, GSC_MEM_POOL * pool_ptr)
+{
+	uint16_t coef_lenght;
+
+	coef_lenght = (uint16_t) (tap * 8);
+	SCI_MEMSET(y_coef_data_ptr, 0, coef_lenght * sizeof(int16_t));
+	CalYmodelCoef(coef_lenght, y_coef_data_ptr, I, D, pool_ptr);
+	return coef_lenght;
+}
+
+static int16_t CalUV_ScalingCoef(int16_t tap,
+			int16_t D,
+			int16_t I,
+			int16_t * uv_coef_data_ptr,
+			int16_t dir, GSC_MEM_POOL * pool_ptr)
+{
+	int16_t uv_coef_lenght;
+
+	if ((dir == 1)) {
+		uv_coef_lenght = (int16_t) (tap * 8);
+		CalYmodelCoef(uv_coef_lenght, uv_coef_data_ptr, I, D, pool_ptr);
+	} else {
+		if (D > I) {
+			uv_coef_lenght = (int16_t) (tap * 8);
+		} else {
+			uv_coef_lenght = (int16_t) (2 * 8);
+		}
+		CalYmodelCoef(uv_coef_lenght, uv_coef_data_ptr, I, D, pool_ptr);
+	}
+	return uv_coef_lenght;
+}
+
+static void GetFilter(int16_t * coef_data_ptr,
+		int16_t * out_filter,
+		int16_t iI_hor, int16_t coef_len, int16_t * filter_len)
+{
+	int16_t i, pos_start;
+
+	pos_start = coef_len / 2;
+	while (pos_start >= iI_hor) {
+		pos_start -= iI_hor;
+	}
+	for (i = 0; i < iI_hor; i++) {
+		int16_t len = 0;
+		int16_t j;
+		int16_t pos = pos_start + i;
+		while (pos >= iI_hor) {
+			pos -= iI_hor;
+		}
+		for (j = 0; j < coef_len; j += iI_hor) {
+			*out_filter++ = coef_data_ptr[j + pos];
+			len++;
+		}
+		*filter_len++ = len;
+	}
+}
+
+static void WriteScalarCoef(int16_t * dst_coef_ptr,
+			int16_t * coef_ptr, int16_t dst_pitch, int16_t src_pitch)
+{
+	int i, j;
+
+	for (i = 0; i < 8; i++) {
+		for (j = 0; j < src_pitch; j++) {
+			*(dst_coef_ptr + j) =
+			*(coef_ptr + i * src_pitch + src_pitch - 1 - j);
+		}
+		dst_coef_ptr += dst_pitch;
+	}
+}
+
+static void SetHorRegisterCoef(uint32_t * reg_coef_ptr, int16_t * y_coef_ptr,
+			int16_t * uv_coef_ptr)
+{
+	int32_t i = 0;
+	int16_t *y_coef_arr[COEF_ARR_ROWS] = { NULL };
+	int16_t *uv_coef_arr[COEF_ARR_ROWS] = { NULL };
+
+	for (i = 0; i < COEF_ARR_ROWS; i++) {
+		y_coef_arr[i] = y_coef_ptr;
+		uv_coef_arr[i] = uv_coef_ptr;
+		y_coef_ptr += COEF_ARR_COLUMNS;
+		uv_coef_ptr += COEF_ARR_COLUMNS;
+	}
+
+	/*horizontal Y Scaling Coef Config register*/
+	for (i = 0; i < 8; i++) {
+		uint16_t p0, p1;
+		uint32_t reg;
+
+		p0 = (uint16_t) y_coef_arr[i][7];
+		p1 = (uint16_t) y_coef_arr[i][6];
+		reg = ((p0 & 0x1ff)) | ((p1 & 0x1ff) << 9);
+		*reg_coef_ptr++ = reg;
+		p0 = (uint16_t) y_coef_arr[i][5];
+		p1 = (uint16_t) y_coef_arr[i][4];
+		reg = ((p0 & 0x1ff)) | ((p1 & 0x1ff) << 9);
+		*reg_coef_ptr++ = reg;
+		p0 = (uint16_t) y_coef_arr[i][3];
+		p1 = (uint16_t) y_coef_arr[i][2];
+		reg = ((p0 & 0x1ff)) | ((p1 & 0x1ff) << 9);
+		*reg_coef_ptr++ = reg;
+		p0 = (uint16_t) y_coef_arr[i][1];
+		p1 = (uint16_t) y_coef_arr[i][0];
+		reg = ((p0 & 0x1ff)) | ((p1 & 0x1ff) << 9);
+		*reg_coef_ptr++ = reg;
+	}
+
+	/*horizontal UV Scaling Coef Config register*/
+	for (i = 0; i < 8; i++) {
+		uint16_t p0, p1;
+		uint32_t reg;
+
+		p0 = (uint16_t) uv_coef_arr[i][3];
+		p1 = (uint16_t) uv_coef_arr[i][2];
+		reg = ((p0 & 0x1ff)) | ((p1 & 0x1ff) << 9);
+		*reg_coef_ptr++ = reg;
+		p0 = (uint16_t) uv_coef_arr[i][1];
+		p1 = (uint16_t) uv_coef_arr[i][0];
+		reg = ((p0 & 0x1ff)) | ((p1 & 0x1ff) << 9);
+		*reg_coef_ptr++ = reg;
+	}
+}
+
+static void SetVerRegisterCoef(uint32_t * reg_coef_lum_ptr,
+			uint32_t *reg_coef_ch_ptr,
+			int16_t * y_coef_ptr,
+			int16_t * uv_coef_ptr,
+			int16_t  i_h,
+			int16_t o_h,
+			uint8_t is_scaling2yuv420)
+{
+	uint32_t cnts = 0;
+	uint32_t i = 0, j = 0;
+
+	if(2 * o_h <= i_h) {
+		for(i = 0; i < 9; i++) {
+			for(j = 0; j < 16; j++) {
+				reg_coef_lum_ptr[cnts++] = *(y_coef_ptr +i * 16 + j);
+				if(SCALER_COEF_TAB_LEN_VER == cnts)
+					break;
+			}
+		}
+
+		cnts = 0;
+		for(i = 0; i < 9; i++) {
+			for(j = 0; j < 16; j++) {
+				reg_coef_ch_ptr[cnts++] = *(uv_coef_ptr + i * 16 +j);
+				if(SCALER_COEF_TAB_LEN_VER == cnts)
+					break;
+			}
+		}
+	} else {
+		for(i = 0; i < 8; i++)
+			for(j = 0; j < 4; j++)
+				reg_coef_lum_ptr[cnts++] = *(y_coef_ptr +i * 16 + j);
+
+		cnts = 0;
+		if((o_h <= i_h) && is_scaling2yuv420) {
+			for(i = 0; i < 9; i++) {
+				for(j = 0; j < 16; j++) {
+					reg_coef_ch_ptr[cnts++] = *(uv_coef_ptr +i * 16 + j);
+					if(SCALER_COEF_TAB_LEN_VER == cnts)
+						break;
+				}
+			}
+		} else {
+			for(i = 0; i < 8; i++)
+				for(j = 0; j < 4; j++)
+					reg_coef_ch_ptr[cnts++] = *(uv_coef_ptr +i * 16 + j);
+		}
+	}
+}
+
+static void CheckCoefRange(int16_t * coef_ptr, int16_t rows, int16_t columns, int16_t pitch)
+{
+	int16_t i, j;
+	int16_t value, diff, sign;
+	int16_t *coef_arr[COEF_ARR_ROWS] = { NULL };
+
+	for (i = 0; i < COEF_ARR_ROWS; i++) {
+		coef_arr[i] = coef_ptr;
+		coef_ptr += pitch;
+	}
+	for (i = 0; i < rows; i++) {
+		for (j = 0; j < columns; j++) {
+			value = coef_arr[i][j];
+			if (value > 255) {
+				diff = value - 255;
+				coef_arr[i][j] = 255;
+				sign = GSC_ABS(diff);
+				if ((sign & 1) == 1) {
+					coef_arr[i][j + 1] =
+					coef_arr[i][j + 1] + (diff + 1) / 2;
+					coef_arr[i][j - 1] =
+					coef_arr[i][j - 1] + (diff - 1) / 2;
+				} else {
+					coef_arr[i][j + 1] =
+					coef_arr[i][j + 1] + (diff) / 2;
+					coef_arr[i][j - 1] =
+					coef_arr[i][j - 1] + (diff) / 2;
+				}
+			}
+		}
+	}
+}
+
+static void CalcVerEdgeCoef(int16_t * coeff_ptr, int16_t D, int16_t I,
+			int16_t tap, int16_t pitch)
+{
+	int32_t phase_temp[9];
+	int32_t acc = 0;
+	int32_t i_sample_cnt = 0;
+	uint8_t phase = 0;
+	uint8_t spec_tap = 0;
+	int32_t l;
+	int16_t i, j;
+	int16_t *coeff_arr[COEF_ARR_ROWS];
+
+	for (i = 0; i < COEF_ARR_ROWS; i++) {
+		coeff_arr[i] = coeff_ptr;
+		coeff_ptr += pitch;
+	}
+	for (j = 0; j <= 8; j++)
+		phase_temp[j] = j * I / 8;
+
+	for (i = 0; i < I; i++) {
+		spec_tap = i & 1;
+		while (acc >= I) {
+			acc -= I;
+			i_sample_cnt++;
+		}
+
+		for (j = 0; j < 8; j++) {
+			if (acc >= phase_temp[j] && acc < phase_temp[j + 1]) {
+				phase = (uint8_t) j;
+				break;
+			}
+		}
+
+		{
+			int32_t j;
+			for (j = (1 - tap / 2); j <= (tap / 2); j++) {
+				l = i_sample_cnt + j;
+				if (l <= 0) {
+					coeff_arr[8][spec_tap] +=
+					coeff_arr[phase][j + tap / 2 - 1];
+				} else {
+					if (l >= D - 1) {
+						coeff_arr[8][spec_tap + 2] +=
+						coeff_arr[phase][j +tap / 2 -1];
+					}
+				}
+			}
+		}
+		acc += D;
+	}
+}
+
+uint8_t GenScaleCoeff(int16_t i_w,
+			int16_t i_h,
+			int16_t o_w,
+			int16_t o_h,
+			uint32_t *coeff_h_ptr,
+			uint32_t *coeff_v_lum_ptr,
+			uint32_t *coeff_v_ch_ptr,
+			uint8_t scaling2yuv420,
+			uint8_t *scaler_tap,
+			uint8_t *chrome_tap,
+			void *temp_buf_ptr,
+			uint32_t temp_buf_size
+			)
+{
+	int16_t D_hor = i_w;
+	int16_t D_ver = i_h;
+	int16_t I_hor = o_w;
+	int16_t I_ver = o_h;
+	int16_t I_ver_bak_uv = o_h;
+	int16_t I_ver_bak_y = o_h;
+	int16_t *cong_Ycom_hor = 0;
+	int16_t *cong_UVcom_hor = 0;
+	int16_t *cong_Ycom_ver = 0;
+	int16_t *cong_UVcom_ver = 0;
+
+	uint16_t luma_ver_tap, chrome_ver_tap;
+	uint16_t luma_ver_maxtap = 16, chrome_ver_maxtap = 16;
+
+	uint32_t coef_buf_size = 0;
+	int16_t *temp_filter_ptr = NULL;
+	int16_t *filter_ptr = NULL;
+	uint32_t filter_buf_size = GSC_COUNT * sizeof(int16_t);
+	int16_t filter_len[COEF_ARR_ROWS] = { 0 };
+	int16_t coef_len = 0;
+	GSC_MEM_POOL pool = { 0 };
+
+	if (0 == i_w || 0 == i_h || 0 == o_w || (0 == o_h) \
+		|| (NULL == coeff_h_ptr) || (NULL == coeff_v_lum_ptr) \
+		|| (NULL == coeff_v_ch_ptr) || (NULL == scaler_tap) \
+		|| (NULL == chrome_tap) || (NULL == temp_buf_ptr)) {
+
+		printk("GenScaleCoeff: i_w: %d, i_h: %d, o_w:%d, o_h: %d, coef_h:%p, coef_v_lum:%p, \
+			coef_v_chr: %p, y_tap: %p, ch_tap: %p, tmp_buf:%p",
+			i_w, i_h, o_w, o_h, coeff_h_ptr, coeff_v_lum_ptr, \
+			coeff_v_ch_ptr, scaler_tap, chrome_tap, temp_buf_ptr);
+
+		return FALSE;
+	}
+
+	/* init pool and allocate static array */
+	if (!_InitPool(temp_buf_ptr, temp_buf_size, &pool))
+		return FALSE;
+
+	coef_buf_size = COEF_ARR_ROWS * COEF_ARR_COL_MAX * sizeof(int16_t);
+	cong_Ycom_hor = (int16_t*)_Allocate(coef_buf_size, 2, &pool);
+	cong_UVcom_hor = (int16_t*)_Allocate(coef_buf_size, 2, &pool);
+	cong_Ycom_ver = (int16_t*)_Allocate(coef_buf_size, 2, &pool);
+	cong_UVcom_ver = (int16_t*)_Allocate(coef_buf_size, 2, &pool);
+
+	if (NULL == cong_Ycom_hor
+		|| NULL == cong_UVcom_hor
+		||(NULL == cong_Ycom_ver)
+		||(NULL == cong_UVcom_ver))
+			return FALSE;
+
+	temp_filter_ptr = _Allocate(filter_buf_size, 2, &pool);
+	filter_ptr = _Allocate(filter_buf_size, 2, &pool);
+	if (NULL == temp_filter_ptr || NULL == filter_ptr)
+		return FALSE;
+
+
+	/* calculate coefficients of Y component in horizontal direction */
+	coef_len = CalY_ScalingCoef(8, D_hor, I_hor, temp_filter_ptr, 1, &pool);
+	GetFilter(temp_filter_ptr, filter_ptr, 8, coef_len, filter_len);
+	WriteScalarCoef(cong_Ycom_hor, filter_ptr, 8, 8);
+	CheckCoefRange(cong_Ycom_hor, 8, 8, 8);
+
+	/* calculate coefficients of UV component in horizontal direction */
+	coef_len = CalUV_ScalingCoef(4, D_hor, I_hor, temp_filter_ptr, 1, &pool);
+	GetFilter(temp_filter_ptr, filter_ptr, 8, coef_len, filter_len);
+	WriteScalarCoef(cong_UVcom_hor, filter_ptr, 8, 4);
+	CheckCoefRange(cong_UVcom_hor, 8, 4, 8);
+	/* write the coefficient to register format */
+	SetHorRegisterCoef(coeff_h_ptr, cong_Ycom_hor, cong_UVcom_hor);
+
+	luma_ver_tap = ((uint8_t)(D_ver / I_ver)) * 2;
+	chrome_ver_tap = luma_ver_tap;
+
+	if ( luma_ver_tap > luma_ver_maxtap)
+		luma_ver_tap = luma_ver_maxtap;
+	if(luma_ver_tap <= 2)
+		luma_ver_tap = 4;
+
+	*scaler_tap = (uint8_t)luma_ver_tap;
+
+	/* calculate coefficients of Y component in vertical direction*/
+	coef_len = CalY_ScalingCoef(luma_ver_tap, D_ver, I_ver, temp_filter_ptr, 0, &pool);
+	GetFilter(temp_filter_ptr, filter_ptr, 8, coef_len, filter_len);
+	WriteScalarCoef(cong_Ycom_ver, filter_ptr, 16, filter_len[0]);
+	CheckCoefRange(cong_Ycom_ver, 8, luma_ver_tap, 16);
+	/* calculate coefficients of UV component in vertical direction */
+	if (scaling2yuv420) {
+		I_ver_bak_uv /= 2;
+		chrome_ver_tap *= 2;
+		chrome_ver_maxtap = 16;
+	}
+
+	if ( chrome_ver_tap > chrome_ver_maxtap)
+		chrome_ver_tap = chrome_ver_maxtap;
+	if(chrome_ver_tap <= 2)
+		chrome_ver_tap = 4;
+	*chrome_tap = (uint8_t)chrome_ver_tap;
+
+	coef_len = CalUV_ScalingCoef((int16_t) (chrome_ver_tap),
+			D_ver, I_ver_bak_uv, temp_filter_ptr,
+			0, &pool);
+	GetFilter(temp_filter_ptr, filter_ptr, 8, coef_len, filter_len);
+	WriteScalarCoef(cong_UVcom_ver, filter_ptr, 16, filter_len[0]);
+	CheckCoefRange(cong_UVcom_ver, 8, chrome_ver_tap, 16);
+
+	/* calculate edge coefficients of Y component in vertical direction */
+	if(2 * I_ver_bak_y <= D_ver) { 	//only scale down
+		CalcVerEdgeCoef(cong_Ycom_ver, D_ver, I_ver_bak_y, luma_ver_tap, 16);
+	}
+	/* calculate edge coefficients of UV component in vertical direction */
+	if(2 * I_ver_bak_uv <= D_ver) {	//only scale down
+		CalcVerEdgeCoef(cong_UVcom_ver, D_ver, I_ver_bak_uv, chrome_ver_tap, 16);
+	}
+	/* write the coefficient to register format */
+	SetVerRegisterCoef(coeff_v_lum_ptr, coeff_v_ch_ptr,
+		cong_Ycom_ver, cong_UVcom_ver,
+		D_ver, I_ver, scaling2yuv420);
+
+	return TRUE;
+}
diff --git a/drivers/media/sprd_scale/common/gen_scale_coef.h b/drivers/media/sprd_scale/common/gen_scale_coef.h
new file mode 100644
index 00000000..f8518d68
--- /dev/null
+++ b/drivers/media/sprd_scale/common/gen_scale_coef.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _GEN_SCALE_COEF_H_
+#define _GEN_SCALE_COEF_H_
+
+#include <linux/types.h>
+
+#define SCALER_COEF_TAB_LEN_HOR 	48
+#define SCALER_COEF_TAB_LEN_VER	132
+
+uint8_t GenScaleCoeff(int16_t i_w,
+			int16_t i_h,
+			int16_t o_w,
+			int16_t o_h,
+			uint32_t *coeff_h_ptr,
+			uint32_t *coeff_v_lum_ptr,
+			uint32_t *coeff_v_ch_ptr,
+			uint8_t scaling2yuv420,
+			uint8_t *scaler_tap,
+			uint8_t *chrome_tap,
+			void *temp_buf_ptr,
+			uint32_t temp_buf_size);
+
+#endif
diff --git a/drivers/media/sprd_scale/common/img_scale.c b/drivers/media/sprd_scale/common/img_scale.c
new file mode 100644
index 00000000..0fa976a2
--- /dev/null
+++ b/drivers/media/sprd_scale/common/img_scale.c
@@ -0,0 +1,388 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/platform_device.h>
+#include <linux/proc_fs.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <asm/uaccess.h>
+#include <video/sprd_scale_k.h>
+#include <linux/kthread.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/vmalloc.h>
+
+#include "img_scale.h"
+#include "compat_img_scale.h"
+#include "dcam_drv.h"
+
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#endif
+
+#define SCALE_DEVICE_NAME "sprd_scale"
+#define SCALE_TIMEOUT 5000/*ms*/
+#define SCALE_MINOR MISC_DYNAMIC_MINOR
+#define SC_COEFF_BUF_SIZE (24 << 10)
+
+static void scale_k_irq(void *fd)
+{
+	struct scale_k_file *scale_file = (struct scale_k_file *)fd;
+
+	if (!scale_file) {
+		printk("scale_k_irq error: hand is null");
+		return;
+	}
+
+	printk("sc done.\n");
+
+	up(&scale_file->scale_done_sem);
+}
+
+static void scale_k_file_init(struct scale_k_file *fd, struct scale_k_private *scale_private)
+{
+	fd->scale_private = scale_private;
+
+	sema_init(&fd->scale_done_sem, 0);
+
+	fd->drv_private.scale_fd = (void*)fd;
+	fd->drv_private.path_info.coeff_addr = scale_private->coeff_addr;
+
+	spin_lock_init(&fd->drv_private.scale_drv_lock);
+	sema_init(&fd->drv_private.path_info.done_sem, 0);
+}
+
+static int scale_k_open(struct inode *node, struct file *file)
+{
+	int ret = 0;
+	struct scale_k_file *fd = NULL;
+	struct scale_k_private *scale_private = NULL;
+	struct miscdevice *md = file->private_data;
+
+	if (!md) {
+		ret = -EFAULT;
+		printk("scale_k_open error: miscdevice is null \n");
+		goto exit;
+	}
+	scale_private = (struct scale_k_private *)md->this_device->platform_data;
+	if (!scale_private) {
+		ret = -EFAULT;
+		printk("scale_k_open error: scale_private is null \n");
+		goto exit;
+	}
+
+	fd = vzalloc(sizeof(*fd));
+	if (!fd) {
+		ret = -ENOMEM;
+		printk("scale_k_open error: alloc \n");
+		goto exit;
+	}
+	fd->dn = md->this_device->of_node;
+	scale_k_file_init(fd, scale_private);
+
+	file->private_data = fd;
+
+	SCALE_TRACE("scale_k_open fd=%p ret=%d\n", fd, ret);
+
+exit:
+	return ret;
+}
+
+ssize_t scale_k_read(struct file *file, char __user *u_data, size_t cnt, loff_t *cnt_ret)
+{
+	uint32_t rt_word[2];
+
+	(void)file; (void)cnt; (void)cnt_ret;
+
+	if (cnt < sizeof(uint32_t)) {
+		printk("scale_k_read error: wrong size of u_data: %ld \n", cnt);
+		return -1;
+	}
+
+	rt_word[0] = SCALE_LINE_BUF_LENGTH;
+	rt_word[1] = SCALE_SC_COEFF_MAX;
+
+	return copy_to_user(u_data, (void*)rt_word, (uint32_t)(2 * sizeof(uint32_t)));
+}
+
+static int scale_k_release(struct inode *node, struct file *file)
+{
+	struct scale_k_file *fd = NULL;
+	struct scale_k_private *scale_private = NULL;
+
+	fd = file->private_data;
+	if (!fd) {
+		goto exit;
+	}
+
+	scale_private = fd->scale_private;
+	if (!scale_private) {
+		goto fd_free;
+	}
+
+	down(&scale_private->start_sem);
+	up(&scale_private->start_sem);
+
+fd_free:
+	vfree(fd);
+	fd = NULL;
+	file->private_data = NULL;
+
+exit:
+	SCALE_TRACE("scale_k_release\n");
+
+	return 0;
+}
+
+static void sprd_img_print_reg(void)
+{
+	uint32_t*                reg_buf = NULL;
+	uint32_t                 reg_buf_len = 0x400;
+	int                      ret;
+	uint32_t                 print_len = 0, print_cnt = 0;
+	reg_buf = (uint32_t*)vzalloc(reg_buf_len);
+	if (NULL == reg_buf)
+		return;
+	ret = dcam_read_registers(reg_buf, &reg_buf_len);
+	if (ret) {
+		vfree(reg_buf);
+		return;
+	}
+	printk("dcam registers \n");
+	while (print_len < reg_buf_len) {
+		printk("offset 0x%03x : 0x%08x, 0x%08x, 0x%08x, 0x%08x \n",
+			print_len,
+			reg_buf[print_cnt],
+			reg_buf[print_cnt+1],
+			reg_buf[print_cnt+2],
+			reg_buf[print_cnt+3]);
+		print_cnt += 4;
+		print_len += 16;
+	}
+	udelay(1);
+	vfree(reg_buf);
+	return;
+}
+static long scale_k_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int ret = 0;
+	struct scale_k_private *scale_private;
+	struct scale_k_file *fd;
+	struct scale_frame_param_t frame_params;
+	struct scale_slice_param_t slice_params;
+
+	fd = file->private_data;
+	if (!fd) {
+		ret = - EFAULT;
+		printk("scale_k_ioctl error:  fd null \n");
+		goto ioctl_exit;
+	}
+
+	scale_private = fd->scale_private;
+	if (!scale_private) {
+		ret = -EFAULT;
+		printk("scale_k_ioctl erro: scale private null \n");
+		goto ioctl_exit;
+	}
+
+	switch (cmd) {
+	case SCALE_IO_START:
+
+		down(&scale_private->start_sem);
+
+		ret = scale_k_module_en(fd->dn);
+		if (unlikely(ret)) {
+			printk("rot_k_ioctl erro: scale_module_en\n");
+			up(&scale_private->start_sem);
+			goto ioctl_exit;
+		}
+
+		ret = scale_k_isr_reg(scale_k_irq, &fd->drv_private);
+		if (unlikely(ret)) {
+			printk("rot_k_ioctl error:  scale_k_isr_reg\n");
+			scale_k_module_dis(fd->dn);
+			up(&scale_private->start_sem);
+			goto ioctl_exit;
+
+		}
+
+		ret = copy_from_user(&frame_params, (struct scale_frame_param_t *)arg, sizeof(frame_params));
+		if (ret) {
+			printk("rot_k_ioctl error: get frame param info \n");
+			scale_k_module_dis(fd->dn);
+			up(&scale_private->start_sem);
+			goto ioctl_exit;
+		}
+
+		ret = scale_k_start(&frame_params, &fd->drv_private.path_info);
+		if (ret) {
+			printk("rot_k_ioctl error: frame start \n");
+			scale_k_module_dis(fd->dn);
+			up(&scale_private->start_sem);
+			goto ioctl_exit;
+		}
+
+		break;
+	case SCALE_IO_DONE:
+		ret = down_timeout(&fd->scale_done_sem, msecs_to_jiffies(SCALE_TIMEOUT));
+		if (ret) {
+			printk("scale_k_ioctl error:  interruptible time out\n");
+			sprd_img_print_reg();
+			goto ioctl_out;
+		}
+
+		scale_k_stop();
+
+		scale_k_module_dis(fd->dn);
+
+		up(&scale_private->start_sem);
+		break;
+	case SCALE_IO_CONTINUE:
+		/*Caution: slice scale is not supported by current driver.Please do not use it*/
+		ret = copy_from_user(&slice_params, (struct scale_slice_param_t *)arg, sizeof(slice_params));
+		if (ret) {
+			printk("rot_k_ioctl error: get slice param info \n");
+			goto ioctl_exit;
+		}
+
+		ret = scale_k_continue(&slice_params, &fd->drv_private.path_info);
+		if (ret) {
+			printk("rot_k_ioctl error: continue \n");
+		}
+		break;
+
+	default:
+		break;
+	}
+
+ioctl_exit:
+	return ret;
+
+ioctl_out:
+	dcam_resize_end();
+	scale_k_stop();
+	scale_k_module_dis(fd->dn);
+	up(&scale_private->start_sem);
+	return ret;
+}
+
+static struct file_operations scale_fops = {
+	.owner = THIS_MODULE,
+	.open = scale_k_open,
+	.read = scale_k_read,
+	.unlocked_ioctl = scale_k_ioctl,
+	.compat_ioctl = compat_scale_k_ioctl,
+	.release = scale_k_release,
+};
+
+static struct miscdevice scale_dev = {
+	.minor = SCALE_MINOR,
+	.name = SCALE_DEVICE_NAME,
+	.fops = &scale_fops,
+};
+
+int scale_k_probe(struct platform_device *pdev)
+{
+	int ret;
+	struct scale_k_private *scale_private;
+
+	scale_private = devm_kzalloc(&pdev->dev, sizeof(*scale_private), GFP_KERNEL);
+	if (!scale_private) {
+		return -ENOMEM;
+	}
+	scale_private->coeff_addr = (void *)vzalloc(SC_COEFF_BUF_SIZE);
+	if (!scale_private->coeff_addr) {
+		devm_kfree(&pdev->dev, scale_private);
+		return -ENOMEM;
+	}
+	sema_init(&scale_private->start_sem, 1);
+
+	platform_set_drvdata(pdev, scale_private);
+
+	ret = misc_register(&scale_dev);
+	if (ret) {
+		printk("scale_k_probe error: ret=%d\n", ret);
+		ret = -EACCES;
+		goto probe_out;
+	}
+
+	scale_dev.this_device->of_node = pdev->dev.of_node;
+	scale_dev.this_device->platform_data = (void *)scale_private;
+
+	goto exit;
+
+probe_out:
+	vfree(scale_private->coeff_addr);
+	devm_kfree(&pdev->dev, scale_private);
+	platform_set_drvdata(pdev, NULL);
+exit:
+	return 0;
+}
+
+static int scale_k_remove(struct platform_device *pdev)
+{
+	struct scale_k_private *scale_private;
+
+	scale_private = platform_get_drvdata(pdev);
+
+	if (!scale_private)
+		goto remove_exit;
+
+	misc_deregister(&scale_dev);
+	if (scale_private->coeff_addr) {
+		vfree(scale_private->coeff_addr);
+	}
+	devm_kfree(&pdev->dev, scale_private);
+	platform_set_drvdata(pdev, NULL);
+
+remove_exit:
+	return 0;
+}
+
+static const struct of_device_id of_match_table_scale[] = {
+	{ .compatible = "sprd,sprd_scale", },
+	{ },
+};
+
+static struct platform_driver scale_driver =
+{
+	.probe = scale_k_probe,
+	.remove = scale_k_remove,
+	.driver = {
+		.owner = THIS_MODULE,
+		.name = SCALE_DEVICE_NAME,
+		.of_match_table = of_match_ptr(of_match_table_scale),
+	}
+};
+
+int __init scale_k_init(void)
+{
+	if (platform_driver_register(&scale_driver) != 0) {
+		printk("platform scale device register Failed \n");
+		return -1;
+	}
+
+	return 0;
+}
+
+void scale_k_exit(void)
+{
+	platform_driver_unregister(&scale_driver);
+}
+
+module_init(scale_k_init);
+module_exit(scale_k_exit);
+MODULE_DESCRIPTION("Sprd Scale Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/sprd_scale/common/img_scale.h b/drivers/media/sprd_scale/common/img_scale.h
new file mode 100644
index 00000000..6df49a0a
--- /dev/null
+++ b/drivers/media/sprd_scale/common/img_scale.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _IMG_SCALE_H_
+#define _IMG_SCALE_H_
+
+#include "scale_drv.h"
+
+#include <asm/ioctl.h>
+#include <linux/types.h>
+
+struct scale_k_private{
+	struct semaphore start_sem;
+	void *coeff_addr;
+};
+
+enum scale_k_status{
+	SCALE_K_IDLE,
+	SCALE_K_RUNNING,
+	SCALE_K_DONE,
+	SCALE_K_MAX
+};
+
+struct scale_k_file{
+	struct scale_k_private *scale_private;
+
+	struct semaphore scale_done_sem;
+
+	struct scale_drv_private drv_private;
+
+	struct device_node *dn;
+};
+
+#endif
diff --git a/drivers/media/sprd_scale/common/sin_cos.c b/drivers/media/sprd_scale/common/sin_cos.c
new file mode 100644
index 00000000..57828254
--- /dev/null
+++ b/drivers/media/sprd_scale/common/sin_cos.c
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include "sin_cos.h"
+#define SINCOS_BIT_31  (1 << 31)
+#define SINCOS_BIT_30  (1 << 30)
+#define SMULL(x, y) ((int64_t)(x) * (int64_t)(y))
+
+static const uint32_t cossin_tbl[64] = {
+	0x3ffec42d, 0x00c90e90, 0x3ff4e5e0, 0x025b0caf,
+	0x3fe12acb, 0x03ecadcf, 0x3fc395f9, 0x057db403,
+	0x3f9c2bfb, 0x070de172, 0x3f6af2e3, 0x089cf867,
+	0x3f2ff24a, 0x0a2abb59, 0x3eeb3347, 0x0bb6ecef,
+	0x3e9cc076, 0x0d415013, 0x3e44a5ef, 0x0ec9a7f3,
+	0x3de2f148, 0x104fb80e, 0x3d77b192, 0x11d3443f,
+	0x3d02f757, 0x135410c3, 0x3c84d496, 0x14d1e242,
+	0x3bfd5cc4, 0x164c7ddd, 0x3b6ca4c4, 0x17c3a931,
+	0x3ad2c2e8, 0x19372a64, 0x3a2fcee8, 0x1aa6c82b,
+	0x3983e1e8, 0x1c1249d8, 0x38cf1669, 0x1d79775c,
+	0x3811884d, 0x1edc1953, 0x374b54ce, 0x2039f90f,
+	0x367c9a7e, 0x2192e09b, 0x35a5793c, 0x22e69ac8,
+	0x34c61236, 0x2434f332, 0x33de87de, 0x257db64c,
+	0x32eefdea, 0x26c0b162, 0x31f79948, 0x27fdb2a7,
+	0x30f8801f, 0x29348937, 0x2ff1d9c7, 0x2a650525,
+	0x2ee3cebe, 0x2b8ef77d, 0x2dce88aa, 0x2cb2324c
+};
+
+static int32_t sin_core(int32_t arc_q33, int32_t sign)
+{
+	int32_t a, b, B;
+	int32_t sin_a, cos_a;
+	int32_t S1, S2, S3, S4, T1;
+	int32_t R = 0;
+	int32_t C1 = 0x6487ed51;
+	int32_t C2 = -715827882;
+
+	a = arc_q33 >> 25;
+	cos_a = cossin_tbl[2 * a];
+	sin_a = cossin_tbl[2 * a + 1];
+	cos_a ^= (sign >> 31);
+	sin_a ^= (sign >> 31);
+	a = a << 25;
+	b = arc_q33 - a;
+	b -= (1 << 24);
+	B = SMULL((b << 3), C1) >> 32;
+	T1 = SMULL(B, B) >> 32;
+	S1 = sin_a;
+	S2 = SMULL(sin_a, T1 >> 1) >> 32;
+	S3 = SMULL(cos_a, B) >> 32;
+	S4 = SMULL(T1, C2) >> 32;
+	S4 = SMULL(S3, S4) >> 32;
+	R = S1 - S2 + S3 + S4;
+	return R;
+}
+
+static int32_t cos_core(int32_t arc_q33, int32_t sign)
+{
+	int32_t a, b, B;
+	int32_t sin_a, cos_a;
+	int32_t S1, S2, S3, S4, T1;
+	int32_t R = 0;
+	int32_t C1 = 0x6487ed51;
+	int32_t C2 = 0x2aaaaaab;
+
+	a = arc_q33 >> 25;
+	cos_a = cossin_tbl[a * 2];
+	sin_a = cossin_tbl[a * 2 + 1];
+	cos_a ^= (sign >> 31);
+	sin_a ^= (sign >> 31);
+	a = a << 25;
+	b = arc_q33 - a;
+	b -= (1 << 24);
+	B = SMULL((b << 3), C1) >> 32;
+	T1 = SMULL(B, B) >> 32;
+	S1 = cos_a;
+	S2 = SMULL(cos_a, T1 >> 1) >> 32;
+	S3 = SMULL(sin_a, B) >> 32;
+	S4 = SMULL(T1, C2) >> 32;
+	S4 = SMULL(S3, S4) >> 32;
+	R = S1 - S2 - S3 + S4;
+	return R;
+}
+
+int32_t sin_32(int32_t n)
+{
+	int32_t s = n & SINCOS_BIT_31;
+	n = n << 1;
+	if (0 == n) {
+		return 0;
+	}
+	if (SINCOS_BIT_31 == (n & SINCOS_BIT_31)) {
+		n &= ~SINCOS_BIT_31;
+		if (n < SINCOS_BIT_30) {
+			return cos_core(n, s);
+		} else if (n == SINCOS_BIT_30) {
+			n -= 1;
+		} else if (n > SINCOS_BIT_30) {
+			n = SINCOS_BIT_31 - n;
+		}
+		return sin_core(n, s);
+	} else {
+		if (n < SINCOS_BIT_30) {
+			return sin_core(n, s);
+		}
+		if (n == SINCOS_BIT_30) {
+			n -= 1;
+		} else if (n > SINCOS_BIT_30) {
+			n = SINCOS_BIT_31 - n;
+		}
+		return cos_core(n, s);
+	}
+}
+
+int32_t cos_32(int32_t n)
+{
+	int32_t s = n & SINCOS_BIT_31;
+
+	n = n << 1;
+	if (n == SINCOS_BIT_31) {
+		return 0;
+	}
+	if (SINCOS_BIT_31 == (n & SINCOS_BIT_31)) {
+		n &= ~SINCOS_BIT_31;
+		if (n < SINCOS_BIT_30) {
+			return -sin_core(n, s);
+		} else if (n == SINCOS_BIT_30) {
+			n -= 1;
+		} else if (n > SINCOS_BIT_30) {
+			n = SINCOS_BIT_31 - n;
+		}
+		return -cos_core(n, s);
+	} else {
+		if (n < SINCOS_BIT_30) {
+			return cos_core(n, s);
+		}
+		if (n == SINCOS_BIT_30) {
+			n -= 1;
+		} else if (n > SINCOS_BIT_30) {
+			n = SINCOS_BIT_31 - n;
+		}
+		return sin_core(n, s);
+	}
+}
diff --git a/drivers/media/sprd_scale/common/sin_cos.h b/drivers/media/sprd_scale/common/sin_cos.h
new file mode 100644
index 00000000..64012926
--- /dev/null
+++ b/drivers/media/sprd_scale/common/sin_cos.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _SIN_COS_H_
+#define _SIN_COS_H_
+#include <linux/types.h>
+
+#define COSSIN_Q 30
+#define pi              3.14159265359
+#define PI_32           0x3243F6A88
+#define ARC_32_COEF     0x80000000
+#define ARC_32(arc) (int32_t)((arc) / (pi) * 0x80000000);
+int32_t sin_32(int32_t n);
+int32_t cos_32(int32_t n);
+#endif
-- 
cgit v1.3.1