linux/drivers/media/video/omap24xxcam.c
<<
>>
Prefs
   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/version.h>
  35#include <linux/platform_device.h>
  36#include <linux/clk.h>
  37#include <linux/io.h>
  38#include <linux/slab.h>
  39
  40#include <media/v4l2-common.h>
  41#include <media/v4l2-ioctl.h>
  42
  43#include "omap24xxcam.h"
  44
  45#define OMAP24XXCAM_VERSION KERNEL_VERSION(0, 0, 0)
  46
  47#define RESET_TIMEOUT_NS 10000
  48
  49static void omap24xxcam_reset(struct omap24xxcam_device *cam);
  50static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam);
  51static void omap24xxcam_device_unregister(struct v4l2_int_device *s);
  52static int omap24xxcam_remove(struct platform_device *pdev);
  53
  54/* module parameters */
  55static 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 */
  60static int capture_mem = 1280 * 960 * 2 * 2;
  61
  62static struct v4l2_int_device omap24xxcam;
  63
  64/*
  65 *
  66 * Clocks.
  67 *
  68 */
  69
  70static 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
  80static 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
 102static void omap24xxcam_clock_on(struct omap24xxcam_device *cam)
 103{
 104        clk_enable(cam->fck);
 105        clk_enable(cam->ick);
 106}
 107
 108static 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 */
 125static 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
 143static 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 */
 169static 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 */
 184static 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. */
 191static 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 */
 229static 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. */
 256static 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 */
 282static 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 | GFP_DMA, order);
 312                /* if allocation fails, try to allocate smaller amount */
 313                while (page == NULL) {
 314                        order--;
 315                        page = alloc_pages(GFP_KERNEL | GFP_DMA, 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
 347out:
 348        omap24xxcam_vbq_free_mmap_buffer(vb);
 349        return err;
 350}
 351
 352static 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;
 372out:
 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 */
 387static 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
 417static 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(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, 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 */
 441static 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
 461static 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
 477static 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
 543static 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
 584static 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 */
 600static 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 */
 624static 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 */
 645static 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 */
 666static 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 */
 695static 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
 713out:
 714        atomic_dec(&cam->in_reset);
 715        spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 716}
 717
 718static ssize_t
 719omap24xxcam_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}
 726static 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 */
 731static 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 */
 740static 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 */
 775static 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
 871static 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 */
 883static 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
 910out:
 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
 919static void omap24xxcam_sensor_exit(struct omap24xxcam_device *cam)
 920{
 921        if (cam->sdev)
 922                vidioc_int_dev_exit(cam->sdev);
 923}
 924
 925static 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 */
 935static 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
 953out:
 954        omap24xxcam_sensor_disable(cam);
 955
 956        return rval;
 957}
 958
 959static 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
 987static 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->version = OMAP24XXCAM_VERSION;
 996        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
 997
 998        return 0;
 999}
