[media] s5p-fimc: Fix 90/270 deg rotation errors
[linux-2.6.git] / drivers / media / video / s5p-fimc / fimc-core.c
1 /*
2  * S5P camera interface (video postprocessor) driver
3  *
4  * Copyright (c) 2010 Samsung Electronics
5  *
6  * Sylwester Nawrocki, <s.nawrocki@samsung.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published
10  * by the Free Software Foundation, either version 2 of the License,
11  * or (at your option) any later version.
12  */
13
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/version.h>
17 #include <linux/types.h>
18 #include <linux/errno.h>
19 #include <linux/bug.h>
20 #include <linux/interrupt.h>
21 #include <linux/device.h>
22 #include <linux/platform_device.h>
23 #include <linux/list.h>
24 #include <linux/io.h>
25 #include <linux/slab.h>
26 #include <linux/clk.h>
27 #include <media/v4l2-ioctl.h>
28 #include <media/videobuf-dma-contig.h>
29
30 #include "fimc-core.h"
31
32 static char *fimc_clock_name[NUM_FIMC_CLOCKS] = { "sclk_fimc", "fimc" };
33
34 static struct fimc_fmt fimc_formats[] = {
35         {
36                 .name   = "RGB565",
37                 .fourcc = V4L2_PIX_FMT_RGB565X,
38                 .depth  = 16,
39                 .color  = S5P_FIMC_RGB565,
40                 .buff_cnt = 1,
41                 .planes_cnt = 1
42         }, {
43                 .name   = "BGR666",
44                 .fourcc = V4L2_PIX_FMT_BGR666,
45                 .depth  = 32,
46                 .color  = S5P_FIMC_RGB666,
47                 .buff_cnt = 1,
48                 .planes_cnt = 1
49         }, {
50                 .name = "XRGB-8-8-8-8, 24 bpp",
51                 .fourcc = V4L2_PIX_FMT_RGB24,
52                 .depth = 32,
53                 .color  = S5P_FIMC_RGB888,
54                 .buff_cnt = 1,
55                 .planes_cnt = 1
56         }, {
57                 .name   = "YUV 4:2:2 packed, YCbYCr",
58                 .fourcc = V4L2_PIX_FMT_YUYV,
59                 .depth  = 16,
60                 .color  = S5P_FIMC_YCBYCR422,
61                 .buff_cnt = 1,
62                 .planes_cnt = 1
63                 }, {
64                 .name   = "YUV 4:2:2 packed, CbYCrY",
65                 .fourcc = V4L2_PIX_FMT_UYVY,
66                 .depth  = 16,
67                 .color  = S5P_FIMC_CBYCRY422,
68                 .buff_cnt = 1,
69                 .planes_cnt = 1
70         }, {
71                 .name   = "YUV 4:2:2 packed, CrYCbY",
72                 .fourcc = V4L2_PIX_FMT_VYUY,
73                 .depth  = 16,
74                 .color  = S5P_FIMC_CRYCBY422,
75                 .buff_cnt = 1,
76                 .planes_cnt = 1
77         }, {
78                 .name   = "YUV 4:2:2 packed, YCrYCb",
79                 .fourcc = V4L2_PIX_FMT_YVYU,
80                 .depth  = 16,
81                 .color  = S5P_FIMC_YCRYCB422,
82                 .buff_cnt = 1,
83                 .planes_cnt = 1
84         }, {
85                 .name   = "YUV 4:2:2 planar, Y/Cb/Cr",
86                 .fourcc = V4L2_PIX_FMT_YUV422P,
87                 .depth  = 12,
88                 .color  = S5P_FIMC_YCBCR422,
89                 .buff_cnt = 1,
90                 .planes_cnt = 3
91         }, {
92                 .name   = "YUV 4:2:2 planar, Y/CbCr",
93                 .fourcc = V4L2_PIX_FMT_NV16,
94                 .depth  = 16,
95                 .color  = S5P_FIMC_YCBCR422,
96                 .buff_cnt = 1,
97                 .planes_cnt = 2
98         }, {
99                 .name   = "YUV 4:2:2 planar, Y/CrCb",
100                 .fourcc = V4L2_PIX_FMT_NV61,
101                 .depth  = 16,
102                 .color  = S5P_FIMC_RGB565,
103                 .buff_cnt = 1,
104                 .planes_cnt = 2
105         }, {
106                 .name   = "YUV 4:2:0 planar, YCbCr",
107                 .fourcc = V4L2_PIX_FMT_YUV420,
108                 .depth  = 12,
109                 .color  = S5P_FIMC_YCBCR420,
110                 .buff_cnt = 1,
111                 .planes_cnt = 3
112         }, {
113                 .name   = "YUV 4:2:0 planar, Y/CbCr",
114                 .fourcc = V4L2_PIX_FMT_NV12,
115                 .depth  = 12,
116                 .color  = S5P_FIMC_YCBCR420,
117                 .buff_cnt = 1,
118                 .planes_cnt = 2
119         }
120 };
121
122 static struct v4l2_queryctrl fimc_ctrls[] = {
123         {
124                 .id             = V4L2_CID_HFLIP,
125                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
126                 .name           = "Horizontal flip",
127                 .minimum        = 0,
128                 .maximum        = 1,
129                 .default_value  = 0,
130         }, {
131                 .id             = V4L2_CID_VFLIP,
132                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
133                 .name           = "Vertical flip",
134                 .minimum        = 0,
135                 .maximum        = 1,
136                 .default_value  = 0,
137         }, {
138                 .id             = V4L2_CID_ROTATE,
139                 .type           = V4L2_CTRL_TYPE_INTEGER,
140                 .name           = "Rotation (CCW)",
141                 .minimum        = 0,
142                 .maximum        = 270,
143                 .step           = 90,
144                 .default_value  = 0,
145         },
146 };
147
148
149 static struct v4l2_queryctrl *get_ctrl(int id)
150 {
151         int i;
152
153         for (i = 0; i < ARRAY_SIZE(fimc_ctrls); ++i)
154                 if (id == fimc_ctrls[i].id)
155                         return &fimc_ctrls[i];
156         return NULL;
157 }
158
159 static int fimc_check_scaler_ratio(struct v4l2_rect *r, struct fimc_frame *f)
160 {
161         if (r->width > f->width) {
162                 if (f->width > (r->width * SCALER_MAX_HRATIO))
163                         return -EINVAL;
164         } else {
165                 if ((f->width * SCALER_MAX_HRATIO) < r->width)
166                         return -EINVAL;
167         }
168
169         if (r->height > f->height) {
170                 if (f->height > (r->height * SCALER_MAX_VRATIO))
171                         return -EINVAL;
172         } else {
173                 if ((f->height * SCALER_MAX_VRATIO) < r->height)
174                         return -EINVAL;
175         }
176
177         return 0;
178 }
179
180 static int fimc_get_scaler_factor(u32 src, u32 tar, u32 *ratio, u32 *shift)
181 {
182         u32 sh = 6;
183
184         if (src >= 64 * tar)
185                 return -EINVAL;
186
187         while (sh--) {
188                 u32 tmp = 1 << sh;
189                 if (src >= tar * tmp) {
190                         *shift = sh, *ratio = tmp;
191                         return 0;
192                 }
193         }
194
195         *shift = 0, *ratio = 1;
196
197         dbg("s: %d, t: %d, shift: %d, ratio: %d",
198             src, tar, *shift, *ratio);
199         return 0;
200 }
201
202 static int fimc_set_scaler_info(struct fimc_ctx *ctx)
203 {
204         struct fimc_scaler *sc = &ctx->scaler;
205         struct fimc_frame *s_frame = &ctx->s_frame;
206         struct fimc_frame *d_frame = &ctx->d_frame;
207         int tx, ty, sx, sy;
208         int ret;
209
210         if (ctx->rotation == 90 || ctx->rotation == 270) {
211                 ty = d_frame->width;
212                 tx = d_frame->height;
213         } else {
214                 tx = d_frame->width;
215                 ty = d_frame->height;
216         }
217         if (tx <= 0 || ty <= 0) {
218                 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev,
219                         "invalid target size: %d x %d", tx, ty);
220                 return -EINVAL;
221         }
222
223         sx = s_frame->width;
224         sy = s_frame->height;
225         if (sx <= 0 || sy <= 0) {
226                 err("invalid source size: %d x %d", sx, sy);
227                 return -EINVAL;
228         }
229
230         sc->real_width = sx;
231         sc->real_height = sy;
232         dbg("sx= %d, sy= %d, tx= %d, ty= %d", sx, sy, tx, ty);
233
234         ret = fimc_get_scaler_factor(sx, tx, &sc->pre_hratio, &sc->hfactor);
235         if (ret)
236                 return ret;
237
238         ret = fimc_get_scaler_factor(sy, ty,  &sc->pre_vratio, &sc->vfactor);
239         if (ret)
240                 return ret;
241
242         sc->pre_dst_width = sx / sc->pre_hratio;
243         sc->pre_dst_height = sy / sc->pre_vratio;
244
245         sc->main_hratio = (sx << 8) / (tx << sc->hfactor);
246         sc->main_vratio = (sy << 8) / (ty << sc->vfactor);
247
248         sc->scaleup_h = (tx >= sx) ? 1 : 0;
249         sc->scaleup_v = (ty >= sy) ? 1 : 0;
250
251         /* check to see if input and output size/format differ */
252         if (s_frame->fmt->color == d_frame->fmt->color
253                 && s_frame->width == d_frame->width
254                 && s_frame->height == d_frame->height)
255                 sc->copy_mode = 1;
256         else
257                 sc->copy_mode = 0;
258
259         return 0;
260 }
261
262
263 static irqreturn_t fimc_isr(int irq, void *priv)
264 {
265         struct fimc_vid_buffer *src_buf, *dst_buf;
266         struct fimc_ctx *ctx;
267         struct fimc_dev *fimc = priv;
268
269         BUG_ON(!fimc);
270         fimc_hw_clear_irq(fimc);
271
272         spin_lock(&fimc->slock);
273
274         if (test_and_clear_bit(ST_M2M_PEND, &fimc->state)) {
275                 ctx = v4l2_m2m_get_curr_priv(fimc->m2m.m2m_dev);
276                 if (!ctx || !ctx->m2m_ctx)
277                         goto isr_unlock;
278                 src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
279                 dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
280                 if (src_buf && dst_buf) {
281                         spin_lock(&fimc->irqlock);
282                         src_buf->vb.state = dst_buf->vb.state = VIDEOBUF_DONE;
283                         wake_up(&src_buf->vb.done);
284                         wake_up(&dst_buf->vb.done);
285                         spin_unlock(&fimc->irqlock);
286                         v4l2_m2m_job_finish(fimc->m2m.m2m_dev, ctx->m2m_ctx);
287                 }
288         }
289
290 isr_unlock:
291         spin_unlock(&fimc->slock);
292         return IRQ_HANDLED;
293 }
294
295 /* The color format (planes_cnt, buff_cnt) must be already configured. */
296 int fimc_prepare_addr(struct fimc_ctx *ctx, struct fimc_vid_buffer *buf,
297                       struct fimc_frame *frame, struct fimc_addr *paddr)
298 {
299         int ret = 0;
300         u32 pix_size;
301
302         if (buf == NULL || frame == NULL)
303                 return -EINVAL;
304
305         pix_size = frame->width * frame->height;
306
307         dbg("buff_cnt= %d, planes_cnt= %d, frame->size= %d, pix_size= %d",
308                 frame->fmt->buff_cnt, frame->fmt->planes_cnt,
309                 frame->size, pix_size);
310
311         if (frame->fmt->buff_cnt == 1) {
312                 paddr->y = videobuf_to_dma_contig(&buf->vb);
313                 switch (frame->fmt->planes_cnt) {
314                 case 1:
315                         paddr->cb = 0;
316                         paddr->cr = 0;
317                         break;
318                 case 2:
319                         /* decompose Y into Y/Cb */
320                         paddr->cb = (u32)(paddr->y + pix_size);
321                         paddr->cr = 0;
322                         break;
323                 case 3:
324                         paddr->cb = (u32)(paddr->y + pix_size);
325                         /* decompose Y into Y/Cb/Cr */
326                         if (S5P_FIMC_YCBCR420 == frame->fmt->color)
327                                 paddr->cr = (u32)(paddr->cb
328                                                 + (pix_size >> 2));
329                         else /* 422 */
330                                 paddr->cr = (u32)(paddr->cb
331                                                 + (pix_size >> 1));
332                         break;
333                 default:
334                         return -EINVAL;
335                 }
336         }
337
338         dbg("PHYS_ADDR: y= 0x%X  cb= 0x%X cr= 0x%X ret= %d",
339             paddr->y, paddr->cb, paddr->cr, ret);
340
341         return ret;
342 }
343
344 /* Set order for 1 and 2 plane YCBCR 4:2:2 formats. */
345 static void fimc_set_yuv_order(struct fimc_ctx *ctx)
346 {
347         /* The one only mode supported in SoC. */
348         ctx->in_order_2p = S5P_FIMC_LSB_CRCB;
349         ctx->out_order_2p = S5P_FIMC_LSB_CRCB;
350
351         /* Set order for 1 plane input formats. */
352         switch (ctx->s_frame.fmt->color) {
353         case S5P_FIMC_YCRYCB422:
354                 ctx->in_order_1p = S5P_FIMC_IN_YCRYCB;
355                 break;
356         case S5P_FIMC_CBYCRY422:
357                 ctx->in_order_1p = S5P_FIMC_IN_CBYCRY;
358                 break;
359         case S5P_FIMC_CRYCBY422:
360                 ctx->in_order_1p = S5P_FIMC_IN_CRYCBY;
361                 break;
362         case S5P_FIMC_YCBYCR422:
363         default:
364                 ctx->in_order_1p = S5P_FIMC_IN_YCBYCR;
365                 break;
366         }
367         dbg("ctx->in_order_1p= %d", ctx->in_order_1p);
368
369         switch (ctx->d_frame.fmt->color) {
370         case S5P_FIMC_YCRYCB422:
371                 ctx->out_order_1p = S5P_FIMC_OUT_YCRYCB;
372                 break;
373         case S5P_FIMC_CBYCRY422:
374                 ctx->out_order_1p = S5P_FIMC_OUT_CBYCRY;
375                 break;
376         case S5P_FIMC_CRYCBY422:
377                 ctx->out_order_1p = S5P_FIMC_OUT_CRYCBY;
378                 break;
379         case S5P_FIMC_YCBYCR422:
380         default:
381                 ctx->out_order_1p = S5P_FIMC_OUT_YCBYCR;
382                 break;
383         }
384         dbg("ctx->out_order_1p= %d", ctx->out_order_1p);
385 }
386
387 static void fimc_prepare_dma_offset(struct fimc_ctx *ctx, struct fimc_frame *f)
388 {
389         struct samsung_fimc_variant *variant = ctx->fimc_dev->variant;
390
391         f->dma_offset.y_h = f->offs_h;
392         if (!variant->pix_hoff)
393                 f->dma_offset.y_h *= (f->fmt->depth >> 3);
394
395         f->dma_offset.y_v = f->offs_v;
396
397         f->dma_offset.cb_h = f->offs_h;
398         f->dma_offset.cb_v = f->offs_v;
399
400         f->dma_offset.cr_h = f->offs_h;
401         f->dma_offset.cr_v = f->offs_v;
402
403         if (!variant->pix_hoff) {
404                 if (f->fmt->planes_cnt == 3) {
405                         f->dma_offset.cb_h >>= 1;
406                         f->dma_offset.cr_h >>= 1;
407                 }
408                 if (f->fmt->color == S5P_FIMC_YCBCR420) {
409                         f->dma_offset.cb_v >>= 1;
410                         f->dma_offset.cr_v >>= 1;
411                 }
412         }
413
414         dbg("in_offset: color= %d, y_h= %d, y_v= %d",
415             f->fmt->color, f->dma_offset.y_h, f->dma_offset.y_v);
416 }
417
418 /**
419  * fimc_prepare_config - check dimensions, operation and color mode
420  *                       and pre-calculate offset and the scaling coefficients.
421  *
422  * @ctx: hardware context information
423  * @flags: flags indicating which parameters to check/update
424  *
425  * Return: 0 if dimensions are valid or non zero otherwise.
426  */
427 static int fimc_prepare_config(struct fimc_ctx *ctx, u32 flags)
428 {
429         struct fimc_frame *s_frame, *d_frame;
430         struct fimc_vid_buffer *buf = NULL;
431         int ret = 0;
432
433         s_frame = &ctx->s_frame;
434         d_frame = &ctx->d_frame;
435
436         if (flags & FIMC_PARAMS) {
437                 /* Prepare the DMA offset ratios for scaler. */
438                 fimc_prepare_dma_offset(ctx, &ctx->s_frame);
439                 fimc_prepare_dma_offset(ctx, &ctx->d_frame);
440
441                 if (s_frame->height > (SCALER_MAX_VRATIO * d_frame->height) ||
442                     s_frame->width > (SCALER_MAX_HRATIO * d_frame->width)) {
443                         err("out of scaler range");
444                         return -EINVAL;
445                 }
446                 fimc_set_yuv_order(ctx);
447         }
448
449         /* Input DMA mode is not allowed when the scaler is disabled. */
450         ctx->scaler.enabled = 1;
451
452         if (flags & FIMC_SRC_ADDR) {
453                 buf = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
454                 ret = fimc_prepare_addr(ctx, buf, s_frame, &s_frame->paddr);
455                 if (ret)
456                         return ret;
457         }
458
459         if (flags & FIMC_DST_ADDR) {
460                 buf = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
461                 ret = fimc_prepare_addr(ctx, buf, d_frame, &d_frame->paddr);
462         }
463
464         return ret;
465 }
466
467 static void fimc_dma_run(void *priv)
468 {
469         struct fimc_ctx *ctx = priv;
470         struct fimc_dev *fimc;
471         unsigned long flags;
472         u32 ret;
473
474         if (WARN(!ctx, "null hardware context"))
475                 return;
476
477         fimc = ctx->fimc_dev;
478
479         spin_lock_irqsave(&ctx->slock, flags);
480         set_bit(ST_M2M_PEND, &fimc->state);
481
482         ctx->state |= (FIMC_SRC_ADDR | FIMC_DST_ADDR);
483         ret = fimc_prepare_config(ctx, ctx->state);
484         if (ret) {
485                 err("Wrong parameters");
486                 goto dma_unlock;
487         }
488         /* Reconfigure hardware if the context has changed. */
489         if (fimc->m2m.ctx != ctx) {
490                 ctx->state |= FIMC_PARAMS;
491                 fimc->m2m.ctx = ctx;
492         }
493
494         fimc_hw_set_input_addr(fimc, &ctx->s_frame.paddr);
495
496         if (ctx->state & FIMC_PARAMS) {
497                 fimc_hw_set_input_path(ctx);
498                 fimc_hw_set_in_dma(ctx);
499                 if (fimc_set_scaler_info(ctx)) {
500                         err("Scaler setup error");
501                         goto dma_unlock;
502                 }
503                 fimc_hw_set_scaler(ctx);
504                 fimc_hw_set_target_format(ctx);
505                 fimc_hw_set_rotation(ctx);
506                 fimc_hw_set_effect(ctx);
507         }
508
509         fimc_hw_set_output_path(ctx);
510         if (ctx->state & (FIMC_DST_ADDR | FIMC_PARAMS))
511                 fimc_hw_set_output_addr(fimc, &ctx->d_frame.paddr, -1);
512
513         if (ctx->state & FIMC_PARAMS)
514                 fimc_hw_set_out_dma(ctx);
515
516         ctx->state = 0;
517         fimc_activate_capture(ctx);
518
519         fimc_hw_activate_input_dma(fimc, true);
520
521 dma_unlock:
522         spin_unlock_irqrestore(&ctx->slock, flags);
523 }
524
525 static void fimc_job_abort(void *priv)
526 {
527         /* Nothing done in job_abort. */
528 }
529
530 static void fimc_buf_release(struct videobuf_queue *vq,
531                                     struct videobuf_buffer *vb)
532 {
533         videobuf_dma_contig_free(vq, vb);
534         vb->state = VIDEOBUF_NEEDS_INIT;
535 }
536
537 static int fimc_buf_setup(struct videobuf_queue *vq, unsigned int *count,
538                                 unsigned int *size)
539 {
540         struct fimc_ctx *ctx = vq->priv_data;
541         struct fimc_frame *frame;
542
543         frame = ctx_get_frame(ctx, vq->type);
544         if (IS_ERR(frame))
545                 return PTR_ERR(frame);
546
547         *size = (frame->width * frame->height * frame->fmt->depth) >> 3;
548         if (0 == *count)
549                 *count = 1;
550         return 0;
551 }
552
553 static int fimc_buf_prepare(struct videobuf_queue *vq,
554                 struct videobuf_buffer *vb, enum v4l2_field field)
555 {
556         struct fimc_ctx *ctx = vq->priv_data;
557         struct v4l2_device *v4l2_dev = &ctx->fimc_dev->m2m.v4l2_dev;
558         struct fimc_frame *frame;
559         int ret;
560
561         frame = ctx_get_frame(ctx, vq->type);
562         if (IS_ERR(frame))
563                 return PTR_ERR(frame);
564
565         if (vb->baddr) {
566                 if (vb->bsize < frame->size) {
567                         v4l2_err(v4l2_dev,
568                                 "User-provided buffer too small (%d < %d)\n",
569                                  vb->bsize, frame->size);
570                         WARN_ON(1);
571                         return -EINVAL;
572                 }
573         } else if (vb->state != VIDEOBUF_NEEDS_INIT
574                    && vb->bsize < frame->size) {
575                 return -EINVAL;
576         }
577
578         vb->width       = frame->width;
579         vb->height      = frame->height;
580         vb->bytesperline = (frame->width * frame->fmt->depth) >> 3;
581         vb->size        = frame->size;
582         vb->field       = field;
583
584         if (VIDEOBUF_NEEDS_INIT == vb->state) {
585                 ret = videobuf_iolock(vq, vb, NULL);
586                 if (ret) {
587                         v4l2_err(v4l2_dev, "Iolock failed\n");
588                         fimc_buf_release(vq, vb);
589                         return ret;
590                 }
591         }
592         vb->state = VIDEOBUF_PREPARED;
593
594         return 0;
595 }
596
597 static void fimc_buf_queue(struct videobuf_queue *vq,
598                                   struct videobuf_buffer *vb)
599 {
600         struct fimc_ctx *ctx = vq->priv_data;
601         v4l2_m2m_buf_queue(ctx->m2m_ctx, vq, vb);
602 }
603
604 static struct videobuf_queue_ops fimc_qops = {
605         .buf_setup      = fimc_buf_setup,
606         .buf_prepare    = fimc_buf_prepare,
607         .buf_queue      = fimc_buf_queue,
608         .buf_release    = fimc_buf_release,
609 };
610
611 static int fimc_m2m_querycap(struct file *file, void *priv,
612                            struct v4l2_capability *cap)
613 {
614         struct fimc_ctx *ctx = file->private_data;
615         struct fimc_dev *fimc = ctx->fimc_dev;
616
617         strncpy(cap->driver, fimc->pdev->name, sizeof(cap->driver) - 1);
618         strncpy(cap->card, fimc->pdev->name, sizeof(cap->card) - 1);
619         cap->bus_info[0] = 0;
620         cap->version = KERNEL_VERSION(1, 0, 0);
621         cap->capabilities = V4L2_CAP_STREAMING |
622                 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT;
623
624         return 0;
625 }
626
627 static int fimc_m2m_enum_fmt(struct file *file, void *priv,
628                                 struct v4l2_fmtdesc *f)
629 {
630         struct fimc_fmt *fmt;
631
632         if (f->index >= ARRAY_SIZE(fimc_formats))
633                 return -EINVAL;
634
635         fmt = &fimc_formats[f->index];
636         strncpy(f->description, fmt->name, sizeof(f->description) - 1);
637         f->pixelformat = fmt->fourcc;
638         return 0;
639 }
640
641 static int fimc_m2m_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
642 {
643         struct fimc_ctx *ctx = priv;
644         struct fimc_frame *frame;
645
646         frame = ctx_get_frame(ctx, f->type);
647         if (IS_ERR(frame))
648                 return PTR_ERR(frame);
649
650         f->fmt.pix.width        = frame->width;
651         f->fmt.pix.height       = frame->height;
652         f->fmt.pix.field        = V4L2_FIELD_NONE;
653         f->fmt.pix.pixelformat  = frame->fmt->fourcc;
654
655         return 0;
656 }
657
658 static struct fimc_fmt *find_format(struct v4l2_format *f)
659 {
660         struct fimc_fmt *fmt;
661         unsigned int i;
662
663         for (i = 0; i < ARRAY_SIZE(fimc_formats); ++i) {
664                 fmt = &fimc_formats[i];
665                 if (fmt->fourcc == f->fmt.pix.pixelformat)
666                         break;
667         }
668         if (i == ARRAY_SIZE(fimc_formats))
669                 return NULL;
670
671         return fmt;
672 }
673
674 static int fimc_m2m_try_fmt(struct file *file, void *priv,
675                              struct v4l2_format *f)
676 {
677         struct fimc_fmt *fmt;
678         u32 max_width, max_height, mod_x, mod_y;
679         struct fimc_ctx *ctx = priv;
680         struct fimc_dev *fimc = ctx->fimc_dev;
681         struct v4l2_pix_format *pix = &f->fmt.pix;
682         struct samsung_fimc_variant *variant = fimc->variant;
683
684         fmt = find_format(f);
685         if (!fmt) {
686                 v4l2_err(&fimc->m2m.v4l2_dev,
687                          "Fourcc format (0x%X) invalid.\n",  pix->pixelformat);
688                 return -EINVAL;
689         }
690
691         if (pix->field == V4L2_FIELD_ANY)
692                 pix->field = V4L2_FIELD_NONE;
693         else if (V4L2_FIELD_NONE != pix->field)
694                 return -EINVAL;
695
696         if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
697                 max_width = variant->scaler_dis_w;
698                 max_height = variant->scaler_dis_w;
699                 mod_x = variant->min_inp_pixsize;
700                 mod_y = variant->min_inp_pixsize;
701         } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
702                 max_width = variant->out_rot_dis_w;
703                 max_height = variant->out_rot_dis_w;
704                 mod_x = variant->min_out_pixsize;
705                 mod_y = variant->min_out_pixsize;
706         } else {
707                 err("Wrong stream type (%d)", f->type);
708                 return -EINVAL;
709         }
710
711         dbg("max_w= %d, max_h= %d", max_width, max_height);
712
713         if (pix->height > max_height)
714                 pix->height = max_height;
715         if (pix->width > max_width)
716                 pix->width = max_width;
717
718         if (tiled_fmt(fmt)) {
719                 mod_x = 64; /* 64x32 tile */
720                 mod_y = 32;
721         }
722
723         dbg("mod_x= 0x%X, mod_y= 0x%X", mod_x, mod_y);
724
725         pix->width = (pix->width == 0) ? mod_x : ALIGN(pix->width, mod_x);
726         pix->height = (pix->height == 0) ? mod_y : ALIGN(pix->height, mod_y);
727
728         if (pix->bytesperline == 0 ||
729             pix->bytesperline * 8 / fmt->depth > pix->width)
730                 pix->bytesperline = (pix->width * fmt->depth) >> 3;
731
732         if (pix->sizeimage == 0)
733                 pix->sizeimage = pix->height * pix->bytesperline;
734
735         dbg("pix->bytesperline= %d, fmt->depth= %d",
736             pix->bytesperline, fmt->depth);
737
738         return 0;
739 }
740
741
742 static int fimc_m2m_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
743 {
744         struct fimc_ctx *ctx = priv;
745         struct v4l2_device *v4l2_dev = &ctx->fimc_dev->m2m.v4l2_dev;
746         struct videobuf_queue *src_vq, *dst_vq;
747         struct fimc_frame *frame;
748         struct v4l2_pix_format *pix;
749         unsigned long flags;
750         int ret = 0;
751
752         BUG_ON(!ctx);
753
754         ret = fimc_m2m_try_fmt(file, priv, f);
755         if (ret)
756                 return ret;
757
758         mutex_lock(&ctx->fimc_dev->lock);
759
760         src_vq = v4l2_m2m_get_src_vq(ctx->m2m_ctx);
761         dst_vq = v4l2_m2m_get_dst_vq(ctx->m2m_ctx);
762
763         mutex_lock(&src_vq->vb_lock);
764         mutex_lock(&dst_vq->vb_lock);
765
766         if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
767                 if (videobuf_queue_is_busy(src_vq)) {
768                         v4l2_err(v4l2_dev, "%s queue busy\n", __func__);
769                         ret = -EBUSY;
770                         goto s_fmt_out;
771                 }
772                 frame = &ctx->s_frame;
773                 spin_lock_irqsave(&ctx->slock, flags);
774                 ctx->state |= FIMC_SRC_FMT;
775                 spin_unlock_irqrestore(&ctx->slock, flags);
776
777         } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
778                 if (videobuf_queue_is_busy(dst_vq)) {
779                         v4l2_err(v4l2_dev, "%s queue busy\n", __func__);
780                         ret = -EBUSY;
781                         goto s_fmt_out;
782                 }
783                 frame = &ctx->d_frame;
784                 spin_lock_irqsave(&ctx->slock, flags);
785                 ctx->state |= FIMC_DST_FMT;
786                 spin_unlock_irqrestore(&ctx->slock, flags);
787         } else {
788                 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev,
789                          "Wrong buffer/video queue type (%d)\n", f->type);
790                 ret = -EINVAL;
791                 goto s_fmt_out;
792         }
793
794         pix = &f->fmt.pix;
795         frame->fmt = find_format(f);
796         if (!frame->fmt) {
797                 ret = -EINVAL;
798                 goto s_fmt_out;
799         }
800
801         frame->f_width = pix->bytesperline * 8 / frame->fmt->depth;
802         frame->f_height = pix->sizeimage/pix->bytesperline;
803         frame->width = pix->width;
804         frame->height = pix->height;
805         frame->o_width = pix->width;
806         frame->o_height = pix->height;
807         frame->offs_h = 0;
808         frame->offs_v = 0;
809         frame->size = (pix->width * pix->height * frame->fmt->depth) >> 3;
810         src_vq->field = dst_vq->field = pix->field;
811         spin_lock_irqsave(&ctx->slock, flags);
812         ctx->state |= FIMC_PARAMS;
813         spin_unlock_irqrestore(&ctx->slock, flags);
814
815         dbg("f_width= %d, f_height= %d", frame->f_width, frame->f_height);
816
817 s_fmt_out:
818         mutex_unlock(&dst_vq->vb_lock);
819         mutex_unlock(&src_vq->vb_lock);
820         mutex_unlock(&ctx->fimc_dev->lock);
821         return ret;
822 }
823
824 static int fimc_m2m_reqbufs(struct file *file, void *priv,
825                           struct v4l2_requestbuffers *reqbufs)
826 {
827         struct fimc_ctx *ctx = priv;
828         return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
829 }
830
831 static int fimc_m2m_querybuf(struct file *file, void *priv,
832                            struct v4l2_buffer *buf)
833 {
834         struct fimc_ctx *ctx = priv;
835         return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
836 }
837
838 static int fimc_m2m_qbuf(struct file *file, void *priv,
839                           struct v4l2_buffer *buf)
840 {
841         struct fimc_ctx *ctx = priv;
842
843         return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
844 }
845
846 static int fimc_m2m_dqbuf(struct file *file, void *priv,
847                            struct v4l2_buffer *buf)
848 {
849         struct fimc_ctx *ctx = priv;
850         return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
851 }
852
853 static int fimc_m2m_streamon(struct file *file, void *priv,
854                            enum v4l2_buf_type type)
855 {
856         struct fimc_ctx *ctx = priv;
857         return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
858 }
859
860 static int fimc_m2m_streamoff(struct file *file, void *priv,
861                             enum v4l2_buf_type type)
862 {
863         struct fimc_ctx *ctx = priv;
864         return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
865 }
866
867 int fimc_m2m_queryctrl(struct file *file, void *priv,
868                             struct v4l2_queryctrl *qc)
869 {
870         struct v4l2_queryctrl *c;
871         c = get_ctrl(qc->id);
872         if (!c)
873                 return -EINVAL;
874         *qc = *c;
875         return 0;
876 }
877
878 int fimc_m2m_g_ctrl(struct file *file, void *priv,
879                          struct v4l2_control *ctrl)
880 {
881         struct fimc_ctx *ctx = priv;
882
883         switch (ctrl->id) {
884         case V4L2_CID_HFLIP:
885                 ctrl->value = (FLIP_X_AXIS & ctx->flip) ? 1 : 0;
886                 break;
887         case V4L2_CID_VFLIP:
888                 ctrl->value = (FLIP_Y_AXIS & ctx->flip) ? 1 : 0;
889                 break;
890         case V4L2_CID_ROTATE:
891                 ctrl->value = ctx->rotation;
892                 break;
893         default:
894                 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev, "Invalid control\n");
895                 return -EINVAL;
896         }
897         dbg("ctrl->value= %d", ctrl->value);
898         return 0;
899 }
900
901 static int check_ctrl_val(struct fimc_ctx *ctx,
902                           struct v4l2_control *ctrl)
903 {
904         struct v4l2_queryctrl *c;
905         c = get_ctrl(ctrl->id);
906         if (!c)
907                 return -EINVAL;
908
909         if (ctrl->value < c->minimum || ctrl->value > c->maximum
910                 || (c->step != 0 && ctrl->value % c->step != 0)) {
911                 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev,
912                 "Invalid control value\n");
913                 return -ERANGE;
914         }
915
916         return 0;
917 }
918
919 int fimc_m2m_s_ctrl(struct file *file, void *priv,
920                          struct v4l2_control *ctrl)
921 {
922         struct fimc_ctx *ctx = priv;
923         struct samsung_fimc_variant *variant = ctx->fimc_dev->variant;
924         unsigned long flags;
925         int ret = 0;
926
927         ret = check_ctrl_val(ctx, ctrl);
928         if (ret)
929                 return ret;
930
931         switch (ctrl->id) {
932         case V4L2_CID_HFLIP:
933                 if (ctx->rotation != 0)
934                         return 0;
935                 if (ctrl->value)
936                         ctx->flip |= FLIP_X_AXIS;
937                 else
938                         ctx->flip &= ~FLIP_X_AXIS;
939                 break;
940
941         case V4L2_CID_VFLIP:
942                 if (ctx->rotation != 0)
943                         return 0;
944                 if (ctrl->value)
945                         ctx->flip |= FLIP_Y_AXIS;
946                 else
947                         ctx->flip &= ~FLIP_Y_AXIS;
948                 break;
949
950         case V4L2_CID_ROTATE:
951                 if (ctrl->value == 90 || ctrl->value == 270) {
952                         if (ctx->out_path == FIMC_LCDFIFO &&
953                             !variant->has_inp_rot) {
954                                 return -EINVAL;
955                         } else if (ctx->in_path == FIMC_DMA &&
956                                    !variant->has_out_rot) {
957                                 return -EINVAL;
958                         }
959                 }
960                 ctx->rotation = ctrl->value;
961                 if (ctrl->value == 180)
962                         ctx->flip = FLIP_XY_AXIS;
963                 break;
964
965         default:
966                 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev, "Invalid control\n");
967                 return -EINVAL;
968         }
969         spin_lock_irqsave(&ctx->slock, flags);
970         ctx->state |= FIMC_PARAMS;
971         spin_unlock_irqrestore(&ctx->slock, flags);
972         return 0;
973 }
974
975
976 static int fimc_m2m_cropcap(struct file *file, void *fh,
977                              struct v4l2_cropcap *cr)
978 {
979         struct fimc_frame *frame;
980         struct fimc_ctx *ctx = fh;
981
982         frame = ctx_get_frame(ctx, cr->type);
983         if (IS_ERR(frame))
984                 return PTR_ERR(frame);
985
986         cr->bounds.left = 0;
987         cr->bounds.top = 0;
988         cr->bounds.width = frame->f_width;
989         cr->bounds.height = frame->f_height;
990         cr->defrect.left = frame->offs_h;
991         cr->defrect.top = frame->offs_v;
992         cr->defrect.width = frame->o_width;
993         cr->defrect.height = frame->o_height;
994         return 0;
995 }
996
997 static int fimc_m2m_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
998 {
999         struct fimc_frame *frame;
1000         struct fimc_ctx *ctx = file->private_data;
1001
1002         frame = ctx_get_frame(ctx, cr->type);
1003         if (IS_ERR(frame))
1004                 return PTR_ERR(frame);
1005
1006         cr->c.left = frame->offs_h;
1007         cr->c.top = frame->offs_v;
1008         cr->c.width = frame->width;
1009         cr->c.height = frame->height;
1010
1011         return 0;
1012 }
1013
1014 static int fimc_m2m_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1015 {
1016         struct fimc_ctx *ctx = file->private_data;
1017         struct fimc_dev *fimc = ctx->fimc_dev;
1018         unsigned long flags;
1019         struct fimc_frame *f;
1020         u32 min_size;
1021         int ret = 0;
1022
1023         if (cr->c.top < 0 || cr->c.left < 0) {
1024                 v4l2_err(&fimc->m2m.v4l2_dev,
1025                         "doesn't support negative values for top & left\n");
1026                 return -EINVAL;
1027         }
1028
1029         if (cr->c.width  <= 0 || cr->c.height <= 0) {
1030                 v4l2_err(&fimc->m2m.v4l2_dev,
1031                         "crop width and height must be greater than 0\n");
1032                 return -EINVAL;
1033         }
1034
1035         f = ctx_get_frame(ctx, cr->type);
1036         if (IS_ERR(f))
1037                 return PTR_ERR(f);
1038
1039         /* Adjust to required pixel boundary. */
1040         min_size = (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) ?
1041                 fimc->variant->min_inp_pixsize : fimc->variant->min_out_pixsize;
1042
1043         cr->c.width = round_down(cr->c.width, min_size);
1044         cr->c.height = round_down(cr->c.height, min_size);
1045         cr->c.left = round_down(cr->c.left + 1, min_size);
1046         cr->c.top = round_down(cr->c.top + 1, min_size);
1047
1048         if ((cr->c.left + cr->c.width > f->o_width)
1049                 || (cr->c.top + cr->c.height > f->o_height)) {
1050                 v4l2_err(&fimc->m2m.v4l2_dev, "Error in S_CROP params\n");
1051                 return -EINVAL;
1052         }
1053
1054         spin_lock_irqsave(&ctx->slock, flags);
1055         if ((ctx->state & FIMC_SRC_FMT) && (ctx->state & FIMC_DST_FMT)) {
1056                 /* Check for the pixel scaling ratio when cropping input img. */
1057                 if (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1058                         ret = fimc_check_scaler_ratio(&cr->c, &ctx->d_frame);
1059                 else if (cr->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1060                         ret = fimc_check_scaler_ratio(&cr->c, &ctx->s_frame);
1061
1062                 if (ret) {
1063                         spin_unlock_irqrestore(&ctx->slock, flags);
1064                         v4l2_err(&fimc->m2m.v4l2_dev,  "Out of scaler range");
1065                         return -EINVAL;
1066                 }
1067         }
1068         ctx->state |= FIMC_PARAMS;
1069         spin_unlock_irqrestore(&ctx->slock, flags);
1070
1071         f->offs_h = cr->c.left;
1072         f->offs_v = cr->c.top;
1073         f->width = cr->c.width;
1074         f->height = cr->c.height;
1075         return 0;
1076 }
1077
1078 static const struct v4l2_ioctl_ops fimc_m2m_ioctl_ops = {
1079         .vidioc_querycap                = fimc_m2m_querycap,
1080
1081         .vidioc_enum_fmt_vid_cap        = fimc_m2m_enum_fmt,
1082         .vidioc_enum_fmt_vid_out        = fimc_m2m_enum_fmt,
1083
1084         .vidioc_g_fmt_vid_cap           = fimc_m2m_g_fmt,
1085         .vidioc_g_fmt_vid_out           = fimc_m2m_g_fmt,
1086
1087         .vidioc_try_fmt_vid_cap         = fimc_m2m_try_fmt,
1088         .vidioc_try_fmt_vid_out         = fimc_m2m_try_fmt,
1089
1090         .vidioc_s_fmt_vid_cap           = fimc_m2m_s_fmt,
1091         .vidioc_s_fmt_vid_out           = fimc_m2m_s_fmt,
1092
1093         .vidioc_reqbufs                 = fimc_m2m_reqbufs,
1094         .vidioc_querybuf                = fimc_m2m_querybuf,
1095
1096         .vidioc_qbuf                    = fimc_m2m_qbuf,
1097         .vidioc_dqbuf                   = fimc_m2m_dqbuf,
1098
1099         .vidioc_streamon                = fimc_m2m_streamon,
1100         .vidioc_streamoff               = fimc_m2m_streamoff,
1101
1102         .vidioc_queryctrl               = fimc_m2m_queryctrl,
1103         .vidioc_g_ctrl                  = fimc_m2m_g_ctrl,
1104         .vidioc_s_ctrl                  = fimc_m2m_s_ctrl,
1105
1106         .vidioc_g_crop                  = fimc_m2m_g_crop,
1107         .vidioc_s_crop                  = fimc_m2m_s_crop,
1108         .vidioc_cropcap                 = fimc_m2m_cropcap
1109
1110 };
1111
1112 static void queue_init(void *priv, struct videobuf_queue *vq,
1113                        enum v4l2_buf_type type)
1114 {
1115         struct fimc_ctx *ctx = priv;
1116         struct fimc_dev *fimc = ctx->fimc_dev;
1117
1118         videobuf_queue_dma_contig_init(vq, &fimc_qops,
1119                 &fimc->pdev->dev,
1120                 &fimc->irqlock, type, V4L2_FIELD_NONE,
1121                 sizeof(struct fimc_vid_buffer), priv, NULL);
1122 }
1123
1124 static int fimc_m2m_open(struct file *file)
1125 {
1126         struct fimc_dev *fimc = video_drvdata(file);
1127         struct fimc_ctx *ctx = NULL;
1128         int err = 0;
1129
1130         mutex_lock(&fimc->lock);
1131         fimc->m2m.refcnt++;
1132         set_bit(ST_OUTDMA_RUN, &fimc->state);
1133         mutex_unlock(&fimc->lock);
1134
1135
1136         ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
1137         if (!ctx)
1138                 return -ENOMEM;
1139
1140         file->private_data = ctx;
1141         ctx->fimc_dev = fimc;
1142         /* Default color format */
1143         ctx->s_frame.fmt = &fimc_formats[0];
1144         ctx->d_frame.fmt = &fimc_formats[0];
1145         /* per user process device context initialization */
1146         ctx->state = 0;
1147         ctx->flags = 0;
1148         ctx->in_path = FIMC_DMA;
1149         ctx->out_path = FIMC_DMA;
1150         spin_lock_init(&ctx->slock);
1151
1152         ctx->m2m_ctx = v4l2_m2m_ctx_init(ctx, fimc->m2m.m2m_dev, queue_init);
1153         if (IS_ERR(ctx->m2m_ctx)) {
1154                 err = PTR_ERR(ctx->m2m_ctx);
1155                 kfree(ctx);
1156         }
1157         return err;
1158 }
1159
1160 static int fimc_m2m_release(struct file *file)
1161 {
1162         struct fimc_ctx *ctx = file->private_data;
1163         struct fimc_dev *fimc = ctx->fimc_dev;
1164
1165         v4l2_m2m_ctx_release(ctx->m2m_ctx);
1166         kfree(ctx);
1167         mutex_lock(&fimc->lock);
1168         if (--fimc->m2m.refcnt <= 0)
1169                 clear_bit(ST_OUTDMA_RUN, &fimc->state);
1170         mutex_unlock(&fimc->lock);
1171         return 0;
1172 }
1173
1174 static unsigned int fimc_m2m_poll(struct file *file,
1175                                      struct poll_table_struct *wait)
1176 {
1177         struct fimc_ctx *ctx = file->private_data;
1178         return v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
1179 }
1180
1181
1182 static int fimc_m2m_mmap(struct file *file, struct vm_area_struct *vma)
1183 {
1184         struct fimc_ctx *ctx = file->private_data;
1185         return v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
1186 }
1187
1188 static const struct v4l2_file_operations fimc_m2m_fops = {
1189         .owner          = THIS_MODULE,
1190         .open           = fimc_m2m_open,
1191         .release        = fimc_m2m_release,
1192         .poll           = fimc_m2m_poll,
1193         .ioctl          = video_ioctl2,
1194         .mmap           = fimc_m2m_mmap,
1195 };
1196
1197 static struct v4l2_m2m_ops m2m_ops = {
1198         .device_run     = fimc_dma_run,
1199         .job_abort      = fimc_job_abort,
1200 };
1201
1202
1203 static int fimc_register_m2m_device(struct fimc_dev *fimc)
1204 {
1205         struct video_device *vfd;
1206         struct platform_device *pdev;
1207         struct v4l2_device *v4l2_dev;
1208         int ret = 0;
1209
1210         if (!fimc)
1211                 return -ENODEV;
1212
1213         pdev = fimc->pdev;
1214         v4l2_dev = &fimc->m2m.v4l2_dev;
1215
1216         /* set name if it is empty */
1217         if (!v4l2_dev->name[0])
1218                 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
1219                          "%s.m2m", dev_name(&pdev->dev));
1220
1221         ret = v4l2_device_register(&pdev->dev, v4l2_dev);
1222         if (ret)
1223                 goto err_m2m_r1;
1224
1225         vfd = video_device_alloc();
1226         if (!vfd) {
1227                 v4l2_err(v4l2_dev, "Failed to allocate video device\n");
1228                 goto err_m2m_r1;
1229         }
1230
1231         vfd->fops       = &fimc_m2m_fops;
1232         vfd->ioctl_ops  = &fimc_m2m_ioctl_ops;
1233         vfd->minor      = -1;
1234         vfd->release    = video_device_release;
1235
1236         snprintf(vfd->name, sizeof(vfd->name), "%s:m2m", dev_name(&pdev->dev));
1237
1238         video_set_drvdata(vfd, fimc);
1239         platform_set_drvdata(pdev, fimc);
1240
1241         fimc->m2m.vfd = vfd;
1242         fimc->m2m.m2m_dev = v4l2_m2m_init(&m2m_ops);
1243         if (IS_ERR(fimc->m2m.m2m_dev)) {
1244                 v4l2_err(v4l2_dev, "failed to initialize v4l2-m2m device\n");
1245                 ret = PTR_ERR(fimc->m2m.m2m_dev);
1246                 goto err_m2m_r2;
1247         }
1248
1249         ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
1250         if (ret) {
1251                 v4l2_err(v4l2_dev,
1252                          "%s(): failed to register video device\n", __func__);
1253                 goto err_m2m_r3;
1254         }
1255         v4l2_info(v4l2_dev,
1256                   "FIMC m2m driver registered as /dev/video%d\n", vfd->num);
1257
1258         return 0;
1259
1260 err_m2m_r3:
1261         v4l2_m2m_release(fimc->m2m.m2m_dev);
1262 err_m2m_r2:
1263         video_device_release(fimc->m2m.vfd);
1264 err_m2m_r1:
1265         v4l2_device_unregister(v4l2_dev);
1266
1267         return ret;
1268 }
1269
1270 static void fimc_unregister_m2m_device(struct fimc_dev *fimc)
1271 {
1272         if (fimc) {
1273                 v4l2_m2m_release(fimc->m2m.m2m_dev);
1274                 video_unregister_device(fimc->m2m.vfd);
1275
1276                 v4l2_device_unregister(&fimc->m2m.v4l2_dev);
1277         }
1278 }
1279
1280 static void fimc_clk_release(struct fimc_dev *fimc)
1281 {
1282         int i;
1283         for (i = 0; i < NUM_FIMC_CLOCKS; i++) {
1284                 if (fimc->clock[i]) {
1285                         clk_disable(fimc->clock[i]);
1286                         clk_put(fimc->clock[i]);
1287                 }
1288         }
1289 }
1290
1291 static int fimc_clk_get(struct fimc_dev *fimc)
1292 {
1293         int i;
1294         for (i = 0; i < NUM_FIMC_CLOCKS; i++) {
1295                 fimc->clock[i] = clk_get(&fimc->pdev->dev, fimc_clock_name[i]);
1296                 if (IS_ERR(fimc->clock[i])) {
1297                         dev_err(&fimc->pdev->dev,
1298                                 "failed to get fimc clock: %s\n",
1299                                 fimc_clock_name[i]);
1300                         return -ENXIO;
1301                 }
1302                 clk_enable(fimc->clock[i]);
1303         }
1304         return 0;
1305 }
1306
1307 static int fimc_probe(struct platform_device *pdev)
1308 {
1309         struct fimc_dev *fimc;
1310         struct resource *res;
1311         struct samsung_fimc_driverdata *drv_data;
1312         int ret = 0;
1313
1314         dev_dbg(&pdev->dev, "%s():\n", __func__);
1315
1316         drv_data = (struct samsung_fimc_driverdata *)
1317                 platform_get_device_id(pdev)->driver_data;
1318
1319         if (pdev->id >= drv_data->devs_cnt) {
1320                 dev_err(&pdev->dev, "Invalid platform device id: %d\n",
1321                         pdev->id);
1322                 return -EINVAL;
1323         }
1324
1325         fimc = kzalloc(sizeof(struct fimc_dev), GFP_KERNEL);
1326         if (!fimc)
1327                 return -ENOMEM;
1328
1329         fimc->id = pdev->id;
1330         fimc->variant = drv_data->variant[fimc->id];
1331         fimc->pdev = pdev;
1332         fimc->state = ST_IDLE;
1333
1334         spin_lock_init(&fimc->irqlock);
1335         spin_lock_init(&fimc->slock);
1336
1337         mutex_init(&fimc->lock);
1338
1339         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1340         if (!res) {
1341                 dev_err(&pdev->dev, "failed to find the registers\n");
1342                 ret = -ENOENT;
1343                 goto err_info;
1344         }
1345
1346         fimc->regs_res = request_mem_region(res->start, resource_size(res),
1347                         dev_name(&pdev->dev));
1348         if (!fimc->regs_res) {
1349                 dev_err(&pdev->dev, "failed to obtain register region\n");
1350                 ret = -ENOENT;
1351                 goto err_info;
1352         }
1353
1354         fimc->regs = ioremap(res->start, resource_size(res));
1355         if (!fimc->regs) {
1356                 dev_err(&pdev->dev, "failed to map registers\n");
1357                 ret = -ENXIO;
1358                 goto err_req_region;
1359         }
1360
1361         ret = fimc_clk_get(fimc);
1362         if (ret)
1363                 goto err_regs_unmap;
1364
1365         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1366         if (!res) {
1367                 dev_err(&pdev->dev, "failed to get IRQ resource\n");
1368                 ret = -ENXIO;
1369                 goto err_clk;
1370         }
1371         fimc->irq = res->start;
1372
1373         fimc_hw_reset(fimc);
1374
1375         ret = request_irq(fimc->irq, fimc_isr, 0, pdev->name, fimc);
1376         if (ret) {
1377                 dev_err(&pdev->dev, "failed to install irq (%d)\n", ret);
1378                 goto err_clk;
1379         }
1380
1381         ret = fimc_register_m2m_device(fimc);
1382         if (ret)
1383                 goto err_irq;
1384
1385         dev_dbg(&pdev->dev, "%s(): fimc-%d registered successfully\n",
1386                 __func__, fimc->id);
1387
1388         return 0;
1389
1390 err_irq:
1391         free_irq(fimc->irq, fimc);
1392 err_clk:
1393         fimc_clk_release(fimc);
1394 err_regs_unmap:
1395         iounmap(fimc->regs);
1396 err_req_region:
1397         release_resource(fimc->regs_res);
1398         kfree(fimc->regs_res);
1399 err_info:
1400         kfree(fimc);
1401
1402         return ret;
1403 }
1404
1405 static int __devexit fimc_remove(struct platform_device *pdev)
1406 {
1407         struct fimc_dev *fimc =
1408                 (struct fimc_dev *)platform_get_drvdata(pdev);
1409
1410         free_irq(fimc->irq, fimc);
1411         fimc_hw_reset(fimc);
1412
1413         fimc_unregister_m2m_device(fimc);
1414         fimc_clk_release(fimc);
1415         iounmap(fimc->regs);
1416         release_resource(fimc->regs_res);
1417         kfree(fimc->regs_res);
1418         kfree(fimc);
1419
1420         dev_info(&pdev->dev, "%s driver unloaded\n", pdev->name);
1421         return 0;
1422 }
1423
1424 static struct samsung_fimc_variant fimc01_variant_s5p = {
1425         .has_inp_rot    = 1,
1426         .has_out_rot    = 1,
1427         .min_inp_pixsize = 16,
1428         .min_out_pixsize = 16,
1429
1430         .scaler_en_w    = 3264,
1431         .scaler_dis_w   = 8192,
1432         .in_rot_en_h    = 1920,
1433         .in_rot_dis_w   = 8192,
1434         .out_rot_en_w   = 1920,
1435         .out_rot_dis_w  = 4224,
1436 };
1437
1438 static struct samsung_fimc_variant fimc2_variant_s5p = {
1439         .min_inp_pixsize = 16,
1440         .min_out_pixsize = 16,
1441
1442         .scaler_en_w    = 4224,
1443         .scaler_dis_w   = 8192,
1444         .in_rot_en_h    = 1920,
1445         .in_rot_dis_w   = 8192,
1446         .out_rot_en_w   = 1920,
1447         .out_rot_dis_w  = 4224,
1448 };
1449
1450 static struct samsung_fimc_variant fimc01_variant_s5pv210 = {
1451         .pix_hoff       = 1,
1452         .has_inp_rot    = 1,
1453         .has_out_rot    = 1,
1454         .min_inp_pixsize = 16,
1455         .min_out_pixsize = 16,
1456
1457         .scaler_en_w    = 4224,
1458         .scaler_dis_w   = 8192,
1459         .in_rot_en_h    = 1920,
1460         .in_rot_dis_w   = 8192,
1461         .out_rot_en_w   = 1920,
1462         .out_rot_dis_w  = 4224,
1463 };
1464
1465 static struct samsung_fimc_variant fimc2_variant_s5pv210 = {
1466         .pix_hoff        = 1,
1467         .min_inp_pixsize = 16,
1468         .min_out_pixsize = 16,
1469
1470         .scaler_en_w    = 1920,
1471         .scaler_dis_w   = 8192,
1472         .in_rot_en_h    = 1280,
1473         .in_rot_dis_w   = 8192,
1474         .out_rot_en_w   = 1280,
1475         .out_rot_dis_w  = 1920,
1476 };
1477
1478 static struct samsung_fimc_driverdata fimc_drvdata_s5p = {
1479         .variant = {
1480                 [0] = &fimc01_variant_s5p,
1481                 [1] = &fimc01_variant_s5p,
1482                 [2] = &fimc2_variant_s5p,
1483         },
1484         .devs_cnt = 3
1485 };
1486
1487 static struct samsung_fimc_driverdata fimc_drvdata_s5pv210 = {
1488         .variant = {
1489                 [0] = &fimc01_variant_s5pv210,
1490                 [1] = &fimc01_variant_s5pv210,
1491                 [2] = &fimc2_variant_s5pv210,
1492         },
1493         .devs_cnt = 3
1494 };
1495
1496 static struct platform_device_id fimc_driver_ids[] = {
1497         {
1498                 .name           = "s5p-fimc",
1499                 .driver_data    = (unsigned long)&fimc_drvdata_s5p,
1500         }, {
1501                 .name           = "s5pv210-fimc",
1502                 .driver_data    = (unsigned long)&fimc_drvdata_s5pv210,
1503         },
1504         {},
1505 };
1506 MODULE_DEVICE_TABLE(platform, fimc_driver_ids);
1507
1508 static struct platform_driver fimc_driver = {
1509         .probe          = fimc_probe,
1510         .remove = __devexit_p(fimc_remove),
1511         .id_table       = fimc_driver_ids,
1512         .driver = {
1513                 .name   = MODULE_NAME,
1514                 .owner  = THIS_MODULE,
1515         }
1516 };
1517
1518 static int __init fimc_init(void)
1519 {
1520         int ret = platform_driver_register(&fimc_driver);
1521         if (ret)
1522                 err("platform_driver_register failed: %d\n", ret);
1523         return ret;
1524 }
1525
1526 static void __exit fimc_exit(void)
1527 {
1528         platform_driver_unregister(&fimc_driver);
1529 }
1530
1531 module_init(fimc_init);
1532 module_exit(fimc_exit);
1533
1534 MODULE_AUTHOR("Sylwester Nawrocki, s.nawrocki@samsung.com");
1535 MODULE_DESCRIPTION("S3C/S5P FIMC (video postprocessor) driver");
1536 MODULE_LICENSE("GPL");