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