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