drivers/media/video/omap24xxcam.c

   1 /*
   2  * drivers/media/video/omap24xxcam.c
   3  *
   4  * OMAP 2 camera block driver.
   5  *
   6  * Copyright (C) 2004 MontaVista Software, Inc.
   7  * Copyright (C) 2004 Texas Instruments.
   8  * Copyright (C) 2007-2008 Nokia Corporation.
   9  *
  10  * Contact: Sakari Ailus <sakari.ailus@nokia.com>
  11  *
  12  * Based on code from Andy Lowe <source@mvista.com>
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * version 2 as published by the Free Software Foundation.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  26  * 02110-1301 USA
  27  */
  28
  29 #include <linux/delay.h>
  30 #include <linux/kernel.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/videodev2.h>
  33 #include <linux/pci.h>          /* needed for videobufs */
  34 #include <linux/platform_device.h>
  35 #include <linux/clk.h>
  36 #include <linux/io.h>
  37 #include <linux/slab.h>
  38 #include <linux/sched.h>
  39
  40 #include <media/v4l2-common.h>
  41 #include <media/v4l2-ioctl.h>
  42
  43 #include "omap24xxcam.h"
  44
  45 #define OMAP24XXCAM_VERSION "0.0.1"
  46
  47 #define RESET_TIMEOUT_NS 10000
  48
  49 static void omap24xxcam_reset(struct omap24xxcam_device *cam);
  50 static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam);
  51 static void omap24xxcam_device_unregister(struct v4l2_int_device *s);
  52 static int omap24xxcam_remove(struct platform_device *pdev);
  53
  54 /* module parameters */
  55 static int video_nr = -1;       /* video device minor (-1 ==> auto assign) */
  56 /*
  57  * Maximum amount of memory to use for capture buffers.
  58  * Default is 4800KB, enough to double-buffer SXGA.
  59  */
  60 static int capture_mem = 1280 * 960 * 2 * 2;
  61
  62 static struct v4l2_int_device omap24xxcam;
  63
  64 /*
  65  *
  66  * Clocks.
  67  *
  68  */
  69
  70 static void omap24xxcam_clock_put(struct omap24xxcam_device *cam)
  71 {
  72         if (cam->ick != NULL && !IS_ERR(cam->ick))
  73                 clk_put(cam->ick);
  74         if (cam->fck != NULL && !IS_ERR(cam->fck))
  75                 clk_put(cam->fck);
  76
  77         cam->ick = cam->fck = NULL;
  78 }
  79
  80 static int omap24xxcam_clock_get(struct omap24xxcam_device *cam)
  81 {
  82         int rval = 0;
  83
  84         cam->fck = clk_get(cam->dev, "fck");
  85         if (IS_ERR(cam->fck)) {
  86                 dev_err(cam->dev, "can't get camera fck");
  87                 rval = PTR_ERR(cam->fck);
  88                 omap24xxcam_clock_put(cam);
  89                 return rval;
  90         }
  91
  92         cam->ick = clk_get(cam->dev, "ick");
  93         if (IS_ERR(cam->ick)) {
  94                 dev_err(cam->dev, "can't get camera ick");
  95                 rval = PTR_ERR(cam->ick);
  96                 omap24xxcam_clock_put(cam);
  97         }
  98
  99         return rval;
 100 }
 101
 102 static void omap24xxcam_clock_on(struct omap24xxcam_device *cam)
 103 {
 104         clk_enable(cam->fck);
 105         clk_enable(cam->ick);
 106 }
 107
 108 static void omap24xxcam_clock_off(struct omap24xxcam_device *cam)
 109 {
 110         clk_disable(cam->fck);
 111         clk_disable(cam->ick);
 112 }
 113
 114 /*
 115  *
 116  * Camera core
 117  *
 118  */
 119
 120 /*
 121  * Set xclk.
 122  *
 123  * To disable xclk, use value zero.
 124  */
 125 static void omap24xxcam_core_xclk_set(const struct omap24xxcam_device *cam,
 126                                       u32 xclk)
 127 {
 128         if (xclk) {
 129                 u32 divisor = CAM_MCLK / xclk;
 130
 131                 if (divisor == 1)
 132                         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
 133                                             CC_CTRL_XCLK,
 134                                             CC_CTRL_XCLK_DIV_BYPASS);
 135                 else
 136                         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
 137                                             CC_CTRL_XCLK, divisor);
 138         } else
 139                 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
 140                                     CC_CTRL_XCLK, CC_CTRL_XCLK_DIV_STABLE_LOW);
 141 }
 142
 143 static void omap24xxcam_core_hwinit(const struct omap24xxcam_device *cam)
 144 {
 145         /*
 146          * Setting the camera core AUTOIDLE bit causes problems with frame
 147          * synchronization, so we will clear the AUTOIDLE bit instead.
 148          */
 149         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_SYSCONFIG,
 150                             CC_SYSCONFIG_AUTOIDLE);
 151
 152         /* program the camera interface DMA packet size */
 153         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL_DMA,
 154                             CC_CTRL_DMA_EN | (DMA_THRESHOLD / 4 - 1));
 155
 156         /* enable camera core error interrupts */
 157         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQENABLE,
 158                             CC_IRQENABLE_FW_ERR_IRQ
 159                             | CC_IRQENABLE_FSC_ERR_IRQ
 160                             | CC_IRQENABLE_SSC_ERR_IRQ
 161                             | CC_IRQENABLE_FIFO_OF_IRQ);
 162 }
 163
 164 /*
 165  * Enable the camera core.
 166  *
 167  * Data transfer to the camera DMA starts from next starting frame.
 168  */
 169 static void omap24xxcam_core_enable(const struct omap24xxcam_device *cam)
 170 {
 171
 172         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
 173                             cam->cc_ctrl);
 174 }
 175
 176 /*
 177  * Disable camera core.
 178  *
 179  * The data transfer will be stopped immediately (CC_CTRL_CC_RST). The
 180  * core internal state machines will be reset. Use
 181  * CC_CTRL_CC_FRAME_TRIG instead if you want to transfer the current
 182  * frame completely.
 183  */
 184 static void omap24xxcam_core_disable(const struct omap24xxcam_device *cam)
 185 {
 186         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
 187                             CC_CTRL_CC_RST);
 188 }
 189
 190 /* Interrupt service routine for camera core interrupts. */
 191 static void omap24xxcam_core_isr(struct omap24xxcam_device *cam)
 192 {
 193         u32 cc_irqstatus;
 194         const u32 cc_irqstatus_err =
 195                 CC_IRQSTATUS_FW_ERR_IRQ
 196                 | CC_IRQSTATUS_FSC_ERR_IRQ
 197                 | CC_IRQSTATUS_SSC_ERR_IRQ
 198                 | CC_IRQSTATUS_FIFO_UF_IRQ
 199                 | CC_IRQSTATUS_FIFO_OF_IRQ;
 200
 201         cc_irqstatus = omap24xxcam_reg_in(cam->mmio_base + CC_REG_OFFSET,
 202                                           CC_IRQSTATUS);
 203         omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQSTATUS,
 204                             cc_irqstatus);
 205
 206         if (cc_irqstatus & cc_irqstatus_err
 207             && !atomic_read(&cam->in_reset)) {
 208                 dev_dbg(cam->dev, "resetting camera, cc_irqstatus 0x%x\n",
 209                         cc_irqstatus);
 210                 omap24xxcam_reset(cam);
 211         }
 212 }
 213
 214 /*
 215  *
 216  * videobuf_buffer handling.
 217  *
 218  * Memory for mmapped videobuf_buffers is not allocated
 219  * conventionally, but by several kmalloc allocations and then
 220  * creating the scatterlist on our own. User-space buffers are handled
 221  * normally.
 222  *
 223  */
 224
 225 /*
 226  * Free the memory-mapped buffer memory allocated for a
 227  * videobuf_buffer and the associated scatterlist.
 228  */
 229 static void omap24xxcam_vbq_free_mmap_buffer(struct videobuf_buffer *vb)
 230 {
 231         struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
 232         size_t alloc_size;
 233         struct page *page;
 234         int i;
 235
 236         if (dma->sglist == NULL)
 237                 return;
 238
 239         i = dma->sglen;
 240         while (i) {
 241                 i--;
 242                 alloc_size = sg_dma_len(&dma->sglist[i]);
 243                 page = sg_page(&dma->sglist[i]);
 244                 do {
 245                         ClearPageReserved(page++);
 246                 } while (alloc_size -= PAGE_SIZE);
 247                 __free_pages(sg_page(&dma->sglist[i]),
 248                              get_order(sg_dma_len(&dma->sglist[i])));
 249         }
 250
 251         kfree(dma->sglist);
 252         dma->sglist = NULL;
 253 }
 254
 255 /* Release all memory related to the videobuf_queue. */
 256 static void omap24xxcam_vbq_free_mmap_buffers(struct videobuf_queue *vbq)
 257 {
 258         int i;
 259
 260         mutex_lock(&vbq->vb_lock);
 261
 262         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
 263                 if (NULL == vbq->bufs[i])
 264                         continue;
 265                 if (V4L2_MEMORY_MMAP != vbq->bufs[i]->memory)
 266                         continue;
 267                 vbq->ops->buf_release(vbq, vbq->bufs[i]);
 268                 omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
 269                 kfree(vbq->bufs[i]);
 270                 vbq->bufs[i] = NULL;
 271         }
 272
 273         mutex_unlock(&vbq->vb_lock);
 274
 275         videobuf_mmap_free(vbq);
 276 }
 277
 278 /*
 279  * Allocate physically as contiguous as possible buffer for video
 280  * frame and allocate and build DMA scatter-gather list for it.
 281  */
 282 static int omap24xxcam_vbq_alloc_mmap_buffer(struct videobuf_buffer *vb)
 283 {
 284         unsigned int order;
 285         size_t alloc_size, size = vb->bsize; /* vb->bsize is page aligned */
 286         struct page *page;
 287         int max_pages, err = 0, i = 0;
 288         struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
 289
 290         /*
 291          * allocate maximum size scatter-gather list. Note this is
 292          * overhead. We may not use as many entries as we allocate
 293          */
 294         max_pages = vb->bsize >> PAGE_SHIFT;
 295         dma->sglist = kcalloc(max_pages, sizeof(*dma->sglist), GFP_KERNEL);
 296         if (dma->sglist == NULL) {
 297                 err = -ENOMEM;
 298                 goto out;
 299         }
 300
 301         while (size) {
 302                 order = get_order(size);
 303                 /*
 304                  * do not over-allocate even if we would get larger
 305                  * contiguous chunk that way
 306                  */
 307                 if ((PAGE_SIZE << order) > size)
 308                         order--;
 309
 310                 /* try to allocate as many contiguous pages as possible */
 311                 page = alloc_pages(GFP_KERNEL, order);
 312                 /* if allocation fails, try to allocate smaller amount */
 313                 while (page == NULL) {
 314                         order--;
 315                         page = alloc_pages(GFP_KERNEL, order);
 316                         if (page == NULL && !order) {
 317                                 err = -ENOMEM;
 318                                 goto out;
 319                         }
 320                 }
 321                 size -= (PAGE_SIZE << order);
 322
 323                 /* append allocated chunk of pages into scatter-gather list */
 324                 sg_set_page(&dma->sglist[i], page, PAGE_SIZE << order, 0);
 325                 dma->sglen++;
 326                 i++;
 327
 328                 alloc_size = (PAGE_SIZE << order);
 329
 330                 /* clear pages before giving them to user space */
 331                 memset(page_address(page), 0, alloc_size);
 332
 333                 /* mark allocated pages reserved */
 334                 do {
 335                         SetPageReserved(page++);
 336                 } while (alloc_size -= PAGE_SIZE);
 337         }
 338         /*
 339          * REVISIT: not fully correct to assign nr_pages == sglen but
 340          * video-buf is passing nr_pages for e.g. unmap_sg calls
 341          */
 342         dma->nr_pages = dma->sglen;
 343         dma->direction = PCI_DMA_FROMDEVICE;
 344
 345         return 0;
 346
 347 out:
 348         omap24xxcam_vbq_free_mmap_buffer(vb);
 349         return err;
 350 }
 351
 352 static int omap24xxcam_vbq_alloc_mmap_buffers(struct videobuf_queue *vbq,
 353                                               unsigned int count)
 354 {
 355         int i, err = 0;
 356         struct omap24xxcam_fh *fh =
 357                 container_of(vbq, struct omap24xxcam_fh, vbq);
 358
 359         mutex_lock(&vbq->vb_lock);
 360
 361         for (i = 0; i < count; i++) {
 362                 err = omap24xxcam_vbq_alloc_mmap_buffer(vbq->bufs[i]);
 363                 if (err)
 364                         goto out;
 365                 dev_dbg(fh->cam->dev, "sglen is %d for buffer %d\n",
 366                         videobuf_to_dma(vbq->bufs[i])->sglen, i);
 367         }
 368
 369         mutex_unlock(&vbq->vb_lock);
 370
 371         return 0;
 372 out:
 373         while (i) {
 374                 i--;
 375                 omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
 376         }
 377
 378         mutex_unlock(&vbq->vb_lock);
 379
 380         return err;
 381 }
 382
 383 /*
 384  * This routine is called from interrupt context when a scatter-gather DMA
 385  * transfer of a videobuf_buffer completes.
 386  */
 387 static void omap24xxcam_vbq_complete(struct omap24xxcam_sgdma *sgdma,
 388                                      u32 csr, void *arg)
 389 {
 390         struct omap24xxcam_device *cam =
 391                 container_of(sgdma, struct omap24xxcam_device, sgdma);
 392         struct omap24xxcam_fh *fh = cam->streaming->private_data;
 393         struct videobuf_buffer *vb = (struct videobuf_buffer *)arg;
 394         const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
 395                 | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
 396                 | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
 397         unsigned long flags;
 398
 399         spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
 400         if (--cam->sgdma_in_queue == 0)
 401                 omap24xxcam_core_disable(cam);
 402         spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 403
 404         do_gettimeofday(&vb->ts);
 405         vb->field_count = atomic_add_return(2, &fh->field_count);
 406         if (csr & csr_error) {
 407                 vb->state = VIDEOBUF_ERROR;
 408                 if (!atomic_read(&fh->cam->in_reset)) {
 409                         dev_dbg(cam->dev, "resetting camera, csr 0x%x\n", csr);
 410                         omap24xxcam_reset(cam);
 411                 }
 412         } else
 413                 vb->state = VIDEOBUF_DONE;
 414         wake_up(&vb->done);
 415 }
 416
 417 static void omap24xxcam_vbq_release(struct videobuf_queue *vbq,
 418                                     struct videobuf_buffer *vb)
 419 {
 420         struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
 421
 422         /* wait for buffer, especially to get out of the sgdma queue */
 423         videobuf_waiton(vbq, vb, 0, 0);
 424         if (vb->memory == V4L2_MEMORY_MMAP) {
 425                 dma_unmap_sg(vbq->dev, dma->sglist, dma->sglen,
 426                              dma->direction);
 427                 dma->direction = DMA_NONE;
 428         } else {
 429                 videobuf_dma_unmap(vbq->dev, videobuf_to_dma(vb));
 430                 videobuf_dma_free(videobuf_to_dma(vb));
 431         }
 432
 433         vb->state = VIDEOBUF_NEEDS_INIT;
 434 }
 435
 436 /*
 437  * Limit the number of available kernel image capture buffers based on the
 438  * number requested, the currently selected image size, and the maximum
 439  * amount of memory permitted for kernel capture buffers.
 440  */
 441 static int omap24xxcam_vbq_setup(struct videobuf_queue *vbq, unsigned int *cnt,
 442                                  unsigned int *size)
 443 {
 444         struct omap24xxcam_fh *fh = vbq->priv_data;
 445
 446         if (*cnt <= 0)
 447                 *cnt = VIDEO_MAX_FRAME; /* supply a default number of buffers */
 448
 449         if (*cnt > VIDEO_MAX_FRAME)
 450                 *cnt = VIDEO_MAX_FRAME;
 451
 452         *size = fh->pix.sizeimage;
 453
 454         /* accessing fh->cam->capture_mem is ok, it's constant */
 455         if (*size * *cnt > fh->cam->capture_mem)
 456                 *cnt = fh->cam->capture_mem / *size;
 457
 458         return 0;
 459 }
 460
 461 static int omap24xxcam_dma_iolock(struct videobuf_queue *vbq,
 462                                   struct videobuf_dmabuf *dma)
 463 {
 464         int err = 0;
 465
 466         dma->direction = PCI_DMA_FROMDEVICE;
 467         if (!dma_map_sg(vbq->dev, dma->sglist, dma->sglen, dma->direction)) {
 468                 kfree(dma->sglist);
 469                 dma->sglist = NULL;
 470                 dma->sglen = 0;
 471                 err = -EIO;
 472         }
 473
 474         return err;
 475 }
 476
 477 static int omap24xxcam_vbq_prepare(struct videobuf_queue *vbq,
 478                                    struct videobuf_buffer *vb,
 479                                    enum v4l2_field field)
 480 {
 481         struct omap24xxcam_fh *fh = vbq->priv_data;
 482         int err = 0;
 483
 484         /*
 485          * Accessing pix here is okay since it's constant while
 486          * streaming is on (and we only get called then).
 487          */
 488         if (vb->baddr) {
 489                 /* This is a userspace buffer. */
 490                 if (fh->pix.sizeimage > vb->bsize) {
 491                         /* The buffer isn't big enough. */
 492                         err = -EINVAL;
 493                 } else
 494                         vb->size = fh->pix.sizeimage;
 495         } else {
 496                 if (vb->state != VIDEOBUF_NEEDS_INIT) {
 497                         /*
 498                          * We have a kernel bounce buffer that has
 499                          * already been allocated.
 500                          */
 501                         if (fh->pix.sizeimage > vb->size) {
 502                                 /*
 503                                  * The image size has been changed to
 504                                  * a larger size since this buffer was
 505                                  * allocated, so we need to free and
 506                                  * reallocate it.
 507                                  */
 508                                 omap24xxcam_vbq_release(vbq, vb);
 509                                 vb->size = fh->pix.sizeimage;
 510                         }
 511                 } else {
 512                         /* We need to allocate a new kernel bounce buffer. */
 513                         vb->size = fh->pix.sizeimage;
 514                 }
 515         }
 516
 517         if (err)
 518                 return err;
 519
 520         vb->width = fh->pix.width;
 521         vb->height = fh->pix.height;
 522         vb->field = field;
 523
 524         if (vb->state == VIDEOBUF_NEEDS_INIT) {
 525                 if (vb->memory == V4L2_MEMORY_MMAP)
 526                         /*
 527                          * we have built the scatter-gather list by ourself so
 528                          * do the scatter-gather mapping as well
 529                          */
 530                         err = omap24xxcam_dma_iolock(vbq, videobuf_to_dma(vb));
 531                 else
 532                         err = videobuf_iolock(vbq, vb, NULL);
 533         }
 534
 535         if (!err)
 536                 vb->state = VIDEOBUF_PREPARED;
 537         else
 538                 omap24xxcam_vbq_release(vbq, vb);
 539
 540         return err;
 541 }
 542
 543 static void omap24xxcam_vbq_queue(struct videobuf_queue *vbq,
 544                                   struct videobuf_buffer *vb)
 545 {
 546         struct omap24xxcam_fh *fh = vbq->priv_data;
 547         struct omap24xxcam_device *cam = fh->cam;
 548         enum videobuf_state state = vb->state;
 549         unsigned long flags;
 550         int err;
 551
 552         /*
 553          * FIXME: We're marking the buffer active since we have no
 554          * pretty way of marking it active exactly when the
 555          * scatter-gather transfer starts.
 556          */
 557         vb->state = VIDEOBUF_ACTIVE;
 558
 559         err = omap24xxcam_sgdma_queue(&fh->cam->sgdma,
 560                                       videobuf_to_dma(vb)->sglist,
 561                                       videobuf_to_dma(vb)->sglen, vb->size,
 562                                       omap24xxcam_vbq_complete, vb);
 563
 564         if (!err) {
 565                 spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
 566                 if (++cam->sgdma_in_queue == 1
 567                     && !atomic_read(&cam->in_reset))
 568                         omap24xxcam_core_enable(cam);
 569                 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 570         } else {
 571                 /*
 572                  * Oops. We're not supposed to get any errors here.
 573                  * The only way we could get an error is if we ran out
 574                  * of scatter-gather DMA slots, but we are supposed to
 575                  * have at least as many scatter-gather DMA slots as
 576                  * video buffers so that can't happen.
 577                  */
 578                 dev_err(cam->dev, "failed to queue a video buffer for dma!\n");
 579                 dev_err(cam->dev, "likely a bug in the driver!\n");
 580                 vb->state = state;
 581         }
 582 }
 583
 584 static struct videobuf_queue_ops omap24xxcam_vbq_ops = {
 585         .buf_setup   = omap24xxcam_vbq_setup,
 586         .buf_prepare = omap24xxcam_vbq_prepare,
 587         .buf_queue   = omap24xxcam_vbq_queue,
 588         .buf_release = omap24xxcam_vbq_release,
 589 };
 590
 591 /*
 592  *
 593  * OMAP main camera system
 594  *
 595  */
 596
 597 /*
 598  * Reset camera block to power-on state.
 599  */
 600 static void omap24xxcam_poweron_reset(struct omap24xxcam_device *cam)
 601 {
 602         int max_loop = RESET_TIMEOUT_NS;
 603
 604         /* Reset whole camera subsystem */
 605         omap24xxcam_reg_out(cam->mmio_base,
 606                             CAM_SYSCONFIG,
 607                             CAM_SYSCONFIG_SOFTRESET);
 608
 609         /* Wait till it's finished */
 610         while (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
 611                  & CAM_SYSSTATUS_RESETDONE)
 612                && --max_loop) {
 613                 ndelay(1);
 614         }
 615
 616         if (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
 617               & CAM_SYSSTATUS_RESETDONE))
 618                 dev_err(cam->dev, "camera soft reset timeout\n");
 619 }
 620
 621 /*
 622  * (Re)initialise the camera block.
 623  */
 624 static void omap24xxcam_hwinit(struct omap24xxcam_device *cam)
 625 {
 626         omap24xxcam_poweron_reset(cam);
 627
 628         /* set the camera subsystem autoidle bit */
 629         omap24xxcam_reg_out(cam->mmio_base, CAM_SYSCONFIG,
 630                             CAM_SYSCONFIG_AUTOIDLE);
 631
 632         /* set the camera MMU autoidle bit */
 633         omap24xxcam_reg_out(cam->mmio_base,
 634                             CAMMMU_REG_OFFSET + CAMMMU_SYSCONFIG,
 635                             CAMMMU_SYSCONFIG_AUTOIDLE);
 636
 637         omap24xxcam_core_hwinit(cam);
 638
 639         omap24xxcam_dma_hwinit(&cam->sgdma.dma);
 640 }
 641
 642 /*
 643  * Callback for dma transfer stalling.
 644  */
 645 static void omap24xxcam_stalled_dma_reset(unsigned long data)
 646 {
 647         struct omap24xxcam_device *cam = (struct omap24xxcam_device *)data;
 648
 649         if (!atomic_read(&cam->in_reset)) {
 650                 dev_dbg(cam->dev, "dma stalled, resetting camera\n");
 651                 omap24xxcam_reset(cam);
 652         }
 653 }
 654
 655 /*
 656  * Stop capture. Mark we're doing a reset, stop DMA transfers and
 657  * core. (No new scatter-gather transfers will be queued whilst
 658  * in_reset is non-zero.)
 659  *
 660  * If omap24xxcam_capture_stop is called from several places at
 661  * once, only the first call will have an effect. Similarly, the last
 662  * call omap24xxcam_streaming_cont will have effect.
 663  *
 664  * Serialisation is ensured by using cam->core_enable_disable_lock.
 665  */
 666 static void omap24xxcam_capture_stop(struct omap24xxcam_device *cam)
 667 {
 668         unsigned long flags;
 669
 670         spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
 671
 672         if (atomic_inc_return(&cam->in_reset) != 1) {
 673                 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 674                 return;
 675         }
 676
 677         omap24xxcam_core_disable(cam);
 678
 679         spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 680
 681         omap24xxcam_sgdma_sync(&cam->sgdma);
 682 }
 683
 684 /*
 685  * Reset and continue streaming.
 686  *
 687  * Note: Resetting the camera FIFO via the CC_RST bit in the CC_CTRL
 688  * register is supposed to be sufficient to recover from a camera
 689  * interface error, but it doesn't seem to be enough. If we only do
 690  * that then subsequent image captures are out of sync by either one
 691  * or two times DMA_THRESHOLD bytes. Resetting and re-initializing the
 692  * entire camera subsystem prevents the problem with frame
 693  * synchronization.
 694  */
 695 static void omap24xxcam_capture_cont(struct omap24xxcam_device *cam)
 696 {
 697         unsigned long flags;
 698
 699         spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
 700
 701         if (atomic_read(&cam->in_reset) != 1)
 702                 goto out;
 703
 704         omap24xxcam_hwinit(cam);
 705
 706         omap24xxcam_sensor_if_enable(cam);
 707
 708         omap24xxcam_sgdma_process(&cam->sgdma);
 709
 710         if (cam->sgdma_in_queue)
 711                 omap24xxcam_core_enable(cam);
 712
 713 out:
 714         atomic_dec(&cam->in_reset);
 715         spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 716 }
 717
 718 static ssize_t
 719 omap24xxcam_streaming_show(struct device *dev, struct device_attribute *attr,
 720                 char *buf)
 721 {
 722         struct omap24xxcam_device *cam = dev_get_drvdata(dev);
 723
 724         return sprintf(buf, "%s\n", cam->streaming ?  "active" : "inactive");
 725 }
 726 static DEVICE_ATTR(streaming, S_IRUGO, omap24xxcam_streaming_show, NULL);
 727
 728 /*
 729  * Stop capture and restart it. I.e. reset the camera during use.
 730  */
 731 static void omap24xxcam_reset(struct omap24xxcam_device *cam)
 732 {
 733         omap24xxcam_capture_stop(cam);
 734         omap24xxcam_capture_cont(cam);
 735 }
 736
 737 /*
 738  * The main interrupt handler.
 739  */
 740 static irqreturn_t omap24xxcam_isr(int irq, void *arg)
 741 {
 742         struct omap24xxcam_device *cam = (struct omap24xxcam_device *)arg;
 743         u32 irqstatus;
 744         unsigned int irqhandled = 0;
 745
 746         irqstatus = omap24xxcam_reg_in(cam->mmio_base, CAM_IRQSTATUS);
 747
 748         if (irqstatus &
 749             (CAM_IRQSTATUS_DMA_IRQ2 | CAM_IRQSTATUS_DMA_IRQ1
 750              | CAM_IRQSTATUS_DMA_IRQ0)) {
 751                 omap24xxcam_dma_isr(&cam->sgdma.dma);
 752                 irqhandled = 1;
 753         }
 754         if (irqstatus & CAM_IRQSTATUS_CC_IRQ) {
 755                 omap24xxcam_core_isr(cam);
 756                 irqhandled = 1;
 757         }
 758         if (irqstatus & CAM_IRQSTATUS_MMU_IRQ)
 759                 dev_err(cam->dev, "unhandled camera MMU interrupt!\n");
 760
 761         return IRQ_RETVAL(irqhandled);
 762 }
 763
 764 /*
 765  *
 766  * Sensor handling.
 767  *
 768  */
 769
 770 /*
 771  * Enable the external sensor interface. Try to negotiate interface
 772  * parameters with the sensor and start using the new ones. The calls
 773  * to sensor_if_enable and sensor_if_disable need not to be balanced.
 774  */
 775 static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam)
 776 {
 777         int rval;
 778         struct v4l2_ifparm p;
 779
 780         rval = vidioc_int_g_ifparm(cam->sdev, &p);
 781         if (rval) {
 782                 dev_err(cam->dev, "vidioc_int_g_ifparm failed with %d\n", rval);
 783                 return rval;
 784         }
 785
 786         cam->if_type = p.if_type;
 787
 788         cam->cc_ctrl = CC_CTRL_CC_EN;
 789
 790         switch (p.if_type) {
 791         case V4L2_IF_TYPE_BT656:
 792                 if (p.u.bt656.frame_start_on_rising_vs)
 793                         cam->cc_ctrl |= CC_CTRL_NOBT_SYNCHRO;
 794                 if (p.u.bt656.bt_sync_correct)
 795                         cam->cc_ctrl |= CC_CTRL_BT_CORRECT;
 796                 if (p.u.bt656.swap)
 797                         cam->cc_ctrl |= CC_CTRL_PAR_ORDERCAM;
 798                 if (p.u.bt656.latch_clk_inv)
 799                         cam->cc_ctrl |= CC_CTRL_PAR_CLK_POL;
 800                 if (p.u.bt656.nobt_hs_inv)
 801                         cam->cc_ctrl |= CC_CTRL_NOBT_HS_POL;
 802                 if (p.u.bt656.nobt_vs_inv)
 803                         cam->cc_ctrl |= CC_CTRL_NOBT_VS_POL;
 804
 805                 switch (p.u.bt656.mode) {
 806                 case V4L2_IF_TYPE_BT656_MODE_NOBT_8BIT:
 807                         cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT8;
 808                         break;
 809                 case V4L2_IF_TYPE_BT656_MODE_NOBT_10BIT:
 810                         cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT10;
 811                         break;
 812                 case V4L2_IF_TYPE_BT656_MODE_NOBT_12BIT:
 813                         cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT12;
 814                         break;
 815                 case V4L2_IF_TYPE_BT656_MODE_BT_8BIT:
 816                         cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT8;
 817                         break;
 818                 case V4L2_IF_TYPE_BT656_MODE_BT_10BIT:
 819                         cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT10;
 820                         break;
 821                 default:
 822                         dev_err(cam->dev,
 823                                 "bt656 interface mode %d not supported\n",
 824                                 p.u.bt656.mode);
 825                         return -EINVAL;
 826                 }
 827                 /*
 828                  * The clock rate that the sensor wants has changed.
 829                  * We have to adjust the xclk from OMAP 2 side to
 830                  * match the sensor's wish as closely as possible.
 831                  */
 832                 if (p.u.bt656.clock_curr != cam->if_u.bt656.xclk) {
 833                         u32 xclk = p.u.bt656.clock_curr;
 834                         u32 divisor;
 835
 836                         if (xclk == 0)
 837                                 return -EINVAL;
 838
 839                         if (xclk > CAM_MCLK)
 840                                 xclk = CAM_MCLK;
 841
 842                         divisor = CAM_MCLK / xclk;
 843                         if (divisor * xclk < CAM_MCLK)
 844                                 divisor++;
 845                         if (CAM_MCLK / divisor < p.u.bt656.clock_min
 846                             && divisor > 1)
 847                                 divisor--;
 848                         if (divisor > 30)
 849                                 divisor = 30;
 850
 851                         xclk = CAM_MCLK / divisor;
 852
 853                         if (xclk < p.u.bt656.clock_min
 854                             || xclk > p.u.bt656.clock_max)
 855                                 return -EINVAL;
 856
 857                         cam->if_u.bt656.xclk = xclk;
 858                 }
 859                 omap24xxcam_core_xclk_set(cam, cam->if_u.bt656.xclk);
 860                 break;
 861         default:
 862                 /* FIXME: how about other interfaces? */
 863                 dev_err(cam->dev, "interface type %d not supported\n",
 864                         p.if_type);
 865                 return -EINVAL;
 866         }
 867
 868         return 0;
 869 }
 870
 871 static void omap24xxcam_sensor_if_disable(const struct omap24xxcam_device *cam)
 872 {
 873         switch (cam->if_type) {
 874         case V4L2_IF_TYPE_BT656:
 875                 omap24xxcam_core_xclk_set(cam, 0);
 876                 break;
 877         }
 878 }
 879
 880 /*
 881  * Initialise the sensor hardware.
 882  */
 883 static int omap24xxcam_sensor_init(struct omap24xxcam_device *cam)
 884 {
 885         int err = 0;
 886         struct v4l2_int_device *sdev = cam->sdev;
 887
 888         omap24xxcam_clock_on(cam);
 889         err = omap24xxcam_sensor_if_enable(cam);
 890         if (err) {
 891                 dev_err(cam->dev, "sensor interface could not be enabled at "
 892                         "initialisation, %d\n", err);
 893                 cam->sdev = NULL;
 894                 goto out;
 895         }
 896
 897         /* power up sensor during sensor initialization */
 898         vidioc_int_s_power(sdev, 1);
 899
 900         err = vidioc_int_dev_init(sdev);
 901         if (err) {
 902                 dev_err(cam->dev, "cannot initialize sensor, error %d\n", err);
 903                 /* Sensor init failed --- it's nonexistent to us! */
 904                 cam->sdev = NULL;
 905                 goto out;
 906         }
 907
 908         dev_info(cam->dev, "sensor is %s\n", sdev->name);
 909
 910 out:
 911         omap24xxcam_sensor_if_disable(cam);
 912         omap24xxcam_clock_off(cam);
 913
 914         vidioc_int_s_power(sdev, 0);
 915
 916         return err;
 917 }
 918
 919 static void omap24xxcam_sensor_exit(struct omap24xxcam_device *cam)
 920 {
 921         if (cam->sdev)
 922                 vidioc_int_dev_exit(cam->sdev);
 923 }
 924
 925 static void omap24xxcam_sensor_disable(struct omap24xxcam_device *cam)
 926 {
 927         omap24xxcam_sensor_if_disable(cam);
 928         omap24xxcam_clock_off(cam);
 929         vidioc_int_s_power(cam->sdev, 0);
 930 }
 931
 932 /*
 933  * Power-up and configure camera sensor. It's ready for capturing now.
 934  */
 935 static int omap24xxcam_sensor_enable(struct omap24xxcam_device *cam)
 936 {
 937         int rval;
 938
 939         omap24xxcam_clock_on(cam);
 940
 941         omap24xxcam_sensor_if_enable(cam);
 942
 943         rval = vidioc_int_s_power(cam->sdev, 1);
 944         if (rval)
 945                 goto out;
 946
 947         rval = vidioc_int_init(cam->sdev);
 948         if (rval)
 949                 goto out;
 950
 951         return 0;
 952
 953 out:
 954         omap24xxcam_sensor_disable(cam);
 955
 956         return rval;
 957 }
 958
 959 static void omap24xxcam_sensor_reset_work(struct work_struct *work)
 960 {
 961         struct omap24xxcam_device *cam =
 962                 container_of(work, struct omap24xxcam_device,
 963                              sensor_reset_work);
 964
 965         if (atomic_read(&cam->reset_disable))
 966                 return;
 967
 968         omap24xxcam_capture_stop(cam);
 969
 970         if (vidioc_int_reset(cam->sdev) == 0) {
 971                 vidioc_int_init(cam->sdev);
 972         } else {
 973                 /* Can't reset it by vidioc_int_reset. */
 974                 omap24xxcam_sensor_disable(cam);
 975                 omap24xxcam_sensor_enable(cam);
 976         }
 977
 978         omap24xxcam_capture_cont(cam);
 979 }
 980
 981 /*
 982  *
 983  * IOCTL interface.
 984  *
 985  */
 986
 987 static int vidioc_querycap(struct file *file, void *fh,
 988                            struct v4l2_capability *cap)
 989 {
 990         struct omap24xxcam_fh *ofh = fh;
 991         struct omap24xxcam_device *cam = ofh->cam;
 992
 993         strlcpy(cap->driver, CAM_NAME, sizeof(cap->driver));
 994         strlcpy(cap->card, cam->vfd->name, sizeof(cap->card));
 995         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
 996
 997         return 0;
 998 }
 999
