6402f76cc620d4e7e937cd5d1e20532774b433c3
[sfrench/cifs-2.6.git] / drivers / media / platform / s5p-mfc / s5p_mfc_opr_v5.c
1 /*
2  * drivers/media/platform/samsung/mfc5/s5p_mfc_opr_v5.c
3  *
4  * Samsung MFC (Multi Function Codec - FIMV) driver
5  * This file contains hw related functions.
6  *
7  * Kamil Debski, Copyright (c) 2011 Samsung Electronics
8  * http://www.samsung.com/
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14
15 #include "s5p_mfc_common.h"
16 #include "s5p_mfc_cmd.h"
17 #include "s5p_mfc_ctrl.h"
18 #include "s5p_mfc_debug.h"
19 #include "s5p_mfc_intr.h"
20 #include "s5p_mfc_pm.h"
21 #include "s5p_mfc_opr.h"
22 #include "s5p_mfc_opr_v5.h"
23 #include <asm/cacheflush.h>
24 #include <linux/delay.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/err.h>
27 #include <linux/firmware.h>
28 #include <linux/io.h>
29 #include <linux/jiffies.h>
30 #include <linux/mm.h>
31 #include <linux/sched.h>
32
33 #define OFFSETA(x)              (((x) - dev->bank1) >> MFC_OFFSET_SHIFT)
34 #define OFFSETB(x)              (((x) - dev->bank2) >> MFC_OFFSET_SHIFT)
35
36 /* Allocate temporary buffers for decoding */
37 static int s5p_mfc_alloc_dec_temp_buffers_v5(struct s5p_mfc_ctx *ctx)
38 {
39         struct s5p_mfc_dev *dev = ctx->dev;
40         struct s5p_mfc_buf_size_v5 *buf_size = dev->variant->buf_size->priv;
41         int ret;
42
43         ctx->dsc.size = buf_size->dsc;
44         ret =  s5p_mfc_alloc_priv_buf(dev->mem_dev_l, dev->bank1, &ctx->dsc);
45         if (ret) {
46                 mfc_err("Failed to allocate temporary buffer\n");
47                 return ret;
48         }
49
50         BUG_ON(ctx->dsc.dma & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
51         memset(ctx->dsc.virt, 0, ctx->dsc.size);
52         wmb();
53         return 0;
54 }
55
56
57 /* Release temporary buffers for decoding */
58 static void s5p_mfc_release_dec_desc_buffer_v5(struct s5p_mfc_ctx *ctx)
59 {
60         s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->dsc);
61 }
62
63 /* Allocate codec buffers */
64 static int s5p_mfc_alloc_codec_buffers_v5(struct s5p_mfc_ctx *ctx)
65 {
66         struct s5p_mfc_dev *dev = ctx->dev;
67         unsigned int enc_ref_y_size = 0;
68         unsigned int enc_ref_c_size = 0;
69         unsigned int guard_width, guard_height;
70         int ret;
71
72         if (ctx->type == MFCINST_DECODER) {
73                 mfc_debug(2, "Luma size:%d Chroma size:%d MV size:%d\n",
74                           ctx->luma_size, ctx->chroma_size, ctx->mv_size);
75                 mfc_debug(2, "Totals bufs: %d\n", ctx->total_dpb_count);
76         } else if (ctx->type == MFCINST_ENCODER) {
77                 enc_ref_y_size = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN)
78                         * ALIGN(ctx->img_height, S5P_FIMV_NV12MT_VALIGN);
79                 enc_ref_y_size = ALIGN(enc_ref_y_size, S5P_FIMV_NV12MT_SALIGN);
80
81                 if (ctx->codec_mode == S5P_MFC_CODEC_H264_ENC) {
82                         enc_ref_c_size = ALIGN(ctx->img_width,
83                                                 S5P_FIMV_NV12MT_HALIGN)
84                                                 * ALIGN(ctx->img_height >> 1,
85                                                 S5P_FIMV_NV12MT_VALIGN);
86                         enc_ref_c_size = ALIGN(enc_ref_c_size,
87                                                         S5P_FIMV_NV12MT_SALIGN);
88                 } else {
89                         guard_width = ALIGN(ctx->img_width + 16,
90                                                         S5P_FIMV_NV12MT_HALIGN);
91                         guard_height = ALIGN((ctx->img_height >> 1) + 4,
92                                                         S5P_FIMV_NV12MT_VALIGN);
93                         enc_ref_c_size = ALIGN(guard_width * guard_height,
94                                                S5P_FIMV_NV12MT_SALIGN);
95                 }
96                 mfc_debug(2, "recon luma size: %d chroma size: %d\n",
97                           enc_ref_y_size, enc_ref_c_size);
98         } else {
99                 return -EINVAL;
100         }
101         /* Codecs have different memory requirements */
102         switch (ctx->codec_mode) {
103         case S5P_MFC_CODEC_H264_DEC:
104                 ctx->bank1.size =
105                     ALIGN(S5P_FIMV_DEC_NB_IP_SIZE +
106                                         S5P_FIMV_DEC_VERT_NB_MV_SIZE,
107                                         S5P_FIMV_DEC_BUF_ALIGN);
108                 ctx->bank2.size = ctx->total_dpb_count * ctx->mv_size;
109                 break;
110         case S5P_MFC_CODEC_MPEG4_DEC:
111                 ctx->bank1.size =
112                     ALIGN(S5P_FIMV_DEC_NB_DCAC_SIZE +
113                                      S5P_FIMV_DEC_UPNB_MV_SIZE +
114                                      S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE +
115                                      S5P_FIMV_DEC_STX_PARSER_SIZE +
116                                      S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE,
117                                      S5P_FIMV_DEC_BUF_ALIGN);
118                 ctx->bank2.size = 0;
119                 break;
120         case S5P_MFC_CODEC_VC1RCV_DEC:
121         case S5P_MFC_CODEC_VC1_DEC:
122                 ctx->bank1.size =
123                     ALIGN(S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE +
124                              S5P_FIMV_DEC_UPNB_MV_SIZE +
125                              S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE +
126                              S5P_FIMV_DEC_NB_DCAC_SIZE +
127                              3 * S5P_FIMV_DEC_VC1_BITPLANE_SIZE,
128                              S5P_FIMV_DEC_BUF_ALIGN);
129                 ctx->bank2.size = 0;
130                 break;
131         case S5P_MFC_CODEC_MPEG2_DEC:
132                 ctx->bank1.size = 0;
133                 ctx->bank2.size = 0;
134                 break;
135         case S5P_MFC_CODEC_H263_DEC:
136                 ctx->bank1.size =
137                     ALIGN(S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE +
138                              S5P_FIMV_DEC_UPNB_MV_SIZE +
139                              S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE +
140                              S5P_FIMV_DEC_NB_DCAC_SIZE,
141                              S5P_FIMV_DEC_BUF_ALIGN);
142                 ctx->bank2.size = 0;
143                 break;
144         case S5P_MFC_CODEC_H264_ENC:
145                 ctx->bank1.size = (enc_ref_y_size * 2) +
146                                    S5P_FIMV_ENC_UPMV_SIZE +
147                                    S5P_FIMV_ENC_COLFLG_SIZE +
148                                    S5P_FIMV_ENC_INTRAMD_SIZE +
149                                    S5P_FIMV_ENC_NBORINFO_SIZE;
150                 ctx->bank2.size = (enc_ref_y_size * 2) +
151                                    (enc_ref_c_size * 4) +
152                                    S5P_FIMV_ENC_INTRAPRED_SIZE;
153                 break;
154         case S5P_MFC_CODEC_MPEG4_ENC:
155                 ctx->bank1.size = (enc_ref_y_size * 2) +
156                                    S5P_FIMV_ENC_UPMV_SIZE +
157                                    S5P_FIMV_ENC_COLFLG_SIZE +
158                                    S5P_FIMV_ENC_ACDCCOEF_SIZE;
159                 ctx->bank2.size = (enc_ref_y_size * 2) +
160                                    (enc_ref_c_size * 4);
161                 break;
162         case S5P_MFC_CODEC_H263_ENC:
163                 ctx->bank1.size = (enc_ref_y_size * 2) +
164                                    S5P_FIMV_ENC_UPMV_SIZE +
165                                    S5P_FIMV_ENC_ACDCCOEF_SIZE;
166                 ctx->bank2.size = (enc_ref_y_size * 2) +
167                                    (enc_ref_c_size * 4);
168                 break;
169         default:
170                 break;
171         }
172         /* Allocate only if memory from bank 1 is necessary */
173         if (ctx->bank1.size > 0) {
174
175                 ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, dev->bank1,
176                                              &ctx->bank1);
177                 if (ret) {
178                         mfc_err("Failed to allocate Bank1 temporary buffer\n");
179                         return ret;
180                 }
181                 BUG_ON(ctx->bank1.dma & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
182         }
183         /* Allocate only if memory from bank 2 is necessary */
184         if (ctx->bank2.size > 0) {
185                 ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_r, dev->bank2,
186                                              &ctx->bank2);
187                 if (ret) {
188                         mfc_err("Failed to allocate Bank2 temporary buffer\n");
189                         s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->bank1);
190                         return ret;
191                 }
192                 BUG_ON(ctx->bank2.dma & ((1 << MFC_BANK2_ALIGN_ORDER) - 1));
193         }
194         return 0;
195 }
196
197 /* Release buffers allocated for codec */
198 static void s5p_mfc_release_codec_buffers_v5(struct s5p_mfc_ctx *ctx)
199 {
200         s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->bank1);
201         s5p_mfc_release_priv_buf(ctx->dev->mem_dev_r, &ctx->bank2);
202 }
203
204 /* Allocate memory for instance data buffer */
205 static int s5p_mfc_alloc_instance_buffer_v5(struct s5p_mfc_ctx *ctx)
206 {
207         struct s5p_mfc_dev *dev = ctx->dev;
208         struct s5p_mfc_buf_size_v5 *buf_size = dev->variant->buf_size->priv;
209         int ret;
210
211         if (ctx->codec_mode == S5P_MFC_CODEC_H264_DEC ||
212                 ctx->codec_mode == S5P_MFC_CODEC_H264_ENC)
213                 ctx->ctx.size = buf_size->h264_ctx;
214         else
215                 ctx->ctx.size = buf_size->non_h264_ctx;
216
217         ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, dev->bank1, &ctx->ctx);
218         if (ret) {
219                 mfc_err("Failed to allocate instance buffer\n");
220                 return ret;
221         }
222         ctx->ctx.ofs = OFFSETA(ctx->ctx.dma);
223
224         /* Zero content of the allocated memory */
225         memset(ctx->ctx.virt, 0, ctx->ctx.size);
226         wmb();
227
228         /* Initialize shared memory */
229         ctx->shm.size = buf_size->shm;
230         ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, dev->bank1, &ctx->shm);
231         if (ret) {
232                 mfc_err("Failed to allocate shared memory buffer\n");
233                 s5p_mfc_release_priv_buf(dev->mem_dev_l, &ctx->ctx);
234                 return ret;
235         }
236
237         /* shared memory offset only keeps the offset from base (port a) */
238         ctx->shm.ofs = ctx->shm.dma - dev->bank1;
239         BUG_ON(ctx->shm.ofs & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
240
241         memset(ctx->shm.virt, 0, buf_size->shm);
242         wmb();
243         return 0;
244 }
245
246 /* Release instance buffer */
247 static void s5p_mfc_release_instance_buffer_v5(struct s5p_mfc_ctx *ctx)
248 {
249         s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->ctx);
250         s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->shm);
251 }
252
253 static int s5p_mfc_alloc_dev_context_buffer_v5(struct s5p_mfc_dev *dev)
254 {
255         /* NOP */
256
257         return 0;
258 }
259
260 static void s5p_mfc_release_dev_context_buffer_v5(struct s5p_mfc_dev *dev)
261 {
262         /* NOP */
263 }
264
265 static void s5p_mfc_write_info_v5(struct s5p_mfc_ctx *ctx, unsigned int data,
266                         unsigned int ofs)
267 {
268         *(u32 *)(ctx->shm.virt + ofs) = data;
269         wmb();
270 }
271
272 static unsigned int s5p_mfc_read_info_v5(struct s5p_mfc_ctx *ctx,
273                                 unsigned long ofs)
274 {
275         rmb();
276         return *(u32 *)(ctx->shm.virt + ofs);
277 }
278
279 static void s5p_mfc_dec_calc_dpb_size_v5(struct s5p_mfc_ctx *ctx)
280 {
281         unsigned int guard_width, guard_height;
282
283         ctx->buf_width = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN);
284         ctx->buf_height = ALIGN(ctx->img_height, S5P_FIMV_NV12MT_VALIGN);
285         mfc_debug(2,
286                 "SEQ Done: Movie dimensions %dx%d, buffer dimensions: %dx%d\n",
287                 ctx->img_width, ctx->img_height, ctx->buf_width,
288                 ctx->buf_height);
289
290         if (ctx->codec_mode == S5P_MFC_CODEC_H264_DEC) {
291                 ctx->luma_size = ALIGN(ctx->buf_width * ctx->buf_height,
292                                 S5P_FIMV_DEC_BUF_ALIGN);
293                 ctx->chroma_size = ALIGN(ctx->buf_width *
294                                 ALIGN((ctx->img_height >> 1),
295                                         S5P_FIMV_NV12MT_VALIGN),
296                                 S5P_FIMV_DEC_BUF_ALIGN);
297                 ctx->mv_size = ALIGN(ctx->buf_width *
298                                 ALIGN((ctx->buf_height >> 2),
299                                         S5P_FIMV_NV12MT_VALIGN),
300                                 S5P_FIMV_DEC_BUF_ALIGN);
301         } else {
302                 guard_width =
303                         ALIGN(ctx->img_width + 24, S5P_FIMV_NV12MT_HALIGN);
304                 guard_height =
305                         ALIGN(ctx->img_height + 16, S5P_FIMV_NV12MT_VALIGN);
306                 ctx->luma_size = ALIGN(guard_width * guard_height,
307                                 S5P_FIMV_DEC_BUF_ALIGN);
308
309                 guard_width =
310                         ALIGN(ctx->img_width + 16, S5P_FIMV_NV12MT_HALIGN);
311                 guard_height =
312                         ALIGN((ctx->img_height >> 1) + 4,
313                                         S5P_FIMV_NV12MT_VALIGN);
314                 ctx->chroma_size = ALIGN(guard_width * guard_height,
315                                 S5P_FIMV_DEC_BUF_ALIGN);
316
317                 ctx->mv_size = 0;
318         }
319 }
320
321 static void s5p_mfc_enc_calc_src_size_v5(struct s5p_mfc_ctx *ctx)
322 {
323         if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_NV12M) {
324                 ctx->buf_width = ALIGN(ctx->img_width, S5P_FIMV_NV12M_HALIGN);
325
326                 ctx->luma_size = ALIGN(ctx->img_width, S5P_FIMV_NV12M_HALIGN)
327                         * ALIGN(ctx->img_height, S5P_FIMV_NV12M_LVALIGN);
328                 ctx->chroma_size = ALIGN(ctx->img_width, S5P_FIMV_NV12M_HALIGN)
329                         * ALIGN((ctx->img_height >> 1), S5P_FIMV_NV12M_CVALIGN);
330
331                 ctx->luma_size = ALIGN(ctx->luma_size, S5P_FIMV_NV12M_SALIGN);
332                 ctx->chroma_size =
333                         ALIGN(ctx->chroma_size, S5P_FIMV_NV12M_SALIGN);
334         } else if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_NV12MT) {
335                 ctx->buf_width = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN);
336
337                 ctx->luma_size = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN)
338                         * ALIGN(ctx->img_height, S5P_FIMV_NV12MT_VALIGN);
339                 ctx->chroma_size =
340                         ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN)
341                         * ALIGN((ctx->img_height >> 1), S5P_FIMV_NV12MT_VALIGN);
342
343                 ctx->luma_size = ALIGN(ctx->luma_size, S5P_FIMV_NV12MT_SALIGN);
344                 ctx->chroma_size =
345                         ALIGN(ctx->chroma_size, S5P_FIMV_NV12MT_SALIGN);
346         }
347 }
348
349 /* Set registers for decoding temporary buffers */
350 static void s5p_mfc_set_dec_desc_buffer(struct s5p_mfc_ctx *ctx)
351 {
352         struct s5p_mfc_dev *dev = ctx->dev;
353         struct s5p_mfc_buf_size_v5 *buf_size = dev->variant->buf_size->priv;
354
355         mfc_write(dev, OFFSETA(ctx->dsc.dma), S5P_FIMV_SI_CH0_DESC_ADR);
356         mfc_write(dev, buf_size->dsc, S5P_FIMV_SI_CH0_DESC_SIZE);
357 }
358
359 /* Set registers for shared buffer */
360 static void s5p_mfc_set_shared_buffer(struct s5p_mfc_ctx *ctx)
361 {
362         struct s5p_mfc_dev *dev = ctx->dev;
363         mfc_write(dev, ctx->shm.ofs, S5P_FIMV_SI_CH0_HOST_WR_ADR);
364 }
365
366 /* Set registers for decoding stream buffer */
367 static int s5p_mfc_set_dec_stream_buffer_v5(struct s5p_mfc_ctx *ctx,
368                 int buf_addr, unsigned int start_num_byte,
369                 unsigned int buf_size)
370 {
371         struct s5p_mfc_dev *dev = ctx->dev;
372
373         mfc_write(dev, OFFSETA(buf_addr), S5P_FIMV_SI_CH0_SB_ST_ADR);
374         mfc_write(dev, ctx->dec_src_buf_size, S5P_FIMV_SI_CH0_CPB_SIZE);
375         mfc_write(dev, buf_size, S5P_FIMV_SI_CH0_SB_FRM_SIZE);
376         s5p_mfc_write_info_v5(ctx, start_num_byte, START_BYTE_NUM);
377         return 0;
378 }
379
380 /* Set decoding frame buffer */
381 static int s5p_mfc_set_dec_frame_buffer_v5(struct s5p_mfc_ctx *ctx)
382 {
383         unsigned int frame_size_lu, i;
384         unsigned int frame_size_ch, frame_size_mv;
385         struct s5p_mfc_dev *dev = ctx->dev;
386         unsigned int dpb;
387         size_t buf_addr1, buf_addr2;
388         int buf_size1, buf_size2;
389
390         buf_addr1 = ctx->bank1.dma;
391         buf_size1 = ctx->bank1.size;
392         buf_addr2 = ctx->bank2.dma;
393         buf_size2 = ctx->bank2.size;
394         dpb = mfc_read(dev, S5P_FIMV_SI_CH0_DPB_CONF_CTRL) &
395                                                 ~S5P_FIMV_DPB_COUNT_MASK;
396         mfc_write(dev, ctx->total_dpb_count | dpb,
397                                                 S5P_FIMV_SI_CH0_DPB_CONF_CTRL);
398         s5p_mfc_set_shared_buffer(ctx);
399         switch (ctx->codec_mode) {
400         case S5P_MFC_CODEC_H264_DEC:
401                 mfc_write(dev, OFFSETA(buf_addr1),
402                                                 S5P_FIMV_H264_VERT_NB_MV_ADR);
403                 buf_addr1 += S5P_FIMV_DEC_VERT_NB_MV_SIZE;
404                 buf_size1 -= S5P_FIMV_DEC_VERT_NB_MV_SIZE;
405                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H264_NB_IP_ADR);
406                 buf_addr1 += S5P_FIMV_DEC_NB_IP_SIZE;
407                 buf_size1 -= S5P_FIMV_DEC_NB_IP_SIZE;
408                 break;
409         case S5P_MFC_CODEC_MPEG4_DEC:
410                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_MPEG4_NB_DCAC_ADR);
411                 buf_addr1 += S5P_FIMV_DEC_NB_DCAC_SIZE;
412                 buf_size1 -= S5P_FIMV_DEC_NB_DCAC_SIZE;
413                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_MPEG4_UP_NB_MV_ADR);
414                 buf_addr1 += S5P_FIMV_DEC_UPNB_MV_SIZE;
415                 buf_size1 -= S5P_FIMV_DEC_UPNB_MV_SIZE;
416                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_MPEG4_SA_MV_ADR);
417                 buf_addr1 += S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE;
418                 buf_size1 -= S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE;
419                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_MPEG4_SP_ADR);
420                 buf_addr1 += S5P_FIMV_DEC_STX_PARSER_SIZE;
421                 buf_size1 -= S5P_FIMV_DEC_STX_PARSER_SIZE;
422                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_MPEG4_OT_LINE_ADR);
423                 buf_addr1 += S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE;
424                 buf_size1 -= S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE;
425                 break;
426         case S5P_MFC_CODEC_H263_DEC:
427                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H263_OT_LINE_ADR);
428                 buf_addr1 += S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE;
429                 buf_size1 -= S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE;
430                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H263_UP_NB_MV_ADR);
431                 buf_addr1 += S5P_FIMV_DEC_UPNB_MV_SIZE;
432                 buf_size1 -= S5P_FIMV_DEC_UPNB_MV_SIZE;
433                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H263_SA_MV_ADR);
434                 buf_addr1 += S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE;
435                 buf_size1 -= S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE;
436                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H263_NB_DCAC_ADR);
437                 buf_addr1 += S5P_FIMV_DEC_NB_DCAC_SIZE;
438                 buf_size1 -= S5P_FIMV_DEC_NB_DCAC_SIZE;
439                 break;
440         case S5P_MFC_CODEC_VC1_DEC:
441         case S5P_MFC_CODEC_VC1RCV_DEC:
442                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_NB_DCAC_ADR);
443                 buf_addr1 += S5P_FIMV_DEC_NB_DCAC_SIZE;
444                 buf_size1 -= S5P_FIMV_DEC_NB_DCAC_SIZE;
445                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_OT_LINE_ADR);
446                 buf_addr1 += S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE;
447                 buf_size1 -= S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE;
448                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_UP_NB_MV_ADR);
449                 buf_addr1 += S5P_FIMV_DEC_UPNB_MV_SIZE;
450                 buf_size1 -= S5P_FIMV_DEC_UPNB_MV_SIZE;
451                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_SA_MV_ADR);
452                 buf_addr1 += S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE;
453                 buf_size1 -= S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE;
454                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_BITPLANE3_ADR);
455                 buf_addr1 += S5P_FIMV_DEC_VC1_BITPLANE_SIZE;
456                 buf_size1 -= S5P_FIMV_DEC_VC1_BITPLANE_SIZE;
457                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_BITPLANE2_ADR);
458                 buf_addr1 += S5P_FIMV_DEC_VC1_BITPLANE_SIZE;
459                 buf_size1 -= S5P_FIMV_DEC_VC1_BITPLANE_SIZE;
460                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_VC1_BITPLANE1_ADR);
461                 buf_addr1 += S5P_FIMV_DEC_VC1_BITPLANE_SIZE;
462                 buf_size1 -= S5P_FIMV_DEC_VC1_BITPLANE_SIZE;
463                 break;
464         case S5P_MFC_CODEC_MPEG2_DEC:
465                 break;
466         default:
467                 mfc_err("Unknown codec for decoding (%x)\n",
468                         ctx->codec_mode);
469                 return -EINVAL;
470         }
471         frame_size_lu = ctx->luma_size;
472         frame_size_ch = ctx->chroma_size;
473         frame_size_mv = ctx->mv_size;
474         mfc_debug(2, "Frm size: %d ch: %d mv: %d\n", frame_size_lu, frame_size_ch,
475                                                                 frame_size_mv);
476         for (i = 0; i < ctx->total_dpb_count; i++) {
477                 /* Bank2 */
478                 mfc_debug(2, "Luma %d: %zx\n", i,
479                                         ctx->dst_bufs[i].cookie.raw.luma);
480                 mfc_write(dev, OFFSETB(ctx->dst_bufs[i].cookie.raw.luma),
481                                                 S5P_FIMV_DEC_LUMA_ADR + i * 4);
482                 mfc_debug(2, "\tChroma %d: %zx\n", i,
483                                         ctx->dst_bufs[i].cookie.raw.chroma);
484                 mfc_write(dev, OFFSETA(ctx->dst_bufs[i].cookie.raw.chroma),
485                                                S5P_FIMV_DEC_CHROMA_ADR + i * 4);
486                 if (ctx->codec_mode == S5P_MFC_CODEC_H264_DEC) {
487                         mfc_debug(2, "\tBuf2: %zx, size: %d\n",
488                                                         buf_addr2, buf_size2);
489                         mfc_write(dev, OFFSETB(buf_addr2),
490                                                 S5P_FIMV_H264_MV_ADR + i * 4);
491                         buf_addr2 += frame_size_mv;
492                         buf_size2 -= frame_size_mv;
493                 }
494         }
495         mfc_debug(2, "Buf1: %zu, buf_size1: %d\n", buf_addr1, buf_size1);
496         mfc_debug(2, "Buf 1/2 size after: %d/%d (frames %d)\n",
497                         buf_size1,  buf_size2, ctx->total_dpb_count);
498         if (buf_size1 < 0 || buf_size2 < 0) {
499                 mfc_debug(2, "Not enough memory has been allocated\n");
500                 return -ENOMEM;
501         }
502         s5p_mfc_write_info_v5(ctx, frame_size_lu, ALLOC_LUMA_DPB_SIZE);
503         s5p_mfc_write_info_v5(ctx, frame_size_ch, ALLOC_CHROMA_DPB_SIZE);
504         if (ctx->codec_mode == S5P_MFC_CODEC_H264_DEC)
505                 s5p_mfc_write_info_v5(ctx, frame_size_mv, ALLOC_MV_SIZE);
506         mfc_write(dev, ((S5P_FIMV_CH_INIT_BUFS & S5P_FIMV_CH_MASK)
507                                         << S5P_FIMV_CH_SHIFT) | (ctx->inst_no),
508                                                 S5P_FIMV_SI_CH0_INST_ID);
509         return 0;
510 }
511
512 /* Set registers for encoding stream buffer */
513 static int s5p_mfc_set_enc_stream_buffer_v5(struct s5p_mfc_ctx *ctx,
514                 unsigned long addr, unsigned int size)
515 {
516         struct s5p_mfc_dev *dev = ctx->dev;
517
518         mfc_write(dev, OFFSETA(addr), S5P_FIMV_ENC_SI_CH0_SB_ADR);
519         mfc_write(dev, size, S5P_FIMV_ENC_SI_CH0_SB_SIZE);
520         return 0;
521 }
522
523 static void s5p_mfc_set_enc_frame_buffer_v5(struct s5p_mfc_ctx *ctx,
524                 unsigned long y_addr, unsigned long c_addr)
525 {
526         struct s5p_mfc_dev *dev = ctx->dev;
527
528         mfc_write(dev, OFFSETB(y_addr), S5P_FIMV_ENC_SI_CH0_CUR_Y_ADR);
529         mfc_write(dev, OFFSETB(c_addr), S5P_FIMV_ENC_SI_CH0_CUR_C_ADR);
530 }
531
532 static void s5p_mfc_get_enc_frame_buffer_v5(struct s5p_mfc_ctx *ctx,
533                 unsigned long *y_addr, unsigned long *c_addr)
534 {
535         struct s5p_mfc_dev *dev = ctx->dev;
536
537         *y_addr = dev->bank2 + (mfc_read(dev, S5P_FIMV_ENCODED_Y_ADDR)
538                                                         << MFC_OFFSET_SHIFT);
539         *c_addr = dev->bank2 + (mfc_read(dev, S5P_FIMV_ENCODED_C_ADDR)
540                                                         << MFC_OFFSET_SHIFT);
541 }
542
543 /* Set encoding ref & codec buffer */
544 static int s5p_mfc_set_enc_ref_buffer_v5(struct s5p_mfc_ctx *ctx)
545 {
546         struct s5p_mfc_dev *dev = ctx->dev;
547         size_t buf_addr1, buf_addr2;
548         size_t buf_size1, buf_size2;
549         unsigned int enc_ref_y_size, enc_ref_c_size;
550         unsigned int guard_width, guard_height;
551         int i;
552
553         buf_addr1 = ctx->bank1.dma;
554         buf_size1 = ctx->bank1.size;
555         buf_addr2 = ctx->bank2.dma;
556         buf_size2 = ctx->bank2.size;
557         enc_ref_y_size = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN)
558                 * ALIGN(ctx->img_height, S5P_FIMV_NV12MT_VALIGN);
559         enc_ref_y_size = ALIGN(enc_ref_y_size, S5P_FIMV_NV12MT_SALIGN);
560         if (ctx->codec_mode == S5P_MFC_CODEC_H264_ENC) {
561                 enc_ref_c_size = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN)
562                         * ALIGN((ctx->img_height >> 1), S5P_FIMV_NV12MT_VALIGN);
563                 enc_ref_c_size = ALIGN(enc_ref_c_size, S5P_FIMV_NV12MT_SALIGN);
564         } else {
565                 guard_width = ALIGN(ctx->img_width + 16,
566                                                 S5P_FIMV_NV12MT_HALIGN);
567                 guard_height = ALIGN((ctx->img_height >> 1) + 4,
568                                                 S5P_FIMV_NV12MT_VALIGN);
569                 enc_ref_c_size = ALIGN(guard_width * guard_height,
570                                        S5P_FIMV_NV12MT_SALIGN);
571         }
572         mfc_debug(2, "buf_size1: %zu, buf_size2: %zu\n", buf_size1, buf_size2);
573         switch (ctx->codec_mode) {
574         case S5P_MFC_CODEC_H264_ENC:
575                 for (i = 0; i < 2; i++) {
576                         mfc_write(dev, OFFSETA(buf_addr1),
577                                 S5P_FIMV_ENC_REF0_LUMA_ADR + (4 * i));
578                         buf_addr1 += enc_ref_y_size;
579                         buf_size1 -= enc_ref_y_size;
580
581                         mfc_write(dev, OFFSETB(buf_addr2),
582                                 S5P_FIMV_ENC_REF2_LUMA_ADR + (4 * i));
583                         buf_addr2 += enc_ref_y_size;
584                         buf_size2 -= enc_ref_y_size;
585                 }
586                 for (i = 0; i < 4; i++) {
587                         mfc_write(dev, OFFSETB(buf_addr2),
588                                 S5P_FIMV_ENC_REF0_CHROMA_ADR + (4 * i));
589                         buf_addr2 += enc_ref_c_size;
590                         buf_size2 -= enc_ref_c_size;
591                 }
592                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H264_UP_MV_ADR);
593                 buf_addr1 += S5P_FIMV_ENC_UPMV_SIZE;
594                 buf_size1 -= S5P_FIMV_ENC_UPMV_SIZE;
595                 mfc_write(dev, OFFSETA(buf_addr1),
596                                         S5P_FIMV_H264_COZERO_FLAG_ADR);
597                 buf_addr1 += S5P_FIMV_ENC_COLFLG_SIZE;
598                 buf_size1 -= S5P_FIMV_ENC_COLFLG_SIZE;
599                 mfc_write(dev, OFFSETA(buf_addr1),
600                                         S5P_FIMV_H264_UP_INTRA_MD_ADR);
601                 buf_addr1 += S5P_FIMV_ENC_INTRAMD_SIZE;
602                 buf_size1 -= S5P_FIMV_ENC_INTRAMD_SIZE;
603                 mfc_write(dev, OFFSETB(buf_addr2),
604                                         S5P_FIMV_H264_UP_INTRA_PRED_ADR);
605                 buf_addr2 += S5P_FIMV_ENC_INTRAPRED_SIZE;
606                 buf_size2 -= S5P_FIMV_ENC_INTRAPRED_SIZE;
607                 mfc_write(dev, OFFSETA(buf_addr1),
608                                         S5P_FIMV_H264_NBOR_INFO_ADR);
609                 buf_addr1 += S5P_FIMV_ENC_NBORINFO_SIZE;
610                 buf_size1 -= S5P_FIMV_ENC_NBORINFO_SIZE;
611                 mfc_debug(2, "buf_size1: %zu, buf_size2: %zu\n",
612                         buf_size1, buf_size2);
613                 break;
614         case S5P_MFC_CODEC_MPEG4_ENC:
615                 for (i = 0; i < 2; i++) {
616                         mfc_write(dev, OFFSETA(buf_addr1),
617                                 S5P_FIMV_ENC_REF0_LUMA_ADR + (4 * i));
618                         buf_addr1 += enc_ref_y_size;
619                         buf_size1 -= enc_ref_y_size;
620                         mfc_write(dev, OFFSETB(buf_addr2),
621                                 S5P_FIMV_ENC_REF2_LUMA_ADR + (4 * i));
622                         buf_addr2 += enc_ref_y_size;
623                         buf_size2 -= enc_ref_y_size;
624                 }
625                 for (i = 0; i < 4; i++) {
626                         mfc_write(dev, OFFSETB(buf_addr2),
627                                 S5P_FIMV_ENC_REF0_CHROMA_ADR + (4 * i));
628                         buf_addr2 += enc_ref_c_size;
629                         buf_size2 -= enc_ref_c_size;
630                 }
631                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_MPEG4_UP_MV_ADR);
632                 buf_addr1 += S5P_FIMV_ENC_UPMV_SIZE;
633                 buf_size1 -= S5P_FIMV_ENC_UPMV_SIZE;
634                 mfc_write(dev, OFFSETA(buf_addr1),
635                                                 S5P_FIMV_MPEG4_COZERO_FLAG_ADR);
636                 buf_addr1 += S5P_FIMV_ENC_COLFLG_SIZE;
637                 buf_size1 -= S5P_FIMV_ENC_COLFLG_SIZE;
638                 mfc_write(dev, OFFSETA(buf_addr1),
639                                                 S5P_FIMV_MPEG4_ACDC_COEF_ADR);
640                 buf_addr1 += S5P_FIMV_ENC_ACDCCOEF_SIZE;
641                 buf_size1 -= S5P_FIMV_ENC_ACDCCOEF_SIZE;
642                 mfc_debug(2, "buf_size1: %zu, buf_size2: %zu\n",
643                         buf_size1, buf_size2);
644                 break;
645         case S5P_MFC_CODEC_H263_ENC:
646                 for (i = 0; i < 2; i++) {
647                         mfc_write(dev, OFFSETA(buf_addr1),
648                                 S5P_FIMV_ENC_REF0_LUMA_ADR + (4 * i));
649                         buf_addr1 += enc_ref_y_size;
650                         buf_size1 -= enc_ref_y_size;
651                         mfc_write(dev, OFFSETB(buf_addr2),
652                                 S5P_FIMV_ENC_REF2_LUMA_ADR + (4 * i));
653                         buf_addr2 += enc_ref_y_size;
654                         buf_size2 -= enc_ref_y_size;
655                 }
656                 for (i = 0; i < 4; i++) {
657                         mfc_write(dev, OFFSETB(buf_addr2),
658                                 S5P_FIMV_ENC_REF0_CHROMA_ADR + (4 * i));
659                         buf_addr2 += enc_ref_c_size;
660                         buf_size2 -= enc_ref_c_size;
661                 }
662                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H263_UP_MV_ADR);
663                 buf_addr1 += S5P_FIMV_ENC_UPMV_SIZE;
664                 buf_size1 -= S5P_FIMV_ENC_UPMV_SIZE;
665                 mfc_write(dev, OFFSETA(buf_addr1), S5P_FIMV_H263_ACDC_COEF_ADR);
666                 buf_addr1 += S5P_FIMV_ENC_ACDCCOEF_SIZE;
667                 buf_size1 -= S5P_FIMV_ENC_ACDCCOEF_SIZE;
668                 mfc_debug(2, "buf_size1: %zu, buf_size2: %zu\n",
669                         buf_size1, buf_size2);
670                 break;
671         default:
672                 mfc_err("Unknown codec set for encoding: %d\n",
673                         ctx->codec_mode);
674                 return -EINVAL;
675         }
676         return 0;
677 }
678
679 static int s5p_mfc_set_enc_params(struct s5p_mfc_ctx *ctx)
680 {
681         struct s5p_mfc_dev *dev = ctx->dev;
682         struct s5p_mfc_enc_params *p = &ctx->enc_params;
683         unsigned int reg;
684         unsigned int shm;
685
686         /* width */
687         mfc_write(dev, ctx->img_width, S5P_FIMV_ENC_HSIZE_PX);
688         /* height */
689         mfc_write(dev, ctx->img_height, S5P_FIMV_ENC_VSIZE_PX);
690         /* pictype : enable, IDR period */
691         reg = mfc_read(dev, S5P_FIMV_ENC_PIC_TYPE_CTRL);
692         reg |= (1 << 18);
693         reg &= ~(0xFFFF);
694         reg |= p->gop_size;
695         mfc_write(dev, reg, S5P_FIMV_ENC_PIC_TYPE_CTRL);
696         mfc_write(dev, 0, S5P_FIMV_ENC_B_RECON_WRITE_ON);
697         /* multi-slice control */
698         /* multi-slice MB number or bit size */
699         mfc_write(dev, p->slice_mode, S5P_FIMV_ENC_MSLICE_CTRL);
700         if (p->slice_mode == V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB) {
701                 mfc_write(dev, p->slice_mb, S5P_FIMV_ENC_MSLICE_MB);
702         } else if (p->slice_mode == V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES) {
703                 mfc_write(dev, p->slice_bit, S5P_FIMV_ENC_MSLICE_BIT);
704         } else {
705                 mfc_write(dev, 0, S5P_FIMV_ENC_MSLICE_MB);
706                 mfc_write(dev, 0, S5P_FIMV_ENC_MSLICE_BIT);
707         }
708         /* cyclic intra refresh */
709         mfc_write(dev, p->intra_refresh_mb, S5P_FIMV_ENC_CIR_CTRL);
710         /* memory structure cur. frame */
711         if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_NV12M)
712                 mfc_write(dev, 0, S5P_FIMV_ENC_MAP_FOR_CUR);
713         else if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_NV12MT)
714                 mfc_write(dev, 3, S5P_FIMV_ENC_MAP_FOR_CUR);
715         /* padding control & value */
716         reg = mfc_read(dev, S5P_FIMV_ENC_PADDING_CTRL);
717         if (p->pad) {
718                 /** enable */
719                 reg |= (1 << 31);
720                 /** cr value */
721                 reg &= ~(0xFF << 16);
722                 reg |= (p->pad_cr << 16);
723                 /** cb value */
724                 reg &= ~(0xFF << 8);
725                 reg |= (p->pad_cb << 8);
726                 /** y value */
727                 reg &= ~(0xFF);
728                 reg |= (p->pad_luma);
729         } else {
730                 /** disable & all value clear */
731                 reg = 0;
732         }
733         mfc_write(dev, reg, S5P_FIMV_ENC_PADDING_CTRL);
734         /* rate control config. */
735         reg = mfc_read(dev, S5P_FIMV_ENC_RC_CONFIG);
736         /** frame-level rate control */
737         reg &= ~(0x1 << 9);
738         reg |= (p->rc_frame << 9);
739         mfc_write(dev, reg, S5P_FIMV_ENC_RC_CONFIG);
740         /* bit rate */
741         if (p->rc_frame)
742                 mfc_write(dev, p->rc_bitrate,
743                         S5P_FIMV_ENC_RC_BIT_RATE);
744         else
745                 mfc_write(dev, 0, S5P_FIMV_ENC_RC_BIT_RATE);
746         /* reaction coefficient */
747         if (p->rc_frame)
748                 mfc_write(dev, p->rc_reaction_coeff, S5P_FIMV_ENC_RC_RPARA);
749         shm = s5p_mfc_read_info_v5(ctx, EXT_ENC_CONTROL);
750         /* seq header ctrl */
751         shm &= ~(0x1 << 3);
752         shm |= (p->seq_hdr_mode << 3);
753         /* frame skip mode */
754         shm &= ~(0x3 << 1);
755         shm |= (p->frame_skip_mode << 1);
756         s5p_mfc_write_info_v5(ctx, shm, EXT_ENC_CONTROL);
757         /* fixed target bit */
758         s5p_mfc_write_info_v5(ctx, p->fixed_target_bit, RC_CONTROL_CONFIG);
759         return 0;
760 }
761
762 static int s5p_mfc_set_enc_params_h264(struct s5p_mfc_ctx *ctx)
763 {
764         struct s5p_mfc_dev *dev = ctx->dev;
765         struct s5p_mfc_enc_params *p = &ctx->enc_params;
766         struct s5p_mfc_h264_enc_params *p_264 = &p->codec.h264;
767         unsigned int reg;
768         unsigned int shm;
769
770         s5p_mfc_set_enc_params(ctx);
771         /* pictype : number of B */
772         reg = mfc_read(dev, S5P_FIMV_ENC_PIC_TYPE_CTRL);
773         /* num_b_frame - 0 ~ 2 */
774         reg &= ~(0x3 << 16);
775         reg |= (p->num_b_frame << 16);
776         mfc_write(dev, reg, S5P_FIMV_ENC_PIC_TYPE_CTRL);
777         /* profile & level */
778         reg = mfc_read(dev, S5P_FIMV_ENC_PROFILE);
779         /* level */
780         reg &= ~(0xFF << 8);
781         reg |= (p_264->level << 8);
782         /* profile - 0 ~ 2 */
783         reg &= ~(0x3F);
784         reg |= p_264->profile;
785         mfc_write(dev, reg, S5P_FIMV_ENC_PROFILE);
786         /* interlace  */
787         mfc_write(dev, p_264->interlace, S5P_FIMV_ENC_PIC_STRUCT);
788         /* height */
789         if (p_264->interlace)
790                 mfc_write(dev, ctx->img_height >> 1, S5P_FIMV_ENC_VSIZE_PX);
791         /* loopfilter ctrl */
792         mfc_write(dev, p_264->loop_filter_mode, S5P_FIMV_ENC_LF_CTRL);
793         /* loopfilter alpha offset */
794         if (p_264->loop_filter_alpha < 0) {
795                 reg = 0x10;
796                 reg |= (0xFF - p_264->loop_filter_alpha) + 1;
797         } else {
798                 reg = 0x00;
799                 reg |= (p_264->loop_filter_alpha & 0xF);
800         }
801         mfc_write(dev, reg, S5P_FIMV_ENC_ALPHA_OFF);
802         /* loopfilter beta offset */
803         if (p_264->loop_filter_beta < 0) {
804                 reg = 0x10;
805                 reg |= (0xFF - p_264->loop_filter_beta) + 1;
806         } else {
807                 reg = 0x00;
808                 reg |= (p_264->loop_filter_beta & 0xF);
809         }
810         mfc_write(dev, reg, S5P_FIMV_ENC_BETA_OFF);
811         /* entropy coding mode */
812         if (p_264->entropy_mode == V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC)
813                 mfc_write(dev, 1, S5P_FIMV_ENC_H264_ENTROPY_MODE);
814         else
815                 mfc_write(dev, 0, S5P_FIMV_ENC_H264_ENTROPY_MODE);
816         /* number of ref. picture */
817         reg = mfc_read(dev, S5P_FIMV_ENC_H264_NUM_OF_REF);
818         /* num of ref. pictures of P */
819         reg &= ~(0x3 << 5);
820         reg |= (p_264->num_ref_pic_4p << 5);
821         /* max number of ref. pictures */
822         reg &= ~(0x1F);
823         reg |= p_264->max_ref_pic;
824         mfc_write(dev, reg, S5P_FIMV_ENC_H264_NUM_OF_REF);
825         /* 8x8 transform enable */
826         mfc_write(dev, p_264->_8x8_transform, S5P_FIMV_ENC_H264_TRANS_FLAG);
827         /* rate control config. */
828         reg = mfc_read(dev, S5P_FIMV_ENC_RC_CONFIG);
829         /* macroblock level rate control */
830         reg &= ~(0x1 << 8);
831         reg |= (p->rc_mb << 8);
832         /* frame QP */
833         reg &= ~(0x3F);
834         reg |= p_264->rc_frame_qp;
835         mfc_write(dev, reg, S5P_FIMV_ENC_RC_CONFIG);
836         /* frame rate */
837         if (p->rc_frame && p->rc_framerate_denom)
838                 mfc_write(dev, p->rc_framerate_num * 1000
839                         / p->rc_framerate_denom, S5P_FIMV_ENC_RC_FRAME_RATE);
840         else
841                 mfc_write(dev, 0, S5P_FIMV_ENC_RC_FRAME_RATE);
842         /* max & min value of QP */
843         reg = mfc_read(dev, S5P_FIMV_ENC_RC_QBOUND);
844         /* max QP */
845         reg &= ~(0x3F << 8);
846         reg |= (p_264->rc_max_qp << 8);
847         /* min QP */
848         reg &= ~(0x3F);
849         reg |= p_264->rc_min_qp;
850         mfc_write(dev, reg, S5P_FIMV_ENC_RC_QBOUND);
851         /* macroblock adaptive scaling features */
852         if (p->rc_mb) {
853                 reg = mfc_read(dev, S5P_FIMV_ENC_RC_MB_CTRL);
854                 /* dark region */
855                 reg &= ~(0x1 << 3);
856                 reg |= (p_264->rc_mb_dark << 3);
857                 /* smooth region */
858                 reg &= ~(0x1 << 2);
859                 reg |= (p_264->rc_mb_smooth << 2);
860                 /* static region */
861                 reg &= ~(0x1 << 1);
862                 reg |= (p_264->rc_mb_static << 1);
863                 /* high activity region */
864                 reg &= ~(0x1);
865                 reg |= p_264->rc_mb_activity;
866                 mfc_write(dev, reg, S5P_FIMV_ENC_RC_MB_CTRL);
867         }
868         if (!p->rc_frame && !p->rc_mb) {
869                 shm = s5p_mfc_read_info_v5(ctx, P_B_FRAME_QP);
870                 shm &= ~(0xFFF);
871                 shm |= ((p_264->rc_b_frame_qp & 0x3F) << 6);
872                 shm |= (p_264->rc_p_frame_qp & 0x3F);
873                 s5p_mfc_write_info_v5(ctx, shm, P_B_FRAME_QP);
874         }
875         /* extended encoder ctrl */
876         shm = s5p_mfc_read_info_v5(ctx, EXT_ENC_CONTROL);
877         /* AR VUI control */
878         shm &= ~(0x1 << 15);
879         shm |= (p_264->vui_sar << 1);
880         s5p_mfc_write_info_v5(ctx, shm, EXT_ENC_CONTROL);
881         if (p_264->vui_sar) {
882                 /* aspect ration IDC */
883                 shm = s5p_mfc_read_info_v5(ctx, SAMPLE_ASPECT_RATIO_IDC);
884                 shm &= ~(0xFF);
885                 shm |= p_264->vui_sar_idc;
886                 s5p_mfc_write_info_v5(ctx, shm, SAMPLE_ASPECT_RATIO_IDC);
887                 if (p_264->vui_sar_idc == 0xFF) {
888                         /* sample  AR info */
889                         shm = s5p_mfc_read_info_v5(ctx, EXTENDED_SAR);
890                         shm &= ~(0xFFFFFFFF);
891                         shm |= p_264->vui_ext_sar_width << 16;
892                         shm |= p_264->vui_ext_sar_height;
893                         s5p_mfc_write_info_v5(ctx, shm, EXTENDED_SAR);
894                 }
895         }
896         /* intra picture period for H.264 */
897         shm = s5p_mfc_read_info_v5(ctx, H264_I_PERIOD);
898         /* control */
899         shm &= ~(0x1 << 16);
900         shm |= (p_264->open_gop << 16);
901         /* value */
902         if (p_264->open_gop) {
903                 shm &= ~(0xFFFF);
904                 shm |= p_264->open_gop_size;
905         }
906         s5p_mfc_write_info_v5(ctx, shm, H264_I_PERIOD);
907         /* extended encoder ctrl */
908         shm = s5p_mfc_read_info_v5(ctx, EXT_ENC_CONTROL);
909         /* vbv buffer size */
910         if (p->frame_skip_mode ==
911                         V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT) {
912                 shm &= ~(0xFFFF << 16);
913                 shm |= (p_264->cpb_size << 16);
914         }
915         s5p_mfc_write_info_v5(ctx, shm, EXT_ENC_CONTROL);
916         return 0;
917 }
918
919 static int s5p_mfc_set_enc_params_mpeg4(struct s5p_mfc_ctx *ctx)
920 {
921         struct s5p_mfc_dev *dev = ctx->dev;
922         struct s5p_mfc_enc_params *p = &ctx->enc_params;
923         struct s5p_mfc_mpeg4_enc_params *p_mpeg4 = &p->codec.mpeg4;
924         unsigned int reg;
925         unsigned int shm;
926         unsigned int framerate;
927
928         s5p_mfc_set_enc_params(ctx);
929         /* pictype : number of B */
930         reg = mfc_read(dev, S5P_FIMV_ENC_PIC_TYPE_CTRL);
931         /* num_b_frame - 0 ~ 2 */
932         reg &= ~(0x3 << 16);
933         reg |= (p->num_b_frame << 16);
934         mfc_write(dev, reg, S5P_FIMV_ENC_PIC_TYPE_CTRL);
935         /* profile & level */
936         reg = mfc_read(dev, S5P_FIMV_ENC_PROFILE);
937         /* level */
938         reg &= ~(0xFF << 8);
939         reg |= (p_mpeg4->level << 8);
940         /* profile - 0 ~ 2 */
941         reg &= ~(0x3F);
942         reg |= p_mpeg4->profile;
943         mfc_write(dev, reg, S5P_FIMV_ENC_PROFILE);
944         /* quarter_pixel */
945         mfc_write(dev, p_mpeg4->quarter_pixel, S5P_FIMV_ENC_MPEG4_QUART_PXL);
946         /* qp */
947         if (!p->rc_frame) {
948                 shm = s5p_mfc_read_info_v5(ctx, P_B_FRAME_QP);
949                 shm &= ~(0xFFF);
950                 shm |= ((p_mpeg4->rc_b_frame_qp & 0x3F) << 6);
951                 shm |= (p_mpeg4->rc_p_frame_qp & 0x3F);
952                 s5p_mfc_write_info_v5(ctx, shm, P_B_FRAME_QP);
953         }
954         /* frame rate */
955         if (p->rc_frame) {
956                 if (p->rc_framerate_denom > 0) {
957                         framerate = p->rc_framerate_num * 1000 /
958                                                 p->rc_framerate_denom;
959                         mfc_write(dev, framerate,
960                                 S5P_FIMV_ENC_RC_FRAME_RATE);
961                         shm = s5p_mfc_read_info_v5(ctx, RC_VOP_TIMING);
962                         shm &= ~(0xFFFFFFFF);
963                         shm |= (1 << 31);
964                         shm |= ((p->rc_framerate_num & 0x7FFF) << 16);
965                         shm |= (p->rc_framerate_denom & 0xFFFF);
966                         s5p_mfc_write_info_v5(ctx, shm, RC_VOP_TIMING);
967                 }
968         } else {
969                 mfc_write(dev, 0, S5P_FIMV_ENC_RC_FRAME_RATE);
970         }
971         /* rate control config. */
972         reg = mfc_read(dev, S5P_FIMV_ENC_RC_CONFIG);
973         /* frame QP */
974         reg &= ~(0x3F);
975         reg |= p_mpeg4->rc_frame_qp;
976         mfc_write(dev, reg, S5P_FIMV_ENC_RC_CONFIG);
977         /* max & min value of QP */
978         reg = mfc_read(dev, S5P_FIMV_ENC_RC_QBOUND);
979         /* max QP */
980         reg &= ~(0x3F << 8);
981         reg |= (p_mpeg4->rc_max_qp << 8);
982         /* min QP */
983         reg &= ~(0x3F);
984         reg |= p_mpeg4->rc_min_qp;
985         mfc_write(dev, reg, S5P_FIMV_ENC_RC_QBOUND);
986         /* extended encoder ctrl */
987         shm = s5p_mfc_read_info_v5(ctx, EXT_ENC_CONTROL);
988         /* vbv buffer size */
989         if (p->frame_skip_mode ==
990                         V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT) {
991                 shm &= ~(0xFFFF << 16);
992                 shm |= (p->vbv_size << 16);
993         }
994         s5p_mfc_write_info_v5(ctx, shm, EXT_ENC_CONTROL);
995         return 0;
996 }
997
998 static int s5p_mfc_set_enc_params_h263(struct s5p_mfc_ctx *ctx)
999 {
1000         struct s5p_mfc_dev *dev = ctx->dev;
1001         struct s5p_mfc_enc_params *p = &ctx->enc_params;
1002         struct s5p_mfc_mpeg4_enc_params *p_h263 = &p->codec.mpeg4;
1003         unsigned int reg;
1004         unsigned int shm;
1005
1006         s5p_mfc_set_enc_params(ctx);
1007         /* qp */
1008         if (!p->rc_frame) {
1009                 shm = s5p_mfc_read_info_v5(ctx, P_B_FRAME_QP);
1010                 shm &= ~(0xFFF);
1011                 shm |= (p_h263->rc_p_frame_qp & 0x3F);
1012                 s5p_mfc_write_info_v5(ctx, shm, P_B_FRAME_QP);
1013         }
1014         /* frame rate */
1015         if (p->rc_frame && p->rc_framerate_denom)
1016                 mfc_write(dev, p->rc_framerate_num * 1000
1017                         / p->rc_framerate_denom, S5P_FIMV_ENC_RC_FRAME_RATE);
1018         else
1019                 mfc_write(dev, 0, S5P_FIMV_ENC_RC_FRAME_RATE);
1020         /* rate control config. */
1021         reg = mfc_read(dev, S5P_FIMV_ENC_RC_CONFIG);
1022         /* frame QP */
1023         reg &= ~(0x3F);
1024         reg |= p_h263->rc_frame_qp;
1025         mfc_write(dev, reg, S5P_FIMV_ENC_RC_CONFIG);
1026         /* max & min value of QP */
1027         reg = mfc_read(dev, S5P_FIMV_ENC_RC_QBOUND);
1028         /* max QP */
1029         reg &= ~(0x3F << 8);
1030         reg |= (p_h263->rc_max_qp << 8);
1031         /* min QP */
1032         reg &= ~(0x3F);
1033         reg |= p_h263->rc_min_qp;
1034         mfc_write(dev, reg, S5P_FIMV_ENC_RC_QBOUND);
1035         /* extended encoder ctrl */
1036         shm = s5p_mfc_read_info_v5(ctx, EXT_ENC_CONTROL);
1037         /* vbv buffer size */
1038         if (p->frame_skip_mode ==
1039                         V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT) {
1040                 shm &= ~(0xFFFF << 16);
1041                 shm |= (p->vbv_size << 16);
1042         }
1043         s5p_mfc_write_info_v5(ctx, shm, EXT_ENC_CONTROL);
1044         return 0;
1045 }
1046
1047 /* Initialize decoding */
1048 static int s5p_mfc_init_decode_v5(struct s5p_mfc_ctx *ctx)
1049 {
1050         struct s5p_mfc_dev *dev = ctx->dev;
1051
1052         s5p_mfc_set_shared_buffer(ctx);
1053         /* Setup loop filter, for decoding this is only valid for MPEG4 */
1054         if (ctx->codec_mode == S5P_MFC_CODEC_MPEG4_DEC)
1055                 mfc_write(dev, ctx->loop_filter_mpeg4, S5P_FIMV_ENC_LF_CTRL);
1056         else
1057                 mfc_write(dev, 0, S5P_FIMV_ENC_LF_CTRL);
1058         mfc_write(dev, ((ctx->slice_interface & S5P_FIMV_SLICE_INT_MASK) <<
1059                 S5P_FIMV_SLICE_INT_SHIFT) | (ctx->display_delay_enable <<
1060                 S5P_FIMV_DDELAY_ENA_SHIFT) | ((ctx->display_delay &
1061                 S5P_FIMV_DDELAY_VAL_MASK) << S5P_FIMV_DDELAY_VAL_SHIFT),
1062                 S5P_FIMV_SI_CH0_DPB_CONF_CTRL);
1063         mfc_write(dev,
1064         ((S5P_FIMV_CH_SEQ_HEADER & S5P_FIMV_CH_MASK) << S5P_FIMV_CH_SHIFT)
1065                                 | (ctx->inst_no), S5P_FIMV_SI_CH0_INST_ID);
1066         return 0;
1067 }
1068
1069 static void s5p_mfc_set_flush(struct s5p_mfc_ctx *ctx, int flush)
1070 {
1071         struct s5p_mfc_dev *dev = ctx->dev;
1072         unsigned int dpb;
1073
1074         if (flush)
1075                 dpb = mfc_read(dev, S5P_FIMV_SI_CH0_DPB_CONF_CTRL) | (
1076                         S5P_FIMV_DPB_FLUSH_MASK << S5P_FIMV_DPB_FLUSH_SHIFT);
1077         else
1078                 dpb = mfc_read(dev, S5P_FIMV_SI_CH0_DPB_CONF_CTRL) &
1079                         ~(S5P_FIMV_DPB_FLUSH_MASK << S5P_FIMV_DPB_FLUSH_SHIFT);
1080         mfc_write(dev, dpb, S5P_FIMV_SI_CH0_DPB_CONF_CTRL);
1081 }
1082
1083 /* Decode a single frame */
1084 static int s5p_mfc_decode_one_frame_v5(struct s5p_mfc_ctx *ctx,
1085                                         enum s5p_mfc_decode_arg last_frame)
1086 {
1087         struct s5p_mfc_dev *dev = ctx->dev;
1088
1089         mfc_write(dev, ctx->dec_dst_flag, S5P_FIMV_SI_CH0_RELEASE_BUF);
1090         s5p_mfc_set_shared_buffer(ctx);
1091         s5p_mfc_set_flush(ctx, ctx->dpb_flush_flag);
1092         /* Issue different commands to instance basing on whether it
1093          * is the last frame or not. */
1094         switch (last_frame) {
1095         case MFC_DEC_FRAME:
1096                 mfc_write(dev, ((S5P_FIMV_CH_FRAME_START & S5P_FIMV_CH_MASK) <<
1097                 S5P_FIMV_CH_SHIFT) | (ctx->inst_no), S5P_FIMV_SI_CH0_INST_ID);
1098                 break;
1099         case MFC_DEC_LAST_FRAME:
1100                 mfc_write(dev, ((S5P_FIMV_CH_LAST_FRAME & S5P_FIMV_CH_MASK) <<
1101                 S5P_FIMV_CH_SHIFT) | (ctx->inst_no), S5P_FIMV_SI_CH0_INST_ID);
1102                 break;
1103         case MFC_DEC_RES_CHANGE:
1104                 mfc_write(dev, ((S5P_FIMV_CH_FRAME_START_REALLOC &
1105                 S5P_FIMV_CH_MASK) << S5P_FIMV_CH_SHIFT) | (ctx->inst_no),
1106                 S5P_FIMV_SI_CH0_INST_ID);
1107                 break;
1108         }
1109         mfc_debug(2, "Decoding a usual frame\n");
1110         return 0;
1111 }
1112
1113 static int s5p_mfc_init_encode_v5(struct s5p_mfc_ctx *ctx)
1114 {
1115         struct s5p_mfc_dev *dev = ctx->dev;
1116
1117         if (ctx->codec_mode == S5P_MFC_CODEC_H264_ENC)
1118                 s5p_mfc_set_enc_params_h264(ctx);
1119         else if (ctx->codec_mode == S5P_MFC_CODEC_MPEG4_ENC)
1120                 s5p_mfc_set_enc_params_mpeg4(ctx);
1121         else if (ctx->codec_mode == S5P_MFC_CODEC_H263_ENC)
1122                 s5p_mfc_set_enc_params_h263(ctx);
1123         else {
1124                 mfc_err("Unknown codec for encoding (%x)\n",
1125                         ctx->codec_mode);
1126                 return -EINVAL;
1127         }
1128         s5p_mfc_set_shared_buffer(ctx);
1129         mfc_write(dev, ((S5P_FIMV_CH_SEQ_HEADER << 16) & 0x70000) |
1130                 (ctx->inst_no), S5P_FIMV_SI_CH0_INST_ID);
1131         return 0;
1132 }
1133
1134 /* Encode a single frame */
1135 static int s5p_mfc_encode_one_frame_v5(struct s5p_mfc_ctx *ctx)
1136 {
1137         struct s5p_mfc_dev *dev = ctx->dev;
1138         int cmd;
1139         /* memory structure cur. frame */
1140         if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_NV12M)
1141                 mfc_write(dev, 0, S5P_FIMV_ENC_MAP_FOR_CUR);
1142         else if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_NV12MT)
1143                 mfc_write(dev, 3, S5P_FIMV_ENC_MAP_FOR_CUR);
1144         s5p_mfc_set_shared_buffer(ctx);
1145
1146         if (ctx->state == MFCINST_FINISHING)
1147                 cmd = S5P_FIMV_CH_LAST_FRAME;
1148         else
1149                 cmd = S5P_FIMV_CH_FRAME_START;
1150         mfc_write(dev, ((cmd & S5P_FIMV_CH_MASK) << S5P_FIMV_CH_SHIFT)
1151                                 | (ctx->inst_no), S5P_FIMV_SI_CH0_INST_ID);
1152
1153         return 0;
1154 }
1155
1156 static int s5p_mfc_get_new_ctx(struct s5p_mfc_dev *dev)
1157 {
1158         unsigned long flags;
1159         int new_ctx;
1160         int cnt;
1161
1162         spin_lock_irqsave(&dev->condlock, flags);
1163         new_ctx = (dev->curr_ctx + 1) % MFC_NUM_CONTEXTS;
1164         cnt = 0;
1165         while (!test_bit(new_ctx, &dev->ctx_work_bits)) {
1166                 new_ctx = (new_ctx + 1) % MFC_NUM_CONTEXTS;
1167                 if (++cnt > MFC_NUM_CONTEXTS) {
1168                         /* No contexts to run */
1169                         spin_unlock_irqrestore(&dev->condlock, flags);
1170                         return -EAGAIN;
1171                 }
1172         }
1173         spin_unlock_irqrestore(&dev->condlock, flags);
1174         return new_ctx;
1175 }
1176
1177 static void s5p_mfc_run_res_change(struct s5p_mfc_ctx *ctx)
1178 {
1179         struct s5p_mfc_dev *dev = ctx->dev;
1180
1181         s5p_mfc_set_dec_stream_buffer_v5(ctx, 0, 0, 0);
1182         dev->curr_ctx = ctx->num;
1183         s5p_mfc_decode_one_frame_v5(ctx, MFC_DEC_RES_CHANGE);
1184 }
1185
1186 static int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx, int last_frame)
1187 {
1188         struct s5p_mfc_dev *dev = ctx->dev;
1189         struct s5p_mfc_buf *temp_vb;
1190         unsigned long flags;
1191
1192         if (ctx->state == MFCINST_FINISHING) {
1193                 last_frame = MFC_DEC_LAST_FRAME;
1194                 s5p_mfc_set_dec_stream_buffer_v5(ctx, 0, 0, 0);
1195                 dev->curr_ctx = ctx->num;
1196                 s5p_mfc_decode_one_frame_v5(ctx, last_frame);
1197                 return 0;
1198         }
1199
1200         spin_lock_irqsave(&dev->irqlock, flags);
1201         /* Frames are being decoded */
1202         if (list_empty(&ctx->src_queue)) {
1203                 mfc_debug(2, "No src buffers\n");
1204                 spin_unlock_irqrestore(&dev->irqlock, flags);
1205                 return -EAGAIN;
1206         }
1207         /* Get the next source buffer */
1208         temp_vb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
1209         temp_vb->flags |= MFC_BUF_FLAG_USED;
1210         s5p_mfc_set_dec_stream_buffer_v5(ctx,
1211                 vb2_dma_contig_plane_dma_addr(temp_vb->b, 0),
1212                 ctx->consumed_stream, temp_vb->b->v4l2_planes[0].bytesused);
1213         spin_unlock_irqrestore(&dev->irqlock, flags);
1214         dev->curr_ctx = ctx->num;
1215         if (temp_vb->b->v4l2_planes[0].bytesused == 0) {
1216                 last_frame = MFC_DEC_LAST_FRAME;
1217                 mfc_debug(2, "Setting ctx->state to FINISHING\n");
1218                 ctx->state = MFCINST_FINISHING;
1219         }
1220         s5p_mfc_decode_one_frame_v5(ctx, last_frame);
1221         return 0;
1222 }
1223
1224 static int s5p_mfc_run_enc_frame(struct s5p_mfc_ctx *ctx)
1225 {
1226         struct s5p_mfc_dev *dev = ctx->dev;
1227         unsigned long flags;
1228         struct s5p_mfc_buf *dst_mb;
1229         struct s5p_mfc_buf *src_mb;
1230         unsigned long src_y_addr, src_c_addr, dst_addr;
1231         unsigned int dst_size;
1232
1233         spin_lock_irqsave(&dev->irqlock, flags);
1234         if (list_empty(&ctx->src_queue) && ctx->state != MFCINST_FINISHING) {
1235                 mfc_debug(2, "no src buffers\n");
1236                 spin_unlock_irqrestore(&dev->irqlock, flags);
1237                 return -EAGAIN;
1238         }
1239         if (list_empty(&ctx->dst_queue)) {
1240                 mfc_debug(2, "no dst buffers\n");
1241                 spin_unlock_irqrestore(&dev->irqlock, flags);
1242                 return -EAGAIN;
1243         }
1244         if (list_empty(&ctx->src_queue)) {
1245                 /* send null frame */
1246                 s5p_mfc_set_enc_frame_buffer_v5(ctx, dev->bank2, dev->bank2);
1247                 src_mb = NULL;
1248         } else {
1249                 src_mb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf,
1250                                                                         list);
1251                 src_mb->flags |= MFC_BUF_FLAG_USED;
1252                 if (src_mb->b->v4l2_planes[0].bytesused == 0) {
1253                         /* send null frame */
1254                         s5p_mfc_set_enc_frame_buffer_v5(ctx, dev->bank2,
1255                                                                 dev->bank2);
1256                         ctx->state = MFCINST_FINISHING;
1257                 } else {
1258                         src_y_addr = vb2_dma_contig_plane_dma_addr(src_mb->b,
1259                                                                         0);
1260                         src_c_addr = vb2_dma_contig_plane_dma_addr(src_mb->b,
1261                                                                         1);
1262                         s5p_mfc_set_enc_frame_buffer_v5(ctx, src_y_addr,
1263                                                                 src_c_addr);
1264                         if (src_mb->flags & MFC_BUF_FLAG_EOS)
1265                                 ctx->state = MFCINST_FINISHING;
1266                 }
1267         }
1268         dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
1269         dst_mb->flags |= MFC_BUF_FLAG_USED;
1270         dst_addr = vb2_dma_contig_plane_dma_addr(dst_mb->b, 0);
1271         dst_size = vb2_plane_size(dst_mb->b, 0);
1272         s5p_mfc_set_enc_stream_buffer_v5(ctx, dst_addr, dst_size);
1273         spin_unlock_irqrestore(&dev->irqlock, flags);
1274         dev->curr_ctx = ctx->num;
1275         mfc_debug(2, "encoding buffer with index=%d state=%d\n",
1276                   src_mb ? src_mb->b->v4l2_buf.index : -1, ctx->state);
1277         s5p_mfc_encode_one_frame_v5(ctx);
1278         return 0;
1279 }
1280
1281 static void s5p_mfc_run_init_dec(struct s5p_mfc_ctx *ctx)
1282 {
1283         struct s5p_mfc_dev *dev = ctx->dev;
1284         unsigned long flags;
1285         struct s5p_mfc_buf *temp_vb;
1286
1287         /* Initializing decoding - parsing header */
1288         spin_lock_irqsave(&dev->irqlock, flags);
1289         mfc_debug(2, "Preparing to init decoding\n");
1290         temp_vb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
1291         s5p_mfc_set_dec_desc_buffer(ctx);
1292         mfc_debug(2, "Header size: %d\n", temp_vb->b->v4l2_planes[0].bytesused);
1293         s5p_mfc_set_dec_stream_buffer_v5(ctx,
1294                                 vb2_dma_contig_plane_dma_addr(temp_vb->b, 0),
1295                                 0, temp_vb->b->v4l2_planes[0].bytesused);
1296         spin_unlock_irqrestore(&dev->irqlock, flags);
1297         dev->curr_ctx = ctx->num;
1298         s5p_mfc_init_decode_v5(ctx);
1299 }
1300
1301 static void s5p_mfc_run_init_enc(struct s5p_mfc_ctx *ctx)
1302 {
1303         struct s5p_mfc_dev *dev = ctx->dev;
1304         unsigned long flags;
1305         struct s5p_mfc_buf *dst_mb;
1306         unsigned long dst_addr;
1307         unsigned int dst_size;
1308
1309         s5p_mfc_set_enc_ref_buffer_v5(ctx);
1310         spin_lock_irqsave(&dev->irqlock, flags);
1311         dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
1312         dst_addr = vb2_dma_contig_plane_dma_addr(dst_mb->b, 0);
1313         dst_size = vb2_plane_size(dst_mb->b, 0);
1314         s5p_mfc_set_enc_stream_buffer_v5(ctx, dst_addr, dst_size);
1315         spin_unlock_irqrestore(&dev->irqlock, flags);
1316         dev->curr_ctx = ctx->num;
1317         s5p_mfc_init_encode_v5(ctx);
1318 }
1319
1320 static int s5p_mfc_run_init_dec_buffers(struct s5p_mfc_ctx *ctx)
1321 {
1322         struct s5p_mfc_dev *dev = ctx->dev;
1323         unsigned long flags;
1324         struct s5p_mfc_buf *temp_vb;
1325         int ret;
1326
1327         /*
1328          * Header was parsed now starting processing
1329          * First set the output frame buffers
1330          */
1331         if (ctx->capture_state != QUEUE_BUFS_MMAPED) {
1332                 mfc_err("It seems that not all destionation buffers were "
1333                         "mmaped\nMFC requires that all destination are mmaped "
1334                         "before starting processing\n");
1335                 return -EAGAIN;
1336         }
1337         spin_lock_irqsave(&dev->irqlock, flags);
1338         if (list_empty(&ctx->src_queue)) {
1339                 mfc_err("Header has been deallocated in the middle of"
1340                         " initialization\n");
1341                 spin_unlock_irqrestore(&dev->irqlock, flags);
1342                 return -EIO;
1343         }
1344         temp_vb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
1345         mfc_debug(2, "Header size: %d\n", temp_vb->b->v4l2_planes[0].bytesused);
1346         s5p_mfc_set_dec_stream_buffer_v5(ctx,
1347                                 vb2_dma_contig_plane_dma_addr(temp_vb->b, 0),
1348                                 0, temp_vb->b->v4l2_planes[0].bytesused);
1349         spin_unlock_irqrestore(&dev->irqlock, flags);
1350         dev->curr_ctx = ctx->num;
1351         ret = s5p_mfc_set_dec_frame_buffer_v5(ctx);
1352         if (ret) {
1353                 mfc_err("Failed to alloc frame mem\n");
1354                 ctx->state = MFCINST_ERROR;
1355         }
1356         return ret;
1357 }
1358
1359 /* Try running an operation on hardware */
1360 static void s5p_mfc_try_run_v5(struct s5p_mfc_dev *dev)
1361 {
1362         struct s5p_mfc_ctx *ctx;
1363         int new_ctx;
1364         unsigned int ret = 0;
1365
1366         if (test_bit(0, &dev->enter_suspend)) {
1367                 mfc_debug(1, "Entering suspend so do not schedule any jobs\n");
1368                 return;
1369         }
1370         /* Check whether hardware is not running */
1371         if (test_and_set_bit(0, &dev->hw_lock) != 0) {
1372                 /* This is perfectly ok, the scheduled ctx should wait */
1373                 mfc_debug(1, "Couldn't lock HW\n");
1374                 return;
1375         }
1376         /* Choose the context to run */
1377         new_ctx = s5p_mfc_get_new_ctx(dev);
1378         if (new_ctx < 0) {
1379                 /* No contexts to run */
1380                 if (test_and_clear_bit(0, &dev->hw_lock) == 0) {
1381                         mfc_err("Failed to unlock hardware\n");
1382                         return;
1383                 }
1384                 mfc_debug(1, "No ctx is scheduled to be run\n");
1385                 return;
1386         }
1387         ctx = dev->ctx[new_ctx];
1388         /* Got context to run in ctx */
1389         /*
1390          * Last frame has already been sent to MFC.
1391          * Now obtaining frames from MFC buffer
1392          */
1393         s5p_mfc_clock_on();
1394         s5p_mfc_clean_ctx_int_flags(ctx);
1395
1396         if (ctx->type == MFCINST_DECODER) {
1397                 s5p_mfc_set_dec_desc_buffer(ctx);
1398                 switch (ctx->state) {
1399                 case MFCINST_FINISHING:
1400                         s5p_mfc_run_dec_frame(ctx, MFC_DEC_LAST_FRAME);
1401                         break;
1402                 case MFCINST_RUNNING:
1403                         ret = s5p_mfc_run_dec_frame(ctx, MFC_DEC_FRAME);
1404                         break;
1405                 case MFCINST_INIT:
1406                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
1407                                         ctx);
1408                         break;
1409                 case MFCINST_RETURN_INST:
1410                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
1411                                         ctx);
1412                         break;
1413                 case MFCINST_GOT_INST:
1414                         s5p_mfc_run_init_dec(ctx);
1415                         break;
1416                 case MFCINST_HEAD_PARSED:
1417                         ret = s5p_mfc_run_init_dec_buffers(ctx);
1418                         mfc_debug(1, "head parsed\n");
1419                         break;
1420                 case MFCINST_RES_CHANGE_INIT:
1421                         s5p_mfc_run_res_change(ctx);
1422                         break;
1423                 case MFCINST_RES_CHANGE_FLUSH:
1424                         s5p_mfc_run_dec_frame(ctx, MFC_DEC_FRAME);
1425                         break;
1426                 case MFCINST_RES_CHANGE_END:
1427                         mfc_debug(2, "Finished remaining frames after resolution change\n");
1428                         ctx->capture_state = QUEUE_FREE;
1429                         mfc_debug(2, "Will re-init the codec\n");
1430                         s5p_mfc_run_init_dec(ctx);
1431                         break;
1432                 default:
1433                         ret = -EAGAIN;
1434                 }
1435         } else if (ctx->type == MFCINST_ENCODER) {
1436                 switch (ctx->state) {
1437                 case MFCINST_FINISHING:
1438                 case MFCINST_RUNNING:
1439                         ret = s5p_mfc_run_enc_frame(ctx);
1440                         break;
1441                 case MFCINST_INIT:
1442                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
1443                                         ctx);
1444                         break;
1445                 case MFCINST_RETURN_INST:
1446                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
1447                                         ctx);
1448                         break;
1449                 case MFCINST_GOT_INST:
1450                         s5p_mfc_run_init_enc(ctx);
1451                         break;
1452                 default:
1453                         ret = -EAGAIN;
1454                 }
1455         } else {
1456                 mfc_err("Invalid context type: %d\n", ctx->type);
1457                 ret = -EAGAIN;
1458         }
1459
1460         if (ret) {
1461                 /* Free hardware lock */
1462                 if (test_and_clear_bit(0, &dev->hw_lock) == 0)
1463                         mfc_err("Failed to unlock hardware\n");
1464
1465                 /* This is in deed imporant, as no operation has been
1466                  * scheduled, reduce the clock count as no one will
1467                  * ever do this, because no interrupt related to this try_run
1468                  * will ever come from hardware. */
1469                 s5p_mfc_clock_off();
1470         }
1471 }
1472
1473
1474 static void s5p_mfc_cleanup_queue_v5(struct list_head *lh, struct vb2_queue *vq)
1475 {
1476         struct s5p_mfc_buf *b;
1477         int i;
1478
1479         while (!list_empty(lh)) {
1480                 b = list_entry(lh->next, struct s5p_mfc_buf, list);
1481                 for (i = 0; i < b->b->num_planes; i++)
1482                         vb2_set_plane_payload(b->b, i, 0);
1483                 vb2_buffer_done(b->b, VB2_BUF_STATE_ERROR);
1484                 list_del(&b->list);
1485         }
1486 }
1487
1488 static void s5p_mfc_clear_int_flags_v5(struct s5p_mfc_dev *dev)
1489 {
1490         mfc_write(dev, 0, S5P_FIMV_RISC_HOST_INT);
1491         mfc_write(dev, 0, S5P_FIMV_RISC2HOST_CMD);
1492         mfc_write(dev, 0xffff, S5P_FIMV_SI_RTN_CHID);
1493 }
1494
1495 static int s5p_mfc_get_dspl_y_adr_v5(struct s5p_mfc_dev *dev)
1496 {
1497         return mfc_read(dev, S5P_FIMV_SI_DISPLAY_Y_ADR) << MFC_OFFSET_SHIFT;
1498 }
1499
1500 static int s5p_mfc_get_dec_y_adr_v5(struct s5p_mfc_dev *dev)
1501 {
1502         return mfc_read(dev, S5P_FIMV_SI_DECODE_Y_ADR) << MFC_OFFSET_SHIFT;
1503 }
1504
1505 static int s5p_mfc_get_dspl_status_v5(struct s5p_mfc_dev *dev)
1506 {
1507         return mfc_read(dev, S5P_FIMV_SI_DISPLAY_STATUS);
1508 }
1509
1510 static int s5p_mfc_get_dec_status_v5(struct s5p_mfc_dev *dev)
1511 {
1512         return mfc_read(dev, S5P_FIMV_SI_DECODE_STATUS);
1513 }
1514
1515 static int s5p_mfc_get_dec_frame_type_v5(struct s5p_mfc_dev *dev)
1516 {
1517         return mfc_read(dev, S5P_FIMV_DECODE_FRAME_TYPE) &
1518                 S5P_FIMV_DECODE_FRAME_MASK;
1519 }
1520
1521 static int s5p_mfc_get_disp_frame_type_v5(struct s5p_mfc_ctx *ctx)
1522 {
1523         return (s5p_mfc_read_info_v5(ctx, DISP_PIC_FRAME_TYPE) >>
1524                         S5P_FIMV_SHARED_DISP_FRAME_TYPE_SHIFT) &
1525                         S5P_FIMV_DECODE_FRAME_MASK;
1526 }
1527
1528 static int s5p_mfc_get_consumed_stream_v5(struct s5p_mfc_dev *dev)
1529 {
1530         return mfc_read(dev, S5P_FIMV_SI_CONSUMED_BYTES);
1531 }
1532
1533 static int s5p_mfc_get_int_reason_v5(struct s5p_mfc_dev *dev)
1534 {
1535         int reason;
1536         reason = mfc_read(dev, S5P_FIMV_RISC2HOST_CMD) &
1537                 S5P_FIMV_RISC2HOST_CMD_MASK;
1538         switch (reason) {
1539         case S5P_FIMV_R2H_CMD_OPEN_INSTANCE_RET:
1540                 reason = S5P_MFC_R2H_CMD_OPEN_INSTANCE_RET;
1541                 break;
1542         case S5P_FIMV_R2H_CMD_CLOSE_INSTANCE_RET:
1543                 reason = S5P_MFC_R2H_CMD_CLOSE_INSTANCE_RET;
1544                 break;
1545         case S5P_FIMV_R2H_CMD_SEQ_DONE_RET:
1546                 reason = S5P_MFC_R2H_CMD_SEQ_DONE_RET;
1547                 break;
1548         case S5P_FIMV_R2H_CMD_FRAME_DONE_RET:
1549                 reason = S5P_MFC_R2H_CMD_FRAME_DONE_RET;
1550                 break;
1551         case S5P_FIMV_R2H_CMD_SLICE_DONE_RET:
1552                 reason = S5P_MFC_R2H_CMD_SLICE_DONE_RET;
1553                 break;
1554         case S5P_FIMV_R2H_CMD_SYS_INIT_RET:
1555                 reason = S5P_MFC_R2H_CMD_SYS_INIT_RET;
1556                 break;
1557         case S5P_FIMV_R2H_CMD_FW_STATUS_RET:
1558                 reason = S5P_MFC_R2H_CMD_FW_STATUS_RET;
1559                 break;
1560         case S5P_FIMV_R2H_CMD_SLEEP_RET:
1561                 reason = S5P_MFC_R2H_CMD_SLEEP_RET;
1562                 break;
1563         case S5P_FIMV_R2H_CMD_WAKEUP_RET:
1564                 reason = S5P_MFC_R2H_CMD_WAKEUP_RET;
1565                 break;
1566         case S5P_FIMV_R2H_CMD_INIT_BUFFERS_RET:
1567                 reason = S5P_MFC_R2H_CMD_INIT_BUFFERS_RET;
1568                 break;
1569         case S5P_FIMV_R2H_CMD_ENC_COMPLETE_RET:
1570                 reason = S5P_MFC_R2H_CMD_COMPLETE_SEQ_RET;
1571                 break;
1572         case S5P_FIMV_R2H_CMD_ERR_RET:
1573                 reason = S5P_MFC_R2H_CMD_ERR_RET;
1574                 break;
1575         default:
1576                 reason = S5P_MFC_R2H_CMD_EMPTY;
1577         }
1578         return reason;
1579 }
1580
1581 static int s5p_mfc_get_int_err_v5(struct s5p_mfc_dev *dev)
1582 {
1583         return mfc_read(dev, S5P_FIMV_RISC2HOST_ARG2);
1584 }
1585
1586 static int s5p_mfc_err_dec_v5(unsigned int err)
1587 {
1588         return (err & S5P_FIMV_ERR_DEC_MASK) >> S5P_FIMV_ERR_DEC_SHIFT;
1589 }
1590
1591 static int s5p_mfc_err_dspl_v5(unsigned int err)
1592 {
1593         return (err & S5P_FIMV_ERR_DSPL_MASK) >> S5P_FIMV_ERR_DSPL_SHIFT;
1594 }
1595
1596 static int s5p_mfc_get_img_width_v5(struct s5p_mfc_dev *dev)
1597 {
1598         return mfc_read(dev, S5P_FIMV_SI_HRESOL);
1599 }
1600
1601 static int s5p_mfc_get_img_height_v5(struct s5p_mfc_dev *dev)
1602 {
1603         return mfc_read(dev, S5P_FIMV_SI_VRESOL);
1604 }
1605
1606 static int s5p_mfc_get_dpb_count_v5(struct s5p_mfc_dev *dev)
1607 {
1608         return mfc_read(dev, S5P_FIMV_SI_BUF_NUMBER);
1609 }
1610
1611 static int s5p_mfc_get_mv_count_v5(struct s5p_mfc_dev *dev)
1612 {
1613         /* NOP */
1614         return -1;
1615 }
1616
1617 static int s5p_mfc_get_inst_no_v5(struct s5p_mfc_dev *dev)
1618 {
1619         return mfc_read(dev, S5P_FIMV_RISC2HOST_ARG1);
1620 }
1621
1622 static int s5p_mfc_get_enc_strm_size_v5(struct s5p_mfc_dev *dev)
1623 {
1624         return mfc_read(dev, S5P_FIMV_ENC_SI_STRM_SIZE);
1625 }
1626
1627 static int s5p_mfc_get_enc_slice_type_v5(struct s5p_mfc_dev *dev)
1628 {
1629         return mfc_read(dev, S5P_FIMV_ENC_SI_SLICE_TYPE);
1630 }
1631
1632 static int s5p_mfc_get_enc_dpb_count_v5(struct s5p_mfc_dev *dev)
1633 {
1634         return -1;
1635 }
1636
1637 static int s5p_mfc_get_enc_pic_count_v5(struct s5p_mfc_dev *dev)
1638 {
1639         return mfc_read(dev, S5P_FIMV_ENC_SI_PIC_CNT);
1640 }
1641
1642 static int s5p_mfc_get_sei_avail_status_v5(struct s5p_mfc_ctx *ctx)
1643 {
1644         return s5p_mfc_read_info_v5(ctx, FRAME_PACK_SEI_AVAIL);
1645 }
1646
1647 static int s5p_mfc_get_mvc_num_views_v5(struct s5p_mfc_dev *dev)
1648 {
1649         return -1;
1650 }
1651
1652 static int s5p_mfc_get_mvc_view_id_v5(struct s5p_mfc_dev *dev)
1653 {
1654         return -1;
1655 }
1656
1657 static unsigned int s5p_mfc_get_pic_type_top_v5(struct s5p_mfc_ctx *ctx)
1658 {
1659         return s5p_mfc_read_info_v5(ctx, PIC_TIME_TOP);
1660 }
1661
1662 static unsigned int s5p_mfc_get_pic_type_bot_v5(struct s5p_mfc_ctx *ctx)
1663 {
1664         return s5p_mfc_read_info_v5(ctx, PIC_TIME_BOT);
1665 }
1666
1667 static unsigned int s5p_mfc_get_crop_info_h_v5(struct s5p_mfc_ctx *ctx)
1668 {
1669         return s5p_mfc_read_info_v5(ctx, CROP_INFO_H);
1670 }
1671
1672 static unsigned int s5p_mfc_get_crop_info_v_v5(struct s5p_mfc_ctx *ctx)
1673 {
1674         return s5p_mfc_read_info_v5(ctx, CROP_INFO_V);
1675 }
1676
1677 /* Initialize opr function pointers for MFC v5 */
1678 static struct s5p_mfc_hw_ops s5p_mfc_ops_v5 = {
1679         .alloc_dec_temp_buffers = s5p_mfc_alloc_dec_temp_buffers_v5,
1680         .release_dec_desc_buffer = s5p_mfc_release_dec_desc_buffer_v5,
1681         .alloc_codec_buffers = s5p_mfc_alloc_codec_buffers_v5,
1682         .release_codec_buffers = s5p_mfc_release_codec_buffers_v5,
1683         .alloc_instance_buffer = s5p_mfc_alloc_instance_buffer_v5,
1684         .release_instance_buffer = s5p_mfc_release_instance_buffer_v5,
1685         .alloc_dev_context_buffer = s5p_mfc_alloc_dev_context_buffer_v5,
1686         .release_dev_context_buffer = s5p_mfc_release_dev_context_buffer_v5,
1687         .dec_calc_dpb_size = s5p_mfc_dec_calc_dpb_size_v5,
1688         .enc_calc_src_size = s5p_mfc_enc_calc_src_size_v5,
1689         .set_dec_stream_buffer = s5p_mfc_set_dec_stream_buffer_v5,
1690         .set_dec_frame_buffer = s5p_mfc_set_dec_frame_buffer_v5,
1691         .set_enc_stream_buffer = s5p_mfc_set_enc_stream_buffer_v5,
1692         .set_enc_frame_buffer = s5p_mfc_set_enc_frame_buffer_v5,
1693         .get_enc_frame_buffer = s5p_mfc_get_enc_frame_buffer_v5,
1694         .set_enc_ref_buffer = s5p_mfc_set_enc_ref_buffer_v5,
1695         .init_decode = s5p_mfc_init_decode_v5,
1696         .init_encode = s5p_mfc_init_encode_v5,
1697         .encode_one_frame = s5p_mfc_encode_one_frame_v5,
1698         .try_run = s5p_mfc_try_run_v5,
1699         .cleanup_queue = s5p_mfc_cleanup_queue_v5,
1700         .clear_int_flags = s5p_mfc_clear_int_flags_v5,
1701         .write_info = s5p_mfc_write_info_v5,
1702         .read_info = s5p_mfc_read_info_v5,
1703         .get_dspl_y_adr = s5p_mfc_get_dspl_y_adr_v5,
1704         .get_dec_y_adr = s5p_mfc_get_dec_y_adr_v5,
1705         .get_dspl_status = s5p_mfc_get_dspl_status_v5,
1706         .get_dec_status = s5p_mfc_get_dec_status_v5,
1707         .get_dec_frame_type = s5p_mfc_get_dec_frame_type_v5,
1708         .get_disp_frame_type = s5p_mfc_get_disp_frame_type_v5,
1709         .get_consumed_stream = s5p_mfc_get_consumed_stream_v5,
1710         .get_int_reason = s5p_mfc_get_int_reason_v5,
1711         .get_int_err = s5p_mfc_get_int_err_v5,
1712         .err_dec = s5p_mfc_err_dec_v5,
1713         .err_dspl = s5p_mfc_err_dspl_v5,
1714         .get_img_width = s5p_mfc_get_img_width_v5,
1715         .get_img_height = s5p_mfc_get_img_height_v5,
1716         .get_dpb_count = s5p_mfc_get_dpb_count_v5,
1717         .get_mv_count = s5p_mfc_get_mv_count_v5,
1718         .get_inst_no = s5p_mfc_get_inst_no_v5,
1719         .get_enc_strm_size = s5p_mfc_get_enc_strm_size_v5,
1720         .get_enc_slice_type = s5p_mfc_get_enc_slice_type_v5,
1721         .get_enc_dpb_count = s5p_mfc_get_enc_dpb_count_v5,
1722         .get_enc_pic_count = s5p_mfc_get_enc_pic_count_v5,
1723         .get_sei_avail_status = s5p_mfc_get_sei_avail_status_v5,
1724         .get_mvc_num_views = s5p_mfc_get_mvc_num_views_v5,
1725         .get_mvc_view_id = s5p_mfc_get_mvc_view_id_v5,
1726         .get_pic_type_top = s5p_mfc_get_pic_type_top_v5,
1727         .get_pic_type_bot = s5p_mfc_get_pic_type_bot_v5,
1728         .get_crop_info_h = s5p_mfc_get_crop_info_h_v5,
1729         .get_crop_info_v = s5p_mfc_get_crop_info_v_v5,
1730 };
1731
1732 struct s5p_mfc_hw_ops *s5p_mfc_init_hw_ops_v5(void)
1733 {
1734         return &s5p_mfc_ops_v5;
1735 }