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

   1 /*
   2  * Copyright 2004-2014 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         }
 199 #endif
 200
 201         if (cam->vf_bufs_vaddr[0]) {
 202                 dma_free_coherent(0, cam->vf_bufs_size[0],
 203                                   cam->vf_bufs_vaddr[0],
 204                                   (dma_addr_t) cam->vf_bufs[0]);
 205         }
 206         if (cam->vf_bufs_vaddr[1]) {
 207                 dma_free_coherent(0, cam->vf_bufs_size[1],
 208                                   cam->vf_bufs_vaddr[1],
 209                                   (dma_addr_t) cam->vf_bufs[1]);
 210         }
 211         csi_mem_bufsize = cam->crop_current.width *
 212                           cam->crop_current.height * 3/2;
 213         cam->vf_bufs_size[0] = PAGE_ALIGN(csi_mem_bufsize);
 214         cam->vf_bufs_vaddr[0] = (void *)dma_alloc_coherent(0,
 215                                                            cam->vf_bufs_size[0],
 216                                                            (dma_addr_t *) &
 217                                                            cam->vf_bufs[0],
 218                                                            GFP_DMA |
 219                                                            GFP_KERNEL);
 220         if (cam->vf_bufs_vaddr[0] == NULL) {
 221                 printk(KERN_ERR "Error to allocate vf buffer\n");
 222                 err = -ENOMEM;
 223                 goto out_2;
 224         }
 225         cam->vf_bufs_size[1] = PAGE_ALIGN(csi_mem_bufsize);
 226         cam->vf_bufs_vaddr[1] = (void *)dma_alloc_coherent(0,
 227                                                            cam->vf_bufs_size[1],
 228                                                            (dma_addr_t *) &
 229                                                            cam->vf_bufs[1],
 230                                                            GFP_DMA |
 231                                                            GFP_KERNEL);
 232         if (cam->vf_bufs_vaddr[1] == NULL) {
 233                 printk(KERN_ERR "Error to allocate vf buffer\n");
 234                 err = -ENOMEM;
 235                 goto out_1;
 236         }
 237         pr_debug("vf_bufs %x %x\n", cam->vf_bufs[0], cam->vf_bufs[1]);
 238
 239         err = ipu_init_channel(cam->ipu, CSI_MEM, &params);
 240         if (err != 0) {
 241                 printk(KERN_ERR "ipu_init_channel %d\n", err);
 242                 goto out_1;
 243         }
 244
 245         if ((cam->crop_current.width == cam->win.w.width) &&
 246                 (cam->crop_current.height == cam->win.w.height) &&
 247                 (vf_out_format == IPU_PIX_FMT_NV12) &&
 248                 (cam->rotation < IPU_ROTATE_VERT_FLIP)) {
 249                 err = ipu_init_channel_buffer(cam->ipu, CSI_MEM,
 250                         IPU_OUTPUT_BUFFER,
 251                         IPU_PIX_FMT_NV12,
 252                         cam->crop_current.width,
 253                         cam->crop_current.height,
 254                         cam->crop_current.width, IPU_ROTATE_NONE,
 255                         fbi->fix.smem_start +
 256                         (fbi->fix.line_length * fbvar.yres),
 257                         fbi->fix.smem_start, 0,
 258                         cam->offset.u_offset, cam->offset.u_offset);
 259         } else {
 260                 err = ipu_init_channel_buffer(cam->ipu, CSI_MEM,
 261                         IPU_OUTPUT_BUFFER,
 262                         IPU_PIX_FMT_NV12,
 263                         cam->crop_current.width,
 264                         cam->crop_current.height,
 265                         cam->crop_current.width, IPU_ROTATE_NONE,
 266                         cam->vf_bufs[0], cam->vf_bufs[1], 0,
 267                         cam->offset.u_offset, cam->offset.u_offset);
 268         }
 269         if (err != 0) {
 270                 printk(KERN_ERR "CSI_MEM output buffer\n");
 271                 goto out_1;
 272         }
 273         err = ipu_enable_channel(cam->ipu, CSI_MEM);
 274         if (err < 0) {
 275                 printk(KERN_ERR "ipu_enable_channel CSI_MEM\n");
 276                 goto out_1;
 277         }
 278
 279         csi_buffer_num = 0;
 280
 281         ipu_select_buffer(cam->ipu, CSI_MEM, IPU_OUTPUT_BUFFER, 0);
 282         ipu_select_buffer(cam->ipu, CSI_MEM, IPU_OUTPUT_BUFFER, 1);
 283         return err;
 284 out_1:
 285         if (cam->vf_bufs_vaddr[0]) {
 286                 dma_free_coherent(0, cam->vf_bufs_size[0],
 287                                   cam->vf_bufs_vaddr[0],
 288                                   (dma_addr_t) cam->vf_bufs[0]);
 289                 cam->vf_bufs_vaddr[0] = NULL;
 290                 cam->vf_bufs[0] = 0;
 291         }
 292         if (cam->vf_bufs_vaddr[1]) {
 293                 dma_free_coherent(0, cam->vf_bufs_size[1],
 294                                   cam->vf_bufs_vaddr[1],
 295                                   (dma_addr_t) cam->vf_bufs[1]);
 296                 cam->vf_bufs_vaddr[1] = NULL;
 297                 cam->vf_bufs[1] = 0;
 298         }
 299 out_2:
 300         return err;
 301 }
 302
 303 /*!
 304  * Enable encoder task
 305  * @param private       struct cam_data * mxc capture instance
 306  *
 307  * @return  status
 308  */
 309 static int csi_enc_enabling_tasks(void *private)
 310 {
 311         cam_data *cam = (cam_data *) private;
 312         int err = 0;
 313         CAMERA_TRACE("IPU:In csi_enc_enabling_tasks\n");
 314
 315         ipu_clear_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF);
 316         err = ipu_request_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF,
 317                               csi_enc_callback, 0, "Mxc Camera", cam);
 318         if (err != 0) {
 319                 printk(KERN_ERR "Error registering CSI0_OUT_EOF irq\n");
 320                 return err;
 321         }
 322
 323         INIT_WORK(&cam->csi_work_struct, csi_buf_work_func);
 324
 325         err = csi_enc_setup(cam);
 326         if (err != 0) {
 327                 printk(KERN_ERR "csi_enc_setup %d\n", err);
 328                 goto out1;
 329         }
 330
 331         return err;
 332 out1:
 333         ipu_free_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF, cam);
 334         return err;
 335 }
 336
 337 /*
 338  * Function definitions
 339  */
 340
 341 /*!
 342  * foreground_start - start the vf task
 343  *
 344  * @param private    cam_data * mxc v4l2 main structure
 345  *
 346  */
 347 static int foreground_start(void *private)
 348 {
 349         cam_data *cam = (cam_data *) private;
 350         int err = 0, i = 0, screen_size;
 351         char *base;
 352
 353         if (!cam) {
 354                 printk(KERN_ERR "private is NULL\n");
 355                 return -EIO;
 356         }
 357
 358         if (cam->overlay_active == true) {
 359                 pr_debug("already started.\n");
 360                 return 0;
 361         }
 362
 363         get_disp_ipu(cam);
 364
 365         for (i = 0; i < num_registered_fb; i++) {
 366                 char *idstr = registered_fb[i]->fix.id;
 367                 if (((strcmp(idstr, "DISP3 FG") == 0) && (cam->output < 3)) ||
 368                     ((strcmp(idstr, "DISP4 FG") == 0) && (cam->output >= 3))) {
 369                         fbi = registered_fb[i];
 370                         break;
 371                 }
 372         }
 373
 374         if (fbi == NULL) {
 375                 printk(KERN_ERR "DISP FG fb not found\n");
 376                 return -EPERM;
 377         }
 378
 379         fbvar = fbi->var;
 380
 381         /* Store the overlay frame buffer's original std */
 382         cam->fb_origin_std = fbvar.nonstd;
 383
 384         if (cam->devtype == IMX5_V4L2 || cam->devtype == IMX6_V4L2) {
 385                 /* Use DP to do CSC so that we can get better performance */
 386                 vf_out_format = IPU_PIX_FMT_NV12;
 387                 fbvar.nonstd = vf_out_format;
 388         } else {
 389                 vf_out_format = IPU_PIX_FMT_RGB565;
 390                 fbvar.nonstd = 0;
 391         }
 392
 393         fbvar.bits_per_pixel = 16;
 394         fbvar.xres = fbvar.xres_virtual = cam->win.w.width;
 395         fbvar.yres = cam->win.w.height;
 396         fbvar.yres_virtual = cam->win.w.height * 2;
 397         fbvar.yoffset = 0;
 398         fbvar.vmode &= ~FB_VMODE_YWRAP;
 399         fbvar.accel_flags = FB_ACCEL_DOUBLE_FLAG;
 400         fbvar.activate |= FB_ACTIVATE_FORCE;
 401         fb_set_var(fbi, &fbvar);
 402
 403         ipu_disp_set_window_pos(disp_ipu, MEM_FG_SYNC, cam->win.w.left,
 404                         cam->win.w.top);
 405
 406         /* Fill black color for framebuffer */
 407         base = (char *) fbi->screen_base;
 408         screen_size = fbi->var.xres * fbi->var.yres;
 409         if (cam->devtype == IMX5_V4L2 || cam->devtype == IMX6_V4L2) {
 410                 memset(base, 0, screen_size);
 411                 base += screen_size;
 412                 for (i = 0; i < screen_size / 2; i++, base++)
 413                         *base = 0x80;
 414         } else {
 415                 for (i = 0; i < screen_size * 2; i++, base++)
 416                         *base = 0x00;
 417         }
 418
 419         console_lock();
 420         fb_blank(fbi, FB_BLANK_UNBLANK);
 421         console_unlock();
 422
 423         /* correct display ch buffer address */
 424         ipu_update_channel_buffer(disp_ipu, MEM_FG_SYNC, IPU_INPUT_BUFFER,
 425                                 0, fbi->fix.smem_start +
 426                                 (fbi->fix.line_length * fbvar.yres));
 427         ipu_update_channel_buffer(disp_ipu, MEM_FG_SYNC, IPU_INPUT_BUFFER,
 428                                         1, fbi->fix.smem_start);
 429
 430         err = csi_enc_enabling_tasks(cam);
 431         if (err != 0) {
 432                 printk(KERN_ERR "Error csi enc enable fail\n");
 433                 return err;
 434         }
 435
 436         cam->overlay_active = true;
 437         return err;
 438
 439 }
 440
 441 /*!
 442  * foreground_stop - stop the vf task
 443  *
 444  * @param private    cam_data * mxc v4l2 main structure
 445  *
 446  */
 447 static int foreground_stop(void *private)
 448 {
 449         cam_data *cam = (cam_data *) private;
 450         int err = 0, i = 0;
 451         struct fb_info *fbi = NULL;
 452         struct fb_var_screeninfo fbvar;
 453
 454 #ifdef CONFIG_MXC_MIPI_CSI2
 455         void *mipi_csi2_info;
 456         int ipu_id;
 457         int csi_id;
 458 #endif
 459
 460         if (cam->overlay_active == false)
 461                 return 0;
 462
 463         err = ipu_disable_channel(cam->ipu, CSI_MEM, true);
 464
 465         ipu_uninit_channel(cam->ipu, CSI_MEM);
 466
 467         csi_buffer_num = 0;
 468         buffer_num = 0;
 469
 470         for (i = 0; i < num_registered_fb; i++) {
 471                 char *idstr = registered_fb[i]->fix.id;
 472                 if (((strcmp(idstr, "DISP3 FG") == 0) && (cam->output < 3)) ||
 473                     ((strcmp(idstr, "DISP4 FG") == 0) && (cam->output >= 3))) {
 474                         fbi = registered_fb[i];
 475                         break;
 476                 }
 477         }
 478
 479         if (fbi == NULL) {
 480                 printk(KERN_ERR "DISP FG fb not found\n");
 481                 return -EPERM;
 482         }
 483
 484         console_lock();
 485         fb_blank(fbi, FB_BLANK_POWERDOWN);
 486         console_unlock();
 487
 488         /* Set the overlay frame buffer std to what it is used to be */
 489         fbvar = fbi->var;
 490         fbvar.accel_flags = FB_ACCEL_TRIPLE_FLAG;
 491         fbvar.nonstd = cam->fb_origin_std;
 492         fbvar.activate |= FB_ACTIVATE_FORCE;
 493         fb_set_var(fbi, &fbvar);
 494
 495 #ifdef CONFIG_MXC_MIPI_CSI2
 496         mipi_csi2_info = mipi_csi2_get_info();
 497
 498         if (mipi_csi2_info) {
 499                 if (mipi_csi2_get_status(mipi_csi2_info)) {
 500                         ipu_id = mipi_csi2_get_bind_ipu(mipi_csi2_info);
 501                         csi_id = mipi_csi2_get_bind_csi(mipi_csi2_info);
 502
 503                         if (cam->ipu == ipu_get_soc(ipu_id)
 504                                 && cam->csi == csi_id)
 505                                 mipi_csi2_pixelclk_disable(mipi_csi2_info);
 506                 }
 507         }
 508 #endif
 509
 510         flush_work(&cam->csi_work_struct);
 511         cancel_work_sync(&cam->csi_work_struct);
 512
 513         if (cam->vf_bufs_vaddr[0]) {
 514                 dma_free_coherent(0, cam->vf_bufs_size[0],
 515                                   cam->vf_bufs_vaddr[0],
 516                                   (dma_addr_t) cam->vf_bufs[0]);
 517                 cam->vf_bufs_vaddr[0] = NULL;
 518                 cam->vf_bufs[0] = 0;
 519         }
 520         if (cam->vf_bufs_vaddr[1]) {
 521                 dma_free_coherent(0, cam->vf_bufs_size[1],
 522                                   cam->vf_bufs_vaddr[1],
 523                                   (dma_addr_t) cam->vf_bufs[1]);
 524                 cam->vf_bufs_vaddr[1] = NULL;
 525                 cam->vf_bufs[1] = 0;
 526         }
 527
 528         cam->overlay_active = false;
 529         return err;
 530 }
 531
 532 /*!
 533  * Enable csi
 534  * @param private       struct cam_data * mxc capture instance
 535  *
 536  * @return  status
 537  */
 538 static int foreground_enable_csi(void *private)
 539 {
 540         cam_data *cam = (cam_data *) private;
 541
 542         return ipu_enable_csi(cam->ipu, cam->csi);
 543 }
 544
 545 /*!
 546  * Disable csi
 547  * @param private       struct cam_data * mxc capture instance
 548  *
 549  * @return  status
 550  */
 551 static int foreground_disable_csi(void *private)
 552 {
 553         cam_data *cam = (cam_data *) private;
 554
 555         /* free csi eof irq firstly.
 556          * when disable csi, wait for idmac eof.
 557          * it requests eof irq again */
 558         ipu_free_irq(cam->ipu, IPU_IRQ_CSI0_OUT_EOF, cam);
 559
 560         return ipu_disable_csi(cam->ipu, cam->csi);
 561 }
 562
 563 /*!
 564  * function to select foreground as the working path
 565  *
 566  * @param private    cam_data * mxc v4l2 main structure
 567  *
 568  * @return  status
 569  */
 570 int foreground_sdc_select(void *private)
 571 {
 572         cam_data *cam;
 573         int err = 0;
 574         if (private) {
 575                 cam = (cam_data *) private;
 576                 cam->vf_start_sdc = foreground_start;
 577                 cam->vf_stop_sdc = foreground_stop;
 578                 cam->vf_enable_csi = foreground_enable_csi;
 579                 cam->vf_disable_csi = foreground_disable_csi;
 580                 cam->overlay_active = false;
 581         } else
 582                 err = -EIO;
 583
 584         return err;
 585 }
 586 EXPORT_SYMBOL(foreground_sdc_select);
 587
 588 /*!
 589  * function to de-select foreground as the working path
 590  *
 591  * @param private    cam_data * mxc v4l2 main structure
 592  *
 593  * @return  int
 594  */
 595 int foreground_sdc_deselect(void *private)
 596 {
 597         cam_data *cam;
 598
 599         if (private) {
 600                 cam = (cam_data *) private;
 601                 cam->vf_start_sdc = NULL;
 602                 cam->vf_stop_sdc = NULL;
 603                 cam->vf_enable_csi = NULL;
 604                 cam->vf_disable_csi = NULL;
 605         }
 606         return 0;
 607 }
 608 EXPORT_SYMBOL(foreground_sdc_deselect);
 609
 610 /*!
 611  * Init viewfinder task.
 612  *
 613  * @return  Error code indicating success or failure
 614  */
 615 __init int foreground_sdc_init(void)
 616 {
 617         return 0;
 618 }
 619
 620 /*!
 621  * Deinit viewfinder task.
 622  *
 623  * @return  Error code indicating success or failure
 624  */
 625 void __exit foreground_sdc_exit(void)
 626 {
 627 }
 628
 629 module_init(foreground_sdc_init);
 630 module_exit(foreground_sdc_exit);
 631
 632 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 633 MODULE_DESCRIPTION("IPU PRP VF SDC Driver");
 634 MODULE_LICENSE("GPL");