git.oblomov.eu Git - linux-2.6/blob - drivers/staging/go7007/go7007-fw.c

   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 <asm/byteorder.h>
  35
  36 #include "go7007-priv.h"
  37
  38 /* Constants used in the source firmware image to describe code segments */
  39
  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 | \
  47                                         FLAG_MODE_H263)
  48 #define FLAG_SPECIAL            (1<<8)
  49
  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
  58
  59 /* Little data class for creating MPEG headers bit-by-bit */
  60
  61 struct code_gen {
  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 */
  66 };
  67
  68 #define CODE_GEN(name, dest) struct code_gen name = { dest, 0, 32, 0 }
  69
  70 #define CODE_ADD(name, val, length) do { \
  71         name.b -= (length); \
  72         name.a |= (val) << name.b; \
  73         while (name.b <= 24) { \
  74                 *name.p = name.a >> 24; \
  75                 ++name.p; \
  76                 name.a <<= 8; \
  77                 name.b += 8; \
  78                 name.len += 8; \
  79         } \
  80 } while (0)
  81
  82 #define CODE_LENGTH(name) (name.len + (32 - name.b))
  83
  84 /* Tables for creating the bitrate control data */
  85
  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,
  97         100
  98 };
  99
 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,
 111         300
 112 };
 113
 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,
 125                 96
 126         },
 127         {
 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,
 138                 120
 139         },
 140         {
 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,
 151                 144
 152         },
 153         {
 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,
 164                 192
 165         }
 166 };
 167
 168 /* MPEG blank frame generation tables */
 169
 170 enum mpeg_frame_type {
 171         PFRAME,
 172         BFRAME_PRE,
 173         BFRAME_POST,
 174         BFRAME_BIDIR,
 175         BFRAME_EMPTY
 176 };
 177
 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 },
 187         { 0x18, 11 }
 188 };
 189
 190 /* Standard JPEG tables */
 191
 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
 201 };
 202
 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
 205 };
 206
 207 static const u8 val_dc_luminance[] = {
 208         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
 209 };
 210
 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
 213 };
 214
 215 static const u8 val_dc_chrominance[] = {
 216         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
 217 };
 218
 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
 221 };
 222
 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,
 244         0xf9, 0xfa
 245 };
 246
 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
 249 };
 250
 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,
 272         0xf9, 0xfa
 273 };
 274
 275 /* Zig-zag mapping for quant table
 276  *
 277  * OK, let's do this mapping on the actual table above so it doesn't have
 278  * to be done on the fly.
 279  */
 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
 285 };
 286
 287 static int copy_packages(__le16 *dest, u16 *src, int pkg_cnt, int space)
 288 {
 289         int i, cnt = pkg_cnt * 32;
 290
 291         if (space < cnt)
 292                 return -1;
 293
 294         for (i = 0; i < cnt; ++i)
 295                 dest[i] = cpu_to_le16p(src + i);
 296
 297         return cnt;
 298 }
 299
 300 static int mjpeg_frame_header(struct go7007 *go, unsigned char *buf, int q)
 301 {
 302         int i, p = 0;
 303
 304         buf[p++] = 0xff;
 305         buf[p++] = 0xd8;
 306         buf[p++] = 0xff;
 307         buf[p++] = 0xdb;
 308         buf[p++] = 0;
 309         buf[p++] = 2 + 65;
 310         buf[p++] = 0;
 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;
 315         buf[p++] = 0xff;
 316         buf[p++] = 0xc0;
 317         buf[p++] = 0;
 318         buf[p++] = 17;
 319         buf[p++] = 8;
 320         buf[p++] = go->height >> 8;
 321         buf[p++] = go->height & 0xff;
 322         buf[p++] = go->width >> 8;
 323         buf[p++] = go->width & 0xff;
 324         buf[p++] = 3;
 325         buf[p++] = 1;
 326         buf[p++] = 0x22;
 327         buf[p++] = 0;
 328         buf[p++] = 2;
 329         buf[p++] = 0x11;
 330         buf[p++] = 0;
 331         buf[p++] = 3;
 332         buf[p++] = 0x11;
 333         buf[p++] = 0;
 334         buf[p++] = 0xff;
 335         buf[p++] = 0xc4;
 336         buf[p++] = 418 >> 8;
 337         buf[p++] = 418 & 0xff;
 338         buf[p++] = 0x00;
 339         memcpy(buf + p, bits_dc_luminance + 1, 16);
 340         p += 16;
 341         memcpy(buf + p, val_dc_luminance, sizeof(val_dc_luminance));
 342         p += sizeof(val_dc_luminance);
 343         buf[p++] = 0x01;
 344         memcpy(buf + p, bits_dc_chrominance + 1, 16);
 345         p += 16;
 346         memcpy(buf + p, val_dc_chrominance, sizeof(val_dc_chrominance));
 347         p += sizeof(val_dc_chrominance);
 348         buf[p++] = 0x10;
 349         memcpy(buf + p, bits_ac_luminance + 1, 16);
 350         p += 16;
 351         memcpy(buf + p, val_ac_luminance, sizeof(val_ac_luminance));
 352         p += sizeof(val_ac_luminance);
 353         buf[p++] = 0x11;
 354         memcpy(buf + p, bits_ac_chrominance + 1, 16);
 355         p += 16;
 356         memcpy(buf + p, val_ac_chrominance, sizeof(val_ac_chrominance));
 357         p += sizeof(val_ac_chrominance);
 358         buf[p++] = 0xff;
 359         buf[p++] = 0xda;
 360         buf[p++] = 0;
 361         buf[p++] = 12;
 362         buf[p++] = 3;
 363         buf[p++] = 1;
 364         buf[p++] = 0x00;
 365         buf[p++] = 2;
 366         buf[p++] = 0x11;
 367         buf[p++] = 3;
 368         buf[p++] = 0x11;
 369         buf[p++] = 0;
 370         buf[p++] = 63;
 371         buf[p++] = 0;
 372         return p;
 373 }
 374
 375 static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *code, int space)
 376 {
 377         u8 *buf;
 378         u16 mem = 0x3e00;
 379         unsigned int addr = 0x19;
 380         int size = 0, i, off = 0, chunk;
 381
 382         buf = kmalloc(4096, GFP_KERNEL);
 383         if (buf == NULL) {
 384                 printk(KERN_ERR "go7007: unable to allocate 4096 bytes for "
 385                                 "firmware construction\n");
 386                 return -1;
 387         }
 388         memset(buf, 0, 4096);
 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 = kmalloc(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         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,
 663                                                         0, 2, PFRAME);
 664         buf[0] = framelen[0] & 0xff;
 665         buf[1] = framelen[0] >> 8;
 666         i = 368;
 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,
 670                                                         0, 2, BFRAME_PRE);
 671         buf[i] = framelen[1] & 0xff;
 672         buf[i + 1] = framelen[1] >> 8;
 673         i += 1632;
 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,
 677                                                         0, 2, BFRAME_POST);
 678         buf[i] = framelen[2] & 0xff;
 679         buf[i + 1] = framelen[2] >> 8;
 680         i += 1432;
 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,
 684                                                         0, 2, BFRAME_BIDIR);
 685         buf[i] = framelen[3] & 0xff;
 686         buf[i + 1] = framelen[3] >> 8;
 687         i += 1632 + 16;
 688         mpeg1_sequence_header(go, buf + i, 0);
 689         i += 40;
 690         for (i = 0; i < 5120; i += chunk * 2) {
 691                 if (space - off < 32) {
 692                         off = -1;
 693                         goto done;
 694                 }
 695
 696                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 697
 698                 chunk = 28;
 699                 if (mem + chunk > 0x4000)
 700                         chunk = 0x4000 - mem;
 701                 if (i + 2 * chunk > 5120)
 702                         chunk = (5120 - i) / 2;
 703
 704                 if (chunk < 28) {
 705                         code[off] = __cpu_to_le16(0x4000 | chunk);
 706                         code[off + 31] = __cpu_to_le16(addr);
 707                         if (mem + chunk == 0x4000) {
 708                                 mem = 0x3e00;
 709                                 ++addr;
 710                         }
 711                 } else {
 712                         code[off] = __cpu_to_le16(0x1000 | 28);
 713                         code[off + 31] = 0;
 714                         mem += 28;
 715                 }
 716
 717                 memcpy(&code[off + 2], buf + i, chunk * 2);
 718                 off += 32;
 719         }
 720 done:
 721         kfree(buf);
 722         return off;
 723 }
 724
 725 static int vti_bitlen(struct go7007 *go)
 726 {
 727         unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
 728
 729         for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i);
 730         return i + 1;
 731 }
 732
 733 static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
 734                 int modulo, enum mpeg_frame_type frame)
 735 {
 736         int i;
 737         CODE_GEN(c, buf + 6);
 738         int mb_count = (go->width >> 4) * (go->height >> 4);
 739
 740         CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
 741         if (modulo)
 742                 CODE_ADD(c, 0x1, 1);
 743         CODE_ADD(c, 0x1, 2);
 744         CODE_ADD(c, 0, vti_bitlen(go));
 745         CODE_ADD(c, 0x3, 2);
 746         if (frame == PFRAME)
 747                 CODE_ADD(c, 0, 1);
 748         CODE_ADD(c, 0xc, 11);
 749         if (frame != PFRAME)
 750                 CODE_ADD(c, 0x4, 3);
 751         if (frame != BFRAME_EMPTY) {
 752                 for (i = 0; i < mb_count; ++i) {
 753                         switch (frame) {
 754                         case PFRAME:
 755                                 CODE_ADD(c, 0x1, 1);
 756                                 break;
 757                         case BFRAME_PRE:
 758                                 CODE_ADD(c, 0x47, 8);
 759                                 break;
 760                         case BFRAME_POST:
 761                                 CODE_ADD(c, 0x27, 7);
 762                                 break;
 763                         case BFRAME_BIDIR:
 764                                 CODE_ADD(c, 0x5f, 8);
 765                                 break;
 766                         case BFRAME_EMPTY: /* keep compiler quiet */
 767                                 break;
 768                         }
 769                 }
 770         }
 771
 772         /* Byte-align with a zero followed by ones */
 773         i = 8 - (CODE_LENGTH(c) % 8);
 774         CODE_ADD(c, 0, 1);
 775         CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
 776
 777         i = CODE_LENGTH(c) + 4 * 8;
 778         buf[0] = i & 0xff;
 779         buf[1] = i >> 8;
 780         buf[2] = 0x00;
 781         buf[3] = 0x00;
 782         buf[4] = 0x01;
 783         buf[5] = 0xb6;
 784         return i;
 785 }
 786
 787 static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
 788 {
 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, };
 793         int i, aspect_ratio;
 794         int fps = go->sensor_framerate / go->fps_scale;
 795         CODE_GEN(c, buf + 2 + sizeof(head));
 796
 797         switch (go->aspect_ratio) {
 798         case GO7007_RATIO_4_3:
 799                 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
 800                 break;
 801         case GO7007_RATIO_16_9:
 802                 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
 803                 break;
 804         default:
 805                 aspect_ratio = 1;
 806                 break;
 807         }
 808
 809         memcpy(buf + 2, head, sizeof(head));
 810         CODE_ADD(c, 0x191, 17);
 811         CODE_ADD(c, aspect_ratio, 4);
 812         CODE_ADD(c, 0x1, 4);
 813         CODE_ADD(c, fps, 16);
 814         CODE_ADD(c, 0x3, 2);
 815         CODE_ADD(c, 1001, vti_bitlen(go));
 816         CODE_ADD(c, 1, 1);
 817         CODE_ADD(c, go->width, 13);
 818         CODE_ADD(c, 1, 1);
 819         CODE_ADD(c, go->height, 13);
 820         CODE_ADD(c, 0x2830, 14);
 821
 822         /* Byte-align */
 823         i = 8 - (CODE_LENGTH(c) % 8);
 824         CODE_ADD(c, 0, 1);
 825         CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
 826
 827         i = CODE_LENGTH(c) + sizeof(head) * 8;
 828         buf[0] = i & 0xff;
 829         buf[1] = i >> 8;
 830         return i;
 831 }
 832
 833 static int gen_mpeg4hdr_to_package(struct go7007 *go,
 834                                         __le16 *code, int space, int *framelen)
 835 {
 836         u8 *buf;
 837         u16 mem = 0x3e00;
 838         unsigned int addr = 0x19;
 839         int i, off = 0, chunk;
 840
 841         buf = kmalloc(5120, GFP_KERNEL);
 842         if (buf == NULL) {
 843                 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
 844                                 "firmware construction\n");
 845                 return -1;
 846         }
 847         memset(buf, 0, 5120);
 848         framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
 849         i = 368;
 850         framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
 851         i += 1632;
 852         framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
 853         i += 1432;
 854         framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
 855         i += 1632;
 856         mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
 857         i += 16;
 858         mpeg4_sequence_header(go, buf + i, 0);
 859         i += 40;
 860         for (i = 0; i < 5120; i += chunk * 2) {
 861                 if (space - off < 32) {
 862                         off = -1;
 863                         goto done;
 864                 }
 865
 866                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 867
 868                 chunk = 28;
 869                 if (mem + chunk > 0x4000)
 870                         chunk = 0x4000 - mem;
 871                 if (i + 2 * chunk > 5120)
 872                         chunk = (5120 - i) / 2;
 873
 874                 if (chunk < 28) {
 875                         code[off] = __cpu_to_le16(0x4000 | chunk);
 876                         code[off + 31] = __cpu_to_le16(addr);
 877                         if (mem + chunk == 0x4000) {
 878                                 mem = 0x3e00;
 879                                 ++addr;
 880                         }
 881                 } else {
 882                         code[off] = __cpu_to_le16(0x1000 | 28);
 883                         code[off + 31] = 0;
 884                         mem += 28;
 885                 }
 886
 887                 memcpy(&code[off + 2], buf + i, chunk * 2);
 888                 off += 32;
 889         }
 890         mem = 0x3e00;
 891         addr = go->ipb ? 0x14f9 : 0x0af9;
 892         memset(buf, 0, 5120);
 893         framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
 894         i = 368;
 895         framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
 896         i += 1632;
 897         framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
 898         i += 1432;
 899         framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
 900         i += 1632;
 901         mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
 902         i += 16;
 903         for (i = 0; i < 5120; i += chunk * 2) {
 904                 if (space - off < 32) {
 905                         off = -1;
 906                         goto done;
 907                 }
 908
 909                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 910
 911                 chunk = 28;
 912                 if (mem + chunk > 0x4000)
 913                         chunk = 0x4000 - mem;
 914                 if (i + 2 * chunk > 5120)
 915                         chunk = (5120 - i) / 2;
 916
 917                 if (chunk < 28) {
 918                         code[off] = __cpu_to_le16(0x4000 | chunk);
 919                         code[off + 31] = __cpu_to_le16(addr);
 920                         if (mem + chunk == 0x4000) {
 921                                 mem = 0x3e00;
 922                                 ++addr;
 923                         }
 924                 } else {
 925                         code[off] = __cpu_to_le16(0x1000 | 28);
 926                         code[off + 31] = 0;
 927                         mem += 28;
 928                 }
 929
 930                 memcpy(&code[off + 2], buf + i, chunk * 2);
 931                 off += 32;
 932         }
 933 done:
 934         kfree(buf);
 935         return off;
 936 }
 937
 938 static int brctrl_to_package(struct go7007 *go,
 939                                         __le16 *code, int space, int *framelen)
 940 {
 941         int converge_speed = 0;
 942         int lambda = (go->format == GO7007_FORMAT_MJPEG || go->dvd_mode) ?
 943                                 100 : 0;
 944         int peak_rate = 6 * go->bitrate / 5;
 945         int vbv_buffer = go->format == GO7007_FORMAT_MJPEG ?
 946                                 go->bitrate :
 947                                 (go->dvd_mode ? 900000 : peak_rate);
 948         int fps = go->sensor_framerate / go->fps_scale;
 949         int q = 0;
 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);
 955         u32 cplx[] = {
 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,
 964         };
 965         u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
 966         u16 pack[] = {
 967                 0x200e,         0x0000,
 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]
 972                                         : 32767,
 973                 0xBF23,         go->ipb ? LAMBDA_table[1][lambda] : 32767,
 974                 0xBF24,         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,
 982                 0xBF2C,         0,
 983                 0xBF2D,         0,
 984                 0,              0,
 985
 986                 0x200e,         0x0000,
 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,
 997                 0xBF38,         0,
 998                 0xBF39,         0,
 999                 0xBF3A,         total_expt_addr & 0x0000FFFF,
