?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Don't clone maps from parent when synthesizing forks
[linux/fpc-iii.git] / drivers / media / platform / davinci / isif.c
blobf924e76e2fbf869d859c6cea46c6f8945b368a02
1 /*
2 * Copyright (C) 2008-2009 Texas Instruments Inc
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * Image Sensor Interface (ISIF) driver
15 *
16 * This driver is for configuring the ISIF IP available on DM365 or any other
17 * TI SoCs. This is used for capturing yuv or bayer video or image data
18 * from a decoder or sensor. This IP is similar to the CCDC IP on DM355
19 * and DM6446, but with enhanced or additional ip blocks. The driver
20 * configures the ISIF upon commands from the vpfe bridge driver through
21 * ccdc_hw_device interface.
22 *
23 * TODO: 1) Raw bayer parameter settings and bayer capture
24 * 2) Add support for control ioctl
25 */
26 #include <linux/delay.h>
27 #include <linux/platform_device.h>
28 #include <linux/uaccess.h>
29 #include <linux/io.h>
30 #include <linux/videodev2.h>
31 #include <linux/err.h>
32 #include <linux/module.h>
33
34 #include <media/davinci/isif.h>
35 #include <media/davinci/vpss.h>
36
37 #include "isif_regs.h"
38 #include "ccdc_hw_device.h"
39
40 /* Defaults for module configuration parameters */
41 static struct isif_config_params_raw isif_config_defaults = {
42 .linearize = {
43 .en = 0,
44 .corr_shft = ISIF_NO_SHIFT,
45 .scale_fact = {1, 0},
46 },
47 .df_csc = {
48 .df_or_csc = 0,
49 .csc = {
50 .en = 0,
51 },
52 },
53 .dfc = {
54 .en = 0,
55 },
56 .bclamp = {
57 .en = 0,
58 },
59 .gain_offset = {
60 .gain = {
61 .r_ye = {1, 0},
62 .gr_cy = {1, 0},
63 .gb_g = {1, 0},
64 .b_mg = {1, 0},
65 },
66 },
67 .culling = {
68 .hcpat_odd = 0xff,
69 .hcpat_even = 0xff,
70 .vcpat = 0xff,
71 },
72 .compress = {
73 .alg = ISIF_ALAW,
74 },
75 };
76
77 /* ISIF operation configuration */
78 static struct isif_oper_config {
79 struct device *dev;
80 enum vpfe_hw_if_type if_type;
81 struct isif_ycbcr_config ycbcr;
82 struct isif_params_raw bayer;
83 enum isif_data_pack data_pack;
84 /* ISIF base address */
85 void __iomem *base_addr;
86 /* ISIF Linear Table 0 */
87 void __iomem *linear_tbl0_addr;
88 /* ISIF Linear Table 1 */
89 void __iomem *linear_tbl1_addr;
90 } isif_cfg = {
91 .ycbcr = {
92 .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
93 .frm_fmt = CCDC_FRMFMT_INTERLACED,
94 .win = ISIF_WIN_NTSC,
95 .fid_pol = VPFE_PINPOL_POSITIVE,
96 .vd_pol = VPFE_PINPOL_POSITIVE,
97 .hd_pol = VPFE_PINPOL_POSITIVE,
98 .pix_order = CCDC_PIXORDER_CBYCRY,
99 .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED,
100 },
101 .bayer = {
102 .pix_fmt = CCDC_PIXFMT_RAW,
103 .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
104 .win = ISIF_WIN_VGA,
105 .fid_pol = VPFE_PINPOL_POSITIVE,
106 .vd_pol = VPFE_PINPOL_POSITIVE,
107 .hd_pol = VPFE_PINPOL_POSITIVE,
108 .gain = {
109 .r_ye = {1, 0},
110 .gr_cy = {1, 0},
111 .gb_g = {1, 0},
112 .b_mg = {1, 0},
113 },
114 .cfa_pat = ISIF_CFA_PAT_MOSAIC,
115 .data_msb = ISIF_BIT_MSB_11,
116 .config_params = {
117 .data_shift = ISIF_NO_SHIFT,
118 .col_pat_field0 = {
119 .olop = ISIF_GREEN_BLUE,
120 .olep = ISIF_BLUE,
121 .elop = ISIF_RED,
122 .elep = ISIF_GREEN_RED,
123 },
124 .col_pat_field1 = {
125 .olop = ISIF_GREEN_BLUE,
126 .olep = ISIF_BLUE,
127 .elop = ISIF_RED,
128 .elep = ISIF_GREEN_RED,
129 },
130 .test_pat_gen = 0,
131 },
132 },
133 .data_pack = ISIF_DATA_PACK8,
134 };
135
136 /* Raw Bayer formats */
137 static const u32 isif_raw_bayer_pix_formats[] = {
138 V4L2_PIX_FMT_SBGGR8, V4L2_PIX_FMT_SBGGR16};
139
140 /* Raw YUV formats */
141 static const u32 isif_raw_yuv_pix_formats[] = {
142 V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_YUYV};
143
144 /* register access routines */
145 static inline u32 regr(u32 offset)
146 {
147 return __raw_readl(isif_cfg.base_addr + offset);
148 }
149
150 static inline void regw(u32 val, u32 offset)
151 {
152 __raw_writel(val, isif_cfg.base_addr + offset);
153 }
154
155 /* reg_modify() - read, modify and write register */
156 static inline u32 reg_modify(u32 mask, u32 val, u32 offset)
157 {
158 u32 new_val = (regr(offset) & ~mask) | (val & mask);
159
160 regw(new_val, offset);
161 return new_val;
162 }
163
164 static inline void regw_lin_tbl(u32 val, u32 offset, int i)
165 {
166 if (!i)
167 __raw_writel(val, isif_cfg.linear_tbl0_addr + offset);
168 else
169 __raw_writel(val, isif_cfg.linear_tbl1_addr + offset);
170 }
171
172 static void isif_disable_all_modules(void)
173 {
174 /* disable BC */
175 regw(0, CLAMPCFG);
176 /* disable vdfc */
177 regw(0, DFCCTL);
178 /* disable CSC */
179 regw(0, CSCCTL);
180 /* disable linearization */
181 regw(0, LINCFG0);
182 /* disable other modules here as they are supported */
183 }
184
185 static void isif_enable(int en)
186 {
187 if (!en) {
188 /* Before disable isif, disable all ISIF modules */
189 isif_disable_all_modules();
190 /*
191 * wait for next VD. Assume lowest scan rate is 12 Hz. So
192 * 100 msec delay is good enough
193 */
194 msleep(100);
195 }
196 reg_modify(ISIF_SYNCEN_VDHDEN_MASK, en, SYNCEN);
197 }
198
199 static void isif_enable_output_to_sdram(int en)
200 {
201 reg_modify(ISIF_SYNCEN_WEN_MASK, en << ISIF_SYNCEN_WEN_SHIFT, SYNCEN);
202 }
203
204 static void isif_config_culling(struct isif_cul *cul)
205 {
206 u32 val;
207
208 /* Horizontal pattern */
209 val = (cul->hcpat_even << CULL_PAT_EVEN_LINE_SHIFT) | cul->hcpat_odd;
210 regw(val, CULH);
211
212 /* vertical pattern */
213 regw(cul->vcpat, CULV);
214
215 /* LPF */
216 reg_modify(ISIF_LPF_MASK << ISIF_LPF_SHIFT,
217 cul->en_lpf << ISIF_LPF_SHIFT, MODESET);
218 }
219
220 static void isif_config_gain_offset(void)
221 {
222 struct isif_gain_offsets_adj *gain_off_p =
223 &isif_cfg.bayer.config_params.gain_offset;
224 u32 val;
225
226 val = (!!gain_off_p->gain_sdram_en << GAIN_SDRAM_EN_SHIFT) |
227 (!!gain_off_p->gain_ipipe_en << GAIN_IPIPE_EN_SHIFT) |
228 (!!gain_off_p->gain_h3a_en << GAIN_H3A_EN_SHIFT) |
229 (!!gain_off_p->offset_sdram_en << OFST_SDRAM_EN_SHIFT) |
230 (!!gain_off_p->offset_ipipe_en << OFST_IPIPE_EN_SHIFT) |
231 (!!gain_off_p->offset_h3a_en << OFST_H3A_EN_SHIFT);
232
233 reg_modify(GAIN_OFFSET_EN_MASK, val, CGAMMAWD);
234
235 val = (gain_off_p->gain.r_ye.integer << GAIN_INTEGER_SHIFT) |
236 gain_off_p->gain.r_ye.decimal;
237 regw(val, CRGAIN);
238
239 val = (gain_off_p->gain.gr_cy.integer << GAIN_INTEGER_SHIFT) |
240 gain_off_p->gain.gr_cy.decimal;
241 regw(val, CGRGAIN);
242
243 val = (gain_off_p->gain.gb_g.integer << GAIN_INTEGER_SHIFT) |
244 gain_off_p->gain.gb_g.decimal;
245 regw(val, CGBGAIN);
246
247 val = (gain_off_p->gain.b_mg.integer << GAIN_INTEGER_SHIFT) |
248 gain_off_p->gain.b_mg.decimal;
249 regw(val, CBGAIN);
250
251 regw(gain_off_p->offset, COFSTA);
252 }
253
254 static void isif_restore_defaults(void)
255 {
256 enum vpss_ccdc_source_sel source = VPSS_CCDCIN;
257
258 dev_dbg(isif_cfg.dev, "\nstarting isif_restore_defaults...");
259 isif_cfg.bayer.config_params = isif_config_defaults;
260 /* Enable clock to ISIF, IPIPEIF and BL */
261 vpss_enable_clock(VPSS_CCDC_CLOCK, 1);
262 vpss_enable_clock(VPSS_IPIPEIF_CLOCK, 1);
263 vpss_enable_clock(VPSS_BL_CLOCK, 1);
264 /* Set default offset and gain */
265 isif_config_gain_offset();
266 vpss_select_ccdc_source(source);
267 dev_dbg(isif_cfg.dev, "\nEnd of isif_restore_defaults...");
268 }
269
270 static int isif_open(struct device *device)
271 {
272 isif_restore_defaults();
273 return 0;
274 }
275
276 /* This function will configure the window size to be capture in ISIF reg */
277 static void isif_setwin(struct v4l2_rect *image_win,
278 enum ccdc_frmfmt frm_fmt, int ppc)
279 {
280 int horz_start, horz_nr_pixels;
281 int vert_start, vert_nr_lines;
282 int mid_img = 0;
283
284 dev_dbg(isif_cfg.dev, "\nStarting isif_setwin...");
285 /*
286 * ppc - per pixel count. indicates how many pixels per cell
287 * output to SDRAM. example, for ycbcr, it is one y and one c, so 2.
288 * raw capture this is 1
289 */
290 horz_start = image_win->left << (ppc - 1);
291 horz_nr_pixels = ((image_win->width) << (ppc - 1)) - 1;
292
293 /* Writing the horizontal info into the registers */
294 regw(horz_start & START_PX_HOR_MASK, SPH);
295 regw(horz_nr_pixels & NUM_PX_HOR_MASK, LNH);
296 vert_start = image_win->top;
297
298 if (frm_fmt == CCDC_FRMFMT_INTERLACED) {
299 vert_nr_lines = (image_win->height >> 1) - 1;
300 vert_start >>= 1;
301 /* To account for VD since line 0 doesn't have any data */
302 vert_start += 1;
303 } else {
304 /* To account for VD since line 0 doesn't have any data */
305 vert_start += 1;
306 vert_nr_lines = image_win->height - 1;
307 /* configure VDINT0 and VDINT1 */
308 mid_img = vert_start + (image_win->height / 2);
309 regw(mid_img, VDINT1);
310 }
311
312 regw(0, VDINT0);
313 regw(vert_start & START_VER_ONE_MASK, SLV0);
314 regw(vert_start & START_VER_TWO_MASK, SLV1);
315 regw(vert_nr_lines & NUM_LINES_VER, LNV);
316 }
317
318 static void isif_config_bclamp(struct isif_black_clamp *bc)
319 {
320 u32 val;
321
322 /*
323 * DC Offset is always added to image data irrespective of bc enable
324 * status
325 */
326 regw(bc->dc_offset, CLDCOFST);
327
328 if (bc->en) {
329 val = bc->bc_mode_color << ISIF_BC_MODE_COLOR_SHIFT;
330
331 /* Enable BC and horizontal clamp caculation paramaters */
332 val = val | 1 | (bc->horz.mode << ISIF_HORZ_BC_MODE_SHIFT);
333
334 regw(val, CLAMPCFG);
335
336 if (bc->horz.mode != ISIF_HORZ_BC_DISABLE) {
337 /*
338 * Window count for calculation
339 * Base window selection
340 * pixel limit
341 * Horizontal size of window
342 * vertical size of the window
343 * Horizontal start position of the window
344 * Vertical start position of the window
345 */
346 val = bc->horz.win_count_calc |
347 ((!!bc->horz.base_win_sel_calc) <<
348 ISIF_HORZ_BC_WIN_SEL_SHIFT) |
349 ((!!bc->horz.clamp_pix_limit) <<
350 ISIF_HORZ_BC_PIX_LIMIT_SHIFT) |
351 (bc->horz.win_h_sz_calc <<
352 ISIF_HORZ_BC_WIN_H_SIZE_SHIFT) |
353 (bc->horz.win_v_sz_calc <<
354 ISIF_HORZ_BC_WIN_V_SIZE_SHIFT);
355 regw(val, CLHWIN0);
356
357 regw(bc->horz.win_start_h_calc, CLHWIN1);
358 regw(bc->horz.win_start_v_calc, CLHWIN2);
359 }
360
361 /* vertical clamp caculation paramaters */
362
363 /* Reset clamp value sel for previous line */
364 val |=
365 (bc->vert.reset_val_sel << ISIF_VERT_BC_RST_VAL_SEL_SHIFT) |
366 (bc->vert.line_ave_coef << ISIF_VERT_BC_LINE_AVE_COEF_SHIFT);
367 regw(val, CLVWIN0);
368
369 /* Optical Black horizontal start position */
370 regw(bc->vert.ob_start_h, CLVWIN1);
371 /* Optical Black vertical start position */
372 regw(bc->vert.ob_start_v, CLVWIN2);
373 /* Optical Black vertical size for calculation */
374 regw(bc->vert.ob_v_sz_calc, CLVWIN3);
375 /* Vertical start position for BC subtraction */
376 regw(bc->vert_start_sub, CLSV);
377 }
378 }
379
380 static void isif_config_linearization(struct isif_linearize *linearize)
381 {
382 u32 val, i;
383
384 if (!linearize->en) {
385 regw(0, LINCFG0);
386 return;
387 }
388
389 /* shift value for correction & enable linearization (set lsb) */
390 val = (linearize->corr_shft << ISIF_LIN_CORRSFT_SHIFT) | 1;
391 regw(val, LINCFG0);
392
393 /* Scale factor */
394 val = ((!!linearize->scale_fact.integer) <<
395 ISIF_LIN_SCALE_FACT_INTEG_SHIFT) |
396 linearize->scale_fact.decimal;
397 regw(val, LINCFG1);
398
399 for (i = 0; i < ISIF_LINEAR_TAB_SIZE; i++) {
400 if (i % 2)
401 regw_lin_tbl(linearize->table[i], ((i >> 1) << 2), 1);
402 else
403 regw_lin_tbl(linearize->table[i], ((i >> 1) << 2), 0);
404 }
405 }
406
407 static int isif_config_dfc(struct isif_dfc *vdfc)
408 {
409 /* initialize retries to loop for max ~ 250 usec */
410 u32 val, count, retries = loops_per_jiffy / (4000/HZ);
411 int i;
412
413 if (!vdfc->en)
414 return 0;
415
416 /* Correction mode */
417 val = (vdfc->corr_mode << ISIF_VDFC_CORR_MOD_SHIFT);
418
419 /* Correct whole line or partial */
420 if (vdfc->corr_whole_line)
421 val |= 1 << ISIF_VDFC_CORR_WHOLE_LN_SHIFT;
422
423 /* level shift value */
424 val |= vdfc->def_level_shift << ISIF_VDFC_LEVEL_SHFT_SHIFT;
425
426 regw(val, DFCCTL);
427
428 /* Defect saturation level */
429 regw(vdfc->def_sat_level, VDFSATLV);
430
431 regw(vdfc->table[0].pos_vert, DFCMEM0);
432 regw(vdfc->table[0].pos_horz, DFCMEM1);
433 if (vdfc->corr_mode == ISIF_VDFC_NORMAL ||
434 vdfc->corr_mode == ISIF_VDFC_HORZ_INTERPOL_IF_SAT) {
435 regw(vdfc->table[0].level_at_pos, DFCMEM2);
436 regw(vdfc->table[0].level_up_pixels, DFCMEM3);
437 regw(vdfc->table[0].level_low_pixels, DFCMEM4);
438 }
439
440 /* set DFCMARST and set DFCMWR */
441 val = regr(DFCMEMCTL) | (1 << ISIF_DFCMEMCTL_DFCMARST_SHIFT) | 1;
442 regw(val, DFCMEMCTL);
443
444 count = retries;
445 while (count && (regr(DFCMEMCTL) & 0x1))
446 count--;
447
448 if (!count) {
449 dev_dbg(isif_cfg.dev, "defect table write timeout !!!\n");
450 return -1;
451 }
452
453 for (i = 1; i < vdfc->num_vdefects; i++) {
454 regw(vdfc->table[i].pos_vert, DFCMEM0);
455 regw(vdfc->table[i].pos_horz, DFCMEM1);
456 if (vdfc->corr_mode == ISIF_VDFC_NORMAL ||
457 vdfc->corr_mode == ISIF_VDFC_HORZ_INTERPOL_IF_SAT) {
458 regw(vdfc->table[i].level_at_pos, DFCMEM2);
459 regw(vdfc->table[i].level_up_pixels, DFCMEM3);
460 regw(vdfc->table[i].level_low_pixels, DFCMEM4);
461 }
462 val = regr(DFCMEMCTL);
463 /* clear DFCMARST and set DFCMWR */
464 val &= ~BIT(ISIF_DFCMEMCTL_DFCMARST_SHIFT);
465 val |= 1;
466 regw(val, DFCMEMCTL);
467
468 count = retries;
469 while (count && (regr(DFCMEMCTL) & 0x1))
470 count--;
471
472 if (!count) {
473 dev_err(isif_cfg.dev,
474 "defect table write timeout !!!\n");
475 return -1;
476 }
477 }
478 if (vdfc->num_vdefects < ISIF_VDFC_TABLE_SIZE) {
479 /* Extra cycle needed */
480 regw(0, DFCMEM0);
481 regw(0x1FFF, DFCMEM1);
482 regw(1, DFCMEMCTL);
483 }
484
485 /* enable VDFC */
486 reg_modify((1 << ISIF_VDFC_EN_SHIFT), (1 << ISIF_VDFC_EN_SHIFT),
487 DFCCTL);
488 return 0;
489 }
490
491 static void isif_config_csc(struct isif_df_csc *df_csc)
492 {
493 u32 val1 = 0, val2 = 0, i;
494
495 if (!df_csc->csc.en) {
496 regw(0, CSCCTL);
497 return;
498 }
499 for (i = 0; i < ISIF_CSC_NUM_COEFF; i++) {
500 if ((i % 2) == 0) {
501 /* CSCM - LSB */
502 val1 = (df_csc->csc.coeff[i].integer <<
503 ISIF_CSC_COEF_INTEG_SHIFT) |
504 df_csc->csc.coeff[i].decimal;
505 } else {
506
507 /* CSCM - MSB */
508 val2 = (df_csc->csc.coeff[i].integer <<
509 ISIF_CSC_COEF_INTEG_SHIFT) |
510 df_csc->csc.coeff[i].decimal;
511 val2 <<= ISIF_CSCM_MSB_SHIFT;
512 val2 |= val1;
513 regw(val2, (CSCM0 + ((i - 1) << 1)));
514 }
515 }
516
517 /* program the active area */
518 regw(df_csc->start_pix, FMTSPH);
519 /*
520 * one extra pixel as required for CSC. Actually number of
521 * pixel - 1 should be configured in this register. So we
522 * need to subtract 1 before writing to FMTSPH, but we will
523 * not do this since csc requires one extra pixel
524 */
525 regw(df_csc->num_pixels, FMTLNH);
526 regw(df_csc->start_line, FMTSLV);
527 /*
528 * one extra line as required for CSC. See reason documented for
529 * num_pixels
530 */
531 regw(df_csc->num_lines, FMTLNV);
532
533 /* Enable CSC */
534 regw(1, CSCCTL);
535 }
536
537 static int isif_config_raw(void)
538 {
539 struct isif_params_raw *params = &isif_cfg.bayer;
540 struct isif_config_params_raw *module_params =
541 &isif_cfg.bayer.config_params;
542 struct vpss_pg_frame_size frame_size;
543 struct vpss_sync_pol sync;
544 u32 val;
545
546 dev_dbg(isif_cfg.dev, "\nStarting isif_config_raw..\n");
547
548 /*
549 * Configure CCDCFG register:-
550 * Set CCD Not to swap input since input is RAW data
551 * Set FID detection function to Latch at V-Sync
552 * Set WENLOG - isif valid area
553 * Set TRGSEL
554 * Set EXTRG
555 * Packed to 8 or 16 bits
556 */
557
558 val = ISIF_YCINSWP_RAW | ISIF_CCDCFG_FIDMD_LATCH_VSYNC |
559 ISIF_CCDCFG_WENLOG_AND | ISIF_CCDCFG_TRGSEL_WEN |
560 ISIF_CCDCFG_EXTRG_DISABLE | isif_cfg.data_pack;
561
562 dev_dbg(isif_cfg.dev, "Writing 0x%x to ...CCDCFG \n", val);
563 regw(val, CCDCFG);
564
565 /*
566 * Configure the vertical sync polarity(MODESET.VDPOL)
567 * Configure the horizontal sync polarity (MODESET.HDPOL)
568 * Configure frame id polarity (MODESET.FLDPOL)
569 * Configure data polarity
570 * Configure External WEN Selection
571 * Configure frame format(progressive or interlace)
572 * Configure pixel format (Input mode)
573 * Configure the data shift
574 */
575
576 val = ISIF_VDHDOUT_INPUT | (params->vd_pol << ISIF_VD_POL_SHIFT) |
577 (params->hd_pol << ISIF_HD_POL_SHIFT) |
578 (params->fid_pol << ISIF_FID_POL_SHIFT) |
579 (ISIF_DATAPOL_NORMAL << ISIF_DATAPOL_SHIFT) |
580 (ISIF_EXWEN_DISABLE << ISIF_EXWEN_SHIFT) |
581 (params->frm_fmt << ISIF_FRM_FMT_SHIFT) |
582 (params->pix_fmt << ISIF_INPUT_SHIFT) |
583 (params->config_params.data_shift << ISIF_DATASFT_SHIFT);
584
585 regw(val, MODESET);
586 dev_dbg(isif_cfg.dev, "Writing 0x%x to MODESET...\n", val);
587
588 /*
589 * Configure GAMMAWD register
590 * CFA pattern setting
591 */
592 val = params->cfa_pat << ISIF_GAMMAWD_CFA_SHIFT;
593
594 /* Gamma msb */
595 if (module_params->compress.alg == ISIF_ALAW)
596 val |= ISIF_ALAW_ENABLE;
597
598 val |= (params->data_msb << ISIF_ALAW_GAMMA_WD_SHIFT);
599 regw(val, CGAMMAWD);
600
601 /* Configure DPCM compression settings */
602 if (module_params->compress.alg == ISIF_DPCM) {
603 val = BIT(ISIF_DPCM_EN_SHIFT) |
604 (module_params->compress.pred <<
605 ISIF_DPCM_PREDICTOR_SHIFT);
606 }
607
608 regw(val, MISC);
609
610 /* Configure Gain & Offset */
611 isif_config_gain_offset();
612
613 /* Configure Color pattern */
614 val = (params->config_params.col_pat_field0.olop) |
615 (params->config_params.col_pat_field0.olep << 2) |
616 (params->config_params.col_pat_field0.elop << 4) |
617 (params->config_params.col_pat_field0.elep << 6) |
618 (params->config_params.col_pat_field1.olop << 8) |
619 (params->config_params.col_pat_field1.olep << 10) |
620 (params->config_params.col_pat_field1.elop << 12) |
621 (params->config_params.col_pat_field1.elep << 14);
622 regw(val, CCOLP);
623 dev_dbg(isif_cfg.dev, "Writing %x to CCOLP ...\n", val);
624
625 /* Configure HSIZE register */
626 val = (!!params->horz_flip_en) << ISIF_HSIZE_FLIP_SHIFT;
627
628 /* calculate line offset in 32 bytes based on pack value */
629 if (isif_cfg.data_pack == ISIF_PACK_8BIT)
630 val |= ((params->win.width + 31) >> 5);
631 else if (isif_cfg.data_pack == ISIF_PACK_12BIT)
632 val |= (((params->win.width +
633 (params->win.width >> 2)) + 31) >> 5);
634 else
635 val |= (((params->win.width * 2) + 31) >> 5);
636 regw(val, HSIZE);
637
638 /* Configure SDOFST register */
639 if (params->frm_fmt == CCDC_FRMFMT_INTERLACED) {
640 if (params->image_invert_en) {
641 /* For interlace inverse mode */
642 regw(0x4B6D, SDOFST);
643 dev_dbg(isif_cfg.dev, "Writing 0x4B6D to SDOFST...\n");
644 } else {
645 /* For interlace non inverse mode */
646 regw(0x0B6D, SDOFST);
647 dev_dbg(isif_cfg.dev, "Writing 0x0B6D to SDOFST...\n");
648 }
649 } else if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE) {
650 if (params->image_invert_en) {
651 /* For progressive inverse mode */
652 regw(0x4000, SDOFST);
653 dev_dbg(isif_cfg.dev, "Writing 0x4000 to SDOFST...\n");
654 } else {
655 /* For progressive non inverse mode */
656 regw(0x0000, SDOFST);
657 dev_dbg(isif_cfg.dev, "Writing 0x0000 to SDOFST...\n");
658 }
659 }
660
661 /* Configure video window */
662 isif_setwin(&params->win, params->frm_fmt, 1);
663
664 /* Configure Black Clamp */
665 isif_config_bclamp(&module_params->bclamp);
666
667 /* Configure Vertical Defection Pixel Correction */
668 if (isif_config_dfc(&module_params->dfc) < 0)
669 return -EFAULT;
670
671 if (!module_params->df_csc.df_or_csc)
672 /* Configure Color Space Conversion */
673 isif_config_csc(&module_params->df_csc);
674
675 isif_config_linearization(&module_params->linearize);
676
677 /* Configure Culling */
678 isif_config_culling(&module_params->culling);
679
680 /* Configure horizontal and vertical offsets(DFC,LSC,Gain) */
681 regw(module_params->horz_offset, DATAHOFST);
682 regw(module_params->vert_offset, DATAVOFST);
683
684 /* Setup test pattern if enabled */
685 if (params->config_params.test_pat_gen) {
686 /* Use the HD/VD pol settings from user */
687 sync.ccdpg_hdpol = params->hd_pol;
688 sync.ccdpg_vdpol = params->vd_pol;
689 dm365_vpss_set_sync_pol(sync);
690 frame_size.hlpfr = isif_cfg.bayer.win.width;
691 frame_size.pplen = isif_cfg.bayer.win.height;
692 dm365_vpss_set_pg_frame_size(frame_size);
693 vpss_select_ccdc_source(VPSS_PGLPBK);
694 }
695
696 dev_dbg(isif_cfg.dev, "\nEnd of isif_config_ycbcr...\n");
697 return 0;
698 }
699
700 static int isif_set_buftype(enum ccdc_buftype buf_type)
701 {
702 if (isif_cfg.if_type == VPFE_RAW_BAYER)
703 isif_cfg.bayer.buf_type = buf_type;
704 else
705 isif_cfg.ycbcr.buf_type = buf_type;
706
707 return 0;
708
709 }
710 static enum ccdc_buftype isif_get_buftype(void)
711 {
712 if (isif_cfg.if_type == VPFE_RAW_BAYER)
713 return isif_cfg.bayer.buf_type;
714
715 return isif_cfg.ycbcr.buf_type;
716 }
717
718 static int isif_enum_pix(u32 *pix, int i)
719 {
720 int ret = -EINVAL;
721
722 if (isif_cfg.if_type == VPFE_RAW_BAYER) {
723 if (i < ARRAY_SIZE(isif_raw_bayer_pix_formats)) {
724 *pix = isif_raw_bayer_pix_formats[i];
725 ret = 0;
726 }
727 } else {
728 if (i < ARRAY_SIZE(isif_raw_yuv_pix_formats)) {
729 *pix = isif_raw_yuv_pix_formats[i];
730 ret = 0;
731 }
732 }
733
734 return ret;
735 }
736
737 static int isif_set_pixel_format(unsigned int pixfmt)
738 {
739 if (isif_cfg.if_type == VPFE_RAW_BAYER) {
740 if (pixfmt == V4L2_PIX_FMT_SBGGR8) {
741 if ((isif_cfg.bayer.config_params.compress.alg !=
742 ISIF_ALAW) &&
743 (isif_cfg.bayer.config_params.compress.alg !=
744 ISIF_DPCM)) {
745 dev_dbg(isif_cfg.dev,
746 "Either configure A-Law or DPCM\n");
747 return -EINVAL;
748 }
749 isif_cfg.data_pack = ISIF_PACK_8BIT;
750 } else if (pixfmt == V4L2_PIX_FMT_SBGGR16) {
751 isif_cfg.bayer.config_params.compress.alg =
752 ISIF_NO_COMPRESSION;
753 isif_cfg.data_pack = ISIF_PACK_16BIT;
754 } else
755 return -EINVAL;
756 isif_cfg.bayer.pix_fmt = CCDC_PIXFMT_RAW;
757 } else {
758 if (pixfmt == V4L2_PIX_FMT_YUYV)
759 isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
760 else if (pixfmt == V4L2_PIX_FMT_UYVY)
761 isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
762 else
763 return -EINVAL;
764 isif_cfg.data_pack = ISIF_PACK_8BIT;
765 }
766 return 0;
767 }
768
769 static u32 isif_get_pixel_format(void)
770 {
771 u32 pixfmt;
772
773 if (isif_cfg.if_type == VPFE_RAW_BAYER)
774 if (isif_cfg.bayer.config_params.compress.alg == ISIF_ALAW ||
775 isif_cfg.bayer.config_params.compress.alg == ISIF_DPCM)
776 pixfmt = V4L2_PIX_FMT_SBGGR8;
777 else
778 pixfmt = V4L2_PIX_FMT_SBGGR16;
779 else {
780 if (isif_cfg.ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
781 pixfmt = V4L2_PIX_FMT_YUYV;
782 else
783 pixfmt = V4L2_PIX_FMT_UYVY;
784 }
785 return pixfmt;
786 }
787
788 static int isif_set_image_window(struct v4l2_rect *win)
789 {
790 if (isif_cfg.if_type == VPFE_RAW_BAYER) {
791 isif_cfg.bayer.win.top = win->top;
792 isif_cfg.bayer.win.left = win->left;
793 isif_cfg.bayer.win.width = win->width;
794 isif_cfg.bayer.win.height = win->height;
795 } else {
796 isif_cfg.ycbcr.win.top = win->top;
797 isif_cfg.ycbcr.win.left = win->left;
798 isif_cfg.ycbcr.win.width = win->width;
799 isif_cfg.ycbcr.win.height = win->height;
800 }
801 return 0;
802 }
803
804 static void isif_get_image_window(struct v4l2_rect *win)
805 {
806 if (isif_cfg.if_type == VPFE_RAW_BAYER)
807 *win = isif_cfg.bayer.win;
808 else
809 *win = isif_cfg.ycbcr.win;
810 }
811
812 static unsigned int isif_get_line_length(void)
813 {
814 unsigned int len;
815
816 if (isif_cfg.if_type == VPFE_RAW_BAYER) {
817 if (isif_cfg.data_pack == ISIF_PACK_8BIT)
818 len = ((isif_cfg.bayer.win.width));
819 else if (isif_cfg.data_pack == ISIF_PACK_12BIT)
820 len = (((isif_cfg.bayer.win.width * 2) +
821 (isif_cfg.bayer.win.width >> 2)));
822 else
823 len = (((isif_cfg.bayer.win.width * 2)));
824 } else
825 len = (((isif_cfg.ycbcr.win.width * 2)));
826 return ALIGN(len, 32);
827 }
828
829 static int isif_set_frame_format(enum ccdc_frmfmt frm_fmt)
830 {
831 if (isif_cfg.if_type == VPFE_RAW_BAYER)
832 isif_cfg.bayer.frm_fmt = frm_fmt;
833 else
834 isif_cfg.ycbcr.frm_fmt = frm_fmt;
835 return 0;
836 }
837 static enum ccdc_frmfmt isif_get_frame_format(void)
838 {
839 if (isif_cfg.if_type == VPFE_RAW_BAYER)
840 return isif_cfg.bayer.frm_fmt;
841 return isif_cfg.ycbcr.frm_fmt;
842 }
843
844 static int isif_getfid(void)
845 {
846 return (regr(MODESET) >> 15) & 0x1;
847 }
848
849 /* misc operations */
850 static void isif_setfbaddr(unsigned long addr)
851 {
852 regw((addr >> 21) & 0x07ff, CADU);
853 regw((addr >> 5) & 0x0ffff, CADL);
854 }
855
856 static int isif_set_hw_if_params(struct vpfe_hw_if_param *params)
857 {
858 isif_cfg.if_type = params->if_type;
859
860 switch (params->if_type) {
861 case VPFE_BT656:
862 case VPFE_BT656_10BIT:
863 case VPFE_YCBCR_SYNC_8:
864 isif_cfg.ycbcr.pix_fmt = CCDC_PIXFMT_YCBCR_8BIT;
865 isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
866 break;
867 case VPFE_BT1120:
868 case VPFE_YCBCR_SYNC_16:
869 isif_cfg.ycbcr.pix_fmt = CCDC_PIXFMT_YCBCR_16BIT;
870 isif_cfg.ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
871 break;
872 case VPFE_RAW_BAYER:
873 isif_cfg.bayer.pix_fmt = CCDC_PIXFMT_RAW;
874 break;
875 default:
876 dev_dbg(isif_cfg.dev, "Invalid interface type\n");
877 return -EINVAL;
878 }
879
880 return 0;
881 }
882
883 /* This function will configure ISIF for YCbCr parameters. */
884 static int isif_config_ycbcr(void)
885 {
886 struct isif_ycbcr_config *params = &isif_cfg.ycbcr;
887 struct vpss_pg_frame_size frame_size;
888 u32 modeset = 0, ccdcfg = 0;
889 struct vpss_sync_pol sync;
890
891 dev_dbg(isif_cfg.dev, "\nStarting isif_config_ycbcr...");
892
893 /* configure pixel format or input mode */
894 modeset = modeset | (params->pix_fmt << ISIF_INPUT_SHIFT) |
895 (params->frm_fmt << ISIF_FRM_FMT_SHIFT) |
896 (params->fid_pol << ISIF_FID_POL_SHIFT) |
897 (params->hd_pol << ISIF_HD_POL_SHIFT) |
898 (params->vd_pol << ISIF_VD_POL_SHIFT);
899
900 /* pack the data to 8-bit ISIFCFG */
901 switch (isif_cfg.if_type) {
902 case VPFE_BT656:
903 if (params->pix_fmt != CCDC_PIXFMT_YCBCR_8BIT) {
904 dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
905 return -EINVAL;
906 }
907 modeset |= (VPFE_PINPOL_NEGATIVE << ISIF_VD_POL_SHIFT);
908 regw(3, REC656IF);
909 ccdcfg = ccdcfg | ISIF_DATA_PACK8 | ISIF_YCINSWP_YCBCR;
910 break;
911 case VPFE_BT656_10BIT:
912 if (params->pix_fmt != CCDC_PIXFMT_YCBCR_8BIT) {
913 dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
914 return -EINVAL;
915 }
916 /* setup BT.656, embedded sync */
917 regw(3, REC656IF);
918 /* enable 10 bit mode in ccdcfg */
919 ccdcfg = ccdcfg | ISIF_DATA_PACK8 | ISIF_YCINSWP_YCBCR |
920 ISIF_BW656_ENABLE;
921 break;
922 case VPFE_BT1120:
923 if (params->pix_fmt != CCDC_PIXFMT_YCBCR_16BIT) {
924 dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
925 return -EINVAL;
926 }
927 regw(3, REC656IF);
928 break;
929
930 case VPFE_YCBCR_SYNC_8:
931 ccdcfg |= ISIF_DATA_PACK8;
932 ccdcfg |= ISIF_YCINSWP_YCBCR;
933 if (params->pix_fmt != CCDC_PIXFMT_YCBCR_8BIT) {
934 dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
935 return -EINVAL;
936 }
937 break;
938 case VPFE_YCBCR_SYNC_16:
939 if (params->pix_fmt != CCDC_PIXFMT_YCBCR_16BIT) {
940 dev_dbg(isif_cfg.dev, "Invalid pix_fmt(input mode)\n");
941 return -EINVAL;
942 }
943 break;
944 default:
945 /* should never come here */
946 dev_dbg(isif_cfg.dev, "Invalid interface type\n");
947 return -EINVAL;
948 }
949
950 regw(modeset, MODESET);
951
952 /* Set up pix order */
953 ccdcfg |= params->pix_order << ISIF_PIX_ORDER_SHIFT;
954
955 regw(ccdcfg, CCDCFG);
956
957 /* configure video window */
958 if ((isif_cfg.if_type == VPFE_BT1120) ||
959 (isif_cfg.if_type == VPFE_YCBCR_SYNC_16))
960 isif_setwin(&params->win, params->frm_fmt, 1);
961 else
962 isif_setwin(&params->win, params->frm_fmt, 2);
963
964 /*
965 * configure the horizontal line offset
966 * this is done by rounding up width to a multiple of 16 pixels
967 * and multiply by two to account for y:cb:cr 4:2:2 data
968 */
969 regw(((((params->win.width * 2) + 31) & 0xffffffe0) >> 5), HSIZE);
970
971 /* configure the memory line offset */
972 if ((params->frm_fmt == CCDC_FRMFMT_INTERLACED) &&
973 (params->buf_type == CCDC_BUFTYPE_FLD_INTERLEAVED))
974 /* two fields are interleaved in memory */
975 regw(0x00000249, SDOFST);
976
977 /* Setup test pattern if enabled */
978 if (isif_cfg.bayer.config_params.test_pat_gen) {
979 sync.ccdpg_hdpol = params->hd_pol;
980 sync.ccdpg_vdpol = params->vd_pol;
981 dm365_vpss_set_sync_pol(sync);
982 dm365_vpss_set_pg_frame_size(frame_size);
983 }
984 return 0;
985 }
986
987 static int isif_configure(void)
988 {
989 if (isif_cfg.if_type == VPFE_RAW_BAYER)
990 return isif_config_raw();
991 return isif_config_ycbcr();
992 }
993
994 static int isif_close(struct device *device)
995 {
996 /* copy defaults to module params */
997 isif_cfg.bayer.config_params = isif_config_defaults;
998 return 0;
999 }
1000
1001 static const struct ccdc_hw_device isif_hw_dev = {
1002 .name = "ISIF",
1003 .owner = THIS_MODULE,
1004 .hw_ops = {
1005 .open = isif_open,
1006 .close = isif_close,
1007 .enable = isif_enable,
1008 .enable_out_to_sdram = isif_enable_output_to_sdram,
1009 .set_hw_if_params = isif_set_hw_if_params,
1010 .configure = isif_configure,
1011 .set_buftype = isif_set_buftype,
1012 .get_buftype = isif_get_buftype,
1013 .enum_pix = isif_enum_pix,
1014 .set_pixel_format = isif_set_pixel_format,
1015 .get_pixel_format = isif_get_pixel_format,
1016 .set_frame_format = isif_set_frame_format,
1017 .get_frame_format = isif_get_frame_format,
1018 .set_image_window = isif_set_image_window,
1019 .get_image_window = isif_get_image_window,
1020 .get_line_length = isif_get_line_length,
1021 .setfbaddr = isif_setfbaddr,
1022 .getfid = isif_getfid,
1023 },
1024 };
1025
1026 static int isif_probe(struct platform_device *pdev)
1027 {
1028 void (*setup_pinmux)(void);
1029 struct resource *res;
1030 void __iomem *addr;
1031 int status = 0, i;
1032
1033 /* Platform data holds setup_pinmux function ptr */
1034 if (!pdev->dev.platform_data)
1035 return -ENODEV;
1036
1037 /*
1038 * first try to register with vpfe. If not correct platform, then we
1039 * don't have to iomap
1040 */
1041 status = vpfe_register_ccdc_device(&isif_hw_dev);
1042 if (status < 0)
1043 return status;
1044
1045 setup_pinmux = pdev->dev.platform_data;
1046 /*
1047 * setup Mux configuration for ccdc which may be different for
1048 * different SoCs using this CCDC
1049 */
1050 setup_pinmux();
1051
1052 i = 0;
1053 /* Get the ISIF base address, linearization table0 and table1 addr. */
1054 while (i < 3) {
1055 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
1056 if (!res) {
1057 status = -ENODEV;
1058 goto fail_nobase_res;
1059 }
1060 res = request_mem_region(res->start, resource_size(res),
1061 res->name);
1062 if (!res) {
1063 status = -EBUSY;
1064 goto fail_nobase_res;
1065 }
1066 addr = ioremap_nocache(res->start, resource_size(res));
1067 if (!addr) {
1068 status = -ENOMEM;
1069 goto fail_base_iomap;
1070 }
1071 switch (i) {
1072 case 0:
1073 /* ISIF base address */
1074 isif_cfg.base_addr = addr;
1075 break;
1076 case 1:
1077 /* ISIF linear tbl0 address */
1078 isif_cfg.linear_tbl0_addr = addr;
1079 break;
1080 default:
1081 /* ISIF linear tbl0 address */
1082 isif_cfg.linear_tbl1_addr = addr;
1083 break;
1084 }
1085 i++;
1086 }
1087 isif_cfg.dev = &pdev->dev;
1088
1089 printk(KERN_NOTICE "%s is registered with vpfe.\n",
1090 isif_hw_dev.name);
1091 return 0;
1092 fail_base_iomap:
1093 release_mem_region(res->start, resource_size(res));
1094 i--;
1095 fail_nobase_res:
1096 if (isif_cfg.base_addr)
1097 iounmap(isif_cfg.base_addr);
1098 if (isif_cfg.linear_tbl0_addr)
1099 iounmap(isif_cfg.linear_tbl0_addr);
1100
1101 while (i >= 0) {
1102 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
1103 release_mem_region(res->start, resource_size(res));
1104 i--;
1105 }
1106 vpfe_unregister_ccdc_device(&isif_hw_dev);
1107 return status;
1108 }
1109
1110 static int isif_remove(struct platform_device *pdev)
1111 {
1112 struct resource *res;
1113 int i = 0;
1114
1115 iounmap(isif_cfg.base_addr);
1116 iounmap(isif_cfg.linear_tbl0_addr);
1117 iounmap(isif_cfg.linear_tbl1_addr);
1118 while (i < 3) {
1119 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
1120 if (res)
1121 release_mem_region(res->start, resource_size(res));
1122 i++;
1123 }
1124 vpfe_unregister_ccdc_device(&isif_hw_dev);
1125 return 0;
1126 }
1127
1128 static struct platform_driver isif_driver = {
1129 .driver = {
1130 .name = "isif",
1131 },
1132 .remove = isif_remove,
1133 .probe = isif_probe,
1134 };
1135
1136 module_platform_driver(isif_driver);
1137
1138 MODULE_LICENSE("GPL");
Linux with added FPC-III support