2 * Copyright (C) 2005-2006 Micronas USA Inc.
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.
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.
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.
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.
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/time.h>
31 #include <linux/device.h>
32 #include <linux/i2c.h>
33 #include <linux/firmware.h>
34 #include <asm/byteorder.h>
36 #include "go7007-priv.h"
38 /* Constants used in the source firmware image to describe code segments */
40 #define FLAG_MODE_MJPEG (1)
41 #define FLAG_MODE_MPEG1 (1<<1)
42 #define FLAG_MODE_MPEG2 (1<<2)
43 #define FLAG_MODE_MPEG4 (1<<3)
44 #define FLAG_MODE_H263 (1<<4)
45 #define FLAG_MODE_ALL (FLAG_MODE_MJPEG | FLAG_MODE_MPEG1 | \
46 FLAG_MODE_MPEG2 | FLAG_MODE_MPEG4 | \
48 #define FLAG_SPECIAL (1<<8)
50 #define SPECIAL_FRM_HEAD 0
51 #define SPECIAL_BRC_CTRL 1
52 #define SPECIAL_CONFIG 2
53 #define SPECIAL_SEQHEAD 3
54 #define SPECIAL_AV_SYNC 4
55 #define SPECIAL_FINAL 5
56 #define SPECIAL_AUDIO 6
57 #define SPECIAL_MODET 7
59 /* Little data class for creating MPEG headers bit-by-bit */
62 unsigned char *p; /* destination */
63 u32 a; /* collects bits at the top of the variable */
64 int b; /* bit position of most recently-written bit */
65 int len; /* written out so far */
68 #define CODE_GEN(name, dest) struct code_gen name = { dest, 0, 32, 0 }
70 #define CODE_ADD(name, val, length) do { \
72 name.a |= (val) << name.b; \
73 while (name.b <= 24) { \
74 *name.p = name.a >> 24; \
82 #define CODE_LENGTH(name) (name.len + (32 - name.b))
84 /* Tables for creating the bitrate control data */
86 static const s16 converge_speed_ip[101] = {
87 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
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, 2,
91 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
92 3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
93 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
94 9, 10, 10, 11, 12, 13, 14, 15, 16, 17,
95 19, 20, 22, 23, 25, 27, 30, 32, 35, 38,
96 41, 45, 49, 53, 58, 63, 69, 76, 83, 91,
100 static const s16 converge_speed_ipb[101] = {
101 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
102 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
103 3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
104 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
105 6, 6, 6, 7, 7, 7, 7, 8, 8, 9,
106 9, 9, 10, 10, 11, 12, 12, 13, 14, 14,
107 15, 16, 17, 18, 19, 20, 22, 23, 25, 26,
108 28, 30, 32, 34, 37, 40, 42, 46, 49, 53,
109 57, 61, 66, 71, 77, 83, 90, 97, 106, 115,
110 125, 135, 147, 161, 175, 191, 209, 228, 249, 273,
114 static const s16 LAMBDA_table[4][101] = {
115 { 16, 16, 16, 16, 17, 17, 17, 18, 18, 18,
116 19, 19, 19, 20, 20, 20, 21, 21, 22, 22,
117 22, 23, 23, 24, 24, 25, 25, 25, 26, 26,
118 27, 27, 28, 28, 29, 29, 30, 31, 31, 32,
119 32, 33, 33, 34, 35, 35, 36, 37, 37, 38,
120 39, 39, 40, 41, 42, 42, 43, 44, 45, 46,
121 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
122 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
123 67, 68, 69, 70, 72, 73, 74, 76, 77, 78,
124 80, 81, 83, 84, 86, 87, 89, 90, 92, 94,
128 20, 20, 20, 21, 21, 21, 22, 22, 23, 23,
129 23, 24, 24, 25, 25, 26, 26, 27, 27, 28,
130 28, 29, 29, 30, 30, 31, 31, 32, 33, 33,
131 34, 34, 35, 36, 36, 37, 38, 38, 39, 40,
132 40, 41, 42, 43, 43, 44, 45, 46, 47, 48,
133 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
134 58, 59, 60, 61, 62, 64, 65, 66, 67, 68,
135 70, 71, 72, 73, 75, 76, 78, 79, 80, 82,
136 83, 85, 86, 88, 90, 91, 93, 95, 96, 98,
137 100, 102, 103, 105, 107, 109, 111, 113, 115, 117,
141 24, 24, 24, 25, 25, 26, 26, 27, 27, 28,
142 28, 29, 29, 30, 30, 31, 31, 32, 33, 33,
143 34, 34, 35, 36, 36, 37, 38, 38, 39, 40,
144 41, 41, 42, 43, 44, 44, 45, 46, 47, 48,
145 49, 50, 50, 51, 52, 53, 54, 55, 56, 57,
146 58, 59, 60, 62, 63, 64, 65, 66, 67, 69,
147 70, 71, 72, 74, 75, 76, 78, 79, 81, 82,
148 84, 85, 87, 88, 90, 92, 93, 95, 97, 98,
149 100, 102, 104, 106, 108, 110, 112, 114, 116, 118,
150 120, 122, 124, 127, 129, 131, 134, 136, 138, 141,
154 32, 32, 33, 33, 34, 34, 35, 36, 36, 37,
155 38, 38, 39, 40, 41, 41, 42, 43, 44, 44,
156 45, 46, 47, 48, 49, 50, 50, 51, 52, 53,
157 54, 55, 56, 57, 58, 59, 60, 62, 63, 64,
158 65, 66, 67, 69, 70, 71, 72, 74, 75, 76,
159 78, 79, 81, 82, 84, 85, 87, 88, 90, 92,
160 93, 95, 97, 98, 100, 102, 104, 106, 108, 110,
161 112, 114, 116, 118, 120, 122, 124, 127, 129, 131,
162 134, 136, 139, 141, 144, 146, 149, 152, 154, 157,
163 160, 163, 166, 169, 172, 175, 178, 181, 185, 188,
168 /* MPEG blank frame generation tables */
170 enum mpeg_frame_type {
178 static const u32 addrinctab[33][2] = {
179 { 0x01, 1 }, { 0x03, 3 }, { 0x02, 3 }, { 0x03, 4 },
180 { 0x02, 4 }, { 0x03, 5 }, { 0x02, 5 }, { 0x07, 7 },
181 { 0x06, 7 }, { 0x0b, 8 }, { 0x0a, 8 }, { 0x09, 8 },
182 { 0x08, 8 }, { 0x07, 8 }, { 0x06, 8 }, { 0x17, 10 },
183 { 0x16, 10 }, { 0x15, 10 }, { 0x14, 10 }, { 0x13, 10 },
184 { 0x12, 10 }, { 0x23, 11 }, { 0x22, 11 }, { 0x21, 11 },
185 { 0x20, 11 }, { 0x1f, 11 }, { 0x1e, 11 }, { 0x1d, 11 },
186 { 0x1c, 11 }, { 0x1b, 11 }, { 0x1a, 11 }, { 0x19, 11 },
190 /* Standard JPEG tables */
192 static const u8 default_intra_quant_table[] = {
193 8, 16, 19, 22, 26, 27, 29, 34,
194 16, 16, 22, 24, 27, 29, 34, 37,
195 19, 22, 26, 27, 29, 34, 34, 38,
196 22, 22, 26, 27, 29, 34, 37, 40,
197 22, 26, 27, 29, 32, 35, 40, 48,
198 26, 27, 29, 32, 35, 40, 48, 58,
199 26, 27, 29, 34, 38, 46, 56, 69,
200 27, 29, 35, 38, 46, 56, 69, 83
203 static const u8 bits_dc_luminance[] = {
204 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
207 static const u8 val_dc_luminance[] = {
208 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
211 static const u8 bits_dc_chrominance[] = {
212 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
215 static const u8 val_dc_chrominance[] = {
216 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
219 static const u8 bits_ac_luminance[] = {
220 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
223 static const u8 val_ac_luminance[] = {
224 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
225 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
226 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
227 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
228 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
229 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
230 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
231 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
232 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
233 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
234 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
235 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
236 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
237 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
238 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
239 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
240 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
241 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
242 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
243 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
247 static const u8 bits_ac_chrominance[] = {
248 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
251 static const u8 val_ac_chrominance[] = {
252 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
253 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
254 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
255 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
256 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
257 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
258 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
259 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
260 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
261 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
262 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
263 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
264 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
265 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
266 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
267 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
268 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
269 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
270 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
271 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
275 /* Zig-zag mapping for quant table
277 * OK, let's do this mapping on the actual table above so it doesn't have
278 * to be done on the fly.
280 static const int zz[64] = {
281 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
282 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
283 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
284 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
287 static int copy_packages(__le16 *dest, u16 *src, int pkg_cnt, int space)
289 int i, cnt = pkg_cnt * 32;
294 for (i = 0; i < cnt; ++i)
295 dest[i] = cpu_to_le16p(src + i);
300 static int mjpeg_frame_header(struct go7007 *go, unsigned char *buf, int q)
311 buf[p++] = default_intra_quant_table[0];
312 for (i = 1; i < 64; ++i)
313 /* buf[p++] = (default_intra_quant_table[i] * q) >> 3; */
314 buf[p++] = (default_intra_quant_table[zz[i]] * q) >> 3;
320 buf[p++] = go->height >> 8;
321 buf[p++] = go->height & 0xff;
322 buf[p++] = go->width >> 8;
323 buf[p++] = go->width & 0xff;
337 buf[p++] = 418 & 0xff;
339 memcpy(buf + p, bits_dc_luminance + 1, 16);
341 memcpy(buf + p, val_dc_luminance, sizeof(val_dc_luminance));
342 p += sizeof(val_dc_luminance);
344 memcpy(buf + p, bits_dc_chrominance + 1, 16);
346 memcpy(buf + p, val_dc_chrominance, sizeof(val_dc_chrominance));
347 p += sizeof(val_dc_chrominance);
349 memcpy(buf + p, bits_ac_luminance + 1, 16);
351 memcpy(buf + p, val_ac_luminance, sizeof(val_ac_luminance));
352 p += sizeof(val_ac_luminance);
354 memcpy(buf + p, bits_ac_chrominance + 1, 16);
356 memcpy(buf + p, val_ac_chrominance, sizeof(val_ac_chrominance));
357 p += sizeof(val_ac_chrominance);
375 static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *code, int space)
379 unsigned int addr = 0x19;
380 int size = 0, i, off = 0, chunk;
382 buf = kmalloc(4096, GFP_KERNEL);
384 printk(KERN_ERR "go7007: unable to allocate 4096 bytes for "
385 "firmware construction\n");
388 memset(buf, 0, 4096);
390 for (i = 1; i < 32; ++i) {
391 mjpeg_frame_header(go, buf + size, i);
394 chunk = mjpeg_frame_header(go, buf + size, 1);
395 memmove(buf + size, buf + size + 80, chunk - 80);
398 for (i = 0; i < size; i += chunk * 2) {
399 if (space - off < 32) {
404 code[off + 1] = __cpu_to_le16(0x8000 | mem);
407 if (mem + chunk > 0x4000)
408 chunk = 0x4000 - mem;
409 if (i + 2 * chunk > size)
410 chunk = (size - i) / 2;
413 code[off] = __cpu_to_le16(0x4000 | chunk);
414 code[off + 31] = __cpu_to_le16(addr++);
417 code[off] = __cpu_to_le16(0x1000 | 28);
422 memcpy(&code[off + 2], buf + i, chunk * 2);
430 static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf,
431 int modulo, int pict_struct, enum mpeg_frame_type frame)
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);
454 default: /* keep the compiler happy */
455 mb_code = mb_len = 0;
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);
463 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
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);
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);
480 CODE_ADD(c, 0x000, 11);
482 CODE_ADD(c, 0x200, 11);
485 CODE_ADD(c, 0x20c, 11);
487 /* Byte-align with zeros */
488 j = 8 - (CODE_LENGTH(c) % 8);
493 for (i = 0; i < rows; ++i) {
495 CODE_ADD(c, i + 1, 8);
498 CODE_ADD(c, mb_code, mb_len);
499 if (go->interlace_coding) {
501 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
503 if (frame == BFRAME_BIDIR) {
505 if (go->interlace_coding)
506 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
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) {
515 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
517 if (frame == BFRAME_BIDIR) {
519 if (go->interlace_coding)
520 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
524 /* Byte-align with zeros */
525 j = 8 - (CODE_LENGTH(c) % 8);
530 i = CODE_LENGTH(c) + 4 * 8;
538 static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
540 int i, aspect_ratio, picture_rate;
541 CODE_GEN(c, buf + 6);
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;
548 case GO7007_RATIO_16_9:
549 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
556 switch (go->aspect_ratio) {
557 case GO7007_RATIO_4_3:
560 case GO7007_RATIO_16_9:
568 switch (go->sensor_framerate) {
576 picture_rate = go->interlace_coding ? 6 : 3;
579 picture_rate = go->interlace_coding ? 7 : 4;
582 picture_rate = go->interlace_coding ? 8 : 5;
585 picture_rate = 5; /* 30 fps seems like a reasonable default */
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);
595 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 112 : 20, 10);
598 /* Byte-align with zeros */
599 i = 8 - (CODE_LENGTH(c) % 8);
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);
610 CODE_ADD(c, 0xa0001, 20);
613 /* Byte-align with zeros */
614 i = 8 - (CODE_LENGTH(c) % 8);
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);
626 CODE_ADD(c, go->height, 14);
628 /* Byte-align with zeros */
629 i = 8 - (CODE_LENGTH(c) % 8);
635 i = CODE_LENGTH(c) + 4 * 8;
645 static int gen_mpeg1hdr_to_package(struct go7007 *go,
646 __le16 *code, int space, int *framelen)
650 unsigned int addr = 0x19;
651 int i, off = 0, chunk;
653 buf = kmalloc(5120, GFP_KERNEL);
655 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
656 "firmware construction\n");
659 memset(buf, 0, 5120);
660 framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME);
661 if (go->interlace_coding)
662 framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8,
664 buf[0] = framelen[0] & 0xff;
665 buf[1] = framelen[0] >> 8;
667 framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE);
668 if (go->interlace_coding)
669 framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8,
671 buf[i] = framelen[1] & 0xff;
672 buf[i + 1] = framelen[1] >> 8;
674 framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST);
675 if (go->interlace_coding)
676 framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8,
678 buf[i] = framelen[2] & 0xff;
679 buf[i + 1] = framelen[2] >> 8;
681 framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR);
682 if (go->interlace_coding)
683 framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8,
685 buf[i] = framelen[3] & 0xff;
686 buf[i + 1] = framelen[3] >> 8;
688 mpeg1_sequence_header(go, buf + i, 0);
690 for (i = 0; i < 5120; i += chunk * 2) {
691 if (space - off < 32) {
696 code[off + 1] = __cpu_to_le16(0x8000 | mem);
699 if (mem + chunk > 0x4000)
700 chunk = 0x4000 - mem;
701 if (i + 2 * chunk > 5120)
702 chunk = (5120 - i) / 2;
705 code[off] = __cpu_to_le16(0x4000 | chunk);
706 code[off + 31] = __cpu_to_le16(addr);
707 if (mem + chunk == 0x4000) {
712 code[off] = __cpu_to_le16(0x1000 | 28);
717 memcpy(&code[off + 2], buf + i, chunk * 2);
725 static int vti_bitlen(struct go7007 *go)
727 unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
729 for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i);
733 static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
734 int modulo, enum mpeg_frame_type frame)
737 CODE_GEN(c, buf + 6);
738 int mb_count = (go->width >> 4) * (go->height >> 4);
740 CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
744 CODE_ADD(c, 0, vti_bitlen(go));
748 CODE_ADD(c, 0xc, 11);
751 if (frame != BFRAME_EMPTY) {
752 for (i = 0; i < mb_count; ++i) {
758 CODE_ADD(c, 0x47, 8);
761 CODE_ADD(c, 0x27, 7);
764 CODE_ADD(c, 0x5f, 8);
766 case BFRAME_EMPTY: /* keep compiler quiet */
772 /* Byte-align with a zero followed by ones */
773 i = 8 - (CODE_LENGTH(c) % 8);
775 CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
777 i = CODE_LENGTH(c) + 4 * 8;
787 static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
789 const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali,
790 0x00, 0x00, 0x01, 0xb5, 0x09,
791 0x00, 0x00, 0x01, 0x00,
792 0x00, 0x00, 0x01, 0x20, };
794 int fps = go->sensor_framerate / go->fps_scale;
795 CODE_GEN(c, buf + 2 + sizeof(head));
797 switch (go->aspect_ratio) {
798 case GO7007_RATIO_4_3:
799 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
801 case GO7007_RATIO_16_9:
802 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
809 memcpy(buf + 2, head, sizeof(head));
810 CODE_ADD(c, 0x191, 17);
811 CODE_ADD(c, aspect_ratio, 4);
813 CODE_ADD(c, fps, 16);
815 CODE_ADD(c, 1001, vti_bitlen(go));
817 CODE_ADD(c, go->width, 13);
819 CODE_ADD(c, go->height, 13);
820 CODE_ADD(c, 0x2830, 14);
823 i = 8 - (CODE_LENGTH(c) % 8);
825 CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
827 i = CODE_LENGTH(c) + sizeof(head) * 8;
833 static int gen_mpeg4hdr_to_package(struct go7007 *go,
834 __le16 *code, int space, int *framelen)
838 unsigned int addr = 0x19;
839 int i, off = 0, chunk;
841 buf = kmalloc(5120, GFP_KERNEL);
843 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
844 "firmware construction\n");
847 memset(buf, 0, 5120);
848 framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
850 framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
852 framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
854 framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
856 mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
858 mpeg4_sequence_header(go, buf + i, 0);
860 for (i = 0; i < 5120; i += chunk * 2) {
861 if (space - off < 32) {
866 code[off + 1] = __cpu_to_le16(0x8000 | mem);
869 if (mem + chunk > 0x4000)
870 chunk = 0x4000 - mem;
871 if (i + 2 * chunk > 5120)
872 chunk = (5120 - i) / 2;
875 code[off] = __cpu_to_le16(0x4000 | chunk);
876 code[off + 31] = __cpu_to_le16(addr);
877 if (mem + chunk == 0x4000) {
882 code[off] = __cpu_to_le16(0x1000 | 28);
887 memcpy(&code[off + 2], buf + i, chunk * 2);
891 addr = go->ipb ? 0x14f9 : 0x0af9;
892 memset(buf, 0, 5120);
893 framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
895 framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
897 framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
899 framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
901 mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
903 for (i = 0; i < 5120; i += chunk * 2) {
904 if (space - off < 32) {
909 code[off + 1] = __cpu_to_le16(0x8000 | mem);
912 if (mem + chunk > 0x4000)
913 chunk = 0x4000 - mem;
914 if (i + 2 * chunk > 5120)
915 chunk = (5120 - i) / 2;
918 code[off] = __cpu_to_le16(0x4000 | chunk);
919 code[off + 31] = __cpu_to_le16(addr);
920 if (mem + chunk == 0x4000) {
925 code[off] = __cpu_to_le16(0x1000 | 28);
930 memcpy(&code[off + 2], buf + i, chunk * 2);
938 static int brctrl_to_package(struct go7007 *go,
939 __le16 *code, int space, int *framelen)
941 int converge_speed = 0;
942 int lambda = (go->format == GO7007_FORMAT_MJPEG || go->dvd_mode) ?
944 int peak_rate = 6 * go->bitrate / 5;
945 int vbv_buffer = go->format == GO7007_FORMAT_MJPEG ?
947 (go->dvd_mode ? 900000 : peak_rate);
948 int fps = go->sensor_framerate / go->fps_scale;
950 /* Bizarre math below depends on rounding errors in division */
951 u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps;
952 u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps;
953 u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000);
954 u32 vbv_alert_addr = vbv_buffer * 3 / (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 q > 0 ? sgop_expt_addr * q :
963 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
965 u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
968 0xBF20, go->ipb ? converge_speed_ipb[converge_speed]
969 : converge_speed_ip[converge_speed],
970 0xBF21, go->ipb ? 2 : 0,
971 0xBF22, go->ipb ? LAMBDA_table[0][lambda / 2 + 50]
973 0xBF23, go->ipb ? LAMBDA_table[1][lambda] : 32767,
975 0xBF25, lambda > 99 ? 32767 : LAMBDA_table[3][lambda],
976 0xBF26, sgop_expt_addr & 0x0000FFFF,
977 0xBF27, sgop_expt_addr >> 16,
978 0xBF28, sgop_peak_addr & 0x0000FFFF,
979 0xBF29, sgop_peak_addr >> 16,
980 0xBF2A, vbv_alert_addr & 0x0000FFFF,
981 0xBF2B, vbv_alert_addr >> 16,
987 0xBF2E, vbv_alert_addr & 0x0000FFFF,
988 0xBF2F, vbv_alert_addr >> 16,
989 0xBF30, cplx[0] & 0x0000FFFF,
990 0xBF31, cplx[0] >> 16,
991 0xBF32, cplx[1] & 0x0000FFFF,
992 0xBF33, cplx[1] >> 16,
993 0xBF34, cplx[2] & 0x0000FFFF,
994 0xBF35, cplx[2] >> 16,
995 0xBF36, cplx[3] & 0x0000FFFF,
996 0xBF37, cplx[3] >> 16,
999 0xBF3A, total_expt_addr & 0x0000FFFF,
1000 0xBF3B, total_expt_addr >> 16,
1004 0xBF3C, total_expt_addr & 0x0000FFFF,
1005 0xBF3D, total_expt_addr >> 16,
1010 0xBF4A, calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
1021 0xBF40, sgop_expt_addr & 0x0000FFFF,
1022 0xBF41, sgop_expt_addr >> 16,
1027 0xBF46, (go->width >> 4) * (go->height >> 4),
1031 0xBF18, framelen[4],
1032 0xBF19, framelen[5],
1033 0xBF1A, framelen[6],
1034 0xBF1B, framelen[7],
1037 #if 0 /* Remove once we don't care about matching */
1084 0xBF52, framelen[0],
1085 0xBF53, framelen[1],
1086 0xBF54, framelen[2],
1087 0xBF55, framelen[3],
1091 return copy_packages(code, pack, 6, space);
1094 static int config_package(struct go7007 *go, __le16 *code, int space)
1096 int fps = go->sensor_framerate / go->fps_scale / 1000;
1097 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1098 int brc_window_size = fps;
1099 int q_min = 2, q_max = 31;
1100 int THACCoeffSet0 = 0;
1107 0xc6c3, go->format == GO7007_FORMAT_MPEG4 ? 0 :
1108 (go->format == GO7007_FORMAT_H263 ? 0 : 1),
1109 0xc680, go->format == GO7007_FORMAT_MPEG4 ? 0xf1 :
1110 (go->format == GO7007_FORMAT_H263 ? 0x61 :
1125 0xd472, (go->board_info->sensor_flags &
1126 GO7007_SENSOR_TV) &&
1127 (!go->interlace_coding) ?
1129 0xd475, (go->board_info->sensor_flags &
1130 GO7007_SENSOR_TV) &&
1131 (!go->interlace_coding) ?
1133 0xc404, go->interlace_coding ? 0x44 :
1134 (go->format == GO7007_FORMAT_MPEG4 ? 0x11 :
1135 (go->format == GO7007_FORMAT_MPEG1 ? 0x02 :
1136 (go->format == GO7007_FORMAT_MPEG2 ? 0x04 :
1137 (go->format == GO7007_FORMAT_H263 ? 0x08 :
1139 0xbf0a, (go->format == GO7007_FORMAT_MPEG4 ? 8 :
1140 (go->format == GO7007_FORMAT_MPEG1 ? 1 :
1141 (go->format == GO7007_FORMAT_MPEG2 ? 2 :
1142 (go->format == GO7007_FORMAT_H263 ? 4 : 16)))) |
1143 ((go->repeat_seqhead ? 1 : 0) << 6) |
1144 ((go->dvd_mode ? 1 : 0) << 9) |
1145 ((go->gop_header_enable ? 1 : 0) << 10),
1147 0xdd5a, go->ipb ? 0x14 : 0x0a,
1150 0xc683, THACCoeffSet0,
1151 0xc40a, (go->width << 4) | rows,
1152 0xe01a, go->board_info->hpi_buffer_cap,
1174 0xbf66, brc_window_size,
1181 0xbfe3, go->ipb ? 3 : 1,
1182 0xc031, go->board_info->sensor_flags &
1183 GO7007_SENSOR_VBI ? 1 : 0,
1187 0xdd88, go->ipb ? 0x1401 : 0x0a01,
1188 0xdd90, go->ipb ? 0x1401 : 0x0a01,
1200 0xbfec, (go->interlace_coding ? 1 << 15 : 0) |
1201 (go->modet_enable ? 0xa : 0) |
1202 (go->board_info->sensor_flags &
1203 GO7007_SENSOR_VBI ? 1 : 0),
1207 0xbff0, go->board_info->sensor_flags &
1208 GO7007_SENSOR_TV ? 0xf060 : 0xb060,
1213 return copy_packages(code, pack, 5, space);
1216 static int seqhead_to_package(struct go7007 *go, __le16 *code, int space,
1217 int (*sequence_header_func)(struct go7007 *go,
1218 unsigned char *buf, int ext))
1220 int vop_time_increment_bitlength = vti_bitlen(go);
1221 int fps = go->sensor_framerate / go->fps_scale *
1222 (go->interlace_coding ? 2 : 1);
1223 unsigned char buf[40] = { };
1224 int len = sequence_header_func(go, buf, 1);
1229 0xbff2, vop_time_increment_bitlength,
1230 0xbff3, (1 << vop_time_increment_bitlength) - 1,
1232 0xbfe7, (fps / 1000) << 8,
1244 0xc800, buf[2] << 8 | buf[3],
1245 0xc801, buf[4] << 8 | buf[5],
1246 0xc802, buf[6] << 8 | buf[7],
1247 0xc803, buf[8] << 8 | buf[9],
1261 0xc808, buf[10] << 8 | buf[11],
1262 0xc809, buf[12] << 8 | buf[13],
1263 0xc80a, buf[14] << 8 | buf[15],
1264 0xc80b, buf[16] << 8 | buf[17],
1265 0xc80c, buf[18] << 8 | buf[19],
1266 0xc80d, buf[20] << 8 | buf[21],
1267 0xc80e, buf[22] << 8 | buf[23],
1268 0xc80f, buf[24] << 8 | buf[25],
1269 0xc810, buf[26] << 8 | buf[27],
1270 0xc811, buf[28] << 8 | buf[29],
1271 0xc812, buf[30] << 8 | buf[31],
1272 0xc813, buf[32] << 8 | buf[33],
1273 0xc814, buf[34] << 8 | buf[35],
1274 0xc815, buf[36] << 8 | buf[37],
1280 return copy_packages(code, pack, 3, space);
1283 static int relative_prime(int big, int little)
1287 while (little != 0) {
1288 remainder = big % little;
1295 static int avsync_to_package(struct go7007 *go, __le16 *code, int space)
1297 int arate = go->board_info->audio_rate * 1001 * go->fps_scale;
1298 int ratio = arate / go->sensor_framerate;
1299 int adjratio = ratio * 215 / 100;
1300 int rprime = relative_prime(go->sensor_framerate,
1301 arate % go->sensor_framerate);
1302 int f1 = (arate % go->sensor_framerate) / rprime;
1303 int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime;
1306 0xbf98, (u16)((-adjratio) & 0xffff),
1307 0xbf99, (u16)((-adjratio) >> 16),
1310 0xbff4, f1 > f2 ? f1 : f2,
1311 0xbff5, f1 < f2 ? f1 : f2,
1312 0xbff6, f1 < f2 ? ratio : ratio + 1,
1313 0xbff7, f1 > f2 ? ratio : ratio + 1,
1316 0xbffa, adjratio & 0xffff,
1317 0xbffb, adjratio >> 16,
1323 return copy_packages(code, pack, 1, space);
1326 static int final_package(struct go7007 *go, __le16 *code, int space)
1328 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1338 ((go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
1339 (!go->interlace_coding) ?
1340 (1 << 14) | (1 << 9) : 0) |
1341 ((go->encoder_subsample ? 1 : 0) << 8) |
1342 (go->board_info->sensor_flags &
1343 GO7007_SENSOR_CONFIG_MASK),
1344 ((go->encoder_v_halve ? 1 : 0) << 14) |
1345 (go->encoder_v_halve ? rows << 9 : rows << 8) |
1346 (go->encoder_h_halve ? 1 << 6 : 0) |
1347 (go->encoder_h_halve ? go->width >> 3 : go->width >> 4),
1348 (1 << 15) | (go->encoder_v_offset << 6) |
1349 (1 << 7) | (go->encoder_h_offset >> 2),
1353 ((go->fps_scale - 1) << 8) |
1354 (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
1357 go->ipb ? 0xd4c : 0x36b,
1358 (rows << 8) | (go->width >> 4),
1359 go->format == GO7007_FORMAT_MPEG4 ? 0x0404 : 0,
1360 (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) |
1361 ((go->closed_gop ? 1 : 0) << 12) |
1362 ((go->format == GO7007_FORMAT_MPEG4 ? 1 : 0) << 11) |
1364 ((go->ipb ? 3 : 0) << 7) |
1365 ((go->modet_enable ? 1 : 0) << 2) |
1366 ((go->dvd_mode ? 1 : 0) << 1) | 1,
1367 (go->format == GO7007_FORMAT_MPEG1 ? 0x89a0 :
1368 (go->format == GO7007_FORMAT_MPEG2 ? 0x89a0 :
1369 (go->format == GO7007_FORMAT_MJPEG ? 0x89a0 :
1370 (go->format == GO7007_FORMAT_MPEG4 ? 0x8920 :
1371 (go->format == GO7007_FORMAT_H263 ? 0x8920 : 0))))),
1372 go->ipb ? 0x1f15 : 0x1f0b,
1373 go->ipb ? 0x0015 : 0x000b,
1374 go->ipb ? 0xa800 : 0x5800,
1376 0x0020 + 0x034b * 0,
1377 0x0020 + 0x034b * 1,
1378 0x0020 + 0x034b * 2,
1379 0x0020 + 0x034b * 3,
1380 0x0020 + 0x034b * 4,
1381 0x0020 + 0x034b * 5,
1382 go->ipb ? (go->gop_size / 3) : go->gop_size,
1383 (go->height >> 4) * (go->width >> 4) * 110 / 100,
1386 return copy_packages(code, pack, 1, space);
1389 static int audio_to_package(struct go7007 *go, __le16 *code, int space)
1391 int clock_config = ((go->board_info->audio_flags &
1392 GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) |
1393 ((go->board_info->audio_flags &
1394 GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) |
1395 (((go->board_info->audio_bclk_div / 4) - 1) << 4) |
1396 (go->board_info->audio_main_div - 1);
1409 0x9000, clock_config,
1410 0x9001, (go->board_info->audio_flags & 0xffff) |
1412 0x9000, ((go->board_info->audio_flags &
1413 GO7007_AUDIO_I2S_MASTER ?
1436 return copy_packages(code, pack, 2, space);
1439 static int modet_to_package(struct go7007 *go, __le16 *code, int space)
1441 int ret, mb, i, addr, cnt = 0;
1443 u16 thresholds[] = {
1445 0xbf82, go->modet[0].pixel_threshold,
1446 0xbf83, go->modet[1].pixel_threshold,
1447 0xbf84, go->modet[2].pixel_threshold,
1448 0xbf85, go->modet[3].pixel_threshold,
1449 0xbf86, go->modet[0].motion_threshold,
1450 0xbf87, go->modet[1].motion_threshold,
1451 0xbf88, go->modet[2].motion_threshold,
1452 0xbf89, go->modet[3].motion_threshold,
1453 0xbf8a, go->modet[0].mb_threshold,
1454 0xbf8b, go->modet[1].mb_threshold,
1455 0xbf8c, go->modet[2].mb_threshold,
1456 0xbf8d, go->modet[3].mb_threshold,
1462 ret = copy_packages(code, thresholds, 1, space);
1468 memset(pack, 0, 64);
1470 for (mb = 0; mb < 1624; ++mb) {
1471 pack[i * 2 + 3] <<= 2;
1472 pack[i * 2 + 3] |= go->modet_map[mb];
1475 pack[i * 2 + 2] = addr++;
1477 if (i == 10 || mb == 1623) {
1478 pack[0] = 0x2000 | i;
1479 ret = copy_packages(code + cnt, pack, 1, space - cnt);
1484 memset(pack, 0, 64);
1486 pack[i * 2 + 3] = 0;
1489 memset(pack, 0, 64);
1491 for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
1492 pack[i * 2 + 2] = addr;
1493 pack[i * 2 + 3] = 0;
1495 if (i == 10 || addr == 0xbbf9) {
1496 pack[0] = 0x2000 | i;
1497 ret = copy_packages(code + cnt, pack, 1, space - cnt);
1502 memset(pack, 0, 64);
1508 static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
1512 case SPECIAL_FRM_HEAD:
1513 switch (go->format) {
1514 case GO7007_FORMAT_MJPEG:
1515 return gen_mjpeghdr_to_package(go, code, space);
1516 case GO7007_FORMAT_MPEG1:
1517 case GO7007_FORMAT_MPEG2:
1518 return gen_mpeg1hdr_to_package(go, code, space,
1520 case GO7007_FORMAT_MPEG4:
1521 return gen_mpeg4hdr_to_package(go, code, space,
1524 case SPECIAL_BRC_CTRL:
1525 return brctrl_to_package(go, code, space, framelen);
1526 case SPECIAL_CONFIG:
1527 return config_package(go, code, space);
1528 case SPECIAL_SEQHEAD:
1529 switch (go->format) {
1530 case GO7007_FORMAT_MPEG1:
1531 case GO7007_FORMAT_MPEG2:
1532 return seqhead_to_package(go, code, space,
1533 mpeg1_sequence_header);
1534 case GO7007_FORMAT_MPEG4:
1535 return seqhead_to_package(go, code, space,
1536 mpeg4_sequence_header);
1540 case SPECIAL_AV_SYNC:
1541 return avsync_to_package(go, code, space);
1543 return final_package(go, code, space);
1545 return audio_to_package(go, code, space);
1547 return modet_to_package(go, code, space);
1550 "go7007: firmware file contains unsupported feature %04x\n",
1555 int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
1557 const struct firmware *fw_entry;
1559 int framelen[8] = { }; /* holds the lengths of empty frame templates */
1560 int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
1564 switch (go->format) {
1565 case GO7007_FORMAT_MJPEG:
1566 mode_flag = FLAG_MODE_MJPEG;
1568 case GO7007_FORMAT_MPEG1:
1569 mode_flag = FLAG_MODE_MPEG1;
1571 case GO7007_FORMAT_MPEG2:
1572 mode_flag = FLAG_MODE_MPEG2;
1574 case GO7007_FORMAT_MPEG4:
1575 mode_flag = FLAG_MODE_MPEG4;
1580 if (request_firmware(&fw_entry, go->board_info->firmware, go->dev)) {
1582 "go7007: unable to load firmware from file \"%s\"\n",
1583 go->board_info->firmware);
1586 code = kmalloc(codespace * 2, GFP_KERNEL);
1588 printk(KERN_ERR "go7007: unable to allocate %d bytes for "
1589 "firmware construction\n", codespace * 2);
1592 memset(code, 0, codespace * 2);
1593 src = (__le16 *)fw_entry->data;
1594 srclen = fw_entry->size / 2;
1595 while (srclen >= 2) {
1596 chunk_flags = __le16_to_cpu(src[0]);
1597 chunk_len = __le16_to_cpu(src[1]);
1598 if (chunk_len + 2 > srclen) {
1599 printk(KERN_ERR "go7007: firmware file \"%s\" "
1600 "appears to be corrupted\n",
1601 go->board_info->firmware);
1604 if (chunk_flags & mode_flag) {
1605 if (chunk_flags & FLAG_SPECIAL) {
1606 ret = do_special(go, __le16_to_cpu(src[2]),
1607 &code[i], codespace - i, framelen);
1609 printk(KERN_ERR "go7007: insufficient "
1610 "memory for firmware "
1616 if (codespace - i < chunk_len) {
1617 printk(KERN_ERR "go7007: insufficient "
1618 "memory for firmware "
1622 memcpy(&code[i], &src[2], chunk_len * 2);
1626 srclen -= chunk_len + 2;
1627 src += chunk_len + 2;
1629 release_firmware(fw_entry);
1636 release_firmware(fw_entry);