drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c

   1 /*
   2  * Copyright (C) 2012 Texas Instruments Inc
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation version 2.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16  *
  17  * Contributors:
  18  *      Manjunath Hadli <manjunath.hadli@ti.com>
  19  *      Prabhakar Lad <prabhakar.lad@ti.com>
  20  *
  21  *
  22  * Driver name : VPFE Capture driver
  23  *    VPFE Capture driver allows applications to capture and stream video
  24  *    frames on DaVinci SoCs (DM6446, DM355 etc) from a YUV source such as
  25  *    TVP5146 or  Raw Bayer RGB image data from an image sensor
  26  *    such as Microns' MT9T001, MT9T031 etc.
  27  *
  28  *    These SoCs have, in common, a Video Processing Subsystem (VPSS) that
  29  *    consists of a Video Processing Front End (VPFE) for capturing
  30  *    video/raw image data and Video Processing Back End (VPBE) for displaying
  31  *    YUV data through an in-built analog encoder or Digital LCD port. This
  32  *    driver is for capture through VPFE. A typical EVM using these SoCs have
  33  *    following high level configuration.
  34  *
  35  *    decoder(TVP5146/          YUV/
  36  *      MT9T001)   -->  Raw Bayer RGB ---> MUX -> VPFE (CCDC/ISIF)
  37  *                      data input              |      |
  38  *                                                      V      |
  39  *                                                    SDRAM    |
  40  *                                                             V
  41  *                                                         Image Processor
  42  *                                                             |
  43  *                                                             V
  44  *                                                           SDRAM
  45  *    The data flow happens from a decoder connected to the VPFE over a
  46  *    YUV embedded (BT.656/BT.1120) or separate sync or raw bayer rgb interface
  47  *    and to the input of VPFE through an optional MUX (if more inputs are
  48  *    to be interfaced on the EVM). The input data is first passed through
  49  *    CCDC (CCD Controller, a.k.a Image Sensor Interface, ISIF). The CCDC
  50  *    does very little or no processing on YUV data and does pre-process Raw
  51  *    Bayer RGB data through modules such as Defect Pixel Correction (DFC)
  52  *    Color Space Conversion (CSC), data gain/offset etc. After this, data
  53  *    can be written to SDRAM or can be connected to the image processing
  54  *    block such as IPIPE (on DM355/DM365 only).
  55  *
  56  *    Features supported
  57  *              - MMAP IO
  58  *              - USERPTR IO
  59  *              - Capture using TVP5146 over BT.656
  60  *              - Support for interfacing decoders using sub device model
  61  *              - Work with DM365 or DM355 or DM6446 CCDC to do Raw Bayer
  62  *                RGB/YUV data capture to SDRAM.
  63  *              - Chaining of Image Processor
  64  *              - SINGLE-SHOT mode
  65  */
  66
  67 #include <linux/interrupt.h>
  68 #include <linux/module.h>
  69 #include <linux/slab.h>
  70
  71 #include "vpfe.h"
  72 #include "vpfe_mc_capture.h"
  73
  74 static bool debug;
  75 static bool interface;
  76
  77 module_param(interface, bool, S_IRUGO);
  78 module_param(debug, bool, 0644);
  79
  80 /**
  81  * VPFE capture can be used for capturing video such as from TVP5146 or TVP7002
  82  * and for capture raw bayer data from camera sensors such as mt9p031. At this
  83  * point there is problem in co-existence of mt9p031 and tvp5146 due to i2c
  84  * address collision. So set the variable below from bootargs to do either video
  85  * capture or camera capture.
  86  * interface = 0 - video capture (from TVP514x or such),
  87  * interface = 1 - Camera capture (from mt9p031 or such)
  88  * Re-visit this when we fix the co-existence issue
  89  */
  90 MODULE_PARM_DESC(interface, "interface 0-1 (default:0)");
  91 MODULE_PARM_DESC(debug, "Debug level 0-1");
  92
  93 MODULE_DESCRIPTION("VPFE Video for Linux Capture Driver");
  94 MODULE_LICENSE("GPL");
  95 MODULE_AUTHOR("Texas Instruments");
  96
  97 /* map mbus_fmt to pixelformat */
  98 void mbus_to_pix(const struct v4l2_mbus_framefmt *mbus,
  99                            struct v4l2_pix_format *pix)
 100 {
 101         switch (mbus->code) {
 102         case MEDIA_BUS_FMT_UYVY8_2X8:
 103                 pix->pixelformat = V4L2_PIX_FMT_UYVY;
 104                 pix->bytesperline = pix->width * 2;
 105                 break;
 106
 107         case MEDIA_BUS_FMT_YUYV8_2X8:
 108                 pix->pixelformat = V4L2_PIX_FMT_YUYV;
 109                 pix->bytesperline = pix->width * 2;
 110                 break;
 111
 112         case MEDIA_BUS_FMT_YUYV10_1X20:
 113                 pix->pixelformat = V4L2_PIX_FMT_UYVY;
 114                 pix->bytesperline = pix->width * 2;
 115                 break;
 116
 117         case MEDIA_BUS_FMT_SGRBG12_1X12:
 118                 pix->pixelformat = V4L2_PIX_FMT_SBGGR16;
 119                 pix->bytesperline = pix->width * 2;
 120                 break;
 121
 122         case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
 123                 pix->pixelformat = V4L2_PIX_FMT_SGRBG10DPCM8;
 124                 pix->bytesperline = pix->width;
 125                 break;
 126
 127         case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
 128                 pix->pixelformat = V4L2_PIX_FMT_SGRBG10ALAW8;
 129                 pix->bytesperline = pix->width;
 130                 break;
 131
 132         case MEDIA_BUS_FMT_YDYUYDYV8_1X16:
 133                 pix->pixelformat = V4L2_PIX_FMT_NV12;
 134                 pix->bytesperline = pix->width;
 135                 break;
 136
 137         case MEDIA_BUS_FMT_Y8_1X8:
 138                 pix->pixelformat = V4L2_PIX_FMT_GREY;
 139                 pix->bytesperline = pix->width;
 140                 break;
 141
 142         case MEDIA_BUS_FMT_UV8_1X8:
 143                 pix->pixelformat = V4L2_PIX_FMT_UV8;
 144                 pix->bytesperline = pix->width;
 145                 break;
 146
 147         default:
 148                 pr_err("Invalid mbus code set\n");
 149         }
 150         /* pitch should be 32 bytes aligned */
 151         pix->bytesperline = ALIGN(pix->bytesperline, 32);
 152         if (pix->pixelformat == V4L2_PIX_FMT_NV12)
 153                 pix->sizeimage = pix->bytesperline * pix->height +
 154                                 ((pix->bytesperline * pix->height) >> 1);
 155         else
 156                 pix->sizeimage = pix->bytesperline * pix->height;
 157 }
 158
 159 /* ISR for VINT0*/
 160 static irqreturn_t vpfe_isr(int irq, void *dev_id)
 161 {
 162         struct vpfe_device *vpfe_dev = dev_id;
 163
 164         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_isr\n");
 165         vpfe_isif_buffer_isr(&vpfe_dev->vpfe_isif);
 166         vpfe_resizer_buffer_isr(&vpfe_dev->vpfe_resizer);
 167         return IRQ_HANDLED;
 168 }
 169
 170 /* vpfe_vdint1_isr() - isr handler for VINT1 interrupt */
 171 static irqreturn_t vpfe_vdint1_isr(int irq, void *dev_id)
 172 {
 173         struct vpfe_device *vpfe_dev = dev_id;
 174
 175         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_vdint1_isr\n");
 176         vpfe_isif_vidint1_isr(&vpfe_dev->vpfe_isif);
 177         return IRQ_HANDLED;
 178 }
 179
 180 /* vpfe_imp_dma_isr() - ISR for ipipe dma completion */
 181 static irqreturn_t vpfe_imp_dma_isr(int irq, void *dev_id)
 182 {
 183         struct vpfe_device *vpfe_dev = dev_id;
 184
 185         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_imp_dma_isr\n");
 186         vpfe_ipipeif_ss_buffer_isr(&vpfe_dev->vpfe_ipipeif);
 187         vpfe_resizer_dma_isr(&vpfe_dev->vpfe_resizer);
 188         return IRQ_HANDLED;
 189 }
 190
 191 /*
 192  * vpfe_disable_clock() - Disable clocks for vpfe capture driver
 193  * @vpfe_dev - ptr to vpfe capture device
 194  *
 195  * Disables clocks defined in vpfe configuration. The function
 196  * assumes that at least one clock is to be defined which is
 197  * true as of now.
 198  */
 199 static void vpfe_disable_clock(struct vpfe_device *vpfe_dev)
 200 {
 201         struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;
 202         int i;
 203
 204         for (i = 0; i < vpfe_cfg->num_clocks; i++) {
 205                 clk_disable_unprepare(vpfe_dev->clks[i]);
 206                 clk_put(vpfe_dev->clks[i]);
 207         }
 208         kzfree(vpfe_dev->clks);
 209         v4l2_info(vpfe_dev->pdev->driver, "vpfe capture clocks disabled\n");
 210 }
 211
 212 /*
 213  * vpfe_enable_clock() - Enable clocks for vpfe capture driver
 214  * @vpfe_dev - ptr to vpfe capture device
 215  *
 216  * Enables clocks defined in vpfe configuration. The function
 217  * assumes that at least one clock is to be defined which is
 218  * true as of now.
 219  */
 220 static int vpfe_enable_clock(struct vpfe_device *vpfe_dev)
 221 {
 222         struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;
 223         int ret = -EFAULT;
 224         int i;
 225
 226         if (!vpfe_cfg->num_clocks)
 227                 return 0;
 228
 229         vpfe_dev->clks = kzalloc(vpfe_cfg->num_clocks *
 230                                    sizeof(struct clock *), GFP_KERNEL);
 231         if (vpfe_dev->clks == NULL)
 232                 return -ENOMEM;
 233
 234         for (i = 0; i < vpfe_cfg->num_clocks; i++) {
 235                 if (vpfe_cfg->clocks[i] == NULL) {
 236                         v4l2_err(vpfe_dev->pdev->driver,
 237                                 "clock %s is not defined in vpfe config\n",
 238                                 vpfe_cfg->clocks[i]);
 239                         goto out;
 240                 }
 241
 242                 vpfe_dev->clks[i] =
 243                                 clk_get(vpfe_dev->pdev, vpfe_cfg->clocks[i]);
 244                 if (IS_ERR(vpfe_dev->clks[i])) {
 245                         v4l2_err(vpfe_dev->pdev->driver,
 246                                 "Failed to get clock %s\n",
 247                                 vpfe_cfg->clocks[i]);
 248                         goto out;
 249                 }
 250
 251                 if (clk_prepare_enable(vpfe_dev->clks[i])) {
 252                         v4l2_err(vpfe_dev->pdev->driver,
 253                                 "vpfe clock %s not enabled\n",
 254                                 vpfe_cfg->clocks[i]);
 255                         goto out;
 256                 }
 257
 258                 v4l2_info(vpfe_dev->pdev->driver, "vpss clock %s enabled",
 259                           vpfe_cfg->clocks[i]);
 260         }
 261
 262         return 0;
 263 out:
 264         for (i = 0; i < vpfe_cfg->num_clocks; i++)
 265                 if (!IS_ERR(vpfe_dev->clks[i])) {
 266                         clk_disable_unprepare(vpfe_dev->clks[i]);
 267                         clk_put(vpfe_dev->clks[i]);
 268                 }
 269
 270         v4l2_err(vpfe_dev->pdev->driver, "Failed to enable clocks\n");
 271         kzfree(vpfe_dev->clks);
 272
 273         return ret;
 274 }
 275
 276 /*
 277  * vpfe_detach_irq() - Detach IRQs for vpfe capture driver
 278  * @vpfe_dev - ptr to vpfe capture device
 279  *
 280  * Detach all IRQs defined in vpfe configuration.
 281  */
 282 static void vpfe_detach_irq(struct vpfe_device *vpfe_dev)
 283 {
 284         free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
 285         free_irq(vpfe_dev->ccdc_irq1, vpfe_dev);
 286         free_irq(vpfe_dev->imp_dma_irq, vpfe_dev);
 287 }
 288
 289 /*
 290  * vpfe_attach_irq() - Attach IRQs for vpfe capture driver
 291  * @vpfe_dev - ptr to vpfe capture device
 292  *
 293  * Attach all IRQs defined in vpfe configuration.
 294  */
 295 static int vpfe_attach_irq(struct vpfe_device *vpfe_dev)
 296 {
 297         int ret = 0;
 298
 299         ret = request_irq(vpfe_dev->ccdc_irq0, vpfe_isr, 0,
 300                           "vpfe_capture0", vpfe_dev);
 301         if (ret < 0) {
 302                 v4l2_err(&vpfe_dev->v4l2_dev,
 303                         "Error: requesting VINT0 interrupt\n");
 304                 return ret;
 305         }
 306
 307         ret = request_irq(vpfe_dev->ccdc_irq1, vpfe_vdint1_isr, 0,
 308                           "vpfe_capture1", vpfe_dev);
 309         if (ret < 0) {
 310                 v4l2_err(&vpfe_dev->v4l2_dev,
 311                         "Error: requesting VINT1 interrupt\n");
 312                 free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
 313                 return ret;
 314         }
 315
 316         ret = request_irq(vpfe_dev->imp_dma_irq, vpfe_imp_dma_isr,
 317                           0, "Imp_Sdram_Irq", vpfe_dev);
 318         if (ret < 0) {
 319                 v4l2_err(&vpfe_dev->v4l2_dev,
 320                          "Error: requesting IMP IRQ interrupt\n");
 321                 free_irq(vpfe_dev->ccdc_irq1, vpfe_dev);
 322                 free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
 323                 return ret;
 324         }
 325
 326         return 0;
 327 }
 328
 329 /*
 330  * register_i2c_devices() - register all i2c v4l2 subdevs
 331  * @vpfe_dev - ptr to vpfe capture device
 332  *
 333  * register all i2c v4l2 subdevs
 334  */
 335 static int register_i2c_devices(struct vpfe_device *vpfe_dev)
 336 {
 337         struct vpfe_ext_subdev_info *sdinfo;
 338         struct vpfe_config *vpfe_cfg;
 339         struct i2c_adapter *i2c_adap;
 340         unsigned int num_subdevs;
 341         int ret;
 342         int i;
 343         int k;
 344
 345         vpfe_cfg = vpfe_dev->cfg;
 346         i2c_adap = i2c_get_adapter(1);
 347         num_subdevs = vpfe_cfg->num_subdevs;
 348         vpfe_dev->sd =
 349                   kzalloc(sizeof(struct v4l2_subdev *)*num_subdevs, GFP_KERNEL);
 350         if (vpfe_dev->sd == NULL)
 351                 return -ENOMEM;
 352
 353         for (i = 0, k = 0; i < num_subdevs; i++) {
 354                 sdinfo = &vpfe_cfg->sub_devs[i];
 355                 /*
 356                  * register subdevices based on interface setting. Currently
 357                  * tvp5146 and mt9p031 cannot co-exists due to i2c address
 358                  * conflicts. So only one of them is registered. Re-visit this
 359                  * once we have support for i2c switch handling in i2c driver
 360                  * framework
 361                  */
 362                 if (interface == sdinfo->is_camera) {
 363                         /* setup input path */
 364                         if (vpfe_cfg->setup_input &&
 365                                 vpfe_cfg->setup_input(sdinfo->grp_id) < 0) {
 366                                 ret = -EFAULT;
 367                                 v4l2_info(&vpfe_dev->v4l2_dev,
 368                                           "could not setup input for %s\n",
 369                                                 sdinfo->module_name);
 370                                 goto probe_sd_out;
 371                         }
 372                         /* Load up the subdevice */
 373                         vpfe_dev->sd[k] =
 374                                 v4l2_i2c_new_subdev_board(&vpfe_dev->v4l2_dev,
 375                                                   i2c_adap, &sdinfo->board_info,
 376                                                   NULL);
 377                         if (vpfe_dev->sd[k]) {
 378                                 v4l2_info(&vpfe_dev->v4l2_dev,
 379                                                 "v4l2 sub device %s registered\n",
 380                                                 sdinfo->module_name);
 381
 382                                 vpfe_dev->sd[k]->grp_id = sdinfo->grp_id;
 383                                 k++;
 384
 385                                 sdinfo->registered = 1;
 386                         }
 387                 } else {
 388                         v4l2_info(&vpfe_dev->v4l2_dev,
 389                                   "v4l2 sub device %s is not registered\n",
 390                                   sdinfo->module_name);
 391                 }
 392         }
 393         vpfe_dev->num_ext_subdevs = k;
 394
 395         return 0;
 396
 397 probe_sd_out:
 398         kzfree(vpfe_dev->sd);
 399
 400         return ret;
 401 }
 402
 403 /*
 404  * vpfe_register_entities() - register all v4l2 subdevs and media entities
 405  * @vpfe_dev - ptr to vpfe capture device
 406  *
 407  * register all v4l2 subdevs, media entities, and creates links
 408  * between entities
 409  */
 410 static int vpfe_register_entities(struct vpfe_device *vpfe_dev)
 411 {
 412         unsigned int flags = 0;
 413         int ret;
 414         int i;
 415
 416         /* register i2c devices first */
 417         ret = register_i2c_devices(vpfe_dev);
 418         if (ret)
 419                 return ret;
 420
 421         /* register rest of the sub-devs */
 422         ret = vpfe_isif_register_entities(&vpfe_dev->vpfe_isif,
 423                                           &vpfe_dev->v4l2_dev);
 424         if (ret)
 425                 return ret;
 426
 427         ret = vpfe_ipipeif_register_entities(&vpfe_dev->vpfe_ipipeif,
 428                                              &vpfe_dev->v4l2_dev);
 429         if (ret)
 430                 goto out_isif_register;
 431
 432         ret = vpfe_ipipe_register_entities(&vpfe_dev->vpfe_ipipe,
 433                                            &vpfe_dev->v4l2_dev);
 434         if (ret)
 435                 goto out_ipipeif_register;
 436
 437         ret = vpfe_resizer_register_entities(&vpfe_dev->vpfe_resizer,
 438                                              &vpfe_dev->v4l2_dev);
 439         if (ret)
 440                 goto out_ipipe_register;
 441
 442         /* create links now, starting with external(i2c) entities */
 443         for (i = 0; i < vpfe_dev->num_ext_subdevs; i++)
 444                 /* if entity has no pads (ex: amplifier),
 445                    cant establish link */
 446                 if (vpfe_dev->sd[i]->entity.num_pads) {
 447                         ret = media_entity_create_link(&vpfe_dev->sd[i]->entity,
 448                                 0, &vpfe_dev->vpfe_isif.subdev.entity,
 449                                 0, flags);
 450                         if (ret < 0)
 451                                 goto out_resizer_register;
 452                 }
 453
 454         ret = media_entity_create_link(&vpfe_dev->vpfe_isif.subdev.entity, 1,
 455                                        &vpfe_dev->vpfe_ipipeif.subdev.entity,
 456                                        0, flags);
 457         if (ret < 0)
 458                 goto out_resizer_register;
 459
 460         ret = media_entity_create_link(&vpfe_dev->vpfe_ipipeif.subdev.entity, 1,
 461                                        &vpfe_dev->vpfe_ipipe.subdev.entity,
 462                                        0, flags);
 463         if (ret < 0)
 464                 goto out_resizer_register;
 465
 466         ret = media_entity_create_link(&vpfe_dev->vpfe_ipipe.subdev.entity,
 467                         1, &vpfe_dev->vpfe_resizer.crop_resizer.subdev.entity,
 468                         0, flags);
 469         if (ret < 0)
 470                 goto out_resizer_register;
 471
 472         ret = media_entity_create_link(&vpfe_dev->vpfe_ipipeif.subdev.entity, 1,
 473                         &vpfe_dev->vpfe_resizer.crop_resizer.subdev.entity,
 474                         0, flags);
 475         if (ret < 0)
 476                 goto out_resizer_register;
 477
 478         ret = v4l2_device_register_subdev_nodes(&vpfe_dev->v4l2_dev);
 479         if (ret < 0)
 480                 goto out_resizer_register;
 481
 482         return 0;
 483
 484 out_resizer_register:
 485         vpfe_resizer_unregister_entities(&vpfe_dev->vpfe_resizer);
 486 out_ipipe_register:
 487         vpfe_ipipe_unregister_entities(&vpfe_dev->vpfe_ipipe);
 488 out_ipipeif_register:
 489         vpfe_ipipeif_unregister_entities(&vpfe_dev->vpfe_ipipeif);
 490 out_isif_register:
 491         vpfe_isif_unregister_entities(&vpfe_dev->vpfe_isif);
 492
 493         return ret;
 494 }
 495
 496 /*
 497  * vpfe_unregister_entities() - unregister all v4l2 subdevs and media entities
 498  * @vpfe_dev - ptr to vpfe capture device
 499  *
 500  * unregister all v4l2 subdevs and media entities
 501  */
 502 static void vpfe_unregister_entities(struct vpfe_device *vpfe_dev)
 503 {
 504         vpfe_isif_unregister_entities(&vpfe_dev->vpfe_isif);
 505         vpfe_ipipeif_unregister_entities(&vpfe_dev->vpfe_ipipeif);
 506         vpfe_ipipe_unregister_entities(&vpfe_dev->vpfe_ipipe);
 507         vpfe_resizer_unregister_entities(&vpfe_dev->vpfe_resizer);
 508 }
 509
 510 /*
 511  * vpfe_cleanup_modules() - cleanup all non-i2c v4l2 subdevs
 512  * @vpfe_dev - ptr to vpfe capture device
 513  * @pdev - pointer to platform device
 514  *
 515  * cleanup all v4l2 subdevs
 516  */
 517 static void vpfe_cleanup_modules(struct vpfe_device *vpfe_dev,
 518                                  struct platform_device *pdev)
 519 {
 520         vpfe_isif_cleanup(&vpfe_dev->vpfe_isif, pdev);
 521         vpfe_ipipeif_cleanup(&vpfe_dev->vpfe_ipipeif, pdev);
 522         vpfe_ipipe_cleanup(&vpfe_dev->vpfe_ipipe, pdev);
 523         vpfe_resizer_cleanup(&vpfe_dev->vpfe_resizer, pdev);
 524 }
 525
 526 /*
 527  * vpfe_initialize_modules() - initialize all non-i2c v4l2 subdevs
 528  * @vpfe_dev - ptr to vpfe capture device
 529  * @pdev - pointer to platform device
 530  *
 531  * intialize all v4l2 subdevs and media entities
 532  */
 533 static int vpfe_initialize_modules(struct vpfe_device *vpfe_dev,
 534                                    struct platform_device *pdev)
 535 {
 536         int ret;
 537
 538         ret = vpfe_isif_init(&vpfe_dev->vpfe_isif, pdev);
 539         if (ret)
 540                 return ret;
 541
 542         ret = vpfe_ipipeif_init(&vpfe_dev->vpfe_ipipeif, pdev);
 543         if (ret)
 544                 goto out_isif_init;
 545
 546         ret = vpfe_ipipe_init(&vpfe_dev->vpfe_ipipe, pdev);
 547         if (ret)
 548                 goto out_ipipeif_init;
 549
 550         ret = vpfe_resizer_init(&vpfe_dev->vpfe_resizer, pdev);
 551         if (ret)
 552                 goto out_ipipe_init;
 553
 554         return 0;
 555
 556 out_ipipe_init:
 557         vpfe_ipipe_cleanup(&vpfe_dev->vpfe_ipipe, pdev);
 558 out_ipipeif_init:
 559         vpfe_ipipeif_cleanup(&vpfe_dev->vpfe_ipipeif, pdev);
 560 out_isif_init:
 561         vpfe_isif_cleanup(&vpfe_dev->vpfe_isif, pdev);
 562
 563         return ret;
 564 }
 565
 566 /*
 567  * vpfe_probe() : vpfe probe function
 568  * @pdev: platform device pointer
 569  *
 570  * This function creates device entries by register itself to the V4L2 driver
 571  * and initializes fields of each device objects
 572  */
 573 static int vpfe_probe(struct platform_device *pdev)
 574 {
 575         struct vpfe_device *vpfe_dev;
 576         struct resource *res1;
 577         int ret = -ENOMEM;
 578
 579         vpfe_dev = kzalloc(sizeof(*vpfe_dev), GFP_KERNEL);
 580         if (!vpfe_dev)
 581                 return ret;
 582
 583         if (pdev->dev.platform_data == NULL) {
 584                 v4l2_err(pdev->dev.driver, "Unable to get vpfe config\n");
 585                 ret = -ENOENT;
 586                 goto probe_free_dev_mem;
 587         }
 588
 589         vpfe_dev->cfg = pdev->dev.platform_data;
 590         if (vpfe_dev->cfg->card_name == NULL ||
 591                         vpfe_dev->cfg->sub_devs == NULL) {
 592                 v4l2_err(pdev->dev.driver, "null ptr in vpfe_cfg\n");
 593                 ret = -ENOENT;
 594                 goto probe_free_dev_mem;
 595         }
 596
 597         /* Get VINT0 irq resource */
 598         res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 599         if (!res1) {
 600                 v4l2_err(pdev->dev.driver,
 601                          "Unable to get interrupt for VINT0\n");
 602                 ret = -ENOENT;
 603                 goto probe_free_dev_mem;
 604         }
 605         vpfe_dev->ccdc_irq0 = res1->start;
 606
 607         /* Get VINT1 irq resource */
 608         res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
 609         if (!res1) {
 610                 v4l2_err(pdev->dev.driver,
 611                          "Unable to get interrupt for VINT1\n");
 612                 ret = -ENOENT;
 613                 goto probe_free_dev_mem;
 614         }
 615         vpfe_dev->ccdc_irq1 = res1->start;
 616
 617         /* Get DMA irq resource */
 618         res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 2);
 619         if (!res1) {
 620                 v4l2_err(pdev->dev.driver,
 621                          "Unable to get interrupt for DMA\n");
 622                 ret = -ENOENT;
 623                 goto probe_free_dev_mem;
 624         }
 625         vpfe_dev->imp_dma_irq = res1->start;
 626
 627         vpfe_dev->pdev = &pdev->dev;
 628
 629         /* enable vpss clocks */
 630         ret = vpfe_enable_clock(vpfe_dev);
 631         if (ret)
 632                 goto probe_free_dev_mem;
 633
 634         ret = vpfe_initialize_modules(vpfe_dev, pdev);
 635         if (ret)
 636                 goto probe_disable_clock;
 637
 638         vpfe_dev->media_dev.dev = vpfe_dev->pdev;
 639         strcpy((char *)&vpfe_dev->media_dev.model, "davinci-media");
 640
 641         ret = media_device_register(&vpfe_dev->media_dev);
 642         if (ret) {
 643                 v4l2_err(pdev->dev.driver,
 644                         "Unable to register media device.\n");
 645                 goto probe_out_entities_cleanup;
 646         }
 647
 648         vpfe_dev->v4l2_dev.mdev = &vpfe_dev->media_dev;
 649         ret = v4l2_device_register(&pdev->dev, &vpfe_dev->v4l2_dev);
 650         if (ret) {
 651                 v4l2_err(pdev->dev.driver, "Unable to register v4l2 device.\n");
 652                 goto probe_out_media_unregister;
 653         }
 654
 655         v4l2_info(&vpfe_dev->v4l2_dev, "v4l2 device registered\n");
 656         /* set the driver data in platform device */
 657         platform_set_drvdata(pdev, vpfe_dev);
 658         /* register subdevs/entities */
 659         ret = vpfe_register_entities(vpfe_dev);
 660         if (ret)
 661                 goto probe_out_v4l2_unregister;
 662
 663         ret = vpfe_attach_irq(vpfe_dev);
 664         if (ret)
 665                 goto probe_out_entities_unregister;
 666
 667         return 0;
 668
 669 probe_out_entities_unregister:
 670         vpfe_unregister_entities(vpfe_dev);
 671         kzfree(vpfe_dev->sd);
 672 probe_out_v4l2_unregister:
 673         v4l2_device_unregister(&vpfe_dev->v4l2_dev);
 674 probe_out_media_unregister:
 675         media_device_unregister(&vpfe_dev->media_dev);
 676 probe_out_entities_cleanup:
 677         vpfe_cleanup_modules(vpfe_dev, pdev);
 678 probe_disable_clock:
 679         vpfe_disable_clock(vpfe_dev);
 680 probe_free_dev_mem:
 681         kzfree(vpfe_dev);
 682
 683         return ret;
 684 }
 685
 686 /*
 687  * vpfe_remove : This function un-registers device from V4L2 driver
 688  */
 689 static int vpfe_remove(struct platform_device *pdev)
 690 {
 691         struct vpfe_device *vpfe_dev = platform_get_drvdata(pdev);
 692
 693         v4l2_info(pdev->dev.driver, "vpfe_remove\n");
 694
 695         kzfree(vpfe_dev->sd);
 696         vpfe_detach_irq(vpfe_dev);
 697         vpfe_unregister_entities(vpfe_dev);
 698         vpfe_cleanup_modules(vpfe_dev, pdev);
 699         v4l2_device_unregister(&vpfe_dev->v4l2_dev);
 700         media_device_unregister(&vpfe_dev->media_dev);
 701         vpfe_disable_clock(vpfe_dev);
 702         kzfree(vpfe_dev);
 703
 704         return 0;
 705 }
 706
 707 static struct platform_driver vpfe_driver = {
 708         .driver = {
 709                 .name = CAPTURE_DRV_NAME,
 710         },
 711         .probe = vpfe_probe,
 712         .remove = vpfe_remove,
 713 };
 714
 715 module_platform_driver(vpfe_driver);