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