1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Rockchip RK3288 VPU codec driver
4  *
5  * Copyright (c) 2014 Rockchip Electronics Co., Ltd.
6  *	Hertz Wong <hertz.wong@rock-chips.com>
7  *	Herman Chen <herman.chen@rock-chips.com>
8  *
9  * Copyright (C) 2014 Google, Inc.
10  *	Tomasz Figa <tfiga@chromium.org>
11  */
12 
13 #include <linux/types.h>
14 #include <media/v4l2-h264.h>
15 #include <media/v4l2-mem2mem.h>
16 
17 #include "hantro.h"
18 #include "hantro_hw.h"
19 
20 /* Size with u32 units. */
21 #define CABAC_INIT_BUFFER_SIZE		(460 * 2)
22 #define POC_BUFFER_SIZE			34
23 #define SCALING_LIST_SIZE		(6 * 16 + 2 * 64)
24 
25 /*
26  * For valid and long term reference marking, index are reversed, so bit 31
27  * indicates the status of the picture 0.
28  */
29 #define REF_BIT(i)			BIT(32 - 1 - (i))
30 
31 /* Data structure describing auxiliary buffer format. */
32 struct hantro_h264_dec_priv_tbl {
33 	u32 cabac_table[CABAC_INIT_BUFFER_SIZE];
34 	u32 poc[POC_BUFFER_SIZE];
35 	u8 scaling_list[SCALING_LIST_SIZE];
36 };
37 
38 /*
39  * Constant CABAC table.
40  * From drivers/media/platform/rk3288-vpu/rk3288_vpu_hw_h264d.c
41  * in https://chromium.googlesource.com/chromiumos/third_party/kernel,
42  * chromeos-3.14 branch.
43  */
44 static const u32 h264_cabac_table[] = {
45 	0x14f10236, 0x034a14f1, 0x0236034a, 0xe47fe968, 0xfa35ff36, 0x07330000,
46 	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
47 	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
48 	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
49 	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
50 	0x0029003f, 0x003f003f, 0xf7530456, 0x0061f948, 0x0d29033e, 0x000b0137,
51 	0x0045ef7f, 0xf3660052, 0xf94aeb6b, 0xe57fe17f, 0xe87fee5f, 0xe57feb72,
52 	0xe27fef7b, 0xf473f07a, 0xf573f43f, 0xfe44f154, 0xf368fd46, 0xf85df65a,
53 	0xe27fff4a, 0xfa61f95b, 0xec7ffc38, 0xfb52f94c, 0xea7df95d, 0xf557fd4d,
54 	0xfb47fc3f, 0xfc44f454, 0xf93ef941, 0x083d0538, 0xfe420140, 0x003dfe4e,
55 	0x01320734, 0x0a23002c, 0x0b26012d, 0x002e052c, 0x1f110133, 0x07321c13,
56 	0x10210e3e, 0xf36cf164, 0xf365f35b, 0xf45ef658, 0xf054f656, 0xf953f357,
57 	0xed5e0146, 0x0048fb4a, 0x123bf866, 0xf164005f, 0xfc4b0248, 0xf54bfd47,
58 	0x0f2ef345, 0x003e0041, 0x1525f148, 0x09391036, 0x003e0c48, 0x18000f09,
59 	0x08190d12, 0x0f090d13, 0x0a250c12, 0x061d1421, 0x0f1e042d, 0x013a003e,
60 	0x073d0c26, 0x0b2d0f27, 0x0b2a0d2c, 0x102d0c29, 0x0a311e22, 0x122a0a37,
61 	0x1133112e, 0x00591aed, 0x16ef1aef, 0x1ee71cec, 0x21e925e5, 0x21e928e4,
62 	0x26ef21f5, 0x28f129fa, 0x26012911, 0x1efa1b03, 0x1a1625f0, 0x23fc26f8,
63 	0x26fd2503, 0x26052a00, 0x23102716, 0x0e301b25, 0x153c0c44, 0x0261fd47,
64 	0xfa2afb32, 0xfd36fe3e, 0x003a013f, 0xfe48ff4a, 0xf75bfb43, 0xfb1bfd27,
65 	0xfe2c002e, 0xf040f844, 0xf64efa4d, 0xf656f45c, 0xf137f63c, 0xfa3efc41,
66 	0xf449f84c, 0xf950f758, 0xef6ef561, 0xec54f54f, 0xfa49fc4a, 0xf356f360,
67 	0xf561ed75, 0xf84efb21, 0xfc30fe35, 0xfd3ef347, 0xf64ff456, 0xf35af261,
68 	0x0000fa5d, 0xfa54f84f, 0x0042ff47, 0x003efe3c, 0xfe3bfb4b, 0xfd3efc3a,
69 	0xf742ff4f, 0x00470344, 0x0a2cf93e, 0x0f240e28, 0x101b0c1d, 0x012c1424,
70 	0x1220052a, 0x01300a3e, 0x112e0940, 0xf468f561, 0xf060f958, 0xf855f955,
71 	0xf755f358, 0x0442fd4d, 0xfd4cfa4c, 0x0a3aff4c, 0xff53f963, 0xf25f025f,
72 	0x004cfb4a, 0x0046f54b, 0x01440041, 0xf249033e, 0x043eff44, 0xf34b0b37,
73 	0x05400c46, 0x0f060613, 0x07100c0e, 0x120d0d0b, 0x0d0f0f10, 0x0c170d17,
74 	0x0f140e1a, 0x0e2c1128, 0x112f1811, 0x15151916, 0x1f1b161d, 0x13230e32,
75 	0x0a39073f, 0xfe4dfc52, 0xfd5e0945, 0xf46d24dd, 0x24de20e6, 0x25e22ce0,
76 	0x22ee22f1, 0x28f121f9, 0x23fb2100, 0x2602210d, 0x17230d3a, 0x1dfd1a00,
77 	0x161e1ff9, 0x23f122fd, 0x220324ff, 0x2205200b, 0x2305220c, 0x270b1e1d,
78 	0x221a1d27, 0x13421f15, 0x1f1f1932, 0xef78ec70, 0xee72f555, 0xf15cf259,
79 	0xe647f151, 0xf2500044, 0xf246e838, 0xe944e832, 0xf54a17f3, 0x1af328f1,
80 	0x31f22c03, 0x2d062c22, 0x21361352, 0xfd4bff17, 0x0122012b, 0x0036fe37,
81 	0x003d0140, 0x0044f75c, 0xf26af361, 0xf15af45a, 0xee58f649, 0xf74ff256,
82 	0xf649f646, 0xf645fb42, 0xf740fb3a, 0x023b15f6, 0x18f51cf8, 0x1cff1d03,
83 	0x1d092314, 0x1d240e43, 0x14f10236, 0x034a14f1, 0x0236034a, 0xe47fe968,
84 	0xfa35ff36, 0x07331721, 0x17021500, 0x01090031, 0xdb760539, 0xf34ef541,
85 	0x013e0c31, 0xfc491132, 0x1240092b, 0x1d001a43, 0x105a0968, 0xd27fec68,
86 	0x0143f34e, 0xf541013e, 0xfa56ef5f, 0xfa3d092d, 0xfd45fa51, 0xf5600637,
87 	0x0743fb56, 0x0258003a, 0xfd4cf65e, 0x05360445, 0xfd510058, 0xf943fb4a,
88 	0xfc4afb50, 0xf948013a, 0x0029003f, 0x003f003f, 0xf7530456, 0x0061f948,
89 	0x0d29033e, 0x002dfc4e, 0xfd60e57e, 0xe462e765, 0xe943e452, 0xec5ef053,
90 	0xea6eeb5b, 0xee66f35d, 0xe37ff95c, 0xfb59f960, 0xf36cfd2e, 0xff41ff39,
91 	0xf75dfd4a, 0xf75cf857, 0xe97e0536, 0x063c063b, 0x0645ff30, 0x0044fc45,
92 	0xf858fe55, 0xfa4eff4b, 0xf94d0236, 0x0532fd44, 0x0132062a, 0xfc51013f,
93 	0xfc460043, 0x0239fe4c, 0x0b230440, 0x013d0b23, 0x12190c18, 0x0d1d0d24,
94 	0xf65df949, 0xfe490d2e, 0x0931f964, 0x09350235, 0x0535fe3d, 0x00380038,
95 	0xf33ffb3c, 0xff3e0439, 0xfa450439, 0x0e270433, 0x0d440340, 0x013d093f,
96 	0x07321027, 0x052c0434, 0x0b30fb3c, 0xff3b003b, 0x1621052c, 0x0e2bff4e,
97 	0x003c0945, 0x0b1c0228, 0x032c0031, 0x002e022c, 0x0233002f, 0x0427023e,
98 	0x062e0036, 0x0336023a, 0x043f0633, 0x06390735, 0x06340637, 0x0b2d0e24,
99 	0x0835ff52, 0x0737fd4e, 0x0f2e161f, 0xff541907, 0x1ef91c03, 0x1c042000,
100 	0x22ff1e06, 0x1e062009, 0x1f131a1b, 0x1a1e2514, 0x1c221146, 0x0143053b,
101 	0x0943101e, 0x12201223, 0x161d181f, 0x1726122b, 0x14290b3f, 0x093b0940,
102 	0xff5efe59, 0xf76cfa4c, 0xfe2c002d, 0x0034fd40, 0xfe3bfc46, 0xfc4bf852,
103 	0xef66f74d, 0x0318002a, 0x00300037, 0xfa3bf947, 0xf453f557, 0xe277013a,
104 	0xfd1dff24, 0x0126022b, 0xfa37003a, 0x0040fd4a, 0xf65a0046, 0xfc1d051f,
105 	0x072a013b, 0xfe3afd48, 0xfd51f561, 0x003a0805, 0x0a0e0e12, 0x0d1b0228,
106 	0x003afd46, 0xfa4ff855, 0x0000f36a, 0xf06af657, 0xeb72ee6e, 0xf262ea6e,
107 	0xeb6aee67, 0xeb6be96c, 0xe670f660, 0xf45ffb5b, 0xf75dea5e, 0xfb560943,
108 	0xfc50f655, 0xff46073c, 0x093a053d, 0x0c320f32, 0x12311136, 0x0a29072e,
109 	0xff330731, 0x08340929, 0x062f0237, 0x0d290a2c, 0x06320535, 0x0d31043f,
110 	0x0640fe45, 0xfe3b0646, 0x0a2c091f, 0x0c2b0335, 0x0e220a26, 0xfd340d28,
111 	0x1120072c, 0x07260d32, 0x0a391a2b, 0x0e0b0b0e, 0x090b120b, 0x150917fe,
112 	0x20f120f1, 0x22eb27e9, 0x2adf29e1, 0x2ee426f4, 0x151d2de8, 0x35d330e6,
113 	0x41d52bed, 0x27f61e09, 0x121a141b, 0x0039f252, 0xfb4bed61, 0xdd7d1b00,
114 	0x1c001ffc, 0x1b062208, 0x1e0a1816, 0x21131620, 0x1a1f1529, 0x1a2c172f,
115 	0x10410e47, 0x083c063f, 0x11411518, 0x17141a17, 0x1b201c17, 0x1c181728,
116 	0x18201c1d, 0x172a1339, 0x1635163d, 0x0b560c28, 0x0b330e3b, 0xfc4ff947,
117 	0xfb45f746, 0xf842f644, 0xed49f445, 0xf046f143, 0xec3eed46, 0xf042ea41,
118 	0xec3f09fe, 0x1af721f7, 0x27f929fe, 0x2d033109, 0x2d1b243b, 0xfa42f923,
119 	0xf92af82d, 0xfb30f438, 0xfa3cfb3e, 0xf842f84c, 0xfb55fa51, 0xf64df951,
120 	0xef50ee49, 0xfc4af653, 0xf747f743, 0xff3df842, 0xf242003b, 0x023b15f3,
121 	0x21f227f9, 0x2efe3302, 0x3c063d11, 0x37222a3e, 0x14f10236, 0x034a14f1,
122 	0x0236034a, 0xe47fe968, 0xfa35ff36, 0x07331619, 0x22001000, 0xfe090429,
123 	0xe3760241, 0xfa47f34f, 0x05340932, 0xfd460a36, 0x1a221316, 0x28003902,
124 	0x29241a45, 0xd37ff165, 0xfc4cfa47, 0xf34f0534, 0x0645f35a, 0x0034082b,
125 	0xfe45fb52, 0xf660023b, 0x024bfd57, 0xfd640138, 0xfd4afa55, 0x003bfd51,
126 	0xf956fb5f, 0xff42ff4d, 0x0146fe56, 0xfb48003d, 0x0029003f, 0x003f003f,
127 	0xf7530456, 0x0061f948, 0x0d29033e, 0x0d0f0733, 0x0250d97f, 0xee5bef60,
128 	0xe651dd62, 0xe866e961, 0xe577e863, 0xeb6eee66, 0xdc7f0050, 0xfb59f95e,
129 	0xfc5c0027, 0x0041f154, 0xdd7ffe49, 0xf468f75b, 0xe17f0337, 0x07380737,
130 	0x083dfd35, 0x0044f94a, 0xf758f367, 0xf35bf759, 0xf25cf84c, 0xf457e96e,
131 	0xe869f64e, 0xec70ef63, 0xb27fba7f, 0xce7fd27f, 0xfc42fb4e, 0xfc47f848,
132 	0x023bff37, 0xf946fa4b, 0xf859de77, 0xfd4b2014, 0x1e16d47f, 0x0036fb3d,
133 	0x003aff3c, 0xfd3df843, 0xe754f24a, 0xfb410534, 0x0239003d, 0xf745f546,
134 	0x1237fc47, 0x003a073d, 0x09291219, 0x0920052b, 0x092f002c, 0x0033022e,
135 	0x1326fc42, 0x0f260c2a, 0x09220059, 0x042d0a1c, 0x0a1f21f5, 0x34d5120f,
136 	0x1c0023ea, 0x26e72200, 0x27ee20f4, 0x66a20000, 0x38f121fc, 0x1d0a25fb,
137 	0x33e327f7, 0x34de45c6, 0x43c12cfb, 0x200737e3, 0x20010000, 0x1b2421e7,
138 	0x22e224e4, 0x26e426e5, 0x22ee23f0, 0x22f220f8, 0x25fa2300, 0x1e0a1c12,
139 	0x1a191d29, 0x004b0248, 0x084d0e23, 0x121f1123, 0x151e112d, 0x142a122d,
140 	0x1b1a1036, 0x07421038, 0x0b490a43, 0xf674e970, 0xf147f93d, 0x0035fb42,
141 	0xf54df750, 0xf754f657, 0xde7feb65, 0xfd27fb35, 0xf93df54b, 0xf14def5b,
142 	0xe76be76f, 0xe47af54c, 0xf62cf634, 0xf639f73a, 0xf048f945, 0xfc45fb4a,
143 	0xf7560242, 0xf7220120, 0x0b1f0534, 0xfe37fe43, 0x0049f859, 0x03340704,
144 	0x0a081108, 0x10130325, 0xff3dfb49, 0xff46fc4e, 0x0000eb7e, 0xe97cec6e,
145 	0xe67ee77c, 0xef69e579, 0xe575ef66, 0xe675e574, 0xdf7af65f, 0xf264f85f,
146 	0xef6fe472, 0xfa59fe50, 0xfc52f755, 0xf851ff48, 0x05400143, 0x09380045,
147 	0x01450745, 0xf945fa43, 0xf04dfe40, 0x023dfa43, 0xfd400239, 0xfd41fd42,
148 	0x003e0933, 0xff42fe47, 0xfe4bff46, 0xf7480e3c, 0x1025002f, 0x12230b25,
149 	0x0c290a29, 0x02300c29, 0x0d29003b, 0x03321328, 0x03421232, 0x13fa12fa,
150 	0x0e001af4, 0x1ff021e7, 0x21ea25e4, 0x27e22ae2, 0x2fd62ddc, 0x31de29ef,
151 	0x200945b9, 0x3fc142c0, 0x4db636d9, 0x34dd29f6, 0x240028ff, 0x1e0e1c1a,
152 	0x17250c37, 0x0b4125df, 0x27dc28db, 0x26e22edf, 0x2ae228e8, 0x31e326f4,
153 	0x28f626fd, 0x2efb1f14, 0x1d1e192c, 0x0c300b31, 0x1a2d1616, 0x17161b15,
154 	0x21141a1c, 0x1e181b22, 0x122a1927, 0x12320c46, 0x15360e47, 0x0b531920,
155 	0x15311536, 0xfb55fa51, 0xf64df951, 0xef50ee49, 0xfc4af653, 0xf747f743,
156 	0xff3df842, 0xf242003b, 0x023b11f6, 0x20f32af7, 0x31fb3500, 0x4003440a,
157 	0x421b2f39, 0xfb470018, 0xff24fe2a, 0xfe34f739, 0xfa3ffc41, 0xfc43f952,
158 	0xfd51fd4c, 0xf948fa4e, 0xf448f244, 0xfd46fa4c, 0xfb42fb3e, 0x0039fc3d,
159 	0xf73c0136, 0x023a11f6, 0x20f32af7, 0x31fb3500, 0x4003440a, 0x421b2f39,
160 	0x14f10236, 0x034a14f1, 0x0236034a, 0xe47fe968, 0xfa35ff36, 0x07331d10,
161 	0x19000e00, 0xf633fd3e, 0xe5631a10, 0xfc55e866, 0x05390639, 0xef490e39,
162 	0x1428140a, 0x1d003600, 0x252a0c61, 0xe07fea75, 0xfe4afc55, 0xe8660539,
163 	0xfa5df258, 0xfa2c0437, 0xf559f167, 0xeb741339, 0x143a0454, 0x0660013f,
164 	0xfb55f36a, 0x053f064b, 0xfd5aff65, 0x0337fc4f, 0xfe4bf461, 0xf932013c,
165 	0x0029003f, 0x003f003f, 0xf7530456, 0x0061f948, 0x0d29033e, 0x0722f758,
166 	0xec7fdc7f, 0xef5bf25f, 0xe754e756, 0xf459ef5b, 0xe17ff24c, 0xee67f35a,
167 	0xdb7f0b50, 0x054c0254, 0x054efa37, 0x043df253, 0xdb7ffb4f, 0xf568f55b,
168 	0xe27f0041, 0xfe4f0048, 0xfc5cfa38, 0x0344f847, 0xf362fc56, 0xf458fb52,
169 	0xfd48fc43, 0xf848f059, 0xf745ff3b, 0x05420439, 0xfc47fe47, 0x023aff4a,
170 	0xfc2cff45, 0x003ef933, 0xfc2ffa2a, 0xfd29fa35, 0x084cf74e, 0xf5530934,
171 	0x0043fb5a, 0x0143f148, 0xfb4bf850, 0xeb53eb40, 0xf31fe740, 0xe35e094b,
172 	0x113ff84a, 0xfb23fe1b, 0x0d5b0341, 0xf945084d, 0xf642033e, 0xfd44ec51,
173 	0x001e0107, 0xfd17eb4a, 0x1042e97c, 0x11252cee, 0x32deea7f, 0x0427002a,
174 	0x07220b1d, 0x081f0625, 0x072a0328, 0x08210d2b, 0x0d24042f, 0x0337023a,
175 	0x063c082c, 0x0b2c0e2a, 0x07300438, 0x04340d25, 0x0931133a, 0x0a300c2d,
176 	0x00451421, 0x083f23ee, 0x21e71cfd, 0x180a1b00, 0x22f234d4, 0x27e81311,
177 	0x1f19241d, 0x1821220f, 0x1e141649, 0x1422131f, 0x1b2c1310, 0x0f240f24,
178 	0x151c1915, 0x1e141f0c, 0x1b10182a, 0x005d0e38, 0x0f391a26, 0xe87fe873,
179 	0xea52f73e, 0x0035003b, 0xf255f359, 0xf35ef55c, 0xe37feb64, 0xf239f443,
180 	0xf547f64d, 0xeb55f058, 0xe968f162, 0xdb7ff652, 0xf830f83d, 0xf842f946,
181 	0xf24bf64f, 0xf753f45c, 0xee6cfc4f, 0xea45f04b, 0xfe3a013a, 0xf34ef753,
182 	0xfc51f363, 0xf351fa26, 0xf33efa3a, 0xfe3bf049, 0xf64cf356, 0xf753f657,
183 	0x0000ea7f, 0xe77fe778, 0xe57fed72, 0xe975e776, 0xe675e871, 0xe476e178,
184 	0xdb7cf65e, 0xf166f663, 0xf36ace7f, 0xfb5c1139, 0xfb56f35e, 0xf45bfe4d,
185 	0x0047ff49, 0x0440f951, 0x05400f39, 0x01430044, 0xf6430144, 0x004d0240,
186 	0x0044fb4e, 0x0737053b, 0x02410e36, 0x0f2c053c, 0x0246fe4c, 0xee560c46,
187 	0x0540f446, 0x0b370538, 0x00450241, 0xfa4a0536, 0x0736fa4c, 0xf552fe4d,
188 	0xfe4d192a, 0x11f310f7, 0x11f41beb, 0x25e229d8, 0x2ad730d1, 0x27e02ed8,
189 	0x34cd2ed7, 0x34d92bed, 0x200b3dc9, 0x38d23ece, 0x51bd2dec, 0x23fe1c0f,
190 	0x22012701, 0x1e111426, 0x122d0f36, 0x004f24f0, 0x25f225ef, 0x2001220f,
191 	0x1d0f1819, 0x22161f10, 0x23121f1c, 0x2129241c, 0x1b2f153e, 0x121f131a,
192 	0x24181817, 0x1b10181e, 0x1f1d1629, 0x162a103c, 0x0f340e3c, 0x034ef07b,
193 	0x15351638, 0x193d1521, 0x1332113d, 0xfd4ef84a, 0xf748f648, 0xee4bf447,
194 	0xf53ffb46, 0xef4bf248, 0xf043f835, 0xf23bf734, 0xf54409fe, 0x1ef61ffc,
195 	0x21ff2107, 0x1f0c2517, 0x1f261440, 0xf747f925, 0xf82cf531, 0xf638f43b,
196 	0xf83ff743, 0xfa44f64f, 0xfd4ef84a, 0xf748f648, 0xee4bf447, 0xf53ffb46,
197 	0xef4bf248, 0xf043f835, 0xf23bf734, 0xf54409fe, 0x1ef61ffc, 0x21ff2107,
198 	0x1f0c2517, 0x1f261440
199 };
200 
201 static void
202 assemble_scaling_list(struct hantro_ctx *ctx)
203 {
204 	const struct hantro_h264_dec_ctrls *ctrls = &ctx->h264_dec.ctrls;
205 	const struct v4l2_ctrl_h264_scaling_matrix *scaling = ctrls->scaling;
206 	const struct v4l2_ctrl_h264_pps *pps = ctrls->pps;
207 	const size_t num_list_4x4 = ARRAY_SIZE(scaling->scaling_list_4x4);
208 	const size_t list_len_4x4 = ARRAY_SIZE(scaling->scaling_list_4x4[0]);
209 	const size_t list_len_8x8 = ARRAY_SIZE(scaling->scaling_list_8x8[0]);
210 	struct hantro_h264_dec_priv_tbl *tbl = ctx->h264_dec.priv.cpu;
211 	u32 *dst = (u32 *)tbl->scaling_list;
212 	const u32 *src;
213 	int i, j;
214 
215 	if (!(pps->flags & V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT))
216 		return;
217 
218 	for (i = 0; i < num_list_4x4; i++) {
219 		src = (u32 *)&scaling->scaling_list_4x4[i];
220 		for (j = 0; j < list_len_4x4 / 4; j++)
221 			*dst++ = swab32(src[j]);
222 	}
223 
224 	/* Only Intra/Inter Y lists */
225 	for (i = 0; i < 2; i++) {
226 		src = (u32 *)&scaling->scaling_list_8x8[i];
227 		for (j = 0; j < list_len_8x8 / 4; j++)
228 			*dst++ = swab32(src[j]);
229 	}
230 }
231 
232 static void prepare_table(struct hantro_ctx *ctx)
233 {
234 	const struct hantro_h264_dec_ctrls *ctrls = &ctx->h264_dec.ctrls;
235 	const struct v4l2_ctrl_h264_decode_params *dec_param = ctrls->decode;
236 	const struct v4l2_ctrl_h264_sps *sps = ctrls->sps;
237 	struct hantro_h264_dec_priv_tbl *tbl = ctx->h264_dec.priv.cpu;
238 	const struct v4l2_h264_dpb_entry *dpb = ctx->h264_dec.dpb;
239 	u32 dpb_longterm = 0;
240 	u32 dpb_valid = 0;
241 	int i;
242 
243 	for (i = 0; i < HANTRO_H264_DPB_SIZE; ++i) {
244 		tbl->poc[i * 2] = dpb[i].top_field_order_cnt;
245 		tbl->poc[i * 2 + 1] = dpb[i].bottom_field_order_cnt;
246 
247 		if (!(dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_VALID))
248 			continue;
249 
250 		/*
251 		 * Set up bit maps of valid and long term DPBs.
252 		 * NOTE: The bits are reversed, i.e. MSb is DPB 0. For frame
253 		 * decoding, bit 31 to 15 are used, while for field decoding,
254 		 * all bits are used, with bit 31 being a top field, 30 a bottom
255 		 * field and so on.
256 		 */
257 		if (dec_param->flags & V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC) {
258 			if (dpb[i].fields & V4L2_H264_TOP_FIELD_REF)
259 				dpb_valid |= REF_BIT(i * 2);
260 
261 			if (dpb[i].fields & V4L2_H264_BOTTOM_FIELD_REF)
262 				dpb_valid |= REF_BIT(i * 2 + 1);
263 
264 			if (dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM) {
265 				dpb_longterm |= REF_BIT(i * 2);
266 				dpb_longterm |= REF_BIT(i * 2 + 1);
267 			}
268 		} else {
269 			dpb_valid |= REF_BIT(i);
270 
271 			if (dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM)
272 				dpb_longterm |= REF_BIT(i);
273 		}
274 	}
275 	ctx->h264_dec.dpb_valid = dpb_valid;
276 	ctx->h264_dec.dpb_longterm = dpb_longterm;
277 
278 	if ((dec_param->flags & V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC) ||
279 	    !(sps->flags & V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD)) {
280 		tbl->poc[32] = ctx->h264_dec.cur_poc;
281 		tbl->poc[33] = 0;
282 	} else {
283 		tbl->poc[32] = dec_param->top_field_order_cnt;
284 		tbl->poc[33] = dec_param->bottom_field_order_cnt;
285 	}
286 
287 	assemble_scaling_list(ctx);
288 }
289 
290 static bool dpb_entry_match(const struct v4l2_h264_dpb_entry *a,
291 			    const struct v4l2_h264_dpb_entry *b)
292 {
293 	return a->reference_ts == b->reference_ts;
294 }
295 
296 static void update_dpb(struct hantro_ctx *ctx)
297 {
298 	const struct v4l2_ctrl_h264_decode_params *dec_param;
299 	DECLARE_BITMAP(new, ARRAY_SIZE(dec_param->dpb)) = { 0, };
300 	DECLARE_BITMAP(used, ARRAY_SIZE(dec_param->dpb)) = { 0, };
301 	unsigned int i, j;
302 
303 	dec_param = ctx->h264_dec.ctrls.decode;
304 
305 	/* Disable all entries by default. */
306 	for (i = 0; i < ARRAY_SIZE(ctx->h264_dec.dpb); i++)
307 		ctx->h264_dec.dpb[i].flags = 0;
308 
309 	/* Try to match new DPB entries with existing ones by their POCs. */
310 	for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
311 		const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
312 
313 		if (!(ndpb->flags & V4L2_H264_DPB_ENTRY_FLAG_VALID))
314 			continue;
315 
316 		/*
317 		 * To cut off some comparisons, iterate only on target DPB
318 		 * entries which are not used yet.
319 		 */
320 		for_each_clear_bit(j, used, ARRAY_SIZE(ctx->h264_dec.dpb)) {
321 			struct v4l2_h264_dpb_entry *cdpb;
322 
323 			cdpb = &ctx->h264_dec.dpb[j];
324 			if (!dpb_entry_match(cdpb, ndpb))
325 				continue;
326 
327 			*cdpb = *ndpb;
328 			set_bit(j, used);
329 			break;
330 		}
331 
332 		if (j == ARRAY_SIZE(ctx->h264_dec.dpb))
333 			set_bit(i, new);
334 	}
335 
336 	/* For entries that could not be matched, use remaining free slots. */
337 	for_each_set_bit(i, new, ARRAY_SIZE(dec_param->dpb)) {
338 		const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
339 		struct v4l2_h264_dpb_entry *cdpb;
340 
341 		/*
342 		 * Both arrays are of the same sizes, so there is no way
343 		 * we can end up with no space in target array, unless
344 		 * something is buggy.
345 		 */
346 		j = find_first_zero_bit(used, ARRAY_SIZE(ctx->h264_dec.dpb));
347 		if (WARN_ON(j >= ARRAY_SIZE(ctx->h264_dec.dpb)))
348 			return;
349 
350 		cdpb = &ctx->h264_dec.dpb[j];
351 		*cdpb = *ndpb;
352 		set_bit(j, used);
353 	}
354 }
355 
356 dma_addr_t hantro_h264_get_ref_buf(struct hantro_ctx *ctx,
357 				   unsigned int dpb_idx)
358 {
359 	struct v4l2_h264_dpb_entry *dpb = ctx->h264_dec.dpb;
360 	dma_addr_t dma_addr = 0;
361 	s32 cur_poc = ctx->h264_dec.cur_poc;
362 	u32 flags;
363 
364 	if (dpb[dpb_idx].flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)
365 		dma_addr = hantro_get_ref(ctx, dpb[dpb_idx].reference_ts);
366 
367 	if (!dma_addr) {
368 		struct vb2_v4l2_buffer *dst_buf;
369 		struct vb2_buffer *buf;
370 
371 		/*
372 		 * If a DPB entry is unused or invalid, address of current
373 		 * destination buffer is returned.
374 		 */
375 		dst_buf = hantro_get_dst_buf(ctx);
376 		buf = &dst_buf->vb2_buf;
377 		dma_addr = hantro_get_dec_buf_addr(ctx, buf);
378 	}
379 
380 	flags = dpb[dpb_idx].flags & V4L2_H264_DPB_ENTRY_FLAG_FIELD ? 0x2 : 0;
381 	flags |= abs(dpb[dpb_idx].top_field_order_cnt - cur_poc) <
382 		 abs(dpb[dpb_idx].bottom_field_order_cnt - cur_poc) ?
383 		 0x1 : 0;
384 
385 	return dma_addr | flags;
386 }
387 
388 u16 hantro_h264_get_ref_nbr(struct hantro_ctx *ctx, unsigned int dpb_idx)
389 {
390 	const struct v4l2_h264_dpb_entry *dpb = &ctx->h264_dec.dpb[dpb_idx];
391 
392 	if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE))
393 		return 0;
394 	return dpb->frame_num;
395 }
396 
397 /*
398  * Removes all references with the same parity as the current picture from the
399  * reference list. The remaining list will have references with the opposite
400  * parity. This is effectively a deduplication of references since each buffer
401  * stores two fields. For this reason, each buffer is found twice in the
402  * reference list.
403  *
404  * This technique has been chosen through trial and error. This simple approach
405  * resulted in the highest conformance score. Note that this method may suffer
406  * worse quality in the case an opposite reference frame has been lost. If this
407  * becomes a problem in the future, it should be possible to add a preprocessing
408  * to identify un-paired fields and avoid removing them.
409  */
410 static void deduplicate_reflist(struct v4l2_h264_reflist_builder *b,
411 				struct v4l2_h264_reference *reflist)
412 {
413 	int write_idx = 0;
414 	int i;
415 
416 	if (b->cur_pic_fields == V4L2_H264_FRAME_REF) {
417 		write_idx = b->num_valid;
418 		goto done;
419 	}
420 
421 	for (i = 0; i < b->num_valid; i++) {
422 		if (!(b->cur_pic_fields == reflist[i].fields)) {
423 			reflist[write_idx++] = reflist[i];
424 			continue;
425 		}
426 	}
427 
428 done:
429 	/* Should not happen unless we have a bug in the reflist builder. */
430 	if (WARN_ON(write_idx > 16))
431 		write_idx = 16;
432 
433 	/* Clear the remaining, some streams fails otherwise */
434 	for (; write_idx < 16; write_idx++)
435 		reflist[write_idx].index = 15;
436 }
437 
438 int hantro_h264_dec_prepare_run(struct hantro_ctx *ctx)
439 {
440 	struct hantro_h264_dec_hw_ctx *h264_ctx = &ctx->h264_dec;
441 	struct hantro_h264_dec_ctrls *ctrls = &h264_ctx->ctrls;
442 	struct v4l2_h264_reflist_builder reflist_builder;
443 
444 	hantro_start_prepare_run(ctx);
445 
446 	ctrls->scaling =
447 		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);
448 	if (WARN_ON(!ctrls->scaling))
449 		return -EINVAL;
450 
451 	ctrls->decode =
452 		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
453 	if (WARN_ON(!ctrls->decode))
454 		return -EINVAL;
455 
456 	ctrls->sps =
457 		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_SPS);
458 	if (WARN_ON(!ctrls->sps))
459 		return -EINVAL;
460 
461 	ctrls->pps =
462 		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_PPS);
463 	if (WARN_ON(!ctrls->pps))
464 		return -EINVAL;
465 
466 	/* Update the DPB with new refs. */
467 	update_dpb(ctx);
468 
469 	/* Build the P/B{0,1} ref lists. */
470 	v4l2_h264_init_reflist_builder(&reflist_builder, ctrls->decode,
471 				       ctrls->sps, ctx->h264_dec.dpb);
472 	h264_ctx->cur_poc = reflist_builder.cur_pic_order_count;
473 
474 	/* Prepare data in memory. */
475 	prepare_table(ctx);
476 
477 	v4l2_h264_build_p_ref_list(&reflist_builder, h264_ctx->reflists.p);
478 	v4l2_h264_build_b_ref_lists(&reflist_builder, h264_ctx->reflists.b0,
479 				    h264_ctx->reflists.b1);
480 
481 	/*
482 	 * Reduce ref lists to at most 16 entries, Hantro hardware will deduce
483 	 * the actual picture lists in field through the dpb_valid,
484 	 * dpb_longterm bitmap along with the current frame parity.
485 	 */
486 	if (reflist_builder.cur_pic_fields != V4L2_H264_FRAME_REF) {
487 		deduplicate_reflist(&reflist_builder, h264_ctx->reflists.p);
488 		deduplicate_reflist(&reflist_builder, h264_ctx->reflists.b0);
489 		deduplicate_reflist(&reflist_builder, h264_ctx->reflists.b1);
490 	}
491 
492 	return 0;
493 }
494 
495 void hantro_h264_dec_exit(struct hantro_ctx *ctx)
496 {
497 	struct hantro_dev *vpu = ctx->dev;
498 	struct hantro_h264_dec_hw_ctx *h264_dec = &ctx->h264_dec;
499 	struct hantro_aux_buf *priv = &h264_dec->priv;
500 
501 	dma_free_coherent(vpu->dev, priv->size, priv->cpu, priv->dma);
502 }
503 
504 int hantro_h264_dec_init(struct hantro_ctx *ctx)
505 {
506 	struct hantro_dev *vpu = ctx->dev;
507 	struct hantro_h264_dec_hw_ctx *h264_dec = &ctx->h264_dec;
508 	struct hantro_aux_buf *priv = &h264_dec->priv;
509 	struct hantro_h264_dec_priv_tbl *tbl;
510 
511 	priv->cpu = dma_alloc_coherent(vpu->dev, sizeof(*tbl), &priv->dma,
512 				       GFP_KERNEL);
513 	if (!priv->cpu)
514 		return -ENOMEM;
515 
516 	priv->size = sizeof(*tbl);
517 	tbl = priv->cpu;
518 	memcpy(tbl->cabac_table, h264_cabac_table, sizeof(tbl->cabac_table));
519 
520 	return 0;
521 }
522