drivers/media/video/sh_mobile_ceu_camera.c

   1 /*
   2  * V4L2 Driver for SuperH Mobile CEU interface
   3  *
   4  * Copyright (C) 2008 Magnus Damm
   5  *
   6  * Based on V4L2 Driver for PXA camera host - "pxa_camera.c",
   7  *
   8  * Copyright (C) 2006, Sascha Hauer, Pengutronix
   9  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  */
  16
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/io.h>
  20 #include <linux/delay.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/errno.h>
  23 #include <linux/fs.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/kernel.h>
  26 #include <linux/mm.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/time.h>
  29 #include <linux/version.h>
  30 #include <linux/device.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/videodev2.h>
  33 #include <linux/pm_runtime.h>
  34 #include <linux/sched.h>
  35
  36 #include <media/v4l2-common.h>
  37 #include <media/v4l2-dev.h>
  38 #include <media/soc_camera.h>
  39 #include <media/sh_mobile_ceu.h>
  40 #include <media/videobuf-dma-contig.h>
  41 #include <media/v4l2-mediabus.h>
  42 #include <media/soc_mediabus.h>
  43
  44 /* register offsets for sh7722 / sh7723 */
  45
  46 #define CAPSR  0x00 /* Capture start register */
  47 #define CAPCR  0x04 /* Capture control register */
  48 #define CAMCR  0x08 /* Capture interface control register */
  49 #define CMCYR  0x0c /* Capture interface cycle  register */
  50 #define CAMOR  0x10 /* Capture interface offset register */
  51 #define CAPWR  0x14 /* Capture interface width register */
  52 #define CAIFR  0x18 /* Capture interface input format register */
  53 #define CSTCR  0x20 /* Camera strobe control register (<= sh7722) */
  54 #define CSECR  0x24 /* Camera strobe emission count register (<= sh7722) */
  55 #define CRCNTR 0x28 /* CEU register control register */
  56 #define CRCMPR 0x2c /* CEU register forcible control register */
  57 #define CFLCR  0x30 /* Capture filter control register */
  58 #define CFSZR  0x34 /* Capture filter size clip register */
  59 #define CDWDR  0x38 /* Capture destination width register */
  60 #define CDAYR  0x3c /* Capture data address Y register */
  61 #define CDACR  0x40 /* Capture data address C register */
  62 #define CDBYR  0x44 /* Capture data bottom-field address Y register */
  63 #define CDBCR  0x48 /* Capture data bottom-field address C register */
  64 #define CBDSR  0x4c /* Capture bundle destination size register */
  65 #define CFWCR  0x5c /* Firewall operation control register */
  66 #define CLFCR  0x60 /* Capture low-pass filter control register */
  67 #define CDOCR  0x64 /* Capture data output control register */
  68 #define CDDCR  0x68 /* Capture data complexity level register */
  69 #define CDDAR  0x6c /* Capture data complexity level address register */
  70 #define CEIER  0x70 /* Capture event interrupt enable register */
  71 #define CETCR  0x74 /* Capture event flag clear register */
  72 #define CSTSR  0x7c /* Capture status register */
  73 #define CSRTR  0x80 /* Capture software reset register */
  74 #define CDSSR  0x84 /* Capture data size register */
  75 #define CDAYR2 0x90 /* Capture data address Y register 2 */
  76 #define CDACR2 0x94 /* Capture data address C register 2 */
  77 #define CDBYR2 0x98 /* Capture data bottom-field address Y register 2 */
  78 #define CDBCR2 0x9c /* Capture data bottom-field address C register 2 */
  79
  80 #undef DEBUG_GEOMETRY
  81 #ifdef DEBUG_GEOMETRY
  82 #define dev_geo dev_info
  83 #else
  84 #define dev_geo dev_dbg
  85 #endif
  86
  87 /* per video frame buffer */
  88 struct sh_mobile_ceu_buffer {
  89         struct videobuf_buffer vb; /* v4l buffer must be first */
  90         enum v4l2_mbus_pixelcode code;
  91 };
  92
  93 struct sh_mobile_ceu_dev {
  94         struct soc_camera_host ici;
  95         struct soc_camera_device *icd;
  96
  97         unsigned int irq;
  98         void __iomem *base;
  99         unsigned long video_limit;
 100
 101         /* lock used to protect videobuf */
 102         spinlock_t lock;
 103         struct list_head capture;
 104         struct videobuf_buffer *active;
 105
 106         struct sh_mobile_ceu_info *pdata;
 107
 108         u32 cflcr;
 109
 110         enum v4l2_field field;
 111
 112         unsigned int image_mode:1;
 113         unsigned int is_16bit:1;
 114 };
 115
 116 struct sh_mobile_ceu_cam {
 117         struct v4l2_rect ceu_rect;
 118         unsigned int cam_width;
 119         unsigned int cam_height;
 120         const struct soc_mbus_pixelfmt *extra_fmt;
 121         enum v4l2_mbus_pixelcode code;
 122 };
 123
 124 static unsigned long make_bus_param(struct sh_mobile_ceu_dev *pcdev)
 125 {
 126         unsigned long flags;
 127
 128         flags = SOCAM_MASTER |
 129                 SOCAM_PCLK_SAMPLE_RISING |
 130                 SOCAM_HSYNC_ACTIVE_HIGH |
 131                 SOCAM_HSYNC_ACTIVE_LOW |
 132                 SOCAM_VSYNC_ACTIVE_HIGH |
 133                 SOCAM_VSYNC_ACTIVE_LOW |
 134                 SOCAM_DATA_ACTIVE_HIGH;
 135
 136         if (pcdev->pdata->flags & SH_CEU_FLAG_USE_8BIT_BUS)
 137                 flags |= SOCAM_DATAWIDTH_8;
 138
 139         if (pcdev->pdata->flags & SH_CEU_FLAG_USE_16BIT_BUS)
 140                 flags |= SOCAM_DATAWIDTH_16;
 141
 142         if (flags & SOCAM_DATAWIDTH_MASK)
 143                 return flags;
 144
 145         return 0;
 146 }
 147
 148 static void ceu_write(struct sh_mobile_ceu_dev *priv,
 149                       unsigned long reg_offs, u32 data)
 150 {
 151         iowrite32(data, priv->base + reg_offs);
 152 }
 153
 154 static u32 ceu_read(struct sh_mobile_ceu_dev *priv, unsigned long reg_offs)
 155 {
 156         return ioread32(priv->base + reg_offs);
 157 }
 158
 159 static int sh_mobile_ceu_soft_reset(struct sh_mobile_ceu_dev *pcdev)
 160 {
 161         int i, success = 0;
 162         struct soc_camera_device *icd = pcdev->icd;
 163
 164         ceu_write(pcdev, CAPSR, 1 << 16); /* reset */
 165
 166         /* wait CSTSR.CPTON bit */
 167         for (i = 0; i < 1000; i++) {
 168                 if (!(ceu_read(pcdev, CSTSR) & 1)) {
 169                         success++;
 170                         break;
 171                 }
 172                 udelay(1);
 173         }
 174
 175         /* wait CAPSR.CPKIL bit */
 176         for (i = 0; i < 1000; i++) {
 177                 if (!(ceu_read(pcdev, CAPSR) & (1 << 16))) {
 178                         success++;
 179                         break;
 180                 }
 181                 udelay(1);
 182         }
 183
 184
 185         if (2 != success) {
 186                 dev_warn(&icd->dev, "soft reset time out\n");
 187                 return -EIO;
 188         }
 189
 190         return 0;
 191 }
 192
 193 /*
 194  *  Videobuf operations
 195  */
 196 static int sh_mobile_ceu_videobuf_setup(struct videobuf_queue *vq,
 197                                         unsigned int *count,
 198                                         unsigned int *size)
 199 {
 200         struct soc_camera_device *icd = vq->priv_data;
 201         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 202         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 203         int bytes_per_line = soc_mbus_bytes_per_line(icd->user_width,
 204                                                 icd->current_fmt->host_fmt);
 205
 206         if (bytes_per_line < 0)
 207                 return bytes_per_line;
 208
 209         *size = bytes_per_line * icd->user_height;
 210
 211         if (0 == *count)
 212                 *count = 2;
 213
 214         if (pcdev->video_limit) {
 215                 while (PAGE_ALIGN(*size) * *count > pcdev->video_limit)
 216                         (*count)--;
 217         }
 218
 219         dev_dbg(icd->dev.parent, "count=%d, size=%d\n", *count, *size);
 220
 221         return 0;
 222 }
 223
 224 static void free_buffer(struct videobuf_queue *vq,
 225                         struct sh_mobile_ceu_buffer *buf)
 226 {
 227         struct soc_camera_device *icd = vq->priv_data;
 228         struct device *dev = icd->dev.parent;
 229
 230         dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
 231                 &buf->vb, buf->vb.baddr, buf->vb.bsize);
 232
 233         if (in_interrupt())
 234                 BUG();
 235
 236         videobuf_waiton(&buf->vb, 0, 0);
 237         videobuf_dma_contig_free(vq, &buf->vb);
 238         dev_dbg(dev, "%s freed\n", __func__);
 239         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 240 }
 241
 242 #define CEU_CETCR_MAGIC 0x0317f313 /* acknowledge magical interrupt sources */
 243 #define CEU_CETCR_IGRW (1 << 4) /* prohibited register access interrupt bit */
 244 #define CEU_CEIER_CPEIE (1 << 0) /* one-frame capture end interrupt */
 245 #define CEU_CEIER_VBP   (1 << 20) /* vbp error */
 246 #define CEU_CAPCR_CTNCP (1 << 16) /* continuous capture mode (if set) */
 247 #define CEU_CEIER_MASK (CEU_CEIER_CPEIE | CEU_CEIER_VBP)
 248
 249
 250 /*
 251  * return value doesn't reflex the success/failure to queue the new buffer,
 252  * but rather the status of the previous buffer.
 253  */
 254 static int sh_mobile_ceu_capture(struct sh_mobile_ceu_dev *pcdev)
 255 {
 256         struct soc_camera_device *icd = pcdev->icd;
 257         dma_addr_t phys_addr_top, phys_addr_bottom;
 258         unsigned long top1, top2;
 259         unsigned long bottom1, bottom2;
 260         u32 status;
 261         int ret = 0;
 262
 263         /*
 264          * The hardware is _very_ picky about this sequence. Especially
 265          * the CEU_CETCR_MAGIC value. It seems like we need to acknowledge
 266          * several not-so-well documented interrupt sources in CETCR.
 267          */
 268         ceu_write(pcdev, CEIER, ceu_read(pcdev, CEIER) & ~CEU_CEIER_MASK);
 269         status = ceu_read(pcdev, CETCR);
 270         ceu_write(pcdev, CETCR, ~status & CEU_CETCR_MAGIC);
 271         ceu_write(pcdev, CEIER, ceu_read(pcdev, CEIER) | CEU_CEIER_MASK);
 272         ceu_write(pcdev, CAPCR, ceu_read(pcdev, CAPCR) & ~CEU_CAPCR_CTNCP);
 273         ceu_write(pcdev, CETCR, CEU_CETCR_MAGIC ^ CEU_CETCR_IGRW);
 274
 275         /*
 276          * When a VBP interrupt occurs, a capture end interrupt does not occur
 277          * and the image of that frame is not captured correctly. So, soft reset
 278          * is needed here.
 279          */
 280         if (status & CEU_CEIER_VBP) {
 281                 sh_mobile_ceu_soft_reset(pcdev);
 282                 ret = -EIO;
 283         }
 284
 285         if (!pcdev->active)
 286                 return ret;
 287
 288         if (V4L2_FIELD_INTERLACED_BT == pcdev->field) {
 289                 top1    = CDBYR;
 290                 top2    = CDBCR;
 291                 bottom1 = CDAYR;
 292                 bottom2 = CDACR;
 293         } else {
 294                 top1    = CDAYR;
 295                 top2    = CDACR;
 296                 bottom1 = CDBYR;
 297                 bottom2 = CDBCR;
 298         }
 299
 300         phys_addr_top = videobuf_to_dma_contig(pcdev->active);
 301         ceu_write(pcdev, top1, phys_addr_top);
 302         if (V4L2_FIELD_NONE != pcdev->field) {
 303                 phys_addr_bottom = phys_addr_top + icd->user_width;
 304                 ceu_write(pcdev, bottom1, phys_addr_bottom);
 305         }
 306
 307         switch (icd->current_fmt->host_fmt->fourcc) {
 308         case V4L2_PIX_FMT_NV12:
 309         case V4L2_PIX_FMT_NV21:
 310         case V4L2_PIX_FMT_NV16:
 311         case V4L2_PIX_FMT_NV61:
 312                 phys_addr_top += icd->user_width *
 313                         icd->user_height;
 314                 ceu_write(pcdev, top2, phys_addr_top);
 315                 if (V4L2_FIELD_NONE != pcdev->field) {
 316                         phys_addr_bottom = phys_addr_top + icd->user_width;
 317                         ceu_write(pcdev, bottom2, phys_addr_bottom);
 318                 }
 319         }
 320
 321         pcdev->active->state = VIDEOBUF_ACTIVE;
 322         ceu_write(pcdev, CAPSR, 0x1); /* start capture */
 323
 324         return ret;
 325 }
 326
 327 static int sh_mobile_ceu_videobuf_prepare(struct videobuf_queue *vq,
 328                                           struct videobuf_buffer *vb,
 329                                           enum v4l2_field field)
 330 {
 331         struct soc_camera_device *icd = vq->priv_data;
 332         struct sh_mobile_ceu_buffer *buf;
 333         int bytes_per_line = soc_mbus_bytes_per_line(icd->user_width,
 334                                                 icd->current_fmt->host_fmt);
 335         int ret;
 336
 337         if (bytes_per_line < 0)
 338                 return bytes_per_line;
 339
 340         buf = container_of(vb, struct sh_mobile_ceu_buffer, vb);
 341
 342         dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
 343                 vb, vb->baddr, vb->bsize);
 344
 345         /* Added list head initialization on alloc */
 346         WARN_ON(!list_empty(&vb->queue));
 347
 348 #ifdef DEBUG
 349         /*
 350          * This can be useful if you want to see if we actually fill
 351          * the buffer with something
 352          */
 353         memset((void *)vb->baddr, 0xaa, vb->bsize);
 354 #endif
 355
 356         BUG_ON(NULL == icd->current_fmt);
 357
 358         if (buf->code   != icd->current_fmt->code ||
 359             vb->width   != icd->user_width ||
 360             vb->height  != icd->user_height ||
 361             vb->field   != field) {
 362                 buf->code       = icd->current_fmt->code;
 363                 vb->width       = icd->user_width;
 364                 vb->height      = icd->user_height;
 365                 vb->field       = field;
 366                 vb->state       = VIDEOBUF_NEEDS_INIT;
 367         }
 368
 369         vb->size = vb->height * bytes_per_line;
 370         if (0 != vb->baddr && vb->bsize < vb->size) {
 371                 ret = -EINVAL;
 372                 goto out;
 373         }
 374
 375         if (vb->state == VIDEOBUF_NEEDS_INIT) {
 376                 ret = videobuf_iolock(vq, vb, NULL);
 377                 if (ret)
 378                         goto fail;
 379                 vb->state = VIDEOBUF_PREPARED;
 380         }
 381
 382         return 0;
 383 fail:
 384         free_buffer(vq, buf);
 385 out:
 386         return ret;
 387 }
 388
 389 /* Called under spinlock_irqsave(&pcdev->lock, ...) */
 390 static void sh_mobile_ceu_videobuf_queue(struct videobuf_queue *vq,
 391                                          struct videobuf_buffer *vb)
 392 {
 393         struct soc_camera_device *icd = vq->priv_data;
 394         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 395         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 396
 397         dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
 398                 vb, vb->baddr, vb->bsize);
 399
 400         vb->state = VIDEOBUF_QUEUED;
 401         list_add_tail(&vb->queue, &pcdev->capture);
 402
 403         if (!pcdev->active) {
 404                 /*
 405                  * Because there were no active buffer at this moment,
 406                  * we are not interested in the return value of
 407                  * sh_mobile_ceu_capture here.
 408                  */
 409                 pcdev->active = vb;
 410                 sh_mobile_ceu_capture(pcdev);
 411         }
 412 }
 413
 414 static void sh_mobile_ceu_videobuf_release(struct videobuf_queue *vq,
 415                                            struct videobuf_buffer *vb)
 416 {
 417         struct soc_camera_device *icd = vq->priv_data;
 418         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 419         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 420         unsigned long flags;
 421
 422         spin_lock_irqsave(&pcdev->lock, flags);
 423
 424         if (pcdev->active == vb) {
 425                 /* disable capture (release DMA buffer), reset */
 426                 ceu_write(pcdev, CAPSR, 1 << 16);
 427                 pcdev->active = NULL;
 428         }
 429
 430         if ((vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) &&
 431             !list_empty(&vb->queue)) {
 432                 vb->state = VIDEOBUF_ERROR;
 433                 list_del_init(&vb->queue);
 434         }
 435
 436         spin_unlock_irqrestore(&pcdev->lock, flags);
 437
 438         free_buffer(vq, container_of(vb, struct sh_mobile_ceu_buffer, vb));
 439 }
 440
 441 static struct videobuf_queue_ops sh_mobile_ceu_videobuf_ops = {
 442         .buf_setup      = sh_mobile_ceu_videobuf_setup,
 443         .buf_prepare    = sh_mobile_ceu_videobuf_prepare,
 444         .buf_queue      = sh_mobile_ceu_videobuf_queue,
 445         .buf_release    = sh_mobile_ceu_videobuf_release,
 446 };
 447
 448 static irqreturn_t sh_mobile_ceu_irq(int irq, void *data)
 449 {
 450         struct sh_mobile_ceu_dev *pcdev = data;
 451         struct videobuf_buffer *vb;
 452         unsigned long flags;
 453
 454         spin_lock_irqsave(&pcdev->lock, flags);
 455
 456         vb = pcdev->active;
 457         if (!vb)
 458                 /* Stale interrupt from a released buffer */
 459                 goto out;
 460
 461         list_del_init(&vb->queue);
 462
 463         if (!list_empty(&pcdev->capture))
 464                 pcdev->active = list_entry(pcdev->capture.next,
 465                                            struct videobuf_buffer, queue);
 466         else
 467                 pcdev->active = NULL;
 468
 469         vb->state = (sh_mobile_ceu_capture(pcdev) < 0) ?
 470                 VIDEOBUF_ERROR : VIDEOBUF_DONE;
 471         do_gettimeofday(&vb->ts);
 472         vb->field_count++;
 473         wake_up(&vb->done);
 474
 475 out:
 476         spin_unlock_irqrestore(&pcdev->lock, flags);
 477
 478         return IRQ_HANDLED;
 479 }
 480
 481 /* Called with .video_lock held */
 482 static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
 483 {
 484         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 485         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 486         int ret;
 487
 488         if (pcdev->icd)
 489                 return -EBUSY;
 490
 491         dev_info(icd->dev.parent,
 492                  "SuperH Mobile CEU driver attached to camera %d\n",
 493                  icd->devnum);
 494
 495         pm_runtime_get_sync(ici->v4l2_dev.dev);
 496
 497         ret = sh_mobile_ceu_soft_reset(pcdev);
 498         if (!ret)
 499                 pcdev->icd = icd;
 500
 501         return ret;
 502 }
 503
 504 /* Called with .video_lock held */
 505 static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
 506 {
 507         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 508         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 509         unsigned long flags;
 510
 511         BUG_ON(icd != pcdev->icd);
 512
 513         /* disable capture, disable interrupts */
 514         ceu_write(pcdev, CEIER, 0);
 515         sh_mobile_ceu_soft_reset(pcdev);
 516
 517         /* make sure active buffer is canceled */
 518         spin_lock_irqsave(&pcdev->lock, flags);
 519         if (pcdev->active) {
 520                 list_del(&pcdev->active->queue);
 521                 pcdev->active->state = VIDEOBUF_ERROR;
 522                 wake_up_all(&pcdev->active->done);
 523                 pcdev->active = NULL;
 524         }
 525         spin_unlock_irqrestore(&pcdev->lock, flags);
 526
 527         pm_runtime_put_sync(ici->v4l2_dev.dev);
 528
 529         dev_info(icd->dev.parent,
 530                  "SuperH Mobile CEU driver detached from camera %d\n",
 531                  icd->devnum);
 532
 533         pcdev->icd = NULL;
 534 }
 535
 536 /*
 537  * See chapter 29.4.12 "Capture Filter Control Register (CFLCR)"
 538  * in SH7722 Hardware Manual
 539  */
 540 static unsigned int size_dst(unsigned int src, unsigned int scale)
 541 {
 542         unsigned int mant_pre = scale >> 12;
 543         if (!src || !scale)
 544                 return src;
 545         return ((mant_pre + 2 * (src - 1)) / (2 * mant_pre) - 1) *
 546                 mant_pre * 4096 / scale + 1;
 547 }
 548
 549 static u16 calc_scale(unsigned int src, unsigned int *dst)
 550 {
 551         u16 scale;
 552
 553         if (src == *dst)
 554                 return 0;
 555
 556         scale = (src * 4096 / *dst) & ~7;
 557
 558         while (scale > 4096 && size_dst(src, scale) < *dst)
 559                 scale -= 8;
 560
 561         *dst = size_dst(src, scale);
 562
 563         return scale;
 564 }
 565
 566 /* rect is guaranteed to not exceed the scaled camera rectangle */
 567 static void sh_mobile_ceu_set_rect(struct soc_camera_device *icd,
 568                                    unsigned int out_width,
 569                                    unsigned int out_height)
 570 {
 571         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 572         struct sh_mobile_ceu_cam *cam = icd->host_priv;
 573         struct v4l2_rect *rect = &cam->ceu_rect;
 574         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 575         unsigned int height, width, cdwdr_width, in_width, in_height;
 576         unsigned int left_offset, top_offset;
 577         u32 camor;
 578
 579         dev_dbg(icd->dev.parent, "Crop %ux%u@%u:%u\n",
 580                 rect->width, rect->height, rect->left, rect->top);
 581
 582         left_offset     = rect->left;
 583         top_offset      = rect->top;
 584
 585         if (pcdev->image_mode) {
 586                 in_width = rect->width;
 587                 if (!pcdev->is_16bit) {
 588                         in_width *= 2;
 589                         left_offset *= 2;
 590                 }
 591                 width = out_width;
 592                 cdwdr_width = out_width;
 593         } else {
 594                 int bytes_per_line = soc_mbus_bytes_per_line(out_width,
 595                                                 icd->current_fmt->host_fmt);
 596                 unsigned int w_factor;
 597
 598                 width = out_width;
 599
 600                 switch (icd->current_fmt->host_fmt->packing) {
 601                 case SOC_MBUS_PACKING_2X8_PADHI:
 602                         w_factor = 2;
 603                         break;
 604                 default:
 605                         w_factor = 1;
 606                 }
 607
 608                 in_width = rect->width * w_factor;
 609                 left_offset = left_offset * w_factor;
 610
 611                 if (bytes_per_line < 0)
 612                         cdwdr_width = out_width;
 613                 else
 614                         cdwdr_width = bytes_per_line;
 615         }
 616
 617         height = out_height;
 618         in_height = rect->height;
 619         if (V4L2_FIELD_NONE != pcdev->field) {
 620                 height /= 2;
 621                 in_height /= 2;
 622                 top_offset /= 2;
 623                 cdwdr_width *= 2;
 624         }
 625
 626         /* Set CAMOR, CAPWR, CFSZR, take care of CDWDR */
 627         camor = left_offset | (top_offset << 16);
 628
 629         dev_geo(icd->dev.parent,
 630                 "CAMOR 0x%x, CAPWR 0x%x, CFSZR 0x%x, CDWDR 0x%x\n", camor,
 631                 (in_height << 16) | in_width, (height << 16) | width,
 632                 cdwdr_width);
 633
 634         ceu_write(pcdev, CAMOR, camor);
 635         ceu_write(pcdev, CAPWR, (in_height << 16) | in_width);
 636         ceu_write(pcdev, CFSZR, (height << 16) | width);
 637         ceu_write(pcdev, CDWDR, cdwdr_width);
 638 }
 639
 640 static u32 capture_save_reset(struct sh_mobile_ceu_dev *pcdev)
 641 {
 642         u32 capsr = ceu_read(pcdev, CAPSR);
 643         ceu_write(pcdev, CAPSR, 1 << 16); /* reset, stop capture */
 644         return capsr;
 645 }
 646
 647 static void capture_restore(struct sh_mobile_ceu_dev *pcdev, u32 capsr)
 648 {
 649         unsigned long timeout = jiffies + 10 * HZ;
 650
 651         /*
 652          * Wait until the end of the current frame. It can take a long time,
 653          * but if it has been aborted by a CAPSR reset, it shoule exit sooner.
 654          */
 655         while ((ceu_read(pcdev, CSTSR) & 1) && time_before(jiffies, timeout))
 656                 msleep(1);
 657
 658         if (time_after(jiffies, timeout)) {
 659                 dev_err(pcdev->ici.v4l2_dev.dev,
 660                         "Timeout waiting for frame end! Interface problem?\n");
 661                 return;
 662         }
 663
 664         /* Wait until reset clears, this shall not hang... */
 665         while (ceu_read(pcdev, CAPSR) & (1 << 16))
 666                 udelay(10);
 667
 668         /* Anything to restore? */
 669         if (capsr & ~(1 << 16))
 670                 ceu_write(pcdev, CAPSR, capsr);
 671 }
 672
 673 static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
 674                                        __u32 pixfmt)
 675 {
 676         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 677         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 678         int ret;
 679         unsigned long camera_flags, common_flags, value;
 680         int yuv_lineskip;
 681         struct sh_mobile_ceu_cam *cam = icd->host_priv;
 682         u32 capsr = capture_save_reset(pcdev);
 683
 684         camera_flags = icd->ops->query_bus_param(icd);
 685         common_flags = soc_camera_bus_param_compatible(camera_flags,
 686                                                        make_bus_param(pcdev));
 687         if (!common_flags)
 688                 return -EINVAL;
 689
 690         /* Make choises, based on platform preferences */
 691         if ((common_flags & SOCAM_HSYNC_ACTIVE_HIGH) &&
 692             (common_flags & SOCAM_HSYNC_ACTIVE_LOW)) {
 693                 if (pcdev->pdata->flags & SH_CEU_FLAG_HSYNC_LOW)
 694                         common_flags &= ~SOCAM_HSYNC_ACTIVE_HIGH;
 695                 else
 696                         common_flags &= ~SOCAM_HSYNC_ACTIVE_LOW;
 697         }
 698
 699         if ((common_flags & SOCAM_VSYNC_ACTIVE_HIGH) &&
 700             (common_flags & SOCAM_VSYNC_ACTIVE_LOW)) {
 701                 if (pcdev->pdata->flags & SH_CEU_FLAG_VSYNC_LOW)
 702                         common_flags &= ~SOCAM_VSYNC_ACTIVE_HIGH;
 703                 else
 704                         common_flags &= ~SOCAM_VSYNC_ACTIVE_LOW;
 705         }
 706
 707         ret = icd->ops->set_bus_param(icd, common_flags);
 708         if (ret < 0)
 709                 return ret;
 710
 711         switch (common_flags & SOCAM_DATAWIDTH_MASK) {
 712         case SOCAM_DATAWIDTH_8:
 713                 pcdev->is_16bit = 0;
 714                 break;
 715         case SOCAM_DATAWIDTH_16:
 716                 pcdev->is_16bit = 1;
 717                 break;
 718         default:
 719                 return -EINVAL;
 720         }
 721
 722         ceu_write(pcdev, CRCNTR, 0);
 723         ceu_write(pcdev, CRCMPR, 0);
 724
 725         value = 0x00000010; /* data fetch by default */
 726         yuv_lineskip = 0;
 727
 728         switch (icd->current_fmt->host_fmt->fourcc) {
 729         case V4L2_PIX_FMT_NV12:
 730         case V4L2_PIX_FMT_NV21:
 731                 yuv_lineskip = 1; /* skip for NV12/21, no skip for NV16/61 */
 732                 /* fall-through */
 733         case V4L2_PIX_FMT_NV16:
 734         case V4L2_PIX_FMT_NV61:
 735                 switch (cam->code) {
 736                 case V4L2_MBUS_FMT_YUYV8_2X8_BE:
 737                         value = 0x00000000; /* Cb0, Y0, Cr0, Y1 */
 738                         break;
 739                 case V4L2_MBUS_FMT_YVYU8_2X8_BE:
 740                         value = 0x00000100; /* Cr0, Y0, Cb0, Y1 */
 741                         break;
 742                 case V4L2_MBUS_FMT_YUYV8_2X8_LE:
 743                         value = 0x00000200; /* Y0, Cb0, Y1, Cr0 */
 744                         break;
 745                 case V4L2_MBUS_FMT_YVYU8_2X8_LE:
 746                         value = 0x00000300; /* Y0, Cr0, Y1, Cb0 */
 747                         break;
 748                 default:
 749                         BUG();
 750                 }
 751         }
 752
 753         if (icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_NV21 ||
 754             icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_NV61)
 755                 value ^= 0x00000100; /* swap U, V to change from NV1x->NVx1 */
 756
 757         value |= common_flags & SOCAM_VSYNC_ACTIVE_LOW ? 1 << 1 : 0;
 758         value |= common_flags & SOCAM_HSYNC_ACTIVE_LOW ? 1 << 0 : 0;
 759         value |= pcdev->is_16bit ? 1 << 12 : 0;
 760         ceu_write(pcdev, CAMCR, value);
 761
 762         ceu_write(pcdev, CAPCR, 0x00300000);
 763
 764         switch (pcdev->field) {
 765         case V4L2_FIELD_INTERLACED_TB:
 766                 value = 0x101;
 767                 break;
 768         case V4L2_FIELD_INTERLACED_BT:
 769                 value = 0x102;
 770                 break;
 771         default:
 772                 value = 0;
 773                 break;
 774         }
 775         ceu_write(pcdev, CAIFR, value);
 776
 777         sh_mobile_ceu_set_rect(icd, icd->user_width, icd->user_height);
 778         mdelay(1);
 779
 780         ceu_write(pcdev, CFLCR, pcdev->cflcr);
 781
 782         /*
 783          * A few words about byte order (observed in Big Endian mode)
 784          *
 785          * In data fetch mode bytes are received in chunks of 8 bytes.
 786          * D0, D1, D2, D3, D4, D5, D6, D7 (D0 received first)
 787          *
 788          * The data is however by default written to memory in reverse order:
 789          * D7, D6, D5, D4, D3, D2, D1, D0 (D7 written to lowest byte)
 790          *
 791          * The lowest three bits of CDOCR allows us to do swapping,
 792          * using 7 we swap the data bytes to match the incoming order:
 793          * D0, D1, D2, D3, D4, D5, D6, D7
 794          */
 795         value = 0x00000017;
 796         if (yuv_lineskip)
 797                 value &= ~0x00000010; /* convert 4:2:2 -> 4:2:0 */
 798
 799         ceu_write(pcdev, CDOCR, value);
 800         ceu_write(pcdev, CFWCR, 0); /* keep "datafetch firewall" disabled */
 801
 802         dev_dbg(icd->dev.parent, "S_FMT successful for %c%c%c%c %ux%u\n",
 803                 pixfmt & 0xff, (pixfmt >> 8) & 0xff,
 804                 (pixfmt >> 16) & 0xff, (pixfmt >> 24) & 0xff,
 805                 icd->user_width, icd->user_height);
 806
 807         capture_restore(pcdev, capsr);
 808
 809         /* not in bundle mode: skip CBDSR, CDAYR2, CDACR2, CDBYR2, CDBCR2 */
 810         return 0;
 811 }
 812
 813 static int sh_mobile_ceu_try_bus_param(struct soc_camera_device *icd,
 814                                        unsigned char buswidth)
 815 {
 816         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 817         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 818         unsigned long camera_flags, common_flags;
 819
 820         camera_flags = icd->ops->query_bus_param(icd);
 821         common_flags = soc_camera_bus_param_compatible(camera_flags,
 822                                                        make_bus_param(pcdev));
 823         if (!common_flags || buswidth > 16 ||
 824             (buswidth > 8 && !(common_flags & SOCAM_DATAWIDTH_16)))
 825                 return -EINVAL;
 826
 827         return 0;
 828 }
 829
 830 static const struct soc_mbus_pixelfmt sh_mobile_ceu_formats[] = {
 831         {
 832                 .fourcc                 = V4L2_PIX_FMT_NV12,
 833                 .name                   = "NV12",
 834                 .bits_per_sample        = 12,
 835                 .packing                = SOC_MBUS_PACKING_NONE,
 836                 .order                  = SOC_MBUS_ORDER_LE,
 837         }, {
 838                 .fourcc                 = V4L2_PIX_FMT_NV21,
 839                 .name                   = "NV21",
 840                 .bits_per_sample        = 12,
 841                 .packing                = SOC_MBUS_PACKING_NONE,
 842                 .order                  = SOC_MBUS_ORDER_LE,
 843         }, {
 844                 .fourcc                 = V4L2_PIX_FMT_NV16,
 845                 .name                   = "NV16",
 846                 .bits_per_sample        = 16,
 847                 .packing                = SOC_MBUS_PACKING_NONE,
 848                 .order                  = SOC_MBUS_ORDER_LE,
 849         }, {
 850                 .fourcc                 = V4L2_PIX_FMT_NV61,
 851                 .name                   = "NV61",
 852                 .bits_per_sample        = 16,
 853                 .packing                = SOC_MBUS_PACKING_NONE,
 854                 .order                  = SOC_MBUS_ORDER_LE,
 855         },
 856 };
 857
 858 /* This will be corrected as we get more formats */
 859 static bool sh_mobile_ceu_packing_supported(const struct soc_mbus_pixelfmt *fmt)
 860 {
 861         return  fmt->packing == SOC_MBUS_PACKING_NONE ||
 862                 (fmt->bits_per_sample == 8 &&
 863                  fmt->packing == SOC_MBUS_PACKING_2X8_PADHI) ||
 864                 (fmt->bits_per_sample > 8 &&
 865                  fmt->packing == SOC_MBUS_PACKING_EXTEND16);
 866 }
 867
 868 static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, int idx,
 869                                      struct soc_camera_format_xlate *xlate)
 870 {
 871         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 872         struct device *dev = icd->dev.parent;
 873         int ret, k, n;
 874         int formats = 0;
 875         struct sh_mobile_ceu_cam *cam;
 876         enum v4l2_mbus_pixelcode code;
 877         const struct soc_mbus_pixelfmt *fmt;
 878
 879         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
 880         if (ret < 0)
 881                 /* No more formats */
 882                 return 0;
 883
 884         fmt = soc_mbus_get_fmtdesc(code);
 885         if (!fmt) {
 886                 dev_err(icd->dev.parent,
 887                         "Invalid format code #%d: %d\n", idx, code);
 888                 return -EINVAL;
 889         }
 890
 891         ret = sh_mobile_ceu_try_bus_param(icd, fmt->bits_per_sample);
 892         if (ret < 0)
 893                 return 0;
 894
 895         if (!icd->host_priv) {
 896                 cam = kzalloc(sizeof(*cam), GFP_KERNEL);
 897                 if (!cam)
 898                         return -ENOMEM;
 899
 900                 icd->host_priv = cam;
 901         } else {
 902                 cam = icd->host_priv;
 903         }
 904
 905         /* Beginning of a pass */
 906         if (!idx)
 907                 cam->extra_fmt = NULL;
 908
 909         switch (code) {
 910         case V4L2_MBUS_FMT_YUYV8_2X8_BE:
 911         case V4L2_MBUS_FMT_YVYU8_2X8_BE:
 912         case V4L2_MBUS_FMT_YUYV8_2X8_LE:
 913         case V4L2_MBUS_FMT_YVYU8_2X8_LE:
 914                 if (cam->extra_fmt)
 915                         break;
 916
 917                 /*
 918                  * Our case is simple so far: for any of the above four camera
 919                  * formats we add all our four synthesized NV* formats, so,
 920                  * just marking the device with a single flag suffices. If
 921                  * the format generation rules are more complex, you would have
 922                  * to actually hang your already added / counted formats onto
 923                  * the host_priv pointer and check whether the format you're
 924                  * going to add now is already there.
 925                  */
 926                 cam->extra_fmt = sh_mobile_ceu_formats;
 927
 928                 n = ARRAY_SIZE(sh_mobile_ceu_formats);
 929                 formats += n;
 930                 for (k = 0; xlate && k < n; k++) {
 931                         xlate->host_fmt = &sh_mobile_ceu_formats[k];
 932                         xlate->code     = code;
 933                         xlate++;
 934                         dev_dbg(dev, "Providing format %s using code %d\n",
 935                                 sh_mobile_ceu_formats[k].name, code);
 936                 }
 937                 break;
 938         default:
 939                 if (!sh_mobile_ceu_packing_supported(fmt))
 940                         return 0;
 941         }
 942
 943         /* Generic pass-through */
 944         formats++;
 945         if (xlate) {
 946                 xlate->host_fmt = fmt;
 947                 xlate->code     = code;
 948                 xlate++;
 949                 dev_dbg(dev, "Providing format %s in pass-through mode\n",
 950                         xlate->host_fmt->name);
 951         }
 952
 953         return formats;
 954 }
 955
 956 static void sh_mobile_ceu_put_formats(struct soc_camera_device *icd)
 957 {
 958         kfree(icd->host_priv);
 959         icd->host_priv = NULL;
 960 }
 961
 962 /* Check if any dimension of r1 is smaller than respective one of r2 */
 963 static bool is_smaller(struct v4l2_rect *r1, struct v4l2_rect *r2)
 964 {
 965         return r1->width < r2->width || r1->height < r2->height;
 966 }
 967
 968 /* Check if r1 fails to cover r2 */
 969 static bool is_inside(struct v4l2_rect *r1, struct v4l2_rect *r2)
 970 {
 971         return r1->left > r2->left || r1->top > r2->top ||
 972                 r1->left + r1->width < r2->left + r2->width ||
 973                 r1->top + r1->height < r2->top + r2->height;
 974 }
 975
 976 static unsigned int scale_down(unsigned int size, unsigned int scale)
 977 {
 978         return (size * 4096 + scale / 2) / scale;
 979 }
 980
 981 static unsigned int scale_up(unsigned int size, unsigned int scale)
 982 {
 983         return (size * scale + 2048) / 4096;
 984 }
 985
 986 static unsigned int calc_generic_scale(unsigned int input, unsigned int output)
 987 {
 988         return (input * 4096 + output / 2) / output;
 989 }
 990
 991 static int client_g_rect(struct v4l2_subdev *sd, struct v4l2_rect *rect)
 992 {
 993         struct v4l2_crop crop;
 994         struct v4l2_cropcap cap;
 995         int ret;
 996
 997         crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 998
 999         ret = v4l2_subdev_call(sd, video, g_crop, &crop);
1000         if (!ret) {
1001                 *rect = crop.c;
1002                 return ret;
1003         }
1004
1005         /* Camera driver doesn't support .g_crop(), assume default rectangle */
1006         cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1007
1008         ret = v4l2_subdev_call(sd, video, cropcap, &cap);
1009         if (ret < 0)
1010                 return ret;
1011
1012         *rect = cap.defrect;
1013
1014         return ret;
1015 }
1016
1017 /*
1018  * The common for both scaling and cropping iterative approach is:
1019  * 1. try if the client can produce exactly what requested by the user
1020  * 2. if (1) failed, try to double the client image until we get one big enough
1021  * 3. if (2) failed, try to request the maximum image
1022  */
1023 static int client_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *crop,
1024                          struct v4l2_crop *cam_crop)
1025 {
1026         struct v4l2_rect *rect = &crop->c, *cam_rect = &cam_crop->c;
1027         struct device *dev = sd->v4l2_dev->dev;
1028         struct v4l2_cropcap cap;
1029         int ret;
1030         unsigned int width, height;
1031
1032         v4l2_subdev_call(sd, video, s_crop, crop);
1033         ret = client_g_rect(sd, cam_rect);
1034         if (ret < 0)
1035                 return ret;
1036
1037         /*
1038          * Now cam_crop contains the current camera input rectangle, and it must
1039          * be within camera cropcap bounds
1040          */
1041         if (!memcmp(rect, cam_rect, sizeof(*rect))) {
1042                 /* Even if camera S_CROP failed, but camera rectangle matches */
1043                 dev_dbg(dev, "Camera S_CROP successful for %ux%u@%u:%u\n",
1044                         rect->width, rect->height, rect->left, rect->top);
1045                 return 0;
1046         }
1047
1048         /* Try to fix cropping, that camera hasn't managed to set */
1049         dev_geo(dev, "Fix camera S_CROP for %ux%u@%u:%u to %ux%u@%u:%u\n",
1050                 cam_rect->width, cam_rect->height,
1051                 cam_rect->left, cam_rect->top,
1052                 rect->width, rect->height, rect->left, rect->top);
1053
1054         /* We need sensor maximum rectangle */
1055         ret = v4l2_subdev_call(sd, video, cropcap, &cap);
1056         if (ret < 0)
1057                 return ret;
1058
1059         soc_camera_limit_side(&rect->left, &rect->width, cap.bounds.left, 2,
1060                               cap.bounds.width);
1061         soc_camera_limit_side(&rect->top, &rect->height, cap.bounds.top, 4,
1062                               cap.bounds.height);
1063
1064         /*
1065          * Popular special case - some cameras can only handle fixed sizes like
1066          * QVGA, VGA,... Take care to avoid infinite loop.
1067          */
1068         width = max(cam_rect->width, 2);
1069         height = max(cam_rect->height, 2);
1070
1071         while (!ret && (is_smaller(cam_rect, rect) ||
1072                         is_inside(cam_rect, rect)) &&
1073                (cap.bounds.width > width || cap.bounds.height > height)) {
1074
1075                 width *= 2;
1076                 height *= 2;
1077
1078                 cam_rect->width = width;
1079                 cam_rect->height = height;
1080
1081                 /*
1082                  * We do not know what capabilities the camera has to set up
1083                  * left and top borders. We could try to be smarter in iterating
1084                  * them, e.g., if camera current left is to the right of the
1085                  * target left, set it to the middle point between the current
1086                  * left and minimum left. But that would add too much
1087                  * complexity: we would have to iterate each border separately.
1088                  */
1089                 if (cam_rect->left > rect->left)
1090                         cam_rect->left = cap.bounds.left;
1091
1092                 if (cam_rect->left + cam_rect->width < rect->left + rect->width)
1093                         cam_rect->width = rect->left + rect->width -
1094                                 cam_rect->left;
1095
1096                 if (cam_rect->top > rect->top)
1097                         cam_rect->top = cap.bounds.top;
1098
1099                 if (cam_rect->top + cam_rect->height < rect->top + rect->height)
1100                         cam_rect->height = rect->top + rect->height -
1101                                 cam_rect->top;
1102
1103                 v4l2_subdev_call(sd, video, s_crop, cam_crop);
1104                 ret = client_g_rect(sd, cam_rect);
1105                 dev_geo(dev, "Camera S_CROP %d for %ux%u@%u:%u\n", ret,
1106                         cam_rect->width, cam_rect->height,
1107                         cam_rect->left, cam_rect->top);
1108         }
1109
1110         /* S_CROP must not modify the rectangle */
1111         if (is_smaller(cam_rect, rect) || is_inside(cam_rect, rect)) {
1112                 /*
1113                  * The camera failed to configure a suitable cropping,
1114                  * we cannot use the current rectangle, set to max
1115                  */
1116                 *cam_rect = cap.bounds;
1117                 v4l2_subdev_call(sd, video, s_crop, cam_crop);
1118                 ret = client_g_rect(sd, cam_rect);
1119                 dev_geo(dev, "Camera S_CROP %d for max %ux%u@%u:%u\n", ret,
1120                         cam_rect->width, cam_rect->height,
1121                         cam_rect->left, cam_rect->top);
1122         }
1123
1124         return ret;
1125 }
1126
1127 static int get_camera_scales(struct v4l2_subdev *sd, struct v4l2_rect *rect,
1128                              unsigned int *scale_h, unsigned int *scale_v)
1129 {
1130         struct v4l2_mbus_framefmt mf;
1131         int ret;
1132
1133         ret = v4l2_subdev_call(sd, video, g_mbus_fmt, &mf);
1134         if (ret < 0)
1135                 return ret;
1136
1137         *scale_h = calc_generic_scale(rect->width, mf.width);
1138         *scale_v = calc_generic_scale(rect->height, mf.height);
1139
1140         return 0;
1141 }
1142
1143 static int get_camera_subwin(struct soc_camera_device *icd,
1144                              struct v4l2_rect *cam_subrect,
1145                              unsigned int cam_hscale, unsigned int cam_vscale)
1146 {
1147         struct sh_mobile_ceu_cam *cam = icd->host_priv;
1148         struct v4l2_rect *ceu_rect = &cam->ceu_rect;
1149
1150         if (!ceu_rect->width) {
1151                 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1152                 struct device *dev = icd->dev.parent;
1153                 struct v4l2_mbus_framefmt mf;
1154                 int ret;
1155                 /* First time */
1156
1157                 ret = v4l2_subdev_call(sd, video, g_mbus_fmt, &mf);
1158                 if (ret < 0)
1159                         return ret;
1160
1161                 dev_geo(dev, "camera fmt %ux%u\n", mf.width, mf.height);
1162
1163                 if (mf.width > 2560) {
1164                         ceu_rect->width  = 2560;
1165                         ceu_rect->left   = (mf.width - 2560) / 2;
1166                 } else {
1167                         ceu_rect->width  = mf.width;
1168                         ceu_rect->left   = 0;
1169                 }
1170
1171                 if (mf.height > 1920) {
1172                         ceu_rect->height = 1920;
1173                         ceu_rect->top    = (mf.height - 1920) / 2;
1174                 } else {
1175                         ceu_rect->height = mf.height;
1176                         ceu_rect->top    = 0;
1177                 }
1178
1179                 dev_geo(dev, "initialised CEU rect %ux%u@%u:%u\n",
1180                         ceu_rect->width, ceu_rect->height,
1181                         ceu_rect->left, ceu_rect->top);
1182         }
1183
1184         cam_subrect->width      = scale_up(ceu_rect->width, cam_hscale);
1185         cam_subrect->left       = scale_up(ceu_rect->left, cam_hscale);
1186         cam_subrect->height     = scale_up(ceu_rect->height, cam_vscale);
1187         cam_subrect->top        = scale_up(ceu_rect->top, cam_vscale);
1188
1189         return 0;
1190 }
1191
1192 static int client_s_fmt(struct soc_camera_device *icd,
1193                         struct v4l2_mbus_framefmt *mf, bool ceu_can_scale)
1194 {
1195         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1196         struct device *dev = icd->dev.parent;
1197         unsigned int width = mf->width, height = mf->height, tmp_w, tmp_h;
1198         unsigned int max_width, max_height;
1199         struct v4l2_cropcap cap;
1200         int ret;
1201
1202         cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1203
1204         ret = v4l2_subdev_call(sd, video, cropcap, &cap);
1205         if (ret < 0)
1206                 return ret;
1207
1208         max_width = min(cap.bounds.width, 2560);
1209         max_height = min(cap.bounds.height, 1920);
1210
1211         ret = v4l2_subdev_call(sd, video, s_mbus_fmt, mf);
1212         if (ret < 0)
1213                 return ret;
1214
1215         dev_geo(dev, "camera scaled to %ux%u\n", mf->width, mf->height);
1216
1217         if ((width == mf->width && height == mf->height) || !ceu_can_scale)
1218                 return 0;
1219
1220         /* Camera set a format, but geometry is not precise, try to improve */
1221         tmp_w = mf->width;
1222         tmp_h = mf->height;
1223
1224         /* width <= max_width && height <= max_height - guaranteed by try_fmt */
1225         while ((width > tmp_w || height > tmp_h) &&
1226                tmp_w < max_width && tmp_h < max_height) {
1227                 tmp_w = min(2 * tmp_w, max_width);
1228                 tmp_h = min(2 * tmp_h, max_height);
1229                 mf->width = tmp_w;
1230                 mf->height = tmp_h;
1231                 ret = v4l2_subdev_call(sd, video, s_mbus_fmt, mf);
1232                 dev_geo(dev, "Camera scaled to %ux%u\n",
1233                         mf->width, mf->height);
1234                 if (ret < 0) {
1235                         /* This shouldn't happen */
1236                         dev_err(dev, "Client failed to set format: %d\n", ret);
1237                         return ret;
1238                 }
1239         }
1240
1241         return 0;
1242 }
1243
1244 /**
1245  * @rect        - camera cropped rectangle
1246  * @sub_rect    - CEU cropped rectangle, mapped back to camera input area
1247  * @ceu_rect    - on output calculated CEU crop rectangle
1248  */
1249 static int client_scale(struct soc_camera_device *icd, struct v4l2_rect *rect,
1250                         struct v4l2_rect *sub_rect, struct v4l2_rect *ceu_rect,
1251                         struct v4l2_mbus_framefmt *mf, bool ceu_can_scale)
1252 {
1253         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1254         struct sh_mobile_ceu_cam *cam = icd->host_priv;
1255         struct device *dev = icd->dev.parent;
1256         struct v4l2_mbus_framefmt mf_tmp = *mf;
1257         unsigned int scale_h, scale_v;
1258         int ret;
1259
1260         /* 5. Apply iterative camera S_FMT for camera user window. */
1261         ret = client_s_fmt(icd, &mf_tmp, ceu_can_scale);
1262         if (ret < 0)
1263                 return ret;
1264
1265         dev_geo(dev, "5: camera scaled to %ux%u\n",
1266                 mf_tmp.width, mf_tmp.height);
1267
1268         /* 6. Retrieve camera output window (g_fmt) */
1269
1270         /* unneeded - it is already in "mf_tmp" */
1271
1272         /* 7. Calculate new camera scales. */
1273         ret = get_camera_scales(sd, rect, &scale_h, &scale_v);
1274         if (ret < 0)
1275                 return ret;
1276
1277         dev_geo(dev, "7: camera scales %u:%u\n", scale_h, scale_v);
1278
1279         cam->cam_width  = mf_tmp.width;
1280         cam->cam_height = mf_tmp.height;
1281         mf->width       = mf_tmp.width;
1282         mf->height      = mf_tmp.height;
1283         mf->colorspace  = mf_tmp.colorspace;
1284
1285         /*
1286          * 8. Calculate new CEU crop - apply camera scales to previously
1287          *    calculated "effective" crop.
1288          */
1289         ceu_rect->left = scale_down(sub_rect->left, scale_h);
1290         ceu_rect->width = scale_down(sub_rect->width, scale_h);
1291         ceu_rect->top = scale_down(sub_rect->top, scale_v);
1292         ceu_rect->height = scale_down(sub_rect->height, scale_v);
1293
1294         dev_geo(dev, "8: new CEU rect %ux%u@%u:%u\n",
1295                 ceu_rect->width, ceu_rect->height,
1296                 ceu_rect->left, ceu_rect->top);
1297
1298         return 0;
1299 }
1300
1301 /* Get combined scales */
1302 static int get_scales(struct soc_camera_device *icd,
1303                       unsigned int *scale_h, unsigned int *scale_v)
1304 {
1305         struct sh_mobile_ceu_cam *cam = icd->host_priv;
1306         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1307         struct v4l2_crop cam_crop;
1308         unsigned int width_in, height_in;
1309         int ret;
1310
1311         cam_crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1312
1313         ret = client_g_rect(sd, &cam_crop.c);
1314         if (ret < 0)
1315                 return ret;
1316
1317         ret = get_camera_scales(sd, &cam_crop.c, scale_h, scale_v);
1318         if (ret < 0)
1319                 return ret;
1320
1321         width_in = scale_up(cam->ceu_rect.width, *scale_h);
1322         height_in = scale_up(cam->ceu_rect.height, *scale_v);
1323
1324         *scale_h = calc_generic_scale(width_in, icd->user_width);
1325         *scale_v = calc_generic_scale(height_in, icd->user_height);
1326
1327         return 0;
1328 }
1329
1330 /*
1331  * CEU can scale and crop, but we don't want to waste bandwidth and kill the
1332  * framerate by always requesting the maximum image from the client. See
1333  * Documentation/video4linux/sh_mobile_camera_ceu.txt for a description of
1334  * scaling and cropping algorithms and for the meaning of referenced here steps.
1335  */
1336 static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
1337                                   struct v4l2_crop *a)
1338 {
1339         struct v4l2_rect *rect = &a->c;
1340         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1341         struct sh_mobile_ceu_dev *pcdev = ici->priv;
1342         struct v4l2_crop cam_crop;
1343         struct sh_mobile_ceu_cam *cam = icd->host_priv;
1344         struct v4l2_rect *cam_rect = &cam_crop.c, *ceu_rect = &cam->ceu_rect;
1345         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1346         struct device *dev = icd->dev.parent;
1347         struct v4l2_mbus_framefmt mf;
1348         unsigned int scale_comb_h, scale_comb_v, scale_ceu_h, scale_ceu_v,
1349                 out_width, out_height;
1350         u32 capsr, cflcr;
1351         int ret;
1352
1353         /* 1. Calculate current combined scales. */
1354         ret = get_scales(icd, &scale_comb_h, &scale_comb_v);
1355         if (ret < 0)
1356                 return ret;
1357
1358         dev_geo(dev, "1: combined scales %u:%u\n", scale_comb_h, scale_comb_v);
1359
1360         /* 2. Apply iterative camera S_CROP for new input window. */
1361         ret = client_s_crop(sd, a, &cam_crop);
1362         if (ret < 0)
1363                 return ret;
1364
1365         dev_geo(dev, "2: camera cropped to %ux%u@%u:%u\n",
1366                 cam_rect->width, cam_rect->height,
1367                 cam_rect->left, cam_rect->top);
1368
1369         /* On success cam_crop contains current camera crop */
1370
1371         /*
1372          * 3. If old combined scales applied to new crop produce an impossible
1373          *    user window, adjust scales to produce nearest possible window.
1374          */
1375         out_width       = scale_down(rect->width, scale_comb_h);
1376         out_height      = scale_down(rect->height, scale_comb_v);
1377
1378         if (out_width > 2560)
1379                 out_width = 2560;
1380         else if (out_width < 2)
1381                 out_width = 2;
1382
1383         if (out_height > 1920)
1384                 out_height = 1920;
1385         else if (out_height < 4)
1386                 out_height = 4;
1387
1388         dev_geo(dev, "3: Adjusted output %ux%u\n", out_width, out_height);
1389
1390         /* 4. Use G_CROP to retrieve actual input window: already in cam_crop */
1391
1392         /*
1393          * 5. Using actual input window and calculated combined scales calculate
1394          *    camera target output window.
1395          */
1396         mf.width        = scale_down(cam_rect->width, scale_comb_h);
1397         mf.height       = scale_down(cam_rect->height, scale_comb_v);
1398
1399         dev_geo(dev, "5: camera target %ux%u\n", mf.width, mf.height);
1400
1401         /* 6. - 9. */
1402         mf.code         = cam->code;
1403         mf.field        = pcdev->field;
1404
1405         capsr = capture_save_reset(pcdev);
1406         dev_dbg(dev, "CAPSR 0x%x, CFLCR 0x%x\n", capsr, pcdev->cflcr);
1407
1408         /* Make relative to camera rectangle */
1409         rect->left      -= cam_rect->left;
1410         rect->top       -= cam_rect->top;
1411
1412         ret = client_scale(icd, cam_rect, rect, ceu_rect, &mf,
1413                            pcdev->image_mode &&
1414                            V4L2_FIELD_NONE == pcdev->field);
1415
1416         dev_geo(dev, "6-9: %d\n", ret);
1417
1418         /* 10. Use CEU cropping to crop to the new window. */
1419         sh_mobile_ceu_set_rect(icd, out_width, out_height);
1420
1421         dev_geo(dev, "10: CEU cropped to %ux%u@%u:%u\n",
1422                 ceu_rect->width, ceu_rect->height,
1423                 ceu_rect->left, ceu_rect->top);
1424
1425         /*
1426          * 11. Calculate CEU scales from camera scales from results of (10) and
1427          *     user window from (3)
1428          */
1429         scale_ceu_h = calc_scale(ceu_rect->width, &out_width);
1430         scale_ceu_v = calc_scale(ceu_rect->height, &out_height);
1431
1432         dev_geo(dev, "11: CEU scales %u:%u\n", scale_ceu_h, scale_ceu_v);
1433
1434         /* 12. Apply CEU scales. */
1435         cflcr = scale_ceu_h | (scale_ceu_v << 16);
1436         if (cflcr != pcdev->cflcr) {
1437                 pcdev->cflcr = cflcr;
1438                 ceu_write(pcdev, CFLCR, cflcr);
1439         }
1440
1441         /* Restore capture */
1442         if (pcdev->active)
1443                 capsr |= 1;
1444         capture_restore(pcdev, capsr);
1445
1446         icd->user_width = out_width;
1447         icd->user_height = out_height;
1448
1449         /* Even if only camera cropping succeeded */
1450         return ret;
1451 }
1452
1453 /* Similar to set_crop multistage iterative algorithm */
1454 static int sh_mobile_ceu_set_fmt(struct soc_camera_device *icd,
1455                                  struct v4l2_format *f)
1456 {
1457         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1458         struct sh_mobile_ceu_dev *pcdev = ici->priv;
1459         struct sh_mobile_ceu_cam *cam = icd->host_priv;
1460         struct v4l2_pix_format *pix = &f->fmt.pix;
1461         struct v4l2_mbus_framefmt mf;
1462         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1463         struct device *dev = icd->dev.parent;
1464         __u32 pixfmt = pix->pixelformat;
1465         const struct soc_camera_format_xlate *xlate;
1466         struct v4l2_crop cam_crop;
1467         struct v4l2_rect *cam_rect = &cam_crop.c, cam_subrect, ceu_rect;
1468         unsigned int scale_cam_h, scale_cam_v;
1469         u16 scale_v, scale_h;
1470         int ret;
1471         bool image_mode;
1472         enum v4l2_field field;
1473
1474         switch (pix->field) {
1475         default:
1476                 pix->field = V4L2_FIELD_NONE;
1477                 /* fall-through */
1478         case V4L2_FIELD_INTERLACED_TB:
1479         case V4L2_FIELD_INTERLACED_BT:
1480         case V4L2_FIELD_NONE:
1481                 field = pix->field;
1482                 break;
1483         case V4L2_FIELD_INTERLACED:
1484                 field = V4L2_FIELD_INTERLACED_TB;
1485                 break;
1486         }
1487
1488         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1489         if (!xlate) {
1490                 dev_warn(dev, "Format %x not found\n", pixfmt);
1491                 return -EINVAL;
1492         }
1493
1494         /* 1. Calculate current camera scales. */
1495         cam_crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1496
1497         ret = client_g_rect(sd, cam_rect);
1498         if (ret < 0)
1499                 return ret;
1500
1501         ret = get_camera_scales(sd, cam_rect, &scale_cam_h, &scale_cam_v);
1502         if (ret < 0)
1503                 return ret;
1504
1505         dev_geo(dev, "1: camera scales %u:%u\n", scale_cam_h, scale_cam_v);
1506
1507         /*
1508          * 2. Calculate "effective" input crop (sensor subwindow) - CEU crop
1509          *    scaled back at current camera scales onto input window.
1510          */
1511         ret = get_camera_subwin(icd, &cam_subrect, scale_cam_h, scale_cam_v);
1512         if (ret < 0)
1513                 return ret;
1514
1515         dev_geo(dev, "2: subwin %ux%u@%u:%u\n",
1516                 cam_subrect.width, cam_subrect.height,
1517                 cam_subrect.left, cam_subrect.top);
1518
1519         /*
1520          * 3. Calculate new combined scales from "effective" input window to
1521          *    requested user window.
1522          */
1523         scale_h = calc_generic_scale(cam_subrect.width, pix->width);
1524         scale_v = calc_generic_scale(cam_subrect.height, pix->height);
1525
1526         dev_geo(dev, "3: scales %u:%u\n", scale_h, scale_v);
1527
1528         /*
1529          * 4. Calculate camera output window by applying combined scales to real
1530          *    input window.
1531          */
1532         mf.width        = scale_down(cam_rect->width, scale_h);
1533         mf.height       = scale_down(cam_rect->height, scale_v);
1534         mf.field        = pix->field;
1535         mf.colorspace   = pix->colorspace;
1536         mf.code         = xlate->code;
1537
1538         switch (pixfmt) {
1539         case V4L2_PIX_FMT_NV12:
1540         case V4L2_PIX_FMT_NV21:
1541         case V4L2_PIX_FMT_NV16:
1542         case V4L2_PIX_FMT_NV61:
1543                 image_mode = true;
1544                 break;
1545         default:
1546                 image_mode = false;
1547         }
1548
1549         dev_geo(dev, "4: camera output %ux%u\n", mf.width, mf.height);
1550
1551         /* 5. - 9. */
1552         ret = client_scale(icd, cam_rect, &cam_subrect, &ceu_rect, &mf,
1553                            image_mode && V4L2_FIELD_NONE == field);
1554
1555         dev_geo(dev, "5-9: client scale %d\n", ret);
1556
1557         /* Done with the camera. Now see if we can improve the result */
1558
1559         dev_dbg(dev, "Camera %d fmt %ux%u, requested %ux%u\n",
1560                 ret, mf.width, mf.height, pix->width, pix->height);
1561         if (ret < 0)
1562                 return ret;
1563
1564         if (mf.code != xlate->code)
1565                 return -EINVAL;
1566
1567         /* 10. Use CEU scaling to scale to the requested user window. */
1568
1569         /* We cannot scale up */
1570         if (pix->width > mf.width)
1571                 pix->width = mf.width;
1572         if (pix->width > ceu_rect.width)
1573                 pix->width = ceu_rect.width;
1574
1575         if (pix->height > mf.height)
1576                 pix->height = mf.height;
1577         if (pix->height > ceu_rect.height)
1578                 pix->height = ceu_rect.height;
1579
1580         pix->colorspace = mf.colorspace;
1581
1582         if (image_mode) {
1583                 /* Scale pix->{width x height} down to width x height */
1584                 scale_h = calc_scale(ceu_rect.width, &pix->width);
1585                 scale_v = calc_scale(ceu_rect.height, &pix->height);
1586
1587                 pcdev->cflcr = scale_h | (scale_v << 16);
1588         } else {
1589                 pix->width = ceu_rect.width;
1590                 pix->height = ceu_rect.height;
1591                 scale_h = scale_v = 0;
1592                 pcdev->cflcr = 0;
1593         }
1594
1595         dev_geo(dev, "10: W: %u : 0x%x = %u, H: %u : 0x%x = %u\n",
1596                 ceu_rect.width, scale_h, pix->width,
1597                 ceu_rect.height, scale_v, pix->height);
1598
1599         cam->code               = xlate->code;
1600         cam->ceu_rect           = ceu_rect;
1601         icd->current_fmt        = xlate;
1602
1603         pcdev->field = field;
1604         pcdev->image_mode = image_mode;
1605
1606         return 0;
1607 }
1608
1609 static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
1610                                  struct v4l2_format *f)
1611 {
1612         const struct soc_camera_format_xlate *xlate;
1613         struct v4l2_pix_format *pix = &f->fmt.pix;
1614         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1615         struct v4l2_mbus_framefmt mf;
1616         __u32 pixfmt = pix->pixelformat;
1617         int width, height;
1618         int ret;
1619
1620         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1621         if (!xlate) {
1622                 dev_warn(icd->dev.parent, "Format %x not found\n", pixfmt);
1623                 return -EINVAL;
1624         }
1625
1626         /* FIXME: calculate using depth and bus width */
1627
1628         v4l_bound_align_image(&pix->width, 2, 2560, 1,
1629                               &pix->height, 4, 1920, 2, 0);
1630
1631         width = pix->width;
1632         height = pix->height;
1633
1634         pix->bytesperline = soc_mbus_bytes_per_line(width, xlate->host_fmt);
1635         if (pix->bytesperline < 0)
1636                 return pix->bytesperline;
1637         pix->sizeimage = height * pix->bytesperline;
1638
1639         /* limit to sensor capabilities */
1640         mf.width        = pix->width;
1641         mf.height       = pix->height;
1642         mf.field        = pix->field;
1643         mf.code         = xlate->code;
1644         mf.colorspace   = pix->colorspace;
1645
1646         ret = v4l2_subdev_call(sd, video, try_mbus_fmt, &mf);
1647         if (ret < 0)
1648                 return ret;
1649
1650         pix->width      = mf.width;
1651         pix->height     = mf.height;
1652         pix->field      = mf.field;
1653         pix->colorspace = mf.colorspace;
1654
1655         switch (pixfmt) {
1656         case V4L2_PIX_FMT_NV12:
1657         case V4L2_PIX_FMT_NV21:
1658         case V4L2_PIX_FMT_NV16:
1659         case V4L2_PIX_FMT_NV61:
1660                 /* FIXME: check against rect_max after converting soc-camera */
1661                 /* We can scale precisely, need a bigger image from camera */
1662                 if (pix->width < width || pix->height < height) {
1663                         /*
1664                          * We presume, the sensor behaves sanely, i.e., if
1665                          * requested a bigger rectangle, it will not return a
1666                          * smaller one.
1667                          */
1668                         mf.width = 2560;
1669                         mf.height = 1920;
1670                         ret = v4l2_subdev_call(sd, video, try_mbus_fmt, &mf);
1671                         if (ret < 0) {
1672                                 /* Shouldn't actually happen... */
1673                                 dev_err(icd->dev.parent,
1674                                         "FIXME: client try_fmt() = %d\n", ret);
1675                                 return ret;
1676                         }
1677                 }
1678                 /* We will scale exactly */
1679                 if (mf.width > width)
1680                         pix->width = width;
1681                 if (mf.height > height)
1682                         pix->height = height;
1683         }
1684
1685         return ret;
1686 }
1687
1688 static int sh_mobile_ceu_reqbufs(struct soc_camera_file *icf,
1689                                  struct v4l2_requestbuffers *p)
1690 {
1691         int i;
1692
1693         /*
1694          * This is for locking debugging only. I removed spinlocks and now I
1695          * check whether .prepare is ever called on a linked buffer, or whether
1696          * a dma IRQ can occur for an in-work or unlinked buffer. Until now
1697          * it hadn't triggered
1698          */
1699         for (i = 0; i < p->count; i++) {
1700                 struct sh_mobile_ceu_buffer *buf;
1701
1702                 buf = container_of(icf->vb_vidq.bufs[i],
1703                                    struct sh_mobile_ceu_buffer, vb);
1704                 INIT_LIST_HEAD(&buf->vb.queue);
1705         }
1706
1707         return 0;
1708 }
1709
1710 static unsigned int sh_mobile_ceu_poll(struct file *file, poll_table *pt)
1711 {
1712         struct soc_camera_file *icf = file->private_data;
1713         struct sh_mobile_ceu_buffer *buf;
1714
1715         buf = list_entry(icf->vb_vidq.stream.next,
1716                          struct sh_mobile_ceu_buffer, vb.stream);
1717
1718         poll_wait(file, &buf->vb.done, pt);
1719
1720         if (buf->vb.state == VIDEOBUF_DONE ||
1721             buf->vb.state == VIDEOBUF_ERROR)
1722                 return POLLIN|POLLRDNORM;
1723
1724         return 0;
1725 }
1726
1727 static int sh_mobile_ceu_querycap(struct soc_camera_host *ici,
1728                                   struct v4l2_capability *cap)
1729 {
1730         strlcpy(cap->card, "SuperH_Mobile_CEU", sizeof(cap->card));
1731         cap->version = KERNEL_VERSION(0, 0, 5);
1732         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1733         return 0;
1734 }
1735
1736 static void sh_mobile_ceu_init_videobuf(struct videobuf_queue *q,
1737                                         struct soc_camera_device *icd)
1738 {
1739         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1740         struct sh_mobile_ceu_dev *pcdev = ici->priv;
1741
1742         videobuf_queue_dma_contig_init(q,
1743                                        &sh_mobile_ceu_videobuf_ops,
1744                                        icd->dev.parent, &pcdev->lock,
1745                                        V4L2_BUF_TYPE_VIDEO_CAPTURE,
1746                                        pcdev->field,
1747                                        sizeof(struct sh_mobile_ceu_buffer),
1748                                        icd);
1749 }
1750
1751 static int sh_mobile_ceu_get_ctrl(struct soc_camera_device *icd,
1752                                   struct v4l2_control *ctrl)
1753 {
1754         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1755         struct sh_mobile_ceu_dev *pcdev = ici->priv;
1756         u32 val;
1757
1758         switch (ctrl->id) {
1759         case V4L2_CID_SHARPNESS:
1760                 val = ceu_read(pcdev, CLFCR);
1761                 ctrl->value = val ^ 1;
1762                 return 0;
1763         }
1764         return -ENOIOCTLCMD;
1765 }
1766
1767 static int sh_mobile_ceu_set_ctrl(struct soc_camera_device *icd,
1768                                   struct v4l2_control *ctrl)
1769 {
1770         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1771         struct sh_mobile_ceu_dev *pcdev = ici->priv;
1772
1773         switch (ctrl->id) {
1774         case V4L2_CID_SHARPNESS:
1775                 switch (icd->current_fmt->host_fmt->fourcc) {
1776                 case V4L2_PIX_FMT_NV12:
1777                 case V4L2_PIX_FMT_NV21:
1778                 case V4L2_PIX_FMT_NV16:
1779                 case V4L2_PIX_FMT_NV61:
1780                         ceu_write(pcdev, CLFCR, !ctrl->value);
1781                         return 0;
1782                 }
1783                 return -EINVAL;
1784         }
1785         return -ENOIOCTLCMD;
1786 }
1787
1788 static const struct v4l2_queryctrl sh_mobile_ceu_controls[] = {
1789         {
1790                 .id             = V4L2_CID_SHARPNESS,
1791                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
1792                 .name           = "Low-pass filter",
1793                 .minimum        = 0,
1794                 .maximum        = 1,
1795                 .step           = 1,
1796                 .default_value  = 0,
1797         },
1798 };
1799
1800 static struct soc_camera_host_ops sh_mobile_ceu_host_ops = {
1801         .owner          = THIS_MODULE,
1802         .add            = sh_mobile_ceu_add_device,
1803         .remove         = sh_mobile_ceu_remove_device,
1804         .get_formats    = sh_mobile_ceu_get_formats,
1805         .put_formats    = sh_mobile_ceu_put_formats,
1806         .set_crop       = sh_mobile_ceu_set_crop,
1807         .set_fmt        = sh_mobile_ceu_set_fmt,
1808         .try_fmt        = sh_mobile_ceu_try_fmt,
1809         .set_ctrl       = sh_mobile_ceu_set_ctrl,
1810         .get_ctrl       = sh_mobile_ceu_get_ctrl,
1811         .reqbufs        = sh_mobile_ceu_reqbufs,
1812         .poll           = sh_mobile_ceu_poll,
1813         .querycap       = sh_mobile_ceu_querycap,
1814         .set_bus_param  = sh_mobile_ceu_set_bus_param,
1815         .init_videobuf  = sh_mobile_ceu_init_videobuf,
1816         .controls       = sh_mobile_ceu_controls,
1817         .num_controls   = ARRAY_SIZE(sh_mobile_ceu_controls),
1818 };
1819
1820 static int __devinit sh_mobile_ceu_probe(struct platform_device *pdev)
1821 {
1822         struct sh_mobile_ceu_dev *pcdev;
1823         struct resource *res;
1824         void __iomem *base;
1825         unsigned int irq;
1826         int err = 0;
1827
1828         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1829         irq = platform_get_irq(pdev, 0);
1830         if (!res || (int)irq <= 0) {
1831                 dev_err(&pdev->dev, "Not enough CEU platform resources.\n");
1832                 err = -ENODEV;
1833                 goto exit;
1834         }
1835
1836         pcdev = kzalloc(sizeof(*pcdev), GFP_KERNEL);
1837         if (!pcdev) {
1838                 dev_err(&pdev->dev, "Could not allocate pcdev\n");
1839                 err = -ENOMEM;
1840                 goto exit;
1841         }
1842
1843         INIT_LIST_HEAD(&pcdev->capture);
1844         spin_lock_init(&pcdev->lock);
1845
1846         pcdev->pdata = pdev->dev.platform_data;
1847         if (!pcdev->pdata) {
1848                 err = -EINVAL;
1849                 dev_err(&pdev->dev, "CEU platform data not set.\n");
1850                 goto exit_kfree;
1851         }
1852
1853         base = ioremap_nocache(res->start, resource_size(res));
1854         if (!base) {
1855                 err = -ENXIO;
1856                 dev_err(&pdev->dev, "Unable to ioremap CEU registers.\n");
1857                 goto exit_kfree;
1858         }
1859
1860         pcdev->irq = irq;
1861         pcdev->base = base;
1862         pcdev->video_limit = 0; /* only enabled if second resource exists */
1863
1864         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1865         if (res) {
1866                 err = dma_declare_coherent_memory(&pdev->dev, res->start,
1867                                                   res->start,
1868                                                   resource_size(res),
1869                                                   DMA_MEMORY_MAP |
1870                                                   DMA_MEMORY_EXCLUSIVE);
1871                 if (!err) {
1872                         dev_err(&pdev->dev, "Unable to declare CEU memory.\n");
1873                         err = -ENXIO;
1874                         goto exit_iounmap;
1875                 }
1876
1877                 pcdev->video_limit = resource_size(res);
1878         }
1879
1880         /* request irq */
1881         err = request_irq(pcdev->irq, sh_mobile_ceu_irq, IRQF_DISABLED,
1882                           dev_name(&pdev->dev), pcdev);
1883         if (err) {
1884                 dev_err(&pdev->dev, "Unable to register CEU interrupt.\n");
1885                 goto exit_release_mem;
1886         }
1887
1888         pm_suspend_ignore_children(&pdev->dev, true);
1889         pm_runtime_enable(&pdev->dev);
1890         pm_runtime_resume(&pdev->dev);
1891
1892         pcdev->ici.priv = pcdev;
1893         pcdev->ici.v4l2_dev.dev = &pdev->dev;
1894         pcdev->ici.nr = pdev->id;
1895         pcdev->ici.drv_name = dev_name(&pdev->dev);
1896         pcdev->ici.ops = &sh_mobile_ceu_host_ops;
1897
1898         err = soc_camera_host_register(&pcdev->ici);
1899         if (err)
1900                 goto exit_free_clk;
1901
1902         return 0;
1903
1904 exit_free_clk:
1905         pm_runtime_disable(&pdev->dev);
1906         free_irq(pcdev->irq, pcdev);
1907 exit_release_mem:
1908         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
1909                 dma_release_declared_memory(&pdev->dev);
1910 exit_iounmap:
1911         iounmap(base);
1912 exit_kfree:
1913         kfree(pcdev);
1914 exit:
1915         return err;
1916 }
1917
1918 static int __devexit sh_mobile_ceu_remove(struct platform_device *pdev)
1919 {
1920         struct soc_camera_host *soc_host = to_soc_camera_host(&pdev->dev);
1921         struct sh_mobile_ceu_dev *pcdev = container_of(soc_host,
1922                                         struct sh_mobile_ceu_dev, ici);
1923
1924         soc_camera_host_unregister(soc_host);
1925         pm_runtime_disable(&pdev->dev);
1926         free_irq(pcdev->irq, pcdev);
1927         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
1928                 dma_release_declared_memory(&pdev->dev);
1929         iounmap(pcdev->base);
1930         kfree(pcdev);
1931         return 0;
1932 }
1933
1934 static int sh_mobile_ceu_runtime_nop(struct device *dev)
1935 {
1936         /* Runtime PM callback shared between ->runtime_suspend()
1937          * and ->runtime_resume(). Simply returns success.
1938          *
1939          * This driver re-initializes all registers after
1940          * pm_runtime_get_sync() anyway so there is no need
1941          * to save and restore registers here.
1942          */
1943         return 0;
1944 }
1945
1946 static const struct dev_pm_ops sh_mobile_ceu_dev_pm_ops = {
1947         .runtime_suspend = sh_mobile_ceu_runtime_nop,
1948         .runtime_resume = sh_mobile_ceu_runtime_nop,
1949 };
1950
1951 static struct platform_driver sh_mobile_ceu_driver = {
1952         .driver         = {
1953                 .name   = "sh_mobile_ceu",
1954                 .pm     = &sh_mobile_ceu_dev_pm_ops,
1955         },
1956         .probe          = sh_mobile_ceu_probe,
1957         .remove         = __devexit_p(sh_mobile_ceu_remove),
1958 };
1959
1960 static int __init sh_mobile_ceu_init(void)
1961 {
1962         return platform_driver_register(&sh_mobile_ceu_driver);
1963 }
1964
1965 static void __exit sh_mobile_ceu_exit(void)
1966 {
1967         platform_driver_unregister(&sh_mobile_ceu_driver);
1968 }
1969
1970 module_init(sh_mobile_ceu_init);
1971 module_exit(sh_mobile_ceu_exit);
1972
1973 MODULE_DESCRIPTION("SuperH Mobile CEU driver");
1974 MODULE_AUTHOR("Magnus Damm");
1975 MODULE_LICENSE("GPL");
1976 MODULE_ALIAS("platform:sh_mobile_ceu");