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 <linux/slab.h>
35 #include <asm/byteorder.h>
37 #include "go7007-priv.h"
39 /* Constants used in the source firmware image to describe code segments */
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 | \
49 #define FLAG_SPECIAL (1<<8)
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
60 /* Little data class for creating MPEG headers bit-by-bit */
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 */
69 #define CODE_GEN(name, dest) struct code_gen name = { dest, 0, 32, 0 }
71 #define CODE_ADD(name, val, length) do { \
73 name.a |= (val) << name.b; \
74 while (name.b <= 24) { \
75 *name.p = name.a >> 24; \
83 #define CODE_LENGTH(name) (name.len + (32 - name.b))
85 /* Tables for creating the bitrate control data */
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,
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,
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,
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,
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,
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,
169 /* MPEG blank frame generation tables */
171 enum mpeg_frame_type {
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 },
191 /* Standard JPEG tables */
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
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
208 static const u8 val_dc_luminance[] = {
209 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
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
216 static const u8 val_dc_chrominance[] = {
217 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
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
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,
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
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,
276 /* Zig-zag mapping for quant table
278 * OK, let's do this mapping on the actual table above so it doesn't have
279 * to be done on the fly.
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
288 static int copy_packages(__le16 *dest, u16 *src, int pkg_cnt, int space)
290 int i, cnt = pkg_cnt * 32;
295 for (i = 0; i < cnt; ++i)
296 dest[i] = cpu_to_le16p(src + i);
301 static int mjpeg_frame_header(struct go7007 *go, unsigned char *buf, int q)
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;
321 buf[p++] = go->height >> 8;
322 buf[p++] = go->height & 0xff;
323 buf[p++] = go->width >> 8;
324 buf[p++] = go->width & 0xff;
338 buf[p++] = 418 & 0xff;
340 memcpy(buf + p, bits_dc_luminance + 1, 16);
342 memcpy(buf + p, val_dc_luminance, sizeof(val_dc_luminance));
343 p += sizeof(val_dc_luminance);
345 memcpy(buf + p, bits_dc_chrominance + 1, 16);
347 memcpy(buf + p, val_dc_chrominance, sizeof(val_dc_chrominance));
348 p += sizeof(val_dc_chrominance);
350 memcpy(buf + p, bits_ac_luminance + 1, 16);
352 memcpy(buf + p, val_ac_luminance, sizeof(val_ac_luminance));
353 p += sizeof(val_ac_luminance);
355 memcpy(buf + p, bits_ac_chrominance + 1, 16);
357 memcpy(buf + p, val_ac_chrominance, sizeof(val_ac_chrominance));
358 p += sizeof(val_ac_chrominance);
376 static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *code, int space)
380 unsigned int addr = 0x19;
381 int size = 0, i, off = 0, chunk;
383 buf = kmalloc(4096, GFP_KERNEL);
385 printk(KERN_ERR "go7007: unable to allocate 4096 bytes for "
386 "firmware construction\n");
389 memset(buf, 0, 4096);
391 for (i = 1; i < 32; ++i) {
392 mjpeg_frame_header(go, buf + size, i);
395 chunk = mjpeg_frame_header(go, buf + size, 1);
396 memmove(buf + size, buf + size + 80, chunk - 80);
399 for (i = 0; i < size; i += chunk * 2) {
400 if (space - off < 32) {
405 code[off + 1] = __cpu_to_le16(0x8000 | mem);
408 if (mem + chunk > 0x4000)
409 chunk = 0x4000 - mem;
410 if (i + 2 * chunk > size)
411 chunk = (size - i) / 2;
414 code[off] = __cpu_to_le16(0x4000 | chunk);
415 code[off + 31] = __cpu_to_le16(addr++);
418 code[off] = __cpu_to_le16(0x1000 | 28);
423 memcpy(&code[off + 2], buf + i, chunk * 2);
431 static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf,
432 int modulo, int pict_struct, enum mpeg_frame_type frame)
434 int i, j, mb_code, mb_len;
435 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
436 CODE_GEN(c, buf + 6);
455 default: /* keep the compiler happy */
456 mb_code = mb_len = 0;
460 CODE_ADD(c, frame == PFRAME ? 0x2 : 0x3, 13);
461 CODE_ADD(c, 0xffff, 16);
462 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
464 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
466 CODE_ADD(c, 0, 4); /* Is this supposed to be here?? */
467 CODE_ADD(c, 0, 3); /* What is this?? */
468 /* Byte-align with zeros */
469 j = 8 - (CODE_LENGTH(c) % 8);
473 if (go->format == GO7007_FORMAT_MPEG2) {
474 CODE_ADD(c, 0x1, 24);
475 CODE_ADD(c, 0xb5, 8);
476 CODE_ADD(c, 0x844, 12);
477 CODE_ADD(c, frame == PFRAME ? 0xff : 0x44, 8);
478 if (go->interlace_coding) {
479 CODE_ADD(c, pict_struct, 4);
481 CODE_ADD(c, 0x000, 11);
483 CODE_ADD(c, 0x200, 11);
486 CODE_ADD(c, 0x20c, 11);
488 /* Byte-align with zeros */
489 j = 8 - (CODE_LENGTH(c) % 8);
494 for (i = 0; i < rows; ++i) {
496 CODE_ADD(c, i + 1, 8);
499 CODE_ADD(c, mb_code, mb_len);
500 if (go->interlace_coding) {
502 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
504 if (frame == BFRAME_BIDIR) {
506 if (go->interlace_coding)
507 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
510 for (j = (go->width >> 4) - 2; j >= 33; j -= 33)
511 CODE_ADD(c, 0x8, 11);
512 CODE_ADD(c, addrinctab[j][0], addrinctab[j][1]);
513 CODE_ADD(c, mb_code, mb_len);
514 if (go->interlace_coding) {
516 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
518 if (frame == BFRAME_BIDIR) {
520 if (go->interlace_coding)
521 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
525 /* Byte-align with zeros */
526 j = 8 - (CODE_LENGTH(c) % 8);
531 i = CODE_LENGTH(c) + 4 * 8;
539 static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
541 int i, aspect_ratio, picture_rate;
542 CODE_GEN(c, buf + 6);
544 if (go->format == GO7007_FORMAT_MPEG1) {
545 switch (go->aspect_ratio) {
546 case GO7007_RATIO_4_3:
547 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
549 case GO7007_RATIO_16_9:
550 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
557 switch (go->aspect_ratio) {
558 case GO7007_RATIO_4_3:
561 case GO7007_RATIO_16_9:
569 switch (go->sensor_framerate) {
577 picture_rate = go->interlace_coding ? 6 : 3;
580 picture_rate = go->interlace_coding ? 7 : 4;
583 picture_rate = go->interlace_coding ? 8 : 5;
586 picture_rate = 5; /* 30 fps seems like a reasonable default */
590 CODE_ADD(c, go->width, 12);
591 CODE_ADD(c, go->height, 12);
592 CODE_ADD(c, aspect_ratio, 4);
593 CODE_ADD(c, picture_rate, 4);
594 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 20000 : 0x3ffff, 18);
596 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 112 : 20, 10);
599 /* Byte-align with zeros */
600 i = 8 - (CODE_LENGTH(c) % 8);
604 if (go->format == GO7007_FORMAT_MPEG2) {
605 CODE_ADD(c, 0x1, 24);
606 CODE_ADD(c, 0xb5, 8);
607 CODE_ADD(c, 0x148, 12);
608 if (go->interlace_coding)
609 CODE_ADD(c, 0x20001, 20);
611 CODE_ADD(c, 0xa0001, 20);
614 /* Byte-align with zeros */
615 i = 8 - (CODE_LENGTH(c) % 8);
620 CODE_ADD(c, 0x1, 24);
621 CODE_ADD(c, 0xb52, 12);
622 CODE_ADD(c, go->standard == GO7007_STD_NTSC ? 2 : 1, 3);
623 CODE_ADD(c, 0x105, 9);
624 CODE_ADD(c, 0x505, 16);
625 CODE_ADD(c, go->width, 14);
627 CODE_ADD(c, go->height, 14);
629 /* Byte-align with zeros */
630 i = 8 - (CODE_LENGTH(c) % 8);
636 i = CODE_LENGTH(c) + 4 * 8;
646 static int gen_mpeg1hdr_to_package(struct go7007 *go,
647 __le16 *code, int space, int *framelen)
651 unsigned int addr = 0x19;
652 int i, off = 0, chunk;
654 buf = kmalloc(5120, GFP_KERNEL);
656 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
657 "firmware construction\n");
660 memset(buf, 0, 5120);
661 framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME);
662 if (go->interlace_coding)
663 framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8,
665 buf[0] = framelen[0] & 0xff;
666 buf[1] = framelen[0] >> 8;
668 framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE);
669 if (go->interlace_coding)
670 framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8,
672 buf[i] = framelen[1] & 0xff;
673 buf[i + 1] = framelen[1] >> 8;
675 framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST);
676 if (go->interlace_coding)
677 framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8,
679 buf[i] = framelen[2] & 0xff;
680 buf[i + 1] = framelen[2] >> 8;
682 framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR);
683 if (go->interlace_coding)
684 framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8,
686 buf[i] = framelen[3] & 0xff;
687 buf[i + 1] = framelen[3] >> 8;
689 mpeg1_sequence_header(go, buf + i, 0);
691 for (i = 0; i < 5120; i += chunk * 2) {
692 if (space - off < 32) {
697 code[off + 1] = __cpu_to_le16(0x8000 | mem);
700 if (mem + chunk > 0x4000)
701 chunk = 0x4000 - mem;
702 if (i + 2 * chunk > 5120)
703 chunk = (5120 - i) / 2;
706 code[off] = __cpu_to_le16(0x4000 | chunk);
707 code[off + 31] = __cpu_to_le16(addr);
708 if (mem + chunk == 0x4000) {
713 code[off] = __cpu_to_le16(0x1000 | 28);
718 memcpy(&code[off + 2], buf + i, chunk * 2);
726 static int vti_bitlen(struct go7007 *go)
728 unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
730 for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i);
734 static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
735 int modulo, enum mpeg_frame_type frame)
738 CODE_GEN(c, buf + 6);
739 int mb_count = (go->width >> 4) * (go->height >> 4);
741 CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
745 CODE_ADD(c, 0, vti_bitlen(go));
749 CODE_ADD(c, 0xc, 11);
752 if (frame != BFRAME_EMPTY) {
753 for (i = 0; i < mb_count; ++i) {
759 CODE_ADD(c, 0x47, 8);
762 CODE_ADD(c, 0x27, 7);
765 CODE_ADD(c, 0x5f, 8);
767 case BFRAME_EMPTY: /* keep compiler quiet */
773 /* Byte-align with a zero followed by ones */
774 i = 8 - (CODE_LENGTH(c) % 8);
776 CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
778 i = CODE_LENGTH(c) + 4 * 8;
788 static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
790 const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali,
791 0x00, 0x00, 0x01, 0xb5, 0x09,
792 0x00, 0x00, 0x01, 0x00,
793 0x00, 0x00, 0x01, 0x20, };
795 int fps = go->sensor_framerate / go->fps_scale;
796 CODE_GEN(c, buf + 2 + sizeof(head));
798 switch (go->aspect_ratio) {
799 case GO7007_RATIO_4_3:
800 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
802 case GO7007_RATIO_16_9:
803 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
810 memcpy(buf + 2, head, sizeof(head));
811 CODE_ADD(c, 0x191, 17);
812 CODE_ADD(c, aspect_ratio, 4);
814 CODE_ADD(c, fps, 16);
816 CODE_ADD(c, 1001, vti_bitlen(go));
818 CODE_ADD(c, go->width, 13);
820 CODE_ADD(c, go->height, 13);
821 CODE_ADD(c, 0x2830, 14);
824 i = 8 - (CODE_LENGTH(c) % 8);
826 CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
828 i = CODE_LENGTH(c) + sizeof(head) * 8;
834 static int gen_mpeg4hdr_to_package(struct go7007 *go,
835 __le16 *code, int space, int *framelen)
839 unsigned int addr = 0x19;
840 int i, off = 0, chunk;
842 buf = kmalloc(5120, GFP_KERNEL);
844 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
845 "firmware construction\n");
848 memset(buf, 0, 5120);
849 framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
851 framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
853 framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
855 framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
857 mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
859 mpeg4_sequence_header(go, buf + i, 0);
861 for (i = 0; i < 5120; i += chunk * 2) {
862 if (space - off < 32) {
867 code[off + 1] = __cpu_to_le16(0x8000 | mem);
870 if (mem + chunk > 0x4000)
871 chunk = 0x4000 - mem;
872 if (i + 2 * chunk > 5120)
873 chunk = (5120 - i) / 2;
876 code[off] = __cpu_to_le16(0x4000 | chunk);
877 code[off + 31] = __cpu_to_le16(addr);
878 if (mem + chunk == 0x4000) {
883 code[off] = __cpu_to_le16(0x1000 | 28);
888 memcpy(&code[off + 2], buf + i, chunk * 2);
892 addr = go->ipb ? 0x14f9 : 0x0af9;
893 memset(buf, 0, 5120);
894 framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
896 framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
898 framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
900 framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
902 mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
904 for (i = 0; i < 5120; i += chunk * 2) {
905 if (space - off < 32) {
910 code[off + 1] = __cpu_to_le16(0x8000 | mem);
913 if (mem + chunk > 0x4000)
914 chunk = 0x4000 - mem;
915 if (i + 2 * chunk > 5120)
916 chunk = (5120 - i) / 2;
919 code[off] = __cpu_to_le16(0x4000 | chunk);
920 code[off + 31] = __cpu_to_le16(addr);
921 if (mem + chunk == 0x4000) {
926 code[off] = __cpu_to_le16(0x1000 | 28);
931 memcpy(&code[off + 2], buf + i, chunk * 2);
939 static int brctrl_to_package(struct go7007 *go,
940 __le16 *code, int space, int *framelen)
942 int converge_speed = 0;
943 int lambda = (go->format == GO7007_FORMAT_MJPEG || go->dvd_mode) ?
945 int peak_rate = 6 * go->bitrate / 5;
946 int vbv_buffer = go->format == GO7007_FORMAT_MJPEG ?
948 (go->dvd_mode ? 900000 : peak_rate);
949 int fps = go->sensor_framerate / go->fps_scale;
951 /* Bizarre math below depends on rounding errors in division */
952 u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps;
953 u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps;
954 u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000);
955 u32 vbv_alert_addr = vbv_buffer * 3 / (4 * 32);
957 q > 0 ? sgop_expt_addr * q :
958 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
959 q > 0 ? sgop_expt_addr * q :
960 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
961 q > 0 ? sgop_expt_addr * q :
962 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
963 q > 0 ? sgop_expt_addr * q :
964 2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
966 u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
969 0xBF20, go->ipb ? converge_speed_ipb[converge_speed]
970 : converge_speed_ip[converge_speed],
971 0xBF21, go->ipb ? 2 : 0,
972 0xBF22, go->ipb ? LAMBDA_table[0][lambda / 2 + 50]
974 0xBF23, go->ipb ? LAMBDA_table[1][lambda] : 32767,
976 0xBF25, lambda > 99 ? 32767 : LAMBDA_table[3][lambda],
977 0xBF26, sgop_expt_addr & 0x0000FFFF,
978 0xBF27, sgop_expt_addr >> 16,
979 0xBF28, sgop_peak_addr & 0x0000FFFF,
980 0xBF29, sgop_peak_addr >> 16,
981 0xBF2A, vbv_alert_addr & 0x0000FFFF,
982 0xBF2B, vbv_alert_addr >> 16,
988 0xBF2E, vbv_alert_addr & 0x0000FFFF,
989 0xBF2F, vbv_alert_addr >> 16,
990 0xBF30, cplx[0] & 0x0000FFFF,
991 0xBF31, cplx[0] >> 16,
992 0xBF32, cplx[1] & 0x0000FFFF,
993 0xBF33, cplx[1] >> 16,
994 0xBF34, cplx[2] & 0x0000FFFF,
995 0xBF35, cplx[2] >> 16,
996 0xBF36, cplx[3] & 0x0000FFFF,
997 0xBF37, cplx[3] >> 16,
1000 0xBF3A, total_expt_addr & 0x0000FFFF,
1001 0xBF3B, total_expt_addr >> 16,
1005 0xBF3C, total_expt_addr & 0x0000FFFF,
1006 0xBF3D, total_expt_addr >> 16,
1011 0xBF4A, calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
1022 0xBF40, sgop_expt_addr & 0x0000FFFF,
1023 0xBF41, sgop_expt_addr >> 16,
1028 0xBF46, (go->width >> 4) * (go->height >> 4),
1032 0xBF18, framelen[4],
1033 0xBF19, framelen[5],
1034 0xBF1A, framelen[6],
1035 0xBF1B, framelen[7],
1039 /* Remove once we don't care about matching */
1086 0xBF52, framelen[0],
1087 0xBF53, framelen[1],
1088 0xBF54, framelen[2],
1089 0xBF55, framelen[3],
1093 return copy_packages(code, pack, 6, space);
1096 static int config_package(struct go7007 *go, __le16 *code, int space)
1098 int fps = go->sensor_framerate / go->fps_scale / 1000;
1099 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1100 int brc_window_size = fps;
1101 int q_min = 2, q_max = 31;
1102 int THACCoeffSet0 = 0;
1109 0xc6c3, go->format == GO7007_FORMAT_MPEG4 ? 0 :
1110 (go->format == GO7007_FORMAT_H263 ? 0 : 1),
1111 0xc680, go->format == GO7007_FORMAT_MPEG4 ? 0xf1 :
1112 (go->format == GO7007_FORMAT_H263 ? 0x61 :
1127 0xd472, (go->board_info->sensor_flags &
1128 GO7007_SENSOR_TV) &&
1129 (!go->interlace_coding) ?
1131 0xd475, (go->board_info->sensor_flags &
1132 GO7007_SENSOR_TV) &&
1133 (!go->interlace_coding) ?
1135 0xc404, go->interlace_coding ? 0x44 :
1136 (go->format == GO7007_FORMAT_MPEG4 ? 0x11 :
1137 (go->format == GO7007_FORMAT_MPEG1 ? 0x02 :
1138 (go->format == GO7007_FORMAT_MPEG2 ? 0x04 :
1139 (go->format == GO7007_FORMAT_H263 ? 0x08 :
1141 0xbf0a, (go->format == GO7007_FORMAT_MPEG4 ? 8 :
1142 (go->format == GO7007_FORMAT_MPEG1 ? 1 :
1143 (go->format == GO7007_FORMAT_MPEG2 ? 2 :
1144 (go->format == GO7007_FORMAT_H263 ? 4 : 16)))) |
1145 ((go->repeat_seqhead ? 1 : 0) << 6) |
1146 ((go->dvd_mode ? 1 : 0) << 9) |
1147 ((go->gop_header_enable ? 1 : 0) << 10),
1149 0xdd5a, go->ipb ? 0x14 : 0x0a,
1152 0xc683, THACCoeffSet0,
1153 0xc40a, (go->width << 4) | rows,
1154 0xe01a, go->board_info->hpi_buffer_cap,
1176 0xbf66, brc_window_size,
1183 0xbfe3, go->ipb ? 3 : 1,
1184 0xc031, go->board_info->sensor_flags &
1185 GO7007_SENSOR_VBI ? 1 : 0,
1189 0xdd88, go->ipb ? 0x1401 : 0x0a01,
1190 0xdd90, go->ipb ? 0x1401 : 0x0a01,
1202 0xbfec, (go->interlace_coding ? 1 << 15 : 0) |
1203 (go->modet_enable ? 0xa : 0) |
1204 (go->board_info->sensor_flags &
1205 GO7007_SENSOR_VBI ? 1 : 0),
1209 0xbff0, go->board_info->sensor_flags &
1210 GO7007_SENSOR_TV ? 0xf060 : 0xb060,
1215 return copy_packages(code, pack, 5, space);
1218 static int seqhead_to_package(struct go7007 *go, __le16 *code, int space,
1219 int (*sequence_header_func)(struct go7007 *go,
1220 unsigned char *buf, int ext))
1222 int vop_time_increment_bitlength = vti_bitlen(go);
1223 int fps = go->sensor_framerate / go->fps_scale *
1224 (go->interlace_coding ? 2 : 1);
1225 unsigned char buf[40] = { };
1226 int len = sequence_header_func(go, buf, 1);
1231 0xbff2, vop_time_increment_bitlength,
1232 0xbff3, (1 << vop_time_increment_bitlength) - 1,
1234 0xbfe7, (fps / 1000) << 8,
1246 0xc800, buf[2] << 8 | buf[3],
1247 0xc801, buf[4] << 8 | buf[5],
1248 0xc802, buf[6] << 8 | buf[7],
1249 0xc803, buf[8] << 8 | buf[9],
1263 0xc808, buf[10] << 8 | buf[11],
1264 0xc809, buf[12] << 8 | buf[13],
1265 0xc80a, buf[14] << 8 | buf[15],
1266 0xc80b, buf[16] << 8 | buf[17],
1267 0xc80c, buf[18] << 8 | buf[19],
1268 0xc80d, buf[20] << 8 | buf[21],
1269 0xc80e, buf[22] << 8 | buf[23],
1270 0xc80f, buf[24] << 8 | buf[25],
1271 0xc810, buf[26] << 8 | buf[27],
1272 0xc811, buf[28] << 8 | buf[29],
1273 0xc812, buf[30] << 8 | buf[31],
1274 0xc813, buf[32] << 8 | buf[33],
1275 0xc814, buf[34] << 8 | buf[35],
1276 0xc815, buf[36] << 8 | buf[37],
1282 return copy_packages(code, pack, 3, space);
1285 static int relative_prime(int big, int little)
1289 while (little != 0) {
1290 remainder = big % little;
1297 static int avsync_to_package(struct go7007 *go, __le16 *code, int space)
1299 int arate = go->board_info->audio_rate * 1001 * go->fps_scale;
1300 int ratio = arate / go->sensor_framerate;
1301 int adjratio = ratio * 215 / 100;
1302 int rprime = relative_prime(go->sensor_framerate,
1303 arate % go->sensor_framerate);
1304 int f1 = (arate % go->sensor_framerate) / rprime;
1305 int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime;
1308 0xbf98, (u16)((-adjratio) & 0xffff),
1309 0xbf99, (u16)((-adjratio) >> 16),
1312 0xbff4, f1 > f2 ? f1 : f2,
1313 0xbff5, f1 < f2 ? f1 : f2,
1314 0xbff6, f1 < f2 ? ratio : ratio + 1,
1315 0xbff7, f1 > f2 ? ratio : ratio + 1,
1318 0xbffa, adjratio & 0xffff,
1319 0xbffb, adjratio >> 16,
1325 return copy_packages(code, pack, 1, space);
1328 static int final_package(struct go7007 *go, __le16 *code, int space)
1330 int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1340 ((go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
1341 (!go->interlace_coding) ?
1342 (1 << 14) | (1 << 9) : 0) |
1343 ((go->encoder_subsample ? 1 : 0) << 8) |
1344 (go->board_info->sensor_flags &
1345 GO7007_SENSOR_CONFIG_MASK),
1346 ((go->encoder_v_halve ? 1 : 0) << 14) |
1347 (go->encoder_v_halve ? rows << 9 : rows << 8) |
1348 (go->encoder_h_halve ? 1 << 6 : 0) |
1349 (go->encoder_h_halve ? go->width >> 3 : go->width >> 4),
1350 (1 << 15) | (go->encoder_v_offset << 6) |
1351 (1 << 7) | (go->encoder_h_offset >> 2),
1355 ((go->fps_scale - 1) << 8) |
1356 (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
1359 go->ipb ? 0xd4c : 0x36b,
1360 (rows << 8) | (go->width >> 4),
1361 go->format == GO7007_FORMAT_MPEG4 ? 0x0404 : 0,
1362 (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) |
1363 ((go->closed_gop ? 1 : 0) << 12) |
1364 ((go->format == GO7007_FORMAT_MPEG4 ? 1 : 0) << 11) |
1366 ((go->ipb ? 3 : 0) << 7) |
1367 ((go->modet_enable ? 1 : 0) << 2) |
1368 ((go->dvd_mode ? 1 : 0) << 1) | 1,
1369 (go->format == GO7007_FORMAT_MPEG1 ? 0x89a0 :
1370 (go->format == GO7007_FORMAT_MPEG2 ? 0x89a0 :
1371 (go->format == GO7007_FORMAT_MJPEG ? 0x89a0 :
1372 (go->format == GO7007_FORMAT_MPEG4 ? 0x8920 :
1373 (go->format == GO7007_FORMAT_H263 ? 0x8920 : 0))))),
1374 go->ipb ? 0x1f15 : 0x1f0b,
1375 go->ipb ? 0x0015 : 0x000b,
1376 go->ipb ? 0xa800 : 0x5800,
1378 0x0020 + 0x034b * 0,
1379 0x0020 + 0x034b * 1,
1380 0x0020 + 0x034b * 2,
1381 0x0020 + 0x034b * 3,
1382 0x0020 + 0x034b * 4,
1383 0x0020 + 0x034b * 5,
1384 go->ipb ? (go->gop_size / 3) : go->gop_size,
1385 (go->height >> 4) * (go->width >> 4) * 110 / 100,
1388 return copy_packages(code, pack, 1, space);
1391 static int audio_to_package(struct go7007 *go, __le16 *code, int space)
1393 int clock_config = ((go->board_info->audio_flags &
1394 GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) |
1395 ((go->board_info->audio_flags &
1396 GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) |
1397 (((go->board_info->audio_bclk_div / 4) - 1) << 4) |
1398 (go->board_info->audio_main_div - 1);
1411 0x9000, clock_config,
1412 0x9001, (go->board_info->audio_flags & 0xffff) |
1414 0x9000, ((go->board_info->audio_flags &
1415 GO7007_AUDIO_I2S_MASTER ?
1438 return copy_packages(code, pack, 2, space);
1441 static int modet_to_package(struct go7007 *go, __le16 *code, int space)
1443 int ret, mb, i, addr, cnt = 0;
1445 u16 thresholds[] = {
1447 0xbf82, go->modet[0].pixel_threshold,
1448 0xbf83, go->modet[1].pixel_threshold,
1449 0xbf84, go->modet[2].pixel_threshold,
1450 0xbf85, go->modet[3].pixel_threshold,
1451 0xbf86, go->modet[0].motion_threshold,
1452 0xbf87, go->modet[1].motion_threshold,
1453 0xbf88, go->modet[2].motion_threshold,
1454 0xbf89, go->modet[3].motion_threshold,
1455 0xbf8a, go->modet[0].mb_threshold,
1456 0xbf8b, go->modet[1].mb_threshold,
1457 0xbf8c, go->modet[2].mb_threshold,
1458 0xbf8d, go->modet[3].mb_threshold,
1464 ret = copy_packages(code, thresholds, 1, space);
1470 memset(pack, 0, 64);
1472 for (mb = 0; mb < 1624; ++mb) {
1473 pack[i * 2 + 3] <<= 2;
1474 pack[i * 2 + 3] |= go->modet_map[mb];
1477 pack[i * 2 + 2] = addr++;
1479 if (i == 10 || mb == 1623) {
1480 pack[0] = 0x2000 | i;
1481 ret = copy_packages(code + cnt, pack, 1, space - cnt);
1486 memset(pack, 0, 64);
1488 pack[i * 2 + 3] = 0;
1491 memset(pack, 0, 64);
1493 for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
1494 pack[i * 2 + 2] = addr;
1495 pack[i * 2 + 3] = 0;
1497 if (i == 10 || addr == 0xbbf9) {
1498 pack[0] = 0x2000 | i;
1499 ret = copy_packages(code + cnt, pack, 1, space - cnt);
1504 memset(pack, 0, 64);
1510 static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
1514 case SPECIAL_FRM_HEAD:
1515 switch (go->format) {
1516 case GO7007_FORMAT_MJPEG:
1517 return gen_mjpeghdr_to_package(go, code, space);
1518 case GO7007_FORMAT_MPEG1:
1519 case GO7007_FORMAT_MPEG2:
1520 return gen_mpeg1hdr_to_package(go, code, space,
1522 case GO7007_FORMAT_MPEG4:
1523 return gen_mpeg4hdr_to_package(go, code, space,
1526 case SPECIAL_BRC_CTRL:
1527 return brctrl_to_package(go, code, space, framelen);
1528 case SPECIAL_CONFIG:
1529 return config_package(go, code, space);
1530 case SPECIAL_SEQHEAD:
1531 switch (go->format) {
1532 case GO7007_FORMAT_MPEG1:
1533 case GO7007_FORMAT_MPEG2:
1534 return seqhead_to_package(go, code, space,
1535 mpeg1_sequence_header);
1536 case GO7007_FORMAT_MPEG4:
1537 return seqhead_to_package(go, code, space,
1538 mpeg4_sequence_header);
1542 case SPECIAL_AV_SYNC:
1543 return avsync_to_package(go, code, space);
1545 return final_package(go, code, space);
1547 return audio_to_package(go, code, space);
1549 return modet_to_package(go, code, space);
1552 "go7007: firmware file contains unsupported feature %04x\n",
1557 int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
1559 const struct firmware *fw_entry;
1561 int framelen[8] = { }; /* holds the lengths of empty frame templates */
1562 int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
1566 switch (go->format) {
1567 case GO7007_FORMAT_MJPEG:
1568 mode_flag = FLAG_MODE_MJPEG;
1570 case GO7007_FORMAT_MPEG1:
1571 mode_flag = FLAG_MODE_MPEG1;
1573 case GO7007_FORMAT_MPEG2:
1574 mode_flag = FLAG_MODE_MPEG2;
1576 case GO7007_FORMAT_MPEG4:
1577 mode_flag = FLAG_MODE_MPEG4;
1582 if (request_firmware(&fw_entry, go->board_info->firmware, go->dev)) {
1584 "go7007: unable to load firmware from file \"%s\"\n",
1585 go->board_info->firmware);
1588 code = kmalloc(codespace * 2, GFP_KERNEL);
1590 printk(KERN_ERR "go7007: unable to allocate %d bytes for "
1591 "firmware construction\n", codespace * 2);
1594 memset(code, 0, codespace * 2);
1595 src = (__le16 *)fw_entry->data;
1596 srclen = fw_entry->size / 2;
1597 while (srclen >= 2) {
1598 chunk_flags = __le16_to_cpu(src[0]);
1599 chunk_len = __le16_to_cpu(src[1]);
1600 if (chunk_len + 2 > srclen) {
1601 printk(KERN_ERR "go7007: firmware file \"%s\" "
1602 "appears to be corrupted\n",
1603 go->board_info->firmware);
1606 if (chunk_flags & mode_flag) {
1607 if (chunk_flags & FLAG_SPECIAL) {
1608 ret = do_special(go, __le16_to_cpu(src[2]),
1609 &code[i], codespace - i, framelen);
1611 printk(KERN_ERR "go7007: insufficient "
1612 "memory for firmware "
1618 if (codespace - i < chunk_len) {
1619 printk(KERN_ERR "go7007: insufficient "
1620 "memory for firmware "
1624 memcpy(&code[i], &src[2], chunk_len * 2);
1628 srclen -= chunk_len + 2;
1629 src += chunk_len + 2;
1631 release_firmware(fw_entry);
1638 release_firmware(fw_entry);