drivers/media/platform/mxc/capture/ipu_fg_overlay_sdc.c

   1 /*
   2  * Copyright 2004-2013 Freescale Semiconductor, Inc. All Rights Reserved.
   3  */
   4 /* * The code contained herein is licensed under the GNU General Public
   5  * License. You may obtain a copy of the GNU General Public License
   6  * Version 2 or later at the following locations:
   7  *
   8  * http://www.opensource.org/licenses/gpl-license.html
   9  * http://www.gnu.org/copyleft/gpl.html
  10  */
  11
  12 /*!
  13  * @file ipu_foreground_sdc.c
  14  *
  15  * @brief IPU Use case for PRP-VF
  16  *
  17  * @ingroup IPU
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/console.h>
  23 #include <linux/ipu.h>
  24 #include <linux/mxcfb.h>
  25 #include <linux/mipi_csi2.h>
  26
  27 #include "mxc_v4l2_capture.h"
  28 #include "ipu_prp_sw.h"
  29
  30 #ifdef CAMERA_DBG
  31         #define CAMERA_TRACE(x) (printk)x
  32 #else
  33         #define CAMERA_TRACE(x)
  34 #endif
  35
  36 static int csi_buffer_num, buffer_num;
  37 static u32 csi_mem_bufsize;
  38 static struct ipu_soc *disp_ipu;
  39 static struct fb_info *fbi;
  40 static struct fb_var_screeninfo fbvar;
  41 static u32 vf_out_format;
  42 static void csi_buf_work_func(struct work_struct *work)
  43 {
  44         int err = 0;
  45         cam_data *cam =
  46                 container_of(work, struct _cam_data, csi_work_struct);
  47
  48         struct ipu_task task;
  49         memset(&task, 0, sizeof(task));
  50
  51         if (csi_buffer_num)
  52                 task.input.paddr = cam->vf_bufs[0];
  53         else
  54                 task.input.paddr = cam->vf_bufs[1];
  55         task.input.width = cam->crop_current.width;
  56         task.input.height = cam->crop_current.height;
  57         task.input.format = IPU_PIX_FMT_NV12;
  58
  59         if (buffer_num == 0)
  60                 task.output.paddr = fbi->fix.smem_start +
  61                                 (fbi->fix.line_length * fbvar.yres);
  62         else
  63                 task.output.paddr = fbi->fix.smem_start;
  64         task.output.width = cam->win.w.width;
  65         task.output.height = cam->win.w.height;
  66         task.output.format = vf_out_format;
  67         task.output.rotate = cam->rotation;
  68 again:
  69         err = ipu_check_task(&task);
  70         if (err != IPU_CHECK_OK) {
  71                 if (err > IPU_CHECK_ERR_MIN) {
  72                         if (err == IPU_CHECK_ERR_SPLIT_INPUTW_OVER) {
  73                                 task.input.crop.w -= 8;
  74                                 goto again;
  75                         }
  76                         if (err == IPU_CHECK_ERR_SPLIT_INPUTH_OVER) {
  77                                 task.input.crop.h -= 8;
  78                                 goto again;
  79                         }
  80                         if (err == IPU_CHECK_ERR_SPLIT_OUTPUTW_OVER) {
  81                                         task.output.width -= 8;
  82                                         task.output.crop.w = task.output.width;
  83                                 goto again;
  84                         }
  85                         if (err == IPU_CHECK_ERR_SPLIT_OUTPUTH_OVER) {
  86                                         task.output.height -= 8;
  87                                         task.output.crop.h = task.output.height;
  88                                 goto again;
  89                         }
  90                         printk(KERN_ERR "check ipu taks fail\n");
  91                         return;
  92                 }
  93                 printk(KERN_ERR "check ipu taks fail\n");
  94                 return;
  95         }
  96         err = ipu_queue_task(&task);
  97         if (err < 0)
  98                 printk(KERN_ERR "queue ipu task error\n");
  99         ipu_select_buffer(disp_ipu, MEM_FG_SYNC, IPU_INPUT_BUFFER, buffer_num);
 100         buffer_num = (buffer_num == 0) ? 1 : 0;
 101 }
 102
 103 static void get_disp_ipu(cam_data *cam)
 104 {
 105         if (cam->output > 2)
 106                 disp_ipu = ipu_get_soc(1); /* using DISP4 */
 107         else
 108                 disp_ipu = ipu_get_soc(0);
 109 }
 110
 111 /*!
 112  * csi ENC callback function.
 113  *
 114  * @param irq       int irq line
 115  * @param dev_id    void * device id
 116  *
 117  * @return status   IRQ_HANDLED for handled
 118  */
 119 static irqreturn_t csi_enc_callback(int irq, void *dev_id)
 120 {
 121         cam_data *cam = (cam_data *) dev_id;
 122
 123         ipu_select_buffer(cam->ipu, CSI_MEM, IPU_OUTPUT_BUFFER, csi_buffer_num);
 124         if ((cam->crop_current.width != cam->win.w.width) ||
 125                 (cam->crop_current.height != cam->win.w.height) ||
 126                 (vf_out_format != IPU_PIX_FMT_NV12) ||
 127                 (cam->rotation >= IPU_ROTATE_VERT_FLIP))
 128                 schedule_work(&cam->csi_work_struct);
 129         csi_buffer_num = (csi_buffer_num == 0) ? 1 : 0;
 130         return IRQ_HANDLED;
 131 }
 132
 133 static int csi_enc_setup(cam_data *cam)
 134 {
 135         ipu_channel_params_t params;
 136         int err = 0, sensor_protocol = 0;
 137 #ifdef CONFIG_MXC_MIPI_CSI2
 138         void *mipi_csi2_info;
 139         int ipu_id;
 140         int csi_id;
 141 #endif
 142
 143         CAMERA_TRACE("In csi_enc_setup\n");
 144         if (!cam) {
 145                 printk(KERN_ERR "cam private is NULL\n");
 146                 return -ENXIO;
 147         }
 148
 149         memset(&params, 0, sizeof(ipu_channel_params_t));
 150         params.csi_mem.csi = cam->csi;
 151
 152         sensor_protocol = ipu_csi_get_sensor_protocol(cam->ipu, cam->csi);
 153         switch (sensor_protocol) {
 154         case IPU_CSI_CLK_MODE_GATED_CLK:
 155         case IPU_CSI_CLK_MODE_NONGATED_CLK:
 156         case IPU_CSI_CLK_MODE_CCIR656_PROGRESSIVE:
 157         case IPU_CSI_CLK_MODE_CCIR1120_PROGRESSIVE_DDR:
 158         case IPU_CSI_CLK_MODE_CCIR1120_PROGRESSIVE_SDR:
 159                 params.csi_mem.interlaced = false;
 160                 break;
 161         case IPU_CSI_CLK_MODE_CCIR656_INTERLACED:
 162         case IPU_CSI_CLK_MODE_CCIR1120_INTERLACED_DDR:
 163         case IPU_CSI_CLK_MODE_CCIR1120_INTERLACED_SDR:
 164                 params.csi_mem.interlaced = true;
 165                 break;
 166         default:
 167                 printk(KERN_ERR "sensor protocol unsupported\n");
 168                 return -EINVAL;
 169         }
 170
 171 #ifdef CONFIG_MXC_MIPI_CSI2
 172         mipi_csi2_info = mipi_csi2_get_info();
 173
 174         if (mipi_csi2_info) {
 175                 if (mipi_csi2_get_status(mipi_csi2_info)) {
 176                         ipu_id = mipi_csi2_get_bind_ipu(mipi_csi2_info);
 177                         csi_id = mipi_csi2_get_bind_csi(mipi_csi2_info);
 178
 179                         if (cam->ipu == ipu_get_soc(ipu_id)
 180                                 && cam->csi == csi_id) {
 181                                 params.csi_mem.mipi_en = true;
 182                                 params.csi_mem.mipi_vc =
 183                                 mipi_csi2_get_virtual_channel(mipi_csi2_info);
 184                                 params.csi_mem.mipi_id =
 185                                 mipi_csi2_get_datatype(mipi_csi2_info);
 186
 187                                 mipi_csi2_pixelclk_enable(mipi_csi2_info);
 188                         } else {
 189                                 params.csi_mem.mipi_en = false;
 190                                 params.csi_mem.mipi_vc = 0;
 191                                 params.csi_mem.mipi_id = 0;
 192                         }
 193                 } else {
 194                         params.csi_mem.mipi_en = false;
 195                         params.csi_mem.mipi_vc = 0;
 196                         params.csi_mem.mipi_id = 0;
 197                 }
 198         } else {
 199                 printk(KERN_ERR "%s() in %s: Fail to get mipi_csi2_info!\n",
 200                        __func__, __FILE__);
 201                 return -EPERM;
 202         }
 203 #endif
 204
 205         if (cam->vf_bufs_vaddr[0]) {
 206                 dma_free_coherent(0, cam->vf_bufs_size[0],
 207                                   cam->vf_bufs_vaddr[0],
 208                                   (dma_addr_t) cam->vf_bufs[0]);
 209         }
 210         if (cam->vf_bufs_vaddr[1]) {
 211                 dma_free_coherent(0, cam->vf_bufs_size[1],
 212                                   cam->vf_bufs_vaddr[1],
 213                                   (dma_addr_t) cam->vf_bufs[1]);
 214         }
 215         csi_mem_bufsize = cam->crop_current.width *
 216                           cam->crop_current.height * 3/2;
 217         cam->vf_bufs_size[0] = PAGE_ALIGN(csi_mem_bufsize);
 218         cam->vf_bufs_vaddr[0] = (void *)dma_alloc_coherent(0,
 219                                                            cam->vf_bufs_size[0],
 220                                                            (dma_addr_t *) &
 221                                                            cam->vf_bufs[0],
 222                                                            GFP_DMA |
 223                                                            GFP_KERNEL);
 224         if (cam->vf_bufs_vaddr[0] == NULL) {
 225                 printk(KERN_ERR "Error to allocate vf buffer\n");
 226                 err = -ENOMEM;
 227                 goto out_2;
 228         }
 229         cam->vf_bufs_size[1] = PAGE_ALIGN(csi_mem_bufsize);
 230         cam->vf_bufs_vaddr[1] = (void *)dma_alloc_coherent(0,
 231                                                            cam->vf_bufs_size[1],
 232                                                            (dma_addr_t *) &
 233                                                            cam->vf_bufs[1],
 234                                                            GFP_DMA |
 235                                                            GFP_KERNEL);
 236         if (cam->vf_bufs_vaddr[1] == NULL) {
 237                 printk(KERN_ERR "Error to allocate vf buffer\n");
 238                 err = -ENOMEM;
 239                 goto out_1;
 240         }
 241         pr_debug("vf_bufs %x %x\n", cam->vf_bufs[0], cam->vf_bufs[1]);
 242
 243         err = ipu_init_channel(cam->ipu, CSI_MEM, &params);
 244         if (err != 0) {
 245                 printk(KERN_ERR "ipu_init_channel %d\n", err);
 246                 goto out_1;
 247         }
 248
 249         if ((cam->crop_current.width == cam->win.w.width) &&
 250                 (cam->crop_current.height == cam->win.w.height) &&
 251                 (vf_out_format == IPU_PIX_FMT_NV12) &&
 252                 (cam->rotation < IPU_ROTATE_VERT_FLIP)) {
 253                 err = ipu_init_channel_buffer(cam->ipu, CSI_MEM,
 254                         IPU_OUTPUT_BUFFER,
 255                         IPU_PIX_FMT_NV12,
 256                         cam->crop_current.width,
 257                         cam->crop_current.height,
 258                         cam->crop_current.width, IPU_ROTATE_NONE,
 259                         fbi->fix.smem_start +
 260                         (fbi->fix.line_length * fbvar.yres),
 261                         fbi->fix.smem_start, 0,
 262                         cam->offset.u_offset, cam->offset.u_offset);
 263         } else {
 264                 err = ipu_init_channel_buffer(cam->ipu, CSI_MEM,
 265                         IPU_OUTPUT_BUFFER,
 266                         IPU_PIX_FMT_NV12,
 267                         cam->crop_current.width,
 268                         cam->crop_current.height,
 269                         cam->crop_current.width, IPU_ROTATE_NONE,
 270                         cam->vf_bufs[0], cam->vf_bufs[1], 0,
 271                         cam->offset.u_offset, cam->offset.u_offset);
 272         }
 273         if (err != 0) {
 274                 printk(KERN_ERR "CSI_MEM output buffer\n");
 275                 goto out_1;
 276         }
 277         err = ipu_enable_channel(cam->ipu, CSI_MEM);
 278         if (err < 0) {
 279                 printk(KERN_ERR "ipu_enable_channel CSI_MEM\n");
 280                 goto out_1;
 281         }
 282
 283         csi_buffer_num = 0;
 284
 285         ipu_select_buffer(cam->ipu, CSI_MEM, IPU_OUTPUT_BUFFER, 0);
 286         ipu_select_buffer(cam->ipu, CSI_MEM, IPU_OUTPUT_BUFFER, 1);
 287         return err;
 288 out_1:
 289         if (cam->vf_bufs_vaddr[0]) {
 290                 dma_free_coherent(0, cam->vf_bufs_size[0],
 291                                   cam->vf_bufs_vaddr[0],
 292                                   (dma_addr_t) cam->vf_bufs[0]);
 293                 cam->vf_bufs_vaddr[0] = NULL;
 294                 cam->vf_bufs[0] = 0;
 295         }
 296         if (cam->vf_bufs_vaddr[1]) {
 297                 dma_free_coherent(0, cam->vf_bufs_size[1],
 298                                   cam->vf_bufs_vaddr[1],
 299                                   (dma_addr_t) cam->vf_bufs[1]);
 300                 cam->vf_bufs_vaddr[1] = NULL;
 301                 cam->vf_bufs[1] = 0;
 302         }
 303 out_2:
 304         return err;
 305 }
 306
 307 /*!
 308  * Enable encoder task
 309  * @param private       struct cam_data * mxc capture instance
 310  *
 311  * @return  status
 312  */
 313 static int csi_enc_enabling_tasks(void *private)
 314 {
 315         cam_data *cam = (cam_data *) private;
 316         int err = 0;
 317         CAMERA_TRACE("IPU:In csi_enc_enabling_tasks\n");
 318
 319         ipu_clear_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF);
 320         err = ipu_request_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF,
 321                               csi_enc_callback, 0, "Mxc Camera", cam);
 322         if (err != 0) {
 323                 printk(KERN_ERR "Error registering CSI0_OUT_EOF irq\n");
 324                 return err;
 325         }
 326
 327         INIT_WORK(&cam->csi_work_struct, csi_buf_work_func);
 328
 329         err = csi_enc_setup(cam);
 330         if (err != 0) {
 331                 printk(KERN_ERR "csi_enc_setup %d\n", err);
 332                 goto out1;
 333         }
 334
 335         return err;
 336 out1:
 337         ipu_free_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF, cam);
 338         return err;
 339 }
 340
 341 /*
 342  * Function definitions
 343  */
 344
 345 /*!
 346  * foreground_start - start the vf task
 347  *
 348  * @param private    cam_data * mxc v4l2 main structure
 349  *
 350  */
 351 static int foreground_start(void *private)
 352 {
 353         cam_data *cam = (cam_data *) private;
 354         int err = 0, i = 0, screen_size;
 355         char *base;
 356
 357         if (!cam) {
 358                 printk(KERN_ERR "private is NULL\n");
 359                 return -EIO;
 360         }
 361
 362         if (cam->overlay_active == true) {
 363                 pr_debug("already started.\n");
 364                 return 0;
 365         }
 366
 367         get_disp_ipu(cam);
 368
 369         for (i = 0; i < num_registered_fb; i++) {
 370                 char *idstr = registered_fb[i]->fix.id;
 371                 if (((strcmp(idstr, "DISP3 FG") == 0) && (cam->output < 3)) ||
 372                     ((strcmp(idstr, "DISP4 FG") == 0) && (cam->output >= 3))) {
 373                         fbi = registered_fb[i];
 374                         break;
 375                 }
 376         }
 377
 378         if (fbi == NULL) {
 379                 printk(KERN_ERR "DISP FG fb not found\n");
 380                 return -EPERM;
 381         }
 382
 383         fbvar = fbi->var;
 384
 385         /* Store the overlay frame buffer's original std */
 386         cam->fb_origin_std = fbvar.nonstd;
 387
 388         if (cam->devtype == IMX5_V4L2 || cam->devtype == IMX6_V4L2) {
 389                 /* Use DP to do CSC so that we can get better performance */
 390                 vf_out_format = IPU_PIX_FMT_NV12;
 391                 fbvar.nonstd = vf_out_format;
 392         } else {
 393                 vf_out_format = IPU_PIX_FMT_RGB565;
 394                 fbvar.nonstd = 0;
 395         }
 396
 397         fbvar.bits_per_pixel = 16;
 398         fbvar.xres = fbvar.xres_virtual = cam->win.w.width;
 399         fbvar.yres = cam->win.w.height;
 400         fbvar.yres_virtual = cam->win.w.height * 2;
 401         fbvar.yoffset = 0;
 402         fbvar.vmode &= ~FB_VMODE_YWRAP;
 403         fbvar.accel_flags = FB_ACCEL_DOUBLE_FLAG;
 404         fbvar.activate |= FB_ACTIVATE_FORCE;
 405         fb_set_var(fbi, &fbvar);
 406
 407         ipu_disp_set_window_pos(disp_ipu, MEM_FG_SYNC, cam->win.w.left,
 408                         cam->win.w.top);
 409
 410         /* Fill black color for framebuffer */
 411         base = (char *) fbi->screen_base;
 412         screen_size = fbi->var.xres * fbi->var.yres;
 413         if (cam->devtype == IMX5_V4L2 || cam->devtype == IMX6_V4L2) {
 414                 memset(base, 0, screen_size);
 415                 base += screen_size;
 416                 for (i = 0; i < screen_size / 2; i++, base++)
 417                         *base = 0x80;
 418         } else {
 419                 for (i = 0; i < screen_size * 2; i++, base++)
 420                         *base = 0x00;
 421         }
 422
 423         console_lock();
 424         fb_blank(fbi, FB_BLANK_UNBLANK);
 425         console_unlock();
 426
 427         /* correct display ch buffer address */
 428         ipu_update_channel_buffer(disp_ipu, MEM_FG_SYNC, IPU_INPUT_BUFFER,
 429                                 0, fbi->fix.smem_start +
 430                                 (fbi->fix.line_length * fbvar.yres));
 431         ipu_update_channel_buffer(disp_ipu, MEM_FG_SYNC, IPU_INPUT_BUFFER,
 432                                         1, fbi->fix.smem_start);
 433
 434         err = csi_enc_enabling_tasks(cam);
 435         if (err != 0) {
 436                 printk(KERN_ERR "Error csi enc enable fail\n");
 437                 return err;
 438         }
 439
 440         cam->overlay_active = true;
 441         return err;
 442
 443 }
 444
 445 /*!
 446  * foreground_stop - stop the vf task
 447  *
 448  * @param private    cam_data * mxc v4l2 main structure
 449  *
 450  */
 451 static int foreground_stop(void *private)
 452 {
 453         cam_data *cam = (cam_data *) private;
 454         int err = 0, i = 0;
 455         struct fb_info *fbi = NULL;
 456         struct fb_var_screeninfo fbvar;
 457
 458 #ifdef CONFIG_MXC_MIPI_CSI2
 459         void *mipi_csi2_info;
 460         int ipu_id;
 461         int csi_id;
 462 #endif
 463
 464         if (cam->overlay_active == false)
 465                 return 0;
 466
 467         err = ipu_disable_channel(cam->ipu, CSI_MEM, true);
 468
 469         ipu_uninit_channel(cam->ipu, CSI_MEM);
 470
 471         csi_buffer_num = 0;
 472         buffer_num = 0;
 473
 474         for (i = 0; i < num_registered_fb; i++) {
 475                 char *idstr = registered_fb[i]->fix.id;
 476                 if (((strcmp(idstr, "DISP3 FG") == 0) && (cam->output < 3)) ||
 477                     ((strcmp(idstr, "DISP4 FG") == 0) && (cam->output >= 3))) {
 478                         fbi = registered_fb[i];
 479                         break;
 480                 }
 481         }
 482
 483         if (fbi == NULL) {
 484                 printk(KERN_ERR "DISP FG fb not found\n");
 485                 return -EPERM;
 486         }
 487
 488         console_lock();
 489         fb_blank(fbi, FB_BLANK_POWERDOWN);
 490         console_unlock();
 491
 492         /* Set the overlay frame buffer std to what it is used to be */
 493         fbvar = fbi->var;
 494         fbvar.accel_flags = FB_ACCEL_TRIPLE_FLAG;
 495         fbvar.nonstd = cam->fb_origin_std;
 496         fbvar.activate |= FB_ACTIVATE_FORCE;
 497         fb_set_var(fbi, &fbvar);
 498
 499 #ifdef CONFIG_MXC_MIPI_CSI2
 500         mipi_csi2_info = mipi_csi2_get_info();
 501
 502         if (mipi_csi2_info) {
 503                 if (mipi_csi2_get_status(mipi_csi2_info)) {
 504                         ipu_id = mipi_csi2_get_bind_ipu(mipi_csi2_info);
 505                         csi_id = mipi_csi2_get_bind_csi(mipi_csi2_info);
 506
 507                         if (cam->ipu == ipu_get_soc(ipu_id)
 508                                 && cam->csi == csi_id)
 509                                 mipi_csi2_pixelclk_disable(mipi_csi2_info);
 510                 }
 511         } else {
 512                 printk(KERN_ERR "%s() in %s: Fail to get mipi_csi2_info!\n",
 513                        __func__, __FILE__);
 514                 return -EPERM;
 515         }
 516 #endif
 517
 518         flush_work(&cam->csi_work_struct);
 519         cancel_work_sync(&cam->csi_work_struct);
 520
 521         if (cam->vf_bufs_vaddr[0]) {
 522                 dma_free_coherent(0, cam->vf_bufs_size[0],
 523                                   cam->vf_bufs_vaddr[0],
 524                                   (dma_addr_t) cam->vf_bufs[0]);
 525                 cam->vf_bufs_vaddr[0] = NULL;
 526                 cam->vf_bufs[0] = 0;
 527         }
 528         if (cam->vf_bufs_vaddr[1]) {
 529                 dma_free_coherent(0, cam->vf_bufs_size[1],
 530                                   cam->vf_bufs_vaddr[1],
 531                                   (dma_addr_t) cam->vf_bufs[1]);
 532                 cam->vf_bufs_vaddr[1] = NULL;
 533                 cam->vf_bufs[1] = 0;
 534         }
 535
 536         cam->overlay_active = false;
 537         return err;
 538 }
 539
 540 /*!
 541  * Enable csi
 542  * @param private       struct cam_data * mxc capture instance
 543  *
 544  * @return  status
 545  */
 546 static int foreground_enable_csi(void *private)
 547 {
 548         cam_data *cam = (cam_data *) private;
 549
 550         return ipu_enable_csi(cam->ipu, cam->csi);
 551 }
 552
 553 /*!
 554  * Disable csi
 555  * @param private       struct cam_data * mxc capture instance
 556  *
 557  * @return  status
 558  */
 559 static int foreground_disable_csi(void *private)
 560 {
 561         cam_data *cam = (cam_data *) private;
 562
 563         /* free csi eof irq firstly.
 564          * when disable csi, wait for idmac eof.
 565          * it requests eof irq again */
 566         ipu_free_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF, cam);
 567
 568         return ipu_disable_csi(cam->ipu, cam->csi);
 569 }
 570
 571 /*!
 572  * function to select foreground as the working path
 573  *
 574  * @param private    cam_data * mxc v4l2 main structure
 575  *
 576  * @return  status
 577  */
 578 int foreground_sdc_select(void *private)
 579 {
 580         cam_data *cam;
 581         int err = 0;
 582         if (private) {
 583                 cam = (cam_data *) private;
 584                 cam->vf_start_sdc = foreground_start;
 585                 cam->vf_stop_sdc = foreground_stop;
 586                 cam->vf_enable_csi = foreground_enable_csi;
 587                 cam->vf_disable_csi = foreground_disable_csi;
 588                 cam->overlay_active = false;
 589         } else
 590                 err = -EIO;
 591
 592         return err;
 593 }
 594 EXPORT_SYMBOL(foreground_sdc_select);
 595
 596 /*!
 597  * function to de-select foreground as the working path
 598  *
 599  * @param private    cam_data * mxc v4l2 main structure
 600  *
 601  * @return  int
 602  */
 603 int foreground_sdc_deselect(void *private)
 604 {
 605         cam_data *cam;
 606
 607         if (private) {
 608                 cam = (cam_data *) private;
 609                 cam->vf_start_sdc = NULL;
 610                 cam->vf_stop_sdc = NULL;
 611                 cam->vf_enable_csi = NULL;
 612                 cam->vf_disable_csi = NULL;
 613         }
 614         return 0;
 615 }
 616 EXPORT_SYMBOL(foreground_sdc_deselect);
 617
 618 /*!
 619  * Init viewfinder task.
 620  *
 621  * @return  Error code indicating success or failure
 622  */
 623 __init int foreground_sdc_init(void)
 624 {
 625         return 0;
 626 }
 627
 628 /*!
 629  * Deinit viewfinder task.
 630  *
 631  * @return  Error code indicating success or failure
 632  */
 633 void __exit foreground_sdc_exit(void)
 634 {
 635 }
 636
 637 module_init(foreground_sdc_init);
 638 module_exit(foreground_sdc_exit);
 639
 640 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 641 MODULE_DESCRIPTION("IPU PRP VF SDC Driver");
 642 MODULE_LICENSE("GPL");