projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] Stop using linux/version.h on the remaining video drivers
[deliverable/linux.git] / drivers / media / video / s5p-fimc / fimc-core.c
1 /*
2 * Samsung S5P/EXYNOS4 SoC series camera interface (video postprocessor) driver
3 *
4 * Copyright (C) 2010-2011 Samsung Electronics Co., Ltd.
5 * Contact: Sylwester Nawrocki, <s.nawrocki@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation, either version 2 of the License,
10 * or (at your option) any later version.
11 */
12
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/bug.h>
18 #include <linux/interrupt.h>
19 #include <linux/device.h>
20 #include <linux/platform_device.h>
21 #include <linux/list.h>
22 #include <linux/io.h>
23 #include <linux/slab.h>
24 #include <linux/clk.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/videobuf2-core.h>
27 #include <media/videobuf2-dma-contig.h>
28
29 #include "fimc-core.h"
30
31 static char *fimc_clocks[MAX_FIMC_CLOCKS] = {
32 "sclk_fimc", "fimc", "sclk_cam"
33 };
34
35 static struct fimc_fmt fimc_formats[] = {
36 {
37 .name = "RGB565",
38 .fourcc = V4L2_PIX_FMT_RGB565X,
39 .depth = { 16 },
40 .color = S5P_FIMC_RGB565,
41 .memplanes = 1,
42 .colplanes = 1,
43 .flags = FMT_FLAGS_M2M,
44 }, {
45 .name = "BGR666",
46 .fourcc = V4L2_PIX_FMT_BGR666,
47 .depth = { 32 },
48 .color = S5P_FIMC_RGB666,
49 .memplanes = 1,
50 .colplanes = 1,
51 .flags = FMT_FLAGS_M2M,
52 }, {
53 .name = "XRGB-8-8-8-8, 32 bpp",
54 .fourcc = V4L2_PIX_FMT_RGB32,
55 .depth = { 32 },
56 .color = S5P_FIMC_RGB888,
57 .memplanes = 1,
58 .colplanes = 1,
59 .flags = FMT_FLAGS_M2M,
60 }, {
61 .name = "YUV 4:2:2 packed, YCbYCr",
62 .fourcc = V4L2_PIX_FMT_YUYV,
63 .depth = { 16 },
64 .color = S5P_FIMC_YCBYCR422,
65 .memplanes = 1,
66 .colplanes = 1,
67 .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
68 .flags = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
69 }, {
70 .name = "YUV 4:2:2 packed, CbYCrY",
71 .fourcc = V4L2_PIX_FMT_UYVY,
72 .depth = { 16 },
73 .color = S5P_FIMC_CBYCRY422,
74 .memplanes = 1,
75 .colplanes = 1,
76 .mbus_code = V4L2_MBUS_FMT_UYVY8_2X8,
77 .flags = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
78 }, {
79 .name = "YUV 4:2:2 packed, CrYCbY",
80 .fourcc = V4L2_PIX_FMT_VYUY,
81 .depth = { 16 },
82 .color = S5P_FIMC_CRYCBY422,
83 .memplanes = 1,
84 .colplanes = 1,
85 .mbus_code = V4L2_MBUS_FMT_VYUY8_2X8,
86 .flags = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
87 }, {
88 .name = "YUV 4:2:2 packed, YCrYCb",
89 .fourcc = V4L2_PIX_FMT_YVYU,
90 .depth = { 16 },
91 .color = S5P_FIMC_YCRYCB422,
92 .memplanes = 1,
93 .colplanes = 1,
94 .mbus_code = V4L2_MBUS_FMT_YVYU8_2X8,
95 .flags = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
96 }, {
97 .name = "YUV 4:2:2 planar, Y/Cb/Cr",
98 .fourcc = V4L2_PIX_FMT_YUV422P,
99 .depth = { 12 },
100 .color = S5P_FIMC_YCBYCR422,
101 .memplanes = 1,
102 .colplanes = 3,
103 .flags = FMT_FLAGS_M2M,
104 }, {
105 .name = "YUV 4:2:2 planar, Y/CbCr",
106 .fourcc = V4L2_PIX_FMT_NV16,
107 .depth = { 16 },
108 .color = S5P_FIMC_YCBYCR422,
109 .memplanes = 1,
110 .colplanes = 2,
111 .flags = FMT_FLAGS_M2M,
112 }, {
113 .name = "YUV 4:2:2 planar, Y/CrCb",
114 .fourcc = V4L2_PIX_FMT_NV61,
115 .depth = { 16 },
116 .color = S5P_FIMC_YCRYCB422,
117 .memplanes = 1,
118 .colplanes = 2,
119 .flags = FMT_FLAGS_M2M,
120 }, {
121 .name = "YUV 4:2:0 planar, YCbCr",
122 .fourcc = V4L2_PIX_FMT_YUV420,
123 .depth = { 12 },
124 .color = S5P_FIMC_YCBCR420,
125 .memplanes = 1,
126 .colplanes = 3,
127 .flags = FMT_FLAGS_M2M,
128 }, {
129 .name = "YUV 4:2:0 planar, Y/CbCr",
130 .fourcc = V4L2_PIX_FMT_NV12,
131 .depth = { 12 },
132 .color = S5P_FIMC_YCBCR420,
133 .memplanes = 1,
134 .colplanes = 2,
135 .flags = FMT_FLAGS_M2M,
136 }, {
137 .name = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr",
138 .fourcc = V4L2_PIX_FMT_NV12M,
139 .color = S5P_FIMC_YCBCR420,
140 .depth = { 8, 4 },
141 .memplanes = 2,
142 .colplanes = 2,
143 .flags = FMT_FLAGS_M2M,
144 }, {
145 .name = "YUV 4:2:0 non-contiguous 3-planar, Y/Cb/Cr",
146 .fourcc = V4L2_PIX_FMT_YUV420M,
147 .color = S5P_FIMC_YCBCR420,
148 .depth = { 8, 2, 2 },
149 .memplanes = 3,
150 .colplanes = 3,
151 .flags = FMT_FLAGS_M2M,
152 }, {
153 .name = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr, tiled",
154 .fourcc = V4L2_PIX_FMT_NV12MT,
155 .color = S5P_FIMC_YCBCR420,
156 .depth = { 8, 4 },
157 .memplanes = 2,
158 .colplanes = 2,
159 .flags = FMT_FLAGS_M2M,
160 },
161 };
162
163 static struct v4l2_queryctrl fimc_ctrls[] = {
164 {
165 .id = V4L2_CID_HFLIP,
166 .type = V4L2_CTRL_TYPE_BOOLEAN,
167 .name = "Horizontal flip",
168 .minimum = 0,
169 .maximum = 1,
170 .default_value = 0,
171 }, {
172 .id = V4L2_CID_VFLIP,
173 .type = V4L2_CTRL_TYPE_BOOLEAN,
174 .name = "Vertical flip",
175 .minimum = 0,
176 .maximum = 1,
177 .default_value = 0,
178 }, {
179 .id = V4L2_CID_ROTATE,
180 .type = V4L2_CTRL_TYPE_INTEGER,
181 .name = "Rotation (CCW)",
182 .minimum = 0,
183 .maximum = 270,
184 .step = 90,
185 .default_value = 0,
186 },
187 };
188
189
190 static struct v4l2_queryctrl *get_ctrl(int id)
191 {
192 int i;
193
194 for (i = 0; i < ARRAY_SIZE(fimc_ctrls); ++i)
195 if (id == fimc_ctrls[i].id)
196 return &fimc_ctrls[i];
197 return NULL;
198 }
199
200 int fimc_check_scaler_ratio(int sw, int sh, int dw, int dh, int rot)
201 {
202 int tx, ty;
203
204 if (rot == 90 || rot == 270) {
205 ty = dw;
206 tx = dh;
207 } else {
208 tx = dw;
209 ty = dh;
210 }
211
212 if ((sw >= SCALER_MAX_HRATIO * tx) || (sh >= SCALER_MAX_VRATIO * ty))
213 return -EINVAL;
214
215 return 0;
216 }
217
218 static int fimc_get_scaler_factor(u32 src, u32 tar, u32 *ratio, u32 *shift)
219 {
220 u32 sh = 6;
221
222 if (src >= 64 * tar)
223 return -EINVAL;
224
225 while (sh--) {
226 u32 tmp = 1 << sh;
227 if (src >= tar * tmp) {
228 *shift = sh, *ratio = tmp;
229 return 0;
230 }
231 }
232 *shift = 0, *ratio = 1;
233 return 0;
234 }
235
236 int fimc_set_scaler_info(struct fimc_ctx *ctx)
237 {
238 struct fimc_scaler *sc = &ctx->scaler;
239 struct fimc_frame *s_frame = &ctx->s_frame;
240 struct fimc_frame *d_frame = &ctx->d_frame;
241 struct samsung_fimc_variant *variant = ctx->fimc_dev->variant;
242 int tx, ty, sx, sy;
243 int ret;
244
245 if (ctx->rotation == 90 || ctx->rotation == 270) {
246 ty = d_frame->width;
247 tx = d_frame->height;
248 } else {
249 tx = d_frame->width;
250 ty = d_frame->height;
251 }
252 if (tx <= 0 || ty <= 0) {
253 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev,
254 "invalid target size: %d x %d", tx, ty);
255 return -EINVAL;
256 }
257
258 sx = s_frame->width;
259 sy = s_frame->height;
260 if (sx <= 0 || sy <= 0) {
261 err("invalid source size: %d x %d", sx, sy);
262 return -EINVAL;
263 }
264 sc->real_width = sx;
265 sc->real_height = sy;
266
267 ret = fimc_get_scaler_factor(sx, tx, &sc->pre_hratio, &sc->hfactor);
268 if (ret)
269 return ret;
270
271 ret = fimc_get_scaler_factor(sy, ty, &sc->pre_vratio, &sc->vfactor);
272 if (ret)
273 return ret;
274
275 sc->pre_dst_width = sx / sc->pre_hratio;
276 sc->pre_dst_height = sy / sc->pre_vratio;
277
278 if (variant->has_mainscaler_ext) {
279 sc->main_hratio = (sx << 14) / (tx << sc->hfactor);
280 sc->main_vratio = (sy << 14) / (ty << sc->vfactor);
281 } else {
282 sc->main_hratio = (sx << 8) / (tx << sc->hfactor);
283 sc->main_vratio = (sy << 8) / (ty << sc->vfactor);
284
285 }
286
287 sc->scaleup_h = (tx >= sx) ? 1 : 0;
288 sc->scaleup_v = (ty >= sy) ? 1 : 0;
289
290 /* check to see if input and output size/format differ */
291 if (s_frame->fmt->color == d_frame->fmt->color
292 && s_frame->width == d_frame->width
293 && s_frame->height == d_frame->height)
294 sc->copy_mode = 1;
295 else
296 sc->copy_mode = 0;
297
298 return 0;
299 }
300
301 static void fimc_m2m_job_finish(struct fimc_ctx *ctx, int vb_state)
302 {
303 struct vb2_buffer *src_vb, *dst_vb;
304 struct fimc_dev *fimc = ctx->fimc_dev;
305
306 if (!ctx || !ctx->m2m_ctx)
307 return;
308
309 src_vb = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
310 dst_vb = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
311
312 if (src_vb && dst_vb) {
313 v4l2_m2m_buf_done(src_vb, vb_state);
314 v4l2_m2m_buf_done(dst_vb, vb_state);
315 v4l2_m2m_job_finish(fimc->m2m.m2m_dev, ctx->m2m_ctx);
316 }
317 }
318
319 /* Complete the transaction which has been scheduled for execution. */
320 static void fimc_m2m_shutdown(struct fimc_ctx *ctx)
321 {
322 struct fimc_dev *fimc = ctx->fimc_dev;
323 int ret;
324
325 if (!fimc_m2m_pending(fimc))
326 return;
327
328 fimc_ctx_state_lock_set(FIMC_CTX_SHUT, ctx);
329
330 ret = wait_event_timeout(fimc->irq_queue,
331 !fimc_ctx_state_is_set(FIMC_CTX_SHUT, ctx),
332 FIMC_SHUTDOWN_TIMEOUT);
333 /*
334 * In case of a timeout the buffers are not released in the interrupt
335 * handler so return them here with the error flag set, if there are
336 * any on the queue.
337 */
338 if (ret == 0)
339 fimc_m2m_job_finish(ctx, VB2_BUF_STATE_ERROR);
340 }
341
342 static int stop_streaming(struct vb2_queue *q)
343 {
344 struct fimc_ctx *ctx = q->drv_priv;
345
346 fimc_m2m_shutdown(ctx);
347
348 return 0;
349 }
350
351 static void fimc_capture_irq_handler(struct fimc_dev *fimc)
352 {
353 struct fimc_vid_cap *cap = &fimc->vid_cap;
354 struct fimc_vid_buffer *v_buf;
355 struct timeval *tv;
356 struct timespec ts;
357
358 if (!list_empty(&cap->active_buf_q) &&
359 test_bit(ST_CAPT_RUN, &fimc->state)) {
360 ktime_get_real_ts(&ts);
361
362 v_buf = active_queue_pop(cap);
363
364 tv = &v_buf->vb.v4l2_buf.timestamp;
365 tv->tv_sec = ts.tv_sec;
366 tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
367 v_buf->vb.v4l2_buf.sequence = cap->frame_count++;
368
369 vb2_buffer_done(&v_buf->vb, VB2_BUF_STATE_DONE);
370 }
371
372 if (test_and_clear_bit(ST_CAPT_SHUT, &fimc->state)) {
373 wake_up(&fimc->irq_queue);
374 return;
375 }
376
377 if (!list_empty(&cap->pending_buf_q)) {
378
379 v_buf = pending_queue_pop(cap);
380 fimc_hw_set_output_addr(fimc, &v_buf->paddr, cap->buf_index);
381 v_buf->index = cap->buf_index;
382
383 /* Move the buffer to the capture active queue */
384 active_queue_add(cap, v_buf);
385
386 dbg("next frame: %d, done frame: %d",
387 fimc_hw_get_frame_index(fimc), v_buf->index);
388
389 if (++cap->buf_index >= FIMC_MAX_OUT_BUFS)
390 cap->buf_index = 0;
391 }
392
393 if (cap->active_buf_cnt == 0) {
394 clear_bit(ST_CAPT_RUN, &fimc->state);
395
396 if (++cap->buf_index >= FIMC_MAX_OUT_BUFS)
397 cap->buf_index = 0;
398 } else {
399 set_bit(ST_CAPT_RUN, &fimc->state);
400 }
401
402 dbg("frame: %d, active_buf_cnt: %d",
403 fimc_hw_get_frame_index(fimc), cap->active_buf_cnt);
404 }
405
406 static irqreturn_t fimc_isr(int irq, void *priv)
407 {
408 struct fimc_dev *fimc = priv;
409 struct fimc_vid_cap *cap = &fimc->vid_cap;
410 struct fimc_ctx *ctx;
411
412 fimc_hw_clear_irq(fimc);
413
414 if (test_and_clear_bit(ST_M2M_PEND, &fimc->state)) {
415 ctx = v4l2_m2m_get_curr_priv(fimc->m2m.m2m_dev);
416 if (ctx != NULL) {
417 fimc_m2m_job_finish(ctx, VB2_BUF_STATE_DONE);
418
419 spin_lock(&ctx->slock);
420 if (ctx->state & FIMC_CTX_SHUT) {
421 ctx->state &= ~FIMC_CTX_SHUT;
422 wake_up(&fimc->irq_queue);
423 }
424 spin_unlock(&ctx->slock);
425 }
426
427 return IRQ_HANDLED;
428 }
429
430 spin_lock(&fimc->slock);
431
432 if (test_bit(ST_CAPT_PEND, &fimc->state)) {
433 fimc_capture_irq_handler(fimc);
434
435 if (cap->active_buf_cnt == 1) {
436 fimc_deactivate_capture(fimc);
437 clear_bit(ST_CAPT_STREAM, &fimc->state);
438 }
439 }
440
441 spin_unlock(&fimc->slock);
442 return IRQ_HANDLED;
443 }
444
445 /* The color format (colplanes, memplanes) must be already configured. */
446 int fimc_prepare_addr(struct fimc_ctx *ctx, struct vb2_buffer *vb,
447 struct fimc_frame *frame, struct fimc_addr *paddr)
448 {
449 int ret = 0;
450 u32 pix_size;
451
452 if (vb == NULL || frame == NULL)
453 return -EINVAL;
454
455 pix_size = frame->width * frame->height;
456
457 dbg("memplanes= %d, colplanes= %d, pix_size= %d",
458 frame->fmt->memplanes, frame->fmt->colplanes, pix_size);
459
460 paddr->y = vb2_dma_contig_plane_paddr(vb, 0);
461
462 if (frame->fmt->memplanes == 1) {
463 switch (frame->fmt->colplanes) {
464 case 1:
465 paddr->cb = 0;
466 paddr->cr = 0;
467 break;
468 case 2:
469 /* decompose Y into Y/Cb */
470 paddr->cb = (u32)(paddr->y + pix_size);
471 paddr->cr = 0;
472 break;
473 case 3:
474 paddr->cb = (u32)(paddr->y + pix_size);
475 /* decompose Y into Y/Cb/Cr */
476 if (S5P_FIMC_YCBCR420 == frame->fmt->color)
477 paddr->cr = (u32)(paddr->cb
478 + (pix_size >> 2));
479 else /* 422 */
480 paddr->cr = (u32)(paddr->cb
481 + (pix_size >> 1));
482 break;
483 default:
484 return -EINVAL;
485 }
486 } else {
487 if (frame->fmt->memplanes >= 2)
488 paddr->cb = vb2_dma_contig_plane_paddr(vb, 1);
489
490 if (frame->fmt->memplanes == 3)
491 paddr->cr = vb2_dma_contig_plane_paddr(vb, 2);
492 }
493
494 dbg("PHYS_ADDR: y= 0x%X cb= 0x%X cr= 0x%X ret= %d",
495 paddr->y, paddr->cb, paddr->cr, ret);
496
497 return ret;
498 }
499
500 /* Set order for 1 and 2 plane YCBCR 4:2:2 formats. */
501 static void fimc_set_yuv_order(struct fimc_ctx *ctx)
502 {
503 /* The one only mode supported in SoC. */
504 ctx->in_order_2p = S5P_FIMC_LSB_CRCB;
505 ctx->out_order_2p = S5P_FIMC_LSB_CRCB;
506
507 /* Set order for 1 plane input formats. */
508 switch (ctx->s_frame.fmt->color) {
509 case S5P_FIMC_YCRYCB422:
510 ctx->in_order_1p = S5P_MSCTRL_ORDER422_CBYCRY;
511 break;
512 case S5P_FIMC_CBYCRY422:
513 ctx->in_order_1p = S5P_MSCTRL_ORDER422_YCRYCB;
514 break;
515 case S5P_FIMC_CRYCBY422:
516 ctx->in_order_1p = S5P_MSCTRL_ORDER422_YCBYCR;
517 break;
518 case S5P_FIMC_YCBYCR422:
519 default:
520 ctx->in_order_1p = S5P_MSCTRL_ORDER422_CRYCBY;
521 break;
522 }
523 dbg("ctx->in_order_1p= %d", ctx->in_order_1p);
524
525 switch (ctx->d_frame.fmt->color) {
526 case S5P_FIMC_YCRYCB422:
527 ctx->out_order_1p = S5P_CIOCTRL_ORDER422_CBYCRY;
528 break;
529 case S5P_FIMC_CBYCRY422:
530 ctx->out_order_1p = S5P_CIOCTRL_ORDER422_YCRYCB;
531 break;
532 case S5P_FIMC_CRYCBY422:
533 ctx->out_order_1p = S5P_CIOCTRL_ORDER422_YCBYCR;
534 break;
535 case S5P_FIMC_YCBYCR422:
536 default:
537 ctx->out_order_1p = S5P_CIOCTRL_ORDER422_CRYCBY;
538 break;
539 }
540 dbg("ctx->out_order_1p= %d", ctx->out_order_1p);
541 }
542
543 static void fimc_prepare_dma_offset(struct fimc_ctx *ctx, struct fimc_frame *f)
544 {
545 struct samsung_fimc_variant *variant = ctx->fimc_dev->variant;
546 u32 i, depth = 0;
547
548 for (i = 0; i < f->fmt->colplanes; i++)
549 depth += f->fmt->depth[i];
550
551 f->dma_offset.y_h = f->offs_h;
552 if (!variant->pix_hoff)
553 f->dma_offset.y_h *= (depth >> 3);
554
555 f->dma_offset.y_v = f->offs_v;
556
557 f->dma_offset.cb_h = f->offs_h;
558 f->dma_offset.cb_v = f->offs_v;
559
560 f->dma_offset.cr_h = f->offs_h;
561 f->dma_offset.cr_v = f->offs_v;
562
563 if (!variant->pix_hoff) {
564 if (f->fmt->colplanes == 3) {
565 f->dma_offset.cb_h >>= 1;
566 f->dma_offset.cr_h >>= 1;
567 }
568 if (f->fmt->color == S5P_FIMC_YCBCR420) {
569 f->dma_offset.cb_v >>= 1;
570 f->dma_offset.cr_v >>= 1;
571 }
572 }
573
574 dbg("in_offset: color= %d, y_h= %d, y_v= %d",
575 f->fmt->color, f->dma_offset.y_h, f->dma_offset.y_v);
576 }
577
578 /**
579 * fimc_prepare_config - check dimensions, operation and color mode
580 * and pre-calculate offset and the scaling coefficients.
581 *
582 * @ctx: hardware context information
583 * @flags: flags indicating which parameters to check/update
584 *
585 * Return: 0 if dimensions are valid or non zero otherwise.
586 */
587 int fimc_prepare_config(struct fimc_ctx *ctx, u32 flags)
588 {
589 struct fimc_frame *s_frame, *d_frame;
590 struct vb2_buffer *vb = NULL;
591 int ret = 0;
592
593 s_frame = &ctx->s_frame;
594 d_frame = &ctx->d_frame;
595
596 if (flags & FIMC_PARAMS) {
597 /* Prepare the DMA offset ratios for scaler. */
598 fimc_prepare_dma_offset(ctx, &ctx->s_frame);
599 fimc_prepare_dma_offset(ctx, &ctx->d_frame);
600
601 if (s_frame->height > (SCALER_MAX_VRATIO * d_frame->height) ||
602 s_frame->width > (SCALER_MAX_HRATIO * d_frame->width)) {
603 err("out of scaler range");
604 return -EINVAL;
605 }
606 fimc_set_yuv_order(ctx);
607 }
608
609 /* Input DMA mode is not allowed when the scaler is disabled. */
610 ctx->scaler.enabled = 1;
611
612 if (flags & FIMC_SRC_ADDR) {
613 vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
614 ret = fimc_prepare_addr(ctx, vb, s_frame, &s_frame->paddr);
615 if (ret)
616 return ret;
617 }
618
619 if (flags & FIMC_DST_ADDR) {
620 vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
621 ret = fimc_prepare_addr(ctx, vb, d_frame, &d_frame->paddr);
622 }
623
624 return ret;
625 }
626
627 static void fimc_dma_run(void *priv)
628 {
629 struct fimc_ctx *ctx = priv;
630 struct fimc_dev *fimc;
631 unsigned long flags;
632 u32 ret;
633
634 if (WARN(!ctx, "null hardware context\n"))
635 return;
636
637 fimc = ctx->fimc_dev;
638
639 spin_lock_irqsave(&ctx->slock, flags);
640 set_bit(ST_M2M_PEND, &fimc->state);
641
642 ctx->state |= (FIMC_SRC_ADDR | FIMC_DST_ADDR);
643 ret = fimc_prepare_config(ctx, ctx->state);
644 if (ret)
645 goto dma_unlock;
646
647 /* Reconfigure hardware if the context has changed. */
648 if (fimc->m2m.ctx != ctx) {
649 ctx->state |= FIMC_PARAMS;
650 fimc->m2m.ctx = ctx;
651 }
652
653 spin_lock(&fimc->slock);
654 fimc_hw_set_input_addr(fimc, &ctx->s_frame.paddr);
655
656 if (ctx->state & FIMC_PARAMS) {
657 fimc_hw_set_input_path(ctx);
658 fimc_hw_set_in_dma(ctx);
659 ret = fimc_set_scaler_info(ctx);
660 if (ret) {
661 spin_unlock(&fimc->slock);
662 goto dma_unlock;
663 }
664 fimc_hw_set_prescaler(ctx);
665 fimc_hw_set_mainscaler(ctx);
666 fimc_hw_set_target_format(ctx);
667 fimc_hw_set_rotation(ctx);
668 fimc_hw_set_effect(ctx);
669 }
670
671 fimc_hw_set_output_path(ctx);
672 if (ctx->state & (FIMC_DST_ADDR | FIMC_PARAMS))
673 fimc_hw_set_output_addr(fimc, &ctx->d_frame.paddr, -1);
674
675 if (ctx->state & FIMC_PARAMS)
676 fimc_hw_set_out_dma(ctx);
677
678 fimc_activate_capture(ctx);
679
680 ctx->state &= (FIMC_CTX_M2M | FIMC_CTX_CAP |
681 FIMC_SRC_FMT | FIMC_DST_FMT);
682 fimc_hw_activate_input_dma(fimc, true);
683 spin_unlock(&fimc->slock);
684
685 dma_unlock:
686 spin_unlock_irqrestore(&ctx->slock, flags);
687 }
688
689 static void fimc_job_abort(void *priv)
690 {
691 fimc_m2m_shutdown(priv);
692 }
693
694 static int fimc_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers,
695 unsigned int *num_planes, unsigned long sizes[],
696 void *allocators[])
697 {
698 struct fimc_ctx *ctx = vb2_get_drv_priv(vq);
699 struct fimc_frame *f;
700 int i;
701
702 f = ctx_get_frame(ctx, vq->type);
703 if (IS_ERR(f))
704 return PTR_ERR(f);
705 /*
706 * Return number of non-contigous planes (plane buffers)
707 * depending on the configured color format.
708 */
709 if (!f->fmt)
710 return -EINVAL;
711
712 *num_planes = f->fmt->memplanes;
713 for (i = 0; i < f->fmt->memplanes; i++) {
714 sizes[i] = (f->f_width * f->f_height * f->fmt->depth[i]) / 8;
715 allocators[i] = ctx->fimc_dev->alloc_ctx;
716 }
717 return 0;
718 }
719
720 static int fimc_buf_prepare(struct vb2_buffer *vb)
721 {
722 struct fimc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
723 struct fimc_frame *frame;
724 int i;
725
726 frame = ctx_get_frame(ctx, vb->vb2_queue->type);
727 if (IS_ERR(frame))
728 return PTR_ERR(frame);
729
730 for (i = 0; i < frame->fmt->memplanes; i++)
731 vb2_set_plane_payload(vb, i, frame->payload[i]);
732
733 return 0;
734 }
735
736 static void fimc_buf_queue(struct vb2_buffer *vb)
737 {
738 struct fimc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
739
740 dbg("ctx: %p, ctx->state: 0x%x", ctx, ctx->state);
741
742 if (ctx->m2m_ctx)
743 v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
744 }
745
746 static void fimc_lock(struct vb2_queue *vq)
747 {
748 struct fimc_ctx *ctx = vb2_get_drv_priv(vq);
749 mutex_lock(&ctx->fimc_dev->lock);
750 }
751
752 static void fimc_unlock(struct vb2_queue *vq)
753 {
754 struct fimc_ctx *ctx = vb2_get_drv_priv(vq);
755 mutex_unlock(&ctx->fimc_dev->lock);
756 }
757
758 static struct vb2_ops fimc_qops = {
759 .queue_setup = fimc_queue_setup,
760 .buf_prepare = fimc_buf_prepare,
761 .buf_queue = fimc_buf_queue,
762 .wait_prepare = fimc_unlock,
763 .wait_finish = fimc_lock,
764 .stop_streaming = stop_streaming,
765 };
766
767 static int fimc_m2m_querycap(struct file *file, void *priv,
768 struct v4l2_capability *cap)
769 {
770 struct fimc_ctx *ctx = file->private_data;
771 struct fimc_dev *fimc = ctx->fimc_dev;
772
773 strncpy(cap->driver, fimc->pdev->name, sizeof(cap->driver) - 1);
774 strncpy(cap->card, fimc->pdev->name, sizeof(cap->card) - 1);
775 cap->bus_info[0] = 0;
776 cap->capabilities = V4L2_CAP_STREAMING |
777 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
778 V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_OUTPUT_MPLANE;
779
780 return 0;
781 }
782
783 int fimc_vidioc_enum_fmt_mplane(struct file *file, void *priv,
784 struct v4l2_fmtdesc *f)
785 {
786 struct fimc_fmt *fmt;
787
788 if (f->index >= ARRAY_SIZE(fimc_formats))
789 return -EINVAL;
790
791 fmt = &fimc_formats[f->index];
792 strncpy(f->description, fmt->name, sizeof(f->description) - 1);
793 f->pixelformat = fmt->fourcc;
794
795 return 0;
796 }
797
798 int fimc_vidioc_g_fmt_mplane(struct file *file, void *priv,
799 struct v4l2_format *f)
800 {
801 struct fimc_ctx *ctx = priv;
802 struct fimc_frame *frame;
803 struct v4l2_pix_format_mplane *pixm;
804 int i;
805
806 frame = ctx_get_frame(ctx, f->type);
807 if (IS_ERR(frame))
808 return PTR_ERR(frame);
809
810 pixm = &f->fmt.pix_mp;
811
812 pixm->width = frame->width;
813 pixm->height = frame->height;
814 pixm->field = V4L2_FIELD_NONE;
815 pixm->pixelformat = frame->fmt->fourcc;
816 pixm->colorspace = V4L2_COLORSPACE_JPEG;
817 pixm->num_planes = frame->fmt->memplanes;
818
819 for (i = 0; i < pixm->num_planes; ++i) {
820 int bpl = frame->o_width;
821
822 if (frame->fmt->colplanes == 1) /* packed formats */
823 bpl = (bpl * frame->fmt->depth[0]) / 8;
824
825 pixm->plane_fmt[i].bytesperline = bpl;
826
827 pixm->plane_fmt[i].sizeimage = (frame->o_width *
828 frame->o_height * frame->fmt->depth[i]) / 8;
829 }
830
831 return 0;
832 }
833
834 struct fimc_fmt *find_format(struct v4l2_format *f, unsigned int mask)
835 {
836 struct fimc_fmt *fmt;
837 unsigned int i;
838
839 for (i = 0; i < ARRAY_SIZE(fimc_formats); ++i) {
840 fmt = &fimc_formats[i];
841 if (fmt->fourcc == f->fmt.pix_mp.pixelformat &&
842 (fmt->flags & mask))
843 break;
844 }
845
846 return (i == ARRAY_SIZE(fimc_formats)) ? NULL : fmt;
847 }
848
849 struct fimc_fmt *find_mbus_format(struct v4l2_mbus_framefmt *f,
850 unsigned int mask)
851 {
852 struct fimc_fmt *fmt;
853 unsigned int i;
854
855 for (i = 0; i < ARRAY_SIZE(fimc_formats); ++i) {
856 fmt = &fimc_formats[i];
857 if (fmt->mbus_code == f->code && (fmt->flags & mask))
858 break;
859 }
860
861 return (i == ARRAY_SIZE(fimc_formats)) ? NULL : fmt;
862 }
863
864
865 int fimc_vidioc_try_fmt_mplane(struct file *file, void *priv,
866 struct v4l2_format *f)
867 {
868 struct fimc_ctx *ctx = priv;
869 struct fimc_dev *fimc = ctx->fimc_dev;
870 struct samsung_fimc_variant *variant = fimc->variant;
871 struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
872 struct fimc_fmt *fmt;
873 u32 max_width, mod_x, mod_y, mask;
874 int i, is_output = 0;
875
876
877 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
878 if (fimc_ctx_state_is_set(FIMC_CTX_CAP, ctx))
879 return -EINVAL;
880 is_output = 1;
881 } else if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
882 return -EINVAL;
883 }
884
885 dbg("w: %d, h: %d", pix->width, pix->height);
886
887 mask = is_output ? FMT_FLAGS_M2M : FMT_FLAGS_M2M | FMT_FLAGS_CAM;
888 fmt = find_format(f, mask);
889 if (!fmt) {
890 v4l2_err(&fimc->m2m.v4l2_dev, "Fourcc format (0x%X) invalid.\n",
891 pix->pixelformat);
892 return -EINVAL;
893 }
894
895 if (pix->field == V4L2_FIELD_ANY)
896 pix->field = V4L2_FIELD_NONE;
897 else if (V4L2_FIELD_NONE != pix->field)
898 return -EINVAL;
899
900 if (is_output) {
901 max_width = variant->pix_limit->scaler_dis_w;
902 mod_x = ffs(variant->min_inp_pixsize) - 1;
903 } else {
904 max_width = variant->pix_limit->out_rot_dis_w;
905 mod_x = ffs(variant->min_out_pixsize) - 1;
906 }
907
908 if (tiled_fmt(fmt)) {
909 mod_x = 6; /* 64 x 32 pixels tile */
910 mod_y = 5;
911 } else {
912 if (fimc->id == 1 && variant->pix_hoff)
913 mod_y = fimc_fmt_is_rgb(fmt->color) ? 0 : 1;
914 else
915 mod_y = mod_x;
916 }
917
918 dbg("mod_x: %d, mod_y: %d, max_w: %d", mod_x, mod_y, max_width);
919
920 v4l_bound_align_image(&pix->width, 16, max_width, mod_x,
921 &pix->height, 8, variant->pix_limit->scaler_dis_w, mod_y, 0);
922
923 pix->num_planes = fmt->memplanes;
924 pix->colorspace = V4L2_COLORSPACE_JPEG;
925
926
927 for (i = 0; i < pix->num_planes; ++i) {
928 u32 bpl = pix->plane_fmt[i].bytesperline;
929 u32 *sizeimage = &pix->plane_fmt[i].sizeimage;
930
931 if (fmt->colplanes > 1 && (bpl == 0 || bpl < pix->width))
932 bpl = pix->width; /* Planar */
933
934 if (fmt->colplanes == 1 && /* Packed */
935 (bpl == 0 || ((bpl * 8) / fmt->depth[i]) < pix->width))
936 bpl = (pix->width * fmt->depth[0]) / 8;
937
938 if (i == 0) /* Same bytesperline for each plane. */
939 mod_x = bpl;
940
941 pix->plane_fmt[i].bytesperline = mod_x;
942 *sizeimage = (pix->width * pix->height * fmt->depth[i]) / 8;
943 }
944
945 return 0;
946 }
947
948 static int fimc_m2m_s_fmt_mplane(struct file *file, void *priv,
949 struct v4l2_format *f)
950 {
951 struct fimc_ctx *ctx = priv;
952 struct fimc_dev *fimc = ctx->fimc_dev;
953 struct vb2_queue *vq;
954 struct fimc_frame *frame;
955 struct v4l2_pix_format_mplane *pix;
956 int i, ret = 0;
957
958 ret = fimc_vidioc_try_fmt_mplane(file, priv, f);
959 if (ret)
960 return ret;
961
962 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
963
964 if (vb2_is_busy(vq)) {
965 v4l2_err(&fimc->m2m.v4l2_dev, "queue (%d) busy\n", f->type);
966 return -EBUSY;
967 }
968
969 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
970 frame = &ctx->s_frame;
971 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
972 frame = &ctx->d_frame;
973 } else {
974 v4l2_err(&fimc->m2m.v4l2_dev,
975 "Wrong buffer/video queue type (%d)\n", f->type);
976 return -EINVAL;
977 }
978
979 pix = &f->fmt.pix_mp;
980 frame->fmt = find_format(f, FMT_FLAGS_M2M);
981 if (!frame->fmt)
982 return -EINVAL;
983
984 for (i = 0; i < frame->fmt->colplanes; i++) {
985 frame->payload[i] =
986 (pix->width * pix->height * frame->fmt->depth[i]) / 8;
987 }
988
989 frame->f_width = pix->plane_fmt[0].bytesperline * 8 /
990 frame->fmt->depth[0];
991 frame->f_height = pix->height;
992 frame->width = pix->width;
993 frame->height = pix->height;
994 frame->o_width = pix->width;
995 frame->o_height = pix->height;
996 frame->offs_h = 0;
997 frame->offs_v = 0;
998
999 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1000 fimc_ctx_state_lock_set(FIMC_PARAMS | FIMC_DST_FMT, ctx);
1001 else
1002 fimc_ctx_state_lock_set(FIMC_PARAMS | FIMC_SRC_FMT, ctx);
1003
1004 dbg("f_w: %d, f_h: %d", frame->f_width, frame->f_height);
1005
1006 return 0;
1007 }
1008
1009 static int fimc_m2m_reqbufs(struct file *file, void *priv,
1010 struct v4l2_requestbuffers *reqbufs)
1011 {
1012 struct fimc_ctx *ctx = priv;
1013 return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
1014 }
1015
1016 static int fimc_m2m_querybuf(struct file *file, void *priv,
1017 struct v4l2_buffer *buf)
1018 {
1019 struct fimc_ctx *ctx = priv;
1020 return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
1021 }
1022
1023 static int fimc_m2m_qbuf(struct file *file, void *priv,
1024 struct v4l2_buffer *buf)
1025 {
1026 struct fimc_ctx *ctx = priv;
1027
1028 return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
1029 }
1030
1031 static int fimc_m2m_dqbuf(struct file *file, void *priv,
1032 struct v4l2_buffer *buf)
1033 {
1034 struct fimc_ctx *ctx = priv;
1035 return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
1036 }
1037
1038 static int fimc_m2m_streamon(struct file *file, void *priv,
1039 enum v4l2_buf_type type)
1040 {
1041 struct fimc_ctx *ctx = priv;
1042
1043 /* The source and target color format need to be set */
1044 if (V4L2_TYPE_IS_OUTPUT(type)) {
1045 if (!fimc_ctx_state_is_set(FIMC_SRC_FMT, ctx))
1046 return -EINVAL;
1047 } else if (!fimc_ctx_state_is_set(FIMC_DST_FMT, ctx)) {
1048 return -EINVAL;
1049 }
1050
1051 return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
1052 }
1053
1054 static int fimc_m2m_streamoff(struct file *file, void *priv,
1055 enum v4l2_buf_type type)
1056 {
1057 struct fimc_ctx *ctx = priv;
1058 return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
1059 }
1060
1061 int fimc_vidioc_queryctrl(struct file *file, void *priv,
1062 struct v4l2_queryctrl *qc)
1063 {
1064 struct fimc_ctx *ctx = priv;
1065 struct v4l2_queryctrl *c;
1066 int ret = -EINVAL;
1067
1068 c = get_ctrl(qc->id);
1069 if (c) {
1070 *qc = *c;
1071 return 0;
1072 }
1073
1074 if (fimc_ctx_state_is_set(FIMC_CTX_CAP, ctx)) {
1075 return v4l2_subdev_call(ctx->fimc_dev->vid_cap.sd,
1076 core, queryctrl, qc);
1077 }
1078 return ret;
1079 }
1080
1081 int fimc_vidioc_g_ctrl(struct file *file, void *priv,
1082 struct v4l2_control *ctrl)
1083 {
1084 struct fimc_ctx *ctx = priv;
1085 struct fimc_dev *fimc = ctx->fimc_dev;
1086
1087 switch (ctrl->id) {
1088 case V4L2_CID_HFLIP:
1089 ctrl->value = (FLIP_X_AXIS & ctx->flip) ? 1 : 0;
1090 break;
1091 case V4L2_CID_VFLIP:
1092 ctrl->value = (FLIP_Y_AXIS & ctx->flip) ? 1 : 0;
1093 break;
1094 case V4L2_CID_ROTATE:
1095 ctrl->value = ctx->rotation;
1096 break;
1097 default:
1098 if (fimc_ctx_state_is_set(FIMC_CTX_CAP, ctx)) {
1099 return v4l2_subdev_call(fimc->vid_cap.sd, core,
1100 g_ctrl, ctrl);
1101 } else {
1102 v4l2_err(&fimc->m2m.v4l2_dev, "Invalid control\n");
1103 return -EINVAL;
1104 }
1105 }
1106 dbg("ctrl->value= %d", ctrl->value);
1107
1108 return 0;
1109 }
1110
1111 int check_ctrl_val(struct fimc_ctx *ctx, struct v4l2_control *ctrl)
1112 {
1113 struct v4l2_queryctrl *c;
1114 c = get_ctrl(ctrl->id);
1115 if (!c)
1116 return -EINVAL;
1117
1118 if (ctrl->value < c->minimum || ctrl->value > c->maximum
1119 || (c->step != 0 && ctrl->value % c->step != 0)) {
1120 v4l2_err(&ctx->fimc_dev->m2m.v4l2_dev,
1121 "Invalid control value\n");
1122 return -ERANGE;
1123 }
1124
1125 return 0;
1126 }
1127
1128 int fimc_s_ctrl(struct fimc_ctx *ctx, struct v4l2_control *ctrl)
1129 {
1130 struct samsung_fimc_variant *variant = ctx->fimc_dev->variant;
1131 struct fimc_dev *fimc = ctx->fimc_dev;
1132 int ret = 0;
1133
1134 switch (ctrl->id) {
1135 case V4L2_CID_HFLIP:
1136 if (ctrl->value)
1137 ctx->flip |= FLIP_X_AXIS;
1138 else
1139 ctx->flip &= ~FLIP_X_AXIS;
1140 break;
1141
1142 case V4L2_CID_VFLIP:
1143 if (ctrl->value)
1144 ctx->flip |= FLIP_Y_AXIS;
1145 else
1146 ctx->flip &= ~FLIP_Y_AXIS;
1147 break;
1148
1149 case V4L2_CID_ROTATE:
1150 if (fimc_ctx_state_is_set(FIMC_DST_FMT | FIMC_SRC_FMT, ctx)) {
1151 ret = fimc_check_scaler_ratio(ctx->s_frame.width,
1152 ctx->s_frame.height, ctx->d_frame.width,
1153 ctx->d_frame.height, ctrl->value);
1154 }
1155
1156 if (ret) {
1157 v4l2_err(&fimc->m2m.v4l2_dev, "Out of scaler range\n");
1158 return -EINVAL;
1159 }
1160
1161 /* Check for the output rotator availability */
1162 if ((ctrl->value == 90 || ctrl->value == 270) &&
1163 (ctx->in_path == FIMC_DMA && !variant->has_out_rot))
1164 return -EINVAL;
1165 ctx->rotation = ctrl->value;
1166 break;
1167
1168 default:
1169 v4l2_err(&fimc->m2m.v4l2_dev, "Invalid control\n");
1170 return -EINVAL;
1171 }
1172
1173 fimc_ctx_state_lock_set(FIMC_PARAMS, ctx);
1174
1175 return 0;
1176 }
1177
1178 static int fimc_m2m_s_ctrl(struct file *file, void *priv,
1179 struct v4l2_control *ctrl)
1180 {
1181 struct fimc_ctx *ctx = priv;
1182 int ret = 0;
1183
1184 ret = check_ctrl_val(ctx, ctrl);
1185 if (ret)
1186 return ret;
1187
1188 ret = fimc_s_ctrl(ctx, ctrl);
1189 return 0;
1190 }
1191
1192 static int fimc_m2m_cropcap(struct file *file, void *fh,
1193 struct v4l2_cropcap *cr)
1194 {
1195 struct fimc_frame *frame;
1196 struct fimc_ctx *ctx = fh;
1197
1198 frame = ctx_get_frame(ctx, cr->type);
1199 if (IS_ERR(frame))
1200 return PTR_ERR(frame);
1201
1202 cr->bounds.left = 0;
1203 cr->bounds.top = 0;
1204 cr->bounds.width = frame->f_width;
1205 cr->bounds.height = frame->f_height;
1206 cr->defrect = cr->bounds;
1207
1208 return 0;
1209 }
1210
1211 static int fimc_m2m_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1212 {
1213 struct fimc_frame *frame;
1214 struct fimc_ctx *ctx = file->private_data;
1215
1216 frame = ctx_get_frame(ctx, cr->type);
1217 if (IS_ERR(frame))
1218 return PTR_ERR(frame);
1219
1220 cr->c.left = frame->offs_h;
1221 cr->c.top = frame->offs_v;
1222 cr->c.width = frame->width;
1223 cr->c.height = frame->height;
1224
1225 return 0;
1226 }
1227
1228 int fimc_try_crop(struct fimc_ctx *ctx, struct v4l2_crop *cr)
1229 {
1230 struct fimc_dev *fimc = ctx->fimc_dev;
1231 struct fimc_frame *f;
1232 u32 min_size, halign, depth = 0;
1233 bool is_capture_ctx;
1234 int i;
1235
1236 if (cr->c.top < 0 || cr->c.left < 0) {
1237 v4l2_err(&fimc->m2m.v4l2_dev,
1238 "doesn't support negative values for top & left\n");
1239 return -EINVAL;
1240 }
1241
1242 is_capture_ctx = fimc_ctx_state_is_set(FIMC_CTX_CAP, ctx);
1243
1244 if (cr->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1245 f = is_capture_ctx ? &ctx->s_frame : &ctx->d_frame;
1246 else if (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&
1247 !is_capture_ctx)
1248 f = &ctx->s_frame;
1249 else
1250 return -EINVAL;
1251
1252 min_size = (f == &ctx->s_frame) ?
1253 fimc->variant->min_inp_pixsize : fimc->variant->min_out_pixsize;
1254
1255 /* Get pixel alignment constraints. */
1256 if (is_capture_ctx) {
1257 min_size = 16;
1258 halign = 4;
1259 } else {
1260 if (fimc->id == 1 && fimc->variant->pix_hoff)
1261 halign = fimc_fmt_is_rgb(f->fmt->color) ? 0 : 1;
1262 else
1263 halign = ffs(min_size) - 1;
1264 }
1265
1266 for (i = 0; i < f->fmt->colplanes; i++)
1267 depth += f->fmt->depth[i];
1268
1269 v4l_bound_align_image(&cr->c.width, min_size, f->o_width,
1270 ffs(min_size) - 1,
1271 &cr->c.height, min_size, f->o_height,
1272 halign, 64/(ALIGN(depth, 8)));
1273
1274 /* adjust left/top if cropping rectangle is out of bounds */
1275 if (cr->c.left + cr->c.width > f->o_width)
1276 cr->c.left = f->o_width - cr->c.width;
1277 if (cr->c.top + cr->c.height > f->o_height)
1278 cr->c.top = f->o_height - cr->c.height;
1279
1280 cr->c.left = round_down(cr->c.left, min_size);
1281 cr->c.top = round_down(cr->c.top, is_capture_ctx ? 16 : 8);
1282
1283 dbg("l:%d, t:%d, w:%d, h:%d, f_w: %d, f_h: %d",
1284 cr->c.left, cr->c.top, cr->c.width, cr->c.height,
1285 f->f_width, f->f_height);
1286
1287 return 0;
1288 }
1289
1290 static int fimc_m2m_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1291 {
1292 struct fimc_ctx *ctx = file->private_data;
1293 struct fimc_dev *fimc = ctx->fimc_dev;
1294 struct fimc_frame *f;
1295 int ret;
1296
1297 ret = fimc_try_crop(ctx, cr);
1298 if (ret)
1299 return ret;
1300
1301 f = (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) ?
1302 &ctx->s_frame : &ctx->d_frame;
1303
1304 /* Check to see if scaling ratio is within supported range */
1305 if (fimc_ctx_state_is_set(FIMC_DST_FMT | FIMC_SRC_FMT, ctx)) {
1306 if (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1307 ret = fimc_check_scaler_ratio(cr->c.width, cr->c.height,
1308 ctx->d_frame.width,
1309 ctx->d_frame.height,
1310 ctx->rotation);
1311 } else {
1312 ret = fimc_check_scaler_ratio(ctx->s_frame.width,
1313 ctx->s_frame.height,
1314 cr->c.width, cr->c.height,
1315 ctx->rotation);
1316 }
1317 if (ret) {
1318 v4l2_err(&fimc->m2m.v4l2_dev, "Out of scaler range\n");
1319 return -EINVAL;
1320 }
1321 }
1322
1323 f->offs_h = cr->c.left;
1324 f->offs_v = cr->c.top;
1325 f->width = cr->c.width;
1326 f->height = cr->c.height;
1327
1328 fimc_ctx_state_lock_set(FIMC_PARAMS, ctx);
1329
1330 return 0;
1331 }
1332
1333 static const struct v4l2_ioctl_ops fimc_m2m_ioctl_ops = {
1334 .vidioc_querycap = fimc_m2m_querycap,
1335
1336 .vidioc_enum_fmt_vid_cap_mplane = fimc_vidioc_enum_fmt_mplane,
1337 .vidioc_enum_fmt_vid_out_mplane = fimc_vidioc_enum_fmt_mplane,
1338
1339 .vidioc_g_fmt_vid_cap_mplane = fimc_vidioc_g_fmt_mplane,
1340 .vidioc_g_fmt_vid_out_mplane = fimc_vidioc_g_fmt_mplane,
1341
1342 .vidioc_try_fmt_vid_cap_mplane = fimc_vidioc_try_fmt_mplane,
1343 .vidioc_try_fmt_vid_out_mplane = fimc_vidioc_try_fmt_mplane,
1344
1345 .vidioc_s_fmt_vid_cap_mplane = fimc_m2m_s_fmt_mplane,
1346 .vidioc_s_fmt_vid_out_mplane = fimc_m2m_s_fmt_mplane,
1347
1348 .vidioc_reqbufs = fimc_m2m_reqbufs,
1349 .vidioc_querybuf = fimc_m2m_querybuf,
1350
1351 .vidioc_qbuf = fimc_m2m_qbuf,
1352 .vidioc_dqbuf = fimc_m2m_dqbuf,
1353
1354 .vidioc_streamon = fimc_m2m_streamon,
1355 .vidioc_streamoff = fimc_m2m_streamoff,
1356
1357 .vidioc_queryctrl = fimc_vidioc_queryctrl,
1358 .vidioc_g_ctrl = fimc_vidioc_g_ctrl,
1359 .vidioc_s_ctrl = fimc_m2m_s_ctrl,
1360
1361 .vidioc_g_crop = fimc_m2m_g_crop,
1362 .vidioc_s_crop = fimc_m2m_s_crop,
1363 .vidioc_cropcap = fimc_m2m_cropcap
1364
1365 };
1366
1367 static int queue_init(void *priv, struct vb2_queue *src_vq,
1368 struct vb2_queue *dst_vq)
1369 {
1370 struct fimc_ctx *ctx = priv;
1371 int ret;
1372
1373 memset(src_vq, 0, sizeof(*src_vq));
1374 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1375 src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
1376 src_vq->drv_priv = ctx;
1377 src_vq->ops = &fimc_qops;
1378 src_vq->mem_ops = &vb2_dma_contig_memops;
1379 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
1380
1381 ret = vb2_queue_init(src_vq);
1382 if (ret)
1383 return ret;
1384
1385 memset(dst_vq, 0, sizeof(*dst_vq));
1386 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1387 dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
1388 dst_vq->drv_priv = ctx;
1389 dst_vq->ops = &fimc_qops;
1390 dst_vq->mem_ops = &vb2_dma_contig_memops;
1391 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
1392
1393 return vb2_queue_init(dst_vq);
1394 }
1395
1396 static int fimc_m2m_open(struct file *file)
1397 {
1398 struct fimc_dev *fimc = video_drvdata(file);
1399 struct fimc_ctx *ctx = NULL;
1400
1401 dbg("pid: %d, state: 0x%lx, refcnt: %d",
1402 task_pid_nr(current), fimc->state, fimc->vid_cap.refcnt);
1403
1404 /*
1405 * Return if the corresponding video capture node
1406 * is already opened.
1407 */
1408 if (fimc->vid_cap.refcnt > 0)
1409 return -EBUSY;
1410
1411 fimc->m2m.refcnt++;
1412 set_bit(ST_OUTDMA_RUN, &fimc->state);
1413
1414 ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
1415 if (!ctx)
1416 return -ENOMEM;
1417
1418 file->private_data = ctx;
1419 ctx->fimc_dev = fimc;
1420 /* Default color format */
1421 ctx->s_frame.fmt = &fimc_formats[0];
1422 ctx->d_frame.fmt = &fimc_formats[0];
1423 /* Setup the device context for mem2mem mode. */
1424 ctx->state = FIMC_CTX_M2M;
1425 ctx->flags = 0;
1426 ctx->in_path = FIMC_DMA;
1427 ctx->out_path = FIMC_DMA;
1428 spin_lock_init(&ctx->slock);
1429
1430 ctx->m2m_ctx = v4l2_m2m_ctx_init(fimc->m2m.m2m_dev, ctx, queue_init);
1431 if (IS_ERR(ctx->m2m_ctx)) {
1432 int err = PTR_ERR(ctx->m2m_ctx);
1433 kfree(ctx);
1434 return err;
1435 }
1436
1437 return 0;
1438 }
1439
1440 static int fimc_m2m_release(struct file *file)
1441 {
1442 struct fimc_ctx *ctx = file->private_data;
1443 struct fimc_dev *fimc = ctx->fimc_dev;
1444
1445 dbg("pid: %d, state: 0x%lx, refcnt= %d",
1446 task_pid_nr(current), fimc->state, fimc->m2m.refcnt);
1447
1448 v4l2_m2m_ctx_release(ctx->m2m_ctx);
1449 kfree(ctx);
1450 if (--fimc->m2m.refcnt <= 0)
1451 clear_bit(ST_OUTDMA_RUN, &fimc->state);
1452
1453 return 0;
1454 }
1455
1456 static unsigned int fimc_m2m_poll(struct file *file,
1457 struct poll_table_struct *wait)
1458 {
1459 struct fimc_ctx *ctx = file->private_data;
1460
1461 return v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
1462 }
1463
1464
1465 static int fimc_m2m_mmap(struct file *file, struct vm_area_struct *vma)
1466 {
1467 struct fimc_ctx *ctx = file->private_data;
1468
1469 return v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
1470 }
1471
1472 static const struct v4l2_file_operations fimc_m2m_fops = {
1473 .owner = THIS_MODULE,
1474 .open = fimc_m2m_open,
1475 .release = fimc_m2m_release,
1476 .poll = fimc_m2m_poll,
1477 .unlocked_ioctl = video_ioctl2,
1478 .mmap = fimc_m2m_mmap,
1479 };
1480
1481 static struct v4l2_m2m_ops m2m_ops = {
1482 .device_run = fimc_dma_run,
1483 .job_abort = fimc_job_abort,
1484 };
1485
1486 static int fimc_register_m2m_device(struct fimc_dev *fimc)
1487 {
1488 struct video_device *vfd;
1489 struct platform_device *pdev;
1490 struct v4l2_device *v4l2_dev;
1491 int ret = 0;
1492
1493 if (!fimc)
1494 return -ENODEV;
1495
1496 pdev = fimc->pdev;
1497 v4l2_dev = &fimc->m2m.v4l2_dev;
1498
1499 /* set name if it is empty */
1500 if (!v4l2_dev->name[0])
1501 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
1502 "%s.m2m", dev_name(&pdev->dev));
1503
1504 ret = v4l2_device_register(&pdev->dev, v4l2_dev);
1505 if (ret)
1506 goto err_m2m_r1;
1507
1508 vfd = video_device_alloc();
1509 if (!vfd) {
1510 v4l2_err(v4l2_dev, "Failed to allocate video device\n");
1511 goto err_m2m_r1;
1512 }
1513
1514 vfd->fops = &fimc_m2m_fops;
1515 vfd->ioctl_ops = &fimc_m2m_ioctl_ops;
1516 vfd->minor = -1;
1517 vfd->release = video_device_release;
1518 vfd->lock = &fimc->lock;
1519
1520 snprintf(vfd->name, sizeof(vfd->name), "%s:m2m", dev_name(&pdev->dev));
1521
1522 video_set_drvdata(vfd, fimc);
1523 platform_set_drvdata(pdev, fimc);
1524
1525 fimc->m2m.vfd = vfd;
1526 fimc->m2m.m2m_dev = v4l2_m2m_init(&m2m_ops);
1527 if (IS_ERR(fimc->m2m.m2m_dev)) {
1528 v4l2_err(v4l2_dev, "failed to initialize v4l2-m2m device\n");
1529 ret = PTR_ERR(fimc->m2m.m2m_dev);
1530 goto err_m2m_r2;
1531 }
1532
1533 ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
1534 if (ret) {
1535 v4l2_err(v4l2_dev,
1536 "%s(): failed to register video device\n", __func__);
1537 goto err_m2m_r3;
1538 }
1539 v4l2_info(v4l2_dev,
1540 "FIMC m2m driver registered as /dev/video%d\n", vfd->num);
1541
1542 return 0;
1543
1544 err_m2m_r3:
1545 v4l2_m2m_release(fimc->m2m.m2m_dev);
1546 err_m2m_r2:
1547 video_device_release(fimc->m2m.vfd);
1548 err_m2m_r1:
1549 v4l2_device_unregister(v4l2_dev);
1550
1551 return ret;
1552 }
1553
1554 static void fimc_unregister_m2m_device(struct fimc_dev *fimc)
1555 {
1556 if (fimc) {
1557 v4l2_m2m_release(fimc->m2m.m2m_dev);
1558 video_unregister_device(fimc->m2m.vfd);
1559
1560 v4l2_device_unregister(&fimc->m2m.v4l2_dev);
1561 }
1562 }
1563
1564 static void fimc_clk_release(struct fimc_dev *fimc)
1565 {
1566 int i;
1567 for (i = 0; i < fimc->num_clocks; i++) {
1568 if (fimc->clock[i]) {
1569 clk_disable(fimc->clock[i]);
1570 clk_put(fimc->clock[i]);
1571 }
1572 }
1573 }
1574
1575 static int fimc_clk_get(struct fimc_dev *fimc)
1576 {
1577 int i;
1578 for (i = 0; i < fimc->num_clocks; i++) {
1579 fimc->clock[i] = clk_get(&fimc->pdev->dev, fimc_clocks[i]);
1580
1581 if (!IS_ERR_OR_NULL(fimc->clock[i])) {
1582 clk_enable(fimc->clock[i]);
1583 continue;
1584 }
1585 dev_err(&fimc->pdev->dev, "failed to get fimc clock: %s\n",
1586 fimc_clocks[i]);
1587 return -ENXIO;
1588 }
1589 return 0;
1590 }
1591
1592 static int fimc_probe(struct platform_device *pdev)
1593 {
1594 struct fimc_dev *fimc;
1595 struct resource *res;
1596 struct samsung_fimc_driverdata *drv_data;
1597 struct s5p_platform_fimc *pdata;
1598 int ret = 0;
1599 int cap_input_index = -1;
1600
1601 dev_dbg(&pdev->dev, "%s():\n", __func__);
1602
1603 drv_data = (struct samsung_fimc_driverdata *)
1604 platform_get_device_id(pdev)->driver_data;
1605
1606 if (pdev->id >= drv_data->num_entities) {
1607 dev_err(&pdev->dev, "Invalid platform device id: %d\n",
1608 pdev->id);
1609 return -EINVAL;
1610 }
1611
1612 fimc = kzalloc(sizeof(struct fimc_dev), GFP_KERNEL);
1613 if (!fimc)
1614 return -ENOMEM;
1615
1616 fimc->id = pdev->id;
1617 fimc->variant = drv_data->variant[fimc->id];
1618 fimc->pdev = pdev;
1619 pdata = pdev->dev.platform_data;
1620 fimc->pdata = pdata;
1621 fimc->state = ST_IDLE;
1622
1623 init_waitqueue_head(&fimc->irq_queue);
1624 spin_lock_init(&fimc->slock);
1625
1626 mutex_init(&fimc->lock);
1627
1628 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1629 if (!res) {
1630 dev_err(&pdev->dev, "failed to find the registers\n");
1631 ret = -ENOENT;
1632 goto err_info;
1633 }
1634
1635 fimc->regs_res = request_mem_region(res->start, resource_size(res),
1636 dev_name(&pdev->dev));
1637 if (!fimc->regs_res) {
1638 dev_err(&pdev->dev, "failed to obtain register region\n");
1639 ret = -ENOENT;
1640 goto err_info;
1641 }
1642
1643 fimc->regs = ioremap(res->start, resource_size(res));
1644 if (!fimc->regs) {
1645 dev_err(&pdev->dev, "failed to map registers\n");
1646 ret = -ENXIO;
1647 goto err_req_region;
1648 }
1649
1650 fimc->num_clocks = MAX_FIMC_CLOCKS - 1;
1651
1652 /* Check if a video capture node needs to be registered. */
1653 if (pdata && pdata->num_clients > 0) {
1654 cap_input_index = 0;
1655 fimc->num_clocks++;
1656 }
1657
1658 ret = fimc_clk_get(fimc);
1659 if (ret)
1660 goto err_regs_unmap;
1661 clk_set_rate(fimc->clock[CLK_BUS], drv_data->lclk_frequency);
1662
1663 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1664 if (!res) {
1665 dev_err(&pdev->dev, "failed to get IRQ resource\n");
1666 ret = -ENXIO;
1667 goto err_clk;
1668 }
1669 fimc->irq = res->start;
1670
1671 fimc_hw_reset(fimc);
1672
1673 ret = request_irq(fimc->irq, fimc_isr, 0, pdev->name, fimc);
1674 if (ret) {
1675 dev_err(&pdev->dev, "failed to install irq (%d)\n", ret);
1676 goto err_clk;
1677 }
1678
1679 /* Initialize contiguous memory allocator */
1680 fimc->alloc_ctx = vb2_dma_contig_init_ctx(&fimc->pdev->dev);
1681 if (IS_ERR(fimc->alloc_ctx)) {
1682 ret = PTR_ERR(fimc->alloc_ctx);
1683 goto err_irq;
1684 }
1685
1686 ret = fimc_register_m2m_device(fimc);
1687 if (ret)
1688 goto err_irq;
1689
1690 /* At least one camera sensor is required to register capture node */
1691 if (cap_input_index >= 0) {
1692 ret = fimc_register_capture_device(fimc);
1693 if (ret)
1694 goto err_m2m;
1695 clk_disable(fimc->clock[CLK_CAM]);
1696 }
1697 /*
1698 * Exclude the additional output DMA address registers by masking
1699 * them out on HW revisions that provide extended capabilites.
1700 */
1701 if (fimc->variant->out_buf_count > 4)
1702 fimc_hw_set_dma_seq(fimc, 0xF);
1703
1704 dev_dbg(&pdev->dev, "%s(): fimc-%d registered successfully\n",
1705 __func__, fimc->id);
1706
1707 return 0;
1708
1709 err_m2m:
1710 fimc_unregister_m2m_device(fimc);
1711 err_irq:
1712 free_irq(fimc->irq, fimc);
1713 err_clk:
1714 fimc_clk_release(fimc);
1715 err_regs_unmap:
1716 iounmap(fimc->regs);
1717 err_req_region:
1718 release_resource(fimc->regs_res);
1719 kfree(fimc->regs_res);
1720 err_info:
1721 kfree(fimc);
1722
1723 return ret;
1724 }
1725
1726 static int __devexit fimc_remove(struct platform_device *pdev)
1727 {
1728 struct fimc_dev *fimc =
1729 (struct fimc_dev *)platform_get_drvdata(pdev);
1730
1731 free_irq(fimc->irq, fimc);
1732 fimc_hw_reset(fimc);
1733
1734 fimc_unregister_m2m_device(fimc);
1735 fimc_unregister_capture_device(fimc);
1736
1737 fimc_clk_release(fimc);
1738
1739 vb2_dma_contig_cleanup_ctx(fimc->alloc_ctx);
1740
1741 iounmap(fimc->regs);
1742 release_resource(fimc->regs_res);
1743 kfree(fimc->regs_res);
1744 kfree(fimc);
1745
1746 dev_info(&pdev->dev, "%s driver unloaded\n", pdev->name);
1747 return 0;
1748 }
1749
1750 /* Image pixel limits, similar across several FIMC HW revisions. */
1751 static struct fimc_pix_limit s5p_pix_limit[4] = {
1752 [0] = {
1753 .scaler_en_w = 3264,
1754 .scaler_dis_w = 8192,
1755 .in_rot_en_h = 1920,
1756 .in_rot_dis_w = 8192,
1757 .out_rot_en_w = 1920,
1758 .out_rot_dis_w = 4224,
1759 },
1760 [1] = {
1761 .scaler_en_w = 4224,
1762 .scaler_dis_w = 8192,
1763 .in_rot_en_h = 1920,
1764 .in_rot_dis_w = 8192,
1765 .out_rot_en_w = 1920,
1766 .out_rot_dis_w = 4224,
1767 },
1768 [2] = {
1769 .scaler_en_w = 1920,
1770 .scaler_dis_w = 8192,
1771 .in_rot_en_h = 1280,
1772 .in_rot_dis_w = 8192,
1773 .out_rot_en_w = 1280,
1774 .out_rot_dis_w = 1920,
1775 },
1776 [3] = {
1777 .scaler_en_w = 1920,
1778 .scaler_dis_w = 8192,
1779 .in_rot_en_h = 1366,
1780 .in_rot_dis_w = 8192,
1781 .out_rot_en_w = 1366,
1782 .out_rot_dis_w = 1920,
1783 },
1784 };
1785
1786 static struct samsung_fimc_variant fimc0_variant_s5p = {
1787 .has_inp_rot = 1,
1788 .has_out_rot = 1,
1789 .min_inp_pixsize = 16,
1790 .min_out_pixsize = 16,
1791 .hor_offs_align = 8,
1792 .out_buf_count = 4,
1793 .pix_limit = &s5p_pix_limit[0],
1794 };
1795
1796 static struct samsung_fimc_variant fimc2_variant_s5p = {
1797 .min_inp_pixsize = 16,
1798 .min_out_pixsize = 16,
1799 .hor_offs_align = 8,
1800 .out_buf_count = 4,
1801 .pix_limit = &s5p_pix_limit[1],
1802 };
1803
1804 static struct samsung_fimc_variant fimc0_variant_s5pv210 = {
1805 .pix_hoff = 1,
1806 .has_inp_rot = 1,
1807 .has_out_rot = 1,
1808 .min_inp_pixsize = 16,
1809 .min_out_pixsize = 16,
1810 .hor_offs_align = 8,
1811 .out_buf_count = 4,
1812 .pix_limit = &s5p_pix_limit[1],
1813 };
1814
1815 static struct samsung_fimc_variant fimc1_variant_s5pv210 = {
1816 .pix_hoff = 1,
1817 .has_inp_rot = 1,
1818 .has_out_rot = 1,
1819 .has_mainscaler_ext = 1,
1820 .min_inp_pixsize = 16,
1821 .min_out_pixsize = 16,
1822 .hor_offs_align = 1,
1823 .out_buf_count = 4,
1824 .pix_limit = &s5p_pix_limit[2],
1825 };
1826
1827 static struct samsung_fimc_variant fimc2_variant_s5pv210 = {
1828 .pix_hoff = 1,
1829 .min_inp_pixsize = 16,
1830 .min_out_pixsize = 16,
1831 .hor_offs_align = 8,
1832 .out_buf_count = 4,
1833 .pix_limit = &s5p_pix_limit[2],
1834 };
1835
1836 static struct samsung_fimc_variant fimc0_variant_exynos4 = {
1837 .pix_hoff = 1,
1838 .has_inp_rot = 1,
1839 .has_out_rot = 1,
1840 .has_cistatus2 = 1,
1841 .has_mainscaler_ext = 1,
1842 .min_inp_pixsize = 16,
1843 .min_out_pixsize = 16,
1844 .hor_offs_align = 1,
1845 .out_buf_count = 32,
1846 .pix_limit = &s5p_pix_limit[1],
1847 };
1848
1849 static struct samsung_fimc_variant fimc2_variant_exynos4 = {
1850 .pix_hoff = 1,
1851 .has_cistatus2 = 1,
1852 .has_mainscaler_ext = 1,
1853 .min_inp_pixsize = 16,
1854 .min_out_pixsize = 16,
1855 .hor_offs_align = 1,
1856 .out_buf_count = 32,
1857 .pix_limit = &s5p_pix_limit[3],
1858 };
1859
1860 /* S5PC100 */
1861 static struct samsung_fimc_driverdata fimc_drvdata_s5p = {
1862 .variant = {
1863 [0] = &fimc0_variant_s5p,
1864 [1] = &fimc0_variant_s5p,
1865 [2] = &fimc2_variant_s5p,
1866 },
1867 .num_entities = 3,
1868 .lclk_frequency = 133000000UL,
1869 };
1870
1871 /* S5PV210, S5PC110 */
1872 static struct samsung_fimc_driverdata fimc_drvdata_s5pv210 = {
1873 .variant = {
1874 [0] = &fimc0_variant_s5pv210,
1875 [1] = &fimc1_variant_s5pv210,
1876 [2] = &fimc2_variant_s5pv210,
1877 },
1878 .num_entities = 3,
1879 .lclk_frequency = 166000000UL,
1880 };
1881
1882 /* S5PV310, S5PC210 */
1883 static struct samsung_fimc_driverdata fimc_drvdata_exynos4 = {
1884 .variant = {
1885 [0] = &fimc0_variant_exynos4,
1886 [1] = &fimc0_variant_exynos4,
1887 [2] = &fimc0_variant_exynos4,
1888 [3] = &fimc2_variant_exynos4,
1889 },
1890 .num_entities = 4,
1891 .lclk_frequency = 166000000UL,
1892 };
1893
1894 static struct platform_device_id fimc_driver_ids[] = {
1895 {
1896 .name = "s5p-fimc",
1897 .driver_data = (unsigned long)&fimc_drvdata_s5p,
1898 }, {
1899 .name = "s5pv210-fimc",
1900 .driver_data = (unsigned long)&fimc_drvdata_s5pv210,
1901 }, {
1902 .name = "exynos4-fimc",
1903 .driver_data = (unsigned long)&fimc_drvdata_exynos4,
1904 },
1905 {},
1906 };
1907 MODULE_DEVICE_TABLE(platform, fimc_driver_ids);
1908
1909 static struct platform_driver fimc_driver = {
1910 .probe = fimc_probe,
1911 .remove = __devexit_p(fimc_remove),
1912 .id_table = fimc_driver_ids,
1913 .driver = {
1914 .name = MODULE_NAME,
1915 .owner = THIS_MODULE,
1916 }
1917 };
1918
1919 static int __init fimc_init(void)
1920 {
1921 int ret = platform_driver_register(&fimc_driver);
1922 if (ret)
1923 err("platform_driver_register failed: %d\n", ret);
1924 return ret;
1925 }
1926
1927 static void __exit fimc_exit(void)
1928 {
1929 platform_driver_unregister(&fimc_driver);
1930 }
1931
1932 module_init(fimc_init);
1933 module_exit(fimc_exit);
1934
1935 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
1936 MODULE_DESCRIPTION("S5P FIMC camera host interface/video postprocessor driver");
1937 MODULE_LICENSE("GPL");
1938 MODULE_VERSION("1.0.1");
Linux kernel - Deliverables
This page took 0.073095 seconds and 6 git commands to generate.