Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
go7007-fw.c
Go to the documentation of this file.
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 }
Generated on Thu Jan 10 2013 14:29:23 for Linux Kernel by   doxygen 1.8.2