summaryrefslogtreecommitdiffstats
path: root/meta/recipes-kernel/linux/linux-omap-2.6.29/isp/omap3camera/0005-omap3isp-Add-ISP-backend-PRV-and-RSZ.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta/recipes-kernel/linux/linux-omap-2.6.29/isp/omap3camera/0005-omap3isp-Add-ISP-backend-PRV-and-RSZ.patch')
-rw-r--r--meta/recipes-kernel/linux/linux-omap-2.6.29/isp/omap3camera/0005-omap3isp-Add-ISP-backend-PRV-and-RSZ.patch3413
1 files changed, 3413 insertions, 0 deletions
diff --git a/meta/recipes-kernel/linux/linux-omap-2.6.29/isp/omap3camera/0005-omap3isp-Add-ISP-backend-PRV-and-RSZ.patch b/meta/recipes-kernel/linux/linux-omap-2.6.29/isp/omap3camera/0005-omap3isp-Add-ISP-backend-PRV-and-RSZ.patch
new file mode 100644
index 0000000000..c549eadc88
--- /dev/null
+++ b/meta/recipes-kernel/linux/linux-omap-2.6.29/isp/omap3camera/0005-omap3isp-Add-ISP-backend-PRV-and-RSZ.patch
@@ -0,0 +1,3413 @@
1From 926b51afea146826c8076e5fb305eaa0332399b4 Mon Sep 17 00:00:00 2001
2From: Sakari Ailus <sakari.ailus@maxwell.research.nokia.com>
3Date: Tue, 10 Mar 2009 10:49:02 +0200
4Subject: [PATCH] omap3isp: Add ISP backend (PRV and RSZ)
5
6Signed-off-by: Sakari Ailus <sakari.ailus@maxwell.research.nokia.com>
7---
8 drivers/media/video/isp/isppreview.c | 1929 ++++++++++++++++++++++++++++++++++
9 drivers/media/video/isp/isppreview.h | 354 +++++++
10 drivers/media/video/isp/ispresizer.c | 928 ++++++++++++++++
11 drivers/media/video/isp/ispresizer.h | 158 +++
12 4 files changed, 3369 insertions(+), 0 deletions(-)
13 create mode 100644 drivers/media/video/isp/isppreview.c
14 create mode 100644 drivers/media/video/isp/isppreview.h
15 create mode 100644 drivers/media/video/isp/ispresizer.c
16 create mode 100644 drivers/media/video/isp/ispresizer.h
17
18diff --git a/drivers/media/video/isp/isppreview.c b/drivers/media/video/isp/isppreview.c
19new file mode 100644
20index 0000000..17f1abc
21--- /dev/null
22+++ b/drivers/media/video/isp/isppreview.c
23@@ -0,0 +1,1929 @@
24+/*
25+ * isppreview.c
26+ *
27+ * Driver Library for Preview module in TI's OMAP3 Camera ISP
28+ *
29+ * Copyright (C) 2009 Texas Instruments, Inc.
30+ *
31+ * Contributors:
32+ * Senthilvadivu Guruswamy <svadivu@ti.com>
33+ * Pallavi Kulkarni <p-kulkarni@ti.com>
34+ * Sergio Aguirre <saaguirre@ti.com>
35+ *
36+ * This package is free software; you can redistribute it and/or modify
37+ * it under the terms of the GNU General Public License version 2 as
38+ * published by the Free Software Foundation.
39+ *
40+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
41+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
42+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
43+ */
44+
45+#include <linux/mutex.h>
46+#include <linux/module.h>
47+#include <linux/uaccess.h>
48+
49+#include "isp.h"
50+#include "ispreg.h"
51+#include "isppreview.h"
52+
53+static struct ispprev_nf prev_nf_t;
54+static struct prev_params *params;
55+static int rg_update, gg_update, bg_update, nf_enable, nf_update;
56+
57+/* Structure for saving/restoring preview module registers */
58+static struct isp_reg ispprev_reg_list[] = {
59+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_HORZ_INFO, 0x0000},
60+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_VERT_INFO, 0x0000},
61+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RSDR_ADDR, 0x0000},
62+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RADR_OFFSET, 0x0000},
63+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_DSDR_ADDR, 0x0000},
64+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_DRKF_OFFSET, 0x0000},
65+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_WSDR_ADDR, 0x0000},
66+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_WADD_OFFSET, 0x0000},
67+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_AVE, 0x0000},
68+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_HMED, 0x0000},
69+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_NF, 0x0000},
70+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_WB_DGAIN, 0x0000},
71+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_WBGAIN, 0x0000},
72+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_WBSEL, 0x0000},
73+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CFA, 0x0000},
74+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_BLKADJOFF, 0x0000},
75+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT1, 0x0000},
76+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT2, 0x0000},
77+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT3, 0x0000},
78+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT4, 0x0000},
79+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT5, 0x0000},
80+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_OFF1, 0x0000},
81+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_OFF2, 0x0000},
82+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC0, 0x0000},
83+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC1, 0x0000},
84+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC2, 0x0000},
85+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC_OFFSET, 0x0000},
86+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT, 0x0000},
87+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CSUP, 0x0000},
88+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_SETUP_YC, 0x0000},
89+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR0, 0x0000},
90+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR1, 0x0000},
91+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR2, 0x0000},
92+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR3, 0x0000},
93+ {OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, 0x0000},
94+ {0, ISP_TOK_TERM, 0x0000}
95+};
96+
97+
98+/* Default values in Office Flourescent Light for RGBtoRGB Blending */
99+static struct ispprev_rgbtorgb flr_rgb2rgb = {
100+ { /* RGB-RGB Matrix */
101+ {0x01E2, 0x0F30, 0x0FEE},
102+ {0x0F9B, 0x01AC, 0x0FB9},
103+ {0x0FE0, 0x0EC0, 0x0260}
104+ }, /* RGB Offset */
105+ {0x0000, 0x0000, 0x0000}
106+};
107+
108+/* Default values in Office Flourescent Light for RGB to YUV Conversion*/
109+static struct ispprev_csc flr_prev_csc[] = {
110+ {
111+ { /* CSC Coef Matrix */
112+ {66, 129, 25},
113+ {-38, -75, 112},
114+ {112, -94 , -18}
115+ }, /* CSC Offset */
116+ {0x0, 0x0, 0x0}
117+ },
118+ {
119+ { /* CSC Coef Matrix BW */
120+ {66, 129, 25},
121+ {0, 0, 0},
122+ {0, 0, 0}
123+ }, /* CSC Offset */
124+ {0x0, 0x0, 0x0}
125+ },
126+ {
127+ { /* CSC Coef Matrix Sepia */
128+ {19, 38, 7},
129+ {0, 0, 0},
130+ {0, 0, 0}
131+ }, /* CSC Offset */
132+ {0x0, 0xE7, 0x14}
133+ }
134+};
135+
136+
137+/* Default values in Office Flourescent Light for CFA Gradient*/
138+#define FLR_CFA_GRADTHRS_HORZ 0x28
139+#define FLR_CFA_GRADTHRS_VERT 0x28
140+
141+/* Default values in Office Flourescent Light for Chroma Suppression*/
142+#define FLR_CSUP_GAIN 0x0D
143+#define FLR_CSUP_THRES 0xEB
144+
145+/* Default values in Office Flourescent Light for Noise Filter*/
146+#define FLR_NF_STRGTH 0x03
147+
148+/* Default values in Office Flourescent Light for White Balance*/
149+#define FLR_WBAL_DGAIN 0x100
150+#define FLR_WBAL_COEF0 0x20
151+#define FLR_WBAL_COEF1 0x29
152+#define FLR_WBAL_COEF2 0x2d
153+#define FLR_WBAL_COEF3 0x20
154+
155+#define FLR_WBAL_COEF0_ES1 0x20
156+#define FLR_WBAL_COEF1_ES1 0x23
157+#define FLR_WBAL_COEF2_ES1 0x39
158+#define FLR_WBAL_COEF3_ES1 0x20
159+
160+/* Default values in Office Flourescent Light for Black Adjustment*/
161+#define FLR_BLKADJ_BLUE 0x0
162+#define FLR_BLKADJ_GREEN 0x0
163+#define FLR_BLKADJ_RED 0x0
164+
165+static int update_color_matrix;
166+
167+/**
168+ * struct isp_prev - Structure for storing ISP Preview module information
169+ * @prev_inuse: Flag to determine if CCDC has been reserved or not (0 or 1).
170+ * @prevout_w: Preview output width.
171+ * @prevout_h: Preview output height.
172+ * @previn_w: Preview input width.
173+ * @previn_h: Preview input height.
174+ * @prev_inpfmt: Preview input format.
175+ * @prev_outfmt: Preview output format.
176+ * @hmed_en: Horizontal median filter enable.
177+ * @nf_en: Noise filter enable.
178+ * @dcor_en: Defect correction enable.
179+ * @cfa_en: Color Filter Array (CFA) interpolation enable.
180+ * @csup_en: Chrominance suppression enable.
181+ * @yenh_en: Luma enhancement enable.
182+ * @fmtavg: Number of horizontal pixels to average in input formatter. The
183+ * input width should be a multiple of this number.
184+ * @brightness: Brightness in preview module.
185+ * @contrast: Contrast in preview module.
186+ * @color: Color effect in preview module.
187+ * @cfafmt: Color Filter Array (CFA) Format.
188+ * @ispprev_mutex: Mutex for isp preview.
189+ *
190+ * This structure is used to store the OMAP ISP Preview module Information.
191+ */
192+static struct isp_prev {
193+ int pm_state;
194+ u8 prev_inuse;
195+ u32 prevout_w;
196+ u32 prevout_h;
197+ u32 previn_w;
198+ u32 previn_h;
199+ enum preview_input prev_inpfmt;
200+ enum preview_output prev_outfmt;
201+ u8 hmed_en;
202+ u8 nf_en;
203+ u8 dcor_en;
204+ u8 cfa_en;
205+ u8 csup_en;
206+ u8 yenh_en;
207+ u8 fmtavg;
208+ u8 brightness;
209+ u8 contrast;
210+ enum v4l2_colorfx color;
211+ enum cfa_fmt cfafmt;
212+ struct mutex ispprev_mutex; /* For checking/modifying prev_inuse */
213+ u32 sph;
214+ u32 slv;
215+} ispprev_obj;
216+
217+/* Saved parameters */
218+static struct prev_params *prev_config_params;
219+
220+/*
221+ * Coeficient Tables for the submodules in Preview.
222+ * Array is initialised with the values from.the tables text file.
223+ */
224+
225+/*
226+ * CFA Filter Coefficient Table
227+ *
228+ */
229+static u32 cfa_coef_table[] = {
230+#include "cfa_coef_table.h"
231+};
232+
233+/*
234+ * Gamma Correction Table - Red
235+ */
236+static u32 redgamma_table[] = {
237+#include "redgamma_table.h"
238+};
239+
240+/*
241+ * Gamma Correction Table - Green
242+ */
243+static u32 greengamma_table[] = {
244+#include "greengamma_table.h"
245+};
246+
247+/*
248+ * Gamma Correction Table - Blue
249+ */
250+static u32 bluegamma_table[] = {
251+#include "bluegamma_table.h"
252+};
253+
254+/*
255+ * Noise Filter Threshold table
256+ */
257+static u32 noise_filter_table[] = {
258+#include "noise_filter_table.h"
259+};
260+
261+/*
262+ * Luminance Enhancement Table
263+ */
264+static u32 luma_enhance_table[] = {
265+#include "luma_enhance_table.h"
266+};
267+
268+/**
269+ * omap34xx_isp_preview_config - Abstraction layer Preview configuration.
270+ * @userspace_add: Pointer from Userspace to structure with flags and data to
271+ * update.
272+ **/
273+int omap34xx_isp_preview_config(void *userspace_add)
274+{
275+ struct ispprev_hmed prev_hmed_t;
276+ struct ispprev_cfa prev_cfa_t;
277+ struct ispprev_csup csup_t;
278+ struct ispprev_wbal prev_wbal_t;
279+ struct ispprev_blkadj prev_blkadj_t;
280+ struct ispprev_rgbtorgb rgb2rgb_t;
281+ struct ispprev_csc prev_csc_t;
282+ struct ispprev_yclimit yclimit_t;
283+ struct ispprev_dcor prev_dcor_t;
284+ struct ispprv_update_config *preview_struct;
285+ struct isptables_update isp_table_update;
286+ int yen_t[ISPPRV_YENH_TBL_SIZE];
287+
288+ if (userspace_add == NULL)
289+ return -EINVAL;
290+
291+ preview_struct = userspace_add;
292+
293+ if (ISP_ABS_PREV_LUMAENH & preview_struct->flag) {
294+ if (ISP_ABS_PREV_LUMAENH & preview_struct->update) {
295+ if (copy_from_user(yen_t, preview_struct->yen,
296+ sizeof(yen_t)))
297+ goto err_copy_from_user;
298+ isppreview_config_luma_enhancement(yen_t);
299+ }
300+ params->features |= PREV_LUMA_ENHANCE;
301+ } else if (ISP_ABS_PREV_LUMAENH & preview_struct->update)
302+ params->features &= ~PREV_LUMA_ENHANCE;
303+
304+ if (ISP_ABS_PREV_INVALAW & preview_struct->flag) {
305+ isppreview_enable_invalaw(1);
306+ params->features |= PREV_INVERSE_ALAW;
307+ } else {
308+ isppreview_enable_invalaw(0);
309+ params->features &= ~PREV_INVERSE_ALAW;
310+ }
311+
312+ if (ISP_ABS_PREV_HRZ_MED & preview_struct->flag) {
313+ if (ISP_ABS_PREV_HRZ_MED & preview_struct->update) {
314+ if (copy_from_user(&prev_hmed_t,
315+ (struct ispprev_hmed *)
316+ preview_struct->prev_hmed,
317+ sizeof(struct ispprev_hmed)))
318+ goto err_copy_from_user;
319+ isppreview_config_hmed(prev_hmed_t);
320+ }
321+ isppreview_enable_hmed(1);
322+ params->features |= PREV_HORZ_MEDIAN_FILTER;
323+ } else if (ISP_ABS_PREV_HRZ_MED & preview_struct->update) {
324+ isppreview_enable_hmed(0);
325+ params->features &= ~PREV_HORZ_MEDIAN_FILTER;
326+ }
327+
328+ if (ISP_ABS_PREV_CFA & preview_struct->flag) {
329+ if (ISP_ABS_PREV_CFA & preview_struct->update) {
330+ if (copy_from_user(&prev_cfa_t,
331+ (struct ispprev_cfa *)
332+ preview_struct->prev_cfa,
333+ sizeof(struct ispprev_cfa)))
334+ goto err_copy_from_user;
335+
336+ isppreview_config_cfa(prev_cfa_t);
337+ }
338+ isppreview_enable_cfa(1);
339+ params->features |= PREV_CFA;
340+ } else if (ISP_ABS_PREV_CFA & preview_struct->update) {
341+ isppreview_enable_cfa(0);
342+ params->features &= ~PREV_CFA;
343+ }
344+
345+ if (ISP_ABS_PREV_CHROMA_SUPP & preview_struct->flag) {
346+ if (ISP_ABS_PREV_CHROMA_SUPP & preview_struct->update) {
347+ if (copy_from_user(&csup_t,
348+ (struct ispprev_csup *)
349+ preview_struct->csup,
350+ sizeof(struct ispprev_csup)))
351+ goto err_copy_from_user;
352+ isppreview_config_chroma_suppression(csup_t);
353+ }
354+ isppreview_enable_chroma_suppression(1);
355+ params->features |= PREV_CHROMA_SUPPRESS;
356+ } else if (ISP_ABS_PREV_CHROMA_SUPP & preview_struct->update) {
357+ isppreview_enable_chroma_suppression(0);
358+ params->features &= ~PREV_CHROMA_SUPPRESS;
359+ }
360+
361+ if (ISP_ABS_PREV_WB & preview_struct->update) {
362+ if (copy_from_user(&prev_wbal_t, (struct ispprev_wbal *)
363+ preview_struct->prev_wbal,
364+ sizeof(struct ispprev_wbal)))
365+ goto err_copy_from_user;
366+ isppreview_config_whitebalance(prev_wbal_t);
367+ }
368+
369+ if (ISP_ABS_PREV_BLKADJ & preview_struct->update) {
370+ if (copy_from_user(&prev_blkadj_t, (struct ispprev_blkadjl *)
371+ preview_struct->prev_blkadj,
372+ sizeof(struct ispprev_blkadj)))
373+ goto err_copy_from_user;
374+ isppreview_config_blkadj(prev_blkadj_t);
375+ }
376+
377+ if (ISP_ABS_PREV_RGB2RGB & preview_struct->update) {
378+ if (copy_from_user(&rgb2rgb_t, (struct ispprev_rgbtorgb *)
379+ preview_struct->rgb2rgb,
380+ sizeof(struct ispprev_rgbtorgb)))
381+ goto err_copy_from_user;
382+ isppreview_config_rgb_blending(rgb2rgb_t);
383+ }
384+
385+ if (ISP_ABS_PREV_COLOR_CONV & preview_struct->update) {
386+ if (copy_from_user(&prev_csc_t, (struct ispprev_csc *)
387+ preview_struct->prev_csc,
388+ sizeof(struct ispprev_csc)))
389+ goto err_copy_from_user;
390+ isppreview_config_rgb_to_ycbcr(prev_csc_t);
391+ }
392+
393+ if (ISP_ABS_PREV_YC_LIMIT & preview_struct->update) {
394+ if (copy_from_user(&yclimit_t, (struct ispprev_yclimit *)
395+ preview_struct->yclimit,
396+ sizeof(struct ispprev_yclimit)))
397+ goto err_copy_from_user;
398+ isppreview_config_yc_range(yclimit_t);
399+ }
400+
401+ if (ISP_ABS_PREV_DEFECT_COR & preview_struct->flag) {
402+ if (ISP_ABS_PREV_DEFECT_COR & preview_struct->update) {
403+ if (copy_from_user(&prev_dcor_t,
404+ (struct ispprev_dcor *)
405+ preview_struct->prev_dcor,
406+ sizeof(struct ispprev_dcor)))
407+ goto err_copy_from_user;
408+ isppreview_config_dcor(prev_dcor_t);
409+ }
410+ isppreview_enable_dcor(1);
411+ params->features |= PREV_DEFECT_COR;
412+ } else if (ISP_ABS_PREV_DEFECT_COR & preview_struct->update) {
413+ isppreview_enable_dcor(0);
414+ params->features &= ~PREV_DEFECT_COR;
415+ }
416+
417+ if (ISP_ABS_PREV_GAMMABYPASS & preview_struct->flag) {
418+ isppreview_enable_gammabypass(1);
419+ params->features |= PREV_GAMMA_BYPASS;
420+ } else {
421+ isppreview_enable_gammabypass(0);
422+ params->features &= ~PREV_GAMMA_BYPASS;
423+ }
424+
425+ isp_table_update.update = preview_struct->update;
426+ isp_table_update.flag = preview_struct->flag;
427+ isp_table_update.prev_nf = preview_struct->prev_nf;
428+ isp_table_update.red_gamma = preview_struct->red_gamma;
429+ isp_table_update.green_gamma = preview_struct->green_gamma;
430+ isp_table_update.blue_gamma = preview_struct->blue_gamma;
431+
432+ if (omap34xx_isp_tables_update(&isp_table_update))
433+ goto err_copy_from_user;
434+
435+ return 0;
436+
437+err_copy_from_user:
438+ printk(KERN_ERR "Preview Config: Copy From User Error\n");
439+ return -EFAULT;
440+}
441+EXPORT_SYMBOL_GPL(omap34xx_isp_preview_config);
442+
443+/**
444+ * omap34xx_isp_tables_update - Abstraction layer Tables update.
445+ * @isptables_struct: Pointer from Userspace to structure with flags and table
446+ * data to update.
447+ **/
448+int omap34xx_isp_tables_update(struct isptables_update *isptables_struct)
449+{
450+
451+ if (ISP_ABS_TBL_NF & isptables_struct->flag) {
452+ nf_enable = 1;
453+ params->features |= PREV_NOISE_FILTER;
454+ if (ISP_ABS_TBL_NF & isptables_struct->update) {
455+ if (copy_from_user(&prev_nf_t, (struct ispprev_nf *)
456+ isptables_struct->prev_nf,
457+ sizeof(struct ispprev_nf)))
458+ goto err_copy_from_user;
459+
460+ nf_update = 1;
461+ } else
462+ nf_update = 0;
463+ } else {
464+ nf_enable = 0;
465+ params->features &= ~PREV_NOISE_FILTER;
466+ if (ISP_ABS_TBL_NF & isptables_struct->update)
467+ nf_update = 1;
468+ else
469+ nf_update = 0;
470+ }
471+
472+ if (ISP_ABS_TBL_REDGAMMA & isptables_struct->update) {
473+ if (copy_from_user(redgamma_table, isptables_struct->red_gamma,
474+ sizeof(redgamma_table))) {
475+ goto err_copy_from_user;
476+ }
477+ rg_update = 1;
478+ } else
479+ rg_update = 0;
480+
481+ if (ISP_ABS_TBL_GREENGAMMA & isptables_struct->update) {
482+ if (copy_from_user(greengamma_table,
483+ isptables_struct->green_gamma,
484+ sizeof(greengamma_table)))
485+ goto err_copy_from_user;
486+ gg_update = 1;
487+ } else
488+ gg_update = 0;
489+
490+ if (ISP_ABS_TBL_BLUEGAMMA & isptables_struct->update) {
491+ if (copy_from_user(bluegamma_table,
492+ isptables_struct->blue_gamma,
493+ sizeof(bluegamma_table))) {
494+ goto err_copy_from_user;
495+ }
496+ bg_update = 1;
497+ } else
498+ bg_update = 0;
499+
500+ return 0;
501+
502+err_copy_from_user:
503+ printk(KERN_ERR "Preview Tables:Copy From User Error\n");
504+ return -EFAULT;
505+}
506+
507+/**
508+ * isppreview_config_shadow_registers - Program shadow registers for preview.
509+ *
510+ * Allows user to program shadow registers associated with preview module.
511+ **/
512+void isppreview_config_shadow_registers()
513+{
514+ u8 current_brightness_contrast;
515+ int ctr, prv_disabled;
516+
517+ isppreview_query_brightness(&current_brightness_contrast);
518+ if (current_brightness_contrast !=
519+ (ispprev_obj.brightness * ISPPRV_BRIGHT_UNITS)) {
520+ DPRINTK_ISPPREV(" Changing Brightness level to %d\n",
521+ ispprev_obj.brightness);
522+ isppreview_config_brightness(ispprev_obj.brightness *
523+ ISPPRV_BRIGHT_UNITS);
524+ }
525+
526+ isppreview_query_contrast(&current_brightness_contrast);
527+ if (current_brightness_contrast !=
528+ (ispprev_obj.contrast * ISPPRV_CONTRAST_UNITS)) {
529+ DPRINTK_ISPPREV(" Changing Contrast level to %d\n",
530+ ispprev_obj.contrast);
531+ isppreview_config_contrast(ispprev_obj.contrast *
532+ ISPPRV_CONTRAST_UNITS);
533+ }
534+ if (update_color_matrix) {
535+ isppreview_config_rgb_to_ycbcr(flr_prev_csc[ispprev_obj.color]);
536+ update_color_matrix = 0;
537+ }
538+ if (gg_update || rg_update || bg_update || nf_update) {
539+ isppreview_enable(0);
540+ prv_disabled = 1;
541+ }
542+
543+ if (gg_update) {
544+ isp_reg_writel(ISPPRV_TBL_ADDR_GREEN_G_START,
545+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
546+
547+ for (ctr = 0; ctr < ISP_GAMMA_TABLE_SIZE; ctr++) {
548+ isp_reg_writel(greengamma_table[ctr],
549+ OMAP3_ISP_IOMEM_PREV,
550+ ISPPRV_SET_TBL_DATA);
551+ }
552+ gg_update = 0;
553+ }
554+
555+ if (rg_update) {
556+ isp_reg_writel(ISPPRV_TBL_ADDR_RED_G_START,
557+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
558+
559+ for (ctr = 0; ctr < ISP_GAMMA_TABLE_SIZE; ctr++) {
560+ isp_reg_writel(redgamma_table[ctr],
561+ OMAP3_ISP_IOMEM_PREV,
562+ ISPPRV_SET_TBL_DATA);
563+ }
564+ rg_update = 0;
565+ }
566+
567+ if (bg_update) {
568+ isp_reg_writel(ISPPRV_TBL_ADDR_BLUE_G_START,
569+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
570+
571+ for (ctr = 0; ctr < ISP_GAMMA_TABLE_SIZE; ctr++) {
572+ isp_reg_writel(bluegamma_table[ctr],
573+ OMAP3_ISP_IOMEM_PREV,
574+ ISPPRV_SET_TBL_DATA);
575+ }
576+ bg_update = 0;
577+ }
578+
579+ if (nf_update && nf_enable) {
580+ isp_reg_writel(0xC00,
581+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
582+ isp_reg_writel(prev_nf_t.spread,
583+ OMAP3_ISP_IOMEM_PREV, ISPPRV_NF);
584+ for (ctr = 0; ctr < ISPPRV_NF_TBL_SIZE; ctr++) {
585+ isp_reg_writel(prev_nf_t.table[ctr],
586+ OMAP3_ISP_IOMEM_PREV,
587+ ISPPRV_SET_TBL_DATA);
588+ }
589+ isppreview_enable_noisefilter(1);
590+ nf_update = 0;
591+ }
592+
593+ if (~nf_update && nf_enable)
594+ isppreview_enable_noisefilter(1);
595+
596+ if (nf_update && ~nf_enable)
597+ isppreview_enable_noisefilter(0);
598+
599+ if (prv_disabled) {
600+ isppreview_enable(1);
601+ prv_disabled = 0;
602+ }
603+}
604+EXPORT_SYMBOL_GPL(isppreview_config_shadow_registers);
605+
606+/**
607+ * isppreview_request - Reserves the preview module.
608+ *
609+ * Returns 0 if successful, or -EBUSY if the module was already reserved.
610+ **/
611+int isppreview_request()
612+{
613+ mutex_lock(&ispprev_obj.ispprev_mutex);
614+ if (ispprev_obj.prev_inuse) {
615+ mutex_unlock(&ispprev_obj.ispprev_mutex);
616+ printk(KERN_ERR "ISP_ERR : Preview Module Busy\n");
617+ return -EBUSY;
618+ }
619+ ispprev_obj.prev_inuse = 1;
620+ mutex_unlock(&ispprev_obj.ispprev_mutex);
621+ isp_reg_or(OMAP3_ISP_IOMEM_MAIN, ISP_CTRL, ISPCTRL_PREV_RAM_EN |
622+ ISPCTRL_PREV_CLK_EN |
623+ ISPCTRL_SBL_WR1_RAM_EN);
624+ return 0;
625+}
626+EXPORT_SYMBOL_GPL(isppreview_request);
627+
628+/**
629+ * isppreview_free - Frees the preview module.
630+ *
631+ * Returns 0 if successful, or -EINVAL if the module was already freed.
632+ **/
633+int isppreview_free()
634+{
635+ mutex_lock(&ispprev_obj.ispprev_mutex);
636+ if (ispprev_obj.prev_inuse) {
637+ ispprev_obj.prev_inuse = 0;
638+ mutex_unlock(&ispprev_obj.ispprev_mutex);
639+ isp_reg_and(OMAP3_ISP_IOMEM_MAIN, ISP_CTRL,
640+ ~(ISPCTRL_PREV_CLK_EN |
641+ ISPCTRL_PREV_RAM_EN |
642+ ISPCTRL_SBL_WR1_RAM_EN));
643+ return 0;
644+ } else {
645+ mutex_unlock(&ispprev_obj.ispprev_mutex);
646+ DPRINTK_ISPPREV("ISP_ERR : Preview Module already freed\n");
647+ return -EINVAL;
648+ }
649+
650+}
651+EXPORT_SYMBOL_GPL(isppreview_free);
652+
653+/** isppreview_config_datapath - Specifies input and output modules for Preview
654+ * @input: Indicates the module that gives the image to preview.
655+ * @output: Indicates the module to which the preview outputs to.
656+ *
657+ * Configures the default configuration for the CCDC to work with.
658+ *
659+ * The valid values for the input are PRV_RAW_CCDC (0), PRV_RAW_MEM (1),
660+ * PRV_RGBBAYERCFA (2), PRV_COMPCFA (3), PRV_CCDC_DRKF (4), PRV_OTHERS (5).
661+ *
662+ * The valid values for the output are PREVIEW_RSZ (0), PREVIEW_MEM (1).
663+ *
664+ * Returns 0 if successful, or -EINVAL if wrong input or output values are
665+ * specified.
666+ **/
667+int isppreview_config_datapath(enum preview_input input,
668+ enum preview_output output)
669+{
670+ u32 pcr = 0;
671+ u8 enable = 0;
672+ struct prev_params *params = prev_config_params;
673+ struct ispprev_yclimit yclimit;
674+
675+ pcr = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
676+
677+ switch (input) {
678+ case PRV_RAW_CCDC:
679+ pcr &= ~ISPPRV_PCR_SOURCE;
680+ pcr &= ~ISPPRV_PCR_ONESHOT;
681+ ispprev_obj.prev_inpfmt = PRV_RAW_CCDC;
682+ break;
683+ case PRV_RAW_MEM:
684+ pcr |= ISPPRV_PCR_SOURCE;
685+ pcr |= ISPPRV_PCR_ONESHOT;
686+ ispprev_obj.prev_inpfmt = PRV_RAW_MEM;
687+ break;
688+ case PRV_CCDC_DRKF:
689+ pcr |= ISPPRV_PCR_DRKFCAP;
690+ pcr |= ISPPRV_PCR_ONESHOT;
691+ ispprev_obj.prev_inpfmt = PRV_CCDC_DRKF;
692+ break;
693+ case PRV_COMPCFA:
694+ ispprev_obj.prev_inpfmt = PRV_COMPCFA;
695+ break;
696+ case PRV_OTHERS:
697+ ispprev_obj.prev_inpfmt = PRV_OTHERS;
698+ break;
699+ case PRV_RGBBAYERCFA:
700+ ispprev_obj.prev_inpfmt = PRV_RGBBAYERCFA;
701+ break;
702+ default:
703+ printk(KERN_ERR "ISP_ERR : Wrong Input\n");
704+ return -EINVAL;
705+ };
706+
707+ switch (output) {
708+ case PREVIEW_RSZ:
709+ pcr |= ISPPRV_PCR_RSZPORT;
710+ pcr &= ~ISPPRV_PCR_SDRPORT;
711+ break;
712+ case PREVIEW_MEM:
713+ pcr &= ~ISPPRV_PCR_RSZPORT;
714+ pcr |= ISPPRV_PCR_SDRPORT;
715+ break;
716+ default:
717+ printk(KERN_ERR "ISP_ERR : Wrong Output\n");
718+ return -EINVAL;
719+ }
720+ ispprev_obj.prev_outfmt = output;
721+
722+ isp_reg_writel(pcr, OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
723+
724+ isppreview_config_ycpos(params->pix_fmt);
725+
726+ if (params->cfa.cfa_table != NULL)
727+ isppreview_config_cfa(params->cfa);
728+ if (params->csup.hypf_en == 1)
729+ isppreview_config_chroma_suppression(params->csup);
730+ if (params->ytable != NULL)
731+ isppreview_config_luma_enhancement(params->ytable);
732+
733+ if (params->gtable.redtable != NULL)
734+ isppreview_config_gammacorrn(params->gtable);
735+
736+ enable = (params->features & PREV_CFA) ? 1 : 0;
737+ isppreview_enable_cfa(enable);
738+
739+ enable = (params->features & PREV_CHROMA_SUPPRESS) ? 1 : 0;
740+ isppreview_enable_chroma_suppression(enable);
741+
742+ enable = (params->features & PREV_LUMA_ENHANCE) ? 1 : 0;
743+ isppreview_enable_luma_enhancement(enable);
744+
745+ enable = (params->features & PREV_NOISE_FILTER) ? 1 : 0;
746+ if (enable)
747+ isppreview_config_noisefilter(params->nf);
748+ isppreview_enable_noisefilter(enable);
749+
750+ enable = (params->features & PREV_DEFECT_COR) ? 1 : 0;
751+ if (enable)
752+ isppreview_config_dcor(params->dcor);
753+ isppreview_enable_dcor(enable);
754+
755+ enable = (params->features & PREV_GAMMA_BYPASS) ? 1 : 0;
756+ isppreview_enable_gammabypass(enable);
757+
758+ isppreview_config_whitebalance(params->wbal);
759+ isppreview_config_blkadj(params->blk_adj);
760+ isppreview_config_rgb_blending(params->rgb2rgb);
761+ isppreview_config_rgb_to_ycbcr(params->rgb2ycbcr);
762+
763+ isppreview_config_contrast(params->contrast * ISPPRV_CONTRAST_UNITS);
764+ isppreview_config_brightness(params->brightness * ISPPRV_BRIGHT_UNITS);
765+
766+ yclimit.minC = ISPPRV_YC_MIN;
767+ yclimit.maxC = ISPPRV_YC_MAX;
768+ yclimit.minY = ISPPRV_YC_MIN;
769+ yclimit.maxY = ISPPRV_YC_MAX;
770+ isppreview_config_yc_range(yclimit);
771+
772+ return 0;
773+}
774+EXPORT_SYMBOL_GPL(isppreview_config_datapath);
775+
776+/**
777+ * isppreview_set_skip - Set the number of rows/columns that should be skipped.
778+ * h - Start Pixel Horizontal.
779+ * v - Start Line Vertical.
780+ **/
781+void isppreview_set_skip(u32 h, u32 v)
782+{
783+ ispprev_obj.sph = h;
784+ ispprev_obj.slv = v;
785+}
786+EXPORT_SYMBOL_GPL(isppreview_set_skip);
787+
788+/**
789+ * isppreview_config_ycpos - Configure byte layout of YUV image.
790+ * @mode: Indicates the required byte layout.
791+ **/
792+void isppreview_config_ycpos(enum preview_ycpos_mode mode)
793+{
794+ u32 pcr = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
795+ pcr &= ~ISPPRV_PCR_YCPOS_CrYCbY;
796+ pcr |= (mode << ISPPRV_PCR_YCPOS_SHIFT);
797+ isp_reg_writel(pcr, OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
798+}
799+EXPORT_SYMBOL_GPL(isppreview_config_ycpos);
800+
801+/**
802+ * isppreview_config_averager - Enable / disable / configure averager
803+ * @average: Average value to be configured.
804+ **/
805+void isppreview_config_averager(u8 average)
806+{
807+ int reg = 0;
808+
809+ reg = AVE_ODD_PIXEL_DIST | AVE_EVEN_PIXEL_DIST | average;
810+ isp_reg_writel(reg, OMAP3_ISP_IOMEM_PREV, ISPPRV_AVE);
811+}
812+EXPORT_SYMBOL_GPL(isppreview_config_averager);
813+
814+/**
815+ * isppreview_enable_invalaw - Enable/Disable Inverse A-Law module in Preview.
816+ * @enable: 1 - Reverse the A-Law done in CCDC.
817+ **/
818+void isppreview_enable_invalaw(u8 enable)
819+{
820+ u32 pcr_val = 0;
821+ pcr_val = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
822+
823+ if (enable) {
824+ isp_reg_writel(pcr_val | ISPPRV_PCR_WIDTH | ISPPRV_PCR_INVALAW,
825+ OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
826+ } else {
827+ isp_reg_writel(pcr_val &
828+ ~(ISPPRV_PCR_WIDTH | ISPPRV_PCR_INVALAW),
829+ OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
830+ }
831+}
832+EXPORT_SYMBOL_GPL(isppreview_enable_invalaw);
833+
834+/**
835+ * isppreview_enable_drkframe - Enable/Disable of the darkframe subtract.
836+ * @enable: 1 - Acquires memory bandwidth since the pixels in each frame is
837+ * subtracted with the pixels in the current frame.
838+ *
839+ * The proccess is applied for each captured frame.
840+ **/
841+void isppreview_enable_drkframe(u8 enable)
842+{
843+ if (enable)
844+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_DRKFEN);
845+ else {
846+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
847+ ~ISPPRV_PCR_DRKFEN);
848+ }
849+}
850+EXPORT_SYMBOL_GPL(isppreview_enable_drkframe);
851+
852+/**
853+ * isppreview_enable_shadcomp - Enables/Disables the shading compensation.
854+ * @enable: 1 - Enables the shading compensation.
855+ *
856+ * If dark frame subtract won't be used, then enable this shading
857+ * compensation.
858+ **/
859+void isppreview_enable_shadcomp(u8 enable)
860+{
861+
862+ if (enable) {
863+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
864+ ISPPRV_PCR_SCOMP_EN);
865+ isppreview_enable_drkframe(1);
866+ } else {
867+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
868+ ~ISPPRV_PCR_SCOMP_EN);
869+ }
870+}
871+EXPORT_SYMBOL_GPL(isppreview_enable_shadcomp);
872+
873+/**
874+ * isppreview_config_drkf_shadcomp - Configures shift value in shading comp.
875+ * @scomp_shtval: 3bit value of shift used in shading compensation.
876+ **/
877+void isppreview_config_drkf_shadcomp(u8 scomp_shtval)
878+{
879+ u32 pcr_val = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
880+
881+ pcr_val &= ISPPRV_PCR_SCOMP_SFT_MASK;
882+ isp_reg_writel(pcr_val | (scomp_shtval << ISPPRV_PCR_SCOMP_SFT_SHIFT),
883+ OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR);
884+}
885+EXPORT_SYMBOL_GPL(isppreview_config_drkf_shadcomp);
886+
887+/**
888+ * isppreview_enable_hmed - Enables/Disables of the Horizontal Median Filter.
889+ * @enable: 1 - Enables Horizontal Median Filter.
890+ **/
891+void isppreview_enable_hmed(u8 enable)
892+{
893+ if (enable)
894+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_HMEDEN);
895+ else {
896+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
897+ ~ISPPRV_PCR_HMEDEN);
898+ }
899+ ispprev_obj.hmed_en = enable ? 1 : 0;
900+}
901+EXPORT_SYMBOL_GPL(isppreview_enable_hmed);
902+
903+/**
904+ * isppreview_config_hmed - Configures the Horizontal Median Filter.
905+ * @prev_hmed: Structure containing the odd and even distance between the
906+ * pixels in the image along with the filter threshold.
907+ **/
908+void isppreview_config_hmed(struct ispprev_hmed prev_hmed)
909+{
910+
911+ u32 odddist = 0;
912+ u32 evendist = 0;
913+
914+ if (prev_hmed.odddist == 1)
915+ odddist = ~ISPPRV_HMED_ODDDIST;
916+ else
917+ odddist = ISPPRV_HMED_ODDDIST;
918+
919+ if (prev_hmed.evendist == 1)
920+ evendist = ~ISPPRV_HMED_EVENDIST;
921+ else
922+ evendist = ISPPRV_HMED_EVENDIST;
923+
924+ isp_reg_writel(odddist | evendist | (prev_hmed.thres <<
925+ ISPPRV_HMED_THRESHOLD_SHIFT),
926+ OMAP3_ISP_IOMEM_PREV, ISPPRV_HMED);
927+
928+}
929+EXPORT_SYMBOL_GPL(isppreview_config_hmed);
930+
931+/**
932+ * isppreview_config_noisefilter - Configures the Noise Filter.
933+ * @prev_nf: Structure containing the noisefilter table, strength to be used
934+ * for the noise filter and the defect correction enable flag.
935+ **/
936+void isppreview_config_noisefilter(struct ispprev_nf prev_nf)
937+{
938+ int i = 0;
939+
940+ isp_reg_writel(prev_nf.spread, OMAP3_ISP_IOMEM_PREV, ISPPRV_NF);
941+ isp_reg_writel(ISPPRV_NF_TABLE_ADDR, OMAP3_ISP_IOMEM_PREV,
942+ ISPPRV_SET_TBL_ADDR);
943+ for (i = 0; i < ISPPRV_NF_TBL_SIZE; i++) {
944+ isp_reg_writel(prev_nf.table[i], OMAP3_ISP_IOMEM_PREV,
945+ ISPPRV_SET_TBL_DATA);
946+ }
947+}
948+EXPORT_SYMBOL_GPL(isppreview_config_noisefilter);
949+
950+/**
951+ * isppreview_config_dcor - Configures the defect correction
952+ * @prev_nf: Structure containing the defect correction structure
953+ **/
954+void isppreview_config_dcor(struct ispprev_dcor prev_dcor)
955+{
956+ if (prev_dcor.couplet_mode_en) {
957+ isp_reg_writel(prev_dcor.detect_correct[0],
958+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR0);
959+ isp_reg_writel(prev_dcor.detect_correct[1],
960+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR1);
961+ isp_reg_writel(prev_dcor.detect_correct[2],
962+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR2);
963+ isp_reg_writel(prev_dcor.detect_correct[3],
964+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CDC_THR3);
965+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_DCCOUP);
966+ } else {
967+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
968+ ~ISPPRV_PCR_DCCOUP);
969+ }
970+}
971+EXPORT_SYMBOL_GPL(isppreview_config_dcor);
972+
973+/**
974+ * isppreview_config_cfa - Configures the CFA Interpolation parameters.
975+ * @prev_cfa: Structure containing the CFA interpolation table, CFA format
976+ * in the image, vertical and horizontal gradient threshold.
977+ **/
978+void isppreview_config_cfa(struct ispprev_cfa prev_cfa)
979+{
980+ int i = 0;
981+
982+ ispprev_obj.cfafmt = prev_cfa.cfafmt;
983+
984+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
985+ (prev_cfa.cfafmt << ISPPRV_PCR_CFAFMT_SHIFT));
986+
987+ isp_reg_writel(
988+ (prev_cfa.cfa_gradthrs_vert << ISPPRV_CFA_GRADTH_VER_SHIFT) |
989+ (prev_cfa.cfa_gradthrs_horz << ISPPRV_CFA_GRADTH_HOR_SHIFT),
990+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CFA);
991+
992+ isp_reg_writel(ISPPRV_CFA_TABLE_ADDR, OMAP3_ISP_IOMEM_PREV,
993+ ISPPRV_SET_TBL_ADDR);
994+
995+ for (i = 0; i < ISPPRV_CFA_TBL_SIZE; i++) {
996+ isp_reg_writel(prev_cfa.cfa_table[i],
997+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_DATA);
998+ }
999+}
1000+EXPORT_SYMBOL_GPL(isppreview_config_cfa);
1001+
1002+/**
1003+ * isppreview_config_gammacorrn - Configures the Gamma Correction table values
1004+ * @gtable: Structure containing the table for red, blue, green gamma table.
1005+ **/
1006+void isppreview_config_gammacorrn(struct ispprev_gtable gtable)
1007+{
1008+ int i = 0;
1009+
1010+ isp_reg_writel(ISPPRV_REDGAMMA_TABLE_ADDR,
1011+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
1012+ for (i = 0; i < ISPPRV_GAMMA_TBL_SIZE; i++) {
1013+ isp_reg_writel(gtable.redtable[i],
1014+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_DATA);
1015+ }
1016+
1017+ isp_reg_writel(ISPPRV_GREENGAMMA_TABLE_ADDR,
1018+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
1019+ for (i = 0; i < ISPPRV_GAMMA_TBL_SIZE; i++) {
1020+ isp_reg_writel(gtable.greentable[i],
1021+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_DATA);
1022+ }
1023+
1024+ isp_reg_writel(ISPPRV_BLUEGAMMA_TABLE_ADDR,
1025+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
1026+ for (i = 0; i < ISPPRV_GAMMA_TBL_SIZE; i++) {
1027+ isp_reg_writel(gtable.bluetable[i],
1028+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_DATA);
1029+ }
1030+}
1031+EXPORT_SYMBOL_GPL(isppreview_config_gammacorrn);
1032+
1033+/**
1034+ * isppreview_config_luma_enhancement - Sets the Luminance Enhancement table.
1035+ * @ytable: Structure containing the table for Luminance Enhancement table.
1036+ **/
1037+void isppreview_config_luma_enhancement(u32 *ytable)
1038+{
1039+ int i = 0;
1040+
1041+ isp_reg_writel(ISPPRV_YENH_TABLE_ADDR,
1042+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_ADDR);
1043+ for (i = 0; i < ISPPRV_YENH_TBL_SIZE; i++) {
1044+ isp_reg_writel(ytable[i],
1045+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SET_TBL_DATA);
1046+ }
1047+}
1048+EXPORT_SYMBOL_GPL(isppreview_config_luma_enhancement);
1049+
1050+/**
1051+ * isppreview_config_chroma_suppression - Configures the Chroma Suppression.
1052+ * @csup: Structure containing the threshold value for suppression
1053+ * and the hypass filter enable flag.
1054+ **/
1055+void isppreview_config_chroma_suppression(struct ispprev_csup csup)
1056+{
1057+ isp_reg_writel(csup.gain | (csup.thres << ISPPRV_CSUP_THRES_SHIFT) |
1058+ (csup.hypf_en << ISPPRV_CSUP_HPYF_SHIFT),
1059+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CSUP);
1060+}
1061+EXPORT_SYMBOL_GPL(isppreview_config_chroma_suppression);
1062+
1063+/**
1064+ * isppreview_enable_noisefilter - Enables/Disables the Noise Filter.
1065+ * @enable: 1 - Enables the Noise Filter.
1066+ **/
1067+void isppreview_enable_noisefilter(u8 enable)
1068+{
1069+ if (enable)
1070+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_NFEN);
1071+ else
1072+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ~ISPPRV_PCR_NFEN);
1073+ ispprev_obj.nf_en = enable ? 1 : 0;
1074+}
1075+EXPORT_SYMBOL_GPL(isppreview_enable_noisefilter);
1076+
1077+/**
1078+ * isppreview_enable_dcor - Enables/Disables the defect correction.
1079+ * @enable: 1 - Enables the defect correction.
1080+ **/
1081+void isppreview_enable_dcor(u8 enable)
1082+{
1083+ if (enable)
1084+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_DCOREN);
1085+ else {
1086+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1087+ ~ISPPRV_PCR_DCOREN);
1088+ }
1089+ ispprev_obj.dcor_en = enable ? 1 : 0;
1090+}
1091+EXPORT_SYMBOL_GPL(isppreview_enable_dcor);
1092+
1093+/**
1094+ * isppreview_enable_cfa - Enable/Disable the CFA Interpolation.
1095+ * @enable: 1 - Enables the CFA.
1096+ **/
1097+void isppreview_enable_cfa(u8 enable)
1098+{
1099+ if (enable)
1100+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_CFAEN);
1101+ else {
1102+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1103+ ~ISPPRV_PCR_CFAEN);
1104+ }
1105+ ispprev_obj.cfa_en = enable ? 1 : 0;
1106+}
1107+EXPORT_SYMBOL_GPL(isppreview_enable_cfa);
1108+
1109+/**
1110+ * isppreview_enable_gammabypass - Enables/Disables the GammaByPass
1111+ * @enable: 1 - Bypasses Gamma - 10bit input is cropped to 8MSB.
1112+ * 0 - Goes through Gamma Correction. input and output is 10bit.
1113+ **/
1114+void isppreview_enable_gammabypass(u8 enable)
1115+{
1116+ if (enable) {
1117+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1118+ ISPPRV_PCR_GAMMA_BYPASS);
1119+ } else {
1120+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1121+ ~ISPPRV_PCR_GAMMA_BYPASS);
1122+ }
1123+}
1124+EXPORT_SYMBOL_GPL(isppreview_enable_gammabypass);
1125+
1126+/**
1127+ * isppreview_enable_luma_enhancement - Enables/Disables Luminance Enhancement
1128+ * @enable: 1 - Enable the Luminance Enhancement.
1129+ **/
1130+void isppreview_enable_luma_enhancement(u8 enable)
1131+{
1132+ if (enable) {
1133+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1134+ ISPPRV_PCR_YNENHEN);
1135+ } else {
1136+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1137+ ~ISPPRV_PCR_YNENHEN);
1138+ }
1139+ ispprev_obj.yenh_en = enable ? 1 : 0;
1140+}
1141+EXPORT_SYMBOL_GPL(isppreview_enable_luma_enhancement);
1142+
1143+/**
1144+ * isppreview_enable_chroma_suppression - Enables/Disables Chrominance Suppr.
1145+ * @enable: 1 - Enable the Chrominance Suppression.
1146+ **/
1147+void isppreview_enable_chroma_suppression(u8 enable)
1148+{
1149+ if (enable)
1150+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_SUPEN);
1151+ else {
1152+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR,
1153+ ~ISPPRV_PCR_SUPEN);
1154+ }
1155+ ispprev_obj.csup_en = enable ? 1 : 0;
1156+}
1157+EXPORT_SYMBOL_GPL(isppreview_enable_chroma_suppression);
1158+
1159+/**
1160+ * isppreview_config_whitebalance - Configures the White Balance parameters.
1161+ * @prev_wbal: Structure containing the digital gain and white balance
1162+ * coefficient.
1163+ *
1164+ * Coefficient matrix always with default values.
1165+ **/
1166+void isppreview_config_whitebalance(struct ispprev_wbal prev_wbal)
1167+{
1168+ u32 val;
1169+
1170+ isp_reg_writel(prev_wbal.dgain, OMAP3_ISP_IOMEM_PREV, ISPPRV_WB_DGAIN);
1171+
1172+ val = prev_wbal.coef0 << ISPPRV_WBGAIN_COEF0_SHIFT;
1173+ val |= prev_wbal.coef1 << ISPPRV_WBGAIN_COEF1_SHIFT;
1174+ val |= prev_wbal.coef2 << ISPPRV_WBGAIN_COEF2_SHIFT;
1175+ val |= prev_wbal.coef3 << ISPPRV_WBGAIN_COEF3_SHIFT;
1176+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_WBGAIN);
1177+
1178+ isp_reg_writel(ISPPRV_WBSEL_COEF0 << ISPPRV_WBSEL_N0_0_SHIFT |
1179+ ISPPRV_WBSEL_COEF1 << ISPPRV_WBSEL_N0_1_SHIFT |
1180+ ISPPRV_WBSEL_COEF0 << ISPPRV_WBSEL_N0_2_SHIFT |
1181+ ISPPRV_WBSEL_COEF1 << ISPPRV_WBSEL_N0_3_SHIFT |
1182+ ISPPRV_WBSEL_COEF2 << ISPPRV_WBSEL_N1_0_SHIFT |
1183+ ISPPRV_WBSEL_COEF3 << ISPPRV_WBSEL_N1_1_SHIFT |
1184+ ISPPRV_WBSEL_COEF2 << ISPPRV_WBSEL_N1_2_SHIFT |
1185+ ISPPRV_WBSEL_COEF3 << ISPPRV_WBSEL_N1_3_SHIFT |
1186+ ISPPRV_WBSEL_COEF0 << ISPPRV_WBSEL_N2_0_SHIFT |
1187+ ISPPRV_WBSEL_COEF1 << ISPPRV_WBSEL_N2_1_SHIFT |
1188+ ISPPRV_WBSEL_COEF0 << ISPPRV_WBSEL_N2_2_SHIFT |
1189+ ISPPRV_WBSEL_COEF1 << ISPPRV_WBSEL_N2_3_SHIFT |
1190+ ISPPRV_WBSEL_COEF2 << ISPPRV_WBSEL_N3_0_SHIFT |
1191+ ISPPRV_WBSEL_COEF3 << ISPPRV_WBSEL_N3_1_SHIFT |
1192+ ISPPRV_WBSEL_COEF2 << ISPPRV_WBSEL_N3_2_SHIFT |
1193+ ISPPRV_WBSEL_COEF3 << ISPPRV_WBSEL_N3_3_SHIFT,
1194+ OMAP3_ISP_IOMEM_PREV, ISPPRV_WBSEL);
1195+}
1196+EXPORT_SYMBOL_GPL(isppreview_config_whitebalance);
1197+
1198+/**
1199+ * isppreview_config_whitebalance2 - Configures the White Balance parameters.
1200+ * @prev_wbal: Structure containing the digital gain and white balance
1201+ * coefficient.
1202+ *
1203+ * Coefficient matrix can be changed.
1204+ **/
1205+void isppreview_config_whitebalance2(struct prev_white_balance prev_wbal)
1206+{
1207+ isp_reg_writel(prev_wbal.wb_dgain,
1208+ OMAP3_ISP_IOMEM_PREV, ISPPRV_WB_DGAIN);
1209+ isp_reg_writel(prev_wbal.wb_gain[0] |
1210+ prev_wbal.wb_gain[1] << ISPPRV_WBGAIN_COEF1_SHIFT |
1211+ prev_wbal.wb_gain[2] << ISPPRV_WBGAIN_COEF2_SHIFT |
1212+ prev_wbal.wb_gain[3] << ISPPRV_WBGAIN_COEF3_SHIFT,
1213+ OMAP3_ISP_IOMEM_PREV, ISPPRV_WBGAIN);
1214+
1215+ isp_reg_writel(
1216+ prev_wbal.wb_coefmatrix[0][0] << ISPPRV_WBSEL_N0_0_SHIFT |
1217+ prev_wbal.wb_coefmatrix[0][1] << ISPPRV_WBSEL_N0_1_SHIFT |
1218+ prev_wbal.wb_coefmatrix[0][2] << ISPPRV_WBSEL_N0_2_SHIFT |
1219+ prev_wbal.wb_coefmatrix[0][3] << ISPPRV_WBSEL_N0_3_SHIFT |
1220+ prev_wbal.wb_coefmatrix[1][0] << ISPPRV_WBSEL_N1_0_SHIFT |
1221+ prev_wbal.wb_coefmatrix[1][1] << ISPPRV_WBSEL_N1_1_SHIFT |
1222+ prev_wbal.wb_coefmatrix[1][2] << ISPPRV_WBSEL_N1_2_SHIFT |
1223+ prev_wbal.wb_coefmatrix[1][3] << ISPPRV_WBSEL_N1_3_SHIFT |
1224+ prev_wbal.wb_coefmatrix[2][0] << ISPPRV_WBSEL_N2_0_SHIFT |
1225+ prev_wbal.wb_coefmatrix[2][1] << ISPPRV_WBSEL_N2_1_SHIFT |
1226+ prev_wbal.wb_coefmatrix[2][2] << ISPPRV_WBSEL_N2_2_SHIFT |
1227+ prev_wbal.wb_coefmatrix[2][3] << ISPPRV_WBSEL_N2_3_SHIFT |
1228+ prev_wbal.wb_coefmatrix[3][0] << ISPPRV_WBSEL_N3_0_SHIFT |
1229+ prev_wbal.wb_coefmatrix[3][1] << ISPPRV_WBSEL_N3_1_SHIFT |
1230+ prev_wbal.wb_coefmatrix[3][2] << ISPPRV_WBSEL_N3_2_SHIFT |
1231+ prev_wbal.wb_coefmatrix[3][3] << ISPPRV_WBSEL_N3_3_SHIFT,
1232+ OMAP3_ISP_IOMEM_PREV, ISPPRV_WBSEL);
1233+}
1234+EXPORT_SYMBOL_GPL(isppreview_config_whitebalance2);
1235+
1236+/**
1237+ * isppreview_config_blkadj - Configures the Black Adjustment parameters.
1238+ * @prev_blkadj: Structure containing the black adjustment towards red, green,
1239+ * blue.
1240+ **/
1241+void isppreview_config_blkadj(struct ispprev_blkadj prev_blkadj)
1242+{
1243+ isp_reg_writel(prev_blkadj.blue |
1244+ (prev_blkadj.green << ISPPRV_BLKADJOFF_G_SHIFT) |
1245+ (prev_blkadj.red << ISPPRV_BLKADJOFF_R_SHIFT),
1246+ OMAP3_ISP_IOMEM_PREV, ISPPRV_BLKADJOFF);
1247+}
1248+EXPORT_SYMBOL_GPL(isppreview_config_blkadj);
1249+
1250+/**
1251+ * isppreview_config_rgb_blending - Configures the RGB-RGB Blending matrix.
1252+ * @rgb2rgb: Structure containing the rgb to rgb blending matrix and the rgb
1253+ * offset.
1254+ **/
1255+void isppreview_config_rgb_blending(struct ispprev_rgbtorgb rgb2rgb)
1256+{
1257+ u32 val = 0;
1258+
1259+ val = (rgb2rgb.matrix[0][0] & 0xfff) << ISPPRV_RGB_MAT1_MTX_RR_SHIFT;
1260+ val |= (rgb2rgb.matrix[0][1] & 0xfff) << ISPPRV_RGB_MAT1_MTX_GR_SHIFT;
1261+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT1);
1262+
1263+ val = (rgb2rgb.matrix[0][2] & 0xfff) << ISPPRV_RGB_MAT2_MTX_BR_SHIFT;
1264+ val |= (rgb2rgb.matrix[1][0] & 0xfff) << ISPPRV_RGB_MAT2_MTX_RG_SHIFT;
1265+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT2);
1266+
1267+ val = (rgb2rgb.matrix[1][1] & 0xfff) << ISPPRV_RGB_MAT3_MTX_GG_SHIFT;
1268+ val |= (rgb2rgb.matrix[1][2] & 0xfff) << ISPPRV_RGB_MAT3_MTX_BG_SHIFT;
1269+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT3);
1270+
1271+ val = (rgb2rgb.matrix[2][0] & 0xfff) << ISPPRV_RGB_MAT4_MTX_RB_SHIFT;
1272+ val |= (rgb2rgb.matrix[2][1] & 0xfff) << ISPPRV_RGB_MAT4_MTX_GB_SHIFT;
1273+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT4);
1274+
1275+ val = (rgb2rgb.matrix[2][2] & 0xfff) << ISPPRV_RGB_MAT5_MTX_BB_SHIFT;
1276+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT5);
1277+
1278+ val = (rgb2rgb.offset[0] & 0x3ff) << ISPPRV_RGB_OFF1_MTX_OFFG_SHIFT;
1279+ val |= (rgb2rgb.offset[1] & 0x3ff) << ISPPRV_RGB_OFF1_MTX_OFFR_SHIFT;
1280+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_OFF1);
1281+
1282+ val = (rgb2rgb.offset[2] & 0x3ff) << ISPPRV_RGB_OFF2_MTX_OFFB_SHIFT;
1283+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_OFF2);
1284+}
1285+EXPORT_SYMBOL_GPL(isppreview_config_rgb_blending);
1286+
1287+/**
1288+ * Configures the RGB-YCbYCr conversion matrix
1289+ * @prev_csc: Structure containing the RGB to YCbYCr matrix and the
1290+ * YCbCr offset.
1291+ **/
1292+void isppreview_config_rgb_to_ycbcr(struct ispprev_csc prev_csc)
1293+{
1294+ u32 val = 0;
1295+
1296+ val = (prev_csc.matrix[0][0] & 0x3ff) << ISPPRV_CSC0_RY_SHIFT;
1297+ val |= (prev_csc.matrix[0][1] & 0x3ff) << ISPPRV_CSC0_GY_SHIFT;
1298+ val |= (prev_csc.matrix[0][2] & 0x3ff) << ISPPRV_CSC0_BY_SHIFT;
1299+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC0);
1300+
1301+ val = (prev_csc.matrix[1][0] & 0x3ff) << ISPPRV_CSC1_RCB_SHIFT;
1302+ val |= (prev_csc.matrix[1][1] & 0x3ff) << ISPPRV_CSC1_GCB_SHIFT;
1303+ val |= (prev_csc.matrix[1][2] & 0x3ff) << ISPPRV_CSC1_BCB_SHIFT;
1304+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC1);
1305+
1306+ val = (prev_csc.matrix[2][0] & 0x3ff) << ISPPRV_CSC2_RCR_SHIFT;
1307+ val |= (prev_csc.matrix[2][1] & 0x3ff) << ISPPRV_CSC2_GCR_SHIFT;
1308+ val |= (prev_csc.matrix[2][2] & 0x3ff) << ISPPRV_CSC2_BCR_SHIFT;
1309+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC2);
1310+
1311+ val = (prev_csc.offset[0] & 0xff) << ISPPRV_CSC_OFFSET_CR_SHIFT;
1312+ val |= (prev_csc.offset[1] & 0xff) << ISPPRV_CSC_OFFSET_CB_SHIFT;
1313+ val |= (prev_csc.offset[2] & 0xff) << ISPPRV_CSC_OFFSET_Y_SHIFT;
1314+ isp_reg_writel(val, OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC_OFFSET);
1315+}
1316+EXPORT_SYMBOL_GPL(isppreview_config_rgb_to_ycbcr);
1317+
1318+/**
1319+ * isppreview_query_contrast - Query the contrast.
1320+ * @contrast: Pointer to hold the current programmed contrast value.
1321+ **/
1322+void isppreview_query_contrast(u8 *contrast)
1323+{
1324+ u32 brt_cnt_val = 0;
1325+
1326+ brt_cnt_val = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT);
1327+ *contrast = (brt_cnt_val >> ISPPRV_CNT_BRT_CNT_SHIFT) & 0xff;
1328+ DPRINTK_ISPPREV(" Current brt cnt value in hw is %x\n", brt_cnt_val);
1329+}
1330+EXPORT_SYMBOL_GPL(isppreview_query_contrast);
1331+
1332+/**
1333+ * isppreview_update_contrast - Updates the contrast.
1334+ * @contrast: Pointer to hold the current programmed contrast value.
1335+ *
1336+ * Value should be programmed before enabling the module.
1337+ **/
1338+void isppreview_update_contrast(u8 *contrast)
1339+{
1340+ ispprev_obj.contrast = *contrast;
1341+}
1342+EXPORT_SYMBOL_GPL(isppreview_update_contrast);
1343+
1344+/**
1345+ * isppreview_config_contrast - Configures the Contrast.
1346+ * @contrast: 8 bit value in U8Q4 format.
1347+ *
1348+ * Value should be programmed before enabling the module.
1349+ **/
1350+void isppreview_config_contrast(u8 contrast)
1351+{
1352+ u32 brt_cnt_val = 0;
1353+
1354+ brt_cnt_val = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT);
1355+ brt_cnt_val &= ~(0xff << ISPPRV_CNT_BRT_CNT_SHIFT);
1356+ contrast &= 0xff;
1357+ isp_reg_writel(brt_cnt_val | contrast << ISPPRV_CNT_BRT_CNT_SHIFT,
1358+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT);
1359+}
1360+EXPORT_SYMBOL_GPL(isppreview_config_contrast);
1361+
1362+/**
1363+ * isppreview_get_contrast_range - Gets the range contrast value.
1364+ * @min_contrast: Pointer to hold the minimum Contrast value.
1365+ * @max_contrast: Pointer to hold the maximum Contrast value.
1366+ **/
1367+void isppreview_get_contrast_range(u8 *min_contrast, u8 *max_contrast)
1368+{
1369+ *min_contrast = ISPPRV_CONTRAST_MIN;
1370+ *max_contrast = ISPPRV_CONTRAST_MAX;
1371+}
1372+EXPORT_SYMBOL_GPL(isppreview_get_contrast_range);
1373+
1374+/**
1375+ * isppreview_update_brightness - Updates the brightness in preview module.
1376+ * @brightness: Pointer to hold the current programmed brightness value.
1377+ *
1378+ **/
1379+void isppreview_update_brightness(u8 *brightness)
1380+{
1381+ ispprev_obj.brightness = *brightness;
1382+}
1383+EXPORT_SYMBOL_GPL(isppreview_update_brightness);
1384+
1385+/**
1386+ * isppreview_config_brightness - Configures the brightness.
1387+ * @contrast: 8bitvalue in U8Q0 format.
1388+ **/
1389+void isppreview_config_brightness(u8 brightness)
1390+{
1391+ u32 brt_cnt_val = 0;
1392+
1393+ DPRINTK_ISPPREV("\tConfiguring brightness in ISP: %d\n", brightness);
1394+ brt_cnt_val = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT);
1395+ brt_cnt_val &= ~(0xff << ISPPRV_CNT_BRT_BRT_SHIFT);
1396+ brightness &= 0xff;
1397+ isp_reg_writel(brt_cnt_val | brightness << ISPPRV_CNT_BRT_BRT_SHIFT,
1398+ OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT);
1399+}
1400+EXPORT_SYMBOL_GPL(isppreview_config_brightness);
1401+
1402+/**
1403+ * isppreview_query_brightness - Query the brightness.
1404+ * @brightness: Pointer to hold the current programmed brightness value.
1405+ **/
1406+void isppreview_query_brightness(u8 *brightness)
1407+{
1408+ *brightness = isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT);
1409+}
1410+EXPORT_SYMBOL_GPL(isppreview_query_brightness);
1411+
1412+/**
1413+ * isppreview_get_brightness_range - Gets the range brightness value
1414+ * @min_brightness: Pointer to hold the minimum brightness value
1415+ * @max_brightness: Pointer to hold the maximum brightness value
1416+ **/
1417+void isppreview_get_brightness_range(u8 *min_brightness, u8 *max_brightness)
1418+{
1419+ *min_brightness = ISPPRV_BRIGHT_MIN;
1420+ *max_brightness = ISPPRV_BRIGHT_MAX;
1421+}
1422+EXPORT_SYMBOL_GPL(isppreview_get_brightness_range);
1423+
1424+/**
1425+ * isppreview_set_color - Sets the color effect.
1426+ * @mode: Indicates the required color effect.
1427+ **/
1428+void isppreview_set_color(u8 *mode)
1429+{
1430+ ispprev_obj.color = *mode;
1431+ update_color_matrix = 1;
1432+}
1433+EXPORT_SYMBOL_GPL(isppreview_set_color);
1434+
1435+/**
1436+ * isppreview_get_color - Gets the current color effect.
1437+ * @mode: Indicates the current color effect.
1438+ **/
1439+void isppreview_get_color(u8 *mode)
1440+{
1441+ *mode = ispprev_obj.color;
1442+}
1443+EXPORT_SYMBOL_GPL(isppreview_get_color);
1444+
1445+/**
1446+ * isppreview_config_yc_range - Configures the max and min Y and C values.
1447+ * @yclimit: Structure containing the range of Y and C values.
1448+ **/
1449+void isppreview_config_yc_range(struct ispprev_yclimit yclimit)
1450+{
1451+ isp_reg_writel(yclimit.maxC << ISPPRV_SETUP_YC_MAXC_SHIFT |
1452+ yclimit.maxY << ISPPRV_SETUP_YC_MAXY_SHIFT |
1453+ yclimit.minC << ISPPRV_SETUP_YC_MINC_SHIFT |
1454+ yclimit.minY << ISPPRV_SETUP_YC_MINY_SHIFT,
1455+ OMAP3_ISP_IOMEM_PREV, ISPPRV_SETUP_YC);
1456+}
1457+EXPORT_SYMBOL_GPL(isppreview_config_yc_range);
1458+
1459+/**
1460+ * isppreview_try_size - Calculates output dimensions with the modules enabled.
1461+ * @input_w: input width for the preview in number of pixels per line
1462+ * @input_h: input height for the preview in number of lines
1463+ * @output_w: output width from the preview in number of pixels per line
1464+ * @output_h: output height for the preview in number of lines
1465+ *
1466+ * Calculates the number of pixels cropped in the submodules that are enabled,
1467+ * Fills up the output width height variables in the isp_prev structure.
1468+ **/
1469+int isppreview_try_size(u32 input_w, u32 input_h, u32 *output_w, u32 *output_h)
1470+{
1471+ u32 prevout_w = input_w;
1472+ u32 prevout_h = input_h;
1473+ u32 div = 0;
1474+ int max_out;
1475+
1476+ ispprev_obj.previn_w = input_w;
1477+ ispprev_obj.previn_h = input_h;
1478+
1479+ if (input_w < 32 || input_h < 32) {
1480+ printk(KERN_ERR "ISP_ERR : preview does not support "
1481+ "width < 16 or height < 32 \n");
1482+ return -EINVAL;
1483+ }
1484+ if (omap_rev() == OMAP3430_REV_ES1_0)
1485+ max_out = ISPPRV_MAXOUTPUT_WIDTH;
1486+ else
1487+ max_out = ISPPRV_MAXOUTPUT_WIDTH_ES2;
1488+
1489+ ispprev_obj.fmtavg = 0;
1490+
1491+ if (input_w > max_out) {
1492+ div = (input_w/max_out);
1493+ if (div >= 2 && div < 4) {
1494+ ispprev_obj.fmtavg = 1;
1495+ prevout_w /= 2;
1496+ } else if (div >= 4 && div < 8) {
1497+ ispprev_obj.fmtavg = 2;
1498+ prevout_w /= 4;
1499+ } else if (div >= 8) {
1500+ ispprev_obj.fmtavg = 3;
1501+ prevout_w /= 8;
1502+ }
1503+ }
1504+
1505+ if (ispprev_obj.hmed_en)
1506+ prevout_w -= 4;
1507+ if (ispprev_obj.nf_en) {
1508+ prevout_w -= 4;
1509+ prevout_h -= 4;
1510+ }
1511+ if (ispprev_obj.cfa_en) {
1512+ switch (ispprev_obj.cfafmt) {
1513+ case CFAFMT_BAYER:
1514+ case CFAFMT_SONYVGA:
1515+ prevout_w -= 4;
1516+ prevout_h -= 4;
1517+ break;
1518+ case CFAFMT_RGBFOVEON:
1519+ case CFAFMT_RRGGBBFOVEON:
1520+ case CFAFMT_DNSPL:
1521+ case CFAFMT_HONEYCOMB:
1522+ prevout_h -= 2;
1523+ break;
1524+ };
1525+ }
1526+ if (ispprev_obj.yenh_en || ispprev_obj.csup_en)
1527+ prevout_w -= 2;
1528+
1529+ /* Start at the correct row/column by skipping
1530+ * a Sensor specific amount.
1531+ */
1532+ prevout_w -= ispprev_obj.sph;
1533+ prevout_h -= ispprev_obj.slv;
1534+
1535+
1536+ if (prevout_w % 2)
1537+ prevout_w -= 1;
1538+
1539+ if (ispprev_obj.prev_outfmt == PREVIEW_MEM) {
1540+ if (((prevout_w * 2) & ISP_32B_BOUNDARY_OFFSET) !=
1541+ (prevout_w * 2)) {
1542+ prevout_w = ((prevout_w * 2) &
1543+ ISP_32B_BOUNDARY_OFFSET) / 2;
1544+ }
1545+ }
1546+ *output_w = prevout_w;
1547+ ispprev_obj.prevout_w = prevout_w;
1548+ *output_h = prevout_h;
1549+ ispprev_obj.prevout_h = prevout_h;
1550+ return 0;
1551+}
1552+EXPORT_SYMBOL_GPL(isppreview_try_size);
1553+
1554+/**
1555+ * isppreview_config_size - Sets the size of ISP preview output.
1556+ * @input_w: input width for the preview in number of pixels per line
1557+ * @input_h: input height for the preview in number of lines
1558+ * @output_w: output width from the preview in number of pixels per line
1559+ * @output_h: output height for the preview in number of lines
1560+ *
1561+ * Configures the appropriate values stored in the isp_prev structure to
1562+ * HORZ/VERT_INFO. Configures PRV_AVE if needed for downsampling as calculated
1563+ * in trysize.
1564+ **/
1565+int isppreview_config_size(u32 input_w, u32 input_h, u32 output_w, u32 output_h)
1566+{
1567+ u32 prevsdroff;
1568+
1569+ if ((output_w != ispprev_obj.prevout_w) ||
1570+ (output_h != ispprev_obj.prevout_h)) {
1571+ printk(KERN_ERR "ISP_ERR : isppreview_try_size should "
1572+ "be called before config size\n");
1573+ return -EINVAL;
1574+ }
1575+
1576+ isp_reg_writel((ispprev_obj.sph << ISPPRV_HORZ_INFO_SPH_SHIFT) |
1577+ (ispprev_obj.previn_w - 1),
1578+ OMAP3_ISP_IOMEM_PREV, ISPPRV_HORZ_INFO);
1579+ isp_reg_writel((ispprev_obj.slv << ISPPRV_VERT_INFO_SLV_SHIFT) |
1580+ (ispprev_obj.previn_h - 2),
1581+ OMAP3_ISP_IOMEM_PREV, ISPPRV_VERT_INFO);
1582+
1583+ if (ispprev_obj.cfafmt == CFAFMT_BAYER)
1584+ isp_reg_writel(ISPPRV_AVE_EVENDIST_2 <<
1585+ ISPPRV_AVE_EVENDIST_SHIFT |
1586+ ISPPRV_AVE_ODDDIST_2 <<
1587+ ISPPRV_AVE_ODDDIST_SHIFT |
1588+ ispprev_obj.fmtavg,
1589+ OMAP3_ISP_IOMEM_PREV, ISPPRV_AVE);
1590+
1591+ if (ispprev_obj.prev_outfmt == PREVIEW_MEM) {
1592+ prevsdroff = ispprev_obj.prevout_w * 2;
1593+ if ((prevsdroff & ISP_32B_BOUNDARY_OFFSET) != prevsdroff) {
1594+ DPRINTK_ISPPREV("ISP_WARN: Preview output buffer line"
1595+ " size is truncated"
1596+ " to 32byte boundary\n");
1597+ prevsdroff &= ISP_32B_BOUNDARY_BUF ;
1598+ }
1599+ isppreview_config_outlineoffset(prevsdroff);
1600+ }
1601+ return 0;
1602+}
1603+EXPORT_SYMBOL_GPL(isppreview_config_size);
1604+
1605+/**
1606+ * isppreview_config_inlineoffset - Configures the Read address line offset.
1607+ * @offset: Line Offset for the input image.
1608+ **/
1609+int isppreview_config_inlineoffset(u32 offset)
1610+{
1611+ if ((offset & ISP_32B_BOUNDARY_OFFSET) == offset) {
1612+ isp_reg_writel(offset & 0xffff,
1613+ OMAP3_ISP_IOMEM_PREV, ISPPRV_RADR_OFFSET);
1614+ } else {
1615+ printk(KERN_ERR "ISP_ERR : Offset should be in 32 byte "
1616+ "boundary\n");
1617+ return -EINVAL;
1618+ }
1619+ return 0;
1620+}
1621+EXPORT_SYMBOL_GPL(isppreview_config_inlineoffset);
1622+
1623+/**
1624+ * isppreview_set_inaddr - Sets memory address of input frame.
1625+ * @addr: 32bit memory address aligned on 32byte boundary.
1626+ *
1627+ * Configures the memory address from which the input frame is to be read.
1628+ **/
1629+int isppreview_set_inaddr(u32 addr)
1630+{
1631+ if ((addr & ISP_32B_BOUNDARY_BUF) == addr)
1632+ isp_reg_writel(addr, OMAP3_ISP_IOMEM_PREV, ISPPRV_RSDR_ADDR);
1633+ else {
1634+ printk(KERN_ERR "ISP_ERR: Address should be in 32 byte "
1635+ "boundary\n");
1636+ return -EINVAL;
1637+ }
1638+ return 0;
1639+}
1640+EXPORT_SYMBOL_GPL(isppreview_set_inaddr);
1641+
1642+/**
1643+ * isppreview_config_outlineoffset - Configures the Write address line offset.
1644+ * @offset: Line Offset for the preview output.
1645+ **/
1646+int isppreview_config_outlineoffset(u32 offset)
1647+{
1648+ if ((offset & ISP_32B_BOUNDARY_OFFSET) != offset) {
1649+ printk(KERN_ERR "ISP_ERR : Offset should be in 32 byte "
1650+ "boundary\n");
1651+ return -EINVAL;
1652+ }
1653+ isp_reg_writel(offset & 0xffff, OMAP3_ISP_IOMEM_PREV,
1654+ ISPPRV_WADD_OFFSET);
1655+ return 0;
1656+}
1657+EXPORT_SYMBOL_GPL(isppreview_config_outlineoffset);
1658+
1659+/**
1660+ * isppreview_set_outaddr - Sets the memory address to store output frame
1661+ * @addr: 32bit memory address aligned on 32byte boundary.
1662+ *
1663+ * Configures the memory address to which the output frame is written.
1664+ **/
1665+int isppreview_set_outaddr(u32 addr)
1666+{
1667+ if ((addr & ISP_32B_BOUNDARY_BUF) != addr) {
1668+ printk(KERN_ERR "ISP_ERR: Address should be in 32 byte "
1669+ "boundary\n");
1670+ return -EINVAL;
1671+ }
1672+ isp_reg_writel(addr, OMAP3_ISP_IOMEM_PREV, ISPPRV_WSDR_ADDR);
1673+ return 0;
1674+}
1675+EXPORT_SYMBOL_GPL(isppreview_set_outaddr);
1676+
1677+/**
1678+ * isppreview_config_darklineoffset - Sets the Dark frame address line offset.
1679+ * @offset: Line Offset for the Darkframe.
1680+ **/
1681+int isppreview_config_darklineoffset(u32 offset)
1682+{
1683+ if ((offset & ISP_32B_BOUNDARY_OFFSET) != offset) {
1684+ printk(KERN_ERR "ISP_ERR : Offset should be in 32 byte "
1685+ "boundary\n");
1686+ return -EINVAL;
1687+ }
1688+ isp_reg_writel(offset & 0xffff, OMAP3_ISP_IOMEM_PREV,
1689+ ISPPRV_DRKF_OFFSET);
1690+ return 0;
1691+}
1692+EXPORT_SYMBOL_GPL(isppreview_config_darklineoffset);
1693+
1694+/**
1695+ * isppreview_set_darkaddr - Sets the memory address to store Dark frame.
1696+ * @addr: 32bit memory address aligned on 32 bit boundary.
1697+ **/
1698+int isppreview_set_darkaddr(u32 addr)
1699+{
1700+ if ((addr & ISP_32B_BOUNDARY_BUF) != addr) {
1701+ printk(KERN_ERR "ISP_ERR : Address should be in 32 byte "
1702+ "boundary\n");
1703+ return -EINVAL;
1704+ }
1705+ isp_reg_writel(addr, OMAP3_ISP_IOMEM_PREV, ISPPRV_DSDR_ADDR);
1706+ return 0;
1707+}
1708+EXPORT_SYMBOL_GPL(isppreview_set_darkaddr);
1709+
1710+void __isppreview_enable(int enable)
1711+{
1712+ if (enable)
1713+ isp_reg_or(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ISPPRV_PCR_EN);
1714+ else
1715+ isp_reg_and(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR, ~ISPPRV_PCR_EN);
1716+}
1717+
1718+/**
1719+ * isppreview_enable - Enables the Preview module.
1720+ * @enable: 1 - Enables the preview module.
1721+ *
1722+ * Client should configure all the sub modules in Preview before this.
1723+ **/
1724+void isppreview_enable(int enable)
1725+{
1726+ __isppreview_enable(enable);
1727+ ispprev_obj.pm_state = enable;
1728+}
1729+EXPORT_SYMBOL_GPL(isppreview_enable);
1730+
1731+/**
1732+ * isppreview_suspend - Suspend Preview module.
1733+ **/
1734+void isppreview_suspend(void)
1735+{
1736+ if (ispprev_obj.pm_state)
1737+ __isppreview_enable(0);
1738+}
1739+EXPORT_SYMBOL_GPL(isppreview_suspend);
1740+
1741+/**
1742+ * isppreview_resume - Resume Preview module.
1743+ **/
1744+void isppreview_resume(void)
1745+{
1746+ if (ispprev_obj.pm_state)
1747+ __isppreview_enable(1);
1748+}
1749+EXPORT_SYMBOL_GPL(isppreview_resume);
1750+
1751+
1752+/**
1753+ * isppreview_busy - Gets busy state of preview module.
1754+ **/
1755+int isppreview_busy(void)
1756+{
1757+ return isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR) &
1758+ ISPPRV_PCR_BUSY;
1759+}
1760+EXPORT_SYMBOL_GPL(isppreview_busy);
1761+
1762+/**
1763+ * isppreview_get_config - Gets parameters of preview module.
1764+ **/
1765+struct prev_params *isppreview_get_config(void)
1766+{
1767+ return prev_config_params;
1768+}
1769+EXPORT_SYMBOL_GPL(isppreview_get_config);
1770+
1771+/**
1772+ * isppreview_save_context - Saves the values of the preview module registers.
1773+ **/
1774+void isppreview_save_context(void)
1775+{
1776+ DPRINTK_ISPPREV("Saving context\n");
1777+ isp_save_context(ispprev_reg_list);
1778+}
1779+EXPORT_SYMBOL_GPL(isppreview_save_context);
1780+
1781+/**
1782+ * isppreview_restore_context - Restores the values of preview module registers
1783+ **/
1784+void isppreview_restore_context(void)
1785+{
1786+ DPRINTK_ISPPREV("Restoring context\n");
1787+ isp_restore_context(ispprev_reg_list);
1788+}
1789+EXPORT_SYMBOL_GPL(isppreview_restore_context);
1790+
1791+/**
1792+ * isppreview_print_status - Prints the values of the Preview Module registers.
1793+ *
1794+ * Also prints other debug information stored in the preview moduel.
1795+ **/
1796+void isppreview_print_status(void)
1797+{
1798+ DPRINTK_ISPPREV("Module in use =%d\n", ispprev_obj.prev_inuse);
1799+ DPRINTK_ISPPREV("Preview Input format =%d, Output Format =%d\n",
1800+ ispprev_obj.prev_inpfmt,
1801+ ispprev_obj.prev_outfmt);
1802+ DPRINTK_ISPPREV("Accepted Preview Input (width = %d,Height = %d)\n",
1803+ ispprev_obj.previn_w,
1804+ ispprev_obj.previn_h);
1805+ DPRINTK_ISPPREV("Accepted Preview Output (width = %d,Height = %d)\n",
1806+ ispprev_obj.prevout_w,
1807+ ispprev_obj.prevout_h);
1808+ DPRINTK_ISPPREV("###ISP_CTRL in preview =0x%x\n",
1809+ isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_CTRL));
1810+ DPRINTK_ISPPREV("###ISP_IRQ0ENABLE in preview =0x%x\n",
1811+ isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE));
1812+ DPRINTK_ISPPREV("###ISP_IRQ0STATUS in preview =0x%x\n",
1813+ isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS));
1814+ DPRINTK_ISPPREV("###PRV PCR =0x%x\n",
1815+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_PCR));
1816+ DPRINTK_ISPPREV("###PRV HORZ_INFO =0x%x\n",
1817+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_HORZ_INFO));
1818+ DPRINTK_ISPPREV("###PRV VERT_INFO =0x%x\n",
1819+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_VERT_INFO));
1820+ DPRINTK_ISPPREV("###PRV WSDR_ADDR =0x%x\n",
1821+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_WSDR_ADDR));
1822+ DPRINTK_ISPPREV("###PRV WADD_OFFSET =0x%x\n",
1823+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV,
1824+ ISPPRV_WADD_OFFSET));
1825+ DPRINTK_ISPPREV("###PRV AVE =0x%x\n",
1826+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_AVE));
1827+ DPRINTK_ISPPREV("###PRV HMED =0x%x\n",
1828+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_HMED));
1829+ DPRINTK_ISPPREV("###PRV NF =0x%x\n",
1830+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_NF));
1831+ DPRINTK_ISPPREV("###PRV WB_DGAIN =0x%x\n",
1832+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_WB_DGAIN));
1833+ DPRINTK_ISPPREV("###PRV WBGAIN =0x%x\n",
1834+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_WBGAIN));
1835+ DPRINTK_ISPPREV("###PRV WBSEL =0x%x\n",
1836+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_WBSEL));
1837+ DPRINTK_ISPPREV("###PRV CFA =0x%x\n",
1838+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CFA));
1839+ DPRINTK_ISPPREV("###PRV BLKADJOFF =0x%x\n",
1840+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_BLKADJOFF));
1841+ DPRINTK_ISPPREV("###PRV RGB_MAT1 =0x%x\n",
1842+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT1));
1843+ DPRINTK_ISPPREV("###PRV RGB_MAT2 =0x%x\n",
1844+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT2));
1845+ DPRINTK_ISPPREV("###PRV RGB_MAT3 =0x%x\n",
1846+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT3));
1847+ DPRINTK_ISPPREV("###PRV RGB_MAT4 =0x%x\n",
1848+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT4));
1849+ DPRINTK_ISPPREV("###PRV RGB_MAT5 =0x%x\n",
1850+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_MAT5));
1851+ DPRINTK_ISPPREV("###PRV RGB_OFF1 =0x%x\n",
1852+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_OFF1));
1853+ DPRINTK_ISPPREV("###PRV RGB_OFF2 =0x%x\n",
1854+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_RGB_OFF2));
1855+ DPRINTK_ISPPREV("###PRV CSC0 =0x%x\n",
1856+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC0));
1857+ DPRINTK_ISPPREV("###PRV CSC1 =0x%x\n",
1858+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC1));
1859+ DPRINTK_ISPPREV("###PRV CSC2 =0x%x\n",
1860+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC2));
1861+ DPRINTK_ISPPREV("###PRV CSC_OFFSET =0x%x\n",
1862+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CSC_OFFSET));
1863+ DPRINTK_ISPPREV("###PRV CNT_BRT =0x%x\n",
1864+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CNT_BRT));
1865+ DPRINTK_ISPPREV("###PRV CSUP =0x%x\n",
1866+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_CSUP));
1867+ DPRINTK_ISPPREV("###PRV SETUP_YC =0x%x\n",
1868+ isp_reg_readl(OMAP3_ISP_IOMEM_PREV, ISPPRV_SETUP_YC));
1869+}
1870+EXPORT_SYMBOL_GPL(isppreview_print_status);
1871+
1872+/**
1873+ * isp_preview_init - Module Initialization.
1874+ **/
1875+int __init isp_preview_init(void)
1876+{
1877+ int i = 0;
1878+
1879+ prev_config_params = kmalloc(sizeof(*prev_config_params), GFP_KERNEL);
1880+ if (!prev_config_params) {
1881+ printk(KERN_ERR "Can't get memory for isp_preview params!\n");
1882+ return -ENOMEM;
1883+ }
1884+ params = prev_config_params;
1885+
1886+ ispprev_obj.prev_inuse = 0;
1887+ mutex_init(&ispprev_obj.ispprev_mutex);
1888+
1889+ /* Init values */
1890+ ispprev_obj.sph = 2;
1891+ ispprev_obj.slv = 0;
1892+ ispprev_obj.color = V4L2_COLORFX_NONE;
1893+ ispprev_obj.contrast = ISPPRV_CONTRAST_DEF;
1894+ params->contrast = ISPPRV_CONTRAST_DEF;
1895+ ispprev_obj.brightness = ISPPRV_BRIGHT_DEF;
1896+ params->brightness = ISPPRV_BRIGHT_DEF;
1897+ params->average = NO_AVE;
1898+ params->lens_shading_shift = 0;
1899+ params->pix_fmt = YCPOS_YCrYCb;
1900+ params->cfa.cfafmt = CFAFMT_BAYER;
1901+ params->cfa.cfa_table = cfa_coef_table;
1902+ params->cfa.cfa_gradthrs_horz = FLR_CFA_GRADTHRS_HORZ;
1903+ params->cfa.cfa_gradthrs_vert = FLR_CFA_GRADTHRS_VERT;
1904+ params->csup.gain = FLR_CSUP_GAIN;
1905+ params->csup.thres = FLR_CSUP_THRES;
1906+ params->csup.hypf_en = 0;
1907+ params->ytable = luma_enhance_table;
1908+ params->nf.spread = FLR_NF_STRGTH;
1909+ memcpy(params->nf.table, noise_filter_table, sizeof(params->nf.table));
1910+ params->dcor.couplet_mode_en = 1;
1911+ for (i = 0; i < 4; i++)
1912+ params->dcor.detect_correct[i] = 0xE;
1913+ params->gtable.bluetable = bluegamma_table;
1914+ params->gtable.greentable = greengamma_table;
1915+ params->gtable.redtable = redgamma_table;
1916+ params->wbal.dgain = FLR_WBAL_DGAIN;
1917+ if (omap_rev() > OMAP3430_REV_ES1_0) {
1918+ params->wbal.coef0 = FLR_WBAL_COEF0_ES1;
1919+ params->wbal.coef1 = FLR_WBAL_COEF1_ES1;
1920+ params->wbal.coef2 = FLR_WBAL_COEF2_ES1;
1921+ params->wbal.coef3 = FLR_WBAL_COEF3_ES1;
1922+ } else {
1923+ params->wbal.coef0 = FLR_WBAL_COEF0;
1924+ params->wbal.coef1 = FLR_WBAL_COEF1;
1925+ params->wbal.coef2 = FLR_WBAL_COEF2;
1926+ params->wbal.coef3 = FLR_WBAL_COEF3;
1927+ }
1928+ params->blk_adj.red = FLR_BLKADJ_RED;
1929+ params->blk_adj.green = FLR_BLKADJ_GREEN;
1930+ params->blk_adj.blue = FLR_BLKADJ_BLUE;
1931+ params->rgb2rgb = flr_rgb2rgb;
1932+ params->rgb2ycbcr = flr_prev_csc[ispprev_obj.color];
1933+
1934+ params->features = PREV_CFA | PREV_DEFECT_COR | PREV_NOISE_FILTER;
1935+ params->features &= ~(PREV_AVERAGER | PREV_INVERSE_ALAW |
1936+ PREV_HORZ_MEDIAN_FILTER |
1937+ PREV_GAMMA_BYPASS |
1938+ PREV_DARK_FRAME_SUBTRACT |
1939+ PREV_LENS_SHADING |
1940+ PREV_DARK_FRAME_CAPTURE |
1941+ PREV_CHROMA_SUPPRESS |
1942+ PREV_LUMA_ENHANCE);
1943+ return 0;
1944+}
1945+
1946+/**
1947+ * isp_preview_cleanup - Module Cleanup.
1948+ **/
1949+void isp_preview_cleanup(void)
1950+{
1951+ kfree(prev_config_params);
1952+}
1953diff --git a/drivers/media/video/isp/isppreview.h b/drivers/media/video/isp/isppreview.h
1954new file mode 100644
1955index 0000000..e88c329
1956--- /dev/null
1957+++ b/drivers/media/video/isp/isppreview.h
1958@@ -0,0 +1,354 @@
1959+/*
1960+ * isppreview.h
1961+ *
1962+ * Driver header file for Preview module in TI's OMAP3 Camera ISP
1963+ *
1964+ * Copyright (C) 2009 Texas Instruments, Inc.
1965+ *
1966+ * Contributors:
1967+ * Senthilvadivu Guruswamy <svadivu@ti.com>
1968+ * Pallavi Kulkarni <p-kulkarni@ti.com>
1969+ * Sergio Aguirre <saaguirre@ti.com>
1970+ *
1971+ * This package is free software; you can redistribute it and/or modify
1972+ * it under the terms of the GNU General Public License version 2 as
1973+ * published by the Free Software Foundation.
1974+ *
1975+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
1976+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
1977+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
1978+ */
1979+
1980+#ifndef OMAP_ISP_PREVIEW_H
1981+#define OMAP_ISP_PREVIEW_H
1982+
1983+#include <mach/isp_user.h>
1984+/* Isp query control structure */
1985+
1986+#define ISPPRV_BRIGHT_STEP 0x1
1987+#define ISPPRV_BRIGHT_DEF 0x0
1988+#define ISPPRV_BRIGHT_LOW 0x0
1989+#define ISPPRV_BRIGHT_HIGH 0xF
1990+#define ISPPRV_BRIGHT_UNITS 0x7
1991+
1992+#define ISPPRV_CONTRAST_STEP 0x1
1993+#define ISPPRV_CONTRAST_DEF 0x4
1994+#define ISPPRV_CONTRAST_LOW 0x0
1995+#define ISPPRV_CONTRAST_HIGH 0xF
1996+#define ISPPRV_CONTRAST_UNITS 0x4
1997+
1998+#define NO_AVE 0x0
1999+#define AVE_2_PIX 0x1
2000+#define AVE_4_PIX 0x2
2001+#define AVE_8_PIX 0x3
2002+#define AVE_ODD_PIXEL_DIST (1 << 4) /* For Bayer Sensors */
2003+#define AVE_EVEN_PIXEL_DIST (1 << 2)
2004+
2005+#define WB_GAIN_MAX 4
2006+
2007+/* Features list */
2008+#define PREV_AVERAGER (1 << 0)
2009+#define PREV_INVERSE_ALAW (1 << 1)
2010+#define PREV_HORZ_MEDIAN_FILTER (1 << 2)
2011+#define PREV_NOISE_FILTER (1 << 3)
2012+#define PREV_CFA (1 << 4)
2013+#define PREV_GAMMA_BYPASS (1 << 5)
2014+#define PREV_LUMA_ENHANCE (1 << 6)
2015+#define PREV_CHROMA_SUPPRESS (1 << 7)
2016+#define PREV_DARK_FRAME_SUBTRACT (1 << 8)
2017+#define PREV_LENS_SHADING (1 << 9)
2018+#define PREV_DARK_FRAME_CAPTURE (1 << 10)
2019+#define PREV_DEFECT_COR (1 << 11)
2020+
2021+
2022+#define ISP_NF_TABLE_SIZE (1 << 10)
2023+
2024+#define ISP_GAMMA_TABLE_SIZE (1 << 10)
2025+
2026+/* Table addresses */
2027+#define ISPPRV_TBL_ADDR_RED_G_START 0x00
2028+#define ISPPRV_TBL_ADDR_BLUE_G_START 0x800
2029+#define ISPPRV_TBL_ADDR_GREEN_G_START 0x400
2030+
2031+/*
2032+ *Enumeration Constants for input and output format
2033+ */
2034+enum preview_input {
2035+ PRV_RAW_CCDC,
2036+ PRV_RAW_MEM,
2037+ PRV_RGBBAYERCFA,
2038+ PRV_COMPCFA,
2039+ PRV_CCDC_DRKF,
2040+ PRV_OTHERS
2041+};
2042+enum preview_output {
2043+ PREVIEW_RSZ,
2044+ PREVIEW_MEM
2045+};
2046+/*
2047+ * Configure byte layout of YUV image
2048+ */
2049+enum preview_ycpos_mode {
2050+ YCPOS_YCrYCb = 0,
2051+ YCPOS_YCbYCr = 1,
2052+ YCPOS_CbYCrY = 2,
2053+ YCPOS_CrYCbY = 3
2054+};
2055+
2056+/**
2057+ * struct ispprev_gtable - Structure for Gamma Correction.
2058+ * @redtable: Pointer to the red gamma table.
2059+ * @greentable: Pointer to the green gamma table.
2060+ * @bluetable: Pointer to the blue gamma table.
2061+ */
2062+struct ispprev_gtable {
2063+ u32 *redtable;
2064+ u32 *greentable;
2065+ u32 *bluetable;
2066+};
2067+
2068+/**
2069+ * struct prev_white_balance - Structure for White Balance 2.
2070+ * @wb_dgain: White balance common gain.
2071+ * @wb_gain: Individual color gains.
2072+ * @wb_coefmatrix: Coefficient matrix
2073+ */
2074+struct prev_white_balance {
2075+ u16 wb_dgain; /* white balance common gain */
2076+ u8 wb_gain[WB_GAIN_MAX]; /* individual color gains */
2077+ u8 wb_coefmatrix[WB_GAIN_MAX][WB_GAIN_MAX];
2078+};
2079+
2080+/**
2081+ * struct prev_size_params - Structure for size parameters.
2082+ * @hstart: Starting pixel.
2083+ * @vstart: Starting line.
2084+ * @hsize: Width of input image.
2085+ * @vsize: Height of input image.
2086+ * @pixsize: Pixel size of the image in terms of bits.
2087+ * @in_pitch: Line offset of input image.
2088+ * @out_pitch: Line offset of output image.
2089+ */
2090+struct prev_size_params {
2091+ unsigned int hstart;
2092+ unsigned int vstart;
2093+ unsigned int hsize;
2094+ unsigned int vsize;
2095+ unsigned char pixsize;
2096+ unsigned short in_pitch;
2097+ unsigned short out_pitch;
2098+};
2099+
2100+/**
2101+ * struct prev_rgb2ycbcr_coeffs - Structure RGB2YCbCr parameters.
2102+ * @coeff: Color conversion gains in 3x3 matrix.
2103+ * @offset: Color conversion offsets.
2104+ */
2105+struct prev_rgb2ycbcr_coeffs {
2106+ short coeff[RGB_MAX][RGB_MAX];
2107+ short offset[RGB_MAX];
2108+};
2109+
2110+/**
2111+ * struct prev_darkfrm_params - Structure for Dark frame suppression.
2112+ * @addr: Memory start address.
2113+ * @offset: Line offset.
2114+ */
2115+struct prev_darkfrm_params {
2116+ u32 addr;
2117+ u32 offset;
2118+ };
2119+
2120+/**
2121+ * struct prev_params - Structure for all configuration
2122+ * @features: Set of features enabled.
2123+ * @pix_fmt: Output pixel format.
2124+ * @cfa: CFA coefficients.
2125+ * @csup: Chroma suppression coefficients.
2126+ * @ytable: Pointer to Luma enhancement coefficients.
2127+ * @nf: Noise filter coefficients.
2128+ * @dcor: Noise filter coefficients.
2129+ * @gtable: Gamma coefficients.
2130+ * @wbal: White Balance parameters.
2131+ * @blk_adj: Black adjustment parameters.
2132+ * @rgb2rgb: RGB blending parameters.
2133+ * @rgb2ycbcr: RGB to ycbcr parameters.
2134+ * @hmf_params: Horizontal median filter.
2135+ * @size_params: Size parameters.
2136+ * @drkf_params: Darkframe parameters.
2137+ * @lens_shading_shift:
2138+ * @average: Downsampling rate for averager.
2139+ * @contrast: Contrast.
2140+ * @brightness: Brightness.
2141+ */
2142+struct prev_params {
2143+ u16 features;
2144+ enum preview_ycpos_mode pix_fmt;
2145+ struct ispprev_cfa cfa;
2146+ struct ispprev_csup csup;
2147+ u32 *ytable;
2148+ struct ispprev_nf nf;
2149+ struct ispprev_dcor dcor;
2150+ struct ispprev_gtable gtable;
2151+ struct ispprev_wbal wbal;
2152+ struct ispprev_blkadj blk_adj;
2153+ struct ispprev_rgbtorgb rgb2rgb;
2154+ struct ispprev_csc rgb2ycbcr;
2155+ struct ispprev_hmed hmf_params;
2156+ struct prev_size_params size_params;
2157+ struct prev_darkfrm_params drkf_params;
2158+ u8 lens_shading_shift;
2159+ u8 average;
2160+ u8 contrast;
2161+ u8 brightness;
2162+};
2163+
2164+/**
2165+ * struct isptables_update - Structure for Table Configuration.
2166+ * @update: Specifies which tables should be updated.
2167+ * @flag: Specifies which tables should be enabled.
2168+ * @prev_nf: Pointer to structure for Noise Filter
2169+ * @lsc: Pointer to LSC gain table. (currently not used)
2170+ * @red_gamma: Pointer to red gamma correction table.
2171+ * @green_gamma: Pointer to green gamma correction table.
2172+ * @blue_gamma: Pointer to blue gamma correction table.
2173+ */
2174+struct isptables_update {
2175+ u16 update;
2176+ u16 flag;
2177+ struct ispprev_nf *prev_nf;
2178+ u32 *lsc;
2179+ u32 *red_gamma;
2180+ u32 *green_gamma;
2181+ u32 *blue_gamma;
2182+};
2183+
2184+void isppreview_config_shadow_registers(void);
2185+
2186+int isppreview_request(void);
2187+
2188+int isppreview_free(void);
2189+
2190+int isppreview_config_datapath(enum preview_input input,
2191+ enum preview_output output);
2192+
2193+void isppreview_config_ycpos(enum preview_ycpos_mode mode);
2194+
2195+void isppreview_config_averager(u8 average);
2196+
2197+void isppreview_enable_invalaw(u8 enable);
2198+
2199+void isppreview_enable_drkframe(u8 enable);
2200+
2201+void isppreview_enable_shadcomp(u8 enable);
2202+
2203+void isppreview_config_drkf_shadcomp(u8 scomp_shtval);
2204+
2205+void isppreview_enable_gammabypass(u8 enable);
2206+
2207+void isppreview_enable_hmed(u8 enable);
2208+
2209+void isppreview_config_hmed(struct ispprev_hmed);
2210+
2211+void isppreview_enable_noisefilter(u8 enable);
2212+
2213+void isppreview_config_noisefilter(struct ispprev_nf prev_nf);
2214+
2215+void isppreview_enable_dcor(u8 enable);
2216+
2217+void isppreview_config_dcor(struct ispprev_dcor prev_dcor);
2218+
2219+
2220+void isppreview_config_cfa(struct ispprev_cfa);
2221+
2222+void isppreview_config_gammacorrn(struct ispprev_gtable);
2223+
2224+void isppreview_config_chroma_suppression(struct ispprev_csup csup);
2225+
2226+void isppreview_enable_cfa(u8 enable);
2227+
2228+void isppreview_config_luma_enhancement(u32 *ytable);
2229+
2230+void isppreview_enable_luma_enhancement(u8 enable);
2231+
2232+void isppreview_enable_chroma_suppression(u8 enable);
2233+
2234+void isppreview_config_whitebalance(struct ispprev_wbal);
2235+
2236+void isppreview_config_blkadj(struct ispprev_blkadj);
2237+
2238+void isppreview_config_rgb_blending(struct ispprev_rgbtorgb);
2239+
2240+void isppreview_config_rgb_to_ycbcr(struct ispprev_csc);
2241+
2242+void isppreview_update_contrast(u8 *contrast);
2243+
2244+void isppreview_query_contrast(u8 *contrast);
2245+
2246+void isppreview_config_contrast(u8 contrast);
2247+
2248+void isppreview_get_contrast_range(u8 *min_contrast, u8 *max_contrast);
2249+
2250+void isppreview_update_brightness(u8 *brightness);
2251+
2252+void isppreview_config_brightness(u8 brightness);
2253+
2254+void isppreview_get_brightness_range(u8 *min_brightness, u8 *max_brightness);
2255+
2256+void isppreview_set_color(u8 *mode);
2257+
2258+void isppreview_get_color(u8 *mode);
2259+
2260+void isppreview_query_brightness(u8 *brightness);
2261+
2262+void isppreview_config_yc_range(struct ispprev_yclimit yclimit);
2263+
2264+int isppreview_try_size(u32 input_w, u32 input_h, u32 *output_w,
2265+ u32 *output_h);
2266+
2267+int isppreview_config_size(u32 input_w, u32 input_h, u32 output_w,
2268+ u32 output_h);
2269+
2270+int isppreview_config_inlineoffset(u32 offset);
2271+
2272+int isppreview_set_inaddr(u32 addr);
2273+
2274+int isppreview_config_outlineoffset(u32 offset);
2275+
2276+int isppreview_set_outaddr(u32 addr);
2277+
2278+int isppreview_config_darklineoffset(u32 offset);
2279+
2280+int isppreview_set_darkaddr(u32 addr);
2281+
2282+void isppreview_enable(int enable);
2283+
2284+void isppreview_suspend(void);
2285+
2286+void isppreview_resume(void);
2287+
2288+int isppreview_busy(void);
2289+
2290+struct prev_params *isppreview_get_config(void);
2291+
2292+void isppreview_print_status(void);
2293+
2294+#ifndef CONFIG_ARCH_OMAP3410
2295+void isppreview_save_context(void);
2296+#else
2297+static inline void isppreview_save_context(void) {}
2298+#endif
2299+
2300+#ifndef CONFIG_ARCH_OMAP3410
2301+void isppreview_restore_context(void);
2302+#else
2303+static inline void isppreview_restore_context(void) {}
2304+#endif
2305+
2306+int omap34xx_isp_preview_config(void *userspace_add);
2307+
2308+int omap34xx_isp_tables_update(struct isptables_update *isptables_struct);
2309+
2310+void isppreview_set_skip(u32 h, u32 v);
2311+
2312+#endif/* OMAP_ISP_PREVIEW_H */
2313diff --git a/drivers/media/video/isp/ispresizer.c b/drivers/media/video/isp/ispresizer.c
2314new file mode 100644
2315index 0000000..f78ddb3
2316--- /dev/null
2317+++ b/drivers/media/video/isp/ispresizer.c
2318@@ -0,0 +1,928 @@
2319+/*
2320+ * ispresizer.c
2321+ *
2322+ * Driver Library for Resizer module in TI's OMAP3 Camera ISP
2323+ *
2324+ * Copyright (C)2009 Texas Instruments, Inc.
2325+ *
2326+ * Contributors:
2327+ * Sameer Venkatraman <sameerv@ti.com>
2328+ * Mohit Jalori
2329+ * Sergio Aguirre <saaguirre@ti.com>
2330+ *
2331+ * This package is free software; you can redistribute it and/or modify
2332+ * it under the terms of the GNU General Public License version 2 as
2333+ * published by the Free Software Foundation.
2334+ *
2335+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
2336+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
2337+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
2338+ */
2339+
2340+#include <linux/module.h>
2341+
2342+#include "isp.h"
2343+#include "ispreg.h"
2344+#include "ispresizer.h"
2345+
2346+/* Default configuration of resizer,filter coefficients,yenh for camera isp */
2347+static struct isprsz_yenh ispreszdefaultyenh = {0, 0, 0, 0};
2348+static struct isprsz_coef ispreszdefcoef = {
2349+ {
2350+ 0x0027, 0x00B2, 0x00B2, 0x0027,
2351+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2352+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2353+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2354+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2355+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2356+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2357+ 0x0027, 0x00B2, 0x0027, 0x00B2,
2358+ },
2359+ {
2360+ 0x0000, 0x0100, 0x0000, 0x0000,
2361+ 0x03FA, 0x00F6, 0x0010, 0x0000,
2362+ 0x03F9, 0x00DB, 0x002C, 0x0000,
2363+ 0x03FB, 0x00B3, 0x0053, 0x03FF,
2364+ 0x03FD, 0x0082, 0x0084, 0x03FD,
2365+ 0x03FF, 0x0053, 0x00B3, 0x03FB,
2366+ 0x0000, 0x002C, 0x00DB, 0x03F9,
2367+ 0x0000, 0x0010, 0x00F6, 0x03FA
2368+ },
2369+ {
2370+ 0x0004, 0x0023, 0x0023, 0x005A,
2371+ 0x005A, 0x0058, 0x0058, 0x0004,
2372+ 0x0023, 0x0023, 0x005A, 0x005A,
2373+ 0x0058, 0x0058, 0x0004, 0x0023,
2374+ 0x0023, 0x005A, 0x005A, 0x0058,
2375+ 0x0058, 0x0004, 0x0023, 0x0023,
2376+ 0x005A, 0x005A, 0x0058, 0x0058
2377+ },
2378+ {
2379+ 0x0004, 0x0023, 0x005A, 0x0058,
2380+ 0x0023, 0x0004, 0x0000, 0x0002,
2381+ 0x0018, 0x004d, 0x0060, 0x0031,
2382+ 0x0008, 0x0000, 0x0001, 0x000f,
2383+ 0x003f, 0x0062, 0x003f, 0x000f,
2384+ 0x0001, 0x0000, 0x0008, 0x0031,
2385+ 0x0060, 0x004d, 0x0018, 0x0002
2386+ }
2387+};
2388+
2389+/**
2390+ * struct isp_res - Structure for the resizer module to store its information.
2391+ * @res_inuse: Indicates if resizer module has been reserved. 1 - Reserved,
2392+ * 0 - Freed.
2393+ * @h_startphase: Horizontal starting phase.
2394+ * @v_startphase: Vertical starting phase.
2395+ * @h_resz: Horizontal resizing value.
2396+ * @v_resz: Vertical resizing value.
2397+ * @outputwidth: Output Image Width in pixels.
2398+ * @outputheight: Output Image Height in pixels.
2399+ * @inputwidth: Input Image Width in pixels.
2400+ * @inputheight: Input Image Height in pixels.
2401+ * @algo: Algorithm select. 0 - Disable, 1 - [-1 2 -1]/2 high-pass filter,
2402+ * 2 - [-1 -2 6 -2 -1]/4 high-pass filter.
2403+ * @ipht_crop: Vertical start line for cropping.
2404+ * @ipwd_crop: Horizontal start pixel for cropping.
2405+ * @cropwidth: Crop Width.
2406+ * @cropheight: Crop Height.
2407+ * @resinput: Resizer input.
2408+ * @coeflist: Register configuration for Resizer.
2409+ * @ispres_mutex: Mutex for isp resizer.
2410+ */
2411+static struct isp_res {
2412+ int pm_state;
2413+ u8 res_inuse;
2414+ u8 h_startphase;
2415+ u8 v_startphase;
2416+ u16 h_resz;
2417+ u16 v_resz;
2418+ u32 outputwidth;
2419+ u32 outputheight;
2420+ u32 inputwidth;
2421+ u32 inputheight;
2422+ u8 algo;
2423+ u32 ipht_crop;
2424+ u32 ipwd_crop;
2425+ u32 cropwidth;
2426+ u32 cropheight;
2427+ dma_addr_t tmp_buf;
2428+ enum ispresizer_input resinput;
2429+ struct isprsz_coef coeflist;
2430+ struct mutex ispres_mutex; /* For checking/modifying res_inuse */
2431+} ispres_obj;
2432+
2433+/* Structure for saving/restoring resizer module registers */
2434+static struct isp_reg isprsz_reg_list[] = {
2435+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT, 0x0000},
2436+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_OUT_SIZE, 0x0000},
2437+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_IN_START, 0x0000},
2438+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_IN_SIZE, 0x0000},
2439+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INADD, 0x0000},
2440+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INOFF, 0x0000},
2441+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_OUTADD, 0x0000},
2442+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_OUTOFF, 0x0000},
2443+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT10, 0x0000},
2444+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT32, 0x0000},
2445+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT54, 0x0000},
2446+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT76, 0x0000},
2447+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT98, 0x0000},
2448+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT1110, 0x0000},
2449+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT1312, 0x0000},
2450+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT1514, 0x0000},
2451+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT1716, 0x0000},
2452+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT1918, 0x0000},
2453+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT2120, 0x0000},
2454+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT2322, 0x0000},
2455+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT2524, 0x0000},
2456+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT2726, 0x0000},
2457+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT2928, 0x0000},
2458+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_HFILT3130, 0x0000},
2459+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT10, 0x0000},
2460+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT32, 0x0000},
2461+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT54, 0x0000},
2462+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT76, 0x0000},
2463+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT98, 0x0000},
2464+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT1110, 0x0000},
2465+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT1312, 0x0000},
2466+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT1514, 0x0000},
2467+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT1716, 0x0000},
2468+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT1918, 0x0000},
2469+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT2120, 0x0000},
2470+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT2322, 0x0000},
2471+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT2524, 0x0000},
2472+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT2726, 0x0000},
2473+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT2928, 0x0000},
2474+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_VFILT3130, 0x0000},
2475+ {OMAP3_ISP_IOMEM_RESZ, ISPRSZ_YENH, 0x0000},
2476+ {0, ISP_TOK_TERM, 0x0000}
2477+};
2478+
2479+/**
2480+ * ispresizer_config_shadow_registers - Configure shadow registers.
2481+ **/
2482+void ispresizer_config_shadow_registers()
2483+{
2484+ return;
2485+}
2486+EXPORT_SYMBOL(ispresizer_config_shadow_registers);
2487+
2488+/**
2489+ * ispresizer_trycrop - Validate crop dimensions.
2490+ * @left: Left distance to start position of crop.
2491+ * @top: Top distance to start position of crop.
2492+ * @width: Width of input image.
2493+ * @height: Height of input image.
2494+ * @ow: Width of output image.
2495+ * @oh: Height of output image.
2496+ **/
2497+void ispresizer_trycrop(u32 left, u32 top, u32 width, u32 height, u32 ow,
2498+ u32 oh)
2499+{
2500+ ispres_obj.cropwidth = width + 6;
2501+ ispres_obj.cropheight = height + 6;
2502+ ispresizer_try_size(&ispres_obj.cropwidth, &ispres_obj.cropheight, &ow,
2503+ &oh);
2504+ ispres_obj.ipht_crop = top;
2505+ ispres_obj.ipwd_crop = left;
2506+}
2507+EXPORT_SYMBOL(ispresizer_trycrop);
2508+
2509+/**
2510+ * ispresizer_applycrop - Apply crop to input image.
2511+ **/
2512+void ispresizer_applycrop(void)
2513+{
2514+ ispresizer_config_size(ispres_obj.cropwidth, ispres_obj.cropheight,
2515+ ispres_obj.outputwidth,
2516+ ispres_obj.outputheight);
2517+ return;
2518+}
2519+EXPORT_SYMBOL(ispresizer_applycrop);
2520+
2521+/**
2522+ * ispresizer_request - Reserves the Resizer module.
2523+ *
2524+ * Allows only one user at a time.
2525+ *
2526+ * Returns 0 if successful, or -EBUSY if resizer module was already requested.
2527+ **/
2528+int ispresizer_request()
2529+{
2530+ mutex_lock(&ispres_obj.ispres_mutex);
2531+ if (!ispres_obj.res_inuse) {
2532+ ispres_obj.res_inuse = 1;
2533+ mutex_unlock(&ispres_obj.ispres_mutex);
2534+ isp_reg_writel(isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_CTRL) |
2535+ ISPCTRL_SBL_WR0_RAM_EN |
2536+ ISPCTRL_RSZ_CLK_EN,
2537+ OMAP3_ISP_IOMEM_MAIN, ISP_CTRL);
2538+ return 0;
2539+ } else {
2540+ mutex_unlock(&ispres_obj.ispres_mutex);
2541+ printk(KERN_ERR "ISP_ERR : Resizer Module Busy\n");
2542+ return -EBUSY;
2543+ }
2544+}
2545+EXPORT_SYMBOL(ispresizer_request);
2546+
2547+/**
2548+ * ispresizer_free - Makes Resizer module free.
2549+ *
2550+ * Returns 0 if successful, or -EINVAL if resizer module was already freed.
2551+ **/
2552+int ispresizer_free()
2553+{
2554+ mutex_lock(&ispres_obj.ispres_mutex);
2555+ if (ispres_obj.res_inuse) {
2556+ ispres_obj.res_inuse = 0;
2557+ mutex_unlock(&ispres_obj.ispres_mutex);
2558+ isp_reg_and(OMAP3_ISP_IOMEM_MAIN, ISP_CTRL,
2559+ ~(ISPCTRL_RSZ_CLK_EN | ISPCTRL_SBL_WR0_RAM_EN));
2560+ return 0;
2561+ } else {
2562+ mutex_unlock(&ispres_obj.ispres_mutex);
2563+ DPRINTK_ISPRESZ("ISP_ERR : Resizer Module already freed\n");
2564+ return -EINVAL;
2565+ }
2566+}
2567+EXPORT_SYMBOL(ispresizer_free);
2568+
2569+/**
2570+ * ispresizer_config_datapath - Specifies which input to use in resizer module
2571+ * @input: Indicates the module that gives the image to resizer.
2572+ *
2573+ * Sets up the default resizer configuration according to the arguments.
2574+ *
2575+ * Returns 0 if successful, or -EINVAL if an unsupported input was requested.
2576+ **/
2577+int ispresizer_config_datapath(enum ispresizer_input input)
2578+{
2579+ u32 cnt = 0;
2580+ DPRINTK_ISPRESZ("ispresizer_config_datapath()+\n");
2581+ ispres_obj.resinput = input;
2582+ switch (input) {
2583+ case RSZ_OTFLY_YUV:
2584+ cnt &= ~ISPRSZ_CNT_INPTYP;
2585+ cnt &= ~ISPRSZ_CNT_INPSRC;
2586+ ispresizer_set_inaddr(0);
2587+ ispresizer_config_inlineoffset(0);
2588+ break;
2589+ case RSZ_MEM_YUV:
2590+ cnt |= ISPRSZ_CNT_INPSRC;
2591+ cnt &= ~ISPRSZ_CNT_INPTYP;
2592+ break;
2593+ case RSZ_MEM_COL8:
2594+ cnt |= ISPRSZ_CNT_INPSRC;
2595+ cnt |= ISPRSZ_CNT_INPTYP;
2596+ break;
2597+ default:
2598+ printk(KERN_ERR "ISP_ERR : Wrong Input\n");
2599+ return -EINVAL;
2600+ }
2601+ isp_reg_or(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT, cnt);
2602+ ispresizer_config_ycpos(0);
2603+ ispresizer_config_filter_coef(&ispreszdefcoef);
2604+ ispresizer_enable_cbilin(0);
2605+ ispresizer_config_luma_enhance(&ispreszdefaultyenh);
2606+ DPRINTK_ISPRESZ("ispresizer_config_datapath()-\n");
2607+ return 0;
2608+}
2609+EXPORT_SYMBOL(ispresizer_config_datapath);
2610+
2611+/**
2612+ * ispresizer_try_size - Validates input and output images size.
2613+ * @input_w: input width for the resizer in number of pixels per line
2614+ * @input_h: input height for the resizer in number of lines
2615+ * @output_w: output width from the resizer in number of pixels per line
2616+ * resizer when writing to memory needs this to be multiple of 16.
2617+ * @output_h: output height for the resizer in number of lines, must be even.
2618+ *
2619+ * Calculates the horizontal and vertical resize ratio, number of pixels to
2620+ * be cropped in the resizer module and checks the validity of various
2621+ * parameters. Formula used for calculation is:-
2622+ *
2623+ * 8-phase 4-tap mode :-
2624+ * inputwidth = (32 * sph + (ow - 1) * hrsz + 16) >> 8 + 7
2625+ * inputheight = (32 * spv + (oh - 1) * vrsz + 16) >> 8 + 4
2626+ * endpahse for width = ((32 * sph + (ow - 1) * hrsz + 16) >> 5) % 8
2627+ * endphase for height = ((32 * sph + (oh - 1) * hrsz + 16) >> 5) % 8
2628+ *
2629+ * 4-phase 7-tap mode :-
2630+ * inputwidth = (64 * sph + (ow - 1) * hrsz + 32) >> 8 + 7
2631+ * inputheight = (64 * spv + (oh - 1) * vrsz + 32) >> 8 + 7
2632+ * endpahse for width = ((64 * sph + (ow - 1) * hrsz + 32) >> 6) % 4
2633+ * endphase for height = ((64 * sph + (oh - 1) * hrsz + 32) >> 6) % 4
2634+ *
2635+ * Where:
2636+ * sph = Start phase horizontal
2637+ * spv = Start phase vertical
2638+ * ow = Output width
2639+ * oh = Output height
2640+ * hrsz = Horizontal resize value
2641+ * vrsz = Vertical resize value
2642+ *
2643+ * Fills up the output/input widht/height, horizontal/vertical resize ratio,
2644+ * horizontal/vertical crop variables in the isp_res structure.
2645+ **/
2646+int ispresizer_try_size(u32 *input_width, u32 *input_height, u32 *output_w,
2647+ u32 *output_h)
2648+{
2649+ u32 rsz, rsz_7, rsz_4;
2650+ u32 sph;
2651+ u32 input_w, input_h;
2652+ int max_in_otf, max_out_7tap;
2653+
2654+ input_w = *input_width;
2655+ input_h = *input_height;
2656+
2657+ if (input_w < 32 || input_h < 32) {
2658+ DPRINTK_ISPCCDC("ISP_ERR: RESIZER cannot handle input width"
2659+ " less than 32 pixels or height less than"
2660+ " 32\n");
2661+ return -EINVAL;
2662+ }
2663+ input_w -= 6;
2664+ input_h -= 6;
2665+
2666+ if (input_h > MAX_IN_HEIGHT)
2667+ return -EINVAL;
2668+
2669+ if (*output_w < 16)
2670+ *output_w = 16;
2671+
2672+ if (*output_h < 2)
2673+ *output_h = 2;
2674+
2675+ if (omap_rev() == OMAP3430_REV_ES1_0) {
2676+ max_in_otf = MAX_IN_WIDTH_ONTHEFLY_MODE;
2677+ max_out_7tap = MAX_7TAP_VRSZ_OUTWIDTH;
2678+ } else {
2679+ max_in_otf = MAX_IN_WIDTH_ONTHEFLY_MODE_ES2;
2680+ max_out_7tap = MAX_7TAP_VRSZ_OUTWIDTH_ES2;
2681+ }
2682+
2683+ if (ispres_obj.resinput == RSZ_OTFLY_YUV) {
2684+ if (input_w > max_in_otf)
2685+ return -EINVAL;
2686+ } else {
2687+ if (input_w > MAX_IN_WIDTH_MEMORY_MODE)
2688+ return -EINVAL;
2689+ }
2690+
2691+ *output_h &= 0xfffffffe;
2692+ sph = DEFAULTSTPHASE;
2693+
2694+ rsz_7 = ((input_h - 7) * 256) / (*output_h - 1);
2695+ rsz_4 = ((input_h - 4) * 256) / (*output_h - 1);
2696+
2697+ rsz = (input_h * 256) / *output_h;
2698+
2699+ if (rsz <= MID_RESIZE_VALUE) {
2700+ rsz = rsz_4;
2701+ if (rsz < MINIMUM_RESIZE_VALUE) {
2702+ rsz = MINIMUM_RESIZE_VALUE;
2703+ *output_h = (((input_h - 4) * 256) / rsz) + 1;
2704+ printk(KERN_INFO "%s: using output_h %d instead\n",
2705+ __func__, *output_h);
2706+ }
2707+ } else {
2708+ rsz = rsz_7;
2709+ if (*output_w > max_out_7tap)
2710+ *output_w = max_out_7tap;
2711+ if (rsz > MAXIMUM_RESIZE_VALUE) {
2712+ rsz = MAXIMUM_RESIZE_VALUE;
2713+ *output_h = (((input_h - 7) * 256) / rsz) + 1;
2714+ printk(KERN_INFO "%s: using output_h %d instead\n",
2715+ __func__, *output_h);
2716+ }
2717+ }
2718+
2719+ if (rsz > MID_RESIZE_VALUE) {
2720+ input_h =
2721+ (((64 * sph) + ((*output_h - 1) * rsz) + 32) / 256) + 7;
2722+ } else {
2723+ input_h =
2724+ (((32 * sph) + ((*output_h - 1) * rsz) + 16) / 256) + 4;
2725+ }
2726+
2727+ ispres_obj.outputheight = *output_h;
2728+ ispres_obj.v_resz = rsz;
2729+ ispres_obj.inputheight = input_h;
2730+ ispres_obj.ipht_crop = DEFAULTSTPIXEL;
2731+ ispres_obj.v_startphase = sph;
2732+
2733+ *output_w &= 0xfffffff0;
2734+ sph = DEFAULTSTPHASE;
2735+
2736+ rsz_7 = ((input_w - 7) * 256) / (*output_w - 1);
2737+ rsz_4 = ((input_w - 4) * 256) / (*output_w - 1);
2738+
2739+ rsz = (input_w * 256) / *output_w;
2740+ if (rsz > MID_RESIZE_VALUE) {
2741+ rsz = rsz_7;
2742+ if (rsz > MAXIMUM_RESIZE_VALUE) {
2743+ rsz = MAXIMUM_RESIZE_VALUE;
2744+ *output_w = (((input_w - 7) * 256) / rsz) + 1;
2745+ *output_w = (*output_w + 0xf) & 0xfffffff0;
2746+ printk(KERN_INFO "%s: using output_w %d instead\n",
2747+ __func__, *output_w);
2748+ }
2749+ } else {
2750+ rsz = rsz_4;
2751+ if (rsz < MINIMUM_RESIZE_VALUE) {
2752+ rsz = MINIMUM_RESIZE_VALUE;
2753+ *output_w = (((input_w - 4) * 256) / rsz) + 1;
2754+ *output_w = (*output_w + 0xf) & 0xfffffff0;
2755+ printk(KERN_INFO "%s: using output_w %d instead\n",
2756+ __func__, *output_w);
2757+ }
2758+ }
2759+
2760+ /* Recalculate input based on TRM equations */
2761+ if (rsz > MID_RESIZE_VALUE) {
2762+ input_w =
2763+ (((64 * sph) + ((*output_w - 1) * rsz) + 32) / 256) + 7;
2764+ } else {
2765+ input_w =
2766+ (((32 * sph) + ((*output_w - 1) * rsz) + 16) / 256) + 7;
2767+ }
2768+
2769+ ispres_obj.outputwidth = *output_w;
2770+ ispres_obj.h_resz = rsz;
2771+ ispres_obj.inputwidth = input_w;
2772+ ispres_obj.ipwd_crop = DEFAULTSTPIXEL;
2773+ ispres_obj.h_startphase = sph;
2774+
2775+ *input_height = input_h;
2776+ *input_width = input_w;
2777+ return 0;
2778+}
2779+EXPORT_SYMBOL(ispresizer_try_size);
2780+
2781+/**
2782+ * ispresizer_config_size - Configures input and output image size.
2783+ * @input_w: input width for the resizer in number of pixels per line.
2784+ * @input_h: input height for the resizer in number of lines.
2785+ * @output_w: output width from the resizer in number of pixels per line.
2786+ * @output_h: output height for the resizer in number of lines.
2787+ *
2788+ * Configures the appropriate values stored in the isp_res structure in the
2789+ * resizer registers.
2790+ *
2791+ * Returns 0 if successful, or -EINVAL if passed values haven't been verified
2792+ * with ispresizer_try_size() previously.
2793+ **/
2794+int ispresizer_config_size(u32 input_w, u32 input_h, u32 output_w,
2795+ u32 output_h)
2796+{
2797+ int i, j;
2798+ u32 res;
2799+ DPRINTK_ISPRESZ("ispresizer_config_size()+, input_w = %d,input_h ="
2800+ " %d, output_w = %d, output_h"
2801+ " = %d,hresz = %d,vresz = %d,"
2802+ " hcrop = %d, vcrop = %d,"
2803+ " hstph = %d, vstph = %d\n",
2804+ ispres_obj.inputwidth,
2805+ ispres_obj.inputheight,
2806+ ispres_obj.outputwidth,
2807+ ispres_obj.outputheight,
2808+ ispres_obj.h_resz,
2809+ ispres_obj.v_resz,
2810+ ispres_obj.ipwd_crop,
2811+ ispres_obj.ipht_crop,
2812+ ispres_obj.h_startphase,
2813+ ispres_obj.v_startphase);
2814+ if ((output_w != ispres_obj.outputwidth)
2815+ || (output_h != ispres_obj.outputheight)) {
2816+ printk(KERN_ERR "Output parameters passed do not match the"
2817+ " values calculated by the"
2818+ " trysize passed w %d, h %d"
2819+ " \n", output_w , output_h);
2820+ return -EINVAL;
2821+ }
2822+
2823+ /* Set Resizer input address and offset adderss */
2824+ ispresizer_config_inlineoffset(isp_reg_readl(OMAP3_ISP_IOMEM_PREV,
2825+ ISPPRV_WADD_OFFSET));
2826+
2827+ res = isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT) &
2828+ ~(ISPRSZ_CNT_HSTPH_MASK | ISPRSZ_CNT_VSTPH_MASK);
2829+ isp_reg_writel(res |
2830+ (ispres_obj.h_startphase << ISPRSZ_CNT_HSTPH_SHIFT) |
2831+ (ispres_obj.v_startphase << ISPRSZ_CNT_VSTPH_SHIFT),
2832+ OMAP3_ISP_IOMEM_RESZ,
2833+ ISPRSZ_CNT);
2834+ /* Set start address for cropping */
2835+ isp_reg_writel(ispres_obj.tmp_buf + 2 *
2836+ (ispres_obj.ipht_crop * ispres_obj.inputwidth +
2837+ (ispres_obj.ipwd_crop & ~15)),
2838+ OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INADD);
2839+
2840+ isp_reg_writel(
2841+ ((ispres_obj.ipwd_crop & 15) << ISPRSZ_IN_START_HORZ_ST_SHIFT) |
2842+ (0x00 << ISPRSZ_IN_START_VERT_ST_SHIFT),
2843+ OMAP3_ISP_IOMEM_RESZ, ISPRSZ_IN_START);
2844+
2845+ isp_reg_writel((0x00 << ISPRSZ_IN_START_HORZ_ST_SHIFT) |
2846+ (0x00 << ISPRSZ_IN_START_VERT_ST_SHIFT),
2847+ OMAP3_ISP_IOMEM_RESZ,
2848+ ISPRSZ_IN_START);
2849+
2850+ isp_reg_writel((ispres_obj.inputwidth << ISPRSZ_IN_SIZE_HORZ_SHIFT) |
2851+ (ispres_obj.inputheight <<
2852+ ISPRSZ_IN_SIZE_VERT_SHIFT),
2853+ OMAP3_ISP_IOMEM_RESZ,
2854+ ISPRSZ_IN_SIZE);
2855+ if (!ispres_obj.algo) {
2856+ isp_reg_writel((output_w << ISPRSZ_OUT_SIZE_HORZ_SHIFT) |
2857+ (output_h << ISPRSZ_OUT_SIZE_VERT_SHIFT),
2858+ OMAP3_ISP_IOMEM_RESZ,
2859+ ISPRSZ_OUT_SIZE);
2860+ } else {
2861+ isp_reg_writel(((output_w - 4) << ISPRSZ_OUT_SIZE_HORZ_SHIFT) |
2862+ (output_h << ISPRSZ_OUT_SIZE_VERT_SHIFT),
2863+ OMAP3_ISP_IOMEM_RESZ,
2864+ ISPRSZ_OUT_SIZE);
2865+ }
2866+
2867+ res = isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT) &
2868+ ~(ISPRSZ_CNT_HRSZ_MASK | ISPRSZ_CNT_VRSZ_MASK);
2869+ isp_reg_writel(res |
2870+ ((ispres_obj.h_resz - 1) << ISPRSZ_CNT_HRSZ_SHIFT) |
2871+ ((ispres_obj.v_resz - 1) << ISPRSZ_CNT_VRSZ_SHIFT),
2872+ OMAP3_ISP_IOMEM_RESZ,
2873+ ISPRSZ_CNT);
2874+ if (ispres_obj.h_resz <= MID_RESIZE_VALUE) {
2875+ j = 0;
2876+ for (i = 0; i < 16; i++) {
2877+ isp_reg_writel(
2878+ (ispres_obj.coeflist.h_filter_coef_4tap[j]
2879+ << ISPRSZ_HFILT10_COEF0_SHIFT) |
2880+ (ispres_obj.coeflist.h_filter_coef_4tap[j + 1]
2881+ << ISPRSZ_HFILT10_COEF1_SHIFT),
2882+ OMAP3_ISP_IOMEM_RESZ,
2883+ ISPRSZ_HFILT10 + (i * 0x04));
2884+ j += 2;
2885+ }
2886+ } else {
2887+ j = 0;
2888+ for (i = 0; i < 16; i++) {
2889+ if ((i + 1) % 4 == 0) {
2890+ isp_reg_writel((ispres_obj.coeflist.
2891+ h_filter_coef_7tap[j] <<
2892+ ISPRSZ_HFILT10_COEF0_SHIFT),
2893+ OMAP3_ISP_IOMEM_RESZ,
2894+ ISPRSZ_HFILT10 + (i * 0x04));
2895+ j += 1;
2896+ } else {
2897+ isp_reg_writel((ispres_obj.coeflist.
2898+ h_filter_coef_7tap[j] <<
2899+ ISPRSZ_HFILT10_COEF0_SHIFT) |
2900+ (ispres_obj.coeflist.
2901+ h_filter_coef_7tap[j+1] <<
2902+ ISPRSZ_HFILT10_COEF1_SHIFT),
2903+ OMAP3_ISP_IOMEM_RESZ,
2904+ ISPRSZ_HFILT10 + (i * 0x04));
2905+ j += 2;
2906+ }
2907+ }
2908+ }
2909+ if (ispres_obj.v_resz <= MID_RESIZE_VALUE) {
2910+ j = 0;
2911+ for (i = 0; i < 16; i++) {
2912+ isp_reg_writel((ispres_obj.coeflist.
2913+ v_filter_coef_4tap[j] <<
2914+ ISPRSZ_VFILT10_COEF0_SHIFT) |
2915+ (ispres_obj.coeflist.
2916+ v_filter_coef_4tap[j + 1] <<
2917+ ISPRSZ_VFILT10_COEF1_SHIFT),
2918+ OMAP3_ISP_IOMEM_RESZ,
2919+ ISPRSZ_VFILT10 + (i * 0x04));
2920+ j += 2;
2921+ }
2922+ } else {
2923+ j = 0;
2924+ for (i = 0; i < 16; i++) {
2925+ if ((i + 1) % 4 == 0) {
2926+ isp_reg_writel((ispres_obj.coeflist.
2927+ v_filter_coef_7tap[j] <<
2928+ ISPRSZ_VFILT10_COEF0_SHIFT),
2929+ OMAP3_ISP_IOMEM_RESZ,
2930+ ISPRSZ_VFILT10 + (i * 0x04));
2931+ j += 1;
2932+ } else {
2933+ isp_reg_writel((ispres_obj.coeflist.
2934+ v_filter_coef_7tap[j] <<
2935+ ISPRSZ_VFILT10_COEF0_SHIFT) |
2936+ (ispres_obj.coeflist.
2937+ v_filter_coef_7tap[j+1] <<
2938+ ISPRSZ_VFILT10_COEF1_SHIFT),
2939+ OMAP3_ISP_IOMEM_RESZ,
2940+ ISPRSZ_VFILT10 + (i * 0x04));
2941+ j += 2;
2942+ }
2943+ }
2944+ }
2945+
2946+ ispresizer_config_outlineoffset(output_w*2);
2947+ DPRINTK_ISPRESZ("ispresizer_config_size()-\n");
2948+ return 0;
2949+}
2950+EXPORT_SYMBOL(ispresizer_config_size);
2951+
2952+void __ispresizer_enable(int enable)
2953+{
2954+ int val;
2955+ DPRINTK_ISPRESZ("+ispresizer_enable()+\n");
2956+ if (enable) {
2957+ val = (isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_PCR) & 0x2) |
2958+ ISPRSZ_PCR_ENABLE;
2959+ } else {
2960+ val = isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_PCR) &
2961+ ~ISPRSZ_PCR_ENABLE;
2962+ }
2963+ isp_reg_writel(val, OMAP3_ISP_IOMEM_RESZ, ISPRSZ_PCR);
2964+ DPRINTK_ISPRESZ("+ispresizer_enable()-\n");
2965+}
2966+
2967+/**
2968+ * ispresizer_enable - Enables the resizer module.
2969+ * @enable: 1 - Enable, 0 - Disable
2970+ *
2971+ * Client should configure all the sub modules in resizer before this.
2972+ **/
2973+void ispresizer_enable(int enable)
2974+{
2975+ __ispresizer_enable(enable);
2976+ ispres_obj.pm_state = enable;
2977+}
2978+EXPORT_SYMBOL(ispresizer_enable);
2979+
2980+/**
2981+ * ispresizer_suspend - Suspend resizer module.
2982+ **/
2983+void ispresizer_suspend(void)
2984+{
2985+ if (ispres_obj.pm_state)
2986+ __ispresizer_enable(0);
2987+}
2988+EXPORT_SYMBOL(ispresizer_suspend);
2989+
2990+/**
2991+ * ispresizer_resume - Resume resizer module.
2992+ **/
2993+void ispresizer_resume(void)
2994+{
2995+ if (ispres_obj.pm_state)
2996+ __ispresizer_enable(1);
2997+}
2998+EXPORT_SYMBOL(ispresizer_resume);
2999+
3000+/**
3001+ * ispresizer_busy - Checks if ISP resizer is busy.
3002+ *
3003+ * Returns busy field from ISPRSZ_PCR register.
3004+ **/
3005+int ispresizer_busy(void)
3006+{
3007+ return isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_PCR) &
3008+ ISPPRV_PCR_BUSY;
3009+}
3010+EXPORT_SYMBOL(ispresizer_busy);
3011+
3012+/**
3013+ * ispresizer_config_startphase - Sets the horizontal and vertical start phase.
3014+ * @hstartphase: horizontal start phase (0 - 7).
3015+ * @vstartphase: vertical startphase (0 - 7).
3016+ *
3017+ * This API just updates the isp_res struct. Actual register write happens in
3018+ * ispresizer_config_size.
3019+ **/
3020+void ispresizer_config_startphase(u8 hstartphase, u8 vstartphase)
3021+{
3022+ DPRINTK_ISPRESZ("ispresizer_config_startphase()+\n");
3023+ ispres_obj.h_startphase = hstartphase;
3024+ ispres_obj.v_startphase = vstartphase;
3025+ DPRINTK_ISPRESZ("ispresizer_config_startphase()-\n");
3026+}
3027+EXPORT_SYMBOL(ispresizer_config_startphase);
3028+
3029+/**
3030+ * ispresizer_config_ycpos - Specifies if output should be in YC or CY format.
3031+ * @yc: 0 - YC format, 1 - CY format
3032+ **/
3033+void ispresizer_config_ycpos(u8 yc)
3034+{
3035+ DPRINTK_ISPRESZ("ispresizer_config_ycpos()+\n");
3036+ isp_reg_and_or(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT, ~ISPRSZ_CNT_YCPOS,
3037+ (yc ? ISPRSZ_CNT_YCPOS : 0));
3038+ DPRINTK_ISPRESZ("ispresizer_config_ycpos()-\n");
3039+}
3040+EXPORT_SYMBOL(ispresizer_config_ycpos);
3041+
3042+/**
3043+ * Sets the chrominance algorithm
3044+ * @cbilin: 0 - chrominance uses same processing as luminance,
3045+ * 1 - bilinear interpolation processing
3046+ **/
3047+void ispresizer_enable_cbilin(u8 enable)
3048+{
3049+ DPRINTK_ISPRESZ("ispresizer_enable_cbilin()+\n");
3050+ isp_reg_and_or(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT, ~ISPRSZ_CNT_CBILIN,
3051+ (enable ? ISPRSZ_CNT_CBILIN : 0));
3052+ DPRINTK_ISPRESZ("ispresizer_enable_cbilin()-\n");
3053+}
3054+EXPORT_SYMBOL(ispresizer_enable_cbilin);
3055+
3056+/**
3057+ * ispresizer_config_luma_enhance - Configures luminance enhancer parameters.
3058+ * @yenh: Pointer to structure containing desired values for core, slope, gain
3059+ * and algo parameters.
3060+ **/
3061+void ispresizer_config_luma_enhance(struct isprsz_yenh *yenh)
3062+{
3063+ DPRINTK_ISPRESZ("ispresizer_config_luma_enhance()+\n");
3064+ ispres_obj.algo = yenh->algo;
3065+ isp_reg_writel((yenh->algo << ISPRSZ_YENH_ALGO_SHIFT) |
3066+ (yenh->gain << ISPRSZ_YENH_GAIN_SHIFT) |
3067+ (yenh->slope << ISPRSZ_YENH_SLOP_SHIFT) |
3068+ (yenh->coreoffset << ISPRSZ_YENH_CORE_SHIFT),
3069+ OMAP3_ISP_IOMEM_RESZ,
3070+ ISPRSZ_YENH);
3071+ DPRINTK_ISPRESZ("ispresizer_config_luma_enhance()-\n");
3072+}
3073+EXPORT_SYMBOL(ispresizer_config_luma_enhance);
3074+
3075+/**
3076+ * ispresizer_config_filter_coef - Sets filter coefficients for 4 & 7-tap mode.
3077+ * This API just updates the isp_res struct.Actual register write happens in
3078+ * ispresizer_config_size.
3079+ * @coef: Structure containing horizontal and vertical filter coefficients for
3080+ * both 4-tap and 7-tap mode.
3081+ **/
3082+void ispresizer_config_filter_coef(struct isprsz_coef *coef)
3083+{
3084+ int i;
3085+ DPRINTK_ISPRESZ("ispresizer_config_filter_coef()+\n");
3086+ for (i = 0; i < 32; i++) {
3087+ ispres_obj.coeflist.h_filter_coef_4tap[i] =
3088+ coef->h_filter_coef_4tap[i];
3089+ ispres_obj.coeflist.v_filter_coef_4tap[i] =
3090+ coef->v_filter_coef_4tap[i];
3091+ }
3092+ for (i = 0; i < 28; i++) {
3093+ ispres_obj.coeflist.h_filter_coef_7tap[i] =
3094+ coef->h_filter_coef_7tap[i];
3095+ ispres_obj.coeflist.v_filter_coef_7tap[i] =
3096+ coef->v_filter_coef_7tap[i];
3097+ }
3098+ DPRINTK_ISPRESZ("ispresizer_config_filter_coef()-\n");
3099+}
3100+EXPORT_SYMBOL(ispresizer_config_filter_coef);
3101+
3102+/**
3103+ * ispresizer_config_inlineoffset - Configures the read address line offset.
3104+ * @offset: Line Offset for the input image.
3105+ *
3106+ * Returns 0 if successful, or -EINVAL if offset is not 32 bits aligned.
3107+ **/
3108+int ispresizer_config_inlineoffset(u32 offset)
3109+{
3110+ DPRINTK_ISPRESZ("ispresizer_config_inlineoffset()+\n");
3111+ if (offset % 32)
3112+ return -EINVAL;
3113+ isp_reg_writel(offset << ISPRSZ_SDR_INOFF_OFFSET_SHIFT,
3114+ OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INOFF);
3115+ DPRINTK_ISPRESZ("ispresizer_config_inlineoffset()-\n");
3116+ return 0;
3117+}
3118+EXPORT_SYMBOL(ispresizer_config_inlineoffset);
3119+
3120+/**
3121+ * ispresizer_set_inaddr - Sets the memory address of the input frame.
3122+ * @addr: 32bit memory address aligned on 32byte boundary.
3123+ *
3124+ * Returns 0 if successful, or -EINVAL if address is not 32 bits aligned.
3125+ **/
3126+int ispresizer_set_inaddr(u32 addr)
3127+{
3128+ DPRINTK_ISPRESZ("ispresizer_set_inaddr()+\n");
3129+ if (addr % 32)
3130+ return -EINVAL;
3131+ isp_reg_writel(addr << ISPRSZ_SDR_INADD_ADDR_SHIFT,
3132+ OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INADD);
3133+ ispres_obj.tmp_buf = addr;
3134+ DPRINTK_ISPRESZ("ispresizer_set_inaddr()-\n");
3135+ return 0;
3136+}
3137+EXPORT_SYMBOL(ispresizer_set_inaddr);
3138+
3139+/**
3140+ * ispresizer_config_outlineoffset - Configures the write address line offset.
3141+ * @offset: Line offset for the preview output.
3142+ *
3143+ * Returns 0 if successful, or -EINVAL if address is not 32 bits aligned.
3144+ **/
3145+int ispresizer_config_outlineoffset(u32 offset)
3146+{
3147+ DPRINTK_ISPRESZ("ispresizer_config_outlineoffset()+\n");
3148+ if (offset % 32)
3149+ return -EINVAL;
3150+ isp_reg_writel(offset << ISPRSZ_SDR_OUTOFF_OFFSET_SHIFT,
3151+ OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_OUTOFF);
3152+ DPRINTK_ISPRESZ("ispresizer_config_outlineoffset()-\n");
3153+ return 0;
3154+}
3155+EXPORT_SYMBOL(ispresizer_config_outlineoffset);
3156+
3157+/**
3158+ * Configures the memory address to which the output frame is written.
3159+ * @addr: 32bit memory address aligned on 32byte boundary.
3160+ **/
3161+int ispresizer_set_outaddr(u32 addr)
3162+{
3163+ DPRINTK_ISPRESZ("ispresizer_set_outaddr()+\n");
3164+ if (addr % 32)
3165+ return -EINVAL;
3166+ isp_reg_writel(addr << ISPRSZ_SDR_OUTADD_ADDR_SHIFT,
3167+ OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_OUTADD);
3168+ DPRINTK_ISPRESZ("ispresizer_set_outaddr()-\n");
3169+ return 0;
3170+}
3171+EXPORT_SYMBOL(ispresizer_set_outaddr);
3172+
3173+/**
3174+ * ispresizer_save_context - Saves the values of the resizer module registers.
3175+ **/
3176+void ispresizer_save_context(void)
3177+{
3178+ DPRINTK_ISPRESZ("Saving context\n");
3179+ isp_save_context(isprsz_reg_list);
3180+}
3181+EXPORT_SYMBOL(ispresizer_save_context);
3182+
3183+/**
3184+ * ispresizer_restore_context - Restores resizer module register values.
3185+ **/
3186+void ispresizer_restore_context(void)
3187+{
3188+ DPRINTK_ISPRESZ("Restoring context\n");
3189+ isp_restore_context(isprsz_reg_list);
3190+}
3191+EXPORT_SYMBOL(ispresizer_restore_context);
3192+
3193+/**
3194+ * ispresizer_print_status - Prints the values of the resizer module registers.
3195+ **/
3196+void ispresizer_print_status()
3197+{
3198+ if (!is_ispresz_debug_enabled())
3199+ return;
3200+ DPRINTK_ISPRESZ("###ISP_CTRL inresizer =0x%x\n",
3201+ isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_CTRL));
3202+ DPRINTK_ISPRESZ("###ISP_IRQ0ENABLE in resizer =0x%x\n",
3203+ isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE));
3204+ DPRINTK_ISPRESZ("###ISP_IRQ0STATUS in resizer =0x%x\n",
3205+ isp_reg_readl(OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS));
3206+ DPRINTK_ISPRESZ("###RSZ PCR =0x%x\n",
3207+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_PCR));
3208+ DPRINTK_ISPRESZ("###RSZ CNT =0x%x\n",
3209+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT));
3210+ DPRINTK_ISPRESZ("###RSZ OUT SIZE =0x%x\n",
3211+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_OUT_SIZE));
3212+ DPRINTK_ISPRESZ("###RSZ IN START =0x%x\n",
3213+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_IN_START));
3214+ DPRINTK_ISPRESZ("###RSZ IN SIZE =0x%x\n",
3215+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_IN_SIZE));
3216+ DPRINTK_ISPRESZ("###RSZ SDR INADD =0x%x\n",
3217+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INADD));
3218+ DPRINTK_ISPRESZ("###RSZ SDR INOFF =0x%x\n",
3219+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_INOFF));
3220+ DPRINTK_ISPRESZ("###RSZ SDR OUTADD =0x%x\n",
3221+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_OUTADD));
3222+ DPRINTK_ISPRESZ("###RSZ SDR OTOFF =0x%x\n",
3223+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_SDR_OUTOFF));
3224+ DPRINTK_ISPRESZ("###RSZ YENH =0x%x\n",
3225+ isp_reg_readl(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_YENH));
3226+}
3227+EXPORT_SYMBOL(ispresizer_print_status);
3228+
3229+/**
3230+ * isp_resizer_init - Module Initialisation.
3231+ *
3232+ * Always returns 0.
3233+ **/
3234+int __init isp_resizer_init(void)
3235+{
3236+ mutex_init(&ispres_obj.ispres_mutex);
3237+ ispres_obj.pm_state = 0;
3238+ return 0;
3239+}
3240+
3241+/**
3242+ * isp_resizer_cleanup - Module Cleanup.
3243+ **/
3244+void isp_resizer_cleanup(void)
3245+{
3246+}
3247diff --git a/drivers/media/video/isp/ispresizer.h b/drivers/media/video/isp/ispresizer.h
3248new file mode 100644
3249index 0000000..4e92225
3250--- /dev/null
3251+++ b/drivers/media/video/isp/ispresizer.h
3252@@ -0,0 +1,158 @@
3253+/*
3254+ * ispresizer.h
3255+ *
3256+ * Driver header file for Resizer module in TI's OMAP3 Camera ISP
3257+ *
3258+ * Copyright (C) 2009 Texas Instruments, Inc.
3259+ *
3260+ * Contributors:
3261+ * Sameer Venkatraman <sameerv@ti.com>
3262+ * Mohit Jalori
3263+ * Sergio Aguirre <saaguirre@ti.com>
3264+ *
3265+ * This package is free software; you can redistribute it and/or modify
3266+ * it under the terms of the GNU General Public License version 2 as
3267+ * published by the Free Software Foundation.
3268+ *
3269+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
3270+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
3271+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
3272+ */
3273+
3274+#ifndef OMAP_ISP_RESIZER_H
3275+#define OMAP_ISP_RESIZER_H
3276+
3277+/*
3278+ * Resizer Constants
3279+ */
3280+#define MAX_IN_WIDTH_MEMORY_MODE 4095
3281+
3282+#define MAX_IN_WIDTH_ONTHEFLY_MODE 1280
3283+#define MAX_IN_WIDTH_ONTHEFLY_MODE_ES2 4095
3284+#define MAX_IN_HEIGHT 4095
3285+#define MINIMUM_RESIZE_VALUE 64
3286+#define MAXIMUM_RESIZE_VALUE 1024
3287+#define MID_RESIZE_VALUE 512
3288+
3289+#define MAX_7TAP_HRSZ_OUTWIDTH 1280
3290+#define MAX_7TAP_VRSZ_OUTWIDTH 640
3291+
3292+#define MAX_7TAP_HRSZ_OUTWIDTH_ES2 3300
3293+#define MAX_7TAP_VRSZ_OUTWIDTH_ES2 1650
3294+
3295+#define DEFAULTSTPIXEL 0
3296+#define DEFAULTSTPHASE 1
3297+#define DEFAULTHSTPIXEL4TAPMODE 3
3298+#define FOURPHASE 4
3299+#define EIGHTPHASE 8
3300+#define RESIZECONSTANT 256
3301+#define SHIFTER4TAPMODE 0
3302+#define SHIFTER7TAPMODE 1
3303+#define DEFAULTOFFSET 7
3304+#define OFFSETVERT4TAPMODE 4
3305+#define OPWDALIGNCONSTANT 0xfffffff0
3306+
3307+/*
3308+ * The client is supposed to call resizer API in the following sequence:
3309+ * - request()
3310+ * - config_datatpath()
3311+ * - optionally config/enable sub modules
3312+ * - try/config size
3313+ * - setup callback
3314+ * - setup in/out memory offsets and ptrs
3315+ * - enable()
3316+ * ...
3317+ * - disable()
3318+ * - free()
3319+ */
3320+
3321+enum ispresizer_input {
3322+ RSZ_OTFLY_YUV,
3323+ RSZ_MEM_YUV,
3324+ RSZ_MEM_COL8
3325+};
3326+
3327+/**
3328+ * struct isprsz_coef - Structure for resizer filter coeffcients.
3329+ * @h_filter_coef_4tap: Horizontal filter coefficients for 8-phase/4-tap
3330+ * mode (.5x-4x)
3331+ * @v_filter_coef_4tap: Vertical filter coefficients for 8-phase/4-tap
3332+ * mode (.5x-4x)
3333+ * @h_filter_coef_7tap: Horizontal filter coefficients for 4-phase/7-tap
3334+ * mode (.25x-.5x)
3335+ * @v_filter_coef_7tap: Vertical filter coefficients for 4-phase/7-tap
3336+ * mode (.25x-.5x)
3337+ */
3338+struct isprsz_coef {
3339+ u16 h_filter_coef_4tap[32];
3340+ u16 v_filter_coef_4tap[32];
3341+ u16 h_filter_coef_7tap[28];
3342+ u16 v_filter_coef_7tap[28];
3343+};
3344+
3345+/**
3346+ * struct isprsz_yenh - Structure for resizer luminance enhancer parameters.
3347+ * @algo: Algorithm select.
3348+ * @gain: Maximum gain.
3349+ * @slope: Slope.
3350+ * @coreoffset: Coring offset.
3351+ */
3352+struct isprsz_yenh {
3353+ u8 algo;
3354+ u8 gain;
3355+ u8 slope;
3356+ u8 coreoffset;
3357+};
3358+
3359+void ispresizer_config_shadow_registers(void);
3360+
3361+int ispresizer_request(void);
3362+
3363+int ispresizer_free(void);
3364+
3365+int ispresizer_config_datapath(enum ispresizer_input input);
3366+
3367+void ispresizer_enable_cbilin(u8 enable);
3368+
3369+void ispresizer_config_ycpos(u8 yc);
3370+
3371+void ispresizer_config_startphase(u8 hstartphase, u8 vstartphase);
3372+
3373+void ispresizer_config_filter_coef(struct isprsz_coef *coef);
3374+
3375+void ispresizer_config_luma_enhance(struct isprsz_yenh *yenh);
3376+
3377+int ispresizer_try_size(u32 *input_w, u32 *input_h, u32 *output_w,
3378+ u32 *output_h);
3379+
3380+void ispresizer_applycrop(void);
3381+
3382+void ispresizer_trycrop(u32 left, u32 top, u32 width, u32 height, u32 ow,
3383+ u32 oh);
3384+
3385+int ispresizer_config_size(u32 input_w, u32 input_h, u32 output_w,
3386+ u32 output_h);
3387+
3388+int ispresizer_config_inlineoffset(u32 offset);
3389+
3390+int ispresizer_set_inaddr(u32 addr);
3391+
3392+int ispresizer_config_outlineoffset(u32 offset);
3393+
3394+int ispresizer_set_outaddr(u32 addr);
3395+
3396+void ispresizer_enable(int enable);
3397+
3398+void ispresizer_suspend(void);
3399+
3400+void ispresizer_resume(void);
3401+
3402+int ispresizer_busy(void);
3403+
3404+void ispresizer_save_context(void);
3405+
3406+void ispresizer_restore_context(void);
3407+
3408+void ispresizer_print_status(void);
3409+
3410+#endif /* OMAP_ISP_RESIZER_H */
3411--
34121.5.6.5
3413
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-04-27 09:30:49 +0000