drivers/media/video/davinci/isif.c

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