1000                 0xBF3B,         total_expt_addr >> 16,
1001                 0,              0,
1002
1003                 0x200e,         0x0000,
1004                 0xBF3C,         total_expt_addr & 0x0000FFFF,
1005                 0xBF3D,         total_expt_addr >> 16,
1006                 0xBF3E,         0,
1007                 0xBF3F,         0,
1008                 0xBF48,         0,
1009                 0xBF49,         0,
1010                 0xBF4A,         calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
1011                 0xBF4B,         4,
1012                 0xBF4C,         0,
1013                 0xBF4D,         0,
1014                 0xBF4E,         0,
1015                 0xBF4F,         0,
1016                 0xBF50,         0,
1017                 0xBF51,         0,
1018                 0,              0,
1019
1020                 0x200e,         0x0000,
1021                 0xBF40,         sgop_expt_addr & 0x0000FFFF,
1022                 0xBF41,         sgop_expt_addr >> 16,
1023                 0xBF42,         0,
1024                 0xBF43,         0,
1025                 0xBF44,         0,
1026                 0xBF45,         0,
1027                 0xBF46,         (go->width >> 4) * (go->height >> 4),
1028                 0xBF47,         0,
1029                 0xBF64,         0,
1030                 0xBF65,         0,
1031                 0xBF18,         framelen[4],
1032                 0xBF19,         framelen[5],
1033                 0xBF1A,         framelen[6],
1034                 0xBF1B,         framelen[7],
1035                 0,              0,
1036
1037 #if 0 /* Remove once we don't care about matching */
1038                 0x200e,         0x0000,
1039                 0xBF56,         4,
1040                 0xBF57,         0,
1041                 0xBF58,         5,
1042                 0xBF59,         0,
1043                 0xBF5A,         6,
1044                 0xBF5B,         0,
1045                 0xBF5C,         8,
1046                 0xBF5D,         0,
1047                 0xBF5E,         1,
1048                 0xBF5F,         0,
1049                 0xBF60,         1,
1050                 0xBF61,         0,
1051                 0xBF62,         0,
1052                 0xBF63,         0,
1053                 0,              0,
1054 #else
1055                 0x2008,         0x0000,
1056                 0xBF56,         4,
1057                 0xBF57,         0,
1058                 0xBF58,         5,
1059                 0xBF59,         0,
1060                 0xBF5A,         6,
1061                 0xBF5B,         0,
1062                 0xBF5C,         8,
1063                 0xBF5D,         0,
1064                 0,              0,
1065                 0,              0,
1066                 0,              0,
1067                 0,              0,
1068                 0,              0,
1069                 0,              0,
1070                 0,              0,
1071 #endif
1072
1073                 0x200e,         0x0000,
1074                 0xBF10,         0,
1075                 0xBF11,         0,
1076                 0xBF12,         0,
1077                 0xBF13,         0,
1078                 0xBF14,         0,
1079                 0xBF15,         0,
1080                 0xBF16,         0,
1081                 0xBF17,         0,
1082                 0xBF7E,         0,
1083                 0xBF7F,         1,
1084                 0xBF52,         framelen[0],
1085                 0xBF53,         framelen[1],
1086                 0xBF54,         framelen[2],
1087                 0xBF55,         framelen[3],
1088                 0,              0,
1089         };
1090
1091         return copy_packages(code, pack, 6, space);
1092 }
1093
1094 static int config_package(struct go7007 *go, __le16 *code, int space)
1095 {
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;
1101         u16 pack[] = {
1102                 0x200e,         0x0000,
1103                 0xc002,         0x14b4,
1104                 0xc003,         0x28b4,
1105                 0xc004,         0x3c5a,
1106                 0xdc05,         0x2a77,
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 :
1111                                                                         0xd3),
1112                 0xc780,         0x0140,
1113                 0xe009,         0x0001,
1114                 0xc60f,         0x0008,
1115                 0xd4ff,         0x0002,
1116                 0xe403,         2340,
1117                 0xe406,         75,
1118                 0xd411,         0x0001,
1119                 0xd410,         0xa1d6,
1120                 0x0001,         0x2801,
1121
1122                 0x200d,         0x0000,
1123                 0xe402,         0x018b,
1124                 0xe401,         0x8b01,
1125                 0xd472,         (go->board_info->sensor_flags &
1126                                                         GO7007_SENSOR_TV) &&
1127                                                 (!go->interlace_coding) ?
1128                                         0x01b0 : 0x0170,
1129                 0xd475,         (go->board_info->sensor_flags &
1130                                                         GO7007_SENSOR_TV) &&
1131                                                 (!go->interlace_coding) ?
1132                                         0x0008 : 0x0009,
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 :
1138                                                                      0x20)))),
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),
1146                 0xbf0b,         0,
1147                 0xdd5a,         go->ipb ? 0x14 : 0x0a,
1148                 0xbf0c,         0,
1149                 0xbf0d,         0,
1150                 0xc683,         THACCoeffSet0,
1151                 0xc40a,         (go->width << 4) | rows,
1152                 0xe01a,         go->board_info->hpi_buffer_cap,
1153                 0,              0,
1154                 0,              0,
1155
1156                 0x2008,         0,
1157                 0xe402,         0x88,
1158                 0xe401,         0x8f01,
1159                 0xbf6a,         0,
1160                 0xbf6b,         0,
1161                 0xbf6c,         0,
1162                 0xbf6d,         0,
1163                 0xbf6e,         0,
1164                 0xbf6f,         0,
1165                 0,              0,
1166                 0,              0,
1167                 0,              0,
1168                 0,              0,
1169                 0,              0,
1170                 0,              0,
1171                 0,              0,
1172
1173                 0x200e,         0,
1174                 0xbf66,         brc_window_size,
1175                 0xbf67,         0,
1176                 0xbf68,         q_min,
1177                 0xbf69,         q_max,
1178                 0xbfe0,         0,
1179                 0xbfe1,         0,
1180                 0xbfe2,         0,
1181                 0xbfe3,         go->ipb ? 3 : 1,
1182                 0xc031,         go->board_info->sensor_flags &
1183                                         GO7007_SENSOR_VBI ? 1 : 0,
1184                 0xc01c,         0x1f,
1185                 0xdd8c,         0x15,
1186                 0xdd94,         0x15,
1187                 0xdd88,         go->ipb ? 0x1401 : 0x0a01,
1188                 0xdd90,         go->ipb ? 0x1401 : 0x0a01,
1189                 0,              0,
1190
1191                 0x200e,         0,
1192                 0xbfe4,         0,
1193                 0xbfe5,         0,
1194                 0xbfe6,         0,
1195                 0xbfe7,         fps << 8,
1196                 0xbfe8,         0x3a00,
1197                 0xbfe9,         0,
1198                 0xbfea,         0,
1199                 0xbfeb,         0,
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),
1204                 0xbfed,         0,
1205                 0xbfee,         0,
1206                 0xbfef,         0,
1207                 0xbff0,         go->board_info->sensor_flags &
1208                                         GO7007_SENSOR_TV ? 0xf060 : 0xb060,
1209                 0xbff1,         0,
1210                 0,              0,
1211         };
1212
1213         return copy_packages(code, pack, 5, space);
1214 }
1215
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))
1219 {
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);
1225         u16 pack[] = {
1226                 0x2006,         0,
1227                 0xbf08,         fps,
1228                 0xbf09,         0,
1229                 0xbff2,         vop_time_increment_bitlength,
1230                 0xbff3,         (1 << vop_time_increment_bitlength) - 1,
1231                 0xbfe6,         0,
1232                 0xbfe7,         (fps / 1000) << 8,
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                 0,              0,
1242
1243                 0x2007,         0,
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],
1248                 0xc406,         64,
1249                 0xc407,         len - 64,
1250                 0xc61b,         1,
1251                 0,              0,
1252                 0,              0,
1253                 0,              0,
1254                 0,              0,
1255                 0,              0,
1256                 0,              0,
1257                 0,              0,
1258                 0,              0,
1259
1260                 0x200e,         0,
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],
1275                 0,              0,
1276                 0,              0,
1277                 0,              0,
1278         };
1279
1280         return copy_packages(code, pack, 3, space);
1281 }
1282
1283 static int relative_prime(int big, int little)
1284 {
1285         int remainder;
1286
1287         while (little != 0) {
1288                 remainder = big % little;
1289                 big = little;
1290                 little = remainder;
1291         }
1292         return big;
1293 }
1294
1295 static int avsync_to_package(struct go7007 *go, __le16 *code, int space)
1296 {
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;
1304         u16 pack[] = {
1305                 0x200e,         0,
1306                 0xbf98,         (u16)((-adjratio) & 0xffff),
1307                 0xbf99,         (u16)((-adjratio) >> 16),
1308                 0xbf92,         0,
1309                 0xbf93,         0,
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,
1314                 0xbff8,         0,
1315                 0xbff9,         0,
1316                 0xbffa,         adjratio & 0xffff,
1317                 0xbffb,         adjratio >> 16,
1318                 0xbf94,         0,
1319                 0xbf95,         0,
1320                 0,              0,
1321         };
1322
1323         return copy_packages(code, pack, 1, space);
1324 }
1325
1326 static int final_package(struct go7007 *go, __le16 *code, int space)
1327 {
1328         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1329         u16 pack[] = {
1330                 0x8000,
1331                 0,
1332                 0,
1333                 0,
1334                 0,
1335                 0,
1336                 0,
1337                 2,
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),
1350                 (1 << 6),
1351                 0,
1352                 0,
1353                 ((go->fps_scale - 1) << 8) |
1354                         (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
1355                                                 (1 << 7) : 0) |
1356                         0x41,
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) |
1363                 /*      (1 << 9) |   */
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,
1375                 0xffff,
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,
1384         };
1385
1386         return copy_packages(code, pack, 1, space);
1387 }
1388
1389 static int audio_to_package(struct go7007 *go, __le16 *code, int space)
1390 {
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);
1397         u16 pack[] = {
1398                 0x200d,         0,
1399                 0x9002,         0,
1400                 0x9002,         0,
1401                 0x9031,         0,
1402                 0x9032,         0,
1403                 0x9033,         0,
1404                 0x9034,         0,
1405                 0x9035,         0,
1406                 0x9036,         0,
1407                 0x9037,         0,
1408                 0x9040,         0,
1409                 0x9000,         clock_config,
1410                 0x9001,         (go->board_info->audio_flags & 0xffff) |
1411                                         (1 << 9),
1412                 0x9000,         ((go->board_info->audio_flags &
1413                                                 GO7007_AUDIO_I2S_MASTER ?
1414                                                 1 : 0) << 10) |
1415                                         clock_config,
1416                 0,              0,
1417                 0,              0,
1418                 0x2005,         0,
1419                 0x9041,         0,
1420                 0x9042,         256,
1421                 0x9043,         0,
1422                 0x9044,         16,
1423                 0x9045,         16,
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                 0,              0,
1434         };
1435
1436         return copy_packages(code, pack, 2, space);
1437 }
1438
1439 static int modet_to_package(struct go7007 *go, __le16 *code, int space)
1440 {
1441         int ret, mb, i, addr, cnt = 0;
1442         u16 pack[32];
1443         u16 thresholds[] = {
1444                 0x200e,         0,
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,
1457                 0xbf8e,         0,
1458                 0xbf8f,         0,
1459                 0,              0,
1460         };
1461
1462         ret = copy_packages(code, thresholds, 1, space);
1463         if (ret < 0)
1464                 return -1;
1465         cnt += ret;
1466
1467         addr = 0xbac0;
1468         memset(pack, 0, 64);
1469         i = 0;
1470         for (mb = 0; mb < 1624; ++mb) {
1471                 pack[i * 2 + 3] <<= 2;
1472                 pack[i * 2 + 3] |= go->modet_map[mb];
1473                 if (mb % 8 != 7)
1474                         continue;
1475                 pack[i * 2 + 2] = addr++;
1476                 ++i;
1477                 if (i == 10 || mb == 1623) {
1478                         pack[0] = 0x2000 | i;
1479                         ret = copy_packages(code + cnt, pack, 1, space - cnt);
1480                         if (ret < 0)
1481                                 return -1;
1482                         cnt += ret;
1483                         i = 0;
1484                         memset(pack, 0, 64);
1485                 }
1486                 pack[i * 2 + 3] = 0;
1487         }
1488
1489         memset(pack, 0, 64);
1490         i = 0;
1491         for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
1492                 pack[i * 2 + 2] = addr;
1493                 pack[i * 2 + 3] = 0;
1494                 ++i;
1495                 if (i == 10 || addr == 0xbbf9) {
1496                         pack[0] = 0x2000 | i;
1497                         ret = copy_packages(code + cnt, pack, 1, space - cnt);
1498                         if (ret < 0)
1499                                 return -1;
1500                         cnt += ret;
1501                         i = 0;
1502                         memset(pack, 0, 64);
1503                 }
1504         }
1505         return cnt;
1506 }
1507
1508 static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
1509                         int *framelen)
1510 {
1511         switch (type) {
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,
1519                                                                 framelen);
1520                 case GO7007_FORMAT_MPEG4:
1521                         return gen_mpeg4hdr_to_package(go, code, space,
1522                                                                 framelen);
1523                 }
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);
1537                 default:
1538                         return 0;
1539                 }
1540         case SPECIAL_AV_SYNC:
1541                 return avsync_to_package(go, code, space);
1542         case SPECIAL_FINAL:
1543                 return final_package(go, code, space);
1544         case SPECIAL_AUDIO:
1545                 return audio_to_package(go, code, space);
1546         case SPECIAL_MODET:
1547                 return modet_to_package(go, code, space);
1548         }
1549         printk(KERN_ERR
1550                 "go7007: firmware file contains unsupported feature %04x\n",
1551                 type);
1552         return -1;
1553 }
1554
1555 int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
1556 {
1557         const struct firmware *fw_entry;
1558         __le16 *code, *src;
1559         int framelen[8] = { }; /* holds the lengths of empty frame templates */
1560         int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
1561         int mode_flag;
1562         int ret;
1563
1564         switch (go->format) {
1565         case GO7007_FORMAT_MJPEG:
1566                 mode_flag = FLAG_MODE_MJPEG;
1567                 break;
1568         case GO7007_FORMAT_MPEG1:
1569                 mode_flag = FLAG_MODE_MPEG1;
1570                 break;
1571         case GO7007_FORMAT_MPEG2:
1572                 mode_flag = FLAG_MODE_MPEG2;
1573                 break;
1574         case GO7007_FORMAT_MPEG4:
1575                 mode_flag = FLAG_MODE_MPEG4;
1576                 break;
1577         default:
1578                 return -1;
1579         }
1580         if (request_firmware(&fw_entry, go->board_info->firmware, go->dev)) {
1581                 printk(KERN_ERR
1582                         "go7007: unable to load firmware from file \"%s\"\n",
1583                         go->board_info->firmware);
1584                 return -1;
1585         }
1586         code = kmalloc(codespace * 2, GFP_KERNEL);
1587         if (code == NULL) {
1588                 printk(KERN_ERR "go7007: unable to allocate %d bytes for "
1589                                 "firmware construction\n", codespace * 2);
1590                 goto fw_failed;
1591         }
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);
1602                         goto fw_failed;
1603                 }
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);
1608                                 if (ret < 0) {
1609                                         printk(KERN_ERR "go7007: insufficient "
1610                                                         "memory for firmware "
1611                                                         "construction\n");
1612                                         goto fw_failed;
1613                                 }
1614                                 i += ret;
1615                         } else {
1616                                 if (codespace - i < chunk_len) {
1617                                         printk(KERN_ERR "go7007: insufficient "
1618                                                         "memory for firmware "
1619                                                         "construction\n");
1620                                         goto fw_failed;
1621                                 }
1622                                 memcpy(&code[i], &src[2], chunk_len * 2);
1623                                 i += chunk_len;
1624                         }
1625                 }
1626                 srclen -= chunk_len + 2;
1627                 src += chunk_len + 2;
1628         }
1629         release_firmware(fw_entry);
1630         *fw = (u8 *)code;
1631         *fwlen = i * 2;
1632         return 0;
1633
1634 fw_failed:
1635         kfree(code);
1636         release_firmware(fw_entry);
1637         return -1;
1638 }