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 <linux/slab.h>
  35 #include <asm/byteorder.h>
  36
  37 #include "go7007-priv.h"
  38
  39 /* Constants used in the source firmware image to describe code segments */
  40
  41 #define FLAG_MODE_MJPEG         (1)
  42 #define FLAG_MODE_MPEG1         (1<<1)
  43 #define FLAG_MODE_MPEG2         (1<<2)
  44 #define FLAG_MODE_MPEG4         (1<<3)
  45 #define FLAG_MODE_H263          (1<<4)
  46 #define FLAG_MODE_ALL           (FLAG_MODE_MJPEG | FLAG_MODE_MPEG1 | \
  47                                         FLAG_MODE_MPEG2 | FLAG_MODE_MPEG4 | \
  48                                         FLAG_MODE_H263)
  49 #define FLAG_SPECIAL            (1<<8)
  50
  51 #define SPECIAL_FRM_HEAD        0
  52 #define SPECIAL_BRC_CTRL        1
  53 #define SPECIAL_CONFIG          2
  54 #define SPECIAL_SEQHEAD         3
  55 #define SPECIAL_AV_SYNC         4
  56 #define SPECIAL_FINAL           5
  57 #define SPECIAL_AUDIO           6
  58 #define SPECIAL_MODET           7
  59
  60 /* Little data class for creating MPEG headers bit-by-bit */
  61
  62 struct code_gen {
  63         unsigned char *p; /* destination */
  64         u32 a; /* collects bits at the top of the variable */
  65         int b; /* bit position of most recently-written bit */
  66         int len; /* written out so far */
  67 };
  68
  69 #define CODE_GEN(name, dest) struct code_gen name = { dest, 0, 32, 0 }
  70
  71 #define CODE_ADD(name, val, length) do { \
  72         name.b -= (length); \
  73         name.a |= (val) << name.b; \
  74         while (name.b <= 24) { \
  75                 *name.p = name.a >> 24; \
  76                 ++name.p; \
  77                 name.a <<= 8; \
  78                 name.b += 8; \
  79                 name.len += 8; \
  80         } \
  81 } while (0)
  82
  83 #define CODE_LENGTH(name) (name.len + (32 - name.b))
  84
  85 /* Tables for creating the bitrate control data */
  86
  87 static const s16 converge_speed_ip[101] = {
  88         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  89         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  90         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  91         1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
  92         2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
  93         3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
  94         5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
  95         9, 10, 10, 11, 12, 13, 14, 15, 16, 17,
  96         19, 20, 22, 23, 25, 27, 30, 32, 35, 38,
  97         41, 45, 49, 53, 58, 63, 69, 76, 83, 91,
  98         100
  99 };
 100
 101 static const s16 converge_speed_ipb[101] = {
 102         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 103         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 104         3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
 105         4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
 106         6, 6, 6, 7, 7, 7, 7, 8, 8, 9,
 107         9, 9, 10, 10, 11, 12, 12, 13, 14, 14,
 108         15, 16, 17, 18, 19, 20, 22, 23, 25, 26,
 109         28, 30, 32, 34, 37, 40, 42, 46, 49, 53,
 110         57, 61, 66, 71, 77, 83, 90, 97, 106, 115,
 111         125, 135, 147, 161, 175, 191, 209, 228, 249, 273,
 112         300
 113 };
 114
 115 static const s16 LAMBDA_table[4][101] = {
 116         {       16, 16, 16, 16, 17, 17, 17, 18, 18, 18,
 117                 19, 19, 19, 20, 20, 20, 21, 21, 22, 22,
 118                 22, 23, 23, 24, 24, 25, 25, 25, 26, 26,
 119                 27, 27, 28, 28, 29, 29, 30, 31, 31, 32,
 120                 32, 33, 33, 34, 35, 35, 36, 37, 37, 38,
 121                 39, 39, 40, 41, 42, 42, 43, 44, 45, 46,
 122                 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
 123                 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
 124                 67, 68, 69, 70, 72, 73, 74, 76, 77, 78,
 125                 80, 81, 83, 84, 86, 87, 89, 90, 92, 94,
 126                 96
 127         },
 128         {
 129                 20, 20, 20, 21, 21, 21, 22, 22, 23, 23,
 130                 23, 24, 24, 25, 25, 26, 26, 27, 27, 28,
 131                 28, 29, 29, 30, 30, 31, 31, 32, 33, 33,
 132                 34, 34, 35, 36, 36, 37, 38, 38, 39, 40,
 133                 40, 41, 42, 43, 43, 44, 45, 46, 47, 48,
 134                 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
 135                 58, 59, 60, 61, 62, 64, 65, 66, 67, 68,
 136                 70, 71, 72, 73, 75, 76, 78, 79, 80, 82,
 137                 83, 85, 86, 88, 90, 91, 93, 95, 96, 98,
 138                 100, 102, 103, 105, 107, 109, 111, 113, 115, 117,
 139                 120
 140         },
 141         {
 142                 24, 24, 24, 25, 25, 26, 26, 27, 27, 28,
 143                 28, 29, 29, 30, 30, 31, 31, 32, 33, 33,
 144                 34, 34, 35, 36, 36, 37, 38, 38, 39, 40,
 145                 41, 41, 42, 43, 44, 44, 45, 46, 47, 48,
 146                 49, 50, 50, 51, 52, 53, 54, 55, 56, 57,
 147                 58, 59, 60, 62, 63, 64, 65, 66, 67, 69,
 148                 70, 71, 72, 74, 75, 76, 78, 79, 81, 82,
 149                 84, 85, 87, 88, 90, 92, 93, 95, 97, 98,
 150                 100, 102, 104, 106, 108, 110, 112, 114, 116, 118,
 151                 120, 122, 124, 127, 129, 131, 134, 136, 138, 141,
 152                 144
 153         },
 154         {
 155                 32, 32, 33, 33, 34, 34, 35, 36, 36, 37,
 156                 38, 38, 39, 40, 41, 41, 42, 43, 44, 44,
 157                 45, 46, 47, 48, 49, 50, 50, 51, 52, 53,
 158                 54, 55, 56, 57, 58, 59, 60, 62, 63, 64,
 159                 65, 66, 67, 69, 70, 71, 72, 74, 75, 76,
 160                 78, 79, 81, 82, 84, 85, 87, 88, 90, 92,
 161                 93, 95, 97, 98, 100, 102, 104, 106, 108, 110,
 162                 112, 114, 116, 118, 120, 122, 124, 127, 129, 131,
 163                 134, 136, 139, 141, 144, 146, 149, 152, 154, 157,
 164                 160, 163, 166, 169, 172, 175, 178, 181, 185, 188,
 165                 192
 166         }
 167 };
 168
 169 /* MPEG blank frame generation tables */
 170
 171 enum mpeg_frame_type {
 172         PFRAME,
 173         BFRAME_PRE,
 174         BFRAME_POST,
 175         BFRAME_BIDIR,
 176         BFRAME_EMPTY
 177 };
 178
 179 static const u32 addrinctab[33][2] = {
 180         { 0x01, 1 },    { 0x03, 3 },    { 0x02, 3 },    { 0x03, 4 },
 181         { 0x02, 4 },    { 0x03, 5 },    { 0x02, 5 },    { 0x07, 7 },
 182         { 0x06, 7 },    { 0x0b, 8 },    { 0x0a, 8 },    { 0x09, 8 },
 183         { 0x08, 8 },    { 0x07, 8 },    { 0x06, 8 },    { 0x17, 10 },
 184         { 0x16, 10 },   { 0x15, 10 },   { 0x14, 10 },   { 0x13, 10 },
 185         { 0x12, 10 },   { 0x23, 11 },   { 0x22, 11 },   { 0x21, 11 },
 186         { 0x20, 11 },   { 0x1f, 11 },   { 0x1e, 11 },   { 0x1d, 11 },
 187         { 0x1c, 11 },   { 0x1b, 11 },   { 0x1a, 11 },   { 0x19, 11 },
 188         { 0x18, 11 }
 189 };
 190
 191 /* Standard JPEG tables */
 192
 193 static const u8 default_intra_quant_table[] = {
 194          8, 16, 19, 22, 26, 27, 29, 34,
 195         16, 16, 22, 24, 27, 29, 34, 37,
 196         19, 22, 26, 27, 29, 34, 34, 38,
 197         22, 22, 26, 27, 29, 34, 37, 40,
 198         22, 26, 27, 29, 32, 35, 40, 48,
 199         26, 27, 29, 32, 35, 40, 48, 58,
 200         26, 27, 29, 34, 38, 46, 56, 69,
 201         27, 29, 35, 38, 46, 56, 69, 83
 202 };
 203
 204 static const u8 bits_dc_luminance[] = {
 205         0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
 206 };
 207
 208 static const u8 val_dc_luminance[] = {
 209         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
 210 };
 211
 212 static const u8 bits_dc_chrominance[] = {
 213         0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
 214 };
 215
 216 static const u8 val_dc_chrominance[] = {
 217         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
 218 };
 219
 220 static const u8 bits_ac_luminance[] = {
 221         0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
 222 };
 223
 224 static const u8 val_ac_luminance[] = {
 225         0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 226         0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 227         0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 228         0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 229         0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 230         0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 231         0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 232         0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 233         0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 234         0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 235         0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 236         0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 237         0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 238         0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 239         0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 240         0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 241         0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 242         0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 243         0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 244         0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 245         0xf9, 0xfa
 246 };
 247
 248 static const u8 bits_ac_chrominance[] = {
 249         0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
 250 };
 251
 252 static const u8 val_ac_chrominance[] = {
 253         0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 254         0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 255         0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 256         0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 257         0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 258         0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 259         0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 260         0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 261         0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 262         0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 263         0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 264         0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 265         0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 266         0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 267         0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 268         0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 269         0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 270         0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 271         0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 272         0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 273         0xf9, 0xfa
 274 };
 275
 276 /* Zig-zag mapping for quant table
 277  *
 278  * OK, let's do this mapping on the actual table above so it doesn't have
 279  * to be done on the fly.
 280  */
 281 static const int zz[64] = {
 282         0,   1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
 283         12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
 284         35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
 285         58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
 286 };
 287
 288 static int copy_packages(__le16 *dest, u16 *src, int pkg_cnt, int space)
 289 {
 290         int i, cnt = pkg_cnt * 32;
 291
 292         if (space < cnt)
 293                 return -1;
 294
 295         for (i = 0; i < cnt; ++i)
 296                 dest[i] = cpu_to_le16p(src + i);
 297
 298         return cnt;
 299 }
 300
 301 static int mjpeg_frame_header(struct go7007 *go, unsigned char *buf, int q)
 302 {
 303         int i, p = 0;
 304
 305         buf[p++] = 0xff;
 306         buf[p++] = 0xd8;
 307         buf[p++] = 0xff;
 308         buf[p++] = 0xdb;
 309         buf[p++] = 0;
 310         buf[p++] = 2 + 65;
 311         buf[p++] = 0;
 312         buf[p++] = default_intra_quant_table[0];
 313         for (i = 1; i < 64; ++i)
 314                 /* buf[p++] = (default_intra_quant_table[i] * q) >> 3; */
 315                 buf[p++] = (default_intra_quant_table[zz[i]] * q) >> 3;
 316         buf[p++] = 0xff;
 317         buf[p++] = 0xc0;
 318         buf[p++] = 0;
 319         buf[p++] = 17;
 320         buf[p++] = 8;
 321         buf[p++] = go->height >> 8;
 322         buf[p++] = go->height & 0xff;
 323         buf[p++] = go->width >> 8;
 324         buf[p++] = go->width & 0xff;
 325         buf[p++] = 3;
 326         buf[p++] = 1;
 327         buf[p++] = 0x22;
 328         buf[p++] = 0;
 329         buf[p++] = 2;
 330         buf[p++] = 0x11;
 331         buf[p++] = 0;
 332         buf[p++] = 3;
 333         buf[p++] = 0x11;
 334         buf[p++] = 0;
 335         buf[p++] = 0xff;
 336         buf[p++] = 0xc4;
 337         buf[p++] = 418 >> 8;
 338         buf[p++] = 418 & 0xff;
 339         buf[p++] = 0x00;
 340         memcpy(buf + p, bits_dc_luminance + 1, 16);
 341         p += 16;
 342         memcpy(buf + p, val_dc_luminance, sizeof(val_dc_luminance));
 343         p += sizeof(val_dc_luminance);
 344         buf[p++] = 0x01;
 345         memcpy(buf + p, bits_dc_chrominance + 1, 16);
 346         p += 16;
 347         memcpy(buf + p, val_dc_chrominance, sizeof(val_dc_chrominance));
 348         p += sizeof(val_dc_chrominance);
 349         buf[p++] = 0x10;
 350         memcpy(buf + p, bits_ac_luminance + 1, 16);
 351         p += 16;
 352         memcpy(buf + p, val_ac_luminance, sizeof(val_ac_luminance));
 353         p += sizeof(val_ac_luminance);
 354         buf[p++] = 0x11;
 355         memcpy(buf + p, bits_ac_chrominance + 1, 16);
 356         p += 16;
 357         memcpy(buf + p, val_ac_chrominance, sizeof(val_ac_chrominance));
 358         p += sizeof(val_ac_chrominance);
 359         buf[p++] = 0xff;
 360         buf[p++] = 0xda;
 361         buf[p++] = 0;
 362         buf[p++] = 12;
 363         buf[p++] = 3;
 364         buf[p++] = 1;
 365         buf[p++] = 0x00;
 366         buf[p++] = 2;
 367         buf[p++] = 0x11;
 368         buf[p++] = 3;
 369         buf[p++] = 0x11;
 370         buf[p++] = 0;
 371         buf[p++] = 63;
 372         buf[p++] = 0;
 373         return p;
 374 }
 375
 376 static int gen_mjpeghdr_to_package(struct go7007 *go, __le16 *code, int space)
 377 {
 378         u8 *buf;
 379         u16 mem = 0x3e00;
 380         unsigned int addr = 0x19;
 381         int size = 0, i, off = 0, chunk;
 382
 383         buf = kzalloc(4096, GFP_KERNEL);
 384         if (buf == NULL) {
 385                 printk(KERN_ERR "go7007: unable to allocate 4096 bytes for "
 386                                 "firmware construction\n");
 387                 return -1;
 388         }
 389
 390         for (i = 1; i < 32; ++i) {
 391                 mjpeg_frame_header(go, buf + size, i);
 392                 size += 80;
 393         }
 394         chunk = mjpeg_frame_header(go, buf + size, 1);
 395         memmove(buf + size, buf + size + 80, chunk - 80);
 396         size += chunk - 80;
 397
 398         for (i = 0; i < size; i += chunk * 2) {
 399                 if (space - off < 32) {
 400                         off = -1;
 401                         goto done;
 402                 }
 403
 404                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 405
 406                 chunk = 28;
 407                 if (mem + chunk > 0x4000)
 408                         chunk = 0x4000 - mem;
 409                 if (i + 2 * chunk > size)
 410                         chunk = (size - i) / 2;
 411
 412                 if (chunk < 28) {
 413                         code[off] = __cpu_to_le16(0x4000 | chunk);
 414                         code[off + 31] = __cpu_to_le16(addr++);
 415                         mem = 0x3e00;
 416                 } else {
 417                         code[off] = __cpu_to_le16(0x1000 | 28);
 418                         code[off + 31] = 0;
 419                         mem += 28;
 420                 }
 421
 422                 memcpy(&code[off + 2], buf + i, chunk * 2);
 423                 off += 32;
 424         }
 425 done:
 426         kfree(buf);
 427         return off;
 428 }
 429
 430 static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf,
 431                 int modulo, int pict_struct, enum mpeg_frame_type frame)
 432 {
 433         int i, j, mb_code, mb_len;
 434         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
 435         CODE_GEN(c, buf + 6);
 436
 437         switch (frame) {
 438         case PFRAME:
 439                 mb_code = 0x1;
 440                 mb_len = 3;
 441                 break;
 442         case BFRAME_PRE:
 443                 mb_code = 0x2;
 444                 mb_len = 4;
 445                 break;
 446         case BFRAME_POST:
 447                 mb_code = 0x2;
 448                 mb_len = 3;
 449                 break;
 450         case BFRAME_BIDIR:
 451                 mb_code = 0x2;
 452                 mb_len = 2;
 453                 break;
 454         default: /* keep the compiler happy */
 455                 mb_code = mb_len = 0;
 456                 break;
 457         }
 458
 459         CODE_ADD(c, frame == PFRAME ? 0x2 : 0x3, 13);
 460         CODE_ADD(c, 0xffff, 16);
 461         CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
 462         if (frame != PFRAME)
 463                 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
 464         else
 465                 CODE_ADD(c, 0, 4); /* Is this supposed to be here?? */
 466         CODE_ADD(c, 0, 3); /* What is this?? */
 467         /* Byte-align with zeros */
 468         j = 8 - (CODE_LENGTH(c) % 8);
 469         if (j != 8)
 470                 CODE_ADD(c, 0, j);
 471
 472         if (go->format == GO7007_FORMAT_MPEG2) {
 473                 CODE_ADD(c, 0x1, 24);
 474                 CODE_ADD(c, 0xb5, 8);
 475                 CODE_ADD(c, 0x844, 12);
 476                 CODE_ADD(c, frame == PFRAME ? 0xff : 0x44, 8);
 477                 if (go->interlace_coding) {
 478                         CODE_ADD(c, pict_struct, 4);
 479                         if (go->dvd_mode)
 480                                 CODE_ADD(c, 0x000, 11);
 481                         else
 482                                 CODE_ADD(c, 0x200, 11);
 483                 } else {
 484                         CODE_ADD(c, 0x3, 4);
 485                         CODE_ADD(c, 0x20c, 11);
 486                 }
 487                 /* Byte-align with zeros */
 488                 j = 8 - (CODE_LENGTH(c) % 8);
 489                 if (j != 8)
 490                         CODE_ADD(c, 0, j);
 491         }
 492
 493         for (i = 0; i < rows; ++i) {
 494                 CODE_ADD(c, 1, 24);
 495                 CODE_ADD(c, i + 1, 8);
 496                 CODE_ADD(c, 0x2, 6);
 497                 CODE_ADD(c, 0x1, 1);
 498                 CODE_ADD(c, mb_code, mb_len);
 499                 if (go->interlace_coding) {
 500                         CODE_ADD(c, 0x1, 2);
 501                         CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 502                 }
 503                 if (frame == BFRAME_BIDIR) {
 504                         CODE_ADD(c, 0x3, 2);
 505                         if (go->interlace_coding)
 506                                 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 507                 }
 508                 CODE_ADD(c, 0x3, 2);
 509                 for (j = (go->width >> 4) - 2; j >= 33; j -= 33)
 510                         CODE_ADD(c, 0x8, 11);
 511                 CODE_ADD(c, addrinctab[j][0], addrinctab[j][1]);
 512                 CODE_ADD(c, mb_code, mb_len);
 513                 if (go->interlace_coding) {
 514                         CODE_ADD(c, 0x1, 2);
 515                         CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 516                 }
 517                 if (frame == BFRAME_BIDIR) {
 518                         CODE_ADD(c, 0x3, 2);
 519                         if (go->interlace_coding)
 520                                 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 521                 }
 522                 CODE_ADD(c, 0x3, 2);
 523
 524                 /* Byte-align with zeros */
 525                 j = 8 - (CODE_LENGTH(c) % 8);
 526                 if (j != 8)
 527                         CODE_ADD(c, 0, j);
 528         }
 529
 530         i = CODE_LENGTH(c) + 4 * 8;
 531         buf[2] = 0x00;
 532         buf[3] = 0x00;
 533         buf[4] = 0x01;
 534         buf[5] = 0x00;
 535         return i;
 536 }
 537
 538 static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
 539 {
 540         int i, aspect_ratio, picture_rate;
 541         CODE_GEN(c, buf + 6);
 542
 543         if (go->format == GO7007_FORMAT_MPEG1) {
 544                 switch (go->aspect_ratio) {
 545                 case GO7007_RATIO_4_3:
 546                         aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
 547                         break;
 548                 case GO7007_RATIO_16_9:
 549                         aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
 550                         break;
 551                 default:
 552                         aspect_ratio = 1;
 553                         break;
 554                 }
 555         } else {
 556                 switch (go->aspect_ratio) {
 557                 case GO7007_RATIO_4_3:
 558                         aspect_ratio = 2;
 559                         break;
 560                 case GO7007_RATIO_16_9:
 561                         aspect_ratio = 3;
 562                         break;
 563                 default:
 564                         aspect_ratio = 1;
 565                         break;
 566                 }
 567         }
 568         switch (go->sensor_framerate) {
 569         case 24000:
 570                 picture_rate = 1;
 571                 break;
 572         case 24024:
 573                 picture_rate = 2;
 574                 break;
 575         case 25025:
 576                 picture_rate = go->interlace_coding ? 6 : 3;
 577                 break;
 578         case 30000:
 579                 picture_rate = go->interlace_coding ? 7 : 4;
 580                 break;
 581         case 30030:
 582                 picture_rate = go->interlace_coding ? 8 : 5;
 583                 break;
 584         default:
 585                 picture_rate = 5; /* 30 fps seems like a reasonable default */
 586                 break;
 587         }
 588
 589         CODE_ADD(c, go->width, 12);
 590         CODE_ADD(c, go->height, 12);
 591         CODE_ADD(c, aspect_ratio, 4);
 592         CODE_ADD(c, picture_rate, 4);
 593         CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 20000 : 0x3ffff, 18);
 594         CODE_ADD(c, 1, 1);
 595         CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 112 : 20, 10);
 596         CODE_ADD(c, 0, 3);
 597
 598         /* Byte-align with zeros */
 599         i = 8 - (CODE_LENGTH(c) % 8);
 600         if (i != 8)
 601                 CODE_ADD(c, 0, i);
 602
 603         if (go->format == GO7007_FORMAT_MPEG2) {
 604                 CODE_ADD(c, 0x1, 24);
 605                 CODE_ADD(c, 0xb5, 8);
 606                 CODE_ADD(c, 0x148, 12);
 607                 if (go->interlace_coding)
 608                         CODE_ADD(c, 0x20001, 20);
 609                 else
 610                         CODE_ADD(c, 0xa0001, 20);
 611                 CODE_ADD(c, 0, 16);
 612
 613                 /* Byte-align with zeros */
 614                 i = 8 - (CODE_LENGTH(c) % 8);
 615                 if (i != 8)
 616                         CODE_ADD(c, 0, i);
 617
 618                 if (ext) {
 619                         CODE_ADD(c, 0x1, 24);
 620                         CODE_ADD(c, 0xb52, 12);
 621                         CODE_ADD(c, go->standard == GO7007_STD_NTSC ? 2 : 1, 3);
 622                         CODE_ADD(c, 0x105, 9);
 623                         CODE_ADD(c, 0x505, 16);
 624                         CODE_ADD(c, go->width, 14);
 625                         CODE_ADD(c, 1, 1);
 626                         CODE_ADD(c, go->height, 14);
 627
 628                         /* Byte-align with zeros */
 629                         i = 8 - (CODE_LENGTH(c) % 8);
 630                         if (i != 8)
 631                                 CODE_ADD(c, 0, i);
 632                 }
 633         }
 634
 635         i = CODE_LENGTH(c) + 4 * 8;
 636         buf[0] = i & 0xff;
 637         buf[1] = i >> 8;
 638         buf[2] = 0x00;
 639         buf[3] = 0x00;
 640         buf[4] = 0x01;
 641         buf[5] = 0xb3;
 642         return i;
 643 }
 644
 645 static int gen_mpeg1hdr_to_package(struct go7007 *go,
 646                                         __le16 *code, int space, int *framelen)
 647 {
 648         u8 *buf;
 649         u16 mem = 0x3e00;
 650         unsigned int addr = 0x19;
 651         int i, off = 0, chunk;
 652
 653         buf = kzalloc(5120, GFP_KERNEL);
 654         if (buf == NULL) {
 655                 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
 656                                 "firmware construction\n");
 657                 return -1;
 658         }
 659         framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME);
 660         if (go->interlace_coding)
 661                 framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8,
 662                                                         0, 2, PFRAME);
 663         buf[0] = framelen[0] & 0xff;
 664         buf[1] = framelen[0] >> 8;
 665         i = 368;
 666         framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE);
 667         if (go->interlace_coding)
 668                 framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8,
 669                                                         0, 2, BFRAME_PRE);
 670         buf[i] = framelen[1] & 0xff;
 671         buf[i + 1] = framelen[1] >> 8;
 672         i += 1632;
 673         framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST);
 674         if (go->interlace_coding)
 675                 framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8,
 676                                                         0, 2, BFRAME_POST);
 677         buf[i] = framelen[2] & 0xff;
 678         buf[i + 1] = framelen[2] >> 8;
 679         i += 1432;
 680         framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR);
 681         if (go->interlace_coding)
 682                 framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8,
 683                                                         0, 2, BFRAME_BIDIR);
 684         buf[i] = framelen[3] & 0xff;
 685         buf[i + 1] = framelen[3] >> 8;
 686         i += 1632 + 16;
 687         mpeg1_sequence_header(go, buf + i, 0);
 688         i += 40;
 689         for (i = 0; i < 5120; i += chunk * 2) {
 690                 if (space - off < 32) {
 691                         off = -1;
 692                         goto done;
 693                 }
 694
 695                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 696
 697                 chunk = 28;
 698                 if (mem + chunk > 0x4000)
 699                         chunk = 0x4000 - mem;
 700                 if (i + 2 * chunk > 5120)
 701                         chunk = (5120 - i) / 2;
 702
 703                 if (chunk < 28) {
 704                         code[off] = __cpu_to_le16(0x4000 | chunk);
 705                         code[off + 31] = __cpu_to_le16(addr);
 706                         if (mem + chunk == 0x4000) {
 707                                 mem = 0x3e00;
 708                                 ++addr;
 709                         }
 710                 } else {
 711                         code[off] = __cpu_to_le16(0x1000 | 28);
 712                         code[off + 31] = 0;
 713                         mem += 28;
 714                 }
 715
 716                 memcpy(&code[off + 2], buf + i, chunk * 2);
 717                 off += 32;
 718         }
 719 done:
 720         kfree(buf);
 721         return off;
 722 }
 723
 724 static int vti_bitlen(struct go7007 *go)
 725 {
 726         unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
 727
 728         for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i);
 729         return i + 1;
 730 }
 731
 732 static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
 733                 int modulo, enum mpeg_frame_type frame)
 734 {
 735         int i;
 736         CODE_GEN(c, buf + 6);
 737         int mb_count = (go->width >> 4) * (go->height >> 4);
 738
 739         CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
 740         if (modulo)
 741                 CODE_ADD(c, 0x1, 1);
 742         CODE_ADD(c, 0x1, 2);
 743         CODE_ADD(c, 0, vti_bitlen(go));
 744         CODE_ADD(c, 0x3, 2);
 745         if (frame == PFRAME)
 746                 CODE_ADD(c, 0, 1);
 747         CODE_ADD(c, 0xc, 11);
 748         if (frame != PFRAME)
 749                 CODE_ADD(c, 0x4, 3);
 750         if (frame != BFRAME_EMPTY) {
 751                 for (i = 0; i < mb_count; ++i) {
 752                         switch (frame) {
 753                         case PFRAME:
 754                                 CODE_ADD(c, 0x1, 1);
 755                                 break;
 756                         case BFRAME_PRE:
 757                                 CODE_ADD(c, 0x47, 8);
 758                                 break;
 759                         case BFRAME_POST:
 760                                 CODE_ADD(c, 0x27, 7);
 761                                 break;
 762                         case BFRAME_BIDIR:
 763                                 CODE_ADD(c, 0x5f, 8);
 764                                 break;
 765                         case BFRAME_EMPTY: /* keep compiler quiet */
 766                                 break;
 767                         }
 768                 }
 769         }
 770
 771         /* Byte-align with a zero followed by ones */
 772         i = 8 - (CODE_LENGTH(c) % 8);
 773         CODE_ADD(c, 0, 1);
 774         CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
 775
 776         i = CODE_LENGTH(c) + 4 * 8;
 777         buf[0] = i & 0xff;
 778         buf[1] = i >> 8;
 779         buf[2] = 0x00;
 780         buf[3] = 0x00;
 781         buf[4] = 0x01;
 782         buf[5] = 0xb6;
 783         return i;
 784 }
 785
 786 static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
 787 {
 788         const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali,
 789                 0x00, 0x00, 0x01, 0xb5, 0x09,
 790                 0x00, 0x00, 0x01, 0x00,
 791                 0x00, 0x00, 0x01, 0x20, };
 792         int i, aspect_ratio;
 793         int fps = go->sensor_framerate / go->fps_scale;
 794         CODE_GEN(c, buf + 2 + sizeof(head));
 795
 796         switch (go->aspect_ratio) {
 797         case GO7007_RATIO_4_3:
 798                 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
 799                 break;
 800         case GO7007_RATIO_16_9:
 801                 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
 802                 break;
 803         default:
 804                 aspect_ratio = 1;
 805                 break;
 806         }
 807
 808         memcpy(buf + 2, head, sizeof(head));
 809         CODE_ADD(c, 0x191, 17);
 810         CODE_ADD(c, aspect_ratio, 4);
 811         CODE_ADD(c, 0x1, 4);
 812         CODE_ADD(c, fps, 16);
 813         CODE_ADD(c, 0x3, 2);
 814         CODE_ADD(c, 1001, vti_bitlen(go));
 815         CODE_ADD(c, 1, 1);
 816         CODE_ADD(c, go->width, 13);
 817         CODE_ADD(c, 1, 1);
 818         CODE_ADD(c, go->height, 13);
 819         CODE_ADD(c, 0x2830, 14);
 820
 821         /* Byte-align */
 822         i = 8 - (CODE_LENGTH(c) % 8);
 823         CODE_ADD(c, 0, 1);
 824         CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
 825
 826         i = CODE_LENGTH(c) + sizeof(head) * 8;
 827         buf[0] = i & 0xff;
 828         buf[1] = i >> 8;
 829         return i;
 830 }
 831
 832 static int gen_mpeg4hdr_to_package(struct go7007 *go,
 833                                         __le16 *code, int space, int *framelen)
 834 {
 835         u8 *buf;
 836         u16 mem = 0x3e00;
 837         unsigned int addr = 0x19;
 838         int i, off = 0, chunk;
 839
 840         buf = kzalloc(5120, GFP_KERNEL);
 841         if (buf == NULL) {
 842                 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
 843                                 "firmware construction\n");
 844                 return -1;
 845         }
 846         framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
 847         i = 368;
 848         framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
 849         i += 1632;
 850         framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
 851         i += 1432;
 852         framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
 853         i += 1632;
 854         mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
 855         i += 16;
 856         mpeg4_sequence_header(go, buf + i, 0);
 857         i += 40;
 858         for (i = 0; i < 5120; i += chunk * 2) {
 859                 if (space - off < 32) {
 860                         off = -1;
 861                         goto done;
 862                 }
 863
 864                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 865
 866                 chunk = 28;
 867                 if (mem + chunk > 0x4000)
 868                         chunk = 0x4000 - mem;
 869                 if (i + 2 * chunk > 5120)
 870                         chunk = (5120 - i) / 2;
 871
 872                 if (chunk < 28) {
 873                         code[off] = __cpu_to_le16(0x4000 | chunk);
 874                         code[off + 31] = __cpu_to_le16(addr);
 875                         if (mem + chunk == 0x4000) {
 876                                 mem = 0x3e00;
 877                                 ++addr;
 878                         }
 879                 } else {
 880                         code[off] = __cpu_to_le16(0x1000 | 28);
 881                         code[off + 31] = 0;
 882                         mem += 28;
 883                 }
 884
 885                 memcpy(&code[off + 2], buf + i, chunk * 2);
 886                 off += 32;
 887         }
 888         mem = 0x3e00;
 889         addr = go->ipb ? 0x14f9 : 0x0af9;
 890         memset(buf, 0, 5120);
 891         framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
 892         i = 368;
 893         framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
 894         i += 1632;
 895         framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
 896         i += 1432;
 897         framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
 898         i += 1632;
 899         mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
 900         i += 16;
 901         for (i = 0; i < 5120; i += chunk * 2) {
 902                 if (space - off < 32) {
 903                         off = -1;
 904                         goto done;
 905                 }
 906
 907                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 908
 909                 chunk = 28;
 910                 if (mem + chunk > 0x4000)
 911                         chunk = 0x4000 - mem;
 912                 if (i + 2 * chunk > 5120)
 913                         chunk = (5120 - i) / 2;
 914
 915                 if (chunk < 28) {
 916                         code[off] = __cpu_to_le16(0x4000 | chunk);
 917                         code[off + 31] = __cpu_to_le16(addr);
 918                         if (mem + chunk == 0x4000) {
 919                                 mem = 0x3e00;
 920                                 ++addr;
 921                         }
 922                 } else {
 923                         code[off] = __cpu_to_le16(0x1000 | 28);
 924                         code[off + 31] = 0;
 925                         mem += 28;
 926                 }
 927
 928                 memcpy(&code[off + 2], buf + i, chunk * 2);
 929                 off += 32;
 930         }
 931 done:
 932         kfree(buf);
 933         return off;
 934 }
 935
 936 static int brctrl_to_package(struct go7007 *go,
 937                                         __le16 *code, int space, int *framelen)
 938 {
 939         int converge_speed = 0;
 940         int lambda = (go->format == GO7007_FORMAT_MJPEG || go->dvd_mode) ?
 941                                 100 : 0;
 942         int peak_rate = 6 * go->bitrate / 5;
 943         int vbv_buffer = go->format == GO7007_FORMAT_MJPEG ?
 944                                 go->bitrate :
 945                                 (go->dvd_mode ? 900000 : peak_rate);
 946         int fps = go->sensor_framerate / go->fps_scale;
 947         int q = 0;
 948         /* Bizarre math below depends on rounding errors in division */
 949         u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps;
 950         u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps;
 951         u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000);
 952         u32 vbv_alert_addr = vbv_buffer * 3 / (4 * 32);
 953         u32 cplx[] = {
 954                 q > 0 ? sgop_expt_addr * q :
 955                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 956                 q > 0 ? sgop_expt_addr * q :
 957                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 958                 q > 0 ? sgop_expt_addr * q :
 959                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 960                 q > 0 ? sgop_expt_addr * q :
 961                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 962         };
 963         u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
 964         u16 pack[] = {
 965                 0x200e,         0x0000,
 966                 0xBF20,         go->ipb ? converge_speed_ipb[converge_speed]
 967                                         : converge_speed_ip[converge_speed],
 968                 0xBF21,         go->ipb ? 2 : 0,
 969                 0xBF22,         go->ipb ? LAMBDA_table[0][lambda / 2 + 50]
 970                                         : 32767,
 971                 0xBF23,         go->ipb ? LAMBDA_table[1][lambda] : 32767,
 972                 0xBF24,         32767,
 973                 0xBF25,         lambda > 99 ? 32767 : LAMBDA_table[3][lambda],
 974                 0xBF26,         sgop_expt_addr & 0x0000FFFF,
 975                 0xBF27,         sgop_expt_addr >> 16,
 976                 0xBF28,         sgop_peak_addr & 0x0000FFFF,
 977                 0xBF29,         sgop_peak_addr >> 16,
 978                 0xBF2A,         vbv_alert_addr & 0x0000FFFF,
 979                 0xBF2B,         vbv_alert_addr >> 16,
 980                 0xBF2C,         0,
 981                 0xBF2D,         0,
 982                 0,              0,
 983
 984                 0x200e,         0x0000,
 985                 0xBF2E,         vbv_alert_addr & 0x0000FFFF,
 986                 0xBF2F,         vbv_alert_addr >> 16,
 987                 0xBF30,         cplx[0] & 0x0000FFFF,
 988                 0xBF31,         cplx[0] >> 16,
 989                 0xBF32,         cplx[1] & 0x0000FFFF,
 990                 0xBF33,         cplx[1] >> 16,
 991                 0xBF34,         cplx[2] & 0x0000FFFF,
 992                 0xBF35,         cplx[2] >> 16,
 993                 0xBF36,         cplx[3] & 0x0000FFFF,
 994                 0xBF37,         cplx[3] >> 16,
 995                 0xBF38,         0,
 996                 0xBF39,         0,
 997                 0xBF3A,         total_expt_addr & 0x0000FFFF,
 998                 0xBF3B,         total_expt_addr >> 16,
 999                 0,              0,
1000
1001                 0x200e,         0x0000,
1002                 0xBF3C,         total_expt_addr & 0x0000FFFF,
1003                 0xBF3D,         total_expt_addr >> 16,
1004                 0xBF3E,         0,
1005                 0xBF3F,         0,
1006                 0xBF48,         0,
1007                 0xBF49,         0,
1008                 0xBF4A,         calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
1009                 0xBF4B,         4,
1010                 0xBF4C,         0,
1011                 0xBF4D,         0,
1012                 0xBF4E,         0,
1013                 0xBF4F,         0,
1014                 0xBF50,         0,
1015                 0xBF51,         0,
1016                 0,              0,
1017
1018                 0x200e,         0x0000,
1019                 0xBF40,         sgop_expt_addr & 0x0000FFFF,
1020                 0xBF41,         sgop_expt_addr >> 16,
1021                 0xBF42,         0,
1022                 0xBF43,         0,
1023                 0xBF44,         0,
1024                 0xBF45,         0,
1025                 0xBF46,         (go->width >> 4) * (go->height >> 4),
1026                 0xBF47,         0,
1027                 0xBF64,         0,
1028                 0xBF65,         0,
1029                 0xBF18,         framelen[4],
1030                 0xBF19,         framelen[5],
1031                 0xBF1A,         framelen[6],
1032                 0xBF1B,         framelen[7],
1033                 0,              0,
1034
1035 #if 0
1036                 /* Remove once we don't care about matching */
1037                 0x200e,         0x0000,
1038                 0xBF56,         4,
1039                 0xBF57,         0,
1040                 0xBF58,         5,
1041                 0xBF59,         0,
1042                 0xBF5A,         6,
1043                 0xBF5B,         0,
1044                 0xBF5C,         8,
1045                 0xBF5D,         0,
1046                 0xBF5E,         1,
1047                 0xBF5F,         0,
1048                 0xBF60,         1,
1049                 0xBF61,         0,
1050                 0xBF62,         0,
1051                 0xBF63,         0,
1052                 0,              0,
1053 #else
1054                 0x2008,         0x0000,
1055                 0xBF56,         4,
1056                 0xBF57,         0,
1057                 0xBF58,         5,
1058                 0xBF59,         0,
1059                 0xBF5A,         6,
1060                 0xBF5B,         0,
1061                 0xBF5C,         8,
1062                 0xBF5D,         0,
1063                 0,              0,
1064                 0,              0,
1065                 0,              0,
1066                 0,              0,
1067                 0,              0,
1068                 0,              0,
1069                 0,              0,
1070 #endif
1071
1072                 0x200e,         0x0000,
1073                 0xBF10,         0,
1074                 0xBF11,         0,
1075                 0xBF12,         0,
1076                 0xBF13,         0,
1077                 0xBF14,         0,
1078                 0xBF15,         0,
1079                 0xBF16,         0,
1080                 0xBF17,         0,
1081                 0xBF7E,         0,
1082                 0xBF7F,         1,
1083                 0xBF52,         framelen[0],
1084                 0xBF53,         framelen[1],
1085                 0xBF54,         framelen[2],
1086                 0xBF55,         framelen[3],
1087                 0,              0,
1088         };
1089
1090         return copy_packages(code, pack, 6, space);
1091 }
1092
1093 static int config_package(struct go7007 *go, __le16 *code, int space)
1094 {
1095         int fps = go->sensor_framerate / go->fps_scale / 1000;
1096         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1097         int brc_window_size = fps;
1098         int q_min = 2, q_max = 31;
1099         int THACCoeffSet0 = 0;
1100         u16 pack[] = {
1101                 0x200e,         0x0000,
1102                 0xc002,         0x14b4,
1103                 0xc003,         0x28b4,
1104                 0xc004,         0x3c5a,
1105                 0xdc05,         0x2a77,
1106                 0xc6c3,         go->format == GO7007_FORMAT_MPEG4 ? 0 :
1107                                 (go->format == GO7007_FORMAT_H263 ? 0 : 1),
1108                 0xc680,         go->format == GO7007_FORMAT_MPEG4 ? 0xf1 :
1109                                 (go->format == GO7007_FORMAT_H263 ? 0x61 :
1110                                                                         0xd3),
1111                 0xc780,         0x0140,
1112                 0xe009,         0x0001,
1113                 0xc60f,         0x0008,
1114                 0xd4ff,         0x0002,
1115                 0xe403,         2340,
1116                 0xe406,         75,
1117                 0xd411,         0x0001,
1118                 0xd410,         0xa1d6,
1119                 0x0001,         0x2801,
1120
1121                 0x200d,         0x0000,
1122                 0xe402,         0x018b,
1123                 0xe401,         0x8b01,
1124                 0xd472,         (go->board_info->sensor_flags &
1125                                                         GO7007_SENSOR_TV) &&
1126                                                 (!go->interlace_coding) ?
1127                                         0x01b0 : 0x0170,
1128                 0xd475,         (go->board_info->sensor_flags &
1129                                                         GO7007_SENSOR_TV) &&
1130                                                 (!go->interlace_coding) ?
1131                                         0x0008 : 0x0009,
1132                 0xc404,         go->interlace_coding ? 0x44 :
1133                                 (go->format == GO7007_FORMAT_MPEG4 ? 0x11 :
1134                                 (go->format == GO7007_FORMAT_MPEG1 ? 0x02 :
1135                                 (go->format == GO7007_FORMAT_MPEG2 ? 0x04 :
1136                                 (go->format == GO7007_FORMAT_H263  ? 0x08 :
1137                                                                      0x20)))),
1138                 0xbf0a,         (go->format == GO7007_FORMAT_MPEG4 ? 8 :
1139                                 (go->format == GO7007_FORMAT_MPEG1 ? 1 :
1140                                 (go->format == GO7007_FORMAT_MPEG2 ? 2 :
1141                                 (go->format == GO7007_FORMAT_H263 ? 4 : 16)))) |
1142                                 ((go->repeat_seqhead ? 1 : 0) << 6) |
1143                                 ((go->dvd_mode ? 1 : 0) << 9) |
1144                                 ((go->gop_header_enable ? 1 : 0) << 10),
1145                 0xbf0b,         0,
1146                 0xdd5a,         go->ipb ? 0x14 : 0x0a,
1147                 0xbf0c,         0,
1148                 0xbf0d,         0,
1149                 0xc683,         THACCoeffSet0,
1150                 0xc40a,         (go->width << 4) | rows,
1151                 0xe01a,         go->board_info->hpi_buffer_cap,
1152                 0,              0,
1153                 0,              0,
1154
1155                 0x2008,         0,
1156                 0xe402,         0x88,
1157                 0xe401,         0x8f01,
1158                 0xbf6a,         0,
1159                 0xbf6b,         0,
1160                 0xbf6c,         0,
1161                 0xbf6d,         0,
1162                 0xbf6e,         0,
1163                 0xbf6f,         0,
1164                 0,              0,
1165                 0,              0,
1166                 0,              0,
1167                 0,              0,
1168                 0,              0,
1169                 0,              0,
1170                 0,              0,
1171
1172                 0x200e,         0,
1173                 0xbf66,         brc_window_size,
1174                 0xbf67,         0,
1175                 0xbf68,         q_min,
1176                 0xbf69,         q_max,
1177                 0xbfe0,         0,
1178                 0xbfe1,         0,
1179                 0xbfe2,         0,
1180                 0xbfe3,         go->ipb ? 3 : 1,
1181                 0xc031,         go->board_info->sensor_flags &
1182                                         GO7007_SENSOR_VBI ? 1 : 0,
1183                 0xc01c,         0x1f,
1184                 0xdd8c,         0x15,
1185                 0xdd94,         0x15,
1186                 0xdd88,         go->ipb ? 0x1401 : 0x0a01,
1187                 0xdd90,         go->ipb ? 0x1401 : 0x0a01,
1188                 0,              0,
1189
1190                 0x200e,         0,
1191                 0xbfe4,         0,
1192                 0xbfe5,         0,
1193                 0xbfe6,         0,
1194                 0xbfe7,         fps << 8,
1195                 0xbfe8,         0x3a00,
1196                 0xbfe9,         0,
1197                 0xbfea,         0,
1198                 0xbfeb,         0,
1199                 0xbfec,         (go->interlace_coding ? 1 << 15 : 0) |
1200                                         (go->modet_enable ? 0xa : 0) |
1201                                         (go->board_info->sensor_flags &
1202                                                 GO7007_SENSOR_VBI ? 1 : 0),
1203                 0xbfed,         0,
1204                 0xbfee,         0,
1205                 0xbfef,         0,
1206                 0xbff0,         go->board_info->sensor_flags &
1207                                         GO7007_SENSOR_TV ? 0xf060 : 0xb060,
1208                 0xbff1,         0,
1209                 0,              0,
1210         };
1211
1212         return copy_packages(code, pack, 5, space);
1213 }
1214
1215 static int seqhead_to_package(struct go7007 *go, __le16 *code, int space,
1216         int (*sequence_header_func)(struct go7007 *go,
1217                 unsigned char *buf, int ext))
1218 {
1219         int vop_time_increment_bitlength = vti_bitlen(go);
1220         int fps = go->sensor_framerate / go->fps_scale *
1221                                         (go->interlace_coding ? 2 : 1);
1222         unsigned char buf[40] = { };
1223         int len = sequence_header_func(go, buf, 1);
1224         u16 pack[] = {
1225                 0x2006,         0,
1226                 0xbf08,         fps,
1227                 0xbf09,         0,
1228                 0xbff2,         vop_time_increment_bitlength,
1229                 0xbff3,         (1 << vop_time_increment_bitlength) - 1,
1230                 0xbfe6,         0,
1231                 0xbfe7,         (fps / 1000) << 8,
1232                 0,              0,
1233                 0,              0,
1234                 0,              0,
1235                 0,              0,
1236                 0,              0,
1237                 0,              0,
1238                 0,              0,
1239                 0,              0,
1240                 0,              0,
1241
1242                 0x2007,         0,
1243                 0xc800,         buf[2] << 8 | buf[3],
1244                 0xc801,         buf[4] << 8 | buf[5],
1245                 0xc802,         buf[6] << 8 | buf[7],
1246                 0xc803,         buf[8] << 8 | buf[9],
1247                 0xc406,         64,
1248                 0xc407,         len - 64,
1249                 0xc61b,         1,
1250                 0,              0,
1251                 0,              0,
1252                 0,              0,
1253                 0,              0,
1254                 0,              0,
1255                 0,              0,
1256                 0,              0,
1257                 0,              0,
1258
1259                 0x200e,         0,
1260                 0xc808,         buf[10] << 8 | buf[11],
1261                 0xc809,         buf[12] << 8 | buf[13],
1262                 0xc80a,         buf[14] << 8 | buf[15],
1263                 0xc80b,         buf[16] << 8 | buf[17],
1264                 0xc80c,         buf[18] << 8 | buf[19],
1265                 0xc80d,         buf[20] << 8 | buf[21],
1266                 0xc80e,         buf[22] << 8 | buf[23],
1267                 0xc80f,         buf[24] << 8 | buf[25],
1268                 0xc810,         buf[26] << 8 | buf[27],
1269                 0xc811,         buf[28] << 8 | buf[29],
1270                 0xc812,         buf[30] << 8 | buf[31],
1271                 0xc813,         buf[32] << 8 | buf[33],
1272                 0xc814,         buf[34] << 8 | buf[35],
1273                 0xc815,         buf[36] << 8 | buf[37],
1274                 0,              0,
1275                 0,              0,
1276                 0,              0,
1277         };
1278
1279         return copy_packages(code, pack, 3, space);
1280 }
1281
1282 static int relative_prime(int big, int little)
1283 {
1284         int remainder;
1285
1286         while (little != 0) {
1287                 remainder = big % little;
1288                 big = little;
1289                 little = remainder;
1290         }
1291         return big;
1292 }
1293
1294 static int avsync_to_package(struct go7007 *go, __le16 *code, int space)
1295 {
1296         int arate = go->board_info->audio_rate * 1001 * go->fps_scale;
1297         int ratio = arate / go->sensor_framerate;
1298         int adjratio = ratio * 215 / 100;
1299         int rprime = relative_prime(go->sensor_framerate,
1300                                         arate % go->sensor_framerate);
1301         int f1 = (arate % go->sensor_framerate) / rprime;
1302         int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime;
1303         u16 pack[] = {
1304                 0x200e,         0,
1305                 0xbf98,         (u16)((-adjratio) & 0xffff),
1306                 0xbf99,         (u16)((-adjratio) >> 16),
1307                 0xbf92,         0,
1308                 0xbf93,         0,
1309                 0xbff4,         f1 > f2 ? f1 : f2,
1310                 0xbff5,         f1 < f2 ? f1 : f2,
1311                 0xbff6,         f1 < f2 ? ratio : ratio + 1,
1312                 0xbff7,         f1 > f2 ? ratio : ratio + 1,
1313                 0xbff8,         0,
1314                 0xbff9,         0,
1315                 0xbffa,         adjratio & 0xffff,
1316                 0xbffb,         adjratio >> 16,
1317                 0xbf94,         0,
1318                 0xbf95,         0,
1319                 0,              0,
1320         };
1321
1322         return copy_packages(code, pack, 1, space);
1323 }
1324
1325 static int final_package(struct go7007 *go, __le16 *code, int space)
1326 {
1327         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1328         u16 pack[] = {
1329                 0x8000,
1330                 0,
1331                 0,
1332                 0,
1333                 0,
1334                 0,
1335                 0,
1336                 2,
1337                 ((go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
1338                                                 (!go->interlace_coding) ?
1339                                         (1 << 14) | (1 << 9) : 0) |
1340                         ((go->encoder_subsample ? 1 : 0) << 8) |
1341                         (go->board_info->sensor_flags &
1342                                 GO7007_SENSOR_CONFIG_MASK),
1343                 ((go->encoder_v_halve ? 1 : 0) << 14) |
1344                         (go->encoder_v_halve ? rows << 9 : rows << 8) |
1345                         (go->encoder_h_halve ? 1 << 6 : 0) |
1346                         (go->encoder_h_halve ? go->width >> 3 : go->width >> 4),
1347                 (1 << 15) | (go->encoder_v_offset << 6) |
1348                         (1 << 7) | (go->encoder_h_offset >> 2),
1349                 (1 << 6),
1350                 0,
1351                 0,
1352                 ((go->fps_scale - 1) << 8) |
1353                         (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
1354                                                 (1 << 7) : 0) |
1355                         0x41,
1356                 go->ipb ? 0xd4c : 0x36b,
1357                 (rows << 8) | (go->width >> 4),
1358                 go->format == GO7007_FORMAT_MPEG4 ? 0x0404 : 0,
1359                 (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) |
1360                         ((go->closed_gop ? 1 : 0) << 12) |
1361                         ((go->format == GO7007_FORMAT_MPEG4 ? 1 : 0) << 11) |
1362                 /*      (1 << 9) |   */
1363                         ((go->ipb ? 3 : 0) << 7) |
1364                         ((go->modet_enable ? 1 : 0) << 2) |
1365                         ((go->dvd_mode ? 1 : 0) << 1) | 1,
1366                 (go->format == GO7007_FORMAT_MPEG1 ? 0x89a0 :
1367                         (go->format == GO7007_FORMAT_MPEG2 ? 0x89a0 :
1368                         (go->format == GO7007_FORMAT_MJPEG ? 0x89a0 :
1369                         (go->format == GO7007_FORMAT_MPEG4 ? 0x8920 :
1370                         (go->format == GO7007_FORMAT_H263 ? 0x8920 : 0))))),
1371                 go->ipb ? 0x1f15 : 0x1f0b,
1372                 go->ipb ? 0x0015 : 0x000b,
1373                 go->ipb ? 0xa800 : 0x5800,
1374                 0xffff,
1375                 0x0020 + 0x034b * 0,
1376                 0x0020 + 0x034b * 1,
1377                 0x0020 + 0x034b * 2,
1378                 0x0020 + 0x034b * 3,
1379                 0x0020 + 0x034b * 4,
1380                 0x0020 + 0x034b * 5,
1381                 go->ipb ? (go->gop_size / 3) : go->gop_size,
1382                 (go->height >> 4) * (go->width >> 4) * 110 / 100,
1383         };
1384
1385         return copy_packages(code, pack, 1, space);
1386 }
1387
1388 static int audio_to_package(struct go7007 *go, __le16 *code, int space)
1389 {
1390         int clock_config = ((go->board_info->audio_flags &
1391                                 GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) |
1392                         ((go->board_info->audio_flags &
1393                                 GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) |
1394                         (((go->board_info->audio_bclk_div / 4) - 1) << 4) |
1395                         (go->board_info->audio_main_div - 1);
1396         u16 pack[] = {
1397                 0x200d,         0,
1398                 0x9002,         0,
1399                 0x9002,         0,
1400                 0x9031,         0,
1401                 0x9032,         0,
1402                 0x9033,         0,
1403                 0x9034,         0,
1404                 0x9035,         0,
1405                 0x9036,         0,
1406                 0x9037,         0,
1407                 0x9040,         0,
1408                 0x9000,         clock_config,
1409                 0x9001,         (go->board_info->audio_flags & 0xffff) |
1410                                         (1 << 9),
1411                 0x9000,         ((go->board_info->audio_flags &
1412                                                 GO7007_AUDIO_I2S_MASTER ?
1413                                                 1 : 0) << 10) |
1414                                         clock_config,
1415                 0,              0,
1416                 0,              0,
1417                 0x2005,         0,
1418                 0x9041,         0,
1419                 0x9042,         256,
1420                 0x9043,         0,
1421                 0x9044,         16,
1422                 0x9045,         16,
1423                 0,              0,
1424                 0,              0,
1425                 0,              0,
1426                 0,              0,
1427                 0,              0,
1428                 0,              0,
1429                 0,              0,
1430                 0,              0,
1431                 0,              0,
1432                 0,              0,
1433         };
1434
1435         return copy_packages(code, pack, 2, space);
1436 }
1437
1438 static int modet_to_package(struct go7007 *go, __le16 *code, int space)
1439 {
1440         int ret, mb, i, addr, cnt = 0;
1441         u16 pack[32];
1442         u16 thresholds[] = {
1443                 0x200e,         0,
1444                 0xbf82,         go->modet[0].pixel_threshold,
1445                 0xbf83,         go->modet[1].pixel_threshold,
1446                 0xbf84,         go->modet[2].pixel_threshold,
1447                 0xbf85,         go->modet[3].pixel_threshold,
1448                 0xbf86,         go->modet[0].motion_threshold,
1449                 0xbf87,         go->modet[1].motion_threshold,
1450                 0xbf88,         go->modet[2].motion_threshold,
1451                 0xbf89,         go->modet[3].motion_threshold,
1452                 0xbf8a,         go->modet[0].mb_threshold,
1453                 0xbf8b,         go->modet[1].mb_threshold,
1454                 0xbf8c,         go->modet[2].mb_threshold,
1455                 0xbf8d,         go->modet[3].mb_threshold,
1456                 0xbf8e,         0,
1457                 0xbf8f,         0,
1458                 0,              0,
1459         };
1460
1461         ret = copy_packages(code, thresholds, 1, space);
1462         if (ret < 0)
1463                 return -1;
1464         cnt += ret;
1465
1466         addr = 0xbac0;
1467         memset(pack, 0, 64);
1468         i = 0;
1469         for (mb = 0; mb < 1624; ++mb) {
1470                 pack[i * 2 + 3] <<= 2;
1471                 pack[i * 2 + 3] |= go->modet_map[mb];
1472                 if (mb % 8 != 7)
1473                         continue;
1474                 pack[i * 2 + 2] = addr++;
1475                 ++i;
1476                 if (i == 10 || mb == 1623) {
1477                         pack[0] = 0x2000 | i;
1478                         ret = copy_packages(code + cnt, pack, 1, space - cnt);
1479                         if (ret < 0)
1480                                 return -1;
1481                         cnt += ret;
1482                         i = 0;
1483                         memset(pack, 0, 64);
1484                 }
1485                 pack[i * 2 + 3] = 0;
1486         }
1487
1488         memset(pack, 0, 64);
1489         i = 0;
1490         for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
1491                 pack[i * 2 + 2] = addr;
1492                 pack[i * 2 + 3] = 0;
1493                 ++i;
1494                 if (i == 10 || addr == 0xbbf9) {
1495                         pack[0] = 0x2000 | i;
1496                         ret = copy_packages(code + cnt, pack, 1, space - cnt);
1497                         if (ret < 0)
1498                                 return -1;
1499                         cnt += ret;
1500                         i = 0;
1501                         memset(pack, 0, 64);
1502                 }
1503         }
1504         return cnt;
1505 }
1506
1507 static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
1508                         int *framelen)
1509 {
1510         switch (type) {
1511         case SPECIAL_FRM_HEAD:
1512                 switch (go->format) {
1513                 case GO7007_FORMAT_MJPEG:
1514                         return gen_mjpeghdr_to_package(go, code, space);
1515                 case GO7007_FORMAT_MPEG1:
1516                 case GO7007_FORMAT_MPEG2:
1517                         return gen_mpeg1hdr_to_package(go, code, space,
1518                                                                 framelen);
1519                 case GO7007_FORMAT_MPEG4:
1520                         return gen_mpeg4hdr_to_package(go, code, space,
1521                                                                 framelen);
1522                 }
1523         case SPECIAL_BRC_CTRL:
1524                 return brctrl_to_package(go, code, space, framelen);
1525         case SPECIAL_CONFIG:
1526                 return config_package(go, code, space);
1527         case SPECIAL_SEQHEAD:
1528                 switch (go->format) {
1529                 case GO7007_FORMAT_MPEG1:
1530                 case GO7007_FORMAT_MPEG2:
1531                         return seqhead_to_package(go, code, space,
1532                                         mpeg1_sequence_header);
1533                 case GO7007_FORMAT_MPEG4:
1534                         return seqhead_to_package(go, code, space,
1535                                         mpeg4_sequence_header);
1536                 default:
1537                         return 0;
1538                 }
1539         case SPECIAL_AV_SYNC:
1540                 return avsync_to_package(go, code, space);
1541         case SPECIAL_FINAL:
1542                 return final_package(go, code, space);
1543         case SPECIAL_AUDIO:
1544                 return audio_to_package(go, code, space);
1545         case SPECIAL_MODET:
1546                 return modet_to_package(go, code, space);
1547         }
1548         printk(KERN_ERR
1549                 "go7007: firmware file contains unsupported feature %04x\n",
1550                 type);
1551         return -1;
1552 }
1553
1554 int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
1555 {
1556         const struct firmware *fw_entry;
1557         __le16 *code, *src;
1558         int framelen[8] = { }; /* holds the lengths of empty frame templates */
1559         int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
1560         int mode_flag;
1561         int ret;
1562
1563         switch (go->format) {
1564         case GO7007_FORMAT_MJPEG:
1565                 mode_flag = FLAG_MODE_MJPEG;
1566                 break;
1567         case GO7007_FORMAT_MPEG1:
1568                 mode_flag = FLAG_MODE_MPEG1;
1569                 break;
1570         case GO7007_FORMAT_MPEG2:
1571                 mode_flag = FLAG_MODE_MPEG2;
1572                 break;
1573         case GO7007_FORMAT_MPEG4:
1574                 mode_flag = FLAG_MODE_MPEG4;
1575                 break;
1576         default:
1577                 return -1;
1578         }
1579         if (request_firmware(&fw_entry, go->board_info->firmware, go->dev)) {
1580                 printk(KERN_ERR
1581                         "go7007: unable to load firmware from file \"%s\"\n",
1582                         go->board_info->firmware);
1583                 return -1;
1584         }
1585         code = kzalloc(codespace * 2, GFP_KERNEL);
1586         if (code == NULL) {
1587                 printk(KERN_ERR "go7007: unable to allocate %d bytes for "
1588                                 "firmware construction\n", codespace * 2);
1589                 goto fw_failed;
1590         }
1591         src = (__le16 *)fw_entry->data;
1592         srclen = fw_entry->size / 2;
1593         while (srclen >= 2) {
1594                 chunk_flags = __le16_to_cpu(src[0]);
1595                 chunk_len = __le16_to_cpu(src[1]);
1596                 if (chunk_len + 2 > srclen) {
1597                         printk(KERN_ERR "go7007: firmware file \"%s\" "
1598                                         "appears to be corrupted\n",
1599                                         go->board_info->firmware);
1600                         goto fw_failed;
1601                 }
1602                 if (chunk_flags & mode_flag) {
1603                         if (chunk_flags & FLAG_SPECIAL) {
1604                                 ret = do_special(go, __le16_to_cpu(src[2]),
1605                                         &code[i], codespace - i, framelen);
1606                                 if (ret < 0) {
1607                                         printk(KERN_ERR "go7007: insufficient "
1608                                                         "memory for firmware "
1609                                                         "construction\n");
1610                                         goto fw_failed;
1611                                 }
1612                                 i += ret;
1613                         } else {
1614                                 if (codespace - i < chunk_len) {
1615                                         printk(KERN_ERR "go7007: insufficient "
1616                                                         "memory for firmware "
1617                                                         "construction\n");
1618                                         goto fw_failed;
1619                                 }
1620                                 memcpy(&code[i], &src[2], chunk_len * 2);
1621                                 i += chunk_len;
1622                         }
1623                 }
1624                 srclen -= chunk_len + 2;
1625                 src += chunk_len + 2;
1626         }
1627         release_firmware(fw_entry);
1628         *fw = (u8 *)code;
1629         *fwlen = i * 2;
1630         return 0;
1631
1632 fw_failed:
1633         kfree(code);
1634         release_firmware(fw_entry);
1635         return -1;
1636 }