Merge tag 'devicetree-for-5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/robh...
[sfrench/cifs-2.6.git] / drivers / media / platform / s5p-mfc / s5p_mfc.c
1 /*
2  * Samsung S5P Multi Format Codec v 5.1
3  *
4  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
5  * Kamil Debski, <k.debski@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 by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  */
12
13 #include <linux/clk.h>
14 #include <linux/delay.h>
15 #include <linux/interrupt.h>
16 #include <linux/io.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/videodev2.h>
22 #include <media/v4l2-event.h>
23 #include <linux/workqueue.h>
24 #include <linux/of.h>
25 #include <linux/of_device.h>
26 #include <linux/of_reserved_mem.h>
27 #include <media/videobuf2-v4l2.h>
28 #include "s5p_mfc_common.h"
29 #include "s5p_mfc_ctrl.h"
30 #include "s5p_mfc_debug.h"
31 #include "s5p_mfc_dec.h"
32 #include "s5p_mfc_enc.h"
33 #include "s5p_mfc_intr.h"
34 #include "s5p_mfc_iommu.h"
35 #include "s5p_mfc_opr.h"
36 #include "s5p_mfc_cmd.h"
37 #include "s5p_mfc_pm.h"
38
39 #define S5P_MFC_DEC_NAME        "s5p-mfc-dec"
40 #define S5P_MFC_ENC_NAME        "s5p-mfc-enc"
41
42 int mfc_debug_level;
43 module_param_named(debug, mfc_debug_level, int, S_IRUGO | S_IWUSR);
44 MODULE_PARM_DESC(debug, "Debug level - higher value produces more verbose messages");
45
46 static char *mfc_mem_size;
47 module_param_named(mem, mfc_mem_size, charp, 0644);
48 MODULE_PARM_DESC(mem, "Preallocated memory size for the firmware and context buffers");
49
50 /* Helper functions for interrupt processing */
51
52 /* Remove from hw execution round robin */
53 void clear_work_bit(struct s5p_mfc_ctx *ctx)
54 {
55         struct s5p_mfc_dev *dev = ctx->dev;
56
57         spin_lock(&dev->condlock);
58         __clear_bit(ctx->num, &dev->ctx_work_bits);
59         spin_unlock(&dev->condlock);
60 }
61
62 /* Add to hw execution round robin */
63 void set_work_bit(struct s5p_mfc_ctx *ctx)
64 {
65         struct s5p_mfc_dev *dev = ctx->dev;
66
67         spin_lock(&dev->condlock);
68         __set_bit(ctx->num, &dev->ctx_work_bits);
69         spin_unlock(&dev->condlock);
70 }
71
72 /* Remove from hw execution round robin */
73 void clear_work_bit_irqsave(struct s5p_mfc_ctx *ctx)
74 {
75         struct s5p_mfc_dev *dev = ctx->dev;
76         unsigned long flags;
77
78         spin_lock_irqsave(&dev->condlock, flags);
79         __clear_bit(ctx->num, &dev->ctx_work_bits);
80         spin_unlock_irqrestore(&dev->condlock, flags);
81 }
82
83 /* Add to hw execution round robin */
84 void set_work_bit_irqsave(struct s5p_mfc_ctx *ctx)
85 {
86         struct s5p_mfc_dev *dev = ctx->dev;
87         unsigned long flags;
88
89         spin_lock_irqsave(&dev->condlock, flags);
90         __set_bit(ctx->num, &dev->ctx_work_bits);
91         spin_unlock_irqrestore(&dev->condlock, flags);
92 }
93
94 int s5p_mfc_get_new_ctx(struct s5p_mfc_dev *dev)
95 {
96         unsigned long flags;
97         int ctx;
98
99         spin_lock_irqsave(&dev->condlock, flags);
100         ctx = dev->curr_ctx;
101         do {
102                 ctx = (ctx + 1) % MFC_NUM_CONTEXTS;
103                 if (ctx == dev->curr_ctx) {
104                         if (!test_bit(ctx, &dev->ctx_work_bits))
105                                 ctx = -EAGAIN;
106                         break;
107                 }
108         } while (!test_bit(ctx, &dev->ctx_work_bits));
109         spin_unlock_irqrestore(&dev->condlock, flags);
110
111         return ctx;
112 }
113
114 /* Wake up context wait_queue */
115 static void wake_up_ctx(struct s5p_mfc_ctx *ctx, unsigned int reason,
116                         unsigned int err)
117 {
118         ctx->int_cond = 1;
119         ctx->int_type = reason;
120         ctx->int_err = err;
121         wake_up(&ctx->queue);
122 }
123
124 /* Wake up device wait_queue */
125 static void wake_up_dev(struct s5p_mfc_dev *dev, unsigned int reason,
126                         unsigned int err)
127 {
128         dev->int_cond = 1;
129         dev->int_type = reason;
130         dev->int_err = err;
131         wake_up(&dev->queue);
132 }
133
134 void s5p_mfc_cleanup_queue(struct list_head *lh, struct vb2_queue *vq)
135 {
136         struct s5p_mfc_buf *b;
137         int i;
138
139         while (!list_empty(lh)) {
140                 b = list_entry(lh->next, struct s5p_mfc_buf, list);
141                 for (i = 0; i < b->b->vb2_buf.num_planes; i++)
142                         vb2_set_plane_payload(&b->b->vb2_buf, i, 0);
143                 vb2_buffer_done(&b->b->vb2_buf, VB2_BUF_STATE_ERROR);
144                 list_del(&b->list);
145         }
146 }
147
148 static void s5p_mfc_watchdog(struct timer_list *t)
149 {
150         struct s5p_mfc_dev *dev = from_timer(dev, t, watchdog_timer);
151
152         if (test_bit(0, &dev->hw_lock))
153                 atomic_inc(&dev->watchdog_cnt);
154         if (atomic_read(&dev->watchdog_cnt) >= MFC_WATCHDOG_CNT) {
155                 /* This means that hw is busy and no interrupts were
156                  * generated by hw for the Nth time of running this
157                  * watchdog timer. This usually means a serious hw
158                  * error. Now it is time to kill all instances and
159                  * reset the MFC. */
160                 mfc_err("Time out during waiting for HW\n");
161                 schedule_work(&dev->watchdog_work);
162         }
163         dev->watchdog_timer.expires = jiffies +
164                                         msecs_to_jiffies(MFC_WATCHDOG_INTERVAL);
165         add_timer(&dev->watchdog_timer);
166 }
167
168 static void s5p_mfc_watchdog_worker(struct work_struct *work)
169 {
170         struct s5p_mfc_dev *dev;
171         struct s5p_mfc_ctx *ctx;
172         unsigned long flags;
173         int mutex_locked;
174         int i, ret;
175
176         dev = container_of(work, struct s5p_mfc_dev, watchdog_work);
177
178         mfc_err("Driver timeout error handling\n");
179         /* Lock the mutex that protects open and release.
180          * This is necessary as they may load and unload firmware. */
181         mutex_locked = mutex_trylock(&dev->mfc_mutex);
182         if (!mutex_locked)
183                 mfc_err("Error: some instance may be closing/opening\n");
184         spin_lock_irqsave(&dev->irqlock, flags);
185
186         s5p_mfc_clock_off();
187
188         for (i = 0; i < MFC_NUM_CONTEXTS; i++) {
189                 ctx = dev->ctx[i];
190                 if (!ctx)
191                         continue;
192                 ctx->state = MFCINST_ERROR;
193                 s5p_mfc_cleanup_queue(&ctx->dst_queue, &ctx->vq_dst);
194                 s5p_mfc_cleanup_queue(&ctx->src_queue, &ctx->vq_src);
195                 clear_work_bit(ctx);
196                 wake_up_ctx(ctx, S5P_MFC_R2H_CMD_ERR_RET, 0);
197         }
198         clear_bit(0, &dev->hw_lock);
199         spin_unlock_irqrestore(&dev->irqlock, flags);
200
201         /* De-init MFC */
202         s5p_mfc_deinit_hw(dev);
203
204         /* Double check if there is at least one instance running.
205          * If no instance is in memory than no firmware should be present */
206         if (dev->num_inst > 0) {
207                 ret = s5p_mfc_load_firmware(dev);
208                 if (ret) {
209                         mfc_err("Failed to reload FW\n");
210                         goto unlock;
211                 }
212                 s5p_mfc_clock_on();
213                 ret = s5p_mfc_init_hw(dev);
214                 s5p_mfc_clock_off();
215                 if (ret)
216                         mfc_err("Failed to reinit FW\n");
217         }
218 unlock:
219         if (mutex_locked)
220                 mutex_unlock(&dev->mfc_mutex);
221 }
222
223 static void s5p_mfc_handle_frame_all_extracted(struct s5p_mfc_ctx *ctx)
224 {
225         struct s5p_mfc_buf *dst_buf;
226         struct s5p_mfc_dev *dev = ctx->dev;
227
228         ctx->state = MFCINST_FINISHED;
229         ctx->sequence++;
230         while (!list_empty(&ctx->dst_queue)) {
231                 dst_buf = list_entry(ctx->dst_queue.next,
232                                      struct s5p_mfc_buf, list);
233                 mfc_debug(2, "Cleaning up buffer: %d\n",
234                                           dst_buf->b->vb2_buf.index);
235                 vb2_set_plane_payload(&dst_buf->b->vb2_buf, 0, 0);
236                 vb2_set_plane_payload(&dst_buf->b->vb2_buf, 1, 0);
237                 list_del(&dst_buf->list);
238                 dst_buf->flags |= MFC_BUF_FLAG_EOS;
239                 ctx->dst_queue_cnt--;
240                 dst_buf->b->sequence = (ctx->sequence++);
241
242                 if (s5p_mfc_hw_call(dev->mfc_ops, get_pic_type_top, ctx) ==
243                         s5p_mfc_hw_call(dev->mfc_ops, get_pic_type_bot, ctx))
244                         dst_buf->b->field = V4L2_FIELD_NONE;
245                 else
246                         dst_buf->b->field = V4L2_FIELD_INTERLACED;
247                 dst_buf->b->flags |= V4L2_BUF_FLAG_LAST;
248
249                 ctx->dec_dst_flag &= ~(1 << dst_buf->b->vb2_buf.index);
250                 vb2_buffer_done(&dst_buf->b->vb2_buf, VB2_BUF_STATE_DONE);
251         }
252 }
253
254 static void s5p_mfc_handle_frame_copy_time(struct s5p_mfc_ctx *ctx)
255 {
256         struct s5p_mfc_dev *dev = ctx->dev;
257         struct s5p_mfc_buf *dst_buf, *src_buf;
258         u32 dec_y_addr;
259         unsigned int frame_type;
260
261         /* Make sure we actually have a new frame before continuing. */
262         frame_type = s5p_mfc_hw_call(dev->mfc_ops, get_dec_frame_type, dev);
263         if (frame_type == S5P_FIMV_DECODE_FRAME_SKIPPED)
264                 return;
265         dec_y_addr = (u32)s5p_mfc_hw_call(dev->mfc_ops, get_dec_y_adr, dev);
266
267         /* Copy timestamp / timecode from decoded src to dst and set
268            appropriate flags. */
269         src_buf = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
270         list_for_each_entry(dst_buf, &ctx->dst_queue, list) {
271                 u32 addr = (u32)vb2_dma_contig_plane_dma_addr(&dst_buf->b->vb2_buf, 0);
272
273                 if (addr == dec_y_addr) {
274                         dst_buf->b->timecode = src_buf->b->timecode;
275                         dst_buf->b->vb2_buf.timestamp =
276                                                 src_buf->b->vb2_buf.timestamp;
277                         dst_buf->b->flags &=
278                                 ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
279                         dst_buf->b->flags |=
280                                 src_buf->b->flags
281                                 & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
282                         switch (frame_type) {
283                         case S5P_FIMV_DECODE_FRAME_I_FRAME:
284                                 dst_buf->b->flags |=
285                                                 V4L2_BUF_FLAG_KEYFRAME;
286                                 break;
287                         case S5P_FIMV_DECODE_FRAME_P_FRAME:
288                                 dst_buf->b->flags |=
289                                                 V4L2_BUF_FLAG_PFRAME;
290                                 break;
291                         case S5P_FIMV_DECODE_FRAME_B_FRAME:
292                                 dst_buf->b->flags |=
293                                                 V4L2_BUF_FLAG_BFRAME;
294                                 break;
295                         default:
296                                 /* Don't know how to handle
297                                    S5P_FIMV_DECODE_FRAME_OTHER_FRAME. */
298                                 mfc_debug(2, "Unexpected frame type: %d\n",
299                                                 frame_type);
300                         }
301                         break;
302                 }
303         }
304 }
305
306 static void s5p_mfc_handle_frame_new(struct s5p_mfc_ctx *ctx, unsigned int err)
307 {
308         struct s5p_mfc_dev *dev = ctx->dev;
309         struct s5p_mfc_buf  *dst_buf;
310         u32 dspl_y_addr;
311         unsigned int frame_type;
312
313         dspl_y_addr = (u32)s5p_mfc_hw_call(dev->mfc_ops, get_dspl_y_adr, dev);
314         if (IS_MFCV6_PLUS(dev))
315                 frame_type = s5p_mfc_hw_call(dev->mfc_ops,
316                         get_disp_frame_type, ctx);
317         else
318                 frame_type = s5p_mfc_hw_call(dev->mfc_ops,
319                         get_dec_frame_type, dev);
320
321         /* If frame is same as previous then skip and do not dequeue */
322         if (frame_type == S5P_FIMV_DECODE_FRAME_SKIPPED) {
323                 if (!ctx->after_packed_pb)
324                         ctx->sequence++;
325                 ctx->after_packed_pb = 0;
326                 return;
327         }
328         ctx->sequence++;
329         /* The MFC returns address of the buffer, now we have to
330          * check which videobuf does it correspond to */
331         list_for_each_entry(dst_buf, &ctx->dst_queue, list) {
332                 u32 addr = (u32)vb2_dma_contig_plane_dma_addr(&dst_buf->b->vb2_buf, 0);
333
334                 /* Check if this is the buffer we're looking for */
335                 if (addr == dspl_y_addr) {
336                         list_del(&dst_buf->list);
337                         ctx->dst_queue_cnt--;
338                         dst_buf->b->sequence = ctx->sequence;
339                         if (s5p_mfc_hw_call(dev->mfc_ops,
340                                         get_pic_type_top, ctx) ==
341                                 s5p_mfc_hw_call(dev->mfc_ops,
342                                         get_pic_type_bot, ctx))
343                                 dst_buf->b->field = V4L2_FIELD_NONE;
344                         else
345                                 dst_buf->b->field =
346                                                         V4L2_FIELD_INTERLACED;
347                         vb2_set_plane_payload(&dst_buf->b->vb2_buf, 0,
348                                                 ctx->luma_size);
349                         vb2_set_plane_payload(&dst_buf->b->vb2_buf, 1,
350                                                 ctx->chroma_size);
351                         clear_bit(dst_buf->b->vb2_buf.index,
352                                                         &ctx->dec_dst_flag);
353
354                         vb2_buffer_done(&dst_buf->b->vb2_buf, err ?
355                                 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
356
357                         break;
358                 }
359         }
360 }
361
362 /* Handle frame decoding interrupt */
363 static void s5p_mfc_handle_frame(struct s5p_mfc_ctx *ctx,
364                                         unsigned int reason, unsigned int err)
365 {
366         struct s5p_mfc_dev *dev = ctx->dev;
367         unsigned int dst_frame_status;
368         unsigned int dec_frame_status;
369         struct s5p_mfc_buf *src_buf;
370         unsigned int res_change;
371
372         dst_frame_status = s5p_mfc_hw_call(dev->mfc_ops, get_dspl_status, dev)
373                                 & S5P_FIMV_DEC_STATUS_DECODING_STATUS_MASK;
374         dec_frame_status = s5p_mfc_hw_call(dev->mfc_ops, get_dec_status, dev)
375                                 & S5P_FIMV_DEC_STATUS_DECODING_STATUS_MASK;
376         res_change = (s5p_mfc_hw_call(dev->mfc_ops, get_dspl_status, dev)
377                                 & S5P_FIMV_DEC_STATUS_RESOLUTION_MASK)
378                                 >> S5P_FIMV_DEC_STATUS_RESOLUTION_SHIFT;
379         mfc_debug(2, "Frame Status: %x\n", dst_frame_status);
380         if (ctx->state == MFCINST_RES_CHANGE_INIT)
381                 ctx->state = MFCINST_RES_CHANGE_FLUSH;
382         if (res_change == S5P_FIMV_RES_INCREASE ||
383                 res_change == S5P_FIMV_RES_DECREASE) {
384                 ctx->state = MFCINST_RES_CHANGE_INIT;
385                 s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
386                 wake_up_ctx(ctx, reason, err);
387                 WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
388                 s5p_mfc_clock_off();
389                 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
390                 return;
391         }
392         if (ctx->dpb_flush_flag)
393                 ctx->dpb_flush_flag = 0;
394
395         /* All frames remaining in the buffer have been extracted  */
396         if (dst_frame_status == S5P_FIMV_DEC_STATUS_DECODING_EMPTY) {
397                 if (ctx->state == MFCINST_RES_CHANGE_FLUSH) {
398                         static const struct v4l2_event ev_src_ch = {
399                                 .type = V4L2_EVENT_SOURCE_CHANGE,
400                                 .u.src_change.changes =
401                                         V4L2_EVENT_SRC_CH_RESOLUTION,
402                         };
403
404                         s5p_mfc_handle_frame_all_extracted(ctx);
405                         ctx->state = MFCINST_RES_CHANGE_END;
406                         v4l2_event_queue_fh(&ctx->fh, &ev_src_ch);
407
408                         goto leave_handle_frame;
409                 } else {
410                         s5p_mfc_handle_frame_all_extracted(ctx);
411                 }
412         }
413
414         if (dec_frame_status == S5P_FIMV_DEC_STATUS_DECODING_DISPLAY)
415                 s5p_mfc_handle_frame_copy_time(ctx);
416
417         /* A frame has been decoded and is in the buffer  */
418         if (dst_frame_status == S5P_FIMV_DEC_STATUS_DISPLAY_ONLY ||
419             dst_frame_status == S5P_FIMV_DEC_STATUS_DECODING_DISPLAY) {
420                 s5p_mfc_handle_frame_new(ctx, err);
421         } else {
422                 mfc_debug(2, "No frame decode\n");
423         }
424         /* Mark source buffer as complete */
425         if (dst_frame_status != S5P_FIMV_DEC_STATUS_DISPLAY_ONLY
426                 && !list_empty(&ctx->src_queue)) {
427                 src_buf = list_entry(ctx->src_queue.next, struct s5p_mfc_buf,
428                                                                 list);
429                 ctx->consumed_stream += s5p_mfc_hw_call(dev->mfc_ops,
430                                                 get_consumed_stream, dev);
431                 if (ctx->codec_mode != S5P_MFC_CODEC_H264_DEC &&
432                         ctx->codec_mode != S5P_MFC_CODEC_VP8_DEC &&
433                         ctx->consumed_stream + STUFF_BYTE <
434                         src_buf->b->vb2_buf.planes[0].bytesused) {
435                         /* Run MFC again on the same buffer */
436                         mfc_debug(2, "Running again the same buffer\n");
437                         ctx->after_packed_pb = 1;
438                 } else {
439                         mfc_debug(2, "MFC needs next buffer\n");
440                         ctx->consumed_stream = 0;
441                         if (src_buf->flags & MFC_BUF_FLAG_EOS)
442                                 ctx->state = MFCINST_FINISHING;
443                         list_del(&src_buf->list);
444                         ctx->src_queue_cnt--;
445                         if (s5p_mfc_hw_call(dev->mfc_ops, err_dec, err) > 0)
446                                 vb2_buffer_done(&src_buf->b->vb2_buf,
447                                                 VB2_BUF_STATE_ERROR);
448                         else
449                                 vb2_buffer_done(&src_buf->b->vb2_buf,
450                                                 VB2_BUF_STATE_DONE);
451                 }
452         }
453 leave_handle_frame:
454         if ((ctx->src_queue_cnt == 0 && ctx->state != MFCINST_FINISHING)
455                                     || ctx->dst_queue_cnt < ctx->pb_count)
456                 clear_work_bit(ctx);
457         s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
458         wake_up_ctx(ctx, reason, err);
459         WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
460         s5p_mfc_clock_off();
461         /* if suspending, wake up device and do not try_run again*/
462         if (test_bit(0, &dev->enter_suspend))
463                 wake_up_dev(dev, reason, err);
464         else
465                 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
466 }
467
468 /* Error handling for interrupt */
469 static void s5p_mfc_handle_error(struct s5p_mfc_dev *dev,
470                 struct s5p_mfc_ctx *ctx, unsigned int reason, unsigned int err)
471 {
472         mfc_err("Interrupt Error: %08x\n", err);
473
474         if (ctx) {
475                 /* Error recovery is dependent on the state of context */
476                 switch (ctx->state) {
477                 case MFCINST_RES_CHANGE_INIT:
478                 case MFCINST_RES_CHANGE_FLUSH:
479                 case MFCINST_RES_CHANGE_END:
480                 case MFCINST_FINISHING:
481                 case MFCINST_FINISHED:
482                 case MFCINST_RUNNING:
483                         /* It is highly probable that an error occurred
484                          * while decoding a frame */
485                         clear_work_bit(ctx);
486                         ctx->state = MFCINST_ERROR;
487                         /* Mark all dst buffers as having an error */
488                         s5p_mfc_cleanup_queue(&ctx->dst_queue, &ctx->vq_dst);
489                         /* Mark all src buffers as having an error */
490                         s5p_mfc_cleanup_queue(&ctx->src_queue, &ctx->vq_src);
491                         wake_up_ctx(ctx, reason, err);
492                         break;
493                 default:
494                         clear_work_bit(ctx);
495                         ctx->state = MFCINST_ERROR;
496                         wake_up_ctx(ctx, reason, err);
497                         break;
498                 }
499         }
500         WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
501         s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
502         s5p_mfc_clock_off();
503         wake_up_dev(dev, reason, err);
504 }
505
506 /* Header parsing interrupt handling */
507 static void s5p_mfc_handle_seq_done(struct s5p_mfc_ctx *ctx,
508                                  unsigned int reason, unsigned int err)
509 {
510         struct s5p_mfc_dev *dev;
511
512         if (!ctx)
513                 return;
514         dev = ctx->dev;
515         if (ctx->c_ops->post_seq_start) {
516                 if (ctx->c_ops->post_seq_start(ctx))
517                         mfc_err("post_seq_start() failed\n");
518         } else {
519                 ctx->img_width = s5p_mfc_hw_call(dev->mfc_ops, get_img_width,
520                                 dev);
521                 ctx->img_height = s5p_mfc_hw_call(dev->mfc_ops, get_img_height,
522                                 dev);
523
524                 s5p_mfc_hw_call(dev->mfc_ops, dec_calc_dpb_size, ctx);
525
526                 ctx->pb_count = s5p_mfc_hw_call(dev->mfc_ops, get_dpb_count,
527                                 dev);
528                 ctx->mv_count = s5p_mfc_hw_call(dev->mfc_ops, get_mv_count,
529                                 dev);
530                 ctx->scratch_buf_size = s5p_mfc_hw_call(dev->mfc_ops,
531                                                 get_min_scratch_buf_size, dev);
532                 if (ctx->img_width == 0 || ctx->img_height == 0)
533                         ctx->state = MFCINST_ERROR;
534                 else
535                         ctx->state = MFCINST_HEAD_PARSED;
536
537                 if ((ctx->codec_mode == S5P_MFC_CODEC_H264_DEC ||
538                         ctx->codec_mode == S5P_MFC_CODEC_H264_MVC_DEC) &&
539                                 !list_empty(&ctx->src_queue)) {
540                         struct s5p_mfc_buf *src_buf;
541                         src_buf = list_entry(ctx->src_queue.next,
542                                         struct s5p_mfc_buf, list);
543                         if (s5p_mfc_hw_call(dev->mfc_ops, get_consumed_stream,
544                                                 dev) <
545                                         src_buf->b->vb2_buf.planes[0].bytesused)
546                                 ctx->head_processed = 0;
547                         else
548                                 ctx->head_processed = 1;
549                 } else {
550                         ctx->head_processed = 1;
551                 }
552         }
553         s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
554         clear_work_bit(ctx);
555         WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
556         s5p_mfc_clock_off();
557         s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
558         wake_up_ctx(ctx, reason, err);
559 }
560
561 /* Header parsing interrupt handling */
562 static void s5p_mfc_handle_init_buffers(struct s5p_mfc_ctx *ctx,
563                                  unsigned int reason, unsigned int err)
564 {
565         struct s5p_mfc_buf *src_buf;
566         struct s5p_mfc_dev *dev;
567
568         if (!ctx)
569                 return;
570         dev = ctx->dev;
571         s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
572         ctx->int_type = reason;
573         ctx->int_err = err;
574         ctx->int_cond = 1;
575         clear_work_bit(ctx);
576         if (err == 0) {
577                 ctx->state = MFCINST_RUNNING;
578                 if (!ctx->dpb_flush_flag && ctx->head_processed) {
579                         if (!list_empty(&ctx->src_queue)) {
580                                 src_buf = list_entry(ctx->src_queue.next,
581                                              struct s5p_mfc_buf, list);
582                                 list_del(&src_buf->list);
583                                 ctx->src_queue_cnt--;
584                                 vb2_buffer_done(&src_buf->b->vb2_buf,
585                                                 VB2_BUF_STATE_DONE);
586                         }
587                 } else {
588                         ctx->dpb_flush_flag = 0;
589                 }
590                 WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
591
592                 s5p_mfc_clock_off();
593
594                 wake_up(&ctx->queue);
595                 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
596         } else {
597                 WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
598
599                 s5p_mfc_clock_off();
600
601                 wake_up(&ctx->queue);
602         }
603 }
604
605 static void s5p_mfc_handle_stream_complete(struct s5p_mfc_ctx *ctx)
606 {
607         struct s5p_mfc_dev *dev = ctx->dev;
608         struct s5p_mfc_buf *mb_entry;
609
610         mfc_debug(2, "Stream completed\n");
611
612         ctx->state = MFCINST_FINISHED;
613
614         if (!list_empty(&ctx->dst_queue)) {
615                 mb_entry = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf,
616                                                                         list);
617                 list_del(&mb_entry->list);
618                 ctx->dst_queue_cnt--;
619                 vb2_set_plane_payload(&mb_entry->b->vb2_buf, 0, 0);
620                 vb2_buffer_done(&mb_entry->b->vb2_buf, VB2_BUF_STATE_DONE);
621         }
622
623         clear_work_bit(ctx);
624
625         WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
626
627         s5p_mfc_clock_off();
628         wake_up(&ctx->queue);
629         s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
630 }
631
632 /* Interrupt processing */
633 static irqreturn_t s5p_mfc_irq(int irq, void *priv)
634 {
635         struct s5p_mfc_dev *dev = priv;
636         struct s5p_mfc_ctx *ctx;
637         unsigned int reason;
638         unsigned int err;
639
640         mfc_debug_enter();
641         /* Reset the timeout watchdog */
642         atomic_set(&dev->watchdog_cnt, 0);
643         spin_lock(&dev->irqlock);
644         ctx = dev->ctx[dev->curr_ctx];
645         /* Get the reason of interrupt and the error code */
646         reason = s5p_mfc_hw_call(dev->mfc_ops, get_int_reason, dev);
647         err = s5p_mfc_hw_call(dev->mfc_ops, get_int_err, dev);
648         mfc_debug(1, "Int reason: %d (err: %08x)\n", reason, err);
649         switch (reason) {
650         case S5P_MFC_R2H_CMD_ERR_RET:
651                 /* An error has occurred */
652                 if (ctx->state == MFCINST_RUNNING &&
653                         (s5p_mfc_hw_call(dev->mfc_ops, err_dec, err) >=
654                                 dev->warn_start ||
655                                 err == S5P_FIMV_ERR_NO_VALID_SEQ_HDR ||
656                                 err == S5P_FIMV_ERR_INCOMPLETE_FRAME ||
657                                 err == S5P_FIMV_ERR_TIMEOUT))
658                         s5p_mfc_handle_frame(ctx, reason, err);
659                 else
660                         s5p_mfc_handle_error(dev, ctx, reason, err);
661                 clear_bit(0, &dev->enter_suspend);
662                 break;
663
664         case S5P_MFC_R2H_CMD_SLICE_DONE_RET:
665         case S5P_MFC_R2H_CMD_FIELD_DONE_RET:
666         case S5P_MFC_R2H_CMD_FRAME_DONE_RET:
667                 if (ctx->c_ops->post_frame_start) {
668                         if (ctx->c_ops->post_frame_start(ctx))
669                                 mfc_err("post_frame_start() failed\n");
670
671                         if (ctx->state == MFCINST_FINISHING &&
672                                                 list_empty(&ctx->ref_queue)) {
673                                 s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
674                                 s5p_mfc_handle_stream_complete(ctx);
675                                 break;
676                         }
677                         s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
678                         WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
679                         s5p_mfc_clock_off();
680                         wake_up_ctx(ctx, reason, err);
681                         s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
682                 } else {
683                         s5p_mfc_handle_frame(ctx, reason, err);
684                 }
685                 break;
686
687         case S5P_MFC_R2H_CMD_SEQ_DONE_RET:
688                 s5p_mfc_handle_seq_done(ctx, reason, err);
689                 break;
690
691         case S5P_MFC_R2H_CMD_OPEN_INSTANCE_RET:
692                 ctx->inst_no = s5p_mfc_hw_call(dev->mfc_ops, get_inst_no, dev);
693                 ctx->state = MFCINST_GOT_INST;
694                 goto irq_cleanup_hw;
695
696         case S5P_MFC_R2H_CMD_CLOSE_INSTANCE_RET:
697                 ctx->inst_no = MFC_NO_INSTANCE_SET;
698                 ctx->state = MFCINST_FREE;
699                 goto irq_cleanup_hw;
700
701         case S5P_MFC_R2H_CMD_SYS_INIT_RET:
702         case S5P_MFC_R2H_CMD_FW_STATUS_RET:
703         case S5P_MFC_R2H_CMD_SLEEP_RET:
704         case S5P_MFC_R2H_CMD_WAKEUP_RET:
705                 if (ctx)
706                         clear_work_bit(ctx);
707                 s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
708                 clear_bit(0, &dev->hw_lock);
709                 clear_bit(0, &dev->enter_suspend);
710                 wake_up_dev(dev, reason, err);
711                 break;
712
713         case S5P_MFC_R2H_CMD_INIT_BUFFERS_RET:
714                 s5p_mfc_handle_init_buffers(ctx, reason, err);
715                 break;
716
717         case S5P_MFC_R2H_CMD_COMPLETE_SEQ_RET:
718                 s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
719                 ctx->int_type = reason;
720                 ctx->int_err = err;
721                 s5p_mfc_handle_stream_complete(ctx);
722                 break;
723
724         case S5P_MFC_R2H_CMD_DPB_FLUSH_RET:
725                 ctx->state = MFCINST_RUNNING;
726                 goto irq_cleanup_hw;
727
728         default:
729                 mfc_debug(2, "Unknown int reason\n");
730                 s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
731         }
732         spin_unlock(&dev->irqlock);
733         mfc_debug_leave();
734         return IRQ_HANDLED;
735 irq_cleanup_hw:
736         s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
737         ctx->int_type = reason;
738         ctx->int_err = err;
739         ctx->int_cond = 1;
740         if (test_and_clear_bit(0, &dev->hw_lock) == 0)
741                 mfc_err("Failed to unlock hw\n");
742
743         s5p_mfc_clock_off();
744         clear_work_bit(ctx);
745         wake_up(&ctx->queue);
746
747         s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
748         spin_unlock(&dev->irqlock);
749         mfc_debug(2, "Exit via irq_cleanup_hw\n");
750         return IRQ_HANDLED;
751 }
752
753 /* Open an MFC node */
754 static int s5p_mfc_open(struct file *file)
755 {
756         struct video_device *vdev = video_devdata(file);
757         struct s5p_mfc_dev *dev = video_drvdata(file);
758         struct s5p_mfc_ctx *ctx = NULL;
759         struct vb2_queue *q;
760         int ret = 0;
761
762         mfc_debug_enter();
763         if (mutex_lock_interruptible(&dev->mfc_mutex))
764                 return -ERESTARTSYS;
765         dev->num_inst++;        /* It is guarded by mfc_mutex in vfd */
766         /* Allocate memory for context */
767         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
768         if (!ctx) {
769                 ret = -ENOMEM;
770                 goto err_alloc;
771         }
772         init_waitqueue_head(&ctx->queue);
773         v4l2_fh_init(&ctx->fh, vdev);
774         file->private_data = &ctx->fh;
775         v4l2_fh_add(&ctx->fh);
776         ctx->dev = dev;
777         INIT_LIST_HEAD(&ctx->src_queue);
778         INIT_LIST_HEAD(&ctx->dst_queue);
779         ctx->src_queue_cnt = 0;
780         ctx->dst_queue_cnt = 0;
781         /* Get context number */
782         ctx->num = 0;
783         while (dev->ctx[ctx->num]) {
784                 ctx->num++;
785                 if (ctx->num >= MFC_NUM_CONTEXTS) {
786                         mfc_debug(2, "Too many open contexts\n");
787                         ret = -EBUSY;
788                         goto err_no_ctx;
789                 }
790         }
791         /* Mark context as idle */
792         clear_work_bit_irqsave(ctx);
793         dev->ctx[ctx->num] = ctx;
794         if (vdev == dev->vfd_dec) {
795                 ctx->type = MFCINST_DECODER;
796                 ctx->c_ops = get_dec_codec_ops();
797                 s5p_mfc_dec_init(ctx);
798                 /* Setup ctrl handler */
799                 ret = s5p_mfc_dec_ctrls_setup(ctx);
800                 if (ret) {
801                         mfc_err("Failed to setup mfc controls\n");
802                         goto err_ctrls_setup;
803                 }
804         } else if (vdev == dev->vfd_enc) {
805                 ctx->type = MFCINST_ENCODER;
806                 ctx->c_ops = get_enc_codec_ops();
807                 /* only for encoder */
808                 INIT_LIST_HEAD(&ctx->ref_queue);
809                 ctx->ref_queue_cnt = 0;
810                 s5p_mfc_enc_init(ctx);
811                 /* Setup ctrl handler */
812                 ret = s5p_mfc_enc_ctrls_setup(ctx);
813                 if (ret) {
814                         mfc_err("Failed to setup mfc controls\n");
815                         goto err_ctrls_setup;
816                 }
817         } else {
818                 ret = -ENOENT;
819                 goto err_bad_node;
820         }
821         ctx->fh.ctrl_handler = &ctx->ctrl_handler;
822         ctx->inst_no = MFC_NO_INSTANCE_SET;
823         /* Load firmware if this is the first instance */
824         if (dev->num_inst == 1) {
825                 dev->watchdog_timer.expires = jiffies +
826                                         msecs_to_jiffies(MFC_WATCHDOG_INTERVAL);
827                 add_timer(&dev->watchdog_timer);
828                 ret = s5p_mfc_power_on();
829                 if (ret < 0) {
830                         mfc_err("power on failed\n");
831                         goto err_pwr_enable;
832                 }
833                 s5p_mfc_clock_on();
834                 ret = s5p_mfc_load_firmware(dev);
835                 if (ret) {
836                         s5p_mfc_clock_off();
837                         goto err_load_fw;
838                 }
839                 /* Init the FW */
840                 ret = s5p_mfc_init_hw(dev);
841                 s5p_mfc_clock_off();
842                 if (ret)
843                         goto err_init_hw;
844         }
845         /* Init videobuf2 queue for CAPTURE */
846         q = &ctx->vq_dst;
847         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
848         q->drv_priv = &ctx->fh;
849         q->lock = &dev->mfc_mutex;
850         if (vdev == dev->vfd_dec) {
851                 q->io_modes = VB2_MMAP;
852                 q->ops = get_dec_queue_ops();
853         } else if (vdev == dev->vfd_enc) {
854                 q->io_modes = VB2_MMAP | VB2_USERPTR;
855                 q->ops = get_enc_queue_ops();
856         } else {
857                 ret = -ENOENT;
858                 goto err_queue_init;
859         }
860         /*
861          * We'll do mostly sequential access, so sacrifice TLB efficiency for
862          * faster allocation.
863          */
864         q->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES;
865         q->mem_ops = &vb2_dma_contig_memops;
866         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
867         ret = vb2_queue_init(q);
868         if (ret) {
869                 mfc_err("Failed to initialize videobuf2 queue(capture)\n");
870                 goto err_queue_init;
871         }
872         /* Init videobuf2 queue for OUTPUT */
873         q = &ctx->vq_src;
874         q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
875         q->drv_priv = &ctx->fh;
876         q->lock = &dev->mfc_mutex;
877         if (vdev == dev->vfd_dec) {
878                 q->io_modes = VB2_MMAP;
879                 q->ops = get_dec_queue_ops();
880         } else if (vdev == dev->vfd_enc) {
881                 q->io_modes = VB2_MMAP | VB2_USERPTR;
882                 q->ops = get_enc_queue_ops();
883         } else {
884                 ret = -ENOENT;
885                 goto err_queue_init;
886         }
887         /* One way to indicate end-of-stream for MFC is to set the
888          * bytesused == 0. However by default videobuf2 handles bytesused
889          * equal to 0 as a special case and changes its value to the size
890          * of the buffer. Set the allow_zero_bytesused flag so that videobuf2
891          * will keep the value of bytesused intact.
892          */
893         q->allow_zero_bytesused = 1;
894
895         /*
896          * We'll do mostly sequential access, so sacrifice TLB efficiency for
897          * faster allocation.
898          */
899         q->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES;
900         q->mem_ops = &vb2_dma_contig_memops;
901         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
902         ret = vb2_queue_init(q);
903         if (ret) {
904                 mfc_err("Failed to initialize videobuf2 queue(output)\n");
905                 goto err_queue_init;
906         }
907         mutex_unlock(&dev->mfc_mutex);
908         mfc_debug_leave();
909         return ret;
910         /* Deinit when failure occurred */
911 err_queue_init:
912         if (dev->num_inst == 1)
913                 s5p_mfc_deinit_hw(dev);
914 err_init_hw:
915 err_load_fw:
916 err_pwr_enable:
917         if (dev->num_inst == 1) {
918                 if (s5p_mfc_power_off() < 0)
919                         mfc_err("power off failed\n");
920                 del_timer_sync(&dev->watchdog_timer);
921         }
922 err_ctrls_setup:
923         s5p_mfc_dec_ctrls_delete(ctx);
924 err_bad_node:
925         dev->ctx[ctx->num] = NULL;
926 err_no_ctx:
927         v4l2_fh_del(&ctx->fh);
928         v4l2_fh_exit(&ctx->fh);
929         kfree(ctx);
930 err_alloc:
931         dev->num_inst--;
932         mutex_unlock(&dev->mfc_mutex);
933         mfc_debug_leave();
934         return ret;
935 }
936
937 /* Release MFC context */
938 static int s5p_mfc_release(struct file *file)
939 {
940         struct s5p_mfc_ctx *ctx = fh_to_ctx(file->private_data);
941         struct s5p_mfc_dev *dev = ctx->dev;
942
943         /* if dev is null, do cleanup that doesn't need dev */
944         mfc_debug_enter();
945         if (dev)
946                 mutex_lock(&dev->mfc_mutex);
947         vb2_queue_release(&ctx->vq_src);
948         vb2_queue_release(&ctx->vq_dst);
949         if (dev) {
950                 s5p_mfc_clock_on();
951
952                 /* Mark context as idle */
953                 clear_work_bit_irqsave(ctx);
954                 /*
955                  * If instance was initialised and not yet freed,
956                  * return instance and free resources
957                 */
958                 if (ctx->state != MFCINST_FREE && ctx->state != MFCINST_INIT) {
959                         mfc_debug(2, "Has to free instance\n");
960                         s5p_mfc_close_mfc_inst(dev, ctx);
961                 }
962                 /* hardware locking scheme */
963                 if (dev->curr_ctx == ctx->num)
964                         clear_bit(0, &dev->hw_lock);
965                 dev->num_inst--;
966                 if (dev->num_inst == 0) {
967                         mfc_debug(2, "Last instance\n");
968                         s5p_mfc_deinit_hw(dev);
969                         del_timer_sync(&dev->watchdog_timer);
970                         s5p_mfc_clock_off();
971                         if (s5p_mfc_power_off() < 0)
972                                 mfc_err("Power off failed\n");
973                 } else {
974                         mfc_debug(2, "Shutting down clock\n");
975                         s5p_mfc_clock_off();
976                 }
977         }
978         if (dev)
979                 dev->ctx[ctx->num] = NULL;
980         s5p_mfc_dec_ctrls_delete(ctx);
981         v4l2_fh_del(&ctx->fh);
982         /* vdev is gone if dev is null */
983         if (dev)
984                 v4l2_fh_exit(&ctx->fh);
985         kfree(ctx);
986         mfc_debug_leave();
987         if (dev)
988                 mutex_unlock(&dev->mfc_mutex);
989
990         return 0;
991 }
992
993 /* Poll */
994 static __poll_t s5p_mfc_poll(struct file *file,
995                                  struct poll_table_struct *wait)
996 {
997         struct s5p_mfc_ctx *ctx = fh_to_ctx(file->private_data);
998         struct s5p_mfc_dev *dev = ctx->dev;
999         struct vb2_queue *src_q, *dst_q;
1000         struct vb2_buffer *src_vb = NULL, *dst_vb = NULL;
1001         __poll_t rc = 0;
1002         unsigned long flags;
1003
1004         mutex_lock(&dev->mfc_mutex);
1005         src_q = &ctx->vq_src;
1006         dst_q = &ctx->vq_dst;
1007         /*
1008          * There has to be at least one buffer queued on each queued_list, which
1009          * means either in driver already or waiting for driver to claim it
1010          * and start processing.
1011          */
1012         if ((!src_q->streaming || list_empty(&src_q->queued_list))
1013                 && (!dst_q->streaming || list_empty(&dst_q->queued_list))) {
1014                 rc = EPOLLERR;
1015                 goto end;
1016         }
1017         mutex_unlock(&dev->mfc_mutex);
1018         poll_wait(file, &ctx->fh.wait, wait);
1019         poll_wait(file, &src_q->done_wq, wait);
1020         poll_wait(file, &dst_q->done_wq, wait);
1021         mutex_lock(&dev->mfc_mutex);
1022         if (v4l2_event_pending(&ctx->fh))
1023                 rc |= EPOLLPRI;
1024         spin_lock_irqsave(&src_q->done_lock, flags);
1025         if (!list_empty(&src_q->done_list))
1026                 src_vb = list_first_entry(&src_q->done_list, struct vb2_buffer,
1027                                                                 done_entry);
1028         if (src_vb && (src_vb->state == VB2_BUF_STATE_DONE
1029                                 || src_vb->state == VB2_BUF_STATE_ERROR))
1030                 rc |= EPOLLOUT | EPOLLWRNORM;
1031         spin_unlock_irqrestore(&src_q->done_lock, flags);
1032         spin_lock_irqsave(&dst_q->done_lock, flags);
1033         if (!list_empty(&dst_q->done_list))
1034                 dst_vb = list_first_entry(&dst_q->done_list, struct vb2_buffer,
1035                                                                 done_entry);
1036         if (dst_vb && (dst_vb->state == VB2_BUF_STATE_DONE
1037                                 || dst_vb->state == VB2_BUF_STATE_ERROR))
1038                 rc |= EPOLLIN | EPOLLRDNORM;
1039         spin_unlock_irqrestore(&dst_q->done_lock, flags);
1040 end:
1041         mutex_unlock(&dev->mfc_mutex);
1042         return rc;
1043 }
1044
1045 /* Mmap */
1046 static int s5p_mfc_mmap(struct file *file, struct vm_area_struct *vma)
1047 {
1048         struct s5p_mfc_ctx *ctx = fh_to_ctx(file->private_data);
1049         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1050         int ret;
1051
1052         if (offset < DST_QUEUE_OFF_BASE) {
1053                 mfc_debug(2, "mmaping source\n");
1054                 ret = vb2_mmap(&ctx->vq_src, vma);
1055         } else {                /* capture */
1056                 mfc_debug(2, "mmaping destination\n");
1057                 vma->vm_pgoff -= (DST_QUEUE_OFF_BASE >> PAGE_SHIFT);
1058                 ret = vb2_mmap(&ctx->vq_dst, vma);
1059         }
1060         return ret;
1061 }
1062
1063 /* v4l2 ops */
1064 static const struct v4l2_file_operations s5p_mfc_fops = {
1065         .owner = THIS_MODULE,
1066         .open = s5p_mfc_open,
1067         .release = s5p_mfc_release,
1068         .poll = s5p_mfc_poll,
1069         .unlocked_ioctl = video_ioctl2,
1070         .mmap = s5p_mfc_mmap,
1071 };
1072
1073 /* DMA memory related helper functions */
1074 static void s5p_mfc_memdev_release(struct device *dev)
1075 {
1076         of_reserved_mem_device_release(dev);
1077 }
1078
1079 static struct device *s5p_mfc_alloc_memdev(struct device *dev,
1080                                            const char *name, unsigned int idx)
1081 {
1082         struct device *child;
1083         int ret;
1084
1085         child = devm_kzalloc(dev, sizeof(*child), GFP_KERNEL);
1086         if (!child)
1087                 return NULL;
1088
1089         device_initialize(child);
1090         dev_set_name(child, "%s:%s", dev_name(dev), name);
1091         child->parent = dev;
1092         child->coherent_dma_mask = dev->coherent_dma_mask;
1093         child->dma_mask = dev->dma_mask;
1094         child->release = s5p_mfc_memdev_release;
1095
1096         /*
1097          * The memdevs are not proper OF platform devices, so in order for them
1098          * to be treated as valid DMA masters we need a bit of a hack to force
1099          * them to inherit the MFC node's DMA configuration.
1100          */
1101         of_dma_configure(child, dev->of_node, true);
1102
1103         if (device_add(child) == 0) {
1104                 ret = of_reserved_mem_device_init_by_idx(child, dev->of_node,
1105                                                          idx);
1106                 if (ret == 0)
1107                         return child;
1108                 device_del(child);
1109         }
1110
1111         put_device(child);
1112         return NULL;
1113 }
1114
1115 static int s5p_mfc_configure_2port_memory(struct s5p_mfc_dev *mfc_dev)
1116 {
1117         struct device *dev = &mfc_dev->plat_dev->dev;
1118         void *bank2_virt;
1119         dma_addr_t bank2_dma_addr;
1120         unsigned long align_size = 1 << MFC_BASE_ALIGN_ORDER;
1121         int ret;
1122
1123         /*
1124          * Create and initialize virtual devices for accessing
1125          * reserved memory regions.
1126          */
1127         mfc_dev->mem_dev[BANK_L_CTX] = s5p_mfc_alloc_memdev(dev, "left",
1128                                                            BANK_L_CTX);
1129         if (!mfc_dev->mem_dev[BANK_L_CTX])
1130                 return -ENODEV;
1131         mfc_dev->mem_dev[BANK_R_CTX] = s5p_mfc_alloc_memdev(dev, "right",
1132                                                            BANK_R_CTX);
1133         if (!mfc_dev->mem_dev[BANK_R_CTX]) {
1134                 device_unregister(mfc_dev->mem_dev[BANK_L_CTX]);
1135                 return -ENODEV;
1136         }
1137
1138         /* Allocate memory for firmware and initialize both banks addresses */
1139         ret = s5p_mfc_alloc_firmware(mfc_dev);
1140         if (ret) {
1141                 device_unregister(mfc_dev->mem_dev[BANK_R_CTX]);
1142                 device_unregister(mfc_dev->mem_dev[BANK_L_CTX]);
1143                 return ret;
1144         }
1145
1146         mfc_dev->dma_base[BANK_L_CTX] = mfc_dev->fw_buf.dma;
1147
1148         bank2_virt = dma_alloc_coherent(mfc_dev->mem_dev[BANK_R_CTX],
1149                                        align_size, &bank2_dma_addr, GFP_KERNEL);
1150         if (!bank2_virt) {
1151                 mfc_err("Allocating bank2 base failed\n");
1152                 s5p_mfc_release_firmware(mfc_dev);
1153                 device_unregister(mfc_dev->mem_dev[BANK_R_CTX]);
1154                 device_unregister(mfc_dev->mem_dev[BANK_L_CTX]);
1155                 return -ENOMEM;
1156         }
1157
1158         /* Valid buffers passed to MFC encoder with LAST_FRAME command
1159          * should not have address of bank2 - MFC will treat it as a null frame.
1160          * To avoid such situation we set bank2 address below the pool address.
1161          */
1162         mfc_dev->dma_base[BANK_R_CTX] = bank2_dma_addr - align_size;
1163
1164         dma_free_coherent(mfc_dev->mem_dev[BANK_R_CTX], align_size, bank2_virt,
1165                           bank2_dma_addr);
1166
1167         vb2_dma_contig_set_max_seg_size(mfc_dev->mem_dev[BANK_L_CTX],
1168                                         DMA_BIT_MASK(32));
1169         vb2_dma_contig_set_max_seg_size(mfc_dev->mem_dev[BANK_R_CTX],
1170                                         DMA_BIT_MASK(32));
1171
1172         return 0;
1173 }
1174
1175 static void s5p_mfc_unconfigure_2port_memory(struct s5p_mfc_dev *mfc_dev)
1176 {
1177         device_unregister(mfc_dev->mem_dev[BANK_L_CTX]);
1178         device_unregister(mfc_dev->mem_dev[BANK_R_CTX]);
1179         vb2_dma_contig_clear_max_seg_size(mfc_dev->mem_dev[BANK_L_CTX]);
1180         vb2_dma_contig_clear_max_seg_size(mfc_dev->mem_dev[BANK_R_CTX]);
1181 }
1182
1183 static int s5p_mfc_configure_common_memory(struct s5p_mfc_dev *mfc_dev)
1184 {
1185         struct device *dev = &mfc_dev->plat_dev->dev;
1186         unsigned long mem_size = SZ_4M;
1187         unsigned int bitmap_size;
1188
1189         if (IS_ENABLED(CONFIG_DMA_CMA) || exynos_is_iommu_available(dev))
1190                 mem_size = SZ_8M;
1191
1192         if (mfc_mem_size)
1193                 mem_size = memparse(mfc_mem_size, NULL);
1194
1195         bitmap_size = BITS_TO_LONGS(mem_size >> PAGE_SHIFT) * sizeof(long);
1196
1197         mfc_dev->mem_bitmap = kzalloc(bitmap_size, GFP_KERNEL);
1198         if (!mfc_dev->mem_bitmap)
1199                 return -ENOMEM;
1200
1201         mfc_dev->mem_virt = dma_alloc_coherent(dev, mem_size,
1202                                                &mfc_dev->mem_base, GFP_KERNEL);
1203         if (!mfc_dev->mem_virt) {
1204                 kfree(mfc_dev->mem_bitmap);
1205                 dev_err(dev, "failed to preallocate %ld MiB for the firmware and context buffers\n",
1206                         (mem_size / SZ_1M));
1207                 return -ENOMEM;
1208         }
1209         mfc_dev->mem_size = mem_size;
1210         mfc_dev->dma_base[BANK_L_CTX] = mfc_dev->mem_base;
1211         mfc_dev->dma_base[BANK_R_CTX] = mfc_dev->mem_base;
1212
1213         /*
1214          * MFC hardware cannot handle 0 as a base address, so mark first 128K
1215          * as used (to keep required base alignment) and adjust base address
1216          */
1217         if (mfc_dev->mem_base == (dma_addr_t)0) {
1218                 unsigned int offset = 1 << MFC_BASE_ALIGN_ORDER;
1219
1220                 bitmap_set(mfc_dev->mem_bitmap, 0, offset >> PAGE_SHIFT);
1221                 mfc_dev->dma_base[BANK_L_CTX] += offset;
1222                 mfc_dev->dma_base[BANK_R_CTX] += offset;
1223         }
1224
1225         /* Firmware allocation cannot fail in this case */
1226         s5p_mfc_alloc_firmware(mfc_dev);
1227
1228         mfc_dev->mem_dev[BANK_L_CTX] = mfc_dev->mem_dev[BANK_R_CTX] = dev;
1229         vb2_dma_contig_set_max_seg_size(dev, DMA_BIT_MASK(32));
1230
1231         dev_info(dev, "preallocated %ld MiB buffer for the firmware and context buffers\n",
1232                  (mem_size / SZ_1M));
1233
1234         return 0;
1235 }
1236
1237 static void s5p_mfc_unconfigure_common_memory(struct s5p_mfc_dev *mfc_dev)
1238 {
1239         struct device *dev = &mfc_dev->plat_dev->dev;
1240
1241         dma_free_coherent(dev, mfc_dev->mem_size, mfc_dev->mem_virt,
1242                           mfc_dev->mem_base);
1243         kfree(mfc_dev->mem_bitmap);
1244         vb2_dma_contig_clear_max_seg_size(dev);
1245 }
1246
1247 static int s5p_mfc_configure_dma_memory(struct s5p_mfc_dev *mfc_dev)
1248 {
1249         struct device *dev = &mfc_dev->plat_dev->dev;
1250
1251         if (exynos_is_iommu_available(dev) || !IS_TWOPORT(mfc_dev))
1252                 return s5p_mfc_configure_common_memory(mfc_dev);
1253         else
1254                 return s5p_mfc_configure_2port_memory(mfc_dev);
1255 }
1256
1257 static void s5p_mfc_unconfigure_dma_memory(struct s5p_mfc_dev *mfc_dev)
1258 {
1259         struct device *dev = &mfc_dev->plat_dev->dev;
1260
1261         s5p_mfc_release_firmware(mfc_dev);
1262         if (exynos_is_iommu_available(dev) || !IS_TWOPORT(mfc_dev))
1263                 s5p_mfc_unconfigure_common_memory(mfc_dev);
1264         else
1265                 s5p_mfc_unconfigure_2port_memory(mfc_dev);
1266 }
1267
1268 /* MFC probe function */
1269 static int s5p_mfc_probe(struct platform_device *pdev)
1270 {
1271         struct s5p_mfc_dev *dev;
1272         struct video_device *vfd;
1273         struct resource *res;
1274         int ret;
1275
1276         pr_debug("%s++\n", __func__);
1277         dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
1278         if (!dev)
1279                 return -ENOMEM;
1280
1281         spin_lock_init(&dev->irqlock);
1282         spin_lock_init(&dev->condlock);
1283         dev->plat_dev = pdev;
1284         if (!dev->plat_dev) {
1285                 dev_err(&pdev->dev, "No platform data specified\n");
1286                 return -ENODEV;
1287         }
1288
1289         dev->variant = of_device_get_match_data(&pdev->dev);
1290
1291         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1292         dev->regs_base = devm_ioremap_resource(&pdev->dev, res);
1293         if (IS_ERR(dev->regs_base))
1294                 return PTR_ERR(dev->regs_base);
1295
1296         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1297         if (!res) {
1298                 dev_err(&pdev->dev, "failed to get irq resource\n");
1299                 return -ENOENT;
1300         }
1301         dev->irq = res->start;
1302         ret = devm_request_irq(&pdev->dev, dev->irq, s5p_mfc_irq,
1303                                         0, pdev->name, dev);
1304         if (ret) {
1305                 dev_err(&pdev->dev, "Failed to install irq (%d)\n", ret);
1306                 return ret;
1307         }
1308
1309         ret = s5p_mfc_configure_dma_memory(dev);
1310         if (ret < 0) {
1311                 dev_err(&pdev->dev, "failed to configure DMA memory\n");
1312                 return ret;
1313         }
1314
1315         ret = s5p_mfc_init_pm(dev);
1316         if (ret < 0) {
1317                 dev_err(&pdev->dev, "failed to get mfc clock source\n");
1318                 goto err_dma;
1319         }
1320
1321         /*
1322          * Load fails if fs isn't mounted. Try loading anyway.
1323          * _open() will load it, it it fails now. Ignore failure.
1324          */
1325         s5p_mfc_load_firmware(dev);
1326
1327         mutex_init(&dev->mfc_mutex);
1328         init_waitqueue_head(&dev->queue);
1329         dev->hw_lock = 0;
1330         INIT_WORK(&dev->watchdog_work, s5p_mfc_watchdog_worker);
1331         atomic_set(&dev->watchdog_cnt, 0);
1332         timer_setup(&dev->watchdog_timer, s5p_mfc_watchdog, 0);
1333
1334         ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
1335         if (ret)
1336                 goto err_v4l2_dev_reg;
1337
1338         /* decoder */
1339         vfd = video_device_alloc();
1340         if (!vfd) {
1341                 v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
1342                 ret = -ENOMEM;
1343                 goto err_dec_alloc;
1344         }
1345         vfd->fops       = &s5p_mfc_fops;
1346         vfd->ioctl_ops  = get_dec_v4l2_ioctl_ops();
1347         vfd->release    = video_device_release;
1348         vfd->lock       = &dev->mfc_mutex;
1349         vfd->v4l2_dev   = &dev->v4l2_dev;
1350         vfd->vfl_dir    = VFL_DIR_M2M;
1351         set_bit(V4L2_FL_QUIRK_INVERTED_CROP, &vfd->flags);
1352         snprintf(vfd->name, sizeof(vfd->name), "%s", S5P_MFC_DEC_NAME);
1353         dev->vfd_dec    = vfd;
1354         video_set_drvdata(vfd, dev);
1355
1356         /* encoder */
1357         vfd = video_device_alloc();
1358         if (!vfd) {
1359                 v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
1360                 ret = -ENOMEM;
1361                 goto err_enc_alloc;
1362         }
1363         vfd->fops       = &s5p_mfc_fops;
1364         vfd->ioctl_ops  = get_enc_v4l2_ioctl_ops();
1365         vfd->release    = video_device_release;
1366         vfd->lock       = &dev->mfc_mutex;
1367         vfd->v4l2_dev   = &dev->v4l2_dev;
1368         vfd->vfl_dir    = VFL_DIR_M2M;
1369         snprintf(vfd->name, sizeof(vfd->name), "%s", S5P_MFC_ENC_NAME);
1370         dev->vfd_enc    = vfd;
1371         video_set_drvdata(vfd, dev);
1372         platform_set_drvdata(pdev, dev);
1373
1374         /* Initialize HW ops and commands based on MFC version */
1375         s5p_mfc_init_hw_ops(dev);
1376         s5p_mfc_init_hw_cmds(dev);
1377         s5p_mfc_init_regs(dev);
1378
1379         /* Register decoder and encoder */
1380         ret = video_register_device(dev->vfd_dec, VFL_TYPE_GRABBER, 0);
1381         if (ret) {
1382                 v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
1383                 goto err_dec_reg;
1384         }
1385         v4l2_info(&dev->v4l2_dev,
1386                   "decoder registered as /dev/video%d\n", dev->vfd_dec->num);
1387
1388         ret = video_register_device(dev->vfd_enc, VFL_TYPE_GRABBER, 0);
1389         if (ret) {
1390                 v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
1391                 goto err_enc_reg;
1392         }
1393         v4l2_info(&dev->v4l2_dev,
1394                   "encoder registered as /dev/video%d\n", dev->vfd_enc->num);
1395
1396         pr_debug("%s--\n", __func__);
1397         return 0;
1398
1399 /* Deinit MFC if probe had failed */
1400 err_enc_reg:
1401         video_unregister_device(dev->vfd_dec);
1402 err_dec_reg:
1403         video_device_release(dev->vfd_enc);
1404 err_enc_alloc:
1405         video_device_release(dev->vfd_dec);
1406 err_dec_alloc:
1407         v4l2_device_unregister(&dev->v4l2_dev);
1408 err_v4l2_dev_reg:
1409         s5p_mfc_final_pm(dev);
1410 err_dma:
1411         s5p_mfc_unconfigure_dma_memory(dev);
1412
1413         pr_debug("%s-- with error\n", __func__);
1414         return ret;
1415
1416 }
1417
1418 /* Remove the driver */
1419 static int s5p_mfc_remove(struct platform_device *pdev)
1420 {
1421         struct s5p_mfc_dev *dev = platform_get_drvdata(pdev);
1422         struct s5p_mfc_ctx *ctx;
1423         int i;
1424
1425         v4l2_info(&dev->v4l2_dev, "Removing %s\n", pdev->name);
1426
1427         /*
1428          * Clear ctx dev pointer to avoid races between s5p_mfc_remove()
1429          * and s5p_mfc_release() and s5p_mfc_release() accessing ctx->dev
1430          * after s5p_mfc_remove() is run during unbind.
1431         */
1432         mutex_lock(&dev->mfc_mutex);
1433         for (i = 0; i < MFC_NUM_CONTEXTS; i++) {
1434                 ctx = dev->ctx[i];
1435                 if (!ctx)
1436                         continue;
1437                 /* clear ctx->dev */
1438                 ctx->dev = NULL;
1439         }
1440         mutex_unlock(&dev->mfc_mutex);
1441
1442         del_timer_sync(&dev->watchdog_timer);
1443         flush_work(&dev->watchdog_work);
1444
1445         video_unregister_device(dev->vfd_enc);
1446         video_unregister_device(dev->vfd_dec);
1447         video_device_release(dev->vfd_enc);
1448         video_device_release(dev->vfd_dec);
1449         v4l2_device_unregister(&dev->v4l2_dev);
1450         s5p_mfc_unconfigure_dma_memory(dev);
1451
1452         s5p_mfc_final_pm(dev);
1453         return 0;
1454 }
1455
1456 #ifdef CONFIG_PM_SLEEP
1457
1458 static int s5p_mfc_suspend(struct device *dev)
1459 {
1460         struct s5p_mfc_dev *m_dev = dev_get_drvdata(dev);
1461         int ret;
1462
1463         if (m_dev->num_inst == 0)
1464                 return 0;
1465
1466         if (test_and_set_bit(0, &m_dev->enter_suspend) != 0) {
1467                 mfc_err("Error: going to suspend for a second time\n");
1468                 return -EIO;
1469         }
1470
1471         /* Check if we're processing then wait if it necessary. */
1472         while (test_and_set_bit(0, &m_dev->hw_lock) != 0) {
1473                 /* Try and lock the HW */
1474                 /* Wait on the interrupt waitqueue */
1475                 ret = wait_event_interruptible_timeout(m_dev->queue,
1476                         m_dev->int_cond, msecs_to_jiffies(MFC_INT_TIMEOUT));
1477                 if (ret == 0) {
1478                         mfc_err("Waiting for hardware to finish timed out\n");
1479                         clear_bit(0, &m_dev->enter_suspend);
1480                         return -EIO;
1481                 }
1482         }
1483
1484         ret = s5p_mfc_sleep(m_dev);
1485         if (ret) {
1486                 clear_bit(0, &m_dev->enter_suspend);
1487                 clear_bit(0, &m_dev->hw_lock);
1488         }
1489         return ret;
1490 }
1491
1492 static int s5p_mfc_resume(struct device *dev)
1493 {
1494         struct s5p_mfc_dev *m_dev = dev_get_drvdata(dev);
1495
1496         if (m_dev->num_inst == 0)
1497                 return 0;
1498         return s5p_mfc_wakeup(m_dev);
1499 }
1500 #endif
1501
1502 /* Power management */
1503 static const struct dev_pm_ops s5p_mfc_pm_ops = {
1504         SET_SYSTEM_SLEEP_PM_OPS(s5p_mfc_suspend, s5p_mfc_resume)
1505 };
1506
1507 static struct s5p_mfc_buf_size_v5 mfc_buf_size_v5 = {
1508         .h264_ctx       = MFC_H264_CTX_BUF_SIZE,
1509         .non_h264_ctx   = MFC_CTX_BUF_SIZE,
1510         .dsc            = DESC_BUF_SIZE,
1511         .shm            = SHARED_BUF_SIZE,
1512 };
1513
1514 static struct s5p_mfc_buf_size buf_size_v5 = {
1515         .fw     = MAX_FW_SIZE,
1516         .cpb    = MAX_CPB_SIZE,
1517         .priv   = &mfc_buf_size_v5,
1518 };
1519
1520 static struct s5p_mfc_variant mfc_drvdata_v5 = {
1521         .version        = MFC_VERSION,
1522         .version_bit    = MFC_V5_BIT,
1523         .port_num       = MFC_NUM_PORTS,
1524         .buf_size       = &buf_size_v5,
1525         .fw_name[0]     = "s5p-mfc.fw",
1526         .clk_names      = {"mfc", "sclk_mfc"},
1527         .num_clocks     = 2,
1528         .use_clock_gating = true,
1529 };
1530
1531 static struct s5p_mfc_buf_size_v6 mfc_buf_size_v6 = {
1532         .dev_ctx        = MFC_CTX_BUF_SIZE_V6,
1533         .h264_dec_ctx   = MFC_H264_DEC_CTX_BUF_SIZE_V6,
1534         .other_dec_ctx  = MFC_OTHER_DEC_CTX_BUF_SIZE_V6,
1535         .h264_enc_ctx   = MFC_H264_ENC_CTX_BUF_SIZE_V6,
1536         .other_enc_ctx  = MFC_OTHER_ENC_CTX_BUF_SIZE_V6,
1537 };
1538
1539 static struct s5p_mfc_buf_size buf_size_v6 = {
1540         .fw     = MAX_FW_SIZE_V6,
1541         .cpb    = MAX_CPB_SIZE_V6,
1542         .priv   = &mfc_buf_size_v6,
1543 };
1544
1545 static struct s5p_mfc_variant mfc_drvdata_v6 = {
1546         .version        = MFC_VERSION_V6,
1547         .version_bit    = MFC_V6_BIT,
1548         .port_num       = MFC_NUM_PORTS_V6,
1549         .buf_size       = &buf_size_v6,
1550         .fw_name[0]     = "s5p-mfc-v6.fw",
1551         /*
1552          * v6-v2 firmware contains bug fixes and interface change
1553          * for init buffer command
1554          */
1555         .fw_name[1]     = "s5p-mfc-v6-v2.fw",
1556         .clk_names      = {"mfc"},
1557         .num_clocks     = 1,
1558 };
1559
1560 static struct s5p_mfc_buf_size_v6 mfc_buf_size_v7 = {
1561         .dev_ctx        = MFC_CTX_BUF_SIZE_V7,
1562         .h264_dec_ctx   = MFC_H264_DEC_CTX_BUF_SIZE_V7,
1563         .other_dec_ctx  = MFC_OTHER_DEC_CTX_BUF_SIZE_V7,
1564         .h264_enc_ctx   = MFC_H264_ENC_CTX_BUF_SIZE_V7,
1565         .other_enc_ctx  = MFC_OTHER_ENC_CTX_BUF_SIZE_V7,
1566 };
1567
1568 static struct s5p_mfc_buf_size buf_size_v7 = {
1569         .fw     = MAX_FW_SIZE_V7,
1570         .cpb    = MAX_CPB_SIZE_V7,
1571         .priv   = &mfc_buf_size_v7,
1572 };
1573
1574 static struct s5p_mfc_variant mfc_drvdata_v7 = {
1575         .version        = MFC_VERSION_V7,
1576         .version_bit    = MFC_V7_BIT,
1577         .port_num       = MFC_NUM_PORTS_V7,
1578         .buf_size       = &buf_size_v7,
1579         .fw_name[0]     = "s5p-mfc-v7.fw",
1580         .clk_names      = {"mfc", "sclk_mfc"},
1581         .num_clocks     = 2,
1582 };
1583
1584 static struct s5p_mfc_buf_size_v6 mfc_buf_size_v8 = {
1585         .dev_ctx        = MFC_CTX_BUF_SIZE_V8,
1586         .h264_dec_ctx   = MFC_H264_DEC_CTX_BUF_SIZE_V8,
1587         .other_dec_ctx  = MFC_OTHER_DEC_CTX_BUF_SIZE_V8,
1588         .h264_enc_ctx   = MFC_H264_ENC_CTX_BUF_SIZE_V8,
1589         .other_enc_ctx  = MFC_OTHER_ENC_CTX_BUF_SIZE_V8,
1590 };
1591
1592 static struct s5p_mfc_buf_size buf_size_v8 = {
1593         .fw     = MAX_FW_SIZE_V8,
1594         .cpb    = MAX_CPB_SIZE_V8,
1595         .priv   = &mfc_buf_size_v8,
1596 };
1597
1598 static struct s5p_mfc_variant mfc_drvdata_v8 = {
1599         .version        = MFC_VERSION_V8,
1600         .version_bit    = MFC_V8_BIT,
1601         .port_num       = MFC_NUM_PORTS_V8,
1602         .buf_size       = &buf_size_v8,
1603         .fw_name[0]     = "s5p-mfc-v8.fw",
1604         .clk_names      = {"mfc"},
1605         .num_clocks     = 1,
1606 };
1607
1608 static struct s5p_mfc_variant mfc_drvdata_v8_5433 = {
1609         .version        = MFC_VERSION_V8,
1610         .version_bit    = MFC_V8_BIT,
1611         .port_num       = MFC_NUM_PORTS_V8,
1612         .buf_size       = &buf_size_v8,
1613         .fw_name[0]     = "s5p-mfc-v8.fw",
1614         .clk_names      = {"pclk", "aclk", "aclk_xiu"},
1615         .num_clocks     = 3,
1616 };
1617
1618 static struct s5p_mfc_buf_size_v6 mfc_buf_size_v10 = {
1619         .dev_ctx        = MFC_CTX_BUF_SIZE_V10,
1620         .h264_dec_ctx   = MFC_H264_DEC_CTX_BUF_SIZE_V10,
1621         .other_dec_ctx  = MFC_OTHER_DEC_CTX_BUF_SIZE_V10,
1622         .h264_enc_ctx   = MFC_H264_ENC_CTX_BUF_SIZE_V10,
1623         .hevc_enc_ctx   = MFC_HEVC_ENC_CTX_BUF_SIZE_V10,
1624         .other_enc_ctx  = MFC_OTHER_ENC_CTX_BUF_SIZE_V10,
1625 };
1626
1627 static struct s5p_mfc_buf_size buf_size_v10 = {
1628         .fw     = MAX_FW_SIZE_V10,
1629         .cpb    = MAX_CPB_SIZE_V10,
1630         .priv   = &mfc_buf_size_v10,
1631 };
1632
1633 static struct s5p_mfc_variant mfc_drvdata_v10 = {
1634         .version        = MFC_VERSION_V10,
1635         .version_bit    = MFC_V10_BIT,
1636         .port_num       = MFC_NUM_PORTS_V10,
1637         .buf_size       = &buf_size_v10,
1638         .fw_name[0]     = "s5p-mfc-v10.fw",
1639 };
1640
1641 static const struct of_device_id exynos_mfc_match[] = {
1642         {
1643                 .compatible = "samsung,mfc-v5",
1644                 .data = &mfc_drvdata_v5,
1645         }, {
1646                 .compatible = "samsung,mfc-v6",
1647                 .data = &mfc_drvdata_v6,
1648         }, {
1649                 .compatible = "samsung,mfc-v7",
1650                 .data = &mfc_drvdata_v7,
1651         }, {
1652                 .compatible = "samsung,mfc-v8",
1653                 .data = &mfc_drvdata_v8,
1654         }, {
1655                 .compatible = "samsung,exynos5433-mfc",
1656                 .data = &mfc_drvdata_v8_5433,
1657         }, {
1658                 .compatible = "samsung,mfc-v10",
1659                 .data = &mfc_drvdata_v10,
1660         },
1661         {},
1662 };
1663 MODULE_DEVICE_TABLE(of, exynos_mfc_match);
1664
1665 static struct platform_driver s5p_mfc_driver = {
1666         .probe          = s5p_mfc_probe,
1667         .remove         = s5p_mfc_remove,
1668         .driver = {
1669                 .name   = S5P_MFC_NAME,
1670                 .pm     = &s5p_mfc_pm_ops,
1671                 .of_match_table = exynos_mfc_match,
1672         },
1673 };
1674
1675 module_platform_driver(s5p_mfc_driver);
1676
1677 MODULE_LICENSE("GPL");
1678 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
1679 MODULE_DESCRIPTION("Samsung S5P Multi Format Codec V4L2 driver");
1680