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