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

   1 /*
   2  * Copyright (C) 2005-2006 Micronas USA Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License (Version 2) as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  16  */
  17
  18 /*
  19  * This file contains code to generate a firmware image for the GO7007SB
  20  * encoder.  Much of the firmware is read verbatim from a file, but some of
  21  * it concerning bitrate control and other things that can be configured at
  22  * run-time are generated dynamically.  Note that the format headers
  23  * generated here do not affect the functioning of the encoder; they are
  24  * merely parroted back to the host at the start of each frame.
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/init.h>
  29 #include <linux/version.h>
  30 #include <linux/time.h>
  31 #include <linux/mm.h>
  32 #include <linux/device.h>
  33 #include <linux/i2c.h>
  34 #include <linux/firmware.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(u16 *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_le16(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, u16 *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 = kmalloc(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         memset(buf, 0, 4096);
 390
 391         for (i = 1; i < 32; ++i) {
 392                 mjpeg_frame_header(go, buf + size, i);
 393                 size += 80;
 394         }
 395         chunk = mjpeg_frame_header(go, buf + size, 1);
 396         memmove(buf + size, buf + size + 80, chunk - 80);
 397         size += chunk - 80;
 398
 399         for (i = 0; i < size; i += chunk * 2) {
 400                 if (space - off < 32) {
 401                         off = -1;
 402                         goto done;
 403                 }
 404
 405                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 406
 407                 chunk = 28;
 408                 if (mem + chunk > 0x4000)
 409                         chunk = 0x4000 - mem;
 410                 if (i + 2 * chunk > size)
 411                         chunk = (size - i) / 2;
 412
 413                 if (chunk < 28) {
 414                         code[off] = __cpu_to_le16(0x4000 | chunk);
 415                         code[off + 31] = __cpu_to_le16(addr++);
 416                         mem = 0x3e00;
 417                 } else {
 418                         code[off] = __cpu_to_le16(0x1000 | 28);
 419                         code[off + 31] = 0;
 420                         mem += 28;
 421                 }
 422
 423                 memcpy(&code[off + 2], buf + i, chunk * 2);
 424                 off += 32;
 425         }
 426 done:
 427         kfree(buf);
 428         return off;
 429 }
 430
 431 static int mpeg1_frame_header(struct go7007 *go, unsigned char *buf,
 432                 int modulo, int pict_struct, enum mpeg_frame_type frame)
 433 {
 434         int i, j, mb_code, mb_len;
 435         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
 436         CODE_GEN(c, buf + 6);
 437
 438         switch (frame) {
 439         case PFRAME:
 440                 mb_code = 0x1;
 441                 mb_len = 3;
 442                 break;
 443         case BFRAME_PRE:
 444                 mb_code = 0x2;
 445                 mb_len = 4;
 446                 break;
 447         case BFRAME_POST:
 448                 mb_code = 0x2;
 449                 mb_len = 3;
 450                 break;
 451         case BFRAME_BIDIR:
 452                 mb_code = 0x2;
 453                 mb_len = 2;
 454                 break;
 455         default: /* keep the compiler happy */
 456                 mb_code = mb_len = 0;
 457                 break;
 458         }
 459
 460         CODE_ADD(c, frame == PFRAME ? 0x2 : 0x3, 13);
 461         CODE_ADD(c, 0xffff, 16);
 462         CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
 463         if (frame != PFRAME)
 464                 CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 0x7 : 0x4, 4);
 465         else
 466                 CODE_ADD(c, 0, 4); /* Is this supposed to be here?? */
 467         CODE_ADD(c, 0, 3); /* What is this?? */
 468         /* Byte-align with zeros */
 469         j = 8 - (CODE_LENGTH(c) % 8);
 470         if (j != 8)
 471                 CODE_ADD(c, 0, j);
 472
 473         if (go->format == GO7007_FORMAT_MPEG2) {
 474                 CODE_ADD(c, 0x1, 24);
 475                 CODE_ADD(c, 0xb5, 8);
 476                 CODE_ADD(c, 0x844, 12);
 477                 CODE_ADD(c, frame == PFRAME ? 0xff : 0x44, 8);
 478                 if (go->interlace_coding) {
 479                         CODE_ADD(c, pict_struct, 4);
 480                         if (go->dvd_mode)
 481                                 CODE_ADD(c, 0x000, 11);
 482                         else
 483                                 CODE_ADD(c, 0x200, 11);
 484                 } else {
 485                         CODE_ADD(c, 0x3, 4);
 486                         CODE_ADD(c, 0x20c, 11);
 487                 }
 488                 /* Byte-align with zeros */
 489                 j = 8 - (CODE_LENGTH(c) % 8);
 490                 if (j != 8)
 491                         CODE_ADD(c, 0, j);
 492         }
 493
 494         for (i = 0; i < rows; ++i) {
 495                 CODE_ADD(c, 1, 24);
 496                 CODE_ADD(c, i + 1, 8);
 497                 CODE_ADD(c, 0x2, 6);
 498                 CODE_ADD(c, 0x1, 1);
 499                 CODE_ADD(c, mb_code, mb_len);
 500                 if (go->interlace_coding) {
 501                         CODE_ADD(c, 0x1, 2);
 502                         CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 503                 }
 504                 if (frame == BFRAME_BIDIR) {
 505                         CODE_ADD(c, 0x3, 2);
 506                         if (go->interlace_coding)
 507                                 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 508                 }
 509                 CODE_ADD(c, 0x3, 2);
 510                 for (j = (go->width >> 4) - 2; j >= 33; j -= 33)
 511                         CODE_ADD(c, 0x8, 11);
 512                 CODE_ADD(c, addrinctab[j][0], addrinctab[j][1]);
 513                 CODE_ADD(c, mb_code, mb_len);
 514                 if (go->interlace_coding) {
 515                         CODE_ADD(c, 0x1, 2);
 516                         CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 517                 }
 518                 if (frame == BFRAME_BIDIR) {
 519                         CODE_ADD(c, 0x3, 2);
 520                         if (go->interlace_coding)
 521                                 CODE_ADD(c, pict_struct == 1 ? 0x0 : 0x1, 1);
 522                 }
 523                 CODE_ADD(c, 0x3, 2);
 524
 525                 /* Byte-align with zeros */
 526                 j = 8 - (CODE_LENGTH(c) % 8);
 527                 if (j != 8)
 528                         CODE_ADD(c, 0, j);
 529         }
 530
 531         i = CODE_LENGTH(c) + 4 * 8;
 532         buf[2] = 0x00;
 533         buf[3] = 0x00;
 534         buf[4] = 0x01;
 535         buf[5] = 0x00;
 536         return i;
 537 }
 538
 539 static int mpeg1_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
 540 {
 541         int i, aspect_ratio, picture_rate;
 542         CODE_GEN(c, buf + 6);
 543
 544         if (go->format == GO7007_FORMAT_MPEG1) {
 545                 switch (go->aspect_ratio) {
 546                 case GO7007_RATIO_4_3:
 547                         aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
 548                         break;
 549                 case GO7007_RATIO_16_9:
 550                         aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
 551                         break;
 552                 default:
 553                         aspect_ratio = 1;
 554                         break;
 555                 }
 556         } else {
 557                 switch (go->aspect_ratio) {
 558                 case GO7007_RATIO_4_3:
 559                         aspect_ratio = 2;
 560                         break;
 561                 case GO7007_RATIO_16_9:
 562                         aspect_ratio = 3;
 563                         break;
 564                 default:
 565                         aspect_ratio = 1;
 566                         break;
 567                 }
 568         }
 569         switch (go->sensor_framerate) {
 570         case 24000:
 571                 picture_rate = 1;
 572                 break;
 573         case 24024:
 574                 picture_rate = 2;
 575                 break;
 576         case 25025:
 577                 picture_rate = go->interlace_coding ? 6 : 3;
 578                 break;
 579         case 30000:
 580                 picture_rate = go->interlace_coding ? 7 : 4;
 581                 break;
 582         case 30030:
 583                 picture_rate = go->interlace_coding ? 8 : 5;
 584                 break;
 585         default:
 586                 picture_rate = 5; /* 30 fps seems like a reasonable default */
 587                 break;
 588         }
 589
 590         CODE_ADD(c, go->width, 12);
 591         CODE_ADD(c, go->height, 12);
 592         CODE_ADD(c, aspect_ratio, 4);
 593         CODE_ADD(c, picture_rate, 4);
 594         CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 20000 : 0x3ffff, 18);
 595         CODE_ADD(c, 1, 1);
 596         CODE_ADD(c, go->format == GO7007_FORMAT_MPEG2 ? 112 : 20, 10);
 597         CODE_ADD(c, 0, 3);
 598
 599         /* Byte-align with zeros */
 600         i = 8 - (CODE_LENGTH(c) % 8);
 601         if (i != 8)
 602                 CODE_ADD(c, 0, i);
 603
 604         if (go->format == GO7007_FORMAT_MPEG2) {
 605                 CODE_ADD(c, 0x1, 24);
 606                 CODE_ADD(c, 0xb5, 8);
 607                 CODE_ADD(c, 0x148, 12);
 608                 if (go->interlace_coding)
 609                         CODE_ADD(c, 0x20001, 20);
 610                 else
 611                         CODE_ADD(c, 0xa0001, 20);
 612                 CODE_ADD(c, 0, 16);
 613
 614                 /* Byte-align with zeros */
 615                 i = 8 - (CODE_LENGTH(c) % 8);
 616                 if (i != 8)
 617                         CODE_ADD(c, 0, i);
 618
 619                 if (ext) {
 620                         CODE_ADD(c, 0x1, 24);
 621                         CODE_ADD(c, 0xb52, 12);
 622                         CODE_ADD(c, go->standard == GO7007_STD_NTSC ? 2 : 1, 3);
 623                         CODE_ADD(c, 0x105, 9);
 624                         CODE_ADD(c, 0x505, 16);
 625                         CODE_ADD(c, go->width, 14);
 626                         CODE_ADD(c, 1, 1);
 627                         CODE_ADD(c, go->height, 14);
 628
 629                         /* Byte-align with zeros */
 630                         i = 8 - (CODE_LENGTH(c) % 8);
 631                         if (i != 8)
 632                                 CODE_ADD(c, 0, i);
 633                 }
 634         }
 635
 636         i = CODE_LENGTH(c) + 4 * 8;
 637         buf[0] = i & 0xff;
 638         buf[1] = i >> 8;
 639         buf[2] = 0x00;
 640         buf[3] = 0x00;
 641         buf[4] = 0x01;
 642         buf[5] = 0xb3;
 643         return i;
 644 }
 645
 646 static int gen_mpeg1hdr_to_package(struct go7007 *go,
 647                                         u16 *code, int space, int *framelen)
 648 {
 649         u8 *buf;
 650         u16 mem = 0x3e00;
 651         unsigned int addr = 0x19;
 652         int i, off = 0, chunk;
 653
 654         buf = kmalloc(5120, GFP_KERNEL);
 655         if (buf == NULL) {
 656                 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
 657                                 "firmware construction\n");
 658                 return -1;
 659         }
 660         memset(buf, 0, 5120);
 661         framelen[0] = mpeg1_frame_header(go, buf, 0, 1, PFRAME);
 662         if (go->interlace_coding)
 663                 framelen[0] += mpeg1_frame_header(go, buf + framelen[0] / 8,
 664                                                         0, 2, PFRAME);
 665         buf[0] = framelen[0] & 0xff;
 666         buf[1] = framelen[0] >> 8;
 667         i = 368;
 668         framelen[1] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_PRE);
 669         if (go->interlace_coding)
 670                 framelen[1] += mpeg1_frame_header(go, buf + i + framelen[1] / 8,
 671                                                         0, 2, BFRAME_PRE);
 672         buf[i] = framelen[1] & 0xff;
 673         buf[i + 1] = framelen[1] >> 8;
 674         i += 1632;
 675         framelen[2] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_POST);
 676         if (go->interlace_coding)
 677                 framelen[2] += mpeg1_frame_header(go, buf + i + framelen[2] / 8,
 678                                                         0, 2, BFRAME_POST);
 679         buf[i] = framelen[2] & 0xff;
 680         buf[i + 1] = framelen[2] >> 8;
 681         i += 1432;
 682         framelen[3] = mpeg1_frame_header(go, buf + i, 0, 1, BFRAME_BIDIR);
 683         if (go->interlace_coding)
 684                 framelen[3] += mpeg1_frame_header(go, buf + i + framelen[3] / 8,
 685                                                         0, 2, BFRAME_BIDIR);
 686         buf[i] = framelen[3] & 0xff;
 687         buf[i + 1] = framelen[3] >> 8;
 688         i += 1632 + 16;
 689         mpeg1_sequence_header(go, buf + i, 0);
 690         i += 40;
 691         for (i = 0; i < 5120; i += chunk * 2) {
 692                 if (space - off < 32) {
 693                         off = -1;
 694                         goto done;
 695                 }
 696
 697                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 698
 699                 chunk = 28;
 700                 if (mem + chunk > 0x4000)
 701                         chunk = 0x4000 - mem;
 702                 if (i + 2 * chunk > 5120)
 703                         chunk = (5120 - i) / 2;
 704
 705                 if (chunk < 28) {
 706                         code[off] = __cpu_to_le16(0x4000 | chunk);
 707                         code[off + 31] = __cpu_to_le16(addr);
 708                         if (mem + chunk == 0x4000) {
 709                                 mem = 0x3e00;
 710                                 ++addr;
 711                         }
 712                 } else {
 713                         code[off] = __cpu_to_le16(0x1000 | 28);
 714                         code[off + 31] = 0;
 715                         mem += 28;
 716                 }
 717
 718                 memcpy(&code[off + 2], buf + i, chunk * 2);
 719                 off += 32;
 720         }
 721 done:
 722         kfree(buf);
 723         return off;
 724 }
 725
 726 static int vti_bitlen(struct go7007 *go)
 727 {
 728         unsigned int i, max_time_incr = go->sensor_framerate / go->fps_scale;
 729
 730         for (i = 31; (max_time_incr & ((1 << i) - 1)) == max_time_incr; --i);
 731         return i + 1;
 732 }
 733
 734 static int mpeg4_frame_header(struct go7007 *go, unsigned char *buf,
 735                 int modulo, enum mpeg_frame_type frame)
 736 {
 737         int i;
 738         CODE_GEN(c, buf + 6);
 739         int mb_count = (go->width >> 4) * (go->height >> 4);
 740
 741         CODE_ADD(c, frame == PFRAME ? 0x1 : 0x2, 2);
 742         if (modulo)
 743                 CODE_ADD(c, 0x1, 1);
 744         CODE_ADD(c, 0x1, 2);
 745         CODE_ADD(c, 0, vti_bitlen(go));
 746         CODE_ADD(c, 0x3, 2);
 747         if (frame == PFRAME)
 748                 CODE_ADD(c, 0, 1);
 749         CODE_ADD(c, 0xc, 11);
 750         if (frame != PFRAME)
 751                 CODE_ADD(c, 0x4, 3);
 752         if (frame != BFRAME_EMPTY) {
 753                 for (i = 0; i < mb_count; ++i) {
 754                         switch (frame) {
 755                         case PFRAME:
 756                                 CODE_ADD(c, 0x1, 1);
 757                                 break;
 758                         case BFRAME_PRE:
 759                                 CODE_ADD(c, 0x47, 8);
 760                                 break;
 761                         case BFRAME_POST:
 762                                 CODE_ADD(c, 0x27, 7);
 763                                 break;
 764                         case BFRAME_BIDIR:
 765                                 CODE_ADD(c, 0x5f, 8);
 766                                 break;
 767                         case BFRAME_EMPTY: /* keep compiler quiet */
 768                                 break;
 769                         }
 770                 }
 771         }
 772
 773         /* Byte-align with a zero followed by ones */
 774         i = 8 - (CODE_LENGTH(c) % 8);
 775         CODE_ADD(c, 0, 1);
 776         CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
 777
 778         i = CODE_LENGTH(c) + 4 * 8;
 779         buf[0] = i & 0xff;
 780         buf[1] = i >> 8;
 781         buf[2] = 0x00;
 782         buf[3] = 0x00;
 783         buf[4] = 0x01;
 784         buf[5] = 0xb6;
 785         return i;
 786 }
 787
 788 static int mpeg4_sequence_header(struct go7007 *go, unsigned char *buf, int ext)
 789 {
 790         const unsigned char head[] = { 0x00, 0x00, 0x01, 0xb0, go->pali,
 791                 0x00, 0x00, 0x01, 0xb5, 0x09,
 792                 0x00, 0x00, 0x01, 0x00,
 793                 0x00, 0x00, 0x01, 0x20, };
 794         int i, aspect_ratio;
 795         int fps = go->sensor_framerate / go->fps_scale;
 796         CODE_GEN(c, buf + 2 + sizeof(head));
 797
 798         switch (go->aspect_ratio) {
 799         case GO7007_RATIO_4_3:
 800                 aspect_ratio = go->standard == GO7007_STD_NTSC ? 3 : 2;
 801                 break;
 802         case GO7007_RATIO_16_9:
 803                 aspect_ratio = go->standard == GO7007_STD_NTSC ? 5 : 4;
 804                 break;
 805         default:
 806                 aspect_ratio = 1;
 807                 break;
 808         }
 809
 810         memcpy(buf + 2, head, sizeof(head));
 811         CODE_ADD(c, 0x191, 17);
 812         CODE_ADD(c, aspect_ratio, 4);
 813         CODE_ADD(c, 0x1, 4);
 814         CODE_ADD(c, fps, 16);
 815         CODE_ADD(c, 0x3, 2);
 816         CODE_ADD(c, 1001, vti_bitlen(go));
 817         CODE_ADD(c, 1, 1);
 818         CODE_ADD(c, go->width, 13);
 819         CODE_ADD(c, 1, 1);
 820         CODE_ADD(c, go->height, 13);
 821         CODE_ADD(c, 0x2830, 14);
 822
 823         /* Byte-align */
 824         i = 8 - (CODE_LENGTH(c) % 8);
 825         CODE_ADD(c, 0, 1);
 826         CODE_ADD(c, (1 << (i - 1)) - 1, i - 1);
 827
 828         i = CODE_LENGTH(c) + sizeof(head) * 8;
 829         buf[0] = i & 0xff;
 830         buf[1] = i >> 8;
 831         return i;
 832 }
 833
 834 static int gen_mpeg4hdr_to_package(struct go7007 *go,
 835                                         u16 *code, int space, int *framelen)
 836 {
 837         u8 *buf;
 838         u16 mem = 0x3e00;
 839         unsigned int addr = 0x19;
 840         int i, off = 0, chunk;
 841
 842         buf = kmalloc(5120, GFP_KERNEL);
 843         if (buf == NULL) {
 844                 printk(KERN_ERR "go7007: unable to allocate 5120 bytes for "
 845                                 "firmware construction\n");
 846                 return -1;
 847         }
 848         memset(buf, 0, 5120);
 849         framelen[0] = mpeg4_frame_header(go, buf, 0, PFRAME);
 850         i = 368;
 851         framelen[1] = mpeg4_frame_header(go, buf + i, 0, BFRAME_PRE);
 852         i += 1632;
 853         framelen[2] = mpeg4_frame_header(go, buf + i, 0, BFRAME_POST);
 854         i += 1432;
 855         framelen[3] = mpeg4_frame_header(go, buf + i, 0, BFRAME_BIDIR);
 856         i += 1632;
 857         mpeg4_frame_header(go, buf + i, 0, BFRAME_EMPTY);
 858         i += 16;
 859         mpeg4_sequence_header(go, buf + i, 0);
 860         i += 40;
 861         for (i = 0; i < 5120; i += chunk * 2) {
 862                 if (space - off < 32) {
 863                         off = -1;
 864                         goto done;
 865                 }
 866
 867                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 868
 869                 chunk = 28;
 870                 if (mem + chunk > 0x4000)
 871                         chunk = 0x4000 - mem;
 872                 if (i + 2 * chunk > 5120)
 873                         chunk = (5120 - i) / 2;
 874
 875                 if (chunk < 28) {
 876                         code[off] = __cpu_to_le16(0x4000 | chunk);
 877                         code[off + 31] = __cpu_to_le16(addr);
 878                         if (mem + chunk == 0x4000) {
 879                                 mem = 0x3e00;
 880                                 ++addr;
 881                         }
 882                 } else {
 883                         code[off] = __cpu_to_le16(0x1000 | 28);
 884                         code[off + 31] = 0;
 885                         mem += 28;
 886                 }
 887
 888                 memcpy(&code[off + 2], buf + i, chunk * 2);
 889                 off += 32;
 890         }
 891         mem = 0x3e00;
 892         addr = go->ipb ? 0x14f9 : 0x0af9;
 893         memset(buf, 0, 5120);
 894         framelen[4] = mpeg4_frame_header(go, buf, 1, PFRAME);
 895         i = 368;
 896         framelen[5] = mpeg4_frame_header(go, buf + i, 1, BFRAME_PRE);
 897         i += 1632;
 898         framelen[6] = mpeg4_frame_header(go, buf + i, 1, BFRAME_POST);
 899         i += 1432;
 900         framelen[7] = mpeg4_frame_header(go, buf + i, 1, BFRAME_BIDIR);
 901         i += 1632;
 902         mpeg4_frame_header(go, buf + i, 1, BFRAME_EMPTY);
 903         i += 16;
 904         for (i = 0; i < 5120; i += chunk * 2) {
 905                 if (space - off < 32) {
 906                         off = -1;
 907                         goto done;
 908                 }
 909
 910                 code[off + 1] = __cpu_to_le16(0x8000 | mem);
 911
 912                 chunk = 28;
 913                 if (mem + chunk > 0x4000)
 914                         chunk = 0x4000 - mem;
 915                 if (i + 2 * chunk > 5120)
 916                         chunk = (5120 - i) / 2;
 917
 918                 if (chunk < 28) {
 919                         code[off] = __cpu_to_le16(0x4000 | chunk);
 920                         code[off + 31] = __cpu_to_le16(addr);
 921                         if (mem + chunk == 0x4000) {
 922                                 mem = 0x3e00;
 923                                 ++addr;
 924                         }
 925                 } else {
 926                         code[off] = __cpu_to_le16(0x1000 | 28);
 927                         code[off + 31] = 0;
 928                         mem += 28;
 929                 }
 930
 931                 memcpy(&code[off + 2], buf + i, chunk * 2);
 932                 off += 32;
 933         }
 934 done:
 935         kfree(buf);
 936         return off;
 937 }
 938
 939 static int brctrl_to_package(struct go7007 *go,
 940                                         u16 *code, int space, int *framelen)
 941 {
 942         int converge_speed = 0;
 943         int lambda = (go->format == GO7007_FORMAT_MJPEG || go->dvd_mode) ?
 944                                 100 : 0;
 945         int peak_rate = 6 * go->bitrate / 5;
 946         int vbv_buffer = go->format == GO7007_FORMAT_MJPEG ?
 947                                 go->bitrate :
 948                                 (go->dvd_mode ? 900000 : peak_rate);
 949         int fps = go->sensor_framerate / go->fps_scale;
 950         int q = 0;
 951         /* Bizarre math below depends on rounding errors in division */
 952         u32 sgop_expt_addr = go->bitrate / 32 * (go->ipb ? 3 : 1) * 1001 / fps;
 953         u32 sgop_peak_addr = peak_rate / 32 * 1001 / fps;
 954         u32 total_expt_addr = go->bitrate / 32 * 1000 / fps * (fps / 1000);
 955         u32 vbv_alert_addr = vbv_buffer * 3 / (4 * 32);
 956         u32 cplx[] = {
 957                 q > 0 ? sgop_expt_addr * q :
 958                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 959                 q > 0 ? sgop_expt_addr * q :
 960                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 961                 q > 0 ? sgop_expt_addr * q :
 962                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 963                 q > 0 ? sgop_expt_addr * q :
 964                         2 * go->width * go->height * (go->ipb ? 6 : 4) / 32,
 965         };
 966         u32 calc_q = q > 0 ? q : cplx[0] / sgop_expt_addr;
 967         u16 pack[] = {
 968                 0x200e,         0x0000,
 969                 0xBF20,         go->ipb ? converge_speed_ipb[converge_speed]
 970                                         : converge_speed_ip[converge_speed],
 971                 0xBF21,         go->ipb ? 2 : 0,
 972                 0xBF22,         go->ipb ? LAMBDA_table[0][lambda / 2 + 50]
 973                                         : 32767,
 974                 0xBF23,         go->ipb ? LAMBDA_table[1][lambda] : 32767,
 975                 0xBF24,         32767,
 976                 0xBF25,         lambda > 99 ? 32767 : LAMBDA_table[3][lambda],
 977                 0xBF26,         sgop_expt_addr & 0x0000FFFF,
 978                 0xBF27,         sgop_expt_addr >> 16,
 979                 0xBF28,         sgop_peak_addr & 0x0000FFFF,
 980                 0xBF29,         sgop_peak_addr >> 16,
 981                 0xBF2A,         vbv_alert_addr & 0x0000FFFF,
 982                 0xBF2B,         vbv_alert_addr >> 16,
 983                 0xBF2C,         0,
 984                 0xBF2D,         0,
 985                 0,              0,
 986
 987                 0x200e,         0x0000,
 988                 0xBF2E,         vbv_alert_addr & 0x0000FFFF,
 989                 0xBF2F,         vbv_alert_addr >> 16,
 990                 0xBF30,         cplx[0] & 0x0000FFFF,
 991                 0xBF31,         cplx[0] >> 16,
 992                 0xBF32,         cplx[1] & 0x0000FFFF,
 993                 0xBF33,         cplx[1] >> 16,
 994                 0xBF34,         cplx[2] & 0x0000FFFF,
 995                 0xBF35,         cplx[2] >> 16,
 996                 0xBF36,         cplx[3] & 0x0000FFFF,
 997                 0xBF37,         cplx[3] >> 16,
 998                 0xBF38,         0,
 999                 0xBF39,         0,
1000                 0xBF3A,         total_expt_addr & 0x0000FFFF,
1001                 0xBF3B,         total_expt_addr >> 16,
1002                 0,              0,
1003
1004                 0x200e,         0x0000,
1005                 0xBF3C,         total_expt_addr & 0x0000FFFF,
1006                 0xBF3D,         total_expt_addr >> 16,
1007                 0xBF3E,         0,
1008                 0xBF3F,         0,
1009                 0xBF48,         0,
1010                 0xBF49,         0,
1011                 0xBF4A,         calc_q < 4 ? 4 : (calc_q > 124 ? 124 : calc_q),
1012                 0xBF4B,         4,
1013                 0xBF4C,         0,
1014                 0xBF4D,         0,
1015                 0xBF4E,         0,
1016                 0xBF4F,         0,
1017                 0xBF50,         0,
1018                 0xBF51,         0,
1019                 0,              0,
1020
1021                 0x200e,         0x0000,
1022                 0xBF40,         sgop_expt_addr & 0x0000FFFF,
1023                 0xBF41,         sgop_expt_addr >> 16,
1024                 0xBF42,         0,
1025                 0xBF43,         0,
1026                 0xBF44,         0,
1027                 0xBF45,         0,
1028                 0xBF46,         (go->width >> 4) * (go->height >> 4),
1029                 0xBF47,         0,
1030                 0xBF64,         0,
1031                 0xBF65,         0,
1032                 0xBF18,         framelen[4],
1033                 0xBF19,         framelen[5],
1034                 0xBF1A,         framelen[6],
1035                 0xBF1B,         framelen[7],
1036                 0,              0,
1037
1038 #if 0 /* Remove once we don't care about matching */
1039                 0x200e,         0x0000,
1040                 0xBF56,         4,
1041                 0xBF57,         0,
1042                 0xBF58,         5,
1043                 0xBF59,         0,
1044                 0xBF5A,         6,
1045                 0xBF5B,         0,
1046                 0xBF5C,         8,
1047                 0xBF5D,         0,
1048                 0xBF5E,         1,
1049                 0xBF5F,         0,
1050                 0xBF60,         1,
1051                 0xBF61,         0,
1052                 0xBF62,         0,
1053                 0xBF63,         0,
1054                 0,              0,
1055 #else
1056                 0x2008,         0x0000,
1057                 0xBF56,         4,
1058                 0xBF57,         0,
1059                 0xBF58,         5,
1060                 0xBF59,         0,
1061                 0xBF5A,         6,
1062                 0xBF5B,         0,
1063                 0xBF5C,         8,
1064                 0xBF5D,         0,
1065                 0,              0,
1066                 0,              0,
1067                 0,              0,
1068                 0,              0,
1069                 0,              0,
1070                 0,              0,
1071                 0,              0,
1072 #endif
1073
1074                 0x200e,         0x0000,
1075                 0xBF10,         0,
1076                 0xBF11,         0,
1077                 0xBF12,         0,
1078                 0xBF13,         0,
1079                 0xBF14,         0,
1080                 0xBF15,         0,
1081                 0xBF16,         0,
1082                 0xBF17,         0,
1083                 0xBF7E,         0,
1084                 0xBF7F,         1,
1085                 0xBF52,         framelen[0],
1086                 0xBF53,         framelen[1],
1087                 0xBF54,         framelen[2],
1088                 0xBF55,         framelen[3],
1089                 0,              0,
1090         };
1091
1092         return copy_packages(code, pack, 6, space);
1093 }
1094
1095 static int config_package(struct go7007 *go, u16 *code, int space)
1096 {
1097         int fps = go->sensor_framerate / go->fps_scale / 1000;
1098         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1099         int brc_window_size = fps;
1100         int q_min = 2, q_max = 31;
1101         int THACCoeffSet0 = 0;
1102         u16 pack[] = {
1103                 0x200e,         0x0000,
1104                 0xc002,         0x14b4,
1105                 0xc003,         0x28b4,
1106                 0xc004,         0x3c5a,
1107                 0xdc05,         0x2a77,
1108                 0xc6c3,         go->format == GO7007_FORMAT_MPEG4 ? 0 :
1109                                 (go->format == GO7007_FORMAT_H263 ? 0 : 1),
1110                 0xc680,         go->format == GO7007_FORMAT_MPEG4 ? 0xf1 :
1111                                 (go->format == GO7007_FORMAT_H263 ? 0x61 :
1112                                                                         0xd3),
1113                 0xc780,         0x0140,
1114                 0xe009,         0x0001,
1115                 0xc60f,         0x0008,
1116                 0xd4ff,         0x0002,
1117                 0xe403,         2340,
1118                 0xe406,         75,
1119                 0xd411,         0x0001,
1120                 0xd410,         0xa1d6,
1121                 0x0001,         0x2801,
1122
1123                 0x200d,         0x0000,
1124                 0xe402,         0x018b,
1125                 0xe401,         0x8b01,
1126                 0xd472,         (go->board_info->sensor_flags &
1127                                                         GO7007_SENSOR_TV) &&
1128                                                 (!go->interlace_coding) ?
1129                                         0x01b0 : 0x0170,
1130                 0xd475,         (go->board_info->sensor_flags &
1131                                                         GO7007_SENSOR_TV) &&
1132                                                 (!go->interlace_coding) ?
1133                                         0x0008 : 0x0009,
1134                 0xc404,         go->interlace_coding ? 0x44 :
1135                                 (go->format == GO7007_FORMAT_MPEG4 ? 0x11 :
1136                                 (go->format == GO7007_FORMAT_MPEG1 ? 0x02 :
1137                                 (go->format == GO7007_FORMAT_MPEG2 ? 0x04 :
1138                                 (go->format == GO7007_FORMAT_H263  ? 0x08 :
1139                                                                      0x20)))),
1140                 0xbf0a,         (go->format == GO7007_FORMAT_MPEG4 ? 8 :
1141                                 (go->format == GO7007_FORMAT_MPEG1 ? 1 :
1142                                 (go->format == GO7007_FORMAT_MPEG2 ? 2 :
1143                                 (go->format == GO7007_FORMAT_H263 ? 4 : 16)))) |
1144                                 ((go->repeat_seqhead ? 1 : 0) << 6) |
1145                                 ((go->dvd_mode ? 1 : 0) << 9) |
1146                                 ((go->gop_header_enable ? 1 : 0) << 10),
1147                 0xbf0b,         0,
1148                 0xdd5a,         go->ipb ? 0x14 : 0x0a,
1149                 0xbf0c,         0,
1150                 0xbf0d,         0,
1151                 0xc683,         THACCoeffSet0,
1152                 0xc40a,         (go->width << 4) | rows,
1153                 0xe01a,         go->board_info->hpi_buffer_cap,
1154                 0,              0,
1155                 0,              0,
1156
1157                 0x2008,         0,
1158                 0xe402,         0x88,
1159                 0xe401,         0x8f01,
1160                 0xbf6a,         0,
1161                 0xbf6b,         0,
1162                 0xbf6c,         0,
1163                 0xbf6d,         0,
1164                 0xbf6e,         0,
1165                 0xbf6f,         0,
1166                 0,              0,
1167                 0,              0,
1168                 0,              0,
1169                 0,              0,
1170                 0,              0,
1171                 0,              0,
1172                 0,              0,
1173
1174                 0x200e,         0,
1175                 0xbf66,         brc_window_size,
1176                 0xbf67,         0,
1177                 0xbf68,         q_min,
1178                 0xbf69,         q_max,
1179                 0xbfe0,         0,
1180                 0xbfe1,         0,
1181                 0xbfe2,         0,
1182                 0xbfe3,         go->ipb ? 3 : 1,
1183                 0xc031,         go->board_info->sensor_flags &
1184                                         GO7007_SENSOR_VBI ? 1 : 0,
1185                 0xc01c,         0x1f,
1186                 0xdd8c,         0x15,
1187                 0xdd94,         0x15,
1188                 0xdd88,         go->ipb ? 0x1401 : 0x0a01,
1189                 0xdd90,         go->ipb ? 0x1401 : 0x0a01,
1190                 0,              0,
1191
1192                 0x200e,         0,
1193                 0xbfe4,         0,
1194                 0xbfe5,         0,
1195                 0xbfe6,         0,
1196                 0xbfe7,         fps << 8,
1197                 0xbfe8,         0x3a00,
1198                 0xbfe9,         0,
1199                 0xbfea,         0,
1200                 0xbfeb,         0,
1201                 0xbfec,         (go->interlace_coding ? 1 << 15 : 0) |
1202                                         (go->modet_enable ? 0xa : 0) |
1203                                         (go->board_info->sensor_flags &
1204                                                 GO7007_SENSOR_VBI ? 1 : 0),
1205                 0xbfed,         0,
1206                 0xbfee,         0,
1207                 0xbfef,         0,
1208                 0xbff0,         go->board_info->sensor_flags &
1209                                         GO7007_SENSOR_TV ? 0xf060 : 0xb060,
1210                 0xbff1,         0,
1211                 0,              0,
1212         };
1213
1214         return copy_packages(code, pack, 5, space);
1215 }
1216
1217 static int seqhead_to_package(struct go7007 *go, u16 *code, int space,
1218         int (*sequence_header_func)(struct go7007 *go,
1219                 unsigned char *buf, int ext))
1220 {
1221         int vop_time_increment_bitlength = vti_bitlen(go);
1222         int fps = go->sensor_framerate / go->fps_scale *
1223                                         (go->interlace_coding ? 2 : 1);
1224         unsigned char buf[40] = { };
1225         int len = sequence_header_func(go, buf, 1);
1226         u16 pack[] = {
1227                 0x2006,         0,
1228                 0xbf08,         fps,
1229                 0xbf09,         0,
1230                 0xbff2,         vop_time_increment_bitlength,
1231                 0xbff3,         (1 << vop_time_increment_bitlength) - 1,
1232                 0xbfe6,         0,
1233                 0xbfe7,         (fps / 1000) << 8,
1234                 0,              0,
1235                 0,              0,
1236                 0,              0,
1237                 0,              0,
1238                 0,              0,
1239                 0,              0,
1240                 0,              0,
1241                 0,              0,
1242                 0,              0,
1243
1244                 0x2007,         0,
1245                 0xc800,         buf[2] << 8 | buf[3],
1246                 0xc801,         buf[4] << 8 | buf[5],
1247                 0xc802,         buf[6] << 8 | buf[7],
1248                 0xc803,         buf[8] << 8 | buf[9],
1249                 0xc406,         64,
1250                 0xc407,         len - 64,
1251                 0xc61b,         1,
1252                 0,              0,
1253                 0,              0,
1254                 0,              0,
1255                 0,              0,
1256                 0,              0,
1257                 0,              0,
1258                 0,              0,
1259                 0,              0,
1260
1261                 0x200e,         0,
1262                 0xc808,         buf[10] << 8 | buf[11],
1263                 0xc809,         buf[12] << 8 | buf[13],
1264                 0xc80a,         buf[14] << 8 | buf[15],
1265                 0xc80b,         buf[16] << 8 | buf[17],
1266                 0xc80c,         buf[18] << 8 | buf[19],
1267                 0xc80d,         buf[20] << 8 | buf[21],
1268                 0xc80e,         buf[22] << 8 | buf[23],
1269                 0xc80f,         buf[24] << 8 | buf[25],
1270                 0xc810,         buf[26] << 8 | buf[27],
1271                 0xc811,         buf[28] << 8 | buf[29],
1272                 0xc812,         buf[30] << 8 | buf[31],
1273                 0xc813,         buf[32] << 8 | buf[33],
1274                 0xc814,         buf[34] << 8 | buf[35],
1275                 0xc815,         buf[36] << 8 | buf[37],
1276                 0,              0,
1277                 0,              0,
1278                 0,              0,
1279         };
1280
1281         return copy_packages(code, pack, 3, space);
1282 }
1283
1284 static int relative_prime(int big, int little)
1285 {
1286         int remainder;
1287
1288         while (little != 0) {
1289                 remainder = big % little;
1290                 big = little;
1291                 little = remainder;
1292         }
1293         return big;
1294 }
1295
1296 static int avsync_to_package(struct go7007 *go, u16 *code, int space)
1297 {
1298         int arate = go->board_info->audio_rate * 1001 * go->fps_scale;
1299         int ratio = arate / go->sensor_framerate;
1300         int adjratio = ratio * 215 / 100;
1301         int rprime = relative_prime(go->sensor_framerate,
1302                                         arate % go->sensor_framerate);
1303         int f1 = (arate % go->sensor_framerate) / rprime;
1304         int f2 = (go->sensor_framerate - arate % go->sensor_framerate) / rprime;
1305         u16 pack[] = {
1306                 0x200e,         0,
1307                 0xbf98,         (u16)((-adjratio) & 0xffff),
1308                 0xbf99,         (u16)((-adjratio) >> 16),
1309                 0xbf92,         0,
1310                 0xbf93,         0,
1311                 0xbff4,         f1 > f2 ? f1 : f2,
1312                 0xbff5,         f1 < f2 ? f1 : f2,
1313                 0xbff6,         f1 < f2 ? ratio : ratio + 1,
1314                 0xbff7,         f1 > f2 ? ratio : ratio + 1,
1315                 0xbff8,         0,
1316                 0xbff9,         0,
1317                 0xbffa,         adjratio & 0xffff,
1318                 0xbffb,         adjratio >> 16,
1319                 0xbf94,         0,
1320                 0xbf95,         0,
1321                 0,              0,
1322         };
1323
1324         return copy_packages(code, pack, 1, space);
1325 }
1326
1327 static int final_package(struct go7007 *go, u16 *code, int space)
1328 {
1329         int rows = go->interlace_coding ? go->height / 32 : go->height / 16;
1330         u16 pack[] = {
1331                 0x8000,
1332                 0,
1333                 0,
1334                 0,
1335                 0,
1336                 0,
1337                 0,
1338                 2,
1339                 ((go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
1340                                                 (!go->interlace_coding) ?
1341                                         (1 << 14) | (1 << 9) : 0) |
1342                         ((go->encoder_subsample ? 1 : 0) << 8) |
1343                         (go->board_info->sensor_flags &
1344                                 GO7007_SENSOR_CONFIG_MASK),
1345                 ((go->encoder_v_halve ? 1 : 0) << 14) |
1346                         (go->encoder_v_halve ? rows << 9 : rows << 8) |
1347                         (go->encoder_h_halve ? 1 << 6 : 0) |
1348                         (go->encoder_h_halve ? go->width >> 3 : go->width >> 4),
1349                 (1 << 15) | (go->encoder_v_offset << 6) |
1350                         (1 << 7) | (go->encoder_h_offset >> 2),
1351                 (1 << 6),
1352                 0,
1353                 0,
1354                 ((go->fps_scale - 1) << 8) |
1355                         (go->board_info->sensor_flags & GO7007_SENSOR_TV ?
1356                                                 (1 << 7) : 0) |
1357                         0x41,
1358                 go->ipb ? 0xd4c : 0x36b,
1359                 (rows << 8) | (go->width >> 4),
1360                 go->format == GO7007_FORMAT_MPEG4 ? 0x0404 : 0,
1361                 (1 << 15) | ((go->interlace_coding ? 1 : 0) << 13) |
1362                         ((go->closed_gop ? 1 : 0) << 12) |
1363                         ((go->format == GO7007_FORMAT_MPEG4 ? 1 : 0) << 11) |
1364                 /*      (1 << 9) |   */
1365                         ((go->ipb ? 3 : 0) << 7) |
1366                         ((go->modet_enable ? 1 : 0) << 2) |
1367                         ((go->dvd_mode ? 1 : 0) << 1) | 1,
1368                 (go->format == GO7007_FORMAT_MPEG1 ? 0x89a0 :
1369                         (go->format == GO7007_FORMAT_MPEG2 ? 0x89a0 :
1370                         (go->format == GO7007_FORMAT_MJPEG ? 0x89a0 :
1371                         (go->format == GO7007_FORMAT_MPEG4 ? 0x8920 :
1372                         (go->format == GO7007_FORMAT_H263 ? 0x8920 : 0))))),
1373                 go->ipb ? 0x1f15 : 0x1f0b,
1374                 go->ipb ? 0x0015 : 0x000b,
1375                 go->ipb ? 0xa800 : 0x5800,
1376                 0xffff,
1377                 0x0020 + 0x034b * 0,
1378                 0x0020 + 0x034b * 1,
1379                 0x0020 + 0x034b * 2,
1380                 0x0020 + 0x034b * 3,
1381                 0x0020 + 0x034b * 4,
1382                 0x0020 + 0x034b * 5,
1383                 go->ipb ? (go->gop_size / 3) : go->gop_size,
1384                 (go->height >> 4) * (go->width >> 4) * 110 / 100,
1385         };
1386
1387         return copy_packages(code, pack, 1, space);
1388 }
1389
1390 static int audio_to_package(struct go7007 *go, u16 *code, int space)
1391 {
1392         int clock_config = ((go->board_info->audio_flags &
1393                                 GO7007_AUDIO_I2S_MASTER ? 1 : 0) << 11) |
1394                         ((go->board_info->audio_flags &
1395                                 GO7007_AUDIO_OKI_MODE ? 1 : 0) << 8) |
1396                         (((go->board_info->audio_bclk_div / 4) - 1) << 4) |
1397                         (go->board_info->audio_main_div - 1);
1398         u16 pack[] = {
1399                 0x200d,         0,
1400                 0x9002,         0,
1401                 0x9002,         0,
1402                 0x9031,         0,
1403                 0x9032,         0,
1404                 0x9033,         0,
1405                 0x9034,         0,
1406                 0x9035,         0,
1407                 0x9036,         0,
1408                 0x9037,         0,
1409                 0x9040,         0,
1410                 0x9000,         clock_config,
1411                 0x9001,         (go->board_info->audio_flags & 0xffff) |
1412                                         (1 << 9),
1413                 0x9000,         ((go->board_info->audio_flags &
1414                                                 GO7007_AUDIO_I2S_MASTER ?
1415                                                 1 : 0) << 10) |
1416                                         clock_config,
1417                 0,              0,
1418                 0,              0,
1419                 0x2005,         0,
1420                 0x9041,         0,
1421                 0x9042,         256,
1422                 0x9043,         0,
1423                 0x9044,         16,
1424                 0x9045,         16,
1425                 0,              0,
1426                 0,              0,
1427                 0,              0,
1428                 0,              0,
1429                 0,              0,
1430                 0,              0,
1431                 0,              0,
1432                 0,              0,
1433                 0,              0,
1434                 0,              0,
1435         };
1436
1437         return copy_packages(code, pack, 2, space);
1438 }
1439
1440 static int modet_to_package(struct go7007 *go, u16 *code, int space)
1441 {
1442         int ret, mb, i, addr, cnt = 0;
1443         u16 pack[32];
1444         u16 thresholds[] = {
1445                 0x200e,         0,
1446                 0xbf82,         go->modet[0].pixel_threshold,
1447                 0xbf83,         go->modet[1].pixel_threshold,
1448                 0xbf84,         go->modet[2].pixel_threshold,
1449                 0xbf85,         go->modet[3].pixel_threshold,
1450                 0xbf86,         go->modet[0].motion_threshold,
1451                 0xbf87,         go->modet[1].motion_threshold,
1452                 0xbf88,         go->modet[2].motion_threshold,
1453                 0xbf89,         go->modet[3].motion_threshold,
1454                 0xbf8a,         go->modet[0].mb_threshold,
1455                 0xbf8b,         go->modet[1].mb_threshold,
1456                 0xbf8c,         go->modet[2].mb_threshold,
1457                 0xbf8d,         go->modet[3].mb_threshold,
1458                 0xbf8e,         0,
1459                 0xbf8f,         0,
1460                 0,              0,
1461         };
1462
1463         ret = copy_packages(code, thresholds, 1, space);
1464         if (ret < 0)
1465                 return -1;
1466         cnt += ret;
1467
1468         addr = 0xbac0;
1469         memset(pack, 0, 64);
1470         i = 0;
1471         for (mb = 0; mb < 1624; ++mb) {
1472                 pack[i * 2 + 3] <<= 2;
1473                 pack[i * 2 + 3] |= go->modet_map[mb];
1474                 if (mb % 8 != 7)
1475                         continue;
1476                 pack[i * 2 + 2] = addr++;
1477                 ++i;
1478                 if (i == 10 || mb == 1623) {
1479                         pack[0] = 0x2000 | i;
1480                         ret = copy_packages(code + cnt, pack, 1, space - cnt);
1481                         if (ret < 0)
1482                                 return -1;
1483                         cnt += ret;
1484                         i = 0;
1485                         memset(pack, 0, 64);
1486                 }
1487                 pack[i * 2 + 3] = 0;
1488         }
1489
1490         memset(pack, 0, 64);
1491         i = 0;
1492         for (addr = 0xbb90; addr < 0xbbfa; ++addr) {
1493                 pack[i * 2 + 2] = addr;
1494                 pack[i * 2 + 3] = 0;
1495                 ++i;
1496                 if (i == 10 || addr == 0xbbf9) {
1497                         pack[0] = 0x2000 | i;
1498                         ret = copy_packages(code + cnt, pack, 1, space - cnt);
1499                         if (ret < 0)
1500                                 return -1;
1501                         cnt += ret;
1502                         i = 0;
1503                         memset(pack, 0, 64);
1504                 }
1505         }
1506         return cnt;
1507 }
1508
1509 static int do_special(struct go7007 *go, u16 type, u16 *code, int space,
1510                         int *framelen)
1511 {
1512         switch (type) {
1513         case SPECIAL_FRM_HEAD:
1514                 switch (go->format) {
1515                 case GO7007_FORMAT_MJPEG:
1516                         return gen_mjpeghdr_to_package(go, code, space);
1517                 case GO7007_FORMAT_MPEG1:
1518                 case GO7007_FORMAT_MPEG2:
1519                         return gen_mpeg1hdr_to_package(go, code, space,
1520                                                                 framelen);
1521                 case GO7007_FORMAT_MPEG4:
1522                         return gen_mpeg4hdr_to_package(go, code, space,
1523                                                                 framelen);
1524                 }
1525         case SPECIAL_BRC_CTRL:
1526                 return brctrl_to_package(go, code, space, framelen);
1527         case SPECIAL_CONFIG:
1528                 return config_package(go, code, space);
1529         case SPECIAL_SEQHEAD:
1530                 switch (go->format) {
1531                 case GO7007_FORMAT_MPEG1:
1532                 case GO7007_FORMAT_MPEG2:
1533                         return seqhead_to_package(go, code, space,
1534                                         mpeg1_sequence_header);
1535                 case GO7007_FORMAT_MPEG4:
1536                         return seqhead_to_package(go, code, space,
1537                                         mpeg4_sequence_header);
1538                 default:
1539                         return 0;
1540                 }
1541         case SPECIAL_AV_SYNC:
1542                 return avsync_to_package(go, code, space);
1543         case SPECIAL_FINAL:
1544                 return final_package(go, code, space);
1545         case SPECIAL_AUDIO:
1546                 return audio_to_package(go, code, space);
1547         case SPECIAL_MODET:
1548                 return modet_to_package(go, code, space);
1549         }
1550         printk(KERN_ERR
1551                 "go7007: firmware file contains unsupported feature %04x\n",
1552                 type);
1553         return -1;
1554 }
1555
1556 int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen)
1557 {
1558         const struct firmware *fw_entry;
1559         u16 *code, *src;
1560         int framelen[8] = { }; /* holds the lengths of empty frame templates */
1561         int codespace = 64 * 1024, i = 0, srclen, chunk_len, chunk_flags;
1562         int mode_flag;
1563         int ret;
1564
1565         switch (go->format) {
1566         case GO7007_FORMAT_MJPEG:
1567                 mode_flag = FLAG_MODE_MJPEG;
1568                 break;
1569         case GO7007_FORMAT_MPEG1:
1570                 mode_flag = FLAG_MODE_MPEG1;
1571                 break;
1572         case GO7007_FORMAT_MPEG2:
1573                 mode_flag = FLAG_MODE_MPEG2;
1574                 break;
1575         case GO7007_FORMAT_MPEG4:
1576                 mode_flag = FLAG_MODE_MPEG4;
1577                 break;
1578         default:
1579                 return -1;
1580         }
1581         if (request_firmware(&fw_entry, go->board_info->firmware, go->dev)) {
1582                 printk(KERN_ERR
1583                         "go7007: unable to load firmware from file \"%s\"\n",
1584                         go->board_info->firmware);
1585                 return -1;
1586         }
1587         code = kmalloc(codespace * 2, GFP_KERNEL);
1588         if (code == NULL) {
1589                 printk(KERN_ERR "go7007: unable to allocate %d bytes for "
1590                                 "firmware construction\n", codespace * 2);
1591                 goto fw_failed;
1592         }
1593         memset(code, 0, codespace * 2);
1594         src = (u16 *)fw_entry->data;
1595         srclen = fw_entry->size / 2;
1596         while (srclen >= 2) {
1597                 chunk_flags = __le16_to_cpu(src[0]);
1598                 chunk_len = __le16_to_cpu(src[1]);
1599                 if (chunk_len + 2 > srclen) {
1600                         printk(KERN_ERR "go7007: firmware file \"%s\" "
1601                                         "appears to be corrupted\n",
1602                                         go->board_info->firmware);
1603                         goto fw_failed;
1604                 }
1605                 if (chunk_flags & mode_flag) {
1606                         if (chunk_flags & FLAG_SPECIAL) {
1607                                 ret = do_special(go, __le16_to_cpu(src[2]),
1608                                         &code[i], codespace - i, framelen);
1609                                 if (ret < 0) {
1610                                         printk(KERN_ERR "go7007: insufficient "
1611                                                         "memory for firmware "
1612                                                         "construction\n");
1613                                         goto fw_failed;
1614                                 }
1615                                 i += ret;
1616                         } else {
1617                                 if (codespace - i < chunk_len) {
1618                                         printk(KERN_ERR "go7007: insufficient "
1619                                                         "memory for firmware "
1620                                                         "construction\n");
1621                                         goto fw_failed;
1622                                 }
1623                                 memcpy(&code[i], &src[2], chunk_len * 2);
1624                                 i += chunk_len;
1625                         }
1626                 }
1627                 srclen -= chunk_len + 2;
1628                 src += chunk_len + 2;
1629         }
1630         release_firmware(fw_entry);
1631         *fw = (u8 *)code;
1632         *fwlen = i * 2;
1633         return 0;
1634
1635 fw_failed:
1636         kfree(code);
1637         release_firmware(fw_entry);
1638         return -1;
1639 }