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