?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'pm/linux-next'
[linux-2.6/next.git] / drivers / staging / go7007 / go7007-fw.c
blobc9a6409edfe36f0153b976e9c63af42cbc37ad9c
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 /* 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
62 struct 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
87 static 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
101 static 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
115 static 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
171 enum mpeg_frame_type {
172 PFRAME,
173 BFRAME_PRE,
174 BFRAME_POST,
175 BFRAME_BIDIR,
176 BFRAME_EMPTY
177 };
178
179 static 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
193 static 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
204 static 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
208 static const u8 val_dc_luminance[] = {
209 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
210 };
211
212 static 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
216 static const u8 val_dc_chrominance[] = {
217 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
218 };
219
220 static 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
224 static 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
248 static 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
252 static 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 */
281 static 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
288 static int copy_packages(__le16 *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_le16p(src + i);
297
298 return cnt;
299 }
300
301 static 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
376 static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *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 = kzalloc(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
390 for (i = 1; i < 32; ++i) {
391 mjpeg_frame_header(go, buf + size, i);
392 size += 80;
393 }
394 chunk = mjpeg_frame_header(go, buf + size, 1);
395 memmove(buf + size, buf + size + 80, chunk - 80);
396 size += chunk - 80;
397
398 for (i = 0; i < size; i += chunk * 2) {
399 if (space - off < 32) {
400 off = -1;
401 goto done;
402 }
403
404 code[off + 1] = __cpu_to_le16(0x8000 | mem);
405
406 chunk = 28;
407 if (mem + chunk > 0x4000)
408 chunk = 0x4000 - mem;
409 if (i + 2 * chunk > size)
410 chunk = (size - i) / 2;
411
412 if (chunk < 28) {
413 code[off] = __cpu_to_le16(0x4000 | chunk);
414 code[off + 31] = __cpu_to_le16(addr++);
415 mem = 0x3e00;
416 } else {
417 code[off] = __cpu_to_le16(0x1000 | 28);
418 code[off + 31] = 0;
419 mem += 28;
420 }
421
422 memcpy(&code[off + 2], buf + i, chunk * 2);
423 off += 32;
424 }
425 done:
426 kfree(buf);
427 return off;
428 }
429
430 static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf,
431 int modulo, int pict_struct, enum mpeg_frame_type frame)
432 {
433 int i, j, mb_code, mb_len;
434 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
435 CODE_GEN(c, buf + 6);
436
437 switch (frame) {
438 case PFRAME:
439 mb_code = 0x1;
440 mb_len = 3;
441 break;
442 case BFRAME_PRE:
443 mb_code = 0x2;
444 mb_len = 4;
445 break;
446 case BFRAME_POST:
447 mb_code = 0x2;
448 mb_len = 3;
449 break;
450 case BFRAME_BIDIR:
451 mb_code = 0x2;
452 mb_len = 2;
453 break;
454 default: /* keep the compiler happy */
455 mb_code = mb_len = 0;
456 break;
457 }
458
459 CODE_ADD(c, frame == PFRAME ? 0x2 : 0x3, 13);
460 CODE_ADD(c, 0xffff, 16);
461 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
462 if (frame != PFRAME)
463 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
464 else
465 CODE_ADD(c, 0, 4); /* Is this supposed to be here?? */
466 CODE_ADD(c, 0, 3); /* What is this?? */
467 /* Byte-align with zeros */
468 j = 8 - (CODE_LENGTH(c) % 8);
469 if (j != 8)
470 CODE_ADD(c, 0, j);
471
472 if (go->format == GO7007_FORMAT_MPEG2) {
473 CODE_ADD(c, 0x1, 24);
474 CODE_ADD(c, 0xb5, 8);
475 CODE_ADD(c, 0x844, 12);
476 CODE_ADD(c, frame == PFRAME ? 0xff : 0x44, 8);
477 if (go->interlace_coding) {
478 CODE_ADD(c, pict_struct, 4);
479 if (go->dvd_mode)
480 CODE_ADD(c, 0x000, 11);
481 else
482 CODE_ADD(c, 0x200, 11);
483 } else {
484 CODE_ADD(c, 0x3, 4);
485 CODE_ADD(c, 0x20c, 11);
486 }
487 /* Byte-align with zeros */
488 j = 8 - (CODE_LENGTH(c) % 8);
489 if (j != 8)
490 CODE_ADD(c, 0, j);
491 }
492
493 for (i = 0; i < rows; ++i) {
494 CODE_ADD(c, 1, 24);
495 CODE_ADD(c, i + 1, 8);
496 CODE_ADD(c, 0x2, 6);
497 CODE_ADD(c, 0x1, 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 for (j = (go->width >> 4) - 2; j >= 33; j -= 33)
510 CODE_ADD(c, 0x8, 11);
511 CODE_ADD(c, addrinctab[j][0], addrinctab[j][1]);
512 CODE_ADD(c, mb_code, mb_len);
513 if (go->interlace_coding) {
514 CODE_ADD(c, 0x1, 2);
515 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
516 }
517 if (frame == BFRAME_BIDIR) {
518 CODE_ADD(c, 0x3, 2);
519 if (go->interlace_coding)
520 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
521 }
522 CODE_ADD(c, 0x3, 2);
523
524 /* Byte-align with zeros */
525 j = 8 - (CODE_LENGTH(c) % 8);
526 if (j != 8)
527 CODE_ADD(c, 0, j);
528 }
529
530 i = CODE_LENGTH(c) + 4 * 8;
531 buf[2] = 0x00;
532 buf[3] = 0x00;
533 buf[4] = 0x01;
534 buf[5] = 0x00;
535 return i;
536 }
537
538 static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
539 {
540 int i, aspect_ratio, picture_rate;
541 CODE_GEN(c, buf + 6);
542
543 if (go->format == GO7007_FORMAT_MPEG1) {
544 switch (go->aspect_ratio) {
545 case GO7007_RATIO_4_3:
546 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
547 break;
548 case GO7007_RATIO_16_9:
549 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
550 break;
551 default:
552 aspect_ratio = 1;
553 break;
554 }
555 } else {
556 switch (go->aspect_ratio) {
557 case GO7007_RATIO_4_3:
558 aspect_ratio = 2;
559 break;
560 case GO7007_RATIO_16_9:
561 aspect_ratio = 3;
562 break;
563 default:
564 aspect_ratio = 1;
565 break;
566 }
567 }
568 switch (go->sensor_framerate) {
569 case 24000:
570 picture_rate = 1;
571 break;
572 case 24024:
573 picture_rate = 2;
574 break;
575 case 25025:
576 picture_rate = go->interlace_coding ? 6 : 3;
577 break;
578 case 30000:
579 picture_rate = go->interlace_coding ? 7 : 4;
580 break;
581 case 30030:
582 picture_rate = go->interlace_coding ? 8 : 5;
583 break;
584 default:
585 picture_rate = 5; /* 30 fps seems like a reasonable default */
586 break;
587 }
588
589 CODE_ADD(c, go->width, 12);
590 CODE_ADD(c, go->height, 12);
591 CODE_ADD(c, aspect_ratio, 4);
592 CODE_ADD(c, picture_rate, 4);
593 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 20000 : 0x3ffff, 18);
594 CODE_ADD(c, 1, 1);
595 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 112 : 20, 10);
596 CODE_ADD(c, 0, 3);
597
598 /* Byte-align with zeros */
599 i = 8 - (CODE_LENGTH(c) % 8);
600 if (i != 8)
601 CODE_ADD(c, 0, i);
602
603 if (go->format == GO7007_FORMAT_MPEG2) {
604 CODE_ADD(c, 0x1, 24);
605 CODE_ADD(c, 0xb5, 8);
606 CODE_ADD(c, 0x148, 12);
607 if (go->interlace_coding)
608 CODE_ADD(c, 0x20001, 20);
609 else
610 CODE_ADD(c, 0xa0001, 20);
611 CODE_ADD(c, 0, 16);
612
613 /* Byte-align with zeros */
614 i = 8 - (CODE_LENGTH(c) % 8);
615 if (i != 8)
616 CODE_ADD(c, 0, i);
617
618 if (ext) {
619 CODE_ADD(c, 0x1, 24);
620 CODE_ADD(c, 0xb52, 12);
621 CODE_ADD(c, go->standard == GO7007_STD_NTSC ? 2 : 1, 3);
622 CODE_ADD(c, 0x105, 9);
623 CODE_ADD(c, 0x505, 16);
624 CODE_ADD(c, go->width, 14);
625 CODE_ADD(c, 1, 1);
626 CODE_ADD(c, go->height, 14);
627
628 /* Byte-align with zeros */
629 i = 8 - (CODE_LENGTH(c) % 8);
630 if (i != 8)
631 CODE_ADD(c, 0, i);
632 }
633 }
634
635 i = CODE_LENGTH(c) + 4 * 8;
636 buf[0] = i & 0xff;
637 buf[1] = i >> 8;
638 buf[2] = 0x00;
639 buf[3] = 0x00;
640 buf[4] = 0x01;
641 buf[5] = 0xb3;
642 return i;
643 }
644
645 static int gen_mpeg1hdr_to_package(struct go7007 *go,
646 __le16 *code, int space, int *framelen)
647 {
648 u8 *buf;
649 u16 mem = 0x3e00;
650 unsigned int addr = 0x19;
651 int i, off = 0, chunk;
652
653 buf = kzalloc(5120, GFP_KERNEL);
654 if (buf == NULL) {
655 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
656 "firmware construction\n");
657 return -1;
658 }
659 framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME);
660 if (go->interlace_coding)
661 framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8,
662 0, 2, PFRAME);
663 buf[0] = framelen[0] & 0xff;
664 buf[1] = framelen[0] >> 8;
665 i = 368;
666 framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE);
667 if (go->interlace_coding)
668 framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8,
669 0, 2, BFRAME_PRE);
670 buf[i] = framelen[1] & 0xff;
671 buf[i + 1] = framelen[1] >> 8;
672 i += 1632;
673 framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST);
674 if (go->interlace_coding)
675 framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8,
676 0, 2, BFRAME_POST);
677 buf[i] = framelen[2] & 0xff;
678 buf[i + 1] = framelen[2] >> 8;
679 i += 1432;
680 framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR);
681 if (go->interlace_coding)
682 framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8,
683 0, 2, BFRAME_BIDIR);
684 buf[i] = framelen[3] & 0xff;
685 buf[i + 1] = framelen[3] >> 8;
686 i += 1632 + 16;
687 mpeg1_sequence_header(go, buf + i, 0);
688 i += 40;
689 for (i = 0; i < 5120; i += chunk * 2) {
690 if (space - off < 32) {
691 off = -1;
692 goto done;
693 }
694
695 code[off + 1] = __cpu_to_le16(0x8000 | mem);
696
697 chunk = 28;
698 if (mem + chunk > 0x4000)
699 chunk = 0x4000 - mem;
700 if (i + 2 * chunk > 5120)
701 chunk = (5120 - i) / 2;
702
703 if (chunk < 28) {
704 code[off] = __cpu_to_le16(0x4000 | chunk);
705 code[off + 31] = __cpu_to_le16(addr);
706 if (mem + chunk == 0x4000) {
707 mem = 0x3e00;
708 ++addr;
709 }
710 } else {
711 code[off] = __cpu_to_le16(0x1000 | 28);
712 code[off + 31] = 0;
713 mem += 28;
714 }
715
716 memcpy(&code[off + 2], buf + i, chunk * 2);
717 off += 32;
718 }
719 done:
720 kfree(buf);
721 return off;
722 }
723
724 static int vti_bitlen(struct go7007 *go)
725 {
726 unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
727
728 for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i);
729 return i + 1;
730 }
731
732 static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
733 int modulo, enum mpeg_frame_type frame)
734 {
735 int i;
736 CODE_GEN(c, buf + 6);
737 int mb_count = (go->width >> 4) * (go->height >> 4);
738
739 CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
740 if (modulo)
741 CODE_ADD(c, 0x1, 1);
742 CODE_ADD(c, 0x1, 2);
743 CODE_ADD(c, 0, vti_bitlen(go));
744 CODE_ADD(c, 0x3, 2);
745 if (frame == PFRAME)
746 CODE_ADD(c, 0, 1);
747 CODE_ADD(c, 0xc, 11);
748 if (frame != PFRAME)
749 CODE_ADD(c, 0x4, 3);
750 if (frame != BFRAME_EMPTY) {
751 for (i = 0; i < mb_count; ++i) {
752 switch (frame) {
753 case PFRAME:
754 CODE_ADD(c, 0x1, 1);
755 break;
756 case BFRAME_PRE:
757 CODE_ADD(c, 0x47, 8);
758 break;
759 case BFRAME_POST:
760 CODE_ADD(c, 0x27, 7);
761 break;
762 case BFRAME_BIDIR:
763 CODE_ADD(c, 0x5f, 8);
764 break;
765 case BFRAME_EMPTY: /* keep compiler quiet */
766 break;
767 }
768 }
769 }
770
771 /* Byte-align with a zero followed by ones */
772 i = 8 - (CODE_LENGTH(c) % 8);
773 CODE_ADD(c, 0, 1);
774 CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
775
776 i = CODE_LENGTH(c) + 4 * 8;
777 buf[0] = i & 0xff;
778 buf[1] = i >> 8;
779 buf[2] = 0x00;
780 buf[3] = 0x00;
781 buf[4] = 0x01;
782 buf[5] = 0xb6;
783 return i;
784 }
785
786 static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
787 {
788 const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali,
789 0x00, 0x00, 0x01, 0xb5, 0x09,
790 0x00, 0x00, 0x01, 0x00,
791 0x00, 0x00, 0x01, 0x20, };
792 int i, aspect_ratio;
793 int fps = go->sensor_framerate / go->fps_scale;
794 CODE_GEN(c, buf + 2 + sizeof(head));
795
796 switch (go->aspect_ratio) {
797 case GO7007_RATIO_4_3:
798 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
799 break;
800 case GO7007_RATIO_16_9:
801 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
802 break;
803 default:
804 aspect_ratio = 1;
805 break;
806 }
807
808 memcpy(buf + 2, head, sizeof(head));
809 CODE_ADD(c, 0x191, 17);
810 CODE_ADD(c, aspect_ratio, 4);
811 CODE_ADD(c, 0x1, 4);
812 CODE_ADD(c, fps, 16);
813 CODE_ADD(c, 0x3, 2);
814 CODE_ADD(c, 1001, vti_bitlen(go));
815 CODE_ADD(c, 1, 1);
816 CODE_ADD(c, go->width, 13);
817 CODE_ADD(c, 1, 1);
818 CODE_ADD(c, go->height, 13);
819 CODE_ADD(c, 0x2830, 14);
820
821 /* Byte-align */
822 i = 8 - (CODE_LENGTH(c) % 8);
823 CODE_ADD(c, 0, 1);
824 CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
825
826 i = CODE_LENGTH(c) + sizeof(head) * 8;
827 buf[0] = i & 0xff;
828 buf[1] = i >> 8;
829 return i;
830 }
831
832 static int gen_mpeg4hdr_to_package(struct go7007 *go,
833 __le16 *code, int space, int *framelen)
834 {
835 u8 *buf;
836 u16 mem = 0x3e00;
837 unsigned int addr = 0x19;
838 int i, off = 0, chunk;
839
840 buf = kzalloc(5120, GFP_KERNEL);
841 if (buf == NULL) {
842 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
843 "firmware construction\n");
844 return -1;
845 }
846 framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
847 i = 368;
848 framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
849 i += 1632;
850 framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
851 i += 1432;
852 framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
853 i += 1632;
854 mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
855 i += 16;
856 mpeg4_sequence_header(go, buf + i, 0);
857 i += 40;
858 for (i = 0; i < 5120; i += chunk * 2) {
859 if (space - off < 32) {
860 off = -1;
861 goto done;
862 }
863
864 code[off + 1] = __cpu_to_le16(0x8000 | mem);
865
866 chunk = 28;
867 if (mem + chunk > 0x4000)
868 chunk = 0x4000 - mem;
869 if (i + 2 * chunk > 5120)
870 chunk = (5120 - i) / 2;
871
872 if (chunk < 28) {
873 code[off] = __cpu_to_le16(0x4000 | chunk);
874 code[off + 31] = __cpu_to_le16(addr);
875 if (mem + chunk == 0x4000) {
876 mem = 0x3e00;
877 ++addr;
878 }
879 } else {
880 code[off] = __cpu_to_le16(0x1000 | 28);
881 code[off + 31] = 0;
882 mem += 28;
883 }
884
885 memcpy(&code[off + 2], buf + i, chunk * 2);
886 off += 32;
887 }
888 mem = 0x3e00;
889 addr = go->ipb ? 0x14f9 : 0x0af9;
890 memset(buf, 0, 5120);
891 framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
892 i = 368;
893 framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
894 i += 1632;
895 framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
896 i += 1432;
897 framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
898 i += 1632;
899 mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
900 i += 16;
901 for (i = 0; i < 5120; i += chunk * 2) {
902 if (space - off < 32) {
903 off = -1;
904 goto done;
905 }
906
907 code[off + 1] = __cpu_to_le16(0x8000 | mem);
908
909 chunk = 28;
910 if (mem + chunk > 0x4000)
911 chunk = 0x4000 - mem;
912 if (i + 2 * chunk > 5120)
913 chunk = (5120 - i) / 2;
914
915 if (chunk < 28) {
916 code[off] = __cpu_to_le16(0x4000 | chunk);
917 code[off + 31] = __cpu_to_le16(addr);
918 if (mem + chunk == 0x4000) {
919 mem = 0x3e00;
920 ++addr;
921 }
922 } else {
923 code[off] = __cpu_to_le16(0x1000 | 28);
924 code[off + 31] = 0;
925 mem += 28;
926 }
927
928 memcpy(&code[off + 2], buf + i, chunk * 2);
929 off += 32;
930 }
931 done:
932 kfree(buf);
933 return off;
934 }
935
936 static int brctrl_to_package(struct go7007 *go,
937 __le16 *code, int space, int *framelen)
938 {
939 int converge_speed = 0;
940 int lambda = (go->format == GO7007_FORMAT_MJPEG || go->dvd_mode) ?
941 100 : 0;
942 int peak_rate = 6 * go->bitrate / 5;
943 int vbv_buffer = go->format == GO7007_FORMAT_MJPEG ?
944 go->bitrate :
945 (go->dvd_mode ? 900000 : peak_rate);
946 int fps = go->sensor_framerate / go->fps_scale;
947 int q = 0;
948 /* Bizarre math below depends on rounding errors in division */
949 u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps;
950 u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps;
951 u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000);
952 u32 vbv_alert_addr = vbv_buffer * 3 / (4 * 32);
953 u32 cplx[] = {
954 q > 0 ? sgop_expt_addr * q :
955 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
956 q > 0 ? sgop_expt_addr * q :
957 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
958 q > 0 ? sgop_expt_addr * q :
959 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
960 q > 0 ? sgop_expt_addr * q :
961 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
962 };
963 u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
964 u16 pack[] = {
965 0x200e, 0x0000,
966 0xBF20, go->ipb ? converge_speed_ipb[converge_speed]
967 : converge_speed_ip[converge_speed],
968 0xBF21, go->ipb ? 2 : 0,
969 0xBF22, go->ipb ? LAMBDA_table[0][lambda / 2 + 50]
970 : 32767,
971 0xBF23, go->ipb ? LAMBDA_table[1][lambda] : 32767,
972 0xBF24, 32767,
973 0xBF25, lambda > 99 ? 32767 : LAMBDA_table[3][lambda],
974 0xBF26, sgop_expt_addr & 0x0000FFFF,
975 0xBF27, sgop_expt_addr >> 16,
976 0xBF28, sgop_peak_addr & 0x0000FFFF,
977 0xBF29, sgop_peak_addr >> 16,
978 0xBF2A, vbv_alert_addr & 0x0000FFFF,
979 0xBF2B, vbv_alert_addr >> 16,
980 0xBF2C, 0,
981 0xBF2D, 0,
982 0, 0,
983
984 0x200e, 0x0000,
985 0xBF2E, vbv_alert_addr & 0x0000FFFF,
986 0xBF2F, vbv_alert_addr >> 16,
987 0xBF30, cplx[0] & 0x0000FFFF,
988 0xBF31, cplx[0] >> 16,
989 0xBF32, cplx[1] & 0x0000FFFF,
990 0xBF33, cplx[1] >> 16,
991 0xBF34, cplx[2] & 0x0000FFFF,
992 0xBF35, cplx[2] >> 16,
993 0xBF36, cplx[3] & 0x0000FFFF,
994 0xBF37, cplx[3] >> 16,
995 0xBF38, 0,
996 0xBF39, 0,
997 0xBF3A, total_expt_addr & 0x0000FFFF,
998 0xBF3B, total_expt_addr >> 16,
999 0, 0,
1000
1001 0x200e, 0x0000,
1002 0xBF3C, total_expt_addr & 0x0000FFFF,
1003 0xBF3D, total_expt_addr >> 16,
1004 0xBF3E, 0,
1005 0xBF3F, 0,
1006 0xBF48, 0,
1007 0xBF49, 0,
1008 0xBF4A, calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
1009 0xBF4B, 4,
1010 0xBF4C, 0,
1011 0xBF4D, 0,
1012 0xBF4E, 0,
1013 0xBF4F, 0,
1014 0xBF50, 0,
1015 0xBF51, 0,
1016 0, 0,
1017
1018 0x200e, 0x0000,
1019 0xBF40, sgop_expt_addr & 0x0000FFFF,
1020 0xBF41, sgop_expt_addr >> 16,
1021 0xBF42, 0,
1022 0xBF43, 0,
1023 0xBF44, 0,
1024 0xBF45, 0,
1025 0xBF46, (go->width >> 4) * (go->height >> 4),
1026 0xBF47, 0,
1027 0xBF64, 0,
1028 0xBF65, 0,
1029 0xBF18, framelen[4],
1030 0xBF19, framelen[5],
1031 0xBF1A, framelen[6],
1032 0xBF1B, framelen[7],
1033 0, 0,
1034
1035 #if 0
1036 /* Remove once we don't care about matching */
1037 0x200e, 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 0xBF5E, 1,
1047 0xBF5F, 0,
1048 0xBF60, 1,
1049 0xBF61, 0,
1050 0xBF62, 0,
1051 0xBF63, 0,
1052 0, 0,
1053 #else
1054 0x2008, 0x0000,
1055 0xBF56, 4,
1056 0xBF57, 0,
1057 0xBF58, 5,
1058 0xBF59, 0,
1059 0xBF5A, 6,
1060 0xBF5B, 0,
1061 0xBF5C, 8,
1062 0xBF5D, 0,
1063 0, 0,
1064 0, 0,
1065 0, 0,
1066 0, 0,
1067 0, 0,
1068 0, 0,
1069 0, 0,
1070 #endif
1071
1072 0x200e, 0x0000,
1073 0xBF10, 0,
1074 0xBF11, 0,
1075 0xBF12, 0,
1076 0xBF13, 0,
1077 0xBF14, 0,
1078 0xBF15, 0,
1079 0xBF16, 0,
1080 0xBF17, 0,
1081 0xBF7E, 0,
1082 0xBF7F, 1,
1083 0xBF52, framelen[0],
1084 0xBF53, framelen[1],
1085 0xBF54, framelen[2],
1086 0xBF55, framelen[3],
1087 0, 0,
1088 };
1089
1090 return copy_packages(code, pack, 6, space);
1091 }
1092
1093 static int config_package(struct go7007 *go, __le16 *code, int space)
1094 {
1095 int fps = go->sensor_framerate / go->fps_scale / 1000;
1096 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1097 int brc_window_size = fps;
1098 int q_min = 2, q_max = 31;
1099 int THACCoeffSet0 = 0;
1100 u16 pack[] = {
1101 0x200e, 0x0000,
1102 0xc002, 0x14b4,
1103 0xc003, 0x28b4,
1104 0xc004, 0x3c5a,
1105 0xdc05, 0x2a77,
1106 0xc6c3, go->format == GO7007_FORMAT_MPEG4 ? 0 :
1107 (go->format == GO7007_FORMAT_H263 ? 0 : 1),
1108 0xc680, go->format == GO7007_FORMAT_MPEG4 ? 0xf1 :
1109 (go->format == GO7007_FORMAT_H263 ? 0x61 :
1110 0xd3),
1111 0xc780, 0x0140,
1112 0xe009, 0x0001,
1113 0xc60f, 0x0008,
1114 0xd4ff, 0x0002,
1115 0xe403, 2340,
1116 0xe406, 75,
1117 0xd411, 0x0001,
1118 0xd410, 0xa1d6,
1119 0x0001, 0x2801,
1120
1121 0x200d, 0x0000,
1122 0xe402, 0x018b,
1123 0xe401, 0x8b01,
1124 0xd472, (go->board_info->sensor_flags &
1125 GO7007_SENSOR_TV) &&
1126 (!go->interlace_coding) ?
1127 0x01b0 : 0x0170,
1128 0xd475, (go->board_info->sensor_flags &
1129 GO7007_SENSOR_TV) &&
1130 (!go->interlace_coding) ?
1131 0x0008 : 0x0009,
1132 0xc404, go->interlace_coding ? 0x44 :
1133 (go->format == GO7007_FORMAT_MPEG4 ? 0x11 :
1134 (go->format == GO7007_FORMAT_MPEG1 ? 0x02 :
1135 (go->format == GO7007_FORMAT_MPEG2 ? 0x04 :
1136 (go->format == GO7007_FORMAT_H263 ? 0x08 :
1137 0x20)))),
1138 0xbf0a, (go->format == GO7007_FORMAT_MPEG4 ? 8 :
1139 (go->format == GO7007_FORMAT_MPEG1 ? 1 :
1140 (go->format == GO7007_FORMAT_MPEG2 ? 2 :
1141 (go->format == GO7007_FORMAT_H263 ? 4 : 16)))) |
1142 ((go->repeat_seqhead ? 1 : 0) << 6) |
1143 ((go->dvd_mode ? 1 : 0) << 9) |
1144 ((go->gop_header_enable ? 1 : 0) << 10),
1145 0xbf0b, 0,
1146 0xdd5a, go->ipb ? 0x14 : 0x0a,
1147 0xbf0c, 0,
1148 0xbf0d, 0,
1149 0xc683, THACCoeffSet0,
1150 0xc40a, (go->width << 4) | rows,
1151 0xe01a, go->board_info->hpi_buffer_cap,
1152 0, 0,
1153 0, 0,
1154
1155 0x2008, 0,
1156 0xe402, 0x88,
1157 0xe401, 0x8f01,
1158 0xbf6a, 0,
1159 0xbf6b, 0,
1160 0xbf6c, 0,
1161 0xbf6d, 0,
1162 0xbf6e, 0,
1163 0xbf6f, 0,
1164 0, 0,
1165 0, 0,
1166 0, 0,
1167 0, 0,
1168 0, 0,
1169 0, 0,
1170 0, 0,
1171
1172 0x200e, 0,
1173 0xbf66, brc_window_size,
1174 0xbf67, 0,
1175 0xbf68, q_min,
1176 0xbf69, q_max,
1177 0xbfe0, 0,
1178 0xbfe1, 0,
1179 0xbfe2, 0,
1180 0xbfe3, go->ipb ? 3 : 1,
1181 0xc031, go->board_info->sensor_flags &
1182 GO7007_SENSOR_VBI ? 1 : 0,
1183 0xc01c, 0x1f,
1184 0xdd8c, 0x15,
1185 0xdd94, 0x15,
1186 0xdd88, go->ipb ? 0x1401 : 0x0a01,
1187 0xdd90, go->ipb ? 0x1401 : 0x0a01,
1188 0, 0,
1189
1190 0x200e, 0,
1191 0xbfe4, 0,
1192 0xbfe5, 0,
1193 0xbfe6, 0,
1194 0xbfe7, fps << 8,
1195 0xbfe8, 0x3a00,
1196 0xbfe9, 0,
1197 0xbfea, 0,
1198 0xbfeb, 0,
1199 0xbfec, (go->interlace_coding ? 1 << 15 : 0) |
1200 (go->modet_enable ? 0xa : 0) |
1201 (go->board_info->sensor_flags &
1202 GO7007_SENSOR_VBI ? 1 : 0),
1203 0xbfed, 0,
1204 0xbfee, 0,
1205 0xbfef, 0,
1206 0xbff0, go->board_info->sensor_flags &
1207 GO7007_SENSOR_TV ? 0xf060 : 0xb060,
1208 0xbff1, 0,
1209 0, 0,
1210 };
1211
1212 return copy_packages(code, pack, 5, space);
1213 }
1214
1215 static int seqhead_to_package(struct go7007 *go, __le16 *code, int space,
1216 int (*sequence_header_func)(struct go7007 *go,
1217 unsigned char *buf, int ext))
1218 {
1219 int vop_time_increment_bitlength = vti_bitlen(go);
1220 int fps = go->sensor_framerate / go->fps_scale *
1221 (go->interlace_coding ? 2 : 1);
1222 unsigned char buf[40] = { };
1223 int len = sequence_header_func(go, buf, 1);
1224 u16 pack[] = {
1225 0x2006, 0,
1226 0xbf08, fps,
1227 0xbf09, 0,
1228 0xbff2, vop_time_increment_bitlength,
1229 0xbff3, (1 << vop_time_increment_bitlength) - 1,
1230 0xbfe6, 0,
1231 0xbfe7, (fps / 1000) << 8,
1232 0, 0,
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 0x2007, 0,
1243 0xc800, buf[2] << 8 | buf[3],
1244 0xc801, buf[4] << 8 | buf[5],
1245 0xc802, buf[6] << 8 | buf[7],
1246 0xc803, buf[8] << 8 | buf[9],
1247 0xc406, 64,
1248 0xc407, len - 64,
1249 0xc61b, 1,
1250 0, 0,
1251 0, 0,
1252 0, 0,
1253 0, 0,
1254 0, 0,
1255 0, 0,
1256 0, 0,
1257 0, 0,
1258
1259 0x200e, 0,
1260 0xc808, buf[10] << 8 | buf[11],
1261 0xc809, buf[12] << 8 | buf[13],
1262 0xc80a, buf[14] << 8 | buf[15],
1263 0xc80b, buf[16] << 8 | buf[17],
1264 0xc80c, buf[18] << 8 | buf[19],
1265 0xc80d, buf[20] << 8 | buf[21],
1266 0xc80e, buf[22] << 8 | buf[23],
1267 0xc80f, buf[24] << 8 | buf[25],
1268 0xc810, buf[26] << 8 | buf[27],
1269 0xc811, buf[28] << 8 | buf[29],
1270 0xc812, buf[30] << 8 | buf[31],
1271 0xc813, buf[32] << 8 | buf[33],
1272 0xc814, buf[34] << 8 | buf[35],
1273 0xc815, buf[36] << 8 | buf[37],
1274 0, 0,
1275 0, 0,
1276 0, 0,
1277 };
1278
1279 return copy_packages(code, pack, 3, space);
1280 }
1281
1282 static int relative_prime(int big, int little)
1283 {
1284 int remainder;
1285
1286 while (little != 0) {
1287 remainder = big % little;
1288 big = little;
1289 little = remainder;
1290 }
1291 return big;
1292 }
1293
1294 static int avsync_to_package(struct go7007 *go, __le16 *code, int space)
1295 {
1296 int arate = go->board_info->audio_rate * 1001 * go->fps_scale;
1297 int ratio = arate / go->sensor_framerate;
1298 int adjratio = ratio * 215 / 100;
1299 int rprime = relative_prime(go->sensor_framerate,
1300 arate % go->sensor_framerate);
1301 int f1 = (arate % go->sensor_framerate) / rprime;
1302 int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime;
1303 u16 pack[] = {
1304 0x200e, 0,
1305 0xbf98, (u16)((-adjratio) & 0xffff),
1306 0xbf99, (u16)((-adjratio) >> 16),
1307 0xbf92, 0,
1308 0xbf93, 0,
1309 0xbff4, f1 > f2 ? f1 : f2,
1310 0xbff5, f1 < f2 ? f1 : f2,
1311 0xbff6, f1 < f2 ? ratio : ratio + 1,
1312 0xbff7, f1 > f2 ? ratio : ratio + 1,
1313 0xbff8, 0,
1314 0xbff9, 0,
1315 0xbffa, adjratio & 0xffff,
1316 0xbffb, adjratio >> 16,
1317 0xbf94, 0,
1318 0xbf95, 0,
1319 0, 0,
1320 };
1321
1322 return copy_packages(code, pack, 1, space);
1323 }
1324
1325 static int final_package(struct go7007 *go, __le16 *code, int space)
1326 {
1327 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1328 u16 pack[] = {
1329 0x8000,
1330 0,
1331 0,
1332 0,
1333 0,
1334 0,
1335 0,
1336 2,
1337 ((go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
1338 (!go->interlace_coding) ?
1339 (1 << 14) | (1 << 9) : 0) |
1340 ((go->encoder_subsample ? 1 : 0) << 8) |
1341 (go->board_info->sensor_flags &
1342 GO7007_SENSOR_CONFIG_MASK),
1343 ((go->encoder_v_halve ? 1 : 0) << 14) |
1344 (go->encoder_v_halve ? rows << 9 : rows << 8) |
1345 (go->encoder_h_halve ? 1 << 6 : 0) |
1346 (go->encoder_h_halve ? go->width >> 3 : go->width >> 4),
1347 (1 << 15) | (go->encoder_v_offset << 6) |
1348 (1 << 7) | (go->encoder_h_offset >> 2),
1349 (1 << 6),
1350 0,
1351 0,
1352 ((go->fps_scale - 1) << 8) |
1353 (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
1354 (1 << 7) : 0) |
1355 0x41,
1356 go->ipb ? 0xd4c : 0x36b,
1357 (rows << 8) | (go->width >> 4),
1358 go->format == GO7007_FORMAT_MPEG4 ? 0x0404 : 0,
1359 (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) |
1360 ((go->closed_gop ? 1 : 0) << 12) |
1361 ((go->format == GO7007_FORMAT_MPEG4 ? 1 : 0) << 11) |
1362 /* (1 << 9) | */
1363 ((go->ipb ? 3 : 0) << 7) |
1364 ((go->modet_enable ? 1 : 0) << 2) |
1365 ((go->dvd_mode ? 1 : 0) << 1) | 1,
1366 (go->format == GO7007_FORMAT_MPEG1 ? 0x89a0 :
1367 (go->format == GO7007_FORMAT_MPEG2 ? 0x89a0 :
1368 (go->format == GO7007_FORMAT_MJPEG ? 0x89a0 :
1369 (go->format == GO7007_FORMAT_MPEG4 ? 0x8920 :
1370 (go->format == GO7007_FORMAT_H263 ? 0x8920 : 0))))),
1371 go->ipb ? 0x1f15 : 0x1f0b,
1372 go->ipb ? 0x0015 : 0x000b,
1373 go->ipb ? 0xa800 : 0x5800,
1374 0xffff,
1375 0x0020 + 0x034b * 0,
1376 0x0020 + 0x034b * 1,
1377 0x0020 + 0x034b * 2,
1378 0x0020 + 0x034b * 3,
1379 0x0020 + 0x034b * 4,
1380 0x0020 + 0x034b * 5,
1381 go->ipb ? (go->gop_size / 3) : go->gop_size,
1382 (go->height >> 4) * (go->width >> 4) * 110 / 100,
1383 };
1384
1385 return copy_packages(code, pack, 1, space);
1386 }
1387
1388 static int audio_to_package(struct go7007 *go, __le16 *code, int space)
1389 {
1390 int clock_config = ((go->board_info->audio_flags &
1391 GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) |
1392 ((go->board_info->audio_flags &
1393 GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) |
1394 (((go->board_info->audio_bclk_div / 4) - 1) << 4) |
1395 (go->board_info->audio_main_div - 1);
1396 u16 pack[] = {
1397 0x200d, 0,
1398 0x9002, 0,
1399 0x9002, 0,
1400 0x9031, 0,
1401 0x9032, 0,
1402 0x9033, 0,
1403 0x9034, 0,
1404 0x9035, 0,
1405 0x9036, 0,
1406 0x9037, 0,
1407 0x9040, 0,
1408 0x9000, clock_config,
1409 0x9001, (go->board_info->audio_flags & 0xffff) |
1410 (1 << 9),
1411 0x9000, ((go->board_info->audio_flags &
1412 GO7007_AUDIO_I2S_MASTER ?
1413 1 : 0) << 10) |
1414 clock_config,
1415 0, 0,
1416 0, 0,
1417 0x2005, 0,
1418 0x9041, 0,
1419 0x9042, 256,
1420 0x9043, 0,
1421 0x9044, 16,
1422 0x9045, 16,
1423 0, 0,
1424 0, 0,
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 };
1434
1435 return copy_packages(code, pack, 2, space);
1436 }
1437
1438 static int modet_to_package(struct go7007 *go, __le16 *code, int space)
1439 {
1440 int ret, mb, i, addr, cnt = 0;
1441 u16 pack[32];
1442 u16 thresholds[] = {
1443 0x200e, 0,
1444 0xbf82, go->modet[0].pixel_threshold,
1445 0xbf83, go->modet[1].pixel_threshold,
1446 0xbf84, go->modet[2].pixel_threshold,
1447 0xbf85, go->modet[3].pixel_threshold,
1448 0xbf86, go->modet[0].motion_threshold,
1449 0xbf87, go->modet[1].motion_threshold,
1450 0xbf88, go->modet[2].motion_threshold,
1451 0xbf89, go->modet[3].motion_threshold,
1452 0xbf8a, go->modet[0].mb_threshold,
1453 0xbf8b, go->modet[1].mb_threshold,
1454 0xbf8c, go->modet[2].mb_threshold,
1455 0xbf8d, go->modet[3].mb_threshold,
1456 0xbf8e, 0,
1457 0xbf8f, 0,
1458 0, 0,
1459 };
1460
1461 ret = copy_packages(code, thresholds, 1, space);
1462 if (ret < 0)
1463 return -1;
1464 cnt += ret;
1465
1466 addr = 0xbac0;
1467 memset(pack, 0, 64);
1468 i = 0;
1469 for (mb = 0; mb < 1624; ++mb) {
1470 pack[i * 2 + 3] <<= 2;
1471 pack[i * 2 + 3] |= go->modet_map[mb];
1472 if (mb % 8 != 7)
1473 continue;
1474 pack[i * 2 + 2] = addr++;
1475 ++i;
1476 if (i == 10 || mb == 1623) {
1477 pack[0] = 0x2000 | i;
1478 ret = copy_packages(code + cnt, pack, 1, space - cnt);
1479 if (ret < 0)
1480 return -1;
1481 cnt += ret;
1482 i = 0;
1483 memset(pack, 0, 64);
1484 }
1485 pack[i * 2 + 3] = 0;
1486 }
1487
1488 memset(pack, 0, 64);
1489 i = 0;
1490 for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
1491 pack[i * 2 + 2] = addr;
1492 pack[i * 2 + 3] = 0;
1493 ++i;
1494 if (i == 10 || addr == 0xbbf9) {
1495 pack[0] = 0x2000 | i;
1496 ret = copy_packages(code + cnt, pack, 1, space - cnt);
1497 if (ret < 0)
1498 return -1;
1499 cnt += ret;
1500 i = 0;
1501 memset(pack, 0, 64);
1502 }
1503 }
1504 return cnt;
1505 }
1506
1507 static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
1508 int *framelen)
1509 {
1510 switch (type) {
1511 case SPECIAL_FRM_HEAD:
1512 switch (go->format) {
1513 case GO7007_FORMAT_MJPEG:
1514 return gen_mjpeghdr_to_package(go, code, space);
1515 case GO7007_FORMAT_MPEG1:
1516 case GO7007_FORMAT_MPEG2:
1517 return gen_mpeg1hdr_to_package(go, code, space,
1518 framelen);
1519 case GO7007_FORMAT_MPEG4:
1520 return gen_mpeg4hdr_to_package(go, code, space,
1521 framelen);
1522 }
1523 case SPECIAL_BRC_CTRL:
1524 return brctrl_to_package(go, code, space, framelen);
1525 case SPECIAL_CONFIG:
1526 return config_package(go, code, space);
1527 case SPECIAL_SEQHEAD:
1528 switch (go->format) {
1529 case GO7007_FORMAT_MPEG1:
1530 case GO7007_FORMAT_MPEG2:
1531 return seqhead_to_package(go, code, space,
1532 mpeg1_sequence_header);
1533 case GO7007_FORMAT_MPEG4:
1534 return seqhead_to_package(go, code, space,
1535 mpeg4_sequence_header);
1536 default:
1537 return 0;
1538 }
1539 case SPECIAL_AV_SYNC:
1540 return avsync_to_package(go, code, space);
1541 case SPECIAL_FINAL:
1542 return final_package(go, code, space);
1543 case SPECIAL_AUDIO:
1544 return audio_to_package(go, code, space);
1545 case SPECIAL_MODET:
1546 return modet_to_package(go, code, space);
1547 }
1548 printk(KERN_ERR
1549 "go7007: firmware file contains unsupported feature %04x\n",
1550 type);
1551 return -1;
1552 }
1553
1554 int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
1555 {
1556 const struct firmware *fw_entry;
1557 __le16 *code, *src;
1558 int framelen[8] = { }; /* holds the lengths of empty frame templates */
1559 int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
1560 int mode_flag;
1561 int ret;
1562
1563 switch (go->format) {
1564 case GO7007_FORMAT_MJPEG:
1565 mode_flag = FLAG_MODE_MJPEG;
1566 break;
1567 case GO7007_FORMAT_MPEG1:
1568 mode_flag = FLAG_MODE_MPEG1;
1569 break;
1570 case GO7007_FORMAT_MPEG2:
1571 mode_flag = FLAG_MODE_MPEG2;
1572 break;
1573 case GO7007_FORMAT_MPEG4:
1574 mode_flag = FLAG_MODE_MPEG4;
1575 break;
1576 default:
1577 return -1;
1578 }
1579 if (request_firmware(&fw_entry, go->board_info->firmware, go->dev)) {
1580 printk(KERN_ERR
1581 "go7007: unable to load firmware from file \"%s\"\n",
1582 go->board_info->firmware);
1583 return -1;
1584 }
1585 code = kzalloc(codespace * 2, GFP_KERNEL);
1586 if (code == NULL) {
1587 printk(KERN_ERR "go7007: unable to allocate %d bytes for "
1588 "firmware construction\n", codespace * 2);
1589 goto fw_failed;
1590 }
1591 src = (__le16 *)fw_entry->data;
1592 srclen = fw_entry->size / 2;
1593 while (srclen >= 2) {
1594 chunk_flags = __le16_to_cpu(src[0]);
1595 chunk_len = __le16_to_cpu(src[1]);
1596 if (chunk_len + 2 > srclen) {
1597 printk(KERN_ERR "go7007: firmware file \"%s\" "
1598 "appears to be corrupted\n",
1599 go->board_info->firmware);
1600 goto fw_failed;
1601 }
1602 if (chunk_flags & mode_flag) {
1603 if (chunk_flags & FLAG_SPECIAL) {
1604 ret = do_special(go, __le16_to_cpu(src[2]),
1605 &code[i], codespace - i, framelen);
1606 if (ret < 0) {
1607 printk(KERN_ERR "go7007: insufficient "
1608 "memory for firmware "
1609 "construction\n");
1610 goto fw_failed;
1611 }
1612 i += ret;
1613 } else {
1614 if (codespace - i < chunk_len) {
1615 printk(KERN_ERR "go7007: insufficient "
1616 "memory for firmware "
1617 "construction\n");
1618 goto fw_failed;
1619 }
1620 memcpy(&code[i], &src[2], chunk_len * 2);
1621 i += chunk_len;
1622 }
1623 }
1624 srclen -= chunk_len + 2;
1625 src += chunk_len + 2;
1626 }
1627 release_firmware(fw_entry);
1628 *fw = (u8 *)code;
1629 *fwlen = i * 2;
1630 return 0;
1631
1632 fw_failed:
1633 kfree(code);
1634 release_firmware(fw_entry);
1635 return -1;
1636 }
linux-next