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 34MODULE_ALIAS("platform:viafb-camera"); 35MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>"); 36MODULE_DESCRIPTION("VIA framebuffer-based camera controller driver"); 37MODULE_LICENSE("GPL"); 38 39static bool flip_image; 40module_param(flip_image, bool, 0444); 41MODULE_PARM_DESC(flip_image, 42 "If set, the sensor will be instructed to flip the image " 43 "vertically."); 44 45static bool override_serial; 46module_param(override_serial, bool, 0444); 47MODULE_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 */ 55enum viacam_opstate { S_IDLE = 0, S_RUNNING = 1 }; 56 57struct 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 */ 111static 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 */ 142static 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 161static 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 */ 178static 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 */ 207static 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 216static 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 223static 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 */ 236static 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 */ 250static 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 */ 277static inline void viacam_write_reg(struct via_camera *cam, 278 int reg, int value) 279{ 280 iowrite32(value, cam->mmio + reg); 281} 282 283static inline int viacam_read_reg(struct via_camera *cam, int reg) 284{ 285 return ioread32(cam->mmio + reg); 286} 287 288static 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 301static 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 */ 325static 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; 342out: 343 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags); 344 return buf; 345} 346 347/* 348 * The threaded IRQ handler. 349 */ 350static 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); 379done: 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 */ 391static 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 398static 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 */ 412static 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 */ 462static 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 */ 484static 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 535static 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 */ 552static 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 564static 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 */ 583static 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 */ 597static 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 */ 620static 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 */ 636static 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 646static 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 656static 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 688static 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 */ 725static 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 762out_unlock: 763 mutex_unlock(&cam->lock); 764 return ret; 765} 766 767 768static 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 776static 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 785static 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 */ 803static 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 815static int viacam_g_input(struct file *filp, void *priv, unsigned int *i) 816{ 817 *i = 0; 818 return 0; 819} 820 821static 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 828static int viacam_s_std(struct file *filp, void *priv, v4l2_std_id std) 829{ 830 return 0; 831} 832 833static 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 */ 843static 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 852static const u32 via_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8; 853 854static 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 */ 869static 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 885static 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 */ 902static 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 920static 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 934static 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 945static 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); 978out: 979 mutex_unlock(&cam->lock); 980 return ret; 981} 982 983static 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 */ 997static 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 1005static 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 1013static 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 1020static 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 1027static 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); 1073out: 1074 mutex_unlock(&cam->lock); 1075 return ret; 1076} 1077 1078static 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); 1099out: 1100 mutex_unlock(&cam->lock); 1101 return ret; 1102} 1103 1104/* G/S_PARM */ 1105 1106static 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 1119static 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 1132static 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 1146static 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 1171static 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 1201static 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 1214static 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 1249static 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 1260static 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 1279static 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 1303static struct ov7670_config sensor_cfg = { 1304 /* The XO-1.5 (only known user) clocks the camera at 90MHz. */ 1305 .clock_speed = 90, 1306}; 1307 1308static 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 1440out_irq: 1441 free_irq(viadev->pdev->irq, cam); 1442out_power_down: 1443 via_sensor_power_release(cam); 1444out_ctrl_hdl_free: 1445 v4l2_ctrl_handler_free(&cam->ctrl_handler); 1446out_unregister: 1447 v4l2_device_unregister(&cam->v4l2_dev); 1448out_free: 1449 kfree(cam); 1450 return ret; 1451} 1452 1453static 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 1468static struct platform_driver viacam_driver = { 1469 .driver = { 1470 .name = "viafb-camera", 1471 }, 1472 .probe = viacam_probe, 1473 .remove = viacam_remove, 1474}; 1475 1476module_platform_driver(viacam_driver); 1477