]>
Commit | Line | Data |
---|---|---|
1802d0be | 1 | // SPDX-License-Identifier: GPL-2.0-only |
866b8695 GKH |
2 | /* |
3 | * Copyright (C) 2005-2006 Micronas USA Inc. | |
866b8695 GKH |
4 | */ |
5 | ||
6 | /* | |
7 | * This file contains code to generate a firmware image for the GO7007SB | |
8 | * encoder. Much of the firmware is read verbatim from a file, but some of | |
9 | * it concerning bitrate control and other things that can be configured at | |
10 | * run-time are generated dynamically. Note that the format headers | |
11 | * generated here do not affect the functioning of the encoder; they are | |
12 | * merely parroted back to the host at the start of each frame. | |
13 | */ | |
14 | ||
15 | #include <linux/module.h> | |
866b8695 GKH |
16 | #include <linux/time.h> |
17 | #include <linux/mm.h> | |
18 | #include <linux/device.h> | |
19 | #include <linux/i2c.h> | |
20 | #include <linux/firmware.h> | |
5a0e3ad6 | 21 | #include <linux/slab.h> |
866b8695 GKH |
22 | #include <asm/byteorder.h> |
23 | ||
24 | #include "go7007-priv.h" | |
25 | ||
0a6ecbb4 HV |
26 | #define GO7007_FW_NAME "go7007/go7007tv.bin" |
27 | ||
866b8695 GKH |
28 | /* Constants used in the source firmware image to describe code segments */ |
29 | ||
30 | #define FLAG_MODE_MJPEG (1) | |
31 | #define FLAG_MODE_MPEG1 (1<<1) | |
32 | #define FLAG_MODE_MPEG2 (1<<2) | |
33 | #define FLAG_MODE_MPEG4 (1<<3) | |
34 | #define FLAG_MODE_H263 (1<<4) | |
35 | #define FLAG_MODE_ALL (FLAG_MODE_MJPEG | FLAG_MODE_MPEG1 | \ | |
36 | FLAG_MODE_MPEG2 | FLAG_MODE_MPEG4 | \ | |
37 | FLAG_MODE_H263) | |
38 | #define FLAG_SPECIAL (1<<8) | |
39 | ||
40 | #define SPECIAL_FRM_HEAD 0 | |
41 | #define SPECIAL_BRC_CTRL 1 | |
42 | #define SPECIAL_CONFIG 2 | |
43 | #define SPECIAL_SEQHEAD 3 | |
44 | #define SPECIAL_AV_SYNC 4 | |
45 | #define SPECIAL_FINAL 5 | |
46 | #define SPECIAL_AUDIO 6 | |
47 | #define SPECIAL_MODET 7 | |
48 | ||
49 | /* Little data class for creating MPEG headers bit-by-bit */ | |
50 | ||
51 | struct code_gen { | |
52 | unsigned char *p; /* destination */ | |
53 | u32 a; /* collects bits at the top of the variable */ | |
54 | int b; /* bit position of most recently-written bit */ | |
55 | int len; /* written out so far */ | |
56 | }; | |
57 | ||
58 | #define CODE_GEN(name, dest) struct code_gen name = { dest, 0, 32, 0 } | |
59 | ||
60 | #define CODE_ADD(name, val, length) do { \ | |
61 | name.b -= (length); \ | |
62 | name.a |= (val) << name.b; \ | |
63 | while (name.b <= 24) { \ | |
64 | *name.p = name.a >> 24; \ | |
65 | ++name.p; \ | |
66 | name.a <<= 8; \ | |
67 | name.b += 8; \ | |
68 | name.len += 8; \ | |
69 | } \ | |
70 | } while (0) | |
71 | ||
72 | #define CODE_LENGTH(name) (name.len + (32 - name.b)) | |
73 | ||
74 | /* Tables for creating the bitrate control data */ | |
75 | ||
76 | static const s16 converge_speed_ip[101] = { | |
77 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
78 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
79 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
80 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, | |
81 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, | |
82 | 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, | |
83 | 5, 5, 5, 6, 6, 6, 7, 7, 8, 8, | |
84 | 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, | |
85 | 19, 20, 22, 23, 25, 27, 30, 32, 35, 38, | |
86 | 41, 45, 49, 53, 58, 63, 69, 76, 83, 91, | |
87 | 100 | |
88 | }; | |
89 | ||
90 | static const s16 converge_speed_ipb[101] = { | |
91 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | |
92 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | |
93 | 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, | |
94 | 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, | |
95 | 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, | |
96 | 9, 9, 10, 10, 11, 12, 12, 13, 14, 14, | |
97 | 15, 16, 17, 18, 19, 20, 22, 23, 25, 26, | |
98 | 28, 30, 32, 34, 37, 40, 42, 46, 49, 53, | |
99 | 57, 61, 66, 71, 77, 83, 90, 97, 106, 115, | |
100 | 125, 135, 147, 161, 175, 191, 209, 228, 249, 273, | |
101 | 300 | |
102 | }; | |
103 | ||
104 | static const s16 LAMBDA_table[4][101] = { | |
105 | { 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, | |
106 | 19, 19, 19, 20, 20, 20, 21, 21, 22, 22, | |
107 | 22, 23, 23, 24, 24, 25, 25, 25, 26, 26, | |
108 | 27, 27, 28, 28, 29, 29, 30, 31, 31, 32, | |
109 | 32, 33, 33, 34, 35, 35, 36, 37, 37, 38, | |
110 | 39, 39, 40, 41, 42, 42, 43, 44, 45, 46, | |
111 | 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, | |
112 | 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, | |
113 | 67, 68, 69, 70, 72, 73, 74, 76, 77, 78, | |
114 | 80, 81, 83, 84, 86, 87, 89, 90, 92, 94, | |
115 | 96 | |
116 | }, | |
117 | { | |
118 | 20, 20, 20, 21, 21, 21, 22, 22, 23, 23, | |
119 | 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, | |
120 | 28, 29, 29, 30, 30, 31, 31, 32, 33, 33, | |
121 | 34, 34, 35, 36, 36, 37, 38, 38, 39, 40, | |
122 | 40, 41, 42, 43, 43, 44, 45, 46, 47, 48, | |
123 | 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, | |
124 | 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, | |
125 | 70, 71, 72, 73, 75, 76, 78, 79, 80, 82, | |
126 | 83, 85, 86, 88, 90, 91, 93, 95, 96, 98, | |
127 | 100, 102, 103, 105, 107, 109, 111, 113, 115, 117, | |
128 | 120 | |
129 | }, | |
130 | { | |
131 | 24, 24, 24, 25, 25, 26, 26, 27, 27, 28, | |
132 | 28, 29, 29, 30, 30, 31, 31, 32, 33, 33, | |
133 | 34, 34, 35, 36, 36, 37, 38, 38, 39, 40, | |
134 | 41, 41, 42, 43, 44, 44, 45, 46, 47, 48, | |
135 | 49, 50, 50, 51, 52, 53, 54, 55, 56, 57, | |
136 | 58, 59, 60, 62, 63, 64, 65, 66, 67, 69, | |
137 | 70, 71, 72, 74, 75, 76, 78, 79, 81, 82, | |
138 | 84, 85, 87, 88, 90, 92, 93, 95, 97, 98, | |
139 | 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, | |
140 | 120, 122, 124, 127, 129, 131, 134, 136, 138, 141, | |
141 | 144 | |
142 | }, | |
143 | { | |
144 | 32, 32, 33, 33, 34, 34, 35, 36, 36, 37, | |
145 | 38, 38, 39, 40, 41, 41, 42, 43, 44, 44, | |
146 | 45, 46, 47, 48, 49, 50, 50, 51, 52, 53, | |
147 | 54, 55, 56, 57, 58, 59, 60, 62, 63, 64, | |
148 | 65, 66, 67, 69, 70, 71, 72, 74, 75, 76, | |
149 | 78, 79, 81, 82, 84, 85, 87, 88, 90, 92, | |
150 | 93, 95, 97, 98, 100, 102, 104, 106, 108, 110, | |
151 | 112, 114, 116, 118, 120, 122, 124, 127, 129, 131, | |
152 | 134, 136, 139, 141, 144, 146, 149, 152, 154, 157, | |
153 | 160, 163, 166, 169, 172, 175, 178, 181, 185, 188, | |
154 | 192 | |
155 | } | |
156 | }; | |
157 | ||
158 | /* MPEG blank frame generation tables */ | |
159 | ||
160 | enum mpeg_frame_type { | |
161 | PFRAME, | |
162 | BFRAME_PRE, | |
163 | BFRAME_POST, | |
164 | BFRAME_BIDIR, | |
165 | BFRAME_EMPTY | |
166 | }; | |
167 | ||
168 | static const u32 addrinctab[33][2] = { | |
169 | { 0x01, 1 }, { 0x03, 3 }, { 0x02, 3 }, { 0x03, 4 }, | |
170 | { 0x02, 4 }, { 0x03, 5 }, { 0x02, 5 }, { 0x07, 7 }, | |
171 | { 0x06, 7 }, { 0x0b, 8 }, { 0x0a, 8 }, { 0x09, 8 }, | |
172 | { 0x08, 8 }, { 0x07, 8 }, { 0x06, 8 }, { 0x17, 10 }, | |
173 | { 0x16, 10 }, { 0x15, 10 }, { 0x14, 10 }, { 0x13, 10 }, | |
174 | { 0x12, 10 }, { 0x23, 11 }, { 0x22, 11 }, { 0x21, 11 }, | |
175 | { 0x20, 11 }, { 0x1f, 11 }, { 0x1e, 11 }, { 0x1d, 11 }, | |
176 | { 0x1c, 11 }, { 0x1b, 11 }, { 0x1a, 11 }, { 0x19, 11 }, | |
177 | { 0x18, 11 } | |
178 | }; | |
179 | ||
180 | /* Standard JPEG tables */ | |
181 | ||
182 | static const u8 default_intra_quant_table[] = { | |
183 | 8, 16, 19, 22, 26, 27, 29, 34, | |
184 | 16, 16, 22, 24, 27, 29, 34, 37, | |
185 | 19, 22, 26, 27, 29, 34, 34, 38, | |
186 | 22, 22, 26, 27, 29, 34, 37, 40, | |
187 | 22, 26, 27, 29, 32, 35, 40, 48, | |
188 | 26, 27, 29, 32, 35, 40, 48, 58, | |
189 | 26, 27, 29, 34, 38, 46, 56, 69, | |
190 | 27, 29, 35, 38, 46, 56, 69, 83 | |
191 | }; | |
192 | ||
193 | static const u8 bits_dc_luminance[] = { | |
194 | 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 | |
195 | }; | |
196 | ||
197 | static const u8 val_dc_luminance[] = { | |
198 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 | |
199 | }; | |
200 | ||
201 | static const u8 bits_dc_chrominance[] = { | |
202 | 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 | |
203 | }; | |
204 | ||
205 | static const u8 val_dc_chrominance[] = { | |
206 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 | |
207 | }; | |
208 | ||
209 | static const u8 bits_ac_luminance[] = { | |
210 | 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d | |
211 | }; | |
212 | ||
213 | static const u8 val_ac_luminance[] = { | |
214 | 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, | |
215 | 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, | |
216 | 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, | |
217 | 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, | |
218 | 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, | |
219 | 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, | |
220 | 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, | |
221 | 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, | |
222 | 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, | |
223 | 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, | |
224 | 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, | |
225 | 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, | |
226 | 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, | |
227 | 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, | |
228 | 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, | |
229 | 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, | |
230 | 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, | |
231 | 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, | |
232 | 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, | |
233 | 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, | |
234 | 0xf9, 0xfa | |
235 | }; | |
236 | ||
237 | static const u8 bits_ac_chrominance[] = { | |
238 | 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 | |
239 | }; | |
240 | ||
241 | static const u8 val_ac_chrominance[] = { | |
242 | 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, | |
243 | 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, | |
244 | 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, | |
245 | 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, | |
246 | 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, | |
247 | 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, | |
248 | 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, | |
249 | 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, | |
250 | 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, | |
251 | 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, | |
252 | 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, | |
253 | 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, | |
254 | 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, | |
255 | 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, | |
256 | 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, | |
257 | 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, | |
258 | 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, | |
259 | 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, | |
260 | 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, | |
261 | 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, | |
262 | 0xf9, 0xfa | |
263 | }; | |
264 | ||
265 | /* Zig-zag mapping for quant table | |
266 | * | |
267 | * OK, let's do this mapping on the actual table above so it doesn't have | |
268 | * to be done on the fly. | |
269 | */ | |
270 | static const int zz[64] = { | |
271 | 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, | |
272 | 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, | |
273 | 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, | |
274 | 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63 | |
275 | }; | |
276 | ||
9febd042 | 277 | static int copy_packages(__le16 *dest, u16 *src, int pkg_cnt, int space) |
866b8695 GKH |
278 | { |
279 | int i, cnt = pkg_cnt * 32; | |
280 | ||
281 | if (space < cnt) | |
282 | return -1; | |
283 | ||
284 | for (i = 0; i < cnt; ++i) | |
9febd042 | 285 | dest[i] = cpu_to_le16p(src + i); |
866b8695 GKH |
286 | |
287 | return cnt; | |
288 | } | |
289 | ||
290 | static int mjpeg_frame_header(struct go7007 *go, unsigned char *buf, int q) | |
291 | { | |
292 | int i, p = 0; | |
293 | ||
294 | buf[p++] = 0xff; | |
295 | buf[p++] = 0xd8; | |
296 | buf[p++] = 0xff; | |
297 | buf[p++] = 0xdb; | |
298 | buf[p++] = 0; | |
299 | buf[p++] = 2 + 65; | |
300 | buf[p++] = 0; | |
301 | buf[p++] = default_intra_quant_table[0]; | |
302 | for (i = 1; i < 64; ++i) | |
303 | /* buf[p++] = (default_intra_quant_table[i] * q) >> 3; */ | |
304 | buf[p++] = (default_intra_quant_table[zz[i]] * q) >> 3; | |
305 | buf[p++] = 0xff; | |
306 | buf[p++] = 0xc0; | |
307 | buf[p++] = 0; | |
308 | buf[p++] = 17; | |
309 | buf[p++] = 8; | |
310 | buf[p++] = go->height >> 8; | |
311 | buf[p++] = go->height & 0xff; | |
312 | buf[p++] = go->width >> 8; | |
313 | buf[p++] = go->width & 0xff; | |
314 | buf[p++] = 3; | |
315 | buf[p++] = 1; | |
316 | buf[p++] = 0x22; | |
317 | buf[p++] = 0; | |
318 | buf[p++] = 2; | |
319 | buf[p++] = 0x11; | |
320 | buf[p++] = 0; | |
321 | buf[p++] = 3; | |
322 | buf[p++] = 0x11; | |
323 | buf[p++] = 0; | |
324 | buf[p++] = 0xff; | |
325 | buf[p++] = 0xc4; | |
326 | buf[p++] = 418 >> 8; | |
327 | buf[p++] = 418 & 0xff; | |
328 | buf[p++] = 0x00; | |
329 | memcpy(buf + p, bits_dc_luminance + 1, 16); | |
330 | p += 16; | |
331 | memcpy(buf + p, val_dc_luminance, sizeof(val_dc_luminance)); | |
332 | p += sizeof(val_dc_luminance); | |
333 | buf[p++] = 0x01; | |
334 | memcpy(buf + p, bits_dc_chrominance + 1, 16); | |
335 | p += 16; | |
336 | memcpy(buf + p, val_dc_chrominance, sizeof(val_dc_chrominance)); | |
337 | p += sizeof(val_dc_chrominance); | |
338 | buf[p++] = 0x10; | |
339 | memcpy(buf + p, bits_ac_luminance + 1, 16); | |
340 | p += 16; | |
341 | memcpy(buf + p, val_ac_luminance, sizeof(val_ac_luminance)); | |
342 | p += sizeof(val_ac_luminance); | |
343 | buf[p++] = 0x11; | |
344 | memcpy(buf + p, bits_ac_chrominance + 1, 16); | |
345 | p += 16; | |
346 | memcpy(buf + p, val_ac_chrominance, sizeof(val_ac_chrominance)); | |
347 | p += sizeof(val_ac_chrominance); | |
348 | buf[p++] = 0xff; | |
349 | buf[p++] = 0xda; | |
350 | buf[p++] = 0; | |
351 | buf[p++] = 12; | |
352 | buf[p++] = 3; | |
353 | buf[p++] = 1; | |
354 | buf[p++] = 0x00; | |
355 | buf[p++] = 2; | |
356 | buf[p++] = 0x11; | |
357 | buf[p++] = 3; | |
358 | buf[p++] = 0x11; | |
359 | buf[p++] = 0; | |
360 | buf[p++] = 63; | |
361 | buf[p++] = 0; | |
362 | return p; | |
363 | } | |
364 | ||
9febd042 | 365 | static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *code, int space) |
866b8695 GKH |
366 | { |
367 | u8 *buf; | |
368 | u16 mem = 0x3e00; | |
369 | unsigned int addr = 0x19; | |
370 | int size = 0, i, off = 0, chunk; | |
371 | ||
7a6cb0d5 | 372 | buf = kzalloc(4096, GFP_KERNEL); |
535ec049 | 373 | if (buf == NULL) |
5bcc0dd7 | 374 | return -ENOMEM; |
866b8695 GKH |
375 | |
376 | for (i = 1; i < 32; ++i) { | |
377 | mjpeg_frame_header(go, buf + size, i); | |
378 | size += 80; | |
379 | } | |
380 | chunk = mjpeg_frame_header(go, buf + size, 1); | |
381 | memmove(buf + size, buf + size + 80, chunk - 80); | |
382 | size += chunk - 80; | |
383 | ||
384 | for (i = 0; i < size; i += chunk * 2) { | |
385 | if (space - off < 32) { | |
386 | off = -1; | |
387 | goto done; | |
388 | } | |
389 | ||
390 | code[off + 1] = __cpu_to_le16(0x8000 | mem); | |
391 | ||
392 | chunk = 28; | |
393 | if (mem + chunk > 0x4000) | |
394 | chunk = 0x4000 - mem; | |
395 | if (i + 2 * chunk > size) | |
396 | chunk = (size - i) / 2; | |
397 | ||
398 | if (chunk < 28) { | |
399 | code[off] = __cpu_to_le16(0x4000 | chunk); | |
400 | code[off + 31] = __cpu_to_le16(addr++); | |
401 | mem = 0x3e00; | |
402 | } else { | |
403 | code[off] = __cpu_to_le16(0x1000 | 28); | |
404 | code[off + 31] = 0; | |
405 | mem += 28; | |
406 | } | |
407 | ||
408 | memcpy(&code[off + 2], buf + i, chunk * 2); | |
409 | off += 32; | |
410 | } | |
411 | done: | |
412 | kfree(buf); | |
413 | return off; | |
414 | } | |
415 | ||
416 | static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf, | |
417 | int modulo, int pict_struct, enum mpeg_frame_type frame) | |
418 | { | |
419 | int i, j, mb_code, mb_len; | |
420 | int rows = go->interlace_coding ? go->height / 32 : go->height / 16; | |
421 | CODE_GEN(c, buf + 6); | |
422 | ||
423 | switch (frame) { | |
424 | case PFRAME: | |
425 | mb_code = 0x1; | |
426 | mb_len = 3; | |
427 | break; | |
428 | case BFRAME_PRE: | |
429 | mb_code = 0x2; | |
430 | mb_len = 4; | |
431 | break; | |
432 | case BFRAME_POST: | |
433 | mb_code = 0x2; | |
434 | mb_len = 3; | |
435 | break; | |
436 | case BFRAME_BIDIR: | |
437 | mb_code = 0x2; | |
438 | mb_len = 2; | |
439 | break; | |
440 | default: /* keep the compiler happy */ | |
441 | mb_code = mb_len = 0; | |
442 | break; | |
443 | } | |
444 | ||
445 | CODE_ADD(c, frame == PFRAME ? 0x2 : 0x3, 13); | |
446 | CODE_ADD(c, 0xffff, 16); | |
35d2d76d | 447 | CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 0x7 : 0x4, 4); |
866b8695 | 448 | if (frame != PFRAME) |
35d2d76d | 449 | CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 0x7 : 0x4, 4); |
866b8695 GKH |
450 | else |
451 | CODE_ADD(c, 0, 4); /* Is this supposed to be here?? */ | |
452 | CODE_ADD(c, 0, 3); /* What is this?? */ | |
453 | /* Byte-align with zeros */ | |
454 | j = 8 - (CODE_LENGTH(c) % 8); | |
455 | if (j != 8) | |
456 | CODE_ADD(c, 0, j); | |
457 | ||
35d2d76d | 458 | if (go->format == V4L2_PIX_FMT_MPEG2) { |
866b8695 GKH |
459 | CODE_ADD(c, 0x1, 24); |
460 | CODE_ADD(c, 0xb5, 8); | |
461 | CODE_ADD(c, 0x844, 12); | |
462 | CODE_ADD(c, frame == PFRAME ? 0xff : 0x44, 8); | |
463 | if (go->interlace_coding) { | |
464 | CODE_ADD(c, pict_struct, 4); | |
465 | if (go->dvd_mode) | |
466 | CODE_ADD(c, 0x000, 11); | |
467 | else | |
468 | CODE_ADD(c, 0x200, 11); | |
469 | } else { | |
470 | CODE_ADD(c, 0x3, 4); | |
471 | CODE_ADD(c, 0x20c, 11); | |
472 | } | |
473 | /* Byte-align with zeros */ | |
474 | j = 8 - (CODE_LENGTH(c) % 8); | |
475 | if (j != 8) | |
476 | CODE_ADD(c, 0, j); | |
477 | } | |
478 | ||
479 | for (i = 0; i < rows; ++i) { | |
480 | CODE_ADD(c, 1, 24); | |
481 | CODE_ADD(c, i + 1, 8); | |
482 | CODE_ADD(c, 0x2, 6); | |
483 | CODE_ADD(c, 0x1, 1); | |
484 | CODE_ADD(c, mb_code, mb_len); | |
485 | if (go->interlace_coding) { | |
486 | CODE_ADD(c, 0x1, 2); | |
487 | CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1); | |
488 | } | |
489 | if (frame == BFRAME_BIDIR) { | |
490 | CODE_ADD(c, 0x3, 2); | |
491 | if (go->interlace_coding) | |
492 | CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1); | |
493 | } | |
494 | CODE_ADD(c, 0x3, 2); | |
495 | for (j = (go->width >> 4) - 2; j >= 33; j -= 33) | |
496 | CODE_ADD(c, 0x8, 11); | |
497 | CODE_ADD(c, addrinctab[j][0], addrinctab[j][1]); | |
498 | CODE_ADD(c, mb_code, mb_len); | |
499 | if (go->interlace_coding) { | |
500 | CODE_ADD(c, 0x1, 2); | |
501 | CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1); | |
502 | } | |
503 | if (frame == BFRAME_BIDIR) { | |
504 | CODE_ADD(c, 0x3, 2); | |
505 | if (go->interlace_coding) | |
506 | CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1); | |
507 | } | |
508 | CODE_ADD(c, 0x3, 2); | |
509 | ||
510 | /* Byte-align with zeros */ | |
511 | j = 8 - (CODE_LENGTH(c) % 8); | |
512 | if (j != 8) | |
513 | CODE_ADD(c, 0, j); | |
514 | } | |
515 | ||
516 | i = CODE_LENGTH(c) + 4 * 8; | |
517 | buf[2] = 0x00; | |
518 | buf[3] = 0x00; | |
519 | buf[4] = 0x01; | |
520 | buf[5] = 0x00; | |
521 | return i; | |
522 | } | |
523 | ||
524 | static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext) | |
525 | { | |
526 | int i, aspect_ratio, picture_rate; | |
527 | CODE_GEN(c, buf + 6); | |
528 | ||
35d2d76d | 529 | if (go->format == V4L2_PIX_FMT_MPEG1) { |
866b8695 GKH |
530 | switch (go->aspect_ratio) { |
531 | case GO7007_RATIO_4_3: | |
532 | aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2; | |
533 | break; | |
534 | case GO7007_RATIO_16_9: | |
535 | aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4; | |
536 | break; | |
537 | default: | |
538 | aspect_ratio = 1; | |
539 | break; | |
540 | } | |
541 | } else { | |
542 | switch (go->aspect_ratio) { | |
543 | case GO7007_RATIO_4_3: | |
544 | aspect_ratio = 2; | |
545 | break; | |
546 | case GO7007_RATIO_16_9: | |
547 | aspect_ratio = 3; | |
548 | break; | |
549 | default: | |
550 | aspect_ratio = 1; | |
551 | break; | |
552 | } | |
553 | } | |
554 | switch (go->sensor_framerate) { | |
555 | case 24000: | |
556 | picture_rate = 1; | |
557 | break; | |
558 | case 24024: | |
559 | picture_rate = 2; | |
560 | break; | |
561 | case 25025: | |
562 | picture_rate = go->interlace_coding ? 6 : 3; | |
563 | break; | |
564 | case 30000: | |
565 | picture_rate = go->interlace_coding ? 7 : 4; | |
566 | break; | |
567 | case 30030: | |
568 | picture_rate = go->interlace_coding ? 8 : 5; | |
569 | break; | |
570 | default: | |
571 | picture_rate = 5; /* 30 fps seems like a reasonable default */ | |
572 | break; | |
573 | } | |
574 | ||
575 | CODE_ADD(c, go->width, 12); | |
576 | CODE_ADD(c, go->height, 12); | |
577 | CODE_ADD(c, aspect_ratio, 4); | |
578 | CODE_ADD(c, picture_rate, 4); | |
35d2d76d | 579 | CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 20000 : 0x3ffff, 18); |
866b8695 | 580 | CODE_ADD(c, 1, 1); |
35d2d76d | 581 | CODE_ADD(c, go->format == V4L2_PIX_FMT_MPEG2 ? 112 : 20, 10); |
866b8695 GKH |
582 | CODE_ADD(c, 0, 3); |
583 | ||
584 | /* Byte-align with zeros */ | |
585 | i = 8 - (CODE_LENGTH(c) % 8); | |
586 | if (i != 8) | |
587 | CODE_ADD(c, 0, i); | |
588 | ||
35d2d76d | 589 | if (go->format == V4L2_PIX_FMT_MPEG2) { |
866b8695 GKH |
590 | CODE_ADD(c, 0x1, 24); |
591 | CODE_ADD(c, 0xb5, 8); | |
592 | CODE_ADD(c, 0x148, 12); | |
593 | if (go->interlace_coding) | |
594 | CODE_ADD(c, 0x20001, 20); | |
595 | else | |
596 | CODE_ADD(c, 0xa0001, 20); | |
597 | CODE_ADD(c, 0, 16); | |
598 | ||
599 | /* Byte-align with zeros */ | |
600 | i = 8 - (CODE_LENGTH(c) % 8); | |
601 | if (i != 8) | |
602 | CODE_ADD(c, 0, i); | |
603 | ||
604 | if (ext) { | |
605 | CODE_ADD(c, 0x1, 24); | |
606 | CODE_ADD(c, 0xb52, 12); | |
607 | CODE_ADD(c, go->standard == GO7007_STD_NTSC ? 2 : 1, 3); | |
608 | CODE_ADD(c, 0x105, 9); | |
609 | CODE_ADD(c, 0x505, 16); | |
610 | CODE_ADD(c, go->width, 14); | |
611 | CODE_ADD(c, 1, 1); | |
612 | CODE_ADD(c, go->height, 14); | |
613 | ||
614 | /* Byte-align with zeros */ | |
615 | i = 8 - (CODE_LENGTH(c) % 8); | |
616 | if (i != 8) | |
617 | CODE_ADD(c, 0, i); | |
618 | } | |
619 | } | |
620 | ||
621 | i = CODE_LENGTH(c) + 4 * 8; | |
622 | buf[0] = i & 0xff; | |
623 | buf[1] = i >> 8; | |
624 | buf[2] = 0x00; | |
625 | buf[3] = 0x00; | |
626 | buf[4] = 0x01; | |
627 | buf[5] = 0xb3; | |
628 | return i; | |
629 | } | |
630 | ||
631 | static int gen_mpeg1hdr_to_package(struct go7007 *go, | |
9febd042 | 632 | __le16 *code, int space, int *framelen) |
866b8695 GKH |
633 | { |
634 | u8 *buf; | |
635 | u16 mem = 0x3e00; | |
636 | unsigned int addr = 0x19; | |
637 | int i, off = 0, chunk; | |
638 | ||
7a6cb0d5 | 639 | buf = kzalloc(5120, GFP_KERNEL); |
535ec049 | 640 | if (buf == NULL) |
5bcc0dd7 | 641 | return -ENOMEM; |
535ec049 | 642 | |
866b8695 GKH |
643 | framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME); |
644 | if (go->interlace_coding) | |
645 | framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8, | |
646 | 0, 2, PFRAME); | |
647 | buf[0] = framelen[0] & 0xff; | |
648 | buf[1] = framelen[0] >> 8; | |
649 | i = 368; | |
650 | framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE); | |
651 | if (go->interlace_coding) | |
652 | framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8, | |
653 | 0, 2, BFRAME_PRE); | |
654 | buf[i] = framelen[1] & 0xff; | |
655 | buf[i + 1] = framelen[1] >> 8; | |
656 | i += 1632; | |
657 | framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST); | |
658 | if (go->interlace_coding) | |
659 | framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8, | |
660 | 0, 2, BFRAME_POST); | |
661 | buf[i] = framelen[2] & 0xff; | |
662 | buf[i + 1] = framelen[2] >> 8; | |
663 | i += 1432; | |
664 | framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR); | |
665 | if (go->interlace_coding) | |
666 | framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8, | |
667 | 0, 2, BFRAME_BIDIR); | |
668 | buf[i] = framelen[3] & 0xff; | |
669 | buf[i + 1] = framelen[3] >> 8; | |
670 | i += 1632 + 16; | |
671 | mpeg1_sequence_header(go, buf + i, 0); | |
672 | i += 40; | |
673 | for (i = 0; i < 5120; i += chunk * 2) { | |
674 | if (space - off < 32) { | |
675 | off = -1; | |
676 | goto done; | |
677 | } | |
678 | ||
679 | code[off + 1] = __cpu_to_le16(0x8000 | mem); | |
680 | ||
681 | chunk = 28; | |
682 | if (mem + chunk > 0x4000) | |
683 | chunk = 0x4000 - mem; | |
684 | if (i + 2 * chunk > 5120) | |
685 | chunk = (5120 - i) / 2; | |
686 | ||
687 | if (chunk < 28) { | |
688 | code[off] = __cpu_to_le16(0x4000 | chunk); | |
689 | code[off + 31] = __cpu_to_le16(addr); | |
690 | if (mem + chunk == 0x4000) { | |
691 | mem = 0x3e00; | |
692 | ++addr; | |
693 | } | |
694 | } else { | |
695 | code[off] = __cpu_to_le16(0x1000 | 28); | |
696 | code[off + 31] = 0; | |
697 | mem += 28; | |
698 | } | |
699 | ||
700 | memcpy(&code[off + 2], buf + i, chunk * 2); | |
701 | off += 32; | |
702 | } | |
703 | done: | |
704 | kfree(buf); | |
705 | return off; | |
706 | } | |
707 | ||
708 | static int vti_bitlen(struct go7007 *go) | |
709 | { | |
710 | unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale; | |
711 | ||
5c72afd8 HS |
712 | for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i) |
713 | ; | |
866b8695 GKH |
714 | return i + 1; |
715 | } | |
716 | ||
717 | static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf, | |
718 | int modulo, enum mpeg_frame_type frame) | |
719 | { | |
720 | int i; | |
721 | CODE_GEN(c, buf + 6); | |
722 | int mb_count = (go->width >> 4) * (go->height >> 4); | |
723 | ||
724 | CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2); | |
725 | if (modulo) | |
726 | CODE_ADD(c, 0x1, 1); | |
727 | CODE_ADD(c, 0x1, 2); | |
728 | CODE_ADD(c, 0, vti_bitlen(go)); | |
729 | CODE_ADD(c, 0x3, 2); | |
730 | if (frame == PFRAME) | |
731 | CODE_ADD(c, 0, 1); | |
732 | CODE_ADD(c, 0xc, 11); | |
733 | if (frame != PFRAME) | |
734 | CODE_ADD(c, 0x4, 3); | |
735 | if (frame != BFRAME_EMPTY) { | |
736 | for (i = 0; i < mb_count; ++i) { | |
737 | switch (frame) { | |
738 | case PFRAME: | |
739 | CODE_ADD(c, 0x1, 1); | |
740 | break; | |
741 | case BFRAME_PRE: | |
742 | CODE_ADD(c, 0x47, 8); | |
743 | break; | |
744 | case BFRAME_POST: | |
745 | CODE_ADD(c, 0x27, 7); | |
746 | break; | |
747 | case BFRAME_BIDIR: | |
748 | CODE_ADD(c, 0x5f, 8); | |
749 | break; | |
750 | case BFRAME_EMPTY: /* keep compiler quiet */ | |
751 | break; | |
752 | } | |
753 | } | |
754 | } | |
755 | ||
756 | /* Byte-align with a zero followed by ones */ | |
757 | i = 8 - (CODE_LENGTH(c) % 8); | |
758 | CODE_ADD(c, 0, 1); | |
759 | CODE_ADD(c, (1 << (i - 1)) - 1, i - 1); | |
760 | ||
761 | i = CODE_LENGTH(c) + 4 * 8; | |
762 | buf[0] = i & 0xff; | |
763 | buf[1] = i >> 8; | |
764 | buf[2] = 0x00; | |
765 | buf[3] = 0x00; | |
766 | buf[4] = 0x01; | |
767 | buf[5] = 0xb6; | |
768 | return i; | |
769 | } | |
770 | ||
771 | static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext) | |
772 | { | |
773 | const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali, | |
774 | 0x00, 0x00, 0x01, 0xb5, 0x09, | |
775 | 0x00, 0x00, 0x01, 0x00, | |
776 | 0x00, 0x00, 0x01, 0x20, }; | |
777 | int i, aspect_ratio; | |
778 | int fps = go->sensor_framerate / go->fps_scale; | |
779 | CODE_GEN(c, buf + 2 + sizeof(head)); | |
780 | ||
781 | switch (go->aspect_ratio) { | |
782 | case GO7007_RATIO_4_3: | |
783 | aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2; | |
784 | break; | |
785 | case GO7007_RATIO_16_9: | |
786 | aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4; | |
787 | break; | |
788 | default: | |
789 | aspect_ratio = 1; | |
790 | break; | |
791 | } | |
792 | ||
793 | memcpy(buf + 2, head, sizeof(head)); | |
794 | CODE_ADD(c, 0x191, 17); | |
795 | CODE_ADD(c, aspect_ratio, 4); | |
796 | CODE_ADD(c, 0x1, 4); | |
797 | CODE_ADD(c, fps, 16); | |
798 | CODE_ADD(c, 0x3, 2); | |
799 | CODE_ADD(c, 1001, vti_bitlen(go)); | |
800 | CODE_ADD(c, 1, 1); | |
801 | CODE_ADD(c, go->width, 13); | |
802 | CODE_ADD(c, 1, 1); | |
803 | CODE_ADD(c, go->height, 13); | |
804 | CODE_ADD(c, 0x2830, 14); | |
805 | ||
806 | /* Byte-align */ | |
807 | i = 8 - (CODE_LENGTH(c) % 8); | |
808 | CODE_ADD(c, 0, 1); | |
809 | CODE_ADD(c, (1 << (i - 1)) - 1, i - 1); | |
810 | ||
811 | i = CODE_LENGTH(c) + sizeof(head) * 8; | |
812 | buf[0] = i & 0xff; | |
813 | buf[1] = i >> 8; | |
814 | return i; | |
815 | } | |
816 | ||
817 | static int gen_mpeg4hdr_to_package(struct go7007 *go, | |
9febd042 | 818 | __le16 *code, int space, int *framelen) |
866b8695 GKH |
819 | { |
820 | u8 *buf; | |
821 | u16 mem = 0x3e00; | |
822 | unsigned int addr = 0x19; | |
823 | int i, off = 0, chunk; | |
824 | ||
7a6cb0d5 | 825 | buf = kzalloc(5120, GFP_KERNEL); |
535ec049 | 826 | if (buf == NULL) |
5bcc0dd7 | 827 | return -ENOMEM; |
535ec049 | 828 | |
866b8695 GKH |
829 | framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME); |
830 | i = 368; | |
831 | framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE); | |
832 | i += 1632; | |
833 | framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST); | |
834 | i += 1432; | |
835 | framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR); | |
836 | i += 1632; | |
837 | mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY); | |
838 | i += 16; | |
839 | mpeg4_sequence_header(go, buf + i, 0); | |
840 | i += 40; | |
841 | for (i = 0; i < 5120; i += chunk * 2) { | |
842 | if (space - off < 32) { | |
843 | off = -1; | |
844 | goto done; | |
845 | } | |
846 | ||
847 | code[off + 1] = __cpu_to_le16(0x8000 | mem); | |
848 | ||
849 | chunk = 28; | |
850 | if (mem + chunk > 0x4000) | |
851 | chunk = 0x4000 - mem; | |
852 | if (i + 2 * chunk > 5120) | |
853 | chunk = (5120 - i) / 2; | |
854 | ||
855 | if (chunk < 28) { | |
856 | code[off] = __cpu_to_le16(0x4000 | chunk); | |
857 | code[off + 31] = __cpu_to_le16(addr); | |
858 | if (mem + chunk == 0x4000) { | |
859 | mem = 0x3e00; | |
860 | ++addr; | |
861 | } | |
862 | } else { | |
863 | code[off] = __cpu_to_le16(0x1000 | 28); | |
864 | code[off + 31] = 0; | |
865 | mem += 28; | |
866 | } | |
867 | ||
868 | memcpy(&code[off + 2], buf + i, chunk * 2); | |
869 | off += 32; | |
870 | } | |
871 | mem = 0x3e00; | |
872 | addr = go->ipb ? 0x14f9 : 0x0af9; | |
873 | memset(buf, 0, 5120); | |
874 | framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME); | |
875 | i = 368; | |
876 | framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE); | |
877 | i += 1632; | |
878 | framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST); | |
879 | i += 1432; | |
880 | framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR); | |
881 | i += 1632; | |
882 | mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY); | |
883 | i += 16; | |
884 | for (i = 0; i < 5120; i += chunk * 2) { | |
885 | if (space - off < 32) { | |
886 | off = -1; | |
887 | goto done; | |
888 | } | |
889 | ||
890 | code[off + 1] = __cpu_to_le16(0x8000 | mem); | |
891 | ||
892 | chunk = 28; | |
893 | if (mem + chunk > 0x4000) | |
894 | chunk = 0x4000 - mem; | |
895 | if (i + 2 * chunk > 5120) | |
896 | chunk = (5120 - i) / 2; | |
897 | ||
898 | if (chunk < 28) { | |
899 | code[off] = __cpu_to_le16(0x4000 | chunk); | |
900 | code[off + 31] = __cpu_to_le16(addr); | |
901 | if (mem + chunk == 0x4000) { | |
902 | mem = 0x3e00; | |
903 | ++addr; | |
904 | } | |
905 | } else { | |
906 | code[off] = __cpu_to_le16(0x1000 | 28); | |
907 | code[off + 31] = 0; | |
908 | mem += 28; | |
909 | } | |
910 | ||
911 | memcpy(&code[off + 2], buf + i, chunk * 2); | |
912 | off += 32; | |
913 | } | |
914 | done: | |
915 | kfree(buf); | |
916 | return off; | |
917 | } | |
918 | ||
919 | static int brctrl_to_package(struct go7007 *go, | |
9febd042 | 920 | __le16 *code, int space, int *framelen) |
866b8695 GKH |
921 | { |
922 | int converge_speed = 0; | |
35d2d76d | 923 | int lambda = (go->format == V4L2_PIX_FMT_MJPEG || go->dvd_mode) ? |
866b8695 GKH |
924 | 100 : 0; |
925 | int peak_rate = 6 * go->bitrate / 5; | |
35d2d76d | 926 | int vbv_buffer = go->format == V4L2_PIX_FMT_MJPEG ? |
866b8695 GKH |
927 | go->bitrate : |
928 | (go->dvd_mode ? 900000 : peak_rate); | |
929 | int fps = go->sensor_framerate / go->fps_scale; | |
930 | int q = 0; | |
931 | /* Bizarre math below depends on rounding errors in division */ | |
932 | u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps; | |
933 | u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps; | |
934 | u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000); | |
935 | u32 vbv_alert_addr = vbv_buffer * 3 / (4 * 32); | |
936 | u32 cplx[] = { | |
937 | q > 0 ? sgop_expt_addr * q : | |
938 | 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32, | |
939 | q > 0 ? sgop_expt_addr * q : | |
940 | 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32, | |
941 | q > 0 ? sgop_expt_addr * q : | |
942 | 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32, | |
943 | q > 0 ? sgop_expt_addr * q : | |
944 | 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32, | |
945 | }; | |
946 | u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr; | |
947 | u16 pack[] = { | |
948 | 0x200e, 0x0000, | |
949 | 0xBF20, go->ipb ? converge_speed_ipb[converge_speed] | |
950 | : converge_speed_ip[converge_speed], | |
951 | 0xBF21, go->ipb ? 2 : 0, | |
952 | 0xBF22, go->ipb ? LAMBDA_table[0][lambda / 2 + 50] | |
953 | : 32767, | |
954 | 0xBF23, go->ipb ? LAMBDA_table[1][lambda] : 32767, | |
955 | 0xBF24, 32767, | |
956 | 0xBF25, lambda > 99 ? 32767 : LAMBDA_table[3][lambda], | |
957 | 0xBF26, sgop_expt_addr & 0x0000FFFF, | |
958 | 0xBF27, sgop_expt_addr >> 16, | |
959 | 0xBF28, sgop_peak_addr & 0x0000FFFF, | |
960 | 0xBF29, sgop_peak_addr >> 16, | |
961 | 0xBF2A, vbv_alert_addr & 0x0000FFFF, | |
962 | 0xBF2B, vbv_alert_addr >> 16, | |
963 | 0xBF2C, 0, | |
964 | 0xBF2D, 0, | |
965 | 0, 0, | |
966 | ||
967 | 0x200e, 0x0000, | |
968 | 0xBF2E, vbv_alert_addr & 0x0000FFFF, | |
969 | 0xBF2F, vbv_alert_addr >> 16, | |
970 | 0xBF30, cplx[0] & 0x0000FFFF, | |
971 | 0xBF31, cplx[0] >> 16, | |
972 | 0xBF32, cplx[1] & 0x0000FFFF, | |
973 | 0xBF33, cplx[1] >> 16, | |
974 | 0xBF34, cplx[2] & 0x0000FFFF, | |
975 | 0xBF35, cplx[2] >> 16, | |
976 | 0xBF36, cplx[3] & 0x0000FFFF, | |
977 | 0xBF37, cplx[3] >> 16, | |
978 | 0xBF38, 0, | |
979 | 0xBF39, 0, | |
980 | 0xBF3A, total_expt_addr & 0x0000FFFF, | |
981 | 0xBF3B, total_expt_addr >> 16, | |
982 | 0, 0, | |
983 | ||
984 | 0x200e, 0x0000, | |
985 | 0xBF3C, total_expt_addr & 0x0000FFFF, | |
986 | 0xBF3D, total_expt_addr >> 16, | |
987 | 0xBF3E, 0, | |
988 | 0xBF3F, 0, | |
989 | 0xBF48, 0, | |
990 | 0xBF49, 0, | |
991 | 0xBF4A, calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q), | |
992 | 0xBF4B, 4, | |
993 | 0xBF4C, 0, | |
994 | 0xBF4D, 0, | |
995 | 0xBF4E, 0, | |
996 | 0xBF4F, 0, | |
997 | 0xBF50, 0, | |
998 | 0xBF51, 0, | |
999 | 0, 0, | |
1000 | ||
1001 | 0x200e, 0x0000, | |
1002 | 0xBF40, sgop_expt_addr & 0x0000FFFF, | |
1003 | 0xBF41, sgop_expt_addr >> 16, | |
1004 | 0xBF42, 0, | |
1005 | 0xBF43, 0, | |
1006 | 0xBF44, 0, | |
1007 | 0xBF45, 0, | |
1008 | 0xBF46, (go->width >> 4) * (go->height >> 4), | |
1009 | 0xBF47, 0, | |
1010 | 0xBF64, 0, | |
1011 | 0xBF65, 0, | |
1012 | 0xBF18, framelen[4], | |
1013 | 0xBF19, framelen[5], | |
1014 | 0xBF1A, framelen[6], | |
1015 | 0xBF1B, framelen[7], | |
1016 | 0, 0, | |
1017 | ||
028d4c98 MCC |
1018 | #if 0 |
1019 | /* Remove once we don't care about matching */ | |
866b8695 GKH |
1020 | 0x200e, 0x0000, |
1021 | 0xBF56, 4, | |
1022 | 0xBF57, 0, | |
1023 | 0xBF58, 5, | |
1024 | 0xBF59, 0, | |
1025 | 0xBF5A, 6, | |
1026 | 0xBF5B, 0, | |
1027 | 0xBF5C, 8, | |
1028 | 0xBF5D, 0, | |
1029 | 0xBF5E, 1, | |
1030 | 0xBF5F, 0, | |
1031 | 0xBF60, 1, | |
1032 | 0xBF61, 0, | |
1033 | 0xBF62, 0, | |
1034 | 0xBF63, 0, | |
1035 | 0, 0, | |
1036 | #else | |
1037 | 0x2008, 0x0000, | |
1038 | 0xBF56, 4, | |
1039 | 0xBF57, 0, | |
1040 | 0xBF58, 5, | |
1041 | 0xBF59, 0, | |
1042 | 0xBF5A, 6, | |
1043 | 0xBF5B, 0, | |
1044 | 0xBF5C, 8, | |
1045 | 0xBF5D, 0, | |
1046 | 0, 0, | |
1047 | 0, 0, | |
1048 | 0, 0, | |
1049 | 0, 0, | |
1050 | 0, 0, | |
1051 | 0, 0, | |
1052 | 0, 0, | |
1053 | #endif | |
1054 | ||
1055 | 0x200e, 0x0000, | |
1056 | 0xBF10, 0, | |
1057 | 0xBF11, 0, | |
1058 | 0xBF12, 0, | |
1059 | 0xBF13, 0, | |
1060 | 0xBF14, 0, | |
1061 | 0xBF15, 0, | |
1062 | 0xBF16, 0, | |
1063 | 0xBF17, 0, | |
1064 | 0xBF7E, 0, | |
1065 | 0xBF7F, 1, | |
1066 | 0xBF52, framelen[0], | |
1067 | 0xBF53, framelen[1], | |
1068 | 0xBF54, framelen[2], | |
1069 | 0xBF55, framelen[3], | |
1070 | 0, 0, | |
1071 | }; | |
1072 | ||
1073 | return copy_packages(code, pack, 6, space); | |
1074 | } | |
1075 | ||
9febd042 | 1076 | static int config_package(struct go7007 *go, __le16 *code, int space) |
866b8695 GKH |
1077 | { |
1078 | int fps = go->sensor_framerate / go->fps_scale / 1000; | |
1079 | int rows = go->interlace_coding ? go->height / 32 : go->height / 16; | |
1080 | int brc_window_size = fps; | |
1081 | int q_min = 2, q_max = 31; | |
1082 | int THACCoeffSet0 = 0; | |
1083 | u16 pack[] = { | |
1084 | 0x200e, 0x0000, | |
1085 | 0xc002, 0x14b4, | |
1086 | 0xc003, 0x28b4, | |
1087 | 0xc004, 0x3c5a, | |
1088 | 0xdc05, 0x2a77, | |
35d2d76d HV |
1089 | 0xc6c3, go->format == V4L2_PIX_FMT_MPEG4 ? 0 : |
1090 | (go->format == V4L2_PIX_FMT_H263 ? 0 : 1), | |
1091 | 0xc680, go->format == V4L2_PIX_FMT_MPEG4 ? 0xf1 : | |
1092 | (go->format == V4L2_PIX_FMT_H263 ? 0x61 : | |
866b8695 GKH |
1093 | 0xd3), |
1094 | 0xc780, 0x0140, | |
1095 | 0xe009, 0x0001, | |
1096 | 0xc60f, 0x0008, | |
1097 | 0xd4ff, 0x0002, | |
1098 | 0xe403, 2340, | |
1099 | 0xe406, 75, | |
1100 | 0xd411, 0x0001, | |
1101 | 0xd410, 0xa1d6, | |
1102 | 0x0001, 0x2801, | |
1103 | ||
1104 | 0x200d, 0x0000, | |
1105 | 0xe402, 0x018b, | |
1106 | 0xe401, 0x8b01, | |
1107 | 0xd472, (go->board_info->sensor_flags & | |
1108 | GO7007_SENSOR_TV) && | |
1109 | (!go->interlace_coding) ? | |
1110 | 0x01b0 : 0x0170, | |
1111 | 0xd475, (go->board_info->sensor_flags & | |
1112 | GO7007_SENSOR_TV) && | |
1113 | (!go->interlace_coding) ? | |
1114 | 0x0008 : 0x0009, | |
1115 | 0xc404, go->interlace_coding ? 0x44 : | |
35d2d76d HV |
1116 | (go->format == V4L2_PIX_FMT_MPEG4 ? 0x11 : |
1117 | (go->format == V4L2_PIX_FMT_MPEG1 ? 0x02 : | |
1118 | (go->format == V4L2_PIX_FMT_MPEG2 ? 0x04 : | |
1119 | (go->format == V4L2_PIX_FMT_H263 ? 0x08 : | |
866b8695 | 1120 | 0x20)))), |
35d2d76d HV |
1121 | 0xbf0a, (go->format == V4L2_PIX_FMT_MPEG4 ? 8 : |
1122 | (go->format == V4L2_PIX_FMT_MPEG1 ? 1 : | |
1123 | (go->format == V4L2_PIX_FMT_MPEG2 ? 2 : | |
1124 | (go->format == V4L2_PIX_FMT_H263 ? 4 : 16)))) | | |
866b8695 GKH |
1125 | ((go->repeat_seqhead ? 1 : 0) << 6) | |
1126 | ((go->dvd_mode ? 1 : 0) << 9) | | |
1127 | ((go->gop_header_enable ? 1 : 0) << 10), | |
1128 | 0xbf0b, 0, | |
1129 | 0xdd5a, go->ipb ? 0x14 : 0x0a, | |
1130 | 0xbf0c, 0, | |
1131 | 0xbf0d, 0, | |
1132 | 0xc683, THACCoeffSet0, | |
1133 | 0xc40a, (go->width << 4) | rows, | |
1134 | 0xe01a, go->board_info->hpi_buffer_cap, | |
1135 | 0, 0, | |
1136 | 0, 0, | |
1137 | ||
1138 | 0x2008, 0, | |
1139 | 0xe402, 0x88, | |
1140 | 0xe401, 0x8f01, | |
1141 | 0xbf6a, 0, | |
1142 | 0xbf6b, 0, | |
1143 | 0xbf6c, 0, | |
1144 | 0xbf6d, 0, | |
1145 | 0xbf6e, 0, | |
1146 | 0xbf6f, 0, | |
1147 | 0, 0, | |
1148 | 0, 0, | |
1149 | 0, 0, | |
1150 | 0, 0, | |
1151 | 0, 0, | |
1152 | 0, 0, | |
1153 | 0, 0, | |
1154 | ||
1155 | 0x200e, 0, | |
1156 | 0xbf66, brc_window_size, | |
1157 | 0xbf67, 0, | |
1158 | 0xbf68, q_min, | |
1159 | 0xbf69, q_max, | |
1160 | 0xbfe0, 0, | |
1161 | 0xbfe1, 0, | |
1162 | 0xbfe2, 0, | |
1163 | 0xbfe3, go->ipb ? 3 : 1, | |
1164 | 0xc031, go->board_info->sensor_flags & | |
1165 | GO7007_SENSOR_VBI ? 1 : 0, | |
1166 | 0xc01c, 0x1f, | |
1167 | 0xdd8c, 0x15, | |
1168 | 0xdd94, 0x15, | |
1169 | 0xdd88, go->ipb ? 0x1401 : 0x0a01, | |
1170 | 0xdd90, go->ipb ? 0x1401 : 0x0a01, | |
1171 | 0, 0, | |
1172 | ||
1173 | 0x200e, 0, | |
1174 | 0xbfe4, 0, | |
1175 | 0xbfe5, 0, | |
1176 | 0xbfe6, 0, | |
1177 | 0xbfe7, fps << 8, | |
1178 | 0xbfe8, 0x3a00, | |
1179 | 0xbfe9, 0, | |
1180 | 0xbfea, 0, | |
1181 | 0xbfeb, 0, | |
1182 | 0xbfec, (go->interlace_coding ? 1 << 15 : 0) | | |
1183 | (go->modet_enable ? 0xa : 0) | | |
1184 | (go->board_info->sensor_flags & | |
1185 | GO7007_SENSOR_VBI ? 1 : 0), | |
1186 | 0xbfed, 0, | |
1187 | 0xbfee, 0, | |
1188 | 0xbfef, 0, | |
1189 | 0xbff0, go->board_info->sensor_flags & | |
1190 | GO7007_SENSOR_TV ? 0xf060 : 0xb060, | |
1191 | 0xbff1, 0, | |
1192 | 0, 0, | |
1193 | }; | |
1194 | ||
1195 | return copy_packages(code, pack, 5, space); | |
1196 | } | |
1197 | ||
9febd042 | 1198 | static int seqhead_to_package(struct go7007 *go, __le16 *code, int space, |
866b8695 GKH |
1199 | int (*sequence_header_func)(struct go7007 *go, |
1200 | unsigned char *buf, int ext)) | |
1201 | { | |
1202 | int vop_time_increment_bitlength = vti_bitlen(go); | |
1203 | int fps = go->sensor_framerate / go->fps_scale * | |
1204 | (go->interlace_coding ? 2 : 1); | |
1205 | unsigned char buf[40] = { }; | |
1206 | int len = sequence_header_func(go, buf, 1); | |
1207 | u16 pack[] = { | |
1208 | 0x2006, 0, | |
1209 | 0xbf08, fps, | |
1210 | 0xbf09, 0, | |
1211 | 0xbff2, vop_time_increment_bitlength, | |
1212 | 0xbff3, (1 << vop_time_increment_bitlength) - 1, | |
1213 | 0xbfe6, 0, | |
1214 | 0xbfe7, (fps / 1000) << 8, | |
1215 | 0, 0, | |
1216 | 0, 0, | |
1217 | 0, 0, | |
1218 | 0, 0, | |
1219 | 0, 0, | |
1220 | 0, 0, | |
1221 | 0, 0, | |
1222 | 0, 0, | |
1223 | 0, 0, | |
1224 | ||
1225 | 0x2007, 0, | |
1226 | 0xc800, buf[2] << 8 | buf[3], | |
1227 | 0xc801, buf[4] << 8 | buf[5], | |
1228 | 0xc802, buf[6] << 8 | buf[7], | |
1229 | 0xc803, buf[8] << 8 | buf[9], | |
1230 | 0xc406, 64, | |
1231 | 0xc407, len - 64, | |
1232 | 0xc61b, 1, | |
1233 | 0, 0, | |
1234 | 0, 0, | |
1235 | 0, 0, | |
1236 | 0, 0, | |
1237 | 0, 0, | |
1238 | 0, 0, | |
1239 | 0, 0, | |
1240 | 0, 0, | |
1241 | ||
1242 | 0x200e, 0, | |
1243 | 0xc808, buf[10] << 8 | buf[11], | |
1244 | 0xc809, buf[12] << 8 | buf[13], | |
1245 | 0xc80a, buf[14] << 8 | buf[15], | |
1246 | 0xc80b, buf[16] << 8 | buf[17], | |
1247 | 0xc80c, buf[18] << 8 | buf[19], | |
1248 | 0xc80d, buf[20] << 8 | buf[21], | |
1249 | 0xc80e, buf[22] << 8 | buf[23], | |
1250 | 0xc80f, buf[24] << 8 | buf[25], | |
1251 | 0xc810, buf[26] << 8 | buf[27], | |
1252 | 0xc811, buf[28] << 8 | buf[29], | |
1253 | 0xc812, buf[30] << 8 | buf[31], | |
1254 | 0xc813, buf[32] << 8 | buf[33], | |
1255 | 0xc814, buf[34] << 8 | buf[35], | |
1256 | 0xc815, buf[36] << 8 | buf[37], | |
1257 | 0, 0, | |
1258 | 0, 0, | |
1259 | 0, 0, | |
1260 | }; | |
1261 | ||
1262 | return copy_packages(code, pack, 3, space); | |
1263 | } | |
1264 | ||
1265 | static int relative_prime(int big, int little) | |
1266 | { | |
1267 | int remainder; | |
1268 | ||
1269 | while (little != 0) { | |
1270 | remainder = big % little; | |
1271 | big = little; | |
1272 | little = remainder; | |
1273 | } | |
1274 | return big; | |
1275 | } | |
1276 | ||
9febd042 | 1277 | static int avsync_to_package(struct go7007 *go, __le16 *code, int space) |
866b8695 GKH |
1278 | { |
1279 | int arate = go->board_info->audio_rate * 1001 * go->fps_scale; | |
1280 | int ratio = arate / go->sensor_framerate; | |
1281 | int adjratio = ratio * 215 / 100; | |
1282 | int rprime = relative_prime(go->sensor_framerate, | |
1283 | arate % go->sensor_framerate); | |
1284 | int f1 = (arate % go->sensor_framerate) / rprime; | |
1285 | int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime; | |
1286 | u16 pack[] = { | |
1287 | 0x200e, 0, | |
1288 | 0xbf98, (u16)((-adjratio) & 0xffff), | |
1289 | 0xbf99, (u16)((-adjratio) >> 16), | |
1290 | 0xbf92, 0, | |
1291 | 0xbf93, 0, | |
1292 | 0xbff4, f1 > f2 ? f1 : f2, | |
1293 | 0xbff5, f1 < f2 ? f1 : f2, | |
1294 | 0xbff6, f1 < f2 ? ratio : ratio + 1, | |
1295 | 0xbff7, f1 > f2 ? ratio : ratio + 1, | |
1296 | 0xbff8, 0, | |
1297 | 0xbff9, 0, | |
1298 | 0xbffa, adjratio & 0xffff, | |
1299 | 0xbffb, adjratio >> 16, | |
1300 | 0xbf94, 0, | |
1301 | 0xbf95, 0, | |
1302 | 0, 0, | |
1303 | }; | |
1304 | ||
1305 | return copy_packages(code, pack, 1, space); | |
1306 | } | |
1307 | ||
9febd042 | 1308 | static int final_package(struct go7007 *go, __le16 *code, int space) |
866b8695 GKH |
1309 | { |
1310 | int rows = go->interlace_coding ? go->height / 32 : go->height / 16; | |
1311 | u16 pack[] = { | |
1312 | 0x8000, | |
1313 | 0, | |
1314 | 0, | |
1315 | 0, | |
1316 | 0, | |
1317 | 0, | |
1318 | 0, | |
1319 | 2, | |
1320 | ((go->board_info->sensor_flags & GO7007_SENSOR_TV) && | |
1321 | (!go->interlace_coding) ? | |
1322 | (1 << 14) | (1 << 9) : 0) | | |
1323 | ((go->encoder_subsample ? 1 : 0) << 8) | | |
1324 | (go->board_info->sensor_flags & | |
1325 | GO7007_SENSOR_CONFIG_MASK), | |
1326 | ((go->encoder_v_halve ? 1 : 0) << 14) | | |
1327 | (go->encoder_v_halve ? rows << 9 : rows << 8) | | |
1328 | (go->encoder_h_halve ? 1 << 6 : 0) | | |
1329 | (go->encoder_h_halve ? go->width >> 3 : go->width >> 4), | |
1330 | (1 << 15) | (go->encoder_v_offset << 6) | | |
1331 | (1 << 7) | (go->encoder_h_offset >> 2), | |
1332 | (1 << 6), | |
1333 | 0, | |
1334 | 0, | |
1335 | ((go->fps_scale - 1) << 8) | | |
1336 | (go->board_info->sensor_flags & GO7007_SENSOR_TV ? | |
1337 | (1 << 7) : 0) | | |
1338 | 0x41, | |
1339 | go->ipb ? 0xd4c : 0x36b, | |
1340 | (rows << 8) | (go->width >> 4), | |
35d2d76d | 1341 | go->format == V4L2_PIX_FMT_MPEG4 ? 0x0404 : 0, |
866b8695 GKH |
1342 | (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) | |
1343 | ((go->closed_gop ? 1 : 0) << 12) | | |
35d2d76d | 1344 | ((go->format == V4L2_PIX_FMT_MPEG4 ? 1 : 0) << 11) | |
866b8695 GKH |
1345 | /* (1 << 9) | */ |
1346 | ((go->ipb ? 3 : 0) << 7) | | |
1347 | ((go->modet_enable ? 1 : 0) << 2) | | |
1348 | ((go->dvd_mode ? 1 : 0) << 1) | 1, | |
35d2d76d HV |
1349 | (go->format == V4L2_PIX_FMT_MPEG1 ? 0x89a0 : |
1350 | (go->format == V4L2_PIX_FMT_MPEG2 ? 0x89a0 : | |
1351 | (go->format == V4L2_PIX_FMT_MJPEG ? 0x89a0 : | |
1352 | (go->format == V4L2_PIX_FMT_MPEG4 ? 0x8920 : | |
1353 | (go->format == V4L2_PIX_FMT_H263 ? 0x8920 : 0))))), | |
866b8695 GKH |
1354 | go->ipb ? 0x1f15 : 0x1f0b, |
1355 | go->ipb ? 0x0015 : 0x000b, | |
1356 | go->ipb ? 0xa800 : 0x5800, | |
1357 | 0xffff, | |
1358 | 0x0020 + 0x034b * 0, | |
1359 | 0x0020 + 0x034b * 1, | |
1360 | 0x0020 + 0x034b * 2, | |
1361 | 0x0020 + 0x034b * 3, | |
1362 | 0x0020 + 0x034b * 4, | |
1363 | 0x0020 + 0x034b * 5, | |
1364 | go->ipb ? (go->gop_size / 3) : go->gop_size, | |
1365 | (go->height >> 4) * (go->width >> 4) * 110 / 100, | |
1366 | }; | |
1367 | ||
1368 | return copy_packages(code, pack, 1, space); | |
1369 | } | |
1370 | ||
9febd042 | 1371 | static int audio_to_package(struct go7007 *go, __le16 *code, int space) |
866b8695 GKH |
1372 | { |
1373 | int clock_config = ((go->board_info->audio_flags & | |
1374 | GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) | | |
1375 | ((go->board_info->audio_flags & | |
1376 | GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) | | |
1377 | (((go->board_info->audio_bclk_div / 4) - 1) << 4) | | |
1378 | (go->board_info->audio_main_div - 1); | |
1379 | u16 pack[] = { | |
1380 | 0x200d, 0, | |
1381 | 0x9002, 0, | |
1382 | 0x9002, 0, | |
1383 | 0x9031, 0, | |
1384 | 0x9032, 0, | |
1385 | 0x9033, 0, | |
1386 | 0x9034, 0, | |
1387 | 0x9035, 0, | |
1388 | 0x9036, 0, | |
1389 | 0x9037, 0, | |
1390 | 0x9040, 0, | |
1391 | 0x9000, clock_config, | |
1392 | 0x9001, (go->board_info->audio_flags & 0xffff) | | |
1393 | (1 << 9), | |
1394 | 0x9000, ((go->board_info->audio_flags & | |
1395 | GO7007_AUDIO_I2S_MASTER ? | |
1396 | 1 : 0) << 10) | | |
1397 | clock_config, | |
1398 | 0, 0, | |
1399 | 0, 0, | |
1400 | 0x2005, 0, | |
1401 | 0x9041, 0, | |
1402 | 0x9042, 256, | |
1403 | 0x9043, 0, | |
1404 | 0x9044, 16, | |
1405 | 0x9045, 16, | |
1406 | 0, 0, | |
1407 | 0, 0, | |
1408 | 0, 0, | |
1409 | 0, 0, | |
1410 | 0, 0, | |
1411 | 0, 0, | |
1412 | 0, 0, | |
1413 | 0, 0, | |
1414 | 0, 0, | |
1415 | 0, 0, | |
1416 | }; | |
1417 | ||
1418 | return copy_packages(code, pack, 2, space); | |
1419 | } | |
1420 | ||
9febd042 | 1421 | static int modet_to_package(struct go7007 *go, __le16 *code, int space) |
866b8695 | 1422 | { |
0ee58f84 HV |
1423 | bool has_modet0 = go->modet[0].enable; |
1424 | bool has_modet1 = go->modet[1].enable; | |
1425 | bool has_modet2 = go->modet[2].enable; | |
1426 | bool has_modet3 = go->modet[3].enable; | |
866b8695 GKH |
1427 | int ret, mb, i, addr, cnt = 0; |
1428 | u16 pack[32]; | |
1429 | u16 thresholds[] = { | |
1430 | 0x200e, 0, | |
0ee58f84 HV |
1431 | 0xbf82, has_modet0 ? go->modet[0].pixel_threshold : 32767, |
1432 | 0xbf83, has_modet1 ? go->modet[1].pixel_threshold : 32767, | |
1433 | 0xbf84, has_modet2 ? go->modet[2].pixel_threshold : 32767, | |
1434 | 0xbf85, has_modet3 ? go->modet[3].pixel_threshold : 32767, | |
1435 | 0xbf86, has_modet0 ? go->modet[0].motion_threshold : 32767, | |
1436 | 0xbf87, has_modet1 ? go->modet[1].motion_threshold : 32767, | |
1437 | 0xbf88, has_modet2 ? go->modet[2].motion_threshold : 32767, | |
1438 | 0xbf89, has_modet3 ? go->modet[3].motion_threshold : 32767, | |
1439 | 0xbf8a, has_modet0 ? go->modet[0].mb_threshold : 32767, | |
1440 | 0xbf8b, has_modet1 ? go->modet[1].mb_threshold : 32767, | |
1441 | 0xbf8c, has_modet2 ? go->modet[2].mb_threshold : 32767, | |
1442 | 0xbf8d, has_modet3 ? go->modet[3].mb_threshold : 32767, | |
866b8695 GKH |
1443 | 0xbf8e, 0, |
1444 | 0xbf8f, 0, | |
1445 | 0, 0, | |
1446 | }; | |
1447 | ||
1448 | ret = copy_packages(code, thresholds, 1, space); | |
1449 | if (ret < 0) | |
1450 | return -1; | |
1451 | cnt += ret; | |
1452 | ||
1453 | addr = 0xbac0; | |
1454 | memset(pack, 0, 64); | |
1455 | i = 0; | |
1456 | for (mb = 0; mb < 1624; ++mb) { | |
1457 | pack[i * 2 + 3] <<= 2; | |
1458 | pack[i * 2 + 3] |= go->modet_map[mb]; | |
1459 | if (mb % 8 != 7) | |
1460 | continue; | |
1461 | pack[i * 2 + 2] = addr++; | |
1462 | ++i; | |
1463 | if (i == 10 || mb == 1623) { | |
1464 | pack[0] = 0x2000 | i; | |
1465 | ret = copy_packages(code + cnt, pack, 1, space - cnt); | |
1466 | if (ret < 0) | |
1467 | return -1; | |
1468 | cnt += ret; | |
1469 | i = 0; | |
1470 | memset(pack, 0, 64); | |
1471 | } | |
1472 | pack[i * 2 + 3] = 0; | |
1473 | } | |
1474 | ||
1475 | memset(pack, 0, 64); | |
1476 | i = 0; | |
1477 | for (addr = 0xbb90; addr < 0xbbfa; ++addr) { | |
1478 | pack[i * 2 + 2] = addr; | |
1479 | pack[i * 2 + 3] = 0; | |
1480 | ++i; | |
1481 | if (i == 10 || addr == 0xbbf9) { | |
1482 | pack[0] = 0x2000 | i; | |
1483 | ret = copy_packages(code + cnt, pack, 1, space - cnt); | |
1484 | if (ret < 0) | |
1485 | return -1; | |
1486 | cnt += ret; | |
1487 | i = 0; | |
1488 | memset(pack, 0, 64); | |
1489 | } | |
1490 | } | |
1491 | return cnt; | |
1492 | } | |
1493 | ||
ed713a4a AB |
1494 | static noinline_for_stack int do_special(struct go7007 *go, u16 type, |
1495 | __le16 *code, int space, int *framelen) | |
866b8695 GKH |
1496 | { |
1497 | switch (type) { | |
1498 | case SPECIAL_FRM_HEAD: | |
1499 | switch (go->format) { | |
35d2d76d | 1500 | case V4L2_PIX_FMT_MJPEG: |
866b8695 | 1501 | return gen_mjpeghdr_to_package(go, code, space); |
35d2d76d HV |
1502 | case V4L2_PIX_FMT_MPEG1: |
1503 | case V4L2_PIX_FMT_MPEG2: | |
866b8695 GKH |
1504 | return gen_mpeg1hdr_to_package(go, code, space, |
1505 | framelen); | |
35d2d76d | 1506 | case V4L2_PIX_FMT_MPEG4: |
866b8695 GKH |
1507 | return gen_mpeg4hdr_to_package(go, code, space, |
1508 | framelen); | |
a7f3482d HV |
1509 | default: |
1510 | break; | |
866b8695 | 1511 | } |
a7f3482d | 1512 | break; |
866b8695 GKH |
1513 | case SPECIAL_BRC_CTRL: |
1514 | return brctrl_to_package(go, code, space, framelen); | |
1515 | case SPECIAL_CONFIG: | |
1516 | return config_package(go, code, space); | |
1517 | case SPECIAL_SEQHEAD: | |
1518 | switch (go->format) { | |
35d2d76d HV |
1519 | case V4L2_PIX_FMT_MPEG1: |
1520 | case V4L2_PIX_FMT_MPEG2: | |
866b8695 GKH |
1521 | return seqhead_to_package(go, code, space, |
1522 | mpeg1_sequence_header); | |
35d2d76d | 1523 | case V4L2_PIX_FMT_MPEG4: |
866b8695 GKH |
1524 | return seqhead_to_package(go, code, space, |
1525 | mpeg4_sequence_header); | |
1526 | default: | |
1527 | return 0; | |
1528 | } | |
1529 | case SPECIAL_AV_SYNC: | |
1530 | return avsync_to_package(go, code, space); | |
1531 | case SPECIAL_FINAL: | |
1532 | return final_package(go, code, space); | |
1533 | case SPECIAL_AUDIO: | |
1534 | return audio_to_package(go, code, space); | |
1535 | case SPECIAL_MODET: | |
1536 | return modet_to_package(go, code, space); | |
1537 | } | |
79280714 YT |
1538 | dev_err(go->dev, |
1539 | "firmware file contains unsupported feature %04x\n", type); | |
866b8695 GKH |
1540 | return -1; |
1541 | } | |
1542 | ||
1543 | int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen) | |
1544 | { | |
1545 | const struct firmware *fw_entry; | |
9febd042 | 1546 | __le16 *code, *src; |
866b8695 GKH |
1547 | int framelen[8] = { }; /* holds the lengths of empty frame templates */ |
1548 | int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags; | |
1549 | int mode_flag; | |
1550 | int ret; | |
1551 | ||
1552 | switch (go->format) { | |
35d2d76d | 1553 | case V4L2_PIX_FMT_MJPEG: |
866b8695 GKH |
1554 | mode_flag = FLAG_MODE_MJPEG; |
1555 | break; | |
35d2d76d | 1556 | case V4L2_PIX_FMT_MPEG1: |
866b8695 GKH |
1557 | mode_flag = FLAG_MODE_MPEG1; |
1558 | break; | |
35d2d76d | 1559 | case V4L2_PIX_FMT_MPEG2: |
866b8695 GKH |
1560 | mode_flag = FLAG_MODE_MPEG2; |
1561 | break; | |
35d2d76d | 1562 | case V4L2_PIX_FMT_MPEG4: |
866b8695 GKH |
1563 | mode_flag = FLAG_MODE_MPEG4; |
1564 | break; | |
1565 | default: | |
1566 | return -1; | |
1567 | } | |
0a6ecbb4 | 1568 | if (request_firmware(&fw_entry, GO7007_FW_NAME, go->dev)) { |
79280714 YT |
1569 | dev_err(go->dev, |
1570 | "unable to load firmware from file \"%s\"\n", | |
0a6ecbb4 | 1571 | GO7007_FW_NAME); |
866b8695 GKH |
1572 | return -1; |
1573 | } | |
6396bb22 | 1574 | code = kcalloc(codespace, 2, GFP_KERNEL); |
535ec049 | 1575 | if (code == NULL) |
866b8695 | 1576 | goto fw_failed; |
535ec049 | 1577 | |
9febd042 | 1578 | src = (__le16 *)fw_entry->data; |
866b8695 GKH |
1579 | srclen = fw_entry->size / 2; |
1580 | while (srclen >= 2) { | |
1581 | chunk_flags = __le16_to_cpu(src[0]); | |
1582 | chunk_len = __le16_to_cpu(src[1]); | |
1583 | if (chunk_len + 2 > srclen) { | |
79280714 YT |
1584 | dev_err(go->dev, |
1585 | "firmware file \"%s\" appears to be corrupted\n", | |
0a6ecbb4 | 1586 | GO7007_FW_NAME); |
866b8695 GKH |
1587 | goto fw_failed; |
1588 | } | |
1589 | if (chunk_flags & mode_flag) { | |
1590 | if (chunk_flags & FLAG_SPECIAL) { | |
1591 | ret = do_special(go, __le16_to_cpu(src[2]), | |
1592 | &code[i], codespace - i, framelen); | |
1593 | if (ret < 0) { | |
79280714 YT |
1594 | dev_err(go->dev, |
1595 | "insufficient memory for firmware construction\n"); | |
866b8695 GKH |
1596 | goto fw_failed; |
1597 | } | |
1598 | i += ret; | |
1599 | } else { | |
1600 | if (codespace - i < chunk_len) { | |
79280714 YT |
1601 | dev_err(go->dev, |
1602 | "insufficient memory for firmware construction\n"); | |
866b8695 GKH |
1603 | goto fw_failed; |
1604 | } | |
1605 | memcpy(&code[i], &src[2], chunk_len * 2); | |
1606 | i += chunk_len; | |
1607 | } | |
1608 | } | |
1609 | srclen -= chunk_len + 2; | |
1610 | src += chunk_len + 2; | |
1611 | } | |
1612 | release_firmware(fw_entry); | |
1613 | *fw = (u8 *)code; | |
1614 | *fwlen = i * 2; | |
1615 | return 0; | |
1616 | ||
1617 | fw_failed: | |
1618 | kfree(code); | |
1619 | release_firmware(fw_entry); | |
1620 | return -1; | |
1621 | } | |
0a6ecbb4 HV |
1622 | |
1623 | MODULE_FIRMWARE(GO7007_FW_NAME); |