1000
1001static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1002                                   struct v4l2_fmtdesc *f)
1003{
1004        struct omap24xxcam_fh *ofh = fh;
1005        struct omap24xxcam_device *cam = ofh->cam;
1006        int rval;
1007
1008        rval = vidioc_int_enum_fmt_cap(cam->sdev, f);
1009
1010        return rval;
1011}
1012
1013static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1014                                struct v4l2_format *f)
1015{
1016        struct omap24xxcam_fh *ofh = fh;
1017        struct omap24xxcam_device *cam = ofh->cam;
1018        int rval;
1019
1020        mutex_lock(&cam->mutex);
1021        rval = vidioc_int_g_fmt_cap(cam->sdev, f);
1022        mutex_unlock(&cam->mutex);
1023
1024        return rval;
1025}
1026
1027static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1028                                struct v4l2_format *f)
1029{
1030        struct omap24xxcam_fh *ofh = fh;
1031        struct omap24xxcam_device *cam = ofh->cam;
1032        int rval;
1033
1034        mutex_lock(&cam->mutex);
1035        if (cam->streaming) {
1036                rval = -EBUSY;
1037                goto out;
1038        }
1039
1040        rval = vidioc_int_s_fmt_cap(cam->sdev, f);
1041
1042out:
1043        mutex_unlock(&cam->mutex);
1044
1045        if (!rval) {
1046                mutex_lock(&ofh->vbq.vb_lock);
1047                ofh->pix = f->fmt.pix;
1048                mutex_unlock(&ofh->vbq.vb_lock);
1049        }
1050
1051        memset(f, 0, sizeof(*f));
1052        vidioc_g_fmt_vid_cap(file, fh, f);
1053
1054        return rval;
1055}
1056
1057static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1058                                  struct v4l2_format *f)
1059{
1060        struct omap24xxcam_fh *ofh = fh;
1061        struct omap24xxcam_device *cam = ofh->cam;
1062        int rval;
1063
1064        mutex_lock(&cam->mutex);
1065        rval = vidioc_int_try_fmt_cap(cam->sdev, f);
1066        mutex_unlock(&cam->mutex);
1067
1068        return rval;
1069}
1070
1071static int vidioc_reqbufs(struct file *file, void *fh,
1072                          struct v4l2_requestbuffers *b)
1073{
1074        struct omap24xxcam_fh *ofh = fh;
1075        struct omap24xxcam_device *cam = ofh->cam;
1076        int rval;
1077
1078        mutex_lock(&cam->mutex);
1079        if (cam->streaming) {
1080                mutex_unlock(&cam->mutex);
1081                return -EBUSY;
1082        }
1083
1084        omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
1085        mutex_unlock(&cam->mutex);
1086
1087        rval = videobuf_reqbufs(&ofh->vbq, b);
1088
1089        /*
1090         * Either videobuf_reqbufs failed or the buffers are not
1091         * memory-mapped (which would need special attention).
1092         */
1093        if (rval < 0 || b->memory != V4L2_MEMORY_MMAP)
1094                goto out;
1095
1096        rval = omap24xxcam_vbq_alloc_mmap_buffers(&ofh->vbq, rval);
1097        if (rval)
1098                omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
1099
1100out:
1101        return rval;
1102}
1103
1104static int vidioc_querybuf(struct file *file, void *fh,
1105                           struct v4l2_buffer *b)
1106{
1107        struct omap24xxcam_fh *ofh = fh;
1108
1109        return videobuf_querybuf(&ofh->vbq, b);
1110}
1111
1112static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1113{
1114        struct omap24xxcam_fh *ofh = fh;
1115
1116        return videobuf_qbuf(&ofh->vbq, b);
1117}
1118
1119static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1120{
1121        struct omap24xxcam_fh *ofh = fh;
1122        struct omap24xxcam_device *cam = ofh->cam;
1123        struct videobuf_buffer *vb;
1124        int rval;
1125
1126videobuf_dqbuf_again:
1127        rval = videobuf_dqbuf(&ofh->vbq, b, file->f_flags & O_NONBLOCK);
1128        if (rval)
1129                goto out;
1130
1131        vb = ofh->vbq.bufs[b->index];
1132
1133        mutex_lock(&cam->mutex);
1134        /* _needs_reset returns -EIO if reset is required. */
1135        rval = vidioc_int_g_needs_reset(cam->sdev, (void *)vb->baddr);
1136        mutex_unlock(&cam->mutex);
1137        if (rval == -EIO)
1138                schedule_work(&cam->sensor_reset_work);
1139        else
1140                rval = 0;
1141
1142out:
1143        /*
1144         * This is a hack. We don't want to show -EIO to the user
1145         * space. Requeue the buffer and try again if we're not doing
1146         * this in non-blocking mode.
1147         */
1148        if (rval == -EIO) {
1149                videobuf_qbuf(&ofh->vbq, b);
1150                if (!(file->f_flags & O_NONBLOCK))
1151                        goto videobuf_dqbuf_again;
1152                /*
1153                 * We don't have a videobuf_buffer now --- maybe next
1154                 * time...
1155                 */
1156                rval = -EAGAIN;
1157        }
1158
1159        return rval;
1160}
1161
1162static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1163{
1164        struct omap24xxcam_fh *ofh = fh;
1165        struct omap24xxcam_device *cam = ofh->cam;
1166        int rval;
1167
1168        mutex_lock(&cam->mutex);
1169        if (cam->streaming) {
1170                rval = -EBUSY;
1171                goto out;
1172        }
1173
1174        rval = omap24xxcam_sensor_if_enable(cam);
1175        if (rval) {
1176                dev_dbg(cam->dev, "vidioc_int_g_ifparm failed\n");
1177                goto out;
1178        }
1179
1180        rval = videobuf_streamon(&ofh->vbq);
1181        if (!rval) {
1182                cam->streaming = file;
1183                sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1184        }
1185
1186out:
1187        mutex_unlock(&cam->mutex);
1188
1189        return rval;
1190}
1191
1192static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1193{
1194        struct omap24xxcam_fh *ofh = fh;
1195        struct omap24xxcam_device *cam = ofh->cam;
1196        struct videobuf_queue *q = &ofh->vbq;
1197        int rval;
1198
1199        atomic_inc(&cam->reset_disable);
1200
1201        flush_scheduled_work();
1202
1203        rval = videobuf_streamoff(q);
1204        if (!rval) {
1205                mutex_lock(&cam->mutex);
1206                cam->streaming = NULL;
1207                mutex_unlock(&cam->mutex);
1208                sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1209        }
1210
1211        atomic_dec(&cam->reset_disable);
1212
1213        return rval;
1214}
1215
1216static int vidioc_enum_input(struct file *file, void *fh,
1217                             struct v4l2_input *inp)
1218{
1219        if (inp->index > 0)
1220                return -EINVAL;
1221
1222        strlcpy(inp->name, "camera", sizeof(inp->name));
1223        inp->type = V4L2_INPUT_TYPE_CAMERA;
1224
1225        return 0;
1226}
1227
1228static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1229{
1230        *i = 0;
1231
1232        return 0;
1233}
1234
1235static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1236{
1237        if (i > 0)
1238                return -EINVAL;
1239
1240        return 0;
1241}
1242
1243static int vidioc_queryctrl(struct file *file, void *fh,
1244                            struct v4l2_queryctrl *a)
1245{
1246        struct omap24xxcam_fh *ofh = fh;
1247        struct omap24xxcam_device *cam = ofh->cam;
1248        int rval;
1249
1250        rval = vidioc_int_queryctrl(cam->sdev, a);
1251
1252        return rval;
1253}
1254
1255static int vidioc_g_ctrl(struct file *file, void *fh,
1256                         struct v4l2_control *a)
1257{
1258        struct omap24xxcam_fh *ofh = fh;
1259        struct omap24xxcam_device *cam = ofh->cam;
1260        int rval;
1261
1262        mutex_lock(&cam->mutex);
1263        rval = vidioc_int_g_ctrl(cam->sdev, a);
1264        mutex_unlock(&cam->mutex);
1265
1266        return rval;
1267}
1268
1269static int vidioc_s_ctrl(struct file *file, void *fh,
1270                         struct v4l2_control *a)
1271{
1272        struct omap24xxcam_fh *ofh = fh;
1273        struct omap24xxcam_device *cam = ofh->cam;
1274        int rval;
1275
1276        mutex_lock(&cam->mutex);
1277        rval = vidioc_int_s_ctrl(cam->sdev, a);
1278        mutex_unlock(&cam->mutex);
1279
1280        return rval;
1281}
1282
1283static int vidioc_g_parm(struct file *file, void *fh,
1284                         struct v4l2_streamparm *a) {
1285        struct omap24xxcam_fh *ofh = fh;
1286        struct omap24xxcam_device *cam = ofh->cam;
1287        int rval;
1288
1289        mutex_lock(&cam->mutex);
1290        rval = vidioc_int_g_parm(cam->sdev, a);
1291        mutex_unlock(&cam->mutex);
1292
1293        return rval;
1294}
1295
1296static int vidioc_s_parm(struct file *file, void *fh,
1297                         struct v4l2_streamparm *a)
1298{
1299        struct omap24xxcam_fh *ofh = fh;
1300        struct omap24xxcam_device *cam = ofh->cam;
1301        struct v4l2_streamparm old_streamparm;
1302        int rval;
1303
1304        mutex_lock(&cam->mutex);
1305        if (cam->streaming) {
1306                rval = -EBUSY;
1307                goto out;
1308        }
1309
1310        old_streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1311        rval = vidioc_int_g_parm(cam->sdev, &old_streamparm);
1312        if (rval)
1313                goto out;
1314
1315        rval = vidioc_int_s_parm(cam->sdev, a);
1316        if (rval)
1317                goto out;
1318
1319        rval = omap24xxcam_sensor_if_enable(cam);
1320        /*
1321         * Revert to old streaming parameters if enabling sensor
1322         * interface with the new ones failed.
1323         */
1324        if (rval)
1325                vidioc_int_s_parm(cam->sdev, &old_streamparm);
1326
1327out:
1328        mutex_unlock(&cam->mutex);
1329
1330        return rval;
1331}
1332
1333/*
1334 *
1335 * File operations.
1336 *
1337 */
1338
1339static unsigned int omap24xxcam_poll(struct file *file,
1340                                     struct poll_table_struct *wait)
1341{
1342        struct omap24xxcam_fh *fh = file->private_data;
1343        struct omap24xxcam_device *cam = fh->cam;
1344        struct videobuf_buffer *vb;
1345
1346        mutex_lock(&cam->mutex);
1347        if (cam->streaming != file) {
1348                mutex_unlock(&cam->mutex);
1349                return POLLERR;
1350        }
1351        mutex_unlock(&cam->mutex);
1352
1353        mutex_lock(&fh->vbq.vb_lock);
1354        if (list_empty(&fh->vbq.stream)) {
1355                mutex_unlock(&fh->vbq.vb_lock);
1356                return POLLERR;
1357        }
1358        vb = list_entry(fh->vbq.stream.next, struct videobuf_buffer, stream);
1359        mutex_unlock(&fh->vbq.vb_lock);
1360
1361        poll_wait(file, &vb->done, wait);
1362
1363        if (vb->state == VIDEOBUF_DONE || vb->state == VIDEOBUF_ERROR)
1364                return POLLIN | POLLRDNORM;
1365
1366        return 0;
1367}
1368
1369static int omap24xxcam_mmap_buffers(struct file *file,
1370                                    struct vm_area_struct *vma)
1371{
1372        struct omap24xxcam_fh *fh = file->private_data;
1373        struct omap24xxcam_device *cam = fh->cam;
1374        struct videobuf_queue *vbq = &fh->vbq;
1375        unsigned int first, last, size, i, j;
1376        int err = 0;
1377
1378        mutex_lock(&cam->mutex);
1379        if (cam->streaming) {
1380                mutex_unlock(&cam->mutex);
1381                return -EBUSY;
1382        }
1383        mutex_unlock(&cam->mutex);
1384        mutex_lock(&vbq->vb_lock);
1385
1386        /* look for first buffer to map */
1387        for (first = 0; first < VIDEO_MAX_FRAME; first++) {
1388                if (NULL == vbq->bufs[first])
1389                        continue;
1390                if (V4L2_MEMORY_MMAP != vbq->bufs[first]->memory)
1391                        continue;
1392                if (vbq->bufs[first]->boff == (vma->vm_pgoff << PAGE_SHIFT))
1393                        break;
1394        }
1395
1396        /* look for last buffer to map */
1397        for (size = 0, last = first; last < VIDEO_MAX_FRAME; last++) {
1398                if (NULL == vbq->bufs[last])
1399                        continue;
1400                if (V4L2_MEMORY_MMAP != vbq->bufs[last]->memory)
1401                        continue;
1402                size += vbq->bufs[last]->bsize;
1403                if (size == (vma->vm_end - vma->vm_start))
1404                        break;
1405        }
1406
1407        size = 0;
1408        for (i = first; i <= last && i < VIDEO_MAX_FRAME; i++) {
1409                struct videobuf_dmabuf *dma = videobuf_to_dma(vbq->bufs[i]);
1410
1411                for (j = 0; j < dma->sglen; j++) {
1412                        err = remap_pfn_range(
1413                                vma, vma->vm_start + size,
1414                                page_to_pfn(sg_page(&dma->sglist[j])),
1415                                sg_dma_len(&dma->sglist[j]), vma->vm_page_prot);
1416                        if (err)
1417                                goto out;
1418                        size += sg_dma_len(&dma->sglist[j]);
1419                }
1420        }
1421
1422out:
1423        mutex_unlock(&vbq->vb_lock);
1424
1425        return err;
1426}
1427
1428static int omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
1429{
1430        struct omap24xxcam_fh *fh = file->private_data;
1431        int rval;
1432
1433        /* let the video-buf mapper check arguments and set-up structures */
1434        rval = videobuf_mmap_mapper(&fh->vbq, vma);
1435        if (rval)
1436                return rval;
1437
1438        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1439
1440        /* do mapping to our allocated buffers */
1441        rval = omap24xxcam_mmap_buffers(file, vma);
1442        /*
1443         * In case of error, free vma->vm_private_data allocated by
1444         * videobuf_mmap_mapper.
1445         */
1446        if (rval)
1447                kfree(vma->vm_private_data);
1448
1449        return rval;
1450}
1451
1452static int omap24xxcam_open(struct file *file)
1453{
1454        struct omap24xxcam_device *cam = omap24xxcam.priv;
1455        struct omap24xxcam_fh *fh;
1456        struct v4l2_format format;
1457
1458        if (!cam || !cam->vfd)
1459                return -ENODEV;
1460
1461        fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1462        if (fh == NULL)
1463                return -ENOMEM;
1464
1465        mutex_lock(&cam->mutex);
1466        if (cam->sdev == NULL || !try_module_get(cam->sdev->module)) {
1467                mutex_unlock(&cam->mutex);
1468                goto out_try_module_get;
1469        }
1470
1471        if (atomic_inc_return(&cam->users) == 1) {
1472                omap24xxcam_hwinit(cam);
1473                if (omap24xxcam_sensor_enable(cam)) {
1474                        mutex_unlock(&cam->mutex);
1475                        goto out_omap24xxcam_sensor_enable;
1476                }
1477        }
1478        mutex_unlock(&cam->mutex);
1479
1480        fh->cam = cam;
1481        mutex_lock(&cam->mutex);
1482        vidioc_int_g_fmt_cap(cam->sdev, &format);
1483        mutex_unlock(&cam->mutex);
1484        /* FIXME: how about fh->pix when there are more users? */
1485        fh->pix = format.fmt.pix;
1486
1487        file->private_data = fh;
1488
1489        spin_lock_init(&fh->vbq_lock);
1490
1491        videobuf_queue_sg_init(&fh->vbq, &omap24xxcam_vbq_ops, NULL,
1492                                &fh->vbq_lock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1493                                V4L2_FIELD_NONE,
1494                                sizeof(struct videobuf_buffer), fh);
1495
1496        return 0;
1497
1498out_omap24xxcam_sensor_enable:
1499        omap24xxcam_poweron_reset(cam);
1500        module_put(cam->sdev->module);
1501
1502out_try_module_get:
1503        kfree(fh);
1504
1505        return -ENODEV;
1506}
1507
1508static int omap24xxcam_release(struct file *file)
1509{
1510        struct omap24xxcam_fh *fh = file->private_data;
1511        struct omap24xxcam_device *cam = fh->cam;
1512
1513        atomic_inc(&cam->reset_disable);
1514
1515        flush_scheduled_work();
1516
1517        /* stop streaming capture */
1518        videobuf_streamoff(&fh->vbq);
1519
1520        mutex_lock(&cam->mutex);
1521        if (cam->streaming == file) {
1522                cam->streaming = NULL;
1523                mutex_unlock(&cam->mutex);
1524                sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1525        } else {
1526                mutex_unlock(&cam->mutex);
1527        }
1528
1529        atomic_dec(&cam->reset_disable);
1530
1531        omap24xxcam_vbq_free_mmap_buffers(&fh->vbq);
1532
1533        /*
1534         * Make sure the reset work we might have scheduled is not
1535         * pending! It may be run *only* if we have users. (And it may
1536         * not be scheduled anymore since streaming is already
1537         * disabled.)
1538         */
1539        flush_scheduled_work();
1540
1541        mutex_lock(&cam->mutex);
1542        if (atomic_dec_return(&cam->users) == 0) {
1543                omap24xxcam_sensor_disable(cam);
1544                omap24xxcam_poweron_reset(cam);
1545        }
1546        mutex_unlock(&cam->mutex);
1547
1548        file->private_data = NULL;
1549
1550        module_put(cam->sdev->module);
1551        kfree(fh);
1552
1553        return 0;
1554}
1555
1556static struct v4l2_file_operations omap24xxcam_fops = {
1557        .ioctl   = video_ioctl2,
1558        .poll    = omap24xxcam_poll,
1559        .mmap    = omap24xxcam_mmap,
1560        .open    = omap24xxcam_open,
1561        .release = omap24xxcam_release,
1562};
1563
1564/*
1565 *
1566 * Power management.
1567 *
1568 */
1569
1570#ifdef CONFIG_PM
1571static int omap24xxcam_suspend(struct platform_device *pdev, pm_message_t state)
1572{
1573        struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1574
1575        if (atomic_read(&cam->users) == 0)
1576                return 0;
1577
1578        if (!atomic_read(&cam->reset_disable))
1579                omap24xxcam_capture_stop(cam);
1580
1581        omap24xxcam_sensor_disable(cam);
1582        omap24xxcam_poweron_reset(cam);
1583
1584        return 0;
1585}
1586
1587static int omap24xxcam_resume(struct platform_device *pdev)
1588{
1589        struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1590
1591        if (atomic_read(&cam->users) == 0)
1592                return 0;
1593
1594        omap24xxcam_hwinit(cam);
1595        omap24xxcam_sensor_enable(cam);
1596
1597        if (!atomic_read(&cam->reset_disable))
1598                omap24xxcam_capture_cont(cam);
1599
1600        return 0;
1601}
1602#endif /* CONFIG_PM */
1603
1604static const struct v4l2_ioctl_ops omap24xxcam_ioctl_fops = {
1605        .vidioc_querycap        = vidioc_querycap,
1606        .vidioc_enum_fmt_vid_cap        = vidioc_enum_fmt_vid_cap,
1607        .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1608        .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1609        .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1610        .vidioc_reqbufs         = vidioc_reqbufs,
1611        .vidioc_querybuf        = vidioc_querybuf,
1612        .vidioc_qbuf            = vidioc_qbuf,
1613        .vidioc_dqbuf           = vidioc_dqbuf,
1614        .vidioc_streamon        = vidioc_streamon,
1615        .vidioc_streamoff       = vidioc_streamoff,
1616        .vidioc_enum_input      = vidioc_enum_input,
1617        .vidioc_g_input         = vidioc_g_input,
1618        .vidioc_s_input         = vidioc_s_input,
1619        .vidioc_queryctrl       = vidioc_queryctrl,
1620        .vidioc_g_ctrl          = vidioc_g_ctrl,
1621        .vidioc_s_ctrl          = vidioc_s_ctrl,
1622        .vidioc_g_parm          = vidioc_g_parm,
1623        .vidioc_s_parm          = vidioc_s_parm,
1624};
1625
1626/*
1627 *
1628 * Camera device (i.e. /dev/video).
1629 *
1630 */
1631
1632static int omap24xxcam_device_register(struct v4l2_int_device *s)
1633{
1634        struct omap24xxcam_device *cam = s->u.slave->master->priv;
1635        struct video_device *vfd;
1636        int rval;
1637
1638        /* We already have a slave. */
1639        if (cam->sdev)
1640                return -EBUSY;
1641
1642        cam->sdev = s;
1643
1644        if (device_create_file(cam->dev, &dev_attr_streaming) != 0) {
1645                dev_err(cam->dev, "could not register sysfs entry\n");
1646                rval = -EBUSY;
1647                goto err;
1648        }
1649
1650        /* initialize the video_device struct */
1651        vfd = cam->vfd = video_device_alloc();
1652        if (!vfd) {
1653                dev_err(cam->dev, "could not allocate video device struct\n");
1654                rval = -ENOMEM;
1655                goto err;
1656        }
1657        vfd->release = video_device_release;
1658
1659        vfd->parent = cam->dev;
1660
1661        strlcpy(vfd->name, CAM_NAME, sizeof(vfd->name));
1662        vfd->fops                = &omap24xxcam_fops;
1663        vfd->ioctl_ops           = &omap24xxcam_ioctl_fops;
1664
1665        omap24xxcam_hwinit(cam);
1666
1667        rval = omap24xxcam_sensor_init(cam);
1668        if (rval)
1669                goto err;
1670
1671        if (video_register_device(vfd, VFL_TYPE_GRABBER, video_nr) < 0) {
1672                dev_err(cam->dev, "could not register V4L device\n");
1673                rval = -EBUSY;
1674                goto err;
1675        }
1676
1677        omap24xxcam_poweron_reset(cam);
1678
1679        dev_info(cam->dev, "registered device %s\n",
1680                 video_device_node_name(vfd));
1681
1682        return 0;
1683
1684err:
1685        omap24xxcam_device_unregister(s);
1686
1687        return rval;
1688}
1689
1690static void omap24xxcam_device_unregister(struct v4l2_int_device *s)
1691{
1692        struct omap24xxcam_device *cam = s->u.slave->master->priv;
1693
1694        omap24xxcam_sensor_exit(cam);
1695
1696        if (cam->vfd) {
1697                if (!video_is_registered(cam->vfd)) {
1698                        /*
1699                         * The device was never registered, so release the
1700                         * video_device struct directly.
1701                         */
1702                        video_device_release(cam->vfd);
1703                } else {
1704                        /*
1705                         * The unregister function will release the
1706                         * video_device struct as well as
1707                         * unregistering it.
1708                         */
1709                        video_unregister_device(cam->vfd);
1710                }
1711                cam->vfd = NULL;
1712        }
1713
1714        device_remove_file(cam->dev, &dev_attr_streaming);
1715
1716        cam->sdev = NULL;
1717}
1718
1719static struct v4l2_int_master omap24xxcam_master = {
1720        .attach = omap24xxcam_device_register,
1721        .detach = omap24xxcam_device_unregister,
1722};
1723
1724static struct v4l2_int_device omap24xxcam = {
1725        .module = THIS_MODULE,
1726        .name   = CAM_NAME,
1727        .type   = v4l2_int_type_master,
1728        .u      = {
1729                .master = &omap24xxcam_master
1730        },
1731};
1732
1733/*
1734 *
1735 * Driver initialisation and deinitialisation.
1736 *
1737 */
1738
1739static int __devinit omap24xxcam_probe(struct platform_device *pdev)
1740{
1741        struct omap24xxcam_device *cam;
1742        struct resource *mem;
1743        int irq;
1744
1745        cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1746        if (!cam) {
1747                dev_err(&pdev->dev, "could not allocate memory\n");
1748                goto err;
1749        }
1750
1751        platform_set_drvdata(pdev, cam);
1752
1753        cam->dev = &pdev->dev;
1754
1755        /*
1756         * Impose a lower limit on the amount of memory allocated for
1757         * capture. We require at least enough memory to double-buffer
1758         * QVGA (300KB).
1759         */
1760        if (capture_mem < 320 * 240 * 2 * 2)
1761                capture_mem = 320 * 240 * 2 * 2;
1762        cam->capture_mem = capture_mem;
1763
1764        /* request the mem region for the camera registers */
1765        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1766        if (!mem) {
1767                dev_err(cam->dev, "no mem resource?\n");
1768                goto err;
1769        }
1770        if (!request_mem_region(mem->start, (mem->end - mem->start) + 1,
1771                                pdev->name)) {
1772                dev_err(cam->dev,
1773                        "cannot reserve camera register I/O region\n");
1774                goto err;
1775        }
1776        cam->mmio_base_phys = mem->start;
1777        cam->mmio_size = (mem->end - mem->start) + 1;
1778
1779        /* map the region */
1780        cam->mmio_base = (unsigned long)
1781                ioremap_nocache(cam->mmio_base_phys, cam->mmio_size);
1782        if (!cam->mmio_base) {
1783                dev_err(cam->dev, "cannot map camera register I/O region\n");
1784                goto err;
1785        }
1786
1787        irq = platform_get_irq(pdev, 0);
1788        if (irq <= 0) {
1789                dev_err(cam->dev, "no irq for camera?\n");
1790                goto err;
1791        }
1792
1793        /* install the interrupt service routine */
1794        if (request_irq(irq, omap24xxcam_isr, 0, CAM_NAME, cam)) {
1795                dev_err(cam->dev,
1796                        "could not install interrupt service routine\n");
1797                goto err;
1798        }
1799        cam->irq = irq;
1800
1801        if (omap24xxcam_clock_get(cam))
1802                goto err;
1803
1804        INIT_WORK(&cam->sensor_reset_work, omap24xxcam_sensor_reset_work);
1805
1806        mutex_init(&cam->mutex);
1807        spin_lock_init(&cam->core_enable_disable_lock);
1808
1809        omap24xxcam_sgdma_init(&cam->sgdma,
1810                               cam->mmio_base + CAMDMA_REG_OFFSET,
1811                               omap24xxcam_stalled_dma_reset,
1812                               (unsigned long)cam);
1813
1814        omap24xxcam.priv = cam;
1815
1816        if (v4l2_int_device_register(&omap24xxcam))
1817                goto err;
1818
1819        return 0;
1820
1821err:
1822        omap24xxcam_remove(pdev);
1823        return -ENODEV;
1824}
1825
1826static int omap24xxcam_remove(struct platform_device *pdev)
1827{
1828        struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1829
1830        if (!cam)
1831                return 0;
1832
1833        if (omap24xxcam.priv != NULL)
1834                v4l2_int_device_unregister(&omap24xxcam);
1835        omap24xxcam.priv = NULL;
1836
1837        omap24xxcam_clock_put(cam);
1838
1839        if (cam->irq) {
1840                free_irq(cam->irq, cam);
1841                cam->irq = 0;
1842        }
1843
1844        if (cam->mmio_base) {
1845                iounmap((void *)cam->mmio_base);
1846                cam->mmio_base = 0;
1847        }
1848
1849        if (cam->mmio_base_phys) {
1850                release_mem_region(cam->mmio_base_phys, cam->mmio_size);
1851                cam->mmio_base_phys = 0;
1852        }
1853
1854        kfree(cam);
1855
1856        return 0;
1857}
1858
1859static struct platform_driver omap24xxcam_driver = {
1860        .probe   = omap24xxcam_probe,
1861        .remove  = omap24xxcam_remove,
1862#ifdef CONFIG_PM
1863        .suspend = omap24xxcam_suspend,
1864        .resume  = omap24xxcam_resume,
1865#endif
1866        .driver  = {
1867                .name = CAM_NAME,
1868                .owner = THIS_MODULE,
1869        },
1870};
1871
1872/*
1873 *
1874 * Module initialisation and deinitialisation
1875 *
1876 */
1877
1878static int __init omap24xxcam_init(void)
1879{
1880        return platform_driver_register(&omap24xxcam_driver);
1881}
1882
1883static void __exit omap24xxcam_cleanup(void)
1884{
1885        platform_driver_unregister(&omap24xxcam_driver);
1886}
1887
1888MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
1889MODULE_DESCRIPTION("OMAP24xx Video for Linux camera driver");
1890MODULE_LICENSE("GPL");
1891module_param(video_nr, int, 0);
1892MODULE_PARM_DESC(video_nr,
1893                 "Minor number for video device (-1 ==> auto assign)");
1894module_param(capture_mem, int, 0);
1895MODULE_PARM_DESC(capture_mem, "Maximum amount of memory for capture "
1896                 "buffers (default 4800kiB)");
1897
1898module_init(omap24xxcam_init);
1899module_exit(omap24xxcam_cleanup);
1900