kernel/drivers/media/platform/via-camera.c

   1 /*
   2  * Driver for the VIA Chrome integrated camera controller.
   3  *
   4  * Copyright 2009,2010 Jonathan Corbet <corbet@lwn.net>
   5  * Distributable under the terms of the GNU General Public License, version 2
   6  *
   7  * This work was supported by the One Laptop Per Child project
   8  */
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/device.h>
  12 #include <linux/list.h>
  13 #include <linux/pci.h>
  14 #include <linux/gpio.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/videodev2.h>
  18 #include <media/v4l2-device.h>
  19 #include <media/v4l2-ioctl.h>
  20 #include <media/v4l2-ctrls.h>
  21 #include <media/v4l2-image-sizes.h>
  22 #include <media/ov7670.h>
  23 #include <media/videobuf-dma-sg.h>
  24 #include <linux/delay.h>
  25 #include <linux/dma-mapping.h>
  26 #include <linux/pm_qos.h>
  27 #include <linux/via-core.h>
  28 #include <linux/via-gpio.h>
  29 #include <linux/via_i2c.h>
  30 #include <asm/olpc.h>
  31
  32 #include "via-camera.h"
  33
  34 MODULE_ALIAS("platform:viafb-camera");
  35 MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
  36 MODULE_DESCRIPTION("VIA framebuffer-based camera controller driver");
  37 MODULE_LICENSE("GPL");
  38
  39 static bool flip_image;
  40 module_param(flip_image, bool, 0444);
  41 MODULE_PARM_DESC(flip_image,
  42                 "If set, the sensor will be instructed to flip the image "
  43                 "vertically.");
  44
  45 static bool override_serial;
  46 module_param(override_serial, bool, 0444);
  47 MODULE_PARM_DESC(override_serial,
  48                 "The camera driver will normally refuse to load if "
  49                 "the XO 1.5 serial port is enabled.  Set this option "
  50                 "to force-enable the camera.");
  51
  52 /*
  53  * The structure describing our camera.
  54  */
  55 enum viacam_opstate { S_IDLE = 0, S_RUNNING = 1 };
  56
  57 struct via_camera {
  58         struct v4l2_device v4l2_dev;
  59         struct v4l2_ctrl_handler ctrl_handler;
  60         struct video_device vdev;
  61         struct v4l2_subdev *sensor;
  62         struct platform_device *platdev;
  63         struct viafb_dev *viadev;
  64         struct mutex lock;
  65         enum viacam_opstate opstate;
  66         unsigned long flags;
  67         struct pm_qos_request qos_request;
  68         /*
  69          * GPIO info for power/reset management
  70          */
  71         int power_gpio;
  72         int reset_gpio;
  73         /*
  74          * I/O memory stuff.
  75          */
  76         void __iomem *mmio;     /* Where the registers live */
  77         void __iomem *fbmem;    /* Frame buffer memory */
  78         u32 fb_offset;          /* Reserved memory offset (FB) */
  79         /*
  80          * Capture buffers and related.  The controller supports
  81          * up to three, so that's what we have here.  These buffers
  82          * live in frame buffer memory, so we don't call them "DMA".
  83          */
  84         unsigned int cb_offsets[3];     /* offsets into fb mem */
  85         u8 __iomem *cb_addrs[3];                /* Kernel-space addresses */
  86         int n_cap_bufs;                 /* How many are we using? */
  87         int next_buf;
  88         struct videobuf_queue vb_queue;
  89         struct list_head buffer_queue;  /* prot. by reg_lock */
  90         /*
  91          * User tracking.
  92          */
  93         int users;
  94         struct file *owner;
  95         /*
  96          * Video format information.  sensor_format is kept in a form
  97          * that we can use to pass to the sensor.  We always run the
  98          * sensor in VGA resolution, though, and let the controller
  99          * downscale things if need be.  So we keep the "real*
 100          * dimensions separately.
 101          */
 102         struct v4l2_pix_format sensor_format;
 103         struct v4l2_pix_format user_format;
 104         u32 mbus_code;
 105 };
 106
 107 /*
 108  * Yes, this is a hack, but there's only going to be one of these
 109  * on any system we know of.
 110  */
 111 static struct via_camera *via_cam_info;
 112
 113 /*
 114  * Flag values, manipulated with bitops
 115  */
 116 #define CF_DMA_ACTIVE    0      /* A frame is incoming */
 117 #define CF_CONFIG_NEEDED 1      /* Must configure hardware */
 118
 119
 120 /*
 121  * Nasty ugly v4l2 boilerplate.
 122  */
 123 #define sensor_call(cam, optype, func, args...) \
 124         v4l2_subdev_call(cam->sensor, optype, func, ##args)
 125
 126 /*
 127  * Debugging and related.
 128  */
 129 #define cam_err(cam, fmt, arg...) \
 130         dev_err(&(cam)->platdev->dev, fmt, ##arg);
 131 #define cam_warn(cam, fmt, arg...) \
 132         dev_warn(&(cam)->platdev->dev, fmt, ##arg);
 133 #define cam_dbg(cam, fmt, arg...) \
 134         dev_dbg(&(cam)->platdev->dev, fmt, ##arg);
 135
 136 /*
 137  * Format handling.  This is ripped almost directly from Hans's changes
 138  * to cafe_ccic.c.  It's a little unfortunate; until this change, we
 139  * didn't need to know anything about the format except its byte depth;
 140  * now this information must be managed at this level too.
 141  */
 142 static struct via_format {
 143         __u8 *desc;
 144         __u32 pixelformat;
 145         int bpp;   /* Bytes per pixel */
 146         u32 mbus_code;
 147 } via_formats[] = {
 148         {
 149                 .desc           = "YUYV 4:2:2",
 150                 .pixelformat    = V4L2_PIX_FMT_YUYV,
 151                 .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
 152                 .bpp            = 2,
 153         },
 154         /* RGB444 and Bayer should be doable, but have never been
 155            tested with this driver. RGB565 seems to work at the default
 156            resolution, but results in color corruption when being scaled by
 157            viacam_set_scaled(), and is disabled as a result. */
 158 };
 159 #define N_VIA_FMTS ARRAY_SIZE(via_formats)
 160
 161 static struct via_format *via_find_format(u32 pixelformat)
 162 {
 163         unsigned i;
 164
 165         for (i = 0; i < N_VIA_FMTS; i++)
 166                 if (via_formats[i].pixelformat == pixelformat)
 167                         return via_formats + i;
 168         /* Not found? Then return the first format. */
 169         return via_formats;
 170 }
 171
 172
 173 /*--------------------------------------------------------------------------*/
 174 /*
 175  * Sensor power/reset management.  This piece is OLPC-specific for
 176  * sure; other configurations will have things connected differently.
 177  */
 178 static int via_sensor_power_setup(struct via_camera *cam)
 179 {
 180         int ret;
 181
 182         cam->power_gpio = viafb_gpio_lookup("VGPIO3");
 183         cam->reset_gpio = viafb_gpio_lookup("VGPIO2");
 184         if (cam->power_gpio < 0 || cam->reset_gpio < 0) {
 185                 dev_err(&cam->platdev->dev, "Unable to find GPIO lines\n");
 186                 return -EINVAL;
 187         }
 188         ret = gpio_request(cam->power_gpio, "viafb-camera");
 189         if (ret) {
 190                 dev_err(&cam->platdev->dev, "Unable to request power GPIO\n");
 191                 return ret;
 192         }
 193         ret = gpio_request(cam->reset_gpio, "viafb-camera");
 194         if (ret) {
 195                 dev_err(&cam->platdev->dev, "Unable to request reset GPIO\n");
 196                 gpio_free(cam->power_gpio);
 197                 return ret;
 198         }
 199         gpio_direction_output(cam->power_gpio, 0);
 200         gpio_direction_output(cam->reset_gpio, 0);
 201         return 0;
 202 }
 203
 204 /*
 205  * Power up the sensor and perform the reset dance.
 206  */
 207 static void via_sensor_power_up(struct via_camera *cam)
 208 {
 209         gpio_set_value(cam->power_gpio, 1);
 210         gpio_set_value(cam->reset_gpio, 0);
 211         msleep(20);  /* Probably excessive */
 212         gpio_set_value(cam->reset_gpio, 1);
 213         msleep(20);
 214 }
 215
 216 static void via_sensor_power_down(struct via_camera *cam)
 217 {
 218         gpio_set_value(cam->power_gpio, 0);
 219         gpio_set_value(cam->reset_gpio, 0);
 220 }
 221
 222
 223 static void via_sensor_power_release(struct via_camera *cam)
 224 {
 225         via_sensor_power_down(cam);
 226         gpio_free(cam->power_gpio);
 227         gpio_free(cam->reset_gpio);
 228 }
 229
 230 /* --------------------------------------------------------------------------*/
 231 /* Sensor ops */
 232
 233 /*
 234  * Manage the ov7670 "flip" bit, which needs special help.
 235  */
 236 static int viacam_set_flip(struct via_camera *cam)
 237 {
 238         struct v4l2_control ctrl;
 239
 240         memset(&ctrl, 0, sizeof(ctrl));
 241         ctrl.id = V4L2_CID_VFLIP;
 242         ctrl.value = flip_image;
 243         return sensor_call(cam, core, s_ctrl, &ctrl);
 244 }
 245
 246 /*
 247  * Configure the sensor.  It's up to the caller to ensure
 248  * that the camera is in the correct operating state.
 249  */
 250 static int viacam_configure_sensor(struct via_camera *cam)
 251 {
 252         struct v4l2_mbus_framefmt mbus_fmt;
 253         int ret;
 254
 255         v4l2_fill_mbus_format(&mbus_fmt, &cam->sensor_format, cam->mbus_code);
 256         ret = sensor_call(cam, core, init, 0);
 257         if (ret == 0)
 258                 ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt);
 259         /*
 260          * OV7670 does weird things if flip is set *before* format...
 261          */
 262         if (ret == 0)
 263                 ret = viacam_set_flip(cam);
 264         return ret;
 265 }
 266
 267
 268
 269 /* --------------------------------------------------------------------------*/
 270 /*
 271  * Some simple register accessors; they assume that the lock is held.
 272  *
 273  * Should we want to support the second capture engine, we could
 274  * hide the register difference by adding 0x1000 to registers in the
 275  * 0x300-350 range.
 276  */
 277 static inline void viacam_write_reg(struct via_camera *cam,
 278                 int reg, int value)
 279 {
 280         iowrite32(value, cam->mmio + reg);
 281 }
 282
 283 static inline int viacam_read_reg(struct via_camera *cam, int reg)
 284 {
 285         return ioread32(cam->mmio + reg);
 286 }
 287
 288 static inline void viacam_write_reg_mask(struct via_camera *cam,
 289                 int reg, int value, int mask)
 290 {
 291         int tmp = viacam_read_reg(cam, reg);
 292
 293         tmp = (tmp & ~mask) | (value & mask);
 294         viacam_write_reg(cam, reg, tmp);
 295 }
 296
 297
 298 /* --------------------------------------------------------------------------*/
 299 /* Interrupt management and handling */
 300
 301 static irqreturn_t viacam_quick_irq(int irq, void *data)
 302 {
 303         struct via_camera *cam = data;
 304         irqreturn_t ret = IRQ_NONE;
 305         int icv;
 306
 307         /*
 308          * All we do here is to clear the interrupts and tell
 309          * the handler thread to wake up.
 310          */
 311         spin_lock(&cam->viadev->reg_lock);
 312         icv = viacam_read_reg(cam, VCR_INTCTRL);
 313         if (icv & VCR_IC_EAV) {
 314                 icv |= VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL;
 315                 viacam_write_reg(cam, VCR_INTCTRL, icv);
 316                 ret = IRQ_WAKE_THREAD;
 317         }
 318         spin_unlock(&cam->viadev->reg_lock);
 319         return ret;
 320 }
 321
 322 /*
 323  * Find the next videobuf buffer which has somebody waiting on it.
 324  */
 325 static struct videobuf_buffer *viacam_next_buffer(struct via_camera *cam)
 326 {
 327         unsigned long flags;
 328         struct videobuf_buffer *buf = NULL;
 329
 330         spin_lock_irqsave(&cam->viadev->reg_lock, flags);
 331         if (cam->opstate != S_RUNNING)
 332                 goto out;
 333         if (list_empty(&cam->buffer_queue))
 334                 goto out;
 335         buf = list_entry(cam->buffer_queue.next, struct videobuf_buffer, queue);
 336         if (!waitqueue_active(&buf->done)) {/* Nobody waiting */
 337                 buf = NULL;
 338                 goto out;
 339         }
 340         list_del(&buf->queue);
 341         buf->state = VIDEOBUF_ACTIVE;
 342 out:
 343         spin_unlock_irqrestore(&cam->viadev->reg_lock, flags);
 344         return buf;
 345 }
 346
 347 /*
 348  * The threaded IRQ handler.
 349  */
 350 static irqreturn_t viacam_irq(int irq, void *data)
 351 {
 352         int bufn;
 353         struct videobuf_buffer *vb;
 354         struct via_camera *cam = data;
 355         struct videobuf_dmabuf *vdma;
 356
 357         /*
 358          * If there is no place to put the data frame, don't bother
 359          * with anything else.
 360          */
 361         vb = viacam_next_buffer(cam);
 362         if (vb == NULL)
 363                 goto done;
 364         /*
 365          * Figure out which buffer we just completed.
 366          */
 367         bufn = (viacam_read_reg(cam, VCR_INTCTRL) & VCR_IC_ACTBUF) >> 3;
 368         bufn -= 1;
 369         if (bufn < 0)
 370                 bufn = cam->n_cap_bufs - 1;
 371         /*
 372          * Copy over the data and let any waiters know.
 373          */
 374         vdma = videobuf_to_dma(vb);
 375         viafb_dma_copy_out_sg(cam->cb_offsets[bufn], vdma->sglist, vdma->sglen);
 376         vb->state = VIDEOBUF_DONE;
 377         vb->size = cam->user_format.sizeimage;
 378         wake_up(&vb->done);
 379 done:
 380         return IRQ_HANDLED;
 381 }
 382
 383
 384 /*
 385  * These functions must mess around with the general interrupt
 386  * control register, which is relevant to much more than just the
 387  * camera.  Nothing else uses interrupts, though, as of this writing.
 388  * Should that situation change, we'll have to improve support at
 389  * the via-core level.
 390  */
 391 static void viacam_int_enable(struct via_camera *cam)
 392 {
 393         viacam_write_reg(cam, VCR_INTCTRL,
 394                         VCR_IC_INTEN|VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL);
 395         viafb_irq_enable(VDE_I_C0AVEN);
 396 }
 397
 398 static void viacam_int_disable(struct via_camera *cam)
 399 {
 400         viafb_irq_disable(VDE_I_C0AVEN);
 401         viacam_write_reg(cam, VCR_INTCTRL, 0);
 402 }
 403
 404
 405
 406 /* --------------------------------------------------------------------------*/
 407 /* Controller operations */
 408
 409 /*
 410  * Set up our capture buffers in framebuffer memory.
 411  */
 412 static int viacam_ctlr_cbufs(struct via_camera *cam)
 413 {
 414         int nbuf = cam->viadev->camera_fbmem_size/cam->sensor_format.sizeimage;
 415         int i;
 416         unsigned int offset;
 417
 418         /*
 419          * See how many buffers we can work with.
 420          */
 421         if (nbuf >= 3) {
 422                 cam->n_cap_bufs = 3;
 423                 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_3BUFS,
 424                                 VCR_CI_3BUFS);
 425         } else if (nbuf == 2) {
 426                 cam->n_cap_bufs = 2;
 427                 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_3BUFS);
 428         } else {
 429                 cam_warn(cam, "Insufficient frame buffer memory\n");
 430                 return -ENOMEM;
 431         }
 432         /*
 433          * Set them up.
 434          */
 435         offset = cam->fb_offset;
 436         for (i = 0; i < cam->n_cap_bufs; i++) {
 437                 cam->cb_offsets[i] = offset;
 438                 cam->cb_addrs[i] = cam->fbmem + offset;
 439                 viacam_write_reg(cam, VCR_VBUF1 + i*4, offset & VCR_VBUF_MASK);
 440                 offset += cam->sensor_format.sizeimage;
 441         }
 442         return 0;
 443 }
 444
 445 /*
 446  * Set the scaling register for downscaling the image.
 447  *
 448  * This register works like this...  Vertical scaling is enabled
 449  * by bit 26; if that bit is set, downscaling is controlled by the
 450  * value in bits 16:25.  Those bits are divided by 1024 to get
 451  * the scaling factor; setting just bit 25 thus cuts the height
 452  * in half.
 453  *
 454  * Horizontal scaling works about the same, but it's enabled by
 455  * bit 11, with bits 0:10 giving the numerator of a fraction
 456  * (over 2048) for the scaling value.
 457  *
 458  * This function is naive in that, if the user departs from
 459  * the 3x4 VGA scaling factor, the image will distort.  We
 460  * could work around that if it really seemed important.
 461  */
 462 static void viacam_set_scale(struct via_camera *cam)
 463 {
 464         unsigned int avscale;
 465         int sf;
 466
 467         if (cam->user_format.width == VGA_WIDTH)
 468                 avscale = 0;
 469         else {
 470                 sf = (cam->user_format.width*2048)/VGA_WIDTH;
 471                 avscale = VCR_AVS_HEN | sf;
 472         }
 473         if (cam->user_format.height < VGA_HEIGHT) {
 474                 sf = (1024*cam->user_format.height)/VGA_HEIGHT;
 475                 avscale |= VCR_AVS_VEN | (sf << 16);
 476         }
 477         viacam_write_reg(cam, VCR_AVSCALE, avscale);
 478 }
 479
 480
 481 /*
 482  * Configure image-related information into the capture engine.
 483  */
 484 static void viacam_ctlr_image(struct via_camera *cam)
 485 {
 486         int cicreg;
 487
 488         /*
 489          * Disable clock before messing with stuff - from the via
 490          * sample driver.
 491          */
 492         viacam_write_reg(cam, VCR_CAPINTC, ~(VCR_CI_ENABLE|VCR_CI_CLKEN));
 493         /*
 494          * Set up the controller for VGA resolution, modulo magic
 495          * offsets from the via sample driver.
 496          */
 497         viacam_write_reg(cam, VCR_HORRANGE, 0x06200120);
 498         viacam_write_reg(cam, VCR_VERTRANGE, 0x01de0000);
 499         viacam_set_scale(cam);
 500         /*
 501          * Image size info.
 502          */
 503         viacam_write_reg(cam, VCR_MAXDATA,
 504                         (cam->sensor_format.height << 16) |
 505                         (cam->sensor_format.bytesperline >> 3));
 506         viacam_write_reg(cam, VCR_MAXVBI, 0);
 507         viacam_write_reg(cam, VCR_VSTRIDE,
 508                         cam->user_format.bytesperline & VCR_VS_STRIDE);
 509         /*
 510          * Set up the capture interface control register,
 511          * everything but the "go" bit.
 512          *
 513          * The FIFO threshold is a bit of a magic number; 8 is what
 514          * VIA's sample code uses.
 515          */
 516         cicreg = VCR_CI_CLKEN |
 517                 0x08000000 |            /* FIFO threshold */
 518                 VCR_CI_FLDINV |         /* OLPC-specific? */
 519                 VCR_CI_VREFINV |        /* OLPC-specific? */
 520                 VCR_CI_DIBOTH |         /* Capture both fields */
 521                 VCR_CI_CCIR601_8;
 522         if (cam->n_cap_bufs == 3)
 523                 cicreg |= VCR_CI_3BUFS;
 524         /*
 525          * YUV formats need different byte swapping than RGB.
 526          */
 527         if (cam->user_format.pixelformat == V4L2_PIX_FMT_YUYV)
 528                 cicreg |= VCR_CI_YUYV;
 529         else
 530                 cicreg |= VCR_CI_UYVY;
 531         viacam_write_reg(cam, VCR_CAPINTC, cicreg);
 532 }
 533
 534
 535 static int viacam_config_controller(struct via_camera *cam)
 536 {
 537         int ret;
 538         unsigned long flags;
 539
 540         spin_lock_irqsave(&cam->viadev->reg_lock, flags);
 541         ret = viacam_ctlr_cbufs(cam);
 542         if (!ret)
 543                 viacam_ctlr_image(cam);
 544         spin_unlock_irqrestore(&cam->viadev->reg_lock, flags);
 545         clear_bit(CF_CONFIG_NEEDED, &cam->flags);
 546         return ret;
 547 }
 548
 549 /*
 550  * Make it start grabbing data.
 551  */
 552 static void viacam_start_engine(struct via_camera *cam)
 553 {
 554         spin_lock_irq(&cam->viadev->reg_lock);
 555         cam->next_buf = 0;
 556         viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_ENABLE, VCR_CI_ENABLE);
 557         viacam_int_enable(cam);
 558         (void) viacam_read_reg(cam, VCR_CAPINTC); /* Force post */
 559         cam->opstate = S_RUNNING;
 560         spin_unlock_irq(&cam->viadev->reg_lock);
 561 }
 562
 563
 564 static void viacam_stop_engine(struct via_camera *cam)
 565 {
 566         spin_lock_irq(&cam->viadev->reg_lock);
 567         viacam_int_disable(cam);
 568         viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_ENABLE);
 569         (void) viacam_read_reg(cam, VCR_CAPINTC); /* Force post */
 570         cam->opstate = S_IDLE;
 571         spin_unlock_irq(&cam->viadev->reg_lock);
 572 }
 573
 574
 575 /* --------------------------------------------------------------------------*/
 576 /* Videobuf callback ops */
 577
 578 /*
 579  * buffer_setup.  The purpose of this one would appear to be to tell
 580  * videobuf how big a single image is.  It's also evidently up to us
 581  * to put some sort of limit on the maximum number of buffers allowed.
 582  */
 583 static int viacam_vb_buf_setup(struct videobuf_queue *q,
 584                 unsigned int *count, unsigned int *size)
 585 {
 586         struct via_camera *cam = q->priv_data;
 587
 588         *size = cam->user_format.sizeimage;
 589         if (*count == 0 || *count > 6)  /* Arbitrary number */
 590                 *count = 6;
 591         return 0;
 592 }
 593
 594 /*
 595  * Prepare a buffer.
 596  */
 597 static int viacam_vb_buf_prepare(struct videobuf_queue *q,
 598                 struct videobuf_buffer *vb, enum v4l2_field field)
 599 {
 600         struct via_camera *cam = q->priv_data;
 601
 602         vb->size = cam->user_format.sizeimage;
 603         vb->width = cam->user_format.width; /* bytesperline???? */
 604         vb->height = cam->user_format.height;
 605         vb->field = field;
 606         if (vb->state == VIDEOBUF_NEEDS_INIT) {
 607                 int ret = videobuf_iolock(q, vb, NULL);
 608                 if (ret)
 609                         return ret;
 610         }
 611         vb->state = VIDEOBUF_PREPARED;
 612         return 0;
 613 }
 614
 615 /*
 616  * We've got a buffer to put data into.
 617  *
 618  * FIXME: check for a running engine and valid buffers?
 619  */
 620 static void viacam_vb_buf_queue(struct videobuf_queue *q,
 621                 struct videobuf_buffer *vb)
 622 {
 623         struct via_camera *cam = q->priv_data;
 624
 625         /*
 626          * Note that videobuf holds the lock when it calls
 627          * us, so we need not (indeed, cannot) take it here.
 628          */
 629         vb->state = VIDEOBUF_QUEUED;
 630         list_add_tail(&vb->queue, &cam->buffer_queue);
 631 }
 632
 633 /*
 634  * Free a buffer.
 635  */
 636 static void viacam_vb_buf_release(struct videobuf_queue *q,
 637                 struct videobuf_buffer *vb)
 638 {
 639         struct via_camera *cam = q->priv_data;
 640
 641         videobuf_dma_unmap(&cam->platdev->dev, videobuf_to_dma(vb));
 642         videobuf_dma_free(videobuf_to_dma(vb));
 643         vb->state = VIDEOBUF_NEEDS_INIT;
 644 }
 645
 646 static const struct videobuf_queue_ops viacam_vb_ops = {
 647         .buf_setup      = viacam_vb_buf_setup,
 648         .buf_prepare    = viacam_vb_buf_prepare,
 649         .buf_queue      = viacam_vb_buf_queue,
 650         .buf_release    = viacam_vb_buf_release,
 651 };
 652
 653 /* --------------------------------------------------------------------------*/
 654 /* File operations */
 655
 656 static int viacam_open(struct file *filp)
 657 {
 658         struct via_camera *cam = video_drvdata(filp);
 659
 660         filp->private_data = cam;
 661         /*
 662          * Note the new user.  If this is the first one, we'll also
 663          * need to power up the sensor.
 664          */
 665         mutex_lock(&cam->lock);
 666         if (cam->users == 0) {
 667                 int ret = viafb_request_dma();
 668
 669                 if (ret) {
 670                         mutex_unlock(&cam->lock);
 671                         return ret;
 672                 }
 673                 via_sensor_power_up(cam);
 674                 set_bit(CF_CONFIG_NEEDED, &cam->flags);
 675                 /*
 676                  * Hook into videobuf.  Evidently this cannot fail.
 677                  */
 678                 videobuf_queue_sg_init(&cam->vb_queue, &viacam_vb_ops,
 679                                 &cam->platdev->dev, &cam->viadev->reg_lock,
 680                                 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
 681                                 sizeof(struct videobuf_buffer), cam, NULL);
 682         }
 683         (cam->users)++;
 684         mutex_unlock(&cam->lock);
 685         return 0;
 686 }
 687
 688 static int viacam_release(struct file *filp)
 689 {
 690         struct via_camera *cam = video_drvdata(filp);
 691
 692         mutex_lock(&cam->lock);
 693         (cam->users)--;
 694         /*
 695          * If the "owner" is closing, shut down any ongoing
 696          * operations.
 697          */
 698         if (filp == cam->owner) {
 699                 videobuf_stop(&cam->vb_queue);
 700                 /*
 701                  * We don't hold the spinlock here, but, if release()
 702                  * is being called by the owner, nobody else will
 703                  * be changing the state.  And an extra stop would
 704                  * not hurt anyway.
 705                  */
 706                 if (cam->opstate != S_IDLE)
 707                         viacam_stop_engine(cam);
 708                 cam->owner = NULL;
 709         }
 710         /*
 711          * Last one out needs to turn out the lights.
 712          */
 713         if (cam->users == 0) {
 714                 videobuf_mmap_free(&cam->vb_queue);
 715                 via_sensor_power_down(cam);
 716                 viafb_release_dma();
 717         }
 718         mutex_unlock(&cam->lock);
 719         return 0;
 720 }
 721
 722 /*
 723  * Read a frame from the device.
 724  */
 725 static ssize_t viacam_read(struct file *filp, char __user *buffer,
 726                 size_t len, loff_t *pos)
 727 {
 728         struct via_camera *cam = video_drvdata(filp);
 729         int ret;
 730
 731         mutex_lock(&cam->lock);
 732         /*
 733          * Enforce the V4l2 "only one owner gets to read data" rule.
 734          */
 735         if (cam->owner && cam->owner != filp) {
 736                 ret = -EBUSY;
 737                 goto out_unlock;
 738         }
 739         cam->owner = filp;
 740         /*
 741          * Do we need to configure the hardware?
 742          */
 743         if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) {
 744                 ret = viacam_configure_sensor(cam);
 745                 if (!ret)
 746                         ret = viacam_config_controller(cam);
 747                 if (ret)
 748                         goto out_unlock;
 749         }
 750         /*
 751          * Fire up the capture engine, then have videobuf do
 752          * the heavy lifting.  Someday it would be good to avoid
 753          * stopping and restarting the engine each time.
 754          */
 755         INIT_LIST_HEAD(&cam->buffer_queue);
 756         viacam_start_engine(cam);
 757         ret = videobuf_read_stream(&cam->vb_queue, buffer, len, pos, 0,
 758                         filp->f_flags & O_NONBLOCK);
 759         viacam_stop_engine(cam);
 760         /* videobuf_stop() ?? */
 761
 762 out_unlock:
 763         mutex_unlock(&cam->lock);
 764         return ret;
 765 }
 766
 767
 768 static unsigned int viacam_poll(struct file *filp, struct poll_table_struct *pt)
 769 {
 770         struct via_camera *cam = video_drvdata(filp);
 771
 772         return videobuf_poll_stream(filp, &cam->vb_queue, pt);
 773 }
 774
 775
 776 static int viacam_mmap(struct file *filp, struct vm_area_struct *vma)
 777 {
 778         struct via_camera *cam = video_drvdata(filp);
 779
 780         return videobuf_mmap_mapper(&cam->vb_queue, vma);
 781 }
 782
 783
 784
 785 static const struct v4l2_file_operations viacam_fops = {
 786         .owner          = THIS_MODULE,
 787         .open           = viacam_open,
 788         .release        = viacam_release,
 789         .read           = viacam_read,
 790         .poll           = viacam_poll,
 791         .mmap           = viacam_mmap,
 792         .unlocked_ioctl = video_ioctl2,
 793 };
 794
 795 /*----------------------------------------------------------------------------*/
 796 /*
 797  * The long list of v4l2 ioctl ops
 798  */
 799
 800 /*
 801  * Only one input.
 802  */
 803 static int viacam_enum_input(struct file *filp, void *priv,
 804                 struct v4l2_input *input)
 805 {
 806         if (input->index != 0)
 807                 return -EINVAL;
 808
 809         input->type = V4L2_INPUT_TYPE_CAMERA;
 810         input->std = V4L2_STD_ALL; /* Not sure what should go here */
 811         strcpy(input->name, "Camera");
 812         return 0;
 813 }
 814
 815 static int viacam_g_input(struct file *filp, void *priv, unsigned int *i)
 816 {
 817         *i = 0;
 818         return 0;
 819 }
 820
 821 static int viacam_s_input(struct file *filp, void *priv, unsigned int i)
 822 {
 823         if (i != 0)
 824                 return -EINVAL;
 825         return 0;
 826 }
 827
 828 static int viacam_s_std(struct file *filp, void *priv, v4l2_std_id std)
 829 {
 830         return 0;
 831 }
 832
 833 static int viacam_g_std(struct file *filp, void *priv, v4l2_std_id *std)
 834 {
 835         *std = V4L2_STD_NTSC_M;
 836         return 0;
 837 }
 838
 839 /*
 840  * Video format stuff.  Here is our default format until
 841  * user space messes with things.
 842  */
 843 static const struct v4l2_pix_format viacam_def_pix_format = {
 844         .width          = VGA_WIDTH,
 845         .height         = VGA_HEIGHT,
 846         .pixelformat    = V4L2_PIX_FMT_YUYV,
 847         .field          = V4L2_FIELD_NONE,
 848         .bytesperline   = VGA_WIDTH * 2,
 849         .sizeimage      = VGA_WIDTH * VGA_HEIGHT * 2,
 850 };
 851
 852 static const u32 via_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
 853
 854 static int viacam_enum_fmt_vid_cap(struct file *filp, void *priv,
 855                 struct v4l2_fmtdesc *fmt)
 856 {
 857         if (fmt->index >= N_VIA_FMTS)
 858                 return -EINVAL;
 859         strlcpy(fmt->description, via_formats[fmt->index].desc,
 860                         sizeof(fmt->description));
 861         fmt->pixelformat = via_formats[fmt->index].pixelformat;
 862         return 0;
 863 }
 864
 865 /*
 866  * Figure out proper image dimensions, but always force the
 867  * sensor to VGA.
 868  */
 869 static void viacam_fmt_pre(struct v4l2_pix_format *userfmt,
 870                 struct v4l2_pix_format *sensorfmt)
 871 {
 872         *sensorfmt = *userfmt;
 873         if (userfmt->width < QCIF_WIDTH || userfmt->height < QCIF_HEIGHT) {
 874                 userfmt->width = QCIF_WIDTH;
 875                 userfmt->height = QCIF_HEIGHT;
 876         }
 877         if (userfmt->width > VGA_WIDTH || userfmt->height > VGA_HEIGHT) {
 878                 userfmt->width = VGA_WIDTH;
 879                 userfmt->height = VGA_HEIGHT;
 880         }
 881         sensorfmt->width = VGA_WIDTH;
 882         sensorfmt->height = VGA_HEIGHT;
 883 }
 884
 885 static void viacam_fmt_post(struct v4l2_pix_format *userfmt,
 886                 struct v4l2_pix_format *sensorfmt)
 887 {
 888         struct via_format *f = via_find_format(userfmt->pixelformat);
 889
 890         sensorfmt->bytesperline = sensorfmt->width * f->bpp;
 891         sensorfmt->sizeimage = sensorfmt->height * sensorfmt->bytesperline;
 892         userfmt->pixelformat = sensorfmt->pixelformat;
 893         userfmt->field = sensorfmt->field;
 894         userfmt->bytesperline = 2 * userfmt->width;
 895         userfmt->sizeimage = userfmt->bytesperline * userfmt->height;
 896 }
 897
 898
 899 /*
 900  * The real work of figuring out a workable format.
 901  */
 902 static int viacam_do_try_fmt(struct via_camera *cam,
 903                 struct v4l2_pix_format *upix, struct v4l2_pix_format *spix)
 904 {
 905         int ret;
 906         struct v4l2_mbus_framefmt mbus_fmt;
 907         struct via_format *f = via_find_format(upix->pixelformat);
 908
 909         upix->pixelformat = f->pixelformat;
 910         viacam_fmt_pre(upix, spix);
 911         v4l2_fill_mbus_format(&mbus_fmt, spix, f->mbus_code);
 912         ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
 913         v4l2_fill_pix_format(spix, &mbus_fmt);
 914         viacam_fmt_post(upix, spix);
 915         return ret;
 916 }
 917
 918
 919
 920 static int viacam_try_fmt_vid_cap(struct file *filp, void *priv,
 921                 struct v4l2_format *fmt)
 922 {
 923         struct via_camera *cam = priv;
 924         struct v4l2_format sfmt;
 925         int ret;
 926
 927         mutex_lock(&cam->lock);
 928         ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix);
 929         mutex_unlock(&cam->lock);
 930         return ret;
 931 }
 932
 933
 934 static int viacam_g_fmt_vid_cap(struct file *filp, void *priv,
 935                 struct v4l2_format *fmt)
 936 {
 937         struct via_camera *cam = priv;
 938
 939         mutex_lock(&cam->lock);
 940         fmt->fmt.pix = cam->user_format;
 941         mutex_unlock(&cam->lock);
 942         return 0;
 943 }
 944
 945 static int viacam_s_fmt_vid_cap(struct file *filp, void *priv,
 946                 struct v4l2_format *fmt)
 947 {
 948         struct via_camera *cam = priv;
 949         int ret;
 950         struct v4l2_format sfmt;
 951         struct via_format *f = via_find_format(fmt->fmt.pix.pixelformat);
 952
 953         /*
 954          * Camera must be idle or we can't mess with the
 955          * video setup.
 956          */
 957         mutex_lock(&cam->lock);
 958         if (cam->opstate != S_IDLE) {
 959                 ret = -EBUSY;
 960                 goto out;
 961         }
 962         /*
 963          * Let the sensor code look over and tweak the
 964          * requested formatting.
 965          */
 966         ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix);
 967         if (ret)
 968                 goto out;
 969         /*
 970          * OK, let's commit to the new format.
 971          */
 972         cam->user_format = fmt->fmt.pix;
 973         cam->sensor_format = sfmt.fmt.pix;
 974         cam->mbus_code = f->mbus_code;
 975         ret = viacam_configure_sensor(cam);
 976         if (!ret)
 977                 ret = viacam_config_controller(cam);
 978 out:
 979         mutex_unlock(&cam->lock);
 980         return ret;
 981 }
 982
 983 static int viacam_querycap(struct file *filp, void *priv,
 984                 struct v4l2_capability *cap)
 985 {
 986         strcpy(cap->driver, "via-camera");
 987         strcpy(cap->card, "via-camera");
 988         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
 989                 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
 990         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 991         return 0;
 992 }
 993
 994 /*
 995  * Streaming operations - pure videobuf stuff.
 996  */
 997 static int viacam_reqbufs(struct file *filp, void *priv,
 998                 struct v4l2_requestbuffers *rb)
 999 {
1000         struct via_camera *cam = priv;
1001
1002         return videobuf_reqbufs(&cam->vb_queue, rb);
1003 }
1004
1005 static int viacam_querybuf(struct file *filp, void *priv,
1006                 struct v4l2_buffer *buf)
1007 {
1008         struct via_camera *cam = priv;
1009
1010         return videobuf_querybuf(&cam->vb_queue, buf);
1011 }
1012
1013 static int viacam_qbuf(struct file *filp, void *priv, struct v4l2_buffer *buf)
1014 {
1015         struct via_camera *cam = priv;
1016
1017         return videobuf_qbuf(&cam->vb_queue, buf);
1018 }
1019
1020 static int viacam_dqbuf(struct file *filp, void *priv, struct v4l2_buffer *buf)
1021 {
1022         struct via_camera *cam = priv;
1023
1024         return videobuf_dqbuf(&cam->vb_queue, buf, filp->f_flags & O_NONBLOCK);
1025 }
1026
1027 static int viacam_streamon(struct file *filp, void *priv, enum v4l2_buf_type t)
1028 {
1029         struct via_camera *cam = priv;
1030         int ret = 0;
1031
1032         if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1033                 return -EINVAL;
1034
1035         mutex_lock(&cam->lock);
1036         if (cam->opstate != S_IDLE) {
1037                 ret = -EBUSY;
1038                 goto out;
1039         }
1040         /*
1041          * Enforce the V4l2 "only one owner gets to read data" rule.
1042          */
1043         if (cam->owner && cam->owner != filp) {
1044                 ret = -EBUSY;
1045                 goto out;
1046         }
1047         cam->owner = filp;
1048         /*
1049          * Configure things if need be.
1050          */
1051         if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) {
1052                 ret = viacam_configure_sensor(cam);
1053                 if (ret)
1054                         goto out;
1055                 ret = viacam_config_controller(cam);
1056                 if (ret)
1057                         goto out;
1058         }
1059         /*
1060          * If the CPU goes into C3, the DMA transfer gets corrupted and
1061          * users start filing unsightly bug reports.  Put in a "latency"
1062          * requirement which will keep the CPU out of the deeper sleep
1063          * states.
1064          */
1065         pm_qos_add_request(&cam->qos_request, PM_QOS_CPU_DMA_LATENCY, 50);
1066         /*
1067          * Fire things up.
1068          */
1069         INIT_LIST_HEAD(&cam->buffer_queue);
1070         ret = videobuf_streamon(&cam->vb_queue);
1071         if (!ret)
1072                 viacam_start_engine(cam);
1073 out:
1074         mutex_unlock(&cam->lock);
1075         return ret;
1076 }
1077
1078 static int viacam_streamoff(struct file *filp, void *priv, enum v4l2_buf_type t)
1079 {
1080         struct via_camera *cam = priv;
1081         int ret;
1082
1083         if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1084                 return -EINVAL;
1085         mutex_lock(&cam->lock);
1086         if (cam->opstate != S_RUNNING) {
1087                 ret = -EINVAL;
1088                 goto out;
1089         }
1090         pm_qos_remove_request(&cam->qos_request);
1091         viacam_stop_engine(cam);
1092         /*
1093          * Videobuf will recycle all of the outstanding buffers, but
1094          * we should be sure we don't retain any references to
1095          * any of them.
1096          */
1097         ret = videobuf_streamoff(&cam->vb_queue);
1098         INIT_LIST_HEAD(&cam->buffer_queue);
1099 out:
1100         mutex_unlock(&cam->lock);
1101         return ret;
1102 }
1103
1104 /* G/S_PARM */
1105
1106 static int viacam_g_parm(struct file *filp, void *priv,
1107                 struct v4l2_streamparm *parm)
1108 {
1109         struct via_camera *cam = priv;
1110         int ret;
1111
1112         mutex_lock(&cam->lock);
1113         ret = sensor_call(cam, video, g_parm, parm);
1114         mutex_unlock(&cam->lock);
1115         parm->parm.capture.readbuffers = cam->n_cap_bufs;
1116         return ret;
1117 }
1118
1119 static int viacam_s_parm(struct file *filp, void *priv,
1120                 struct v4l2_streamparm *parm)
1121 {
1122         struct via_camera *cam = priv;
1123         int ret;
1124
1125         mutex_lock(&cam->lock);
1126         ret = sensor_call(cam, video, s_parm, parm);
1127         mutex_unlock(&cam->lock);
1128         parm->parm.capture.readbuffers = cam->n_cap_bufs;
1129         return ret;
1130 }
1131
1132 static int viacam_enum_framesizes(struct file *filp, void *priv,
1133                 struct v4l2_frmsizeenum *sizes)
1134 {
1135         if (sizes->index != 0)
1136                 return -EINVAL;
1137         sizes->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
1138         sizes->stepwise.min_width = QCIF_WIDTH;
1139         sizes->stepwise.min_height = QCIF_HEIGHT;
1140         sizes->stepwise.max_width = VGA_WIDTH;
1141         sizes->stepwise.max_height = VGA_HEIGHT;
1142         sizes->stepwise.step_width = sizes->stepwise.step_height = 1;
1143         return 0;
1144 }
1145
1146 static int viacam_enum_frameintervals(struct file *filp, void *priv,
1147                 struct v4l2_frmivalenum *interval)
1148 {
1149         struct via_camera *cam = priv;
1150         struct v4l2_subdev_frame_interval_enum fie = {
1151                 .index = interval->index,
1152                 .code = cam->mbus_code,
1153                 .width = cam->sensor_format.width,
1154                 .height = cam->sensor_format.height,
1155                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1156         };
1157         int ret;
1158
1159         mutex_lock(&cam->lock);
1160         ret = sensor_call(cam, pad, enum_frame_interval, NULL, &fie);
1161         mutex_unlock(&cam->lock);
1162         if (ret)
1163                 return ret;
1164         interval->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1165         interval->discrete = fie.interval;
1166         return 0;
1167 }
1168
1169
1170
1171 static const struct v4l2_ioctl_ops viacam_ioctl_ops = {
1172         .vidioc_enum_input      = viacam_enum_input,
1173         .vidioc_g_input         = viacam_g_input,
1174         .vidioc_s_input         = viacam_s_input,
1175         .vidioc_s_std           = viacam_s_std,
1176         .vidioc_g_std           = viacam_g_std,
1177         .vidioc_enum_fmt_vid_cap = viacam_enum_fmt_vid_cap,
1178         .vidioc_try_fmt_vid_cap = viacam_try_fmt_vid_cap,
1179         .vidioc_g_fmt_vid_cap   = viacam_g_fmt_vid_cap,
1180         .vidioc_s_fmt_vid_cap   = viacam_s_fmt_vid_cap,
1181         .vidioc_querycap        = viacam_querycap,
1182         .vidioc_reqbufs         = viacam_reqbufs,
1183         .vidioc_querybuf        = viacam_querybuf,
1184         .vidioc_qbuf            = viacam_qbuf,
1185         .vidioc_dqbuf           = viacam_dqbuf,
1186         .vidioc_streamon        = viacam_streamon,
1187         .vidioc_streamoff       = viacam_streamoff,
1188         .vidioc_g_parm          = viacam_g_parm,
1189         .vidioc_s_parm          = viacam_s_parm,
1190         .vidioc_enum_framesizes = viacam_enum_framesizes,
1191         .vidioc_enum_frameintervals = viacam_enum_frameintervals,
1192 };
1193
1194 /*----------------------------------------------------------------------------*/
1195
1196 /*
1197  * Power management.
1198  */
1199 #ifdef CONFIG_PM
1200
1201 static int viacam_suspend(void *priv)
1202 {
1203         struct via_camera *cam = priv;
1204         enum viacam_opstate state = cam->opstate;
1205
1206         if (cam->opstate != S_IDLE) {
1207                 viacam_stop_engine(cam);
1208                 cam->opstate = state; /* So resume restarts */
1209         }
1210
1211         return 0;
1212 }
1213
1214 static int viacam_resume(void *priv)
1215 {
1216         struct via_camera *cam = priv;
1217         int ret = 0;
1218
1219         /*
1220          * Get back to a reasonable operating state.
1221          */
1222         via_write_reg_mask(VIASR, 0x78, 0, 0x80);
1223         via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0);
1224         viacam_int_disable(cam);
1225         set_bit(CF_CONFIG_NEEDED, &cam->flags);
1226         /*
1227          * Make sure the sensor's power state is correct
1228          */
1229         if (cam->users > 0)
1230                 via_sensor_power_up(cam);
1231         else
1232                 via_sensor_power_down(cam);
1233         /*
1234          * If it was operating, try to restart it.
1235          */
1236         if (cam->opstate != S_IDLE) {
1237                 mutex_lock(&cam->lock);
1238                 ret = viacam_configure_sensor(cam);
1239                 if (!ret)
1240                         ret = viacam_config_controller(cam);
1241                 mutex_unlock(&cam->lock);
1242                 if (!ret)
1243                         viacam_start_engine(cam);
1244         }
1245
1246         return ret;
1247 }
1248
1249 static struct viafb_pm_hooks viacam_pm_hooks = {
1250         .suspend = viacam_suspend,
1251         .resume = viacam_resume
1252 };
1253
1254 #endif /* CONFIG_PM */
1255
1256 /*
1257  * Setup stuff.
1258  */
1259
1260 static struct video_device viacam_v4l_template = {
1261         .name           = "via-camera",
1262         .minor          = -1,
1263         .tvnorms        = V4L2_STD_NTSC_M,
1264         .fops           = &viacam_fops,
1265         .ioctl_ops      = &viacam_ioctl_ops,
1266         .release        = video_device_release_empty, /* Check this */
1267 };
1268
1269 /*
1270  * The OLPC folks put the serial port on the same pin as
1271  * the camera.  They also get grumpy if we break the
1272  * serial port and keep them from using it.  So we have
1273  * to check the serial enable bit and not step on it.
1274  */
1275 #define VIACAM_SERIAL_DEVFN 0x88
1276 #define VIACAM_SERIAL_CREG 0x46
1277 #define VIACAM_SERIAL_BIT 0x40
1278
1279 static bool viacam_serial_is_enabled(void)
1280 {
1281         struct pci_bus *pbus = pci_find_bus(0, 0);
1282         u8 cbyte;
1283
1284         if (!pbus)
1285                 return false;
1286         pci_bus_read_config_byte(pbus, VIACAM_SERIAL_DEVFN,
1287                         VIACAM_SERIAL_CREG, &cbyte);
1288         if ((cbyte & VIACAM_SERIAL_BIT) == 0)
1289                 return false; /* Not enabled */
1290         if (!override_serial) {
1291                 printk(KERN_NOTICE "Via camera: serial port is enabled, " \
1292                                 "refusing to load.\n");
1293                 printk(KERN_NOTICE "Specify override_serial=1 to force " \
1294                                 "module loading.\n");
1295                 return true;
1296         }
1297         printk(KERN_NOTICE "Via camera: overriding serial port\n");
1298         pci_bus_write_config_byte(pbus, VIACAM_SERIAL_DEVFN,
1299                         VIACAM_SERIAL_CREG, cbyte & ~VIACAM_SERIAL_BIT);
1300         return false;
1301 }
1302
1303 static struct ov7670_config sensor_cfg = {
1304         /* The XO-1.5 (only known user) clocks the camera at 90MHz. */
1305         .clock_speed = 90,
1306 };
1307
1308 static int viacam_probe(struct platform_device *pdev)
1309 {
1310         int ret;
1311         struct i2c_adapter *sensor_adapter;
1312         struct viafb_dev *viadev = pdev->dev.platform_data;
1313         struct i2c_board_info ov7670_info = {
1314                 .type = "ov7670",
1315                 .addr = 0x42 >> 1,
1316                 .platform_data = &sensor_cfg,
1317         };
1318
1319         /*
1320          * Note that there are actually two capture channels on
1321          * the device.  We only deal with one for now.  That
1322          * is encoded here; nothing else assumes it's dealing with
1323          * a unique capture device.
1324          */
1325         struct via_camera *cam;
1326
1327         /*
1328          * Ensure that frame buffer memory has been set aside for
1329          * this purpose.  As an arbitrary limit, refuse to work
1330          * with less than two frames of VGA 16-bit data.
1331          *
1332          * If we ever support the second port, we'll need to set
1333          * aside more memory.
1334          */
1335         if (viadev->camera_fbmem_size < (VGA_HEIGHT*VGA_WIDTH*4)) {
1336                 printk(KERN_ERR "viacam: insufficient FB memory reserved\n");
1337                 return -ENOMEM;
1338         }
1339         if (viadev->engine_mmio == NULL) {
1340                 printk(KERN_ERR "viacam: No I/O memory, so no pictures\n");
1341                 return -ENOMEM;
1342         }
1343
1344         if (machine_is_olpc() && viacam_serial_is_enabled())
1345                 return -EBUSY;
1346
1347         /*
1348          * Basic structure initialization.
1349          */
1350         cam = kzalloc (sizeof(struct via_camera), GFP_KERNEL);
1351         if (cam == NULL)
1352                 return -ENOMEM;
1353         via_cam_info = cam;
1354         cam->platdev = pdev;
1355         cam->viadev = viadev;
1356         cam->users = 0;
1357         cam->owner = NULL;
1358         cam->opstate = S_IDLE;
1359         cam->user_format = cam->sensor_format = viacam_def_pix_format;
1360         mutex_init(&cam->lock);
1361         INIT_LIST_HEAD(&cam->buffer_queue);
1362         cam->mmio = viadev->engine_mmio;
1363         cam->fbmem = viadev->fbmem;
1364         cam->fb_offset = viadev->camera_fbmem_offset;
1365         cam->flags = 1 << CF_CONFIG_NEEDED;
1366         cam->mbus_code = via_def_mbus_code;
1367         /*
1368          * Tell V4L that we exist.
1369          */
1370         ret = v4l2_device_register(&pdev->dev, &cam->v4l2_dev);
1371         if (ret) {
1372                 dev_err(&pdev->dev, "Unable to register v4l2 device\n");
1373                 goto out_free;
1374         }
1375         ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
1376         if (ret)
1377                 goto out_unregister;
1378         cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
1379         /*
1380          * Convince the system that we can do DMA.
1381          */
1382         pdev->dev.dma_mask = &viadev->pdev->dma_mask;
1383         dma_set_mask(&pdev->dev, 0xffffffff);
1384         /*
1385          * Fire up the capture port.  The write to 0x78 looks purely
1386          * OLPCish; any system will need to tweak 0x1e.
1387          */
1388         via_write_reg_mask(VIASR, 0x78, 0, 0x80);
1389         via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0);
1390         /*
1391          * Get the sensor powered up.
1392          */
1393         ret = via_sensor_power_setup(cam);
1394         if (ret)
1395                 goto out_ctrl_hdl_free;
1396         via_sensor_power_up(cam);
1397
1398         /*
1399          * See if we can't find it on the bus.  The VIA_PORT_31 assumption
1400          * is OLPC-specific.  0x42 assumption is ov7670-specific.
1401          */
1402         sensor_adapter = viafb_find_i2c_adapter(VIA_PORT_31);
1403         cam->sensor = v4l2_i2c_new_subdev_board(&cam->v4l2_dev, sensor_adapter,
1404                         &ov7670_info, NULL);
1405         if (cam->sensor == NULL) {
1406                 dev_err(&pdev->dev, "Unable to find the sensor!\n");
1407                 ret = -ENODEV;
1408                 goto out_power_down;
1409         }
1410         /*
1411          * Get the IRQ.
1412          */
1413         viacam_int_disable(cam);
1414         ret = request_threaded_irq(viadev->pdev->irq, viacam_quick_irq,
1415                         viacam_irq, IRQF_SHARED, "via-camera", cam);
1416         if (ret)
1417                 goto out_power_down;
1418         /*
1419          * Tell V4l2 that we exist.
1420          */
1421         cam->vdev = viacam_v4l_template;
1422         cam->vdev.v4l2_dev = &cam->v4l2_dev;
1423         ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1424         if (ret)
1425                 goto out_irq;
1426         video_set_drvdata(&cam->vdev, cam);
1427
1428 #ifdef CONFIG_PM
1429         /*
1430          * Hook into PM events
1431          */
1432         viacam_pm_hooks.private = cam;
1433         viafb_pm_register(&viacam_pm_hooks);
1434 #endif
1435
1436         /* Power the sensor down until somebody opens the device */
1437         via_sensor_power_down(cam);
1438         return 0;
1439
1440 out_irq:
1441         free_irq(viadev->pdev->irq, cam);
1442 out_power_down:
1443         via_sensor_power_release(cam);
1444 out_ctrl_hdl_free:
1445         v4l2_ctrl_handler_free(&cam->ctrl_handler);
1446 out_unregister:
1447         v4l2_device_unregister(&cam->v4l2_dev);
1448 out_free:
1449         kfree(cam);
1450         return ret;
1451 }
1452
1453 static int viacam_remove(struct platform_device *pdev)
1454 {
1455         struct via_camera *cam = via_cam_info;
1456         struct viafb_dev *viadev = pdev->dev.platform_data;
1457
1458         video_unregister_device(&cam->vdev);
1459         v4l2_device_unregister(&cam->v4l2_dev);
1460         free_irq(viadev->pdev->irq, cam);
1461         via_sensor_power_release(cam);
1462         v4l2_ctrl_handler_free(&cam->ctrl_handler);
1463         kfree(cam);
1464         via_cam_info = NULL;
1465         return 0;
1466 }
1467
1468 static struct platform_driver viacam_driver = {
1469         .driver = {
1470                 .name = "viafb-camera",
1471         },
1472         .probe = viacam_probe,
1473         .remove = viacam_remove,
1474 };
1475
1476 module_platform_driver(viacam_driver);