1000 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1001                                    struct v4l2_fmtdesc *f)
1002 {
1003         struct omap24xxcam_fh *ofh = fh;
1004         struct omap24xxcam_device *cam = ofh->cam;
1005         int rval;
1006
1007         rval = vidioc_int_enum_fmt_cap(cam->sdev, f);
1008
1009         return rval;
1010 }
1011
1012 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1013                                 struct v4l2_format *f)
1014 {
1015         struct omap24xxcam_fh *ofh = fh;
1016         struct omap24xxcam_device *cam = ofh->cam;
1017         int rval;
1018
1019         mutex_lock(&cam->mutex);
1020         rval = vidioc_int_g_fmt_cap(cam->sdev, f);
1021         mutex_unlock(&cam->mutex);
1022
1023         return rval;
1024 }
1025
1026 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1027                                 struct v4l2_format *f)
1028 {
1029         struct omap24xxcam_fh *ofh = fh;
1030         struct omap24xxcam_device *cam = ofh->cam;
1031         int rval;
1032
1033         mutex_lock(&cam->mutex);
1034         if (cam->streaming) {
1035                 rval = -EBUSY;
1036                 goto out;
1037         }
1038
1039         rval = vidioc_int_s_fmt_cap(cam->sdev, f);
1040
1041 out:
1042         mutex_unlock(&cam->mutex);
1043
1044         if (!rval) {
1045                 mutex_lock(&ofh->vbq.vb_lock);
1046                 ofh->pix = f->fmt.pix;
1047                 mutex_unlock(&ofh->vbq.vb_lock);
1048         }
1049
1050         memset(f, 0, sizeof(*f));
1051         vidioc_g_fmt_vid_cap(file, fh, f);
1052
1053         return rval;
1054 }
1055
1056 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1057                                   struct v4l2_format *f)
1058 {
1059         struct omap24xxcam_fh *ofh = fh;
1060         struct omap24xxcam_device *cam = ofh->cam;
1061         int rval;
1062
1063         mutex_lock(&cam->mutex);
1064         rval = vidioc_int_try_fmt_cap(cam->sdev, f);
1065         mutex_unlock(&cam->mutex);
1066
1067         return rval;
1068 }
1069
1070 static int vidioc_reqbufs(struct file *file, void *fh,
1071                           struct v4l2_requestbuffers *b)
1072 {
1073         struct omap24xxcam_fh *ofh = fh;
1074         struct omap24xxcam_device *cam = ofh->cam;
1075         int rval;
1076
1077         mutex_lock(&cam->mutex);
1078         if (cam->streaming) {
1079                 mutex_unlock(&cam->mutex);
1080                 return -EBUSY;
1081         }
1082
1083         omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
1084         mutex_unlock(&cam->mutex);
1085
1086         rval = videobuf_reqbufs(&ofh->vbq, b);
1087
1088         /*
1089          * Either videobuf_reqbufs failed or the buffers are not
1090          * memory-mapped (which would need special attention).
1091          */
1092         if (rval < 0 || b->memory != V4L2_MEMORY_MMAP)
1093                 goto out;
1094
1095         rval = omap24xxcam_vbq_alloc_mmap_buffers(&ofh->vbq, rval);
1096         if (rval)
1097                 omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
1098
1099 out:
1100         return rval;
1101 }
1102
1103 static int vidioc_querybuf(struct file *file, void *fh,
1104                            struct v4l2_buffer *b)
1105 {
1106         struct omap24xxcam_fh *ofh = fh;
1107
1108         return videobuf_querybuf(&ofh->vbq, b);
1109 }
1110
1111 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1112 {
1113         struct omap24xxcam_fh *ofh = fh;
1114
1115         return videobuf_qbuf(&ofh->vbq, b);
1116 }
1117
1118 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1119 {
1120         struct omap24xxcam_fh *ofh = fh;
1121         struct omap24xxcam_device *cam = ofh->cam;
1122         struct videobuf_buffer *vb;
1123         int rval;
1124
1125 videobuf_dqbuf_again:
1126         rval = videobuf_dqbuf(&ofh->vbq, b, file->f_flags & O_NONBLOCK);
1127         if (rval)
1128                 goto out;
1129
1130         vb = ofh->vbq.bufs[b->index];
1131
1132         mutex_lock(&cam->mutex);
1133         /* _needs_reset returns -EIO if reset is required. */
1134         rval = vidioc_int_g_needs_reset(cam->sdev, (void *)vb->baddr);
1135         mutex_unlock(&cam->mutex);
1136         if (rval == -EIO)
1137                 schedule_work(&cam->sensor_reset_work);
1138         else
1139                 rval = 0;
1140
1141 out:
1142         /*
1143          * This is a hack. We don't want to show -EIO to the user
1144          * space. Requeue the buffer and try again if we're not doing
1145          * this in non-blocking mode.
1146          */
1147         if (rval == -EIO) {
1148                 videobuf_qbuf(&ofh->vbq, b);
1149                 if (!(file->f_flags & O_NONBLOCK))
1150                         goto videobuf_dqbuf_again;
1151                 /*
1152                  * We don't have a videobuf_buffer now --- maybe next
1153                  * time...
1154                  */
1155                 rval = -EAGAIN;
1156         }
1157
1158         return rval;
1159 }
1160
1161 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1162 {
1163         struct omap24xxcam_fh *ofh = fh;
1164         struct omap24xxcam_device *cam = ofh->cam;
1165         int rval;
1166
1167         mutex_lock(&cam->mutex);
1168         if (cam->streaming) {
1169                 rval = -EBUSY;
1170                 goto out;
1171         }
1172
1173         rval = omap24xxcam_sensor_if_enable(cam);
1174         if (rval) {
1175                 dev_dbg(cam->dev, "vidioc_int_g_ifparm failed\n");
1176                 goto out;
1177         }
1178
1179         rval = videobuf_streamon(&ofh->vbq);
1180         if (!rval) {
1181                 cam->streaming = file;
1182                 sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1183         }
1184
1185 out:
1186         mutex_unlock(&cam->mutex);
1187
1188         return rval;
1189 }
1190
1191 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1192 {
1193         struct omap24xxcam_fh *ofh = fh;
1194         struct omap24xxcam_device *cam = ofh->cam;
1195         struct videobuf_queue *q = &ofh->vbq;
1196         int rval;
1197
1198         atomic_inc(&cam->reset_disable);
1199
1200         flush_work_sync(&cam->sensor_reset_work);
1201
1202         rval = videobuf_streamoff(q);
1203         if (!rval) {
1204                 mutex_lock(&cam->mutex);
1205                 cam->streaming = NULL;
1206                 mutex_unlock(&cam->mutex);
1207                 sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1208         }
1209
1210         atomic_dec(&cam->reset_disable);
1211
1212         return rval;
1213 }
1214
1215 static int vidioc_enum_input(struct file *file, void *fh,
1216                              struct v4l2_input *inp)
1217 {
1218         if (inp->index > 0)
1219                 return -EINVAL;
1220
1221         strlcpy(inp->name, "camera", sizeof(inp->name));
1222         inp->type = V4L2_INPUT_TYPE_CAMERA;
1223
1224         return 0;
1225 }
1226
1227 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1228 {
1229         *i = 0;
1230
1231         return 0;
1232 }
1233
1234 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1235 {
1236         if (i > 0)
1237                 return -EINVAL;
1238
1239         return 0;
1240 }
1241
1242 static int vidioc_queryctrl(struct file *file, void *fh,
1243                             struct v4l2_queryctrl *a)
1244 {
1245         struct omap24xxcam_fh *ofh = fh;
1246         struct omap24xxcam_device *cam = ofh->cam;
1247         int rval;
1248
1249         rval = vidioc_int_queryctrl(cam->sdev, a);
1250
1251         return rval;
1252 }
1253
1254 static int vidioc_g_ctrl(struct file *file, void *fh,
1255                          struct v4l2_control *a)
1256 {
1257         struct omap24xxcam_fh *ofh = fh;
1258         struct omap24xxcam_device *cam = ofh->cam;
1259         int rval;
1260
1261         mutex_lock(&cam->mutex);
1262         rval = vidioc_int_g_ctrl(cam->sdev, a);
1263         mutex_unlock(&cam->mutex);
1264
1265         return rval;
1266 }
1267
1268 static int vidioc_s_ctrl(struct file *file, void *fh,
1269                          struct v4l2_control *a)
1270 {
1271         struct omap24xxcam_fh *ofh = fh;
1272         struct omap24xxcam_device *cam = ofh->cam;
1273         int rval;
1274
1275         mutex_lock(&cam->mutex);
1276         rval = vidioc_int_s_ctrl(cam->sdev, a);
1277         mutex_unlock(&cam->mutex);
1278
1279         return rval;
1280 }
1281
1282 static int vidioc_g_parm(struct file *file, void *fh,
1283                          struct v4l2_streamparm *a) {
1284         struct omap24xxcam_fh *ofh = fh;
1285         struct omap24xxcam_device *cam = ofh->cam;
1286         int rval;
1287
1288         mutex_lock(&cam->mutex);
1289         rval = vidioc_int_g_parm(cam->sdev, a);
1290         mutex_unlock(&cam->mutex);
1291
1292         return rval;
1293 }
1294
1295 static int vidioc_s_parm(struct file *file, void *fh,
1296                          struct v4l2_streamparm *a)
1297 {
1298         struct omap24xxcam_fh *ofh = fh;
1299         struct omap24xxcam_device *cam = ofh->cam;
1300         struct v4l2_streamparm old_streamparm;
1301         int rval;
1302
1303         mutex_lock(&cam->mutex);
1304         if (cam->streaming) {
1305                 rval = -EBUSY;
1306                 goto out;
1307         }
1308
1309         old_streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1310         rval = vidioc_int_g_parm(cam->sdev, &old_streamparm);
1311         if (rval)
1312                 goto out;
1313
1314         rval = vidioc_int_s_parm(cam->sdev, a);
1315         if (rval)
1316                 goto out;
1317
1318         rval = omap24xxcam_sensor_if_enable(cam);
1319         /*
1320          * Revert to old streaming parameters if enabling sensor
1321          * interface with the new ones failed.
1322          */
1323         if (rval)
1324                 vidioc_int_s_parm(cam->sdev, &old_streamparm);
1325
1326 out:
1327         mutex_unlock(&cam->mutex);
1328
1329         return rval;
1330 }
1331
1332 /*
1333  *
1334  * File operations.
1335  *
1336  */
1337
1338 static unsigned int omap24xxcam_poll(struct file *file,
1339                                      struct poll_table_struct *wait)
1340 {
1341         struct omap24xxcam_fh *fh = file->private_data;
1342         struct omap24xxcam_device *cam = fh->cam;
1343         struct videobuf_buffer *vb;
1344
1345         mutex_lock(&cam->mutex);
1346         if (cam->streaming != file) {
1347                 mutex_unlock(&cam->mutex);
1348                 return POLLERR;
1349         }
1350         mutex_unlock(&cam->mutex);
1351
1352         mutex_lock(&fh->vbq.vb_lock);
1353         if (list_empty(&fh->vbq.stream)) {
1354                 mutex_unlock(&fh->vbq.vb_lock);
1355                 return POLLERR;
1356         }
1357         vb = list_entry(fh->vbq.stream.next, struct videobuf_buffer, stream);
1358         mutex_unlock(&fh->vbq.vb_lock);
1359
1360         poll_wait(file, &vb->done, wait);
1361
1362         if (vb->state == VIDEOBUF_DONE || vb->state == VIDEOBUF_ERROR)
1363                 return POLLIN | POLLRDNORM;
1364
1365         return 0;
1366 }
1367
1368 static int omap24xxcam_mmap_buffers(struct file *file,
1369                                     struct vm_area_struct *vma)
1370 {
1371         struct omap24xxcam_fh *fh = file->private_data;
1372         struct omap24xxcam_device *cam = fh->cam;
1373         struct videobuf_queue *vbq = &fh->vbq;
1374         unsigned int first, last, size, i, j;
1375         int err = 0;
1376
1377         mutex_lock(&cam->mutex);
1378         if (cam->streaming) {
1379                 mutex_unlock(&cam->mutex);
1380                 return -EBUSY;
1381         }
1382         mutex_unlock(&cam->mutex);
1383         mutex_lock(&vbq->vb_lock);
1384
1385         /* look for first buffer to map */
1386         for (first = 0; first < VIDEO_MAX_FRAME; first++) {
1387                 if (NULL == vbq->bufs[first])
1388                         continue;
1389                 if (V4L2_MEMORY_MMAP != vbq->bufs[first]->memory)
1390                         continue;
1391                 if (vbq->bufs[first]->boff == (vma->vm_pgoff << PAGE_SHIFT))
1392                         break;
1393         }
1394
1395         /* look for last buffer to map */
1396         for (size = 0, last = first; last < VIDEO_MAX_FRAME; last++) {
1397                 if (NULL == vbq->bufs[last])
1398                         continue;
1399                 if (V4L2_MEMORY_MMAP != vbq->bufs[last]->memory)
1400                         continue;
1401                 size += vbq->bufs[last]->bsize;
1402                 if (size == (vma->vm_end - vma->vm_start))
1403                         break;
1404         }
1405
1406         size = 0;
1407         for (i = first; i <= last && i < VIDEO_MAX_FRAME; i++) {
1408                 struct videobuf_dmabuf *dma = videobuf_to_dma(vbq->bufs[i]);
1409
1410                 for (j = 0; j < dma->sglen; j++) {
1411                         err = remap_pfn_range(
1412                                 vma, vma->vm_start + size,
1413                                 page_to_pfn(sg_page(&dma->sglist[j])),
1414                                 sg_dma_len(&dma->sglist[j]), vma->vm_page_prot);
1415                         if (err)
1416                                 goto out;
1417                         size += sg_dma_len(&dma->sglist[j]);
1418                 }
1419         }
1420
1421 out:
1422         mutex_unlock(&vbq->vb_lock);
1423
1424         return err;
1425 }
1426
1427 static int omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
1428 {
1429         struct omap24xxcam_fh *fh = file->private_data;
1430         int rval;
1431
1432         /* let the video-buf mapper check arguments and set-up structures */
1433         rval = videobuf_mmap_mapper(&fh->vbq, vma);
1434         if (rval)
1435                 return rval;
1436
1437         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1438
1439         /* do mapping to our allocated buffers */
1440         rval = omap24xxcam_mmap_buffers(file, vma);
1441         /*
1442          * In case of error, free vma->vm_private_data allocated by
1443          * videobuf_mmap_mapper.
1444          */
1445         if (rval)
1446                 kfree(vma->vm_private_data);
1447
1448         return rval;
1449 }
1450
1451 static int omap24xxcam_open(struct file *file)
1452 {
1453         struct omap24xxcam_device *cam = omap24xxcam.priv;
1454         struct omap24xxcam_fh *fh;
1455         struct v4l2_format format;
1456
1457         if (!cam || !cam->vfd)
1458                 return -ENODEV;
1459
1460         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1461         if (fh == NULL)
1462                 return -ENOMEM;
1463
1464         mutex_lock(&cam->mutex);
1465         if (cam->sdev == NULL || !try_module_get(cam->sdev->module)) {
1466                 mutex_unlock(&cam->mutex);
1467                 goto out_try_module_get;
1468         }
1469
1470         if (atomic_inc_return(&cam->users) == 1) {
1471                 omap24xxcam_hwinit(cam);
1472                 if (omap24xxcam_sensor_enable(cam)) {
1473                         mutex_unlock(&cam->mutex);
1474                         goto out_omap24xxcam_sensor_enable;
1475                 }
1476         }
1477         mutex_unlock(&cam->mutex);
1478
1479         fh->cam = cam;
1480         mutex_lock(&cam->mutex);
1481         vidioc_int_g_fmt_cap(cam->sdev, &format);
1482         mutex_unlock(&cam->mutex);
1483         /* FIXME: how about fh->pix when there are more users? */
1484         fh->pix = format.fmt.pix;
1485
1486         file->private_data = fh;
1487
1488         spin_lock_init(&fh->vbq_lock);
1489
1490         videobuf_queue_sg_init(&fh->vbq, &omap24xxcam_vbq_ops, NULL,
1491                                 &fh->vbq_lock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1492                                 V4L2_FIELD_NONE,
1493                                 sizeof(struct videobuf_buffer), fh, NULL);
1494
1495         return 0;
1496
1497 out_omap24xxcam_sensor_enable:
1498         omap24xxcam_poweron_reset(cam);
1499         module_put(cam->sdev->module);
1500
1501 out_try_module_get:
1502         kfree(fh);
1503
1504         return -ENODEV;
1505 }
1506
1507 static int omap24xxcam_release(struct file *file)
1508 {
1509         struct omap24xxcam_fh *fh = file->private_data;
1510         struct omap24xxcam_device *cam = fh->cam;
1511
1512         atomic_inc(&cam->reset_disable);
1513
1514         flush_work_sync(&cam->sensor_reset_work);
1515
1516         /* stop streaming capture */
1517         videobuf_streamoff(&fh->vbq);
1518
1519         mutex_lock(&cam->mutex);
1520         if (cam->streaming == file) {
1521                 cam->streaming = NULL;
1522                 mutex_unlock(&cam->mutex);
1523                 sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1524         } else {
1525                 mutex_unlock(&cam->mutex);
1526         }
1527
1528         atomic_dec(&cam->reset_disable);
1529
1530         omap24xxcam_vbq_free_mmap_buffers(&fh->vbq);
1531
1532         /*
1533          * Make sure the reset work we might have scheduled is not
1534          * pending! It may be run *only* if we have users. (And it may
1535          * not be scheduled anymore since streaming is already
1536          * disabled.)
1537          */
1538         flush_work_sync(&cam->sensor_reset_work);
1539
1540         mutex_lock(&cam->mutex);
1541         if (atomic_dec_return(&cam->users) == 0) {
1542                 omap24xxcam_sensor_disable(cam);
1543                 omap24xxcam_poweron_reset(cam);
1544         }
1545         mutex_unlock(&cam->mutex);
1546
1547         file->private_data = NULL;
1548
1549         module_put(cam->sdev->module);
1550         kfree(fh);
1551
1552         return 0;
1553 }
1554
1555 static struct v4l2_file_operations omap24xxcam_fops = {
1556         .ioctl   = video_ioctl2,
1557         .poll    = omap24xxcam_poll,
1558         .mmap    = omap24xxcam_mmap,
1559         .open    = omap24xxcam_open,
1560         .release = omap24xxcam_release,
1561 };
1562
1563 /*
1564  *
1565  * Power management.
1566  *
1567  */
1568
1569 #ifdef CONFIG_PM
1570 static int omap24xxcam_suspend(struct platform_device *pdev, pm_message_t state)
1571 {
1572         struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1573
1574         if (atomic_read(&cam->users) == 0)
1575                 return 0;
1576
1577         if (!atomic_read(&cam->reset_disable))
1578                 omap24xxcam_capture_stop(cam);
1579
1580         omap24xxcam_sensor_disable(cam);
1581         omap24xxcam_poweron_reset(cam);
1582
1583         return 0;
1584 }
1585
1586 static int omap24xxcam_resume(struct platform_device *pdev)
1587 {
1588         struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1589
1590         if (atomic_read(&cam->users) == 0)
1591                 return 0;
1592
1593         omap24xxcam_hwinit(cam);
1594         omap24xxcam_sensor_enable(cam);
1595
1596         if (!atomic_read(&cam->reset_disable))
1597                 omap24xxcam_capture_cont(cam);
1598
1599         return 0;
1600 }
1601 #endif /* CONFIG_PM */
1602
1603 static const struct v4l2_ioctl_ops omap24xxcam_ioctl_fops = {
1604         .vidioc_querycap        = vidioc_querycap,
1605         .vidioc_enum_fmt_vid_cap        = vidioc_enum_fmt_vid_cap,
1606         .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1607         .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1608         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1609         .vidioc_reqbufs         = vidioc_reqbufs,
1610         .vidioc_querybuf        = vidioc_querybuf,
1611         .vidioc_qbuf            = vidioc_qbuf,
1612         .vidioc_dqbuf           = vidioc_dqbuf,
1613         .vidioc_streamon        = vidioc_streamon,
1614         .vidioc_streamoff       = vidioc_streamoff,
1615         .vidioc_enum_input      = vidioc_enum_input,
1616         .vidioc_g_input         = vidioc_g_input,
1617         .vidioc_s_input         = vidioc_s_input,
1618         .vidioc_queryctrl       = vidioc_queryctrl,
1619         .vidioc_g_ctrl          = vidioc_g_ctrl,
1620         .vidioc_s_ctrl          = vidioc_s_ctrl,
1621         .vidioc_g_parm          = vidioc_g_parm,
1622         .vidioc_s_parm          = vidioc_s_parm,
1623 };
1624
1625 /*
1626  *
1627  * Camera device (i.e. /dev/video).
1628  *
1629  */
1630
1631 static int omap24xxcam_device_register(struct v4l2_int_device *s)
1632 {
1633         struct omap24xxcam_device *cam = s->u.slave->master->priv;
1634         struct video_device *vfd;
1635         int rval;
1636
1637         /* We already have a slave. */
1638         if (cam->sdev)
1639                 return -EBUSY;
1640
1641         cam->sdev = s;
1642
1643         if (device_create_file(cam->dev, &dev_attr_streaming) != 0) {
1644                 dev_err(cam->dev, "could not register sysfs entry\n");
1645                 rval = -EBUSY;
1646                 goto err;
1647         }
1648
1649         /* initialize the video_device struct */
1650         vfd = cam->vfd = video_device_alloc();
1651         if (!vfd) {
1652                 dev_err(cam->dev, "could not allocate video device struct\n");
1653                 rval = -ENOMEM;
1654                 goto err;
1655         }
1656         vfd->release = video_device_release;
1657
1658         vfd->parent = cam->dev;
1659
1660         strlcpy(vfd->name, CAM_NAME, sizeof(vfd->name));
1661         vfd->fops                = &omap24xxcam_fops;
1662         vfd->ioctl_ops           = &omap24xxcam_ioctl_fops;
1663
1664         omap24xxcam_hwinit(cam);
1665
1666         rval = omap24xxcam_sensor_init(cam);
1667         if (rval)
1668                 goto err;
1669
1670         if (video_register_device(vfd, VFL_TYPE_GRABBER, video_nr) < 0) {
1671                 dev_err(cam->dev, "could not register V4L device\n");
1672                 rval = -EBUSY;
1673                 goto err;
1674         }
1675
1676         omap24xxcam_poweron_reset(cam);
1677
1678         dev_info(cam->dev, "registered device %s\n",
1679                  video_device_node_name(vfd));
1680
1681         return 0;
1682
1683 err:
1684         omap24xxcam_device_unregister(s);
1685
1686         return rval;
1687 }
1688
1689 static void omap24xxcam_device_unregister(struct v4l2_int_device *s)
1690 {
1691         struct omap24xxcam_device *cam = s->u.slave->master->priv;
1692
1693         omap24xxcam_sensor_exit(cam);
1694
1695         if (cam->vfd) {
1696                 if (!video_is_registered(cam->vfd)) {
1697                         /*
1698                          * The device was never registered, so release the
1699                          * video_device struct directly.
1700                          */
1701                         video_device_release(cam->vfd);
1702                 } else {
1703                         /*
1704                          * The unregister function will release the
1705                          * video_device struct as well as
1706                          * unregistering it.
1707                          */
1708                         video_unregister_device(cam->vfd);
1709                 }
1710                 cam->vfd = NULL;
1711         }
1712
1713         device_remove_file(cam->dev, &dev_attr_streaming);
1714
1715         cam->sdev = NULL;
1716 }
1717
1718 static struct v4l2_int_master omap24xxcam_master = {
1719         .attach = omap24xxcam_device_register,
1720         .detach = omap24xxcam_device_unregister,
1721 };
1722
1723 static struct v4l2_int_device omap24xxcam = {
1724         .module = THIS_MODULE,
1725         .name   = CAM_NAME,
1726         .type   = v4l2_int_type_master,
1727         .u      = {
1728                 .master = &omap24xxcam_master
1729         },
1730 };
1731
1732 /*
1733  *
1734  * Driver initialisation and deinitialisation.
1735  *
1736  */
1737
1738 static int __devinit omap24xxcam_probe(struct platform_device *pdev)
1739 {
1740         struct omap24xxcam_device *cam;
1741         struct resource *mem;
1742         int irq;
1743
1744         cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1745         if (!cam) {
1746                 dev_err(&pdev->dev, "could not allocate memory\n");
1747                 goto err;
1748         }
1749
1750         platform_set_drvdata(pdev, cam);
1751
1752         cam->dev = &pdev->dev;
1753
1754         /*
1755          * Impose a lower limit on the amount of memory allocated for
1756          * capture. We require at least enough memory to double-buffer
1757          * QVGA (300KB).
1758          */
1759         if (capture_mem < 320 * 240 * 2 * 2)
1760                 capture_mem = 320 * 240 * 2 * 2;
1761         cam->capture_mem = capture_mem;
1762
1763         /* request the mem region for the camera registers */
1764         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1765         if (!mem) {
1766                 dev_err(cam->dev, "no mem resource?\n");
1767                 goto err;
1768         }
1769         if (!request_mem_region(mem->start, resource_size(mem), pdev->name)) {
1770                 dev_err(cam->dev,
1771                         "cannot reserve camera register I/O region\n");
1772                 goto err;
1773         }
1774         cam->mmio_base_phys = mem->start;
1775         cam->mmio_size = resource_size(mem);
1776
1777         /* map the region */
1778         cam->mmio_base = (unsigned long)
1779                 ioremap_nocache(cam->mmio_base_phys, cam->mmio_size);
1780         if (!cam->mmio_base) {
1781                 dev_err(cam->dev, "cannot map camera register I/O region\n");
1782                 goto err;
1783         }
1784
1785         irq = platform_get_irq(pdev, 0);
1786         if (irq <= 0) {
1787                 dev_err(cam->dev, "no irq for camera?\n");
1788                 goto err;
1789         }
1790
1791         /* install the interrupt service routine */
1792         if (request_irq(irq, omap24xxcam_isr, 0, CAM_NAME, cam)) {
1793                 dev_err(cam->dev,
1794                         "could not install interrupt service routine\n");
1795                 goto err;
1796         }
1797         cam->irq = irq;
1798
1799         if (omap24xxcam_clock_get(cam))
1800                 goto err;
1801
1802         INIT_WORK(&cam->sensor_reset_work, omap24xxcam_sensor_reset_work);
1803
1804         mutex_init(&cam->mutex);
1805         spin_lock_init(&cam->core_enable_disable_lock);
1806
1807         omap24xxcam_sgdma_init(&cam->sgdma,
1808                                cam->mmio_base + CAMDMA_REG_OFFSET,
1809                                omap24xxcam_stalled_dma_reset,
1810                                (unsigned long)cam);
1811
1812         omap24xxcam.priv = cam;
1813
1814         if (v4l2_int_device_register(&omap24xxcam))
1815                 goto err;
1816
1817         return 0;
1818
1819 err:
1820         omap24xxcam_remove(pdev);
1821         return -ENODEV;
1822 }
1823
1824 static int omap24xxcam_remove(struct platform_device *pdev)
1825 {
1826         struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1827
1828         if (!cam)
1829                 return 0;
1830
1831         if (omap24xxcam.priv != NULL)
1832                 v4l2_int_device_unregister(&omap24xxcam);
1833         omap24xxcam.priv = NULL;
1834
1835         omap24xxcam_clock_put(cam);
1836
1837         if (cam->irq) {
1838                 free_irq(cam->irq, cam);
1839                 cam->irq = 0;
1840         }
1841
1842         if (cam->mmio_base) {
1843                 iounmap((void *)cam->mmio_base);
1844                 cam->mmio_base = 0;
1845         }
1846
1847         if (cam->mmio_base_phys) {
1848                 release_mem_region(cam->mmio_base_phys, cam->mmio_size);
1849                 cam->mmio_base_phys = 0;
1850         }
1851
1852         kfree(cam);
1853
1854         return 0;
1855 }
1856
1857 static struct platform_driver omap24xxcam_driver = {
1858         .probe   = omap24xxcam_probe,
1859         .remove  = omap24xxcam_remove,
1860 #ifdef CONFIG_PM
1861         .suspend = omap24xxcam_suspend,
1862         .resume  = omap24xxcam_resume,
1863 #endif
1864         .driver  = {
1865                 .name = CAM_NAME,
1866                 .owner = THIS_MODULE,
1867         },
1868 };
1869
1870 /*
1871  *
1872  * Module initialisation and deinitialisation
1873  *
1874  */
1875
1876 static int __init omap24xxcam_init(void)
1877 {
1878         return platform_driver_register(&omap24xxcam_driver);
1879 }
1880
1881 static void __exit omap24xxcam_cleanup(void)
1882 {
1883         platform_driver_unregister(&omap24xxcam_driver);
1884 }
1885
1886 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
1887 MODULE_DESCRIPTION("OMAP24xx Video for Linux camera driver");
1888 MODULE_LICENSE("GPL");
1889 MODULE_VERSION(OMAP24XXCAM_VERSION);
1890 module_param(video_nr, int, 0);
1891 MODULE_PARM_DESC(video_nr,
1892                  "Minor number for video device (-1 ==> auto assign)");
1893 module_param(capture_mem, int, 0);
1894 MODULE_PARM_DESC(capture_mem, "Maximum amount of memory for capture "
1895                  "buffers (default 4800kiB)");
1896
1897 module_init(omap24xxcam_init);
1898 module_exit(omap24xxcam_cleanup);