[media] media: videobuf2: Restructure vb2_buffer
[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->vb2_buf, 0),
1212                 ctx->consumed_stream, temp_vb->b->vb2_buf.planes[0].bytesused);
1213         spin_unlock_irqrestore(&dev->irqlock, flags);
1214         dev->curr_ctx = ctx->num;
1215         if (temp_vb->b->vb2_buf.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->vb2_buf.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(
1259                                         &src_mb->b->vb2_buf, 0);
1260                         src_c_addr = vb2_dma_contig_plane_dma_addr(
1261                                         &src_mb->b->vb2_buf, 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->vb2_buf, 0);
1271         dst_size = vb2_plane_size(&dst_mb->b->vb2_buf, 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->vb2_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",
1293                         temp_vb->b->vb2_buf.planes[0].bytesused);
1294         s5p_mfc_set_dec_stream_buffer_v5(ctx,
1295                         vb2_dma_contig_plane_dma_addr(&temp_vb->b->vb2_buf, 0),
1296                         0, temp_vb->b->vb2_buf.planes[0].bytesused);
1297         spin_unlock_irqrestore(&dev->irqlock, flags);
1298         dev->curr_ctx = ctx->num;
1299         s5p_mfc_init_decode_v5(ctx);
1300 }
1301
1302 static void s5p_mfc_run_init_enc(struct s5p_mfc_ctx *ctx)
1303 {
1304         struct s5p_mfc_dev *dev = ctx->dev;
1305         unsigned long flags;
1306         struct s5p_mfc_buf *dst_mb;
1307         unsigned long dst_addr;
1308         unsigned int dst_size;
1309
1310         s5p_mfc_set_enc_ref_buffer_v5(ctx);
1311         spin_lock_irqsave(&dev->irqlock, flags);
1312         dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
1313         dst_addr = vb2_dma_contig_plane_dma_addr(&dst_mb->b->vb2_buf, 0);
1314         dst_size = vb2_plane_size(&dst_mb->b->vb2_buf, 0);
1315         s5p_mfc_set_enc_stream_buffer_v5(ctx, dst_addr, dst_size);
1316         spin_unlock_irqrestore(&dev->irqlock, flags);
1317         dev->curr_ctx = ctx->num;
1318         s5p_mfc_init_encode_v5(ctx);
1319 }
1320
1321 static int s5p_mfc_run_init_dec_buffers(struct s5p_mfc_ctx *ctx)
1322 {
1323         struct s5p_mfc_dev *dev = ctx->dev;
1324         unsigned long flags;
1325         struct s5p_mfc_buf *temp_vb;
1326         int ret;
1327
1328         /*
1329          * Header was parsed now starting processing
1330          * First set the output frame buffers
1331          */
1332         if (ctx->capture_state != QUEUE_BUFS_MMAPED) {
1333                 mfc_err("It seems that not all destionation buffers were "
1334                         "mmaped\nMFC requires that all destination are mmaped "
1335                         "before starting processing\n");
1336                 return -EAGAIN;
1337         }
1338         spin_lock_irqsave(&dev->irqlock, flags);
1339         if (list_empty(&ctx->src_queue)) {
1340                 mfc_err("Header has been deallocated in the middle of"
1341                         " initialization\n");
1342                 spin_unlock_irqrestore(&dev->irqlock, flags);
1343                 return -EIO;
1344         }
1345         temp_vb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
1346         mfc_debug(2, "Header size: %d\n",
1347                         temp_vb->b->vb2_buf.planes[0].bytesused);
1348         s5p_mfc_set_dec_stream_buffer_v5(ctx,
1349                         vb2_dma_contig_plane_dma_addr(&temp_vb->b->vb2_buf, 0),
1350                         0, temp_vb->b->vb2_buf.planes[0].bytesused);
1351         spin_unlock_irqrestore(&dev->irqlock, flags);
1352         dev->curr_ctx = ctx->num;
1353         ret = s5p_mfc_set_dec_frame_buffer_v5(ctx);
1354         if (ret) {
1355                 mfc_err("Failed to alloc frame mem\n");
1356                 ctx->state = MFCINST_ERROR;
1357         }
1358         return ret;
1359 }
1360
1361 /* Try running an operation on hardware */
1362 static void s5p_mfc_try_run_v5(struct s5p_mfc_dev *dev)
1363 {
1364         struct s5p_mfc_ctx *ctx;
1365         int new_ctx;
1366         unsigned int ret = 0;
1367
1368         if (test_bit(0, &dev->enter_suspend)) {
1369                 mfc_debug(1, "Entering suspend so do not schedule any jobs\n");
1370                 return;
1371         }
1372         /* Check whether hardware is not running */
1373         if (test_and_set_bit(0, &dev->hw_lock) != 0) {
1374                 /* This is perfectly ok, the scheduled ctx should wait */
1375                 mfc_debug(1, "Couldn't lock HW\n");
1376                 return;
1377         }
1378         /* Choose the context to run */
1379         new_ctx = s5p_mfc_get_new_ctx(dev);
1380         if (new_ctx < 0) {
1381                 /* No contexts to run */
1382                 if (test_and_clear_bit(0, &dev->hw_lock) == 0) {
1383                         mfc_err("Failed to unlock hardware\n");
1384                         return;
1385                 }
1386                 mfc_debug(1, "No ctx is scheduled to be run\n");
1387                 return;
1388         }
1389         ctx = dev->ctx[new_ctx];
1390         /* Got context to run in ctx */
1391         /*
1392          * Last frame has already been sent to MFC.
1393          * Now obtaining frames from MFC buffer
1394          */
1395         s5p_mfc_clock_on();
1396         s5p_mfc_clean_ctx_int_flags(ctx);
1397
1398         if (ctx->type == MFCINST_DECODER) {
1399                 s5p_mfc_set_dec_desc_buffer(ctx);
1400                 switch (ctx->state) {
1401                 case MFCINST_FINISHING:
1402                         s5p_mfc_run_dec_frame(ctx, MFC_DEC_LAST_FRAME);
1403                         break;
1404                 case MFCINST_RUNNING:
1405                         ret = s5p_mfc_run_dec_frame(ctx, MFC_DEC_FRAME);
1406                         break;
1407                 case MFCINST_INIT:
1408                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
1409                                         ctx);
1410                         break;
1411                 case MFCINST_RETURN_INST:
1412                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
1413                                         ctx);
1414                         break;
1415                 case MFCINST_GOT_INST:
1416                         s5p_mfc_run_init_dec(ctx);
1417                         break;
1418                 case MFCINST_HEAD_PARSED:
1419                         ret = s5p_mfc_run_init_dec_buffers(ctx);
1420                         mfc_debug(1, "head parsed\n");
1421                         break;
1422                 case MFCINST_RES_CHANGE_INIT:
1423                         s5p_mfc_run_res_change(ctx);
1424                         break;
1425                 case MFCINST_RES_CHANGE_FLUSH:
1426                         s5p_mfc_run_dec_frame(ctx, MFC_DEC_FRAME);
1427                         break;
1428                 case MFCINST_RES_CHANGE_END:
1429                         mfc_debug(2, "Finished remaining frames after resolution change\n");
1430                         ctx->capture_state = QUEUE_FREE;
1431                         mfc_debug(2, "Will re-init the codec\n");
1432                         s5p_mfc_run_init_dec(ctx);
1433                         break;
1434                 default:
1435                         ret = -EAGAIN;
1436                 }
1437         } else if (ctx->type == MFCINST_ENCODER) {
1438                 switch (ctx->state) {
1439                 case MFCINST_FINISHING:
1440                 case MFCINST_RUNNING:
1441                         ret = s5p_mfc_run_enc_frame(ctx);
1442                         break;
1443                 case MFCINST_INIT:
1444                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
1445                                         ctx);
1446                         break;
1447                 case MFCINST_RETURN_INST:
1448                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
1449                                         ctx);
1450                         break;
1451                 case MFCINST_GOT_INST:
1452                         s5p_mfc_run_init_enc(ctx);
1453                         break;
1454                 default:
1455                         ret = -EAGAIN;
1456                 }
1457         } else {
1458                 mfc_err("Invalid context type: %d\n", ctx->type);
1459                 ret = -EAGAIN;
1460         }
1461
1462         if (ret) {
1463                 /* Free hardware lock */
1464                 if (test_and_clear_bit(0, &dev->hw_lock) == 0)
1465                         mfc_err("Failed to unlock hardware\n");
1466
1467                 /* This is in deed imporant, as no operation has been
1468                  * scheduled, reduce the clock count as no one will
1469                  * ever do this, because no interrupt related to this try_run
1470                  * will ever come from hardware. */
1471                 s5p_mfc_clock_off();
1472         }
1473 }
1474
1475
1476 static void s5p_mfc_cleanup_queue_v5(struct list_head *lh, struct vb2_queue *vq)
1477 {
1478         struct s5p_mfc_buf *b;
1479         int i;
1480
1481         while (!list_empty(lh)) {
1482                 b = list_entry(lh->next, struct s5p_mfc_buf, list);
1483                 for (i = 0; i < b->b->vb2_buf.num_planes; i++)
1484                         vb2_set_plane_payload(&b->b->vb2_buf, i, 0);
1485                 vb2_buffer_done(&b->b->vb2_buf, VB2_BUF_STATE_ERROR);
1486                 list_del(&b->list);
1487         }
1488 }
1489
1490 static void s5p_mfc_clear_int_flags_v5(struct s5p_mfc_dev *dev)
1491 {
1492         mfc_write(dev, 0, S5P_FIMV_RISC_HOST_INT);
1493         mfc_write(dev, 0, S5P_FIMV_RISC2HOST_CMD);
1494         mfc_write(dev, 0xffff, S5P_FIMV_SI_RTN_CHID);
1495 }
1496
1497 static int s5p_mfc_get_dspl_y_adr_v5(struct s5p_mfc_dev *dev)
1498 {
1499         return mfc_read(dev, S5P_FIMV_SI_DISPLAY_Y_ADR) << MFC_OFFSET_SHIFT;
1500 }
1501
1502 static int s5p_mfc_get_dec_y_adr_v5(struct s5p_mfc_dev *dev)
1503 {
1504         return mfc_read(dev, S5P_FIMV_SI_DECODE_Y_ADR) << MFC_OFFSET_SHIFT;
1505 }
1506
1507 static int s5p_mfc_get_dspl_status_v5(struct s5p_mfc_dev *dev)
1508 {
1509         return mfc_read(dev, S5P_FIMV_SI_DISPLAY_STATUS);
1510 }
1511
1512 static int s5p_mfc_get_dec_status_v5(struct s5p_mfc_dev *dev)
1513 {
1514         return mfc_read(dev, S5P_FIMV_SI_DECODE_STATUS);
1515 }
1516
1517 static int s5p_mfc_get_dec_frame_type_v5(struct s5p_mfc_dev *dev)
1518 {
1519         return mfc_read(dev, S5P_FIMV_DECODE_FRAME_TYPE) &
1520                 S5P_FIMV_DECODE_FRAME_MASK;
1521 }
1522
1523 static int s5p_mfc_get_disp_frame_type_v5(struct s5p_mfc_ctx *ctx)
1524 {
1525         return (s5p_mfc_read_info_v5(ctx, DISP_PIC_FRAME_TYPE) >>
1526                         S5P_FIMV_SHARED_DISP_FRAME_TYPE_SHIFT) &
1527                         S5P_FIMV_DECODE_FRAME_MASK;
1528 }
1529
1530 static int s5p_mfc_get_consumed_stream_v5(struct s5p_mfc_dev *dev)
1531 {
1532         return mfc_read(dev, S5P_FIMV_SI_CONSUMED_BYTES);
1533 }
1534
1535 static int s5p_mfc_get_int_reason_v5(struct s5p_mfc_dev *dev)
1536 {
1537         int reason;
1538         reason = mfc_read(dev, S5P_FIMV_RISC2HOST_CMD) &
1539                 S5P_FIMV_RISC2HOST_CMD_MASK;
1540         switch (reason) {
1541         case S5P_FIMV_R2H_CMD_OPEN_INSTANCE_RET:
1542                 reason = S5P_MFC_R2H_CMD_OPEN_INSTANCE_RET;
1543                 break;
1544         case S5P_FIMV_R2H_CMD_CLOSE_INSTANCE_RET:
1545                 reason = S5P_MFC_R2H_CMD_CLOSE_INSTANCE_RET;
1546                 break;
1547         case S5P_FIMV_R2H_CMD_SEQ_DONE_RET:
1548                 reason = S5P_MFC_R2H_CMD_SEQ_DONE_RET;
1549                 break;
1550         case S5P_FIMV_R2H_CMD_FRAME_DONE_RET:
1551                 reason = S5P_MFC_R2H_CMD_FRAME_DONE_RET;
1552                 break;
1553         case S5P_FIMV_R2H_CMD_SLICE_DONE_RET:
1554                 reason = S5P_MFC_R2H_CMD_SLICE_DONE_RET;
1555                 break;
1556         case S5P_FIMV_R2H_CMD_SYS_INIT_RET:
1557                 reason = S5P_MFC_R2H_CMD_SYS_INIT_RET;
1558                 break;
1559         case S5P_FIMV_R2H_CMD_FW_STATUS_RET:
1560                 reason = S5P_MFC_R2H_CMD_FW_STATUS_RET;
1561                 break;
1562         case S5P_FIMV_R2H_CMD_SLEEP_RET:
1563                 reason = S5P_MFC_R2H_CMD_SLEEP_RET;
1564                 break;
1565         case S5P_FIMV_R2H_CMD_WAKEUP_RET:
1566                 reason = S5P_MFC_R2H_CMD_WAKEUP_RET;
1567                 break;
1568         case S5P_FIMV_R2H_CMD_INIT_BUFFERS_RET:
1569                 reason = S5P_MFC_R2H_CMD_INIT_BUFFERS_RET;
1570                 break;
1571         case S5P_FIMV_R2H_CMD_ENC_COMPLETE_RET:
1572                 reason = S5P_MFC_R2H_CMD_COMPLETE_SEQ_RET;
1573                 break;
1574         case S5P_FIMV_R2H_CMD_ERR_RET:
1575                 reason = S5P_MFC_R2H_CMD_ERR_RET;
1576                 break;
1577         default:
1578                 reason = S5P_MFC_R2H_CMD_EMPTY;
1579         }
1580         return reason;
1581 }
1582
1583 static int s5p_mfc_get_int_err_v5(struct s5p_mfc_dev *dev)
1584 {
1585         return mfc_read(dev, S5P_FIMV_RISC2HOST_ARG2);
1586 }
1587
1588 static int s5p_mfc_err_dec_v5(unsigned int err)
1589 {
1590         return (err & S5P_FIMV_ERR_DEC_MASK) >> S5P_FIMV_ERR_DEC_SHIFT;
1591 }
1592
1593 static int s5p_mfc_err_dspl_v5(unsigned int err)
1594 {
1595         return (err & S5P_FIMV_ERR_DSPL_MASK) >> S5P_FIMV_ERR_DSPL_SHIFT;
1596 }
1597
1598 static int s5p_mfc_get_img_width_v5(struct s5p_mfc_dev *dev)
1599 {
1600         return mfc_read(dev, S5P_FIMV_SI_HRESOL);
1601 }
1602
1603 static int s5p_mfc_get_img_height_v5(struct s5p_mfc_dev *dev)
1604 {
1605         return mfc_read(dev, S5P_FIMV_SI_VRESOL);
1606 }
1607
1608 static int s5p_mfc_get_dpb_count_v5(struct s5p_mfc_dev *dev)
1609 {
1610         return mfc_read(dev, S5P_FIMV_SI_BUF_NUMBER);
1611 }
1612
1613 static int s5p_mfc_get_mv_count_v5(struct s5p_mfc_dev *dev)
1614 {
1615         /* NOP */
1616         return -1;
1617 }
1618
1619 static int s5p_mfc_get_inst_no_v5(struct s5p_mfc_dev *dev)
1620 {
1621         return mfc_read(dev, S5P_FIMV_RISC2HOST_ARG1);
1622 }
1623
1624 static int s5p_mfc_get_enc_strm_size_v5(struct s5p_mfc_dev *dev)
1625 {
1626         return mfc_read(dev, S5P_FIMV_ENC_SI_STRM_SIZE);
1627 }
1628
1629 static int s5p_mfc_get_enc_slice_type_v5(struct s5p_mfc_dev *dev)
1630 {
1631         return mfc_read(dev, S5P_FIMV_ENC_SI_SLICE_TYPE);
1632 }
1633
1634 static int s5p_mfc_get_enc_dpb_count_v5(struct s5p_mfc_dev *dev)
1635 {
1636         return -1;
1637 }
1638
1639 static int s5p_mfc_get_enc_pic_count_v5(struct s5p_mfc_dev *dev)
1640 {
1641         return mfc_read(dev, S5P_FIMV_ENC_SI_PIC_CNT);
1642 }
1643
1644 static int s5p_mfc_get_sei_avail_status_v5(struct s5p_mfc_ctx *ctx)
1645 {
1646         return s5p_mfc_read_info_v5(ctx, FRAME_PACK_SEI_AVAIL);
1647 }
1648
1649 static int s5p_mfc_get_mvc_num_views_v5(struct s5p_mfc_dev *dev)
1650 {
1651         return -1;
1652 }
1653
1654 static int s5p_mfc_get_mvc_view_id_v5(struct s5p_mfc_dev *dev)
1655 {
1656         return -1;
1657 }
1658
1659 static unsigned int s5p_mfc_get_pic_type_top_v5(struct s5p_mfc_ctx *ctx)
1660 {
1661         return s5p_mfc_read_info_v5(ctx, PIC_TIME_TOP);
1662 }
1663
1664 static unsigned int s5p_mfc_get_pic_type_bot_v5(struct s5p_mfc_ctx *ctx)
1665 {
1666         return s5p_mfc_read_info_v5(ctx, PIC_TIME_BOT);
1667 }
1668
1669 static unsigned int s5p_mfc_get_crop_info_h_v5(struct s5p_mfc_ctx *ctx)
1670 {
1671         return s5p_mfc_read_info_v5(ctx, CROP_INFO_H);
1672 }
1673
1674 static unsigned int s5p_mfc_get_crop_info_v_v5(struct s5p_mfc_ctx *ctx)
1675 {
1676         return s5p_mfc_read_info_v5(ctx, CROP_INFO_V);
1677 }
1678
1679 /* Initialize opr function pointers for MFC v5 */
1680 static struct s5p_mfc_hw_ops s5p_mfc_ops_v5 = {
1681         .alloc_dec_temp_buffers = s5p_mfc_alloc_dec_temp_buffers_v5,
1682         .release_dec_desc_buffer = s5p_mfc_release_dec_desc_buffer_v5,
1683         .alloc_codec_buffers = s5p_mfc_alloc_codec_buffers_v5,
1684         .release_codec_buffers = s5p_mfc_release_codec_buffers_v5,
1685         .alloc_instance_buffer = s5p_mfc_alloc_instance_buffer_v5,
1686         .release_instance_buffer = s5p_mfc_release_instance_buffer_v5,
1687         .alloc_dev_context_buffer = s5p_mfc_alloc_dev_context_buffer_v5,
1688         .release_dev_context_buffer = s5p_mfc_release_dev_context_buffer_v5,
1689         .dec_calc_dpb_size = s5p_mfc_dec_calc_dpb_size_v5,
1690         .enc_calc_src_size = s5p_mfc_enc_calc_src_size_v5,
1691         .set_dec_stream_buffer = s5p_mfc_set_dec_stream_buffer_v5,
1692         .set_dec_frame_buffer = s5p_mfc_set_dec_frame_buffer_v5,
1693         .set_enc_stream_buffer = s5p_mfc_set_enc_stream_buffer_v5,
1694         .set_enc_frame_buffer = s5p_mfc_set_enc_frame_buffer_v5,
1695         .get_enc_frame_buffer = s5p_mfc_get_enc_frame_buffer_v5,
1696         .set_enc_ref_buffer = s5p_mfc_set_enc_ref_buffer_v5,
1697         .init_decode = s5p_mfc_init_decode_v5,
1698         .init_encode = s5p_mfc_init_encode_v5,
1699         .encode_one_frame = s5p_mfc_encode_one_frame_v5,
1700         .try_run = s5p_mfc_try_run_v5,
1701         .cleanup_queue = s5p_mfc_cleanup_queue_v5,
1702         .clear_int_flags = s5p_mfc_clear_int_flags_v5,
1703         .write_info = s5p_mfc_write_info_v5,
1704         .read_info = s5p_mfc_read_info_v5,
1705         .get_dspl_y_adr = s5p_mfc_get_dspl_y_adr_v5,
1706         .get_dec_y_adr = s5p_mfc_get_dec_y_adr_v5,
1707         .get_dspl_status = s5p_mfc_get_dspl_status_v5,
1708         .get_dec_status = s5p_mfc_get_dec_status_v5,
1709         .get_dec_frame_type = s5p_mfc_get_dec_frame_type_v5,
1710         .get_disp_frame_type = s5p_mfc_get_disp_frame_type_v5,
1711         .get_consumed_stream = s5p_mfc_get_consumed_stream_v5,
1712         .get_int_reason = s5p_mfc_get_int_reason_v5,
1713         .get_int_err = s5p_mfc_get_int_err_v5,
1714         .err_dec = s5p_mfc_err_dec_v5,
1715         .err_dspl = s5p_mfc_err_dspl_v5,
1716         .get_img_width = s5p_mfc_get_img_width_v5,
1717         .get_img_height = s5p_mfc_get_img_height_v5,
1718         .get_dpb_count = s5p_mfc_get_dpb_count_v5,
1719         .get_mv_count = s5p_mfc_get_mv_count_v5,
1720         .get_inst_no = s5p_mfc_get_inst_no_v5,
1721         .get_enc_strm_size = s5p_mfc_get_enc_strm_size_v5,
1722         .get_enc_slice_type = s5p_mfc_get_enc_slice_type_v5,
1723         .get_enc_dpb_count = s5p_mfc_get_enc_dpb_count_v5,
1724         .get_enc_pic_count = s5p_mfc_get_enc_pic_count_v5,
1725         .get_sei_avail_status = s5p_mfc_get_sei_avail_status_v5,
1726         .get_mvc_num_views = s5p_mfc_get_mvc_num_views_v5,
1727         .get_mvc_view_id = s5p_mfc_get_mvc_view_id_v5,
1728         .get_pic_type_top = s5p_mfc_get_pic_type_top_v5,
1729         .get_pic_type_bot = s5p_mfc_get_pic_type_bot_v5,
1730         .get_crop_info_h = s5p_mfc_get_crop_info_h_v5,
1731         .get_crop_info_v = s5p_mfc_get_crop_info_v_v5,
1732 };
1733
1734 struct s5p_mfc_hw_ops *s5p_mfc_init_hw_ops_v5(void)
1735 {
1736         return &s5p_mfc_ops_v5;
1737 }