SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/soc_camera.c

   1 /*
   2  * camera image capture (abstract) bus driver
   3  *
   4  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
   5  *
   6  * This driver provides an interface between platform-specific camera
   7  * busses and camera devices. It should be used if the camera is
   8  * connected not over a "proper" bus like PCI or USB, but over a
   9  * special bus, like, for example, the Quick Capture interface on PXA270
  10  * SoCs. Later it should also be used for i.MX31 SoCs from Freescale.
  11  * It can handle multiple cameras and / or multiple busses, which can
  12  * be used, e.g., in stereo-vision applications.
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  */
  18
  19 #include <linux/device.h>
  20 #include <linux/err.h>
  21 #include <linux/i2c.h>
  22 #include <linux/init.h>
  23 #include <linux/list.h>
  24 #include <linux/mutex.h>
  25 #include <linux/module.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/vmalloc.h>
  28
  29 #include <media/soc_camera.h>
  30 #include <media/v4l2-common.h>
  31 #include <media/v4l2-ioctl.h>
  32 #include <media/v4l2-dev.h>
  33 #include <media/videobuf-core.h>
  34
  35 /* Default to VGA resolution */
  36 #define DEFAULT_WIDTH   640
  37 #define DEFAULT_HEIGHT  480
  38
  39 static LIST_HEAD(hosts);
  40 static LIST_HEAD(devices);
  41 static DEFINE_MUTEX(list_lock);         /* Protects the list of hosts */
  42
  43 const struct soc_camera_data_format *soc_camera_format_by_fourcc(
  44         struct soc_camera_device *icd, unsigned int fourcc)
  45 {
  46         unsigned int i;
  47
  48         for (i = 0; i < icd->num_formats; i++)
  49                 if (icd->formats[i].fourcc == fourcc)
  50                         return icd->formats + i;
  51         return NULL;
  52 }
  53 EXPORT_SYMBOL(soc_camera_format_by_fourcc);
  54
  55 const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
  56         struct soc_camera_device *icd, unsigned int fourcc)
  57 {
  58         unsigned int i;
  59
  60         for (i = 0; i < icd->num_user_formats; i++)
  61                 if (icd->user_formats[i].host_fmt->fourcc == fourcc)
  62                         return icd->user_formats + i;
  63         return NULL;
  64 }
  65 EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
  66
  67 /**
  68  * soc_camera_apply_sensor_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
  69  * @icl:        camera platform parameters
  70  * @flags:      flags to be inverted according to platform configuration
  71  * @return:     resulting flags
  72  */
  73 unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link *icl,
  74                                             unsigned long flags)
  75 {
  76         unsigned long f;
  77
  78         /* If only one of the two polarities is supported, switch to the opposite */
  79         if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
  80                 f = flags & (SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW);
  81                 if (f == SOCAM_HSYNC_ACTIVE_HIGH || f == SOCAM_HSYNC_ACTIVE_LOW)
  82                         flags ^= SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW;
  83         }
  84
  85         if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
  86                 f = flags & (SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW);
  87                 if (f == SOCAM_VSYNC_ACTIVE_HIGH || f == SOCAM_VSYNC_ACTIVE_LOW)
  88                         flags ^= SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW;
  89         }
  90
  91         if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
  92                 f = flags & (SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING);
  93                 if (f == SOCAM_PCLK_SAMPLE_RISING || f == SOCAM_PCLK_SAMPLE_FALLING)
  94                         flags ^= SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING;
  95         }
  96
  97         return flags;
  98 }
  99 EXPORT_SYMBOL(soc_camera_apply_sensor_flags);
 100
 101 static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
 102                                       struct v4l2_format *f)
 103 {
 104         struct soc_camera_file *icf = file->private_data;
 105         struct soc_camera_device *icd = icf->icd;
 106         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 107
 108         WARN_ON(priv != file->private_data);
 109
 110         /* limit format to hardware capabilities */
 111         return ici->ops->try_fmt(icd, f);
 112 }
 113
 114 static int soc_camera_enum_input(struct file *file, void *priv,
 115                                  struct v4l2_input *inp)
 116 {
 117         struct soc_camera_file *icf = file->private_data;
 118         struct soc_camera_device *icd = icf->icd;
 119         int ret = 0;
 120
 121         if (inp->index != 0)
 122                 return -EINVAL;
 123
 124         if (icd->ops->enum_input)
 125                 ret = icd->ops->enum_input(icd, inp);
 126         else {
 127                 /* default is camera */
 128                 inp->type = V4L2_INPUT_TYPE_CAMERA;
 129                 inp->std  = V4L2_STD_UNKNOWN;
 130                 strcpy(inp->name, "Camera");
 131         }
 132
 133         return ret;
 134 }
 135
 136 static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
 137 {
 138         *i = 0;
 139
 140         return 0;
 141 }
 142
 143 static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
 144 {
 145         if (i > 0)
 146                 return -EINVAL;
 147
 148         return 0;
 149 }
 150
 151 static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
 152 {
 153         struct soc_camera_file *icf = file->private_data;
 154         struct soc_camera_device *icd = icf->icd;
 155         int ret = 0;
 156
 157         if (icd->ops->set_std)
 158                 ret = icd->ops->set_std(icd, a);
 159
 160         return ret;
 161 }
 162
 163 static int soc_camera_reqbufs(struct file *file, void *priv,
 164                               struct v4l2_requestbuffers *p)
 165 {
 166         int ret;
 167         struct soc_camera_file *icf = file->private_data;
 168         struct soc_camera_device *icd = icf->icd;
 169         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 170
 171         WARN_ON(priv != file->private_data);
 172
 173         ret = videobuf_reqbufs(&icf->vb_vidq, p);
 174         if (ret < 0)
 175                 return ret;
 176
 177         return ici->ops->reqbufs(icf, p);
 178 }
 179
 180 static int soc_camera_querybuf(struct file *file, void *priv,
 181                                struct v4l2_buffer *p)
 182 {
 183         struct soc_camera_file *icf = file->private_data;
 184
 185         WARN_ON(priv != file->private_data);
 186
 187         return videobuf_querybuf(&icf->vb_vidq, p);
 188 }
 189
 190 static int soc_camera_qbuf(struct file *file, void *priv,
 191                            struct v4l2_buffer *p)
 192 {
 193         struct soc_camera_file *icf = file->private_data;
 194
 195         WARN_ON(priv != file->private_data);
 196
 197         return videobuf_qbuf(&icf->vb_vidq, p);
 198 }
 199
 200 static int soc_camera_dqbuf(struct file *file, void *priv,
 201                             struct v4l2_buffer *p)
 202 {
 203         struct soc_camera_file *icf = file->private_data;
 204
 205         WARN_ON(priv != file->private_data);
 206
 207         return videobuf_dqbuf(&icf->vb_vidq, p, file->f_flags & O_NONBLOCK);
 208 }
 209
 210 /* Always entered with .video_lock held */
 211 static int soc_camera_init_user_formats(struct soc_camera_device *icd)
 212 {
 213         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 214         int i, fmts = 0;
 215
 216         if (!ici->ops->get_formats)
 217                 /*
 218                  * Fallback mode - the host will have to serve all
 219                  * sensor-provided formats one-to-one to the user
 220                  */
 221                 fmts = icd->num_formats;
 222         else
 223                 /*
 224                  * First pass - only count formats this host-sensor
 225                  * configuration can provide
 226                  */
 227                 for (i = 0; i < icd->num_formats; i++)
 228                         fmts += ici->ops->get_formats(icd, i, NULL);
 229
 230         if (!fmts)
 231                 return -ENXIO;
 232
 233         icd->user_formats =
 234                 vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
 235         if (!icd->user_formats)
 236                 return -ENOMEM;
 237
 238         icd->num_user_formats = fmts;
 239
 240         dev_dbg(&icd->dev, "Found %d supported formats.\n", fmts);
 241
 242         /* Second pass - actually fill data formats */
 243         fmts = 0;
 244         for (i = 0; i < icd->num_formats; i++)
 245                 if (!ici->ops->get_formats) {
 246                         icd->user_formats[i].host_fmt = icd->formats + i;
 247                         icd->user_formats[i].cam_fmt = icd->formats + i;
 248                         icd->user_formats[i].buswidth = icd->formats[i].depth;
 249                 } else {
 250                         fmts += ici->ops->get_formats(icd, i,
 251                                                       &icd->user_formats[fmts]);
 252                 }
 253
 254         icd->current_fmt = icd->user_formats[0].host_fmt;
 255
 256         return 0;
 257 }
 258
 259 /* Always entered with .video_lock held */
 260 static void soc_camera_free_user_formats(struct soc_camera_device *icd)
 261 {
 262         icd->current_fmt = NULL;
 263         vfree(icd->user_formats);
 264         icd->user_formats = NULL;
 265 }
 266
 267 /* Called with .vb_lock held */
 268 static int soc_camera_set_fmt(struct soc_camera_file *icf,
 269                               struct v4l2_format *f)
 270 {
 271         struct soc_camera_device *icd = icf->icd;
 272         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 273         struct v4l2_pix_format *pix = &f->fmt.pix;
 274         int ret;
 275
 276         /* We always call try_fmt() before set_fmt() or set_crop() */
 277         ret = ici->ops->try_fmt(icd, f);
 278         if (ret < 0)
 279                 return ret;
 280
 281         ret = ici->ops->set_fmt(icd, f);
 282         if (ret < 0) {
 283                 return ret;
 284         } else if (!icd->current_fmt ||
 285                    icd->current_fmt->fourcc != pix->pixelformat) {
 286                 dev_err(ici->v4l2_dev.dev,
 287                         "Host driver hasn't set up current format correctly!\n");
 288                 return -EINVAL;
 289         }
 290
 291         icd->width              = pix->width;
 292         icd->height             = pix->height;
 293         icf->vb_vidq.field      =
 294                 icd->field      = pix->field;
 295
 296         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 297                 dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
 298                          f->type);
 299
 300         dev_dbg(&icd->dev, "set width: %d height: %d\n",
 301                 icd->width, icd->height);
 302
 303         /* set physical bus parameters */
 304         return ici->ops->set_bus_param(icd, pix->pixelformat);
 305 }
 306
 307 static int soc_camera_open(struct file *file)
 308 {
 309         struct video_device *vdev = video_devdata(file);
 310         struct soc_camera_device *icd = container_of(vdev->parent, struct soc_camera_device, dev);
 311         struct soc_camera_link *icl = to_soc_camera_link(icd);
 312         struct soc_camera_host *ici;
 313         struct soc_camera_file *icf;
 314         int ret;
 315
 316         if (!icd->ops)
 317                 /* No device driver attached */
 318                 return -ENODEV;
 319
 320         ici = to_soc_camera_host(icd->dev.parent);
 321
 322         icf = vmalloc(sizeof(*icf));
 323         if (!icf)
 324                 return -ENOMEM;
 325
 326         if (!try_module_get(ici->ops->owner)) {
 327                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
 328                 ret = -EINVAL;
 329                 goto emgi;
 330         }
 331
 332         /* Protect against icd->ops->remove() until we module_get() both drivers. */
 333         mutex_lock(&icd->video_lock);
 334
 335         icf->icd = icd;
 336         icd->use_count++;
 337
 338         /* Now we really have to activate the camera */
 339         if (icd->use_count == 1) {
 340                 /* Restore parameters before the last close() per V4L2 API */
 341                 struct v4l2_format f = {
 342                         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 343                         .fmt.pix = {
 344                                 .width          = icd->width,
 345                                 .height         = icd->height,
 346                                 .field          = icd->field,
 347                         },
 348                 };
 349
 350                 ret = soc_camera_init_user_formats(icd);
 351                 if (ret < 0)
 352                         goto eiufmt;
 353
 354                 f.fmt.pix.pixelformat   = icd->current_fmt->fourcc;
 355                 f.fmt.pix.colorspace    = icd->current_fmt->colorspace;
 356
 357                 if (icl->power) {
 358                         ret = icl->power(icd->pdev, 1);
 359                         if (ret < 0)
 360                                 goto epower;
 361                 }
 362
 363                 /* The camera could have been already on, try to reset */
 364                 if (icl->reset)
 365                         icl->reset(icd->pdev);
 366
 367                 ret = ici->ops->add(icd);
 368                 if (ret < 0) {
 369                         dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
 370                         goto eiciadd;
 371                 }
 372
 373                 if (icd->ops->init) {
 374                         ret = icd->ops->init(icd);
 375                         if (ret < 0)
 376                                 goto einit;
 377                 }
 378
 379                 /* Try to configure with default parameters */
 380                 ret = soc_camera_set_fmt(icf, &f);
 381                 if (ret < 0)
 382                         goto esfmt;
 383         }
 384
 385         file->private_data = icf;
 386         dev_dbg(&icd->dev, "camera device open\n");
 387
 388         ici->ops->init_videobuf(&icf->vb_vidq, icd);
 389
 390         mutex_unlock(&icd->video_lock);
 391
 392         return 0;
 393
 394         /*
 395          * First five errors are entered with the .video_lock held
 396          * and use_count == 1
 397          */
 398 esfmt:
 399         if (icd->ops->release)
 400                 icd->ops->release(icd);
 401 einit:
 402         ici->ops->remove(icd);
 403 eiciadd:
 404         if (icl->power)
 405                 icl->power(icd->pdev, 0);
 406 epower:
 407         soc_camera_free_user_formats(icd);
 408 eiufmt:
 409         icd->use_count--;
 410         mutex_unlock(&icd->video_lock);
 411         module_put(ici->ops->owner);
 412 emgi:
 413         vfree(icf);
 414         return ret;
 415 }
 416
 417 static int soc_camera_close(struct file *file)
 418 {
 419         struct soc_camera_file *icf = file->private_data;
 420         struct soc_camera_device *icd = icf->icd;
 421         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 422         struct video_device *vdev = icd->vdev;
 423
 424         mutex_lock(&icd->video_lock);
 425         icd->use_count--;
 426         if (!icd->use_count) {
 427                 struct soc_camera_link *icl = to_soc_camera_link(icd);
 428
 429                 if (icd->ops->release)
 430                         icd->ops->release(icd);
 431                 ici->ops->remove(icd);
 432                 if (icl->power)
 433                         icl->power(icd->pdev, 0);
 434                 soc_camera_free_user_formats(icd);
 435         }
 436
 437         mutex_unlock(&icd->video_lock);
 438
 439         module_put(ici->ops->owner);
 440
 441         vfree(icf);
 442
 443         dev_dbg(vdev->parent, "camera device close\n");
 444
 445         return 0;
 446 }
 447
 448 static ssize_t soc_camera_read(struct file *file, char __user *buf,
 449                                size_t count, loff_t *ppos)
 450 {
 451         struct soc_camera_file *icf = file->private_data;
 452         struct soc_camera_device *icd = icf->icd;
 453         struct video_device *vdev = icd->vdev;
 454         int err = -EINVAL;
 455
 456         dev_err(vdev->parent, "camera device read not implemented\n");
 457
 458         return err;
 459 }
 460
 461 static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
 462 {
 463         struct soc_camera_file *icf = file->private_data;
 464         struct soc_camera_device *icd = icf->icd;
 465         int err;
 466
 467         dev_dbg(&icd->dev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
 468
 469         err = videobuf_mmap_mapper(&icf->vb_vidq, vma);
 470
 471         dev_dbg(&icd->dev, "vma start=0x%08lx, size=%ld, ret=%d\n",
 472                 (unsigned long)vma->vm_start,
 473                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
 474                 err);
 475
 476         return err;
 477 }
 478
 479 static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
 480 {
 481         struct soc_camera_file *icf = file->private_data;
 482         struct soc_camera_device *icd = icf->icd;
 483         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 484
 485         if (list_empty(&icf->vb_vidq.stream)) {
 486                 dev_err(&icd->dev, "Trying to poll with no queued buffers!\n");
 487                 return POLLERR;
 488         }
 489
 490         return ici->ops->poll(file, pt);
 491 }
 492
 493 static struct v4l2_file_operations soc_camera_fops = {
 494         .owner          = THIS_MODULE,
 495         .open           = soc_camera_open,
 496         .release        = soc_camera_close,
 497         .ioctl          = video_ioctl2,
 498         .read           = soc_camera_read,
 499         .mmap           = soc_camera_mmap,
 500         .poll           = soc_camera_poll,
 501 };
 502
 503 static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
 504                                     struct v4l2_format *f)
 505 {
 506         struct soc_camera_file *icf = file->private_data;
 507         struct soc_camera_device *icd = icf->icd;
 508         int ret;
 509
 510         WARN_ON(priv != file->private_data);
 511
 512         mutex_lock(&icf->vb_vidq.vb_lock);
 513
 514         if (videobuf_queue_is_busy(&icf->vb_vidq)) {
 515                 dev_err(&icd->dev, "S_FMT denied: queue busy\n");
 516                 ret = -EBUSY;
 517                 goto unlock;
 518         }
 519
 520         ret = soc_camera_set_fmt(icf, f);
 521
 522 unlock:
 523         mutex_unlock(&icf->vb_vidq.vb_lock);
 524
 525         return ret;
 526 }
 527
 528 static int soc_camera_enum_fmt_vid_cap(struct file *file, void  *priv,
 529                                        struct v4l2_fmtdesc *f)
 530 {
 531         struct soc_camera_file *icf = file->private_data;
 532         struct soc_camera_device *icd = icf->icd;
 533         const struct soc_camera_data_format *format;
 534
 535         WARN_ON(priv != file->private_data);
 536
 537         if (f->index >= icd->num_user_formats)
 538                 return -EINVAL;
 539
 540         format = icd->user_formats[f->index].host_fmt;
 541
 542         strlcpy(f->description, format->name, sizeof(f->description));
 543         f->pixelformat = format->fourcc;
 544         return 0;
 545 }
 546
 547 static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
 548                                     struct v4l2_format *f)
 549 {
 550         struct soc_camera_file *icf = file->private_data;
 551         struct soc_camera_device *icd = icf->icd;
 552         struct v4l2_pix_format *pix = &f->fmt.pix;
 553
 554         WARN_ON(priv != file->private_data);
 555
 556         pix->width              = icd->width;
 557         pix->height             = icd->height;
 558         pix->field              = icf->vb_vidq.field;
 559         pix->pixelformat        = icd->current_fmt->fourcc;
 560         pix->bytesperline       = pix->width *
 561                 DIV_ROUND_UP(icd->current_fmt->depth, 8);
 562         pix->sizeimage          = pix->height * pix->bytesperline;
 563         dev_dbg(&icd->dev, "current_fmt->fourcc: 0x%08x\n",
 564                 icd->current_fmt->fourcc);
 565         return 0;
 566 }
 567
 568 static int soc_camera_querycap(struct file *file, void  *priv,
 569                                struct v4l2_capability *cap)
 570 {
 571         struct soc_camera_file *icf = file->private_data;
 572         struct soc_camera_device *icd = icf->icd;
 573         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 574
 575         WARN_ON(priv != file->private_data);
 576
 577         strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
 578         return ici->ops->querycap(ici, cap);
 579 }
 580
 581 static int soc_camera_streamon(struct file *file, void *priv,
 582                                enum v4l2_buf_type i)
 583 {
 584         struct soc_camera_file *icf = file->private_data;
 585         struct soc_camera_device *icd = icf->icd;
 586         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 587         int ret;
 588
 589         WARN_ON(priv != file->private_data);
 590
 591         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 592                 return -EINVAL;
 593
 594         mutex_lock(&icd->video_lock);
 595
 596         v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video, s_stream, 1);
 597
 598         /* This calls buf_queue from host driver's videobuf_queue_ops */
 599         ret = videobuf_streamon(&icf->vb_vidq);
 600
 601         mutex_unlock(&icd->video_lock);
 602
 603         return ret;
 604 }
 605
 606 static int soc_camera_streamoff(struct file *file, void *priv,
 607                                 enum v4l2_buf_type i)
 608 {
 609         struct soc_camera_file *icf = file->private_data;
 610         struct soc_camera_device *icd = icf->icd;
 611         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 612
 613         WARN_ON(priv != file->private_data);
 614
 615         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 616                 return -EINVAL;
 617
 618         mutex_lock(&icd->video_lock);
 619
 620         /* This calls buf_release from host driver's videobuf_queue_ops for all
 621          * remaining buffers. When the last buffer is freed, stop capture */
 622         videobuf_streamoff(&icf->vb_vidq);
 623
 624         v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video, s_stream, 0);
 625
 626         mutex_unlock(&icd->video_lock);
 627
 628         return 0;
 629 }
 630
 631 static int soc_camera_queryctrl(struct file *file, void *priv,
 632                                 struct v4l2_queryctrl *qc)
 633 {
 634         struct soc_camera_file *icf = file->private_data;
 635         struct soc_camera_device *icd = icf->icd;
 636         int i;
 637
 638         WARN_ON(priv != file->private_data);
 639
 640         if (!qc->id)
 641                 return -EINVAL;
 642
 643         for (i = 0; i < icd->ops->num_controls; i++)
 644                 if (qc->id == icd->ops->controls[i].id) {
 645                         memcpy(qc, &(icd->ops->controls[i]),
 646                                 sizeof(*qc));
 647                         return 0;
 648                 }
 649
 650         return -EINVAL;
 651 }
 652
 653 static int soc_camera_g_ctrl(struct file *file, void *priv,
 654                              struct v4l2_control *ctrl)
 655 {
 656         struct soc_camera_file *icf = file->private_data;
 657         struct soc_camera_device *icd = icf->icd;
 658         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 659
 660         WARN_ON(priv != file->private_data);
 661
 662         switch (ctrl->id) {
 663         case V4L2_CID_GAIN:
 664                 if (icd->gain == (unsigned short)~0)
 665                         return -EINVAL;
 666                 ctrl->value = icd->gain;
 667                 return 0;
 668         case V4L2_CID_EXPOSURE:
 669                 if (icd->exposure == (unsigned short)~0)
 670                         return -EINVAL;
 671                 ctrl->value = icd->exposure;
 672                 return 0;
 673         }
 674
 675         return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, g_ctrl, ctrl);
 676 }
 677
 678 static int soc_camera_s_ctrl(struct file *file, void *priv,
 679                              struct v4l2_control *ctrl)
 680 {
 681         struct soc_camera_file *icf = file->private_data;
 682         struct soc_camera_device *icd = icf->icd;
 683         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 684
 685         WARN_ON(priv != file->private_data);
 686
 687         return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, s_ctrl, ctrl);
 688 }
 689
 690 static int soc_camera_cropcap(struct file *file, void *fh,
 691                               struct v4l2_cropcap *a)
 692 {
 693         struct soc_camera_file *icf = file->private_data;
 694         struct soc_camera_device *icd = icf->icd;
 695
 696         a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 697         a->bounds.left                  = icd->x_min;
 698         a->bounds.top                   = icd->y_min;
 699         a->bounds.width                 = icd->width_max;
 700         a->bounds.height                = icd->height_max;
 701         a->defrect.left                 = icd->x_min;
 702         a->defrect.top                  = icd->y_min;
 703         a->defrect.width                = DEFAULT_WIDTH;
 704         a->defrect.height               = DEFAULT_HEIGHT;
 705         a->pixelaspect.numerator        = 1;
 706         a->pixelaspect.denominator      = 1;
 707
 708         return 0;
 709 }
 710
 711 static int soc_camera_g_crop(struct file *file, void *fh,
 712                              struct v4l2_crop *a)
 713 {
 714         struct soc_camera_file *icf = file->private_data;
 715         struct soc_camera_device *icd = icf->icd;
 716
 717         a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 718         a->c.left       = icd->x_current;
 719         a->c.top        = icd->y_current;
 720         a->c.width      = icd->width;
 721         a->c.height     = icd->height;
 722
 723         return 0;
 724 }
 725
 726 static int soc_camera_s_crop(struct file *file, void *fh,
 727                              struct v4l2_crop *a)
 728 {
 729         struct soc_camera_file *icf = file->private_data;
 730         struct soc_camera_device *icd = icf->icd;
 731         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 732         int ret;
 733
 734         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 735                 return -EINVAL;
 736
 737         /* Cropping is allowed during a running capture, guard consistency */
 738         mutex_lock(&icf->vb_vidq.vb_lock);
 739
 740         ret = ici->ops->set_crop(icd, &a->c);
 741         if (!ret) {
 742                 icd->width      = a->c.width;
 743                 icd->height     = a->c.height;
 744                 icd->x_current  = a->c.left;
 745                 icd->y_current  = a->c.top;
 746         }
 747
 748         mutex_unlock(&icf->vb_vidq.vb_lock);
 749
 750         return ret;
 751 }
 752
 753 static int soc_camera_g_chip_ident(struct file *file, void *fh,
 754                                    struct v4l2_dbg_chip_ident *id)
 755 {
 756         struct soc_camera_file *icf = file->private_data;
 757         struct soc_camera_device *icd = icf->icd;
 758         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 759
 760         return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, g_chip_ident, id);
 761 }
 762
 763 #ifdef CONFIG_VIDEO_ADV_DEBUG
 764 static int soc_camera_g_register(struct file *file, void *fh,
 765                                  struct v4l2_dbg_register *reg)
 766 {
 767         struct soc_camera_file *icf = file->private_data;
 768         struct soc_camera_device *icd = icf->icd;
 769         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 770
 771         return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, g_register, reg);
 772 }
 773
 774 static int soc_camera_s_register(struct file *file, void *fh,
 775                                  struct v4l2_dbg_register *reg)
 776 {
 777         struct soc_camera_file *icf = file->private_data;
 778         struct soc_camera_device *icd = icf->icd;
 779         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 780
 781         return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, s_register, reg);
 782 }
 783 #endif
 784
 785 /* So far this function cannot fail */
 786 static void scan_add_host(struct soc_camera_host *ici)
 787 {
 788         struct soc_camera_device *icd;
 789
 790         mutex_lock(&list_lock);
 791
 792         list_for_each_entry(icd, &devices, list) {
 793                 if (icd->iface == ici->nr) {
 794                         int ret;
 795                         icd->dev.parent = ici->v4l2_dev.dev;
 796                         dev_set_name(&icd->dev, "%u-%u", icd->iface,
 797                                      icd->devnum);
 798                         ret = device_register(&icd->dev);
 799                         if (ret < 0) {
 800                                 icd->dev.parent = NULL;
 801                                 dev_err(&icd->dev,
 802                                         "Cannot register device: %d\n", ret);
 803                         }
 804                 }
 805         }
 806
 807         mutex_unlock(&list_lock);
 808 }
 809
 810 #ifdef CONFIG_I2C_BOARDINFO
 811 static int soc_camera_init_i2c(struct soc_camera_device *icd,
 812                                struct soc_camera_link *icl)
 813 {
 814         struct i2c_client *client;
 815         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 816         struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
 817         struct v4l2_subdev *subdev;
 818         int ret;
 819
 820         if (!adap) {
 821                 ret = -ENODEV;
 822                 dev_err(&icd->dev, "Cannot get I2C adapter #%d. No driver?\n",
 823                         icl->i2c_adapter_id);
 824                 goto ei2cga;
 825         }
 826
 827         icl->board_info->platform_data = icd;
 828
 829         subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
 830                                 icl->module_name, icl->board_info, NULL);
 831         if (!subdev) {
 832                 ret = -ENOMEM;
 833                 goto ei2cnd;
 834         }
 835
 836         subdev->grp_id = (__u32)icd;
 837         client = subdev->priv;
 838
 839         /* Use to_i2c_client(dev) to recover the i2c client */
 840         dev_set_drvdata(&icd->dev, &client->dev);
 841
 842         return 0;
 843 ei2cnd:
 844         i2c_put_adapter(adap);
 845 ei2cga:
 846         return ret;
 847 }
 848
 849 static void soc_camera_free_i2c(struct soc_camera_device *icd)
 850 {
 851         struct i2c_client *client =
 852                 to_i2c_client(to_soc_camera_control(icd));
 853         dev_set_drvdata(&icd->dev, NULL);
 854         v4l2_device_unregister_subdev(i2c_get_clientdata(client));
 855         i2c_unregister_device(client);
 856         i2c_put_adapter(client->adapter);
 857 }
 858 #else
 859 #define soc_camera_init_i2c(icd, icl)   (-ENODEV)
 860 #define soc_camera_free_i2c(icd)        do {} while (0)
 861 #endif
 862
 863 static int soc_camera_video_start(struct soc_camera_device *icd);
 864 static int video_dev_create(struct soc_camera_device *icd);
 865 /* Called during host-driver probe */
 866 static int soc_camera_probe(struct device *dev)
 867 {
 868         struct soc_camera_device *icd = to_soc_camera_dev(dev);
 869         struct soc_camera_host *ici = to_soc_camera_host(dev->parent);
 870         struct soc_camera_link *icl = to_soc_camera_link(icd);
 871         struct device *control = NULL;
 872         int ret;
 873
 874         dev_info(dev, "Probing %s\n", dev_name(dev));
 875
 876         if (icl->power) {
 877                 ret = icl->power(icd->pdev, 1);
 878                 if (ret < 0) {
 879                         dev_err(dev,
 880                                 "Platform failed to power-on the camera.\n");
 881                         goto epower;
 882                 }
 883         }
 884
 885         /* The camera could have been already on, try to reset */
 886         if (icl->reset)
 887                 icl->reset(icd->pdev);
 888
 889         ret = ici->ops->add(icd);
 890         if (ret < 0)
 891                 goto eadd;
 892
 893         /* Must have icd->vdev before registering the device */
 894         ret = video_dev_create(icd);
 895         if (ret < 0)
 896                 goto evdc;
 897
 898         /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */
 899         if (icl->board_info) {
 900                 ret = soc_camera_init_i2c(icd, icl);
 901                 if (ret < 0)
 902                         goto eadddev;
 903         } else if (!icl->add_device || !icl->del_device) {
 904                 ret = -EINVAL;
 905                 goto eadddev;
 906         } else {
 907                 if (icl->module_name)
 908                         ret = request_module(icl->module_name);
 909
 910                 ret = icl->add_device(icl, &icd->dev);
 911                 if (ret < 0)
 912                         goto eadddev;
 913
 914                 /* FIXME: this is racy, have to use driver-binding notification */
 915                 control = to_soc_camera_control(icd);
 916                 if (!control || !control->driver ||
 917                     !try_module_get(control->driver->owner)) {
 918                         icl->del_device(icl);
 919                         goto enodrv;
 920                 }
 921         }
 922
 923         /* ..._video_start() will create a device node, so we have to protect */
 924         mutex_lock(&icd->video_lock);
 925
 926         ret = soc_camera_video_start(icd);
 927         if (ret < 0)
 928                 goto evidstart;
 929
 930         /* Do we have to sysfs_remove_link() before device_unregister()? */
 931         if (to_soc_camera_control(icd) &&
 932             sysfs_create_link(&icd->dev.kobj, &to_soc_camera_control(icd)->kobj,
 933                               "control"))
 934                 dev_warn(&icd->dev, "Failed creating the control symlink\n");
 935
 936         ici->ops->remove(icd);
 937
 938         if (icl->power)
 939                 icl->power(icd->pdev, 0);
 940
 941         mutex_unlock(&icd->video_lock);
 942
 943         return 0;
 944
 945 evidstart:
 946         mutex_unlock(&icd->video_lock);
 947         if (icl->board_info) {
 948                 soc_camera_free_i2c(icd);
 949         } else {
 950                 icl->del_device(icl);
 951                 module_put(control->driver->owner);
 952         }
 953 enodrv:
 954 eadddev:
 955         video_device_release(icd->vdev);
 956 evdc:
 957         ici->ops->remove(icd);
 958 eadd:
 959         if (icl->power)
 960                 icl->power(icd->pdev, 0);
 961 epower:
 962         return ret;
 963 }
 964
 965 /* This is called on device_unregister, which only means we have to disconnect
 966  * from the host, but not remove ourselves from the device list */
 967 static int soc_camera_remove(struct device *dev)
 968 {
 969         struct soc_camera_device *icd = to_soc_camera_dev(dev);
 970         struct soc_camera_link *icl = to_soc_camera_link(icd);
 971         struct video_device *vdev = icd->vdev;
 972
 973         BUG_ON(!dev->parent);
 974
 975         if (vdev) {
 976                 mutex_lock(&icd->video_lock);
 977                 video_unregister_device(vdev);
 978                 icd->vdev = NULL;
 979                 mutex_unlock(&icd->video_lock);
 980         }
 981
 982         if (icl->board_info) {
 983                 soc_camera_free_i2c(icd);
 984         } else {
 985                 struct device_driver *drv = to_soc_camera_control(icd) ?
 986                         to_soc_camera_control(icd)->driver : NULL;
 987                 if (drv) {
 988                         icl->del_device(icl);
 989                         module_put(drv->owner);
 990                 }
 991         }
 992
 993         return 0;
 994 }
 995
 996 static int soc_camera_suspend(struct device *dev, pm_message_t state)
 997 {
 998         struct soc_camera_device *icd = to_soc_camera_dev(dev);
 999         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1000         int ret = 0;
1001
1002         if (ici->ops->suspend)
1003                 ret = ici->ops->suspend(icd, state);
1004
1005         return ret;
1006 }
1007
1008 static int soc_camera_resume(struct device *dev)
1009 {
1010         struct soc_camera_device *icd = to_soc_camera_dev(dev);
1011         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1012         int ret = 0;
1013
1014         if (ici->ops->resume)
1015                 ret = ici->ops->resume(icd);
1016
1017         return ret;
1018 }
1019
1020 static struct bus_type soc_camera_bus_type = {
1021         .name           = "soc-camera",
1022         .probe          = soc_camera_probe,
1023         .remove         = soc_camera_remove,
1024         .suspend        = soc_camera_suspend,
1025         .resume         = soc_camera_resume,
1026 };
1027
1028 static struct device_driver ic_drv = {
1029         .name   = "camera",
1030         .bus    = &soc_camera_bus_type,
1031         .owner  = THIS_MODULE,
1032 };
1033
1034 static void dummy_release(struct device *dev)
1035 {
1036 }
1037
1038 int soc_camera_host_register(struct soc_camera_host *ici)
1039 {
1040         struct soc_camera_host *ix;
1041         int ret;
1042
1043         if (!ici || !ici->ops ||
1044             !ici->ops->try_fmt ||
1045             !ici->ops->set_fmt ||
1046             !ici->ops->set_crop ||
1047             !ici->ops->set_bus_param ||
1048             !ici->ops->querycap ||
1049             !ici->ops->init_videobuf ||
1050             !ici->ops->reqbufs ||
1051             !ici->ops->add ||
1052             !ici->ops->remove ||
1053             !ici->ops->poll ||
1054             !ici->v4l2_dev.dev)
1055                 return -EINVAL;
1056
1057         mutex_lock(&list_lock);
1058         list_for_each_entry(ix, &hosts, list) {
1059                 if (ix->nr == ici->nr) {
1060                         ret = -EBUSY;
1061                         goto edevreg;
1062                 }
1063         }
1064
1065         ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
1066         if (ret < 0)
1067                 goto edevreg;
1068
1069         list_add_tail(&ici->list, &hosts);
1070         mutex_unlock(&list_lock);
1071
1072         scan_add_host(ici);
1073
1074         return 0;
1075
1076 edevreg:
1077         mutex_unlock(&list_lock);
1078         return ret;
1079 }
1080 EXPORT_SYMBOL(soc_camera_host_register);
1081
1082 /* Unregister all clients! */
1083 void soc_camera_host_unregister(struct soc_camera_host *ici)
1084 {
1085         struct soc_camera_device *icd;
1086
1087         mutex_lock(&list_lock);
1088
1089         list_del(&ici->list);
1090
1091         list_for_each_entry(icd, &devices, list) {
1092                 if (icd->iface == ici->nr) {
1093                         /* The bus->remove will be called */
1094                         device_unregister(&icd->dev);
1095                         /* Not before device_unregister(), .remove
1096                          * needs parent to call ici->ops->remove() */
1097                         icd->dev.parent = NULL;
1098
1099                         /* If the host module is loaded again, device_register()
1100                          * would complain "already initialised" */
1101                         memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
1102                 }
1103         }
1104
1105         mutex_unlock(&list_lock);
1106
1107         v4l2_device_unregister(&ici->v4l2_dev);
1108 }
1109 EXPORT_SYMBOL(soc_camera_host_unregister);
1110
1111 /* Image capture device */
1112 static int soc_camera_device_register(struct soc_camera_device *icd)
1113 {
1114         struct soc_camera_device *ix;
1115         int num = -1, i;
1116
1117         for (i = 0; i < 256 && num < 0; i++) {
1118                 num = i;
1119                 /* Check if this index is available on this interface */
1120                 list_for_each_entry(ix, &devices, list) {
1121                         if (ix->iface == icd->iface && ix->devnum == i) {
1122                                 num = -1;
1123                                 break;
1124                         }
1125                 }
1126         }
1127
1128         if (num < 0)
1129                 /* ok, we have 256 cameras on this host...
1130                  * man, stay reasonable... */
1131                 return -ENOMEM;
1132
1133         icd->devnum = num;
1134         icd->dev.bus = &soc_camera_bus_type;
1135
1136         icd->dev.release        = dummy_release;
1137         icd->use_count          = 0;
1138         icd->host_priv          = NULL;
1139         mutex_init(&icd->video_lock);
1140
1141         list_add_tail(&icd->list, &devices);
1142
1143         return 0;
1144 }
1145
1146 static void soc_camera_device_unregister(struct soc_camera_device *icd)
1147 {
1148         list_del(&icd->list);
1149 }
1150
1151 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
1152         .vidioc_querycap         = soc_camera_querycap,
1153         .vidioc_g_fmt_vid_cap    = soc_camera_g_fmt_vid_cap,
1154         .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
1155         .vidioc_s_fmt_vid_cap    = soc_camera_s_fmt_vid_cap,
1156         .vidioc_enum_input       = soc_camera_enum_input,
1157         .vidioc_g_input          = soc_camera_g_input,
1158         .vidioc_s_input          = soc_camera_s_input,
1159         .vidioc_s_std            = soc_camera_s_std,
1160         .vidioc_reqbufs          = soc_camera_reqbufs,
1161         .vidioc_try_fmt_vid_cap  = soc_camera_try_fmt_vid_cap,
1162         .vidioc_querybuf         = soc_camera_querybuf,
1163         .vidioc_qbuf             = soc_camera_qbuf,
1164         .vidioc_dqbuf            = soc_camera_dqbuf,
1165         .vidioc_streamon         = soc_camera_streamon,
1166         .vidioc_streamoff        = soc_camera_streamoff,
1167         .vidioc_queryctrl        = soc_camera_queryctrl,
1168         .vidioc_g_ctrl           = soc_camera_g_ctrl,
1169         .vidioc_s_ctrl           = soc_camera_s_ctrl,
1170         .vidioc_cropcap          = soc_camera_cropcap,
1171         .vidioc_g_crop           = soc_camera_g_crop,
1172         .vidioc_s_crop           = soc_camera_s_crop,
1173         .vidioc_g_chip_ident     = soc_camera_g_chip_ident,
1174 #ifdef CONFIG_VIDEO_ADV_DEBUG
1175         .vidioc_g_register       = soc_camera_g_register,
1176         .vidioc_s_register       = soc_camera_s_register,
1177 #endif
1178 };
1179
1180 static int video_dev_create(struct soc_camera_device *icd)
1181 {
1182         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1183         struct video_device *vdev = video_device_alloc();
1184
1185         if (!vdev)
1186                 return -ENOMEM;
1187
1188         strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
1189
1190         vdev->parent            = &icd->dev;
1191         vdev->current_norm      = V4L2_STD_UNKNOWN;
1192         vdev->fops              = &soc_camera_fops;
1193         vdev->ioctl_ops         = &soc_camera_ioctl_ops;
1194         vdev->release           = video_device_release;
1195         vdev->minor             = -1;
1196         vdev->tvnorms           = V4L2_STD_UNKNOWN;
1197
1198         icd->vdev = vdev;
1199
1200         return 0;
1201 }
1202
1203 /*
1204  * Called from soc_camera_probe() above (with .video_lock held???)
1205  */
1206 static int soc_camera_video_start(struct soc_camera_device *icd)
1207 {
1208         const struct v4l2_queryctrl *qctrl;
1209         int ret;
1210
1211         if (!icd->dev.parent)
1212                 return -ENODEV;
1213
1214         if (!icd->ops ||
1215             !icd->ops->query_bus_param ||
1216             !icd->ops->set_bus_param)
1217                 return -EINVAL;
1218
1219         ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER,
1220                                     icd->vdev->minor);
1221         if (ret < 0) {
1222                 dev_err(&icd->dev, "video_register_device failed: %d\n", ret);
1223                 return ret;
1224         }
1225
1226         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
1227         icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
1228         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
1229         icd->exposure = qctrl ? qctrl->default_value : (unsigned short)~0;
1230
1231         return 0;
1232 }
1233
1234 static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
1235 {
1236         struct soc_camera_link *icl = pdev->dev.platform_data;
1237         struct soc_camera_device *icd;
1238         int ret;
1239
1240         if (!icl)
1241                 return -EINVAL;
1242
1243         icd = kzalloc(sizeof(*icd), GFP_KERNEL);
1244         if (!icd)
1245                 return -ENOMEM;
1246
1247         icd->iface = icl->bus_id;
1248         icd->pdev = &pdev->dev;
1249         platform_set_drvdata(pdev, icd);
1250         icd->dev.platform_data = icl;
1251
1252         ret = soc_camera_device_register(icd);
1253         if (ret < 0)
1254                 goto escdevreg;
1255
1256         return 0;
1257
1258 escdevreg:
1259         kfree(icd);
1260
1261         return ret;
1262 }
1263
1264 /* Only called on rmmod for each platform device, since they are not
1265  * hot-pluggable. Now we know, that all our users - hosts and devices have
1266  * been unloaded already */
1267 static int __devexit soc_camera_pdrv_remove(struct platform_device *pdev)
1268 {
1269         struct soc_camera_device *icd = platform_get_drvdata(pdev);
1270
1271         if (!icd)
1272                 return -EINVAL;
1273
1274         soc_camera_device_unregister(icd);
1275
1276         kfree(icd);
1277
1278         return 0;
1279 }
1280
1281 static struct platform_driver __refdata soc_camera_pdrv = {
1282         .remove  = __devexit_p(soc_camera_pdrv_remove),
1283         .driver  = {
1284                 .name   = "soc-camera-pdrv",
1285                 .owner  = THIS_MODULE,
1286         },
1287 };
1288
1289 static int __init soc_camera_init(void)
1290 {
1291         int ret = bus_register(&soc_camera_bus_type);
1292         if (ret)
1293                 return ret;
1294         ret = driver_register(&ic_drv);
1295         if (ret)
1296                 goto edrvr;
1297
1298         ret = platform_driver_probe(&soc_camera_pdrv, soc_camera_pdrv_probe);
1299         if (ret)
1300                 goto epdr;
1301
1302         return 0;
1303
1304 epdr:
1305         driver_unregister(&ic_drv);
1306 edrvr:
1307         bus_unregister(&soc_camera_bus_type);
1308         return ret;
1309 }
1310
1311 static void __exit soc_camera_exit(void)
1312 {
1313         platform_driver_unregister(&soc_camera_pdrv);
1314         driver_unregister(&ic_drv);
1315         bus_unregister(&soc_camera_bus_type);
1316 }
1317
1318 module_init(soc_camera_init);
1319 module_exit(soc_camera_exit);
1320
1321 MODULE_DESCRIPTION("Image capture bus driver");
1322 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1323 MODULE_LICENSE("GPL");
1324 MODULE_ALIAS("platform:soc-camera-pdrv");