drivers/media/video/saa7114.c

   1 /*
   2  * saa7114 - Philips SAA7114H video decoder driver version 0.0.1
   3  *
   4  * Copyright (C) 2002 Maxim Yevtyushkin <max@linuxmedialabs.com>
   5  *
   6  * Based on saa7111 driver by Dave Perks
   7  *
   8  * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
   9  *
  10  * Slight changes for video timing and attachment output by
  11  * Wolfgang Scherr <scherr@net4you.net>
  12  *
  13  * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
  14  *    - moved over to linux>=2.4.x i2c protocol (1/1/2003)
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29  */
  30
  31 #include <linux/module.h>
  32 #include <linux/init.h>
  33 #include <linux/delay.h>
  34 #include <linux/errno.h>
  35 #include <linux/fs.h>
  36 #include <linux/kernel.h>
  37 #include <linux/major.h>
  38
  39 #include <linux/slab.h>
  40
  41 #include <linux/mm.h>
  42 #include <linux/pci.h>
  43 #include <linux/signal.h>
  44 #include <asm/io.h>
  45 #include <asm/pgtable.h>
  46 #include <asm/page.h>
  47 #include <linux/sched.h>
  48 #include <asm/segment.h>
  49 #include <linux/types.h>
  50
  51 #include <linux/videodev.h>
  52 #include <asm/uaccess.h>
  53
  54 MODULE_DESCRIPTION("Philips SAA7114H video decoder driver");
  55 MODULE_AUTHOR("Maxim Yevtyushkin");
  56 MODULE_LICENSE("GPL");
  57
  58 #include <linux/i2c.h>
  59 #include <linux/i2c-dev.h>
  60
  61 #define I2C_NAME(x) (x)->name
  62
  63 #include <linux/video_decoder.h>
  64
  65 static int debug = 0;
  66 MODULE_PARM(debug, "i");
  67 MODULE_PARM_DESC(debug, "Debug level (0-1)");
  68
  69 #define dprintk(num, format, args...) \
  70         do { \
  71                 if (debug >= num) \
  72                         printk(format, ##args); \
  73         } while (0)
  74
  75 /* ----------------------------------------------------------------------- */
  76
  77 struct saa7114 {
  78         unsigned char reg[0xf0 * 2];
  79
  80         int norm;
  81         int input;
  82         int enable;
  83         int bright;
  84         int contrast;
  85         int hue;
  86         int sat;
  87         int playback;
  88 };
  89
  90 #define   I2C_SAA7114        0x42
  91 #define   I2C_SAA7114A       0x40
  92
  93 #define   I2C_DELAY   10
  94
  95
  96 //#define SAA_7114_NTSC_HSYNC_START       (-3)
  97 //#define SAA_7114_NTSC_HSYNC_STOP        (-18)
  98
  99 #define SAA_7114_NTSC_HSYNC_START  (-17)
 100 #define SAA_7114_NTSC_HSYNC_STOP   (-32)
 101
 102 //#define SAA_7114_NTSC_HOFFSET           (5)
 103 #define SAA_7114_NTSC_HOFFSET           (6)
 104 #define SAA_7114_NTSC_VOFFSET           (10)
 105 #define SAA_7114_NTSC_WIDTH             (720)
 106 #define SAA_7114_NTSC_HEIGHT            (250)
 107
 108 #define SAA_7114_SECAM_HSYNC_START      (-17)
 109 #define SAA_7114_SECAM_HSYNC_STOP       (-32)
 110
 111 #define SAA_7114_SECAM_HOFFSET          (2)
 112 #define SAA_7114_SECAM_VOFFSET          (10)
 113 #define SAA_7114_SECAM_WIDTH            (720)
 114 #define SAA_7114_SECAM_HEIGHT           (300)
 115
 116 #define SAA_7114_PAL_HSYNC_START        (-17)
 117 #define SAA_7114_PAL_HSYNC_STOP         (-32)
 118
 119 #define SAA_7114_PAL_HOFFSET            (2)
 120 #define SAA_7114_PAL_VOFFSET            (10)
 121 #define SAA_7114_PAL_WIDTH              (720)
 122 #define SAA_7114_PAL_HEIGHT             (300)
 123
 124
 125
 126 #define SAA_7114_VERTICAL_CHROMA_OFFSET         0       //0x50504040
 127 #define SAA_7114_VERTICAL_LUMA_OFFSET           0
 128
 129 #define REG_ADDR(x) (((x) << 1) + 1)
 130 #define LOBYTE(x) ((unsigned char)((x) & 0xff))
 131 #define HIBYTE(x) ((unsigned char)(((x) >> 8) & 0xff))
 132 #define LOWORD(x) ((unsigned short int)((x) & 0xffff))
 133 #define HIWORD(x) ((unsigned short int)(((x) >> 16) & 0xffff))
 134
 135
 136 /* ----------------------------------------------------------------------- */
 137
 138 static inline int
 139 saa7114_write (struct i2c_client *client,
 140                u8                 reg,
 141                u8                 value)
 142 {
 143         /*struct saa7114 *decoder = i2c_get_clientdata(client);*/
 144
 145         /*decoder->reg[reg] = value;*/
 146         return i2c_smbus_write_byte_data(client, reg, value);
 147 }
 148
 149 static int
 150 saa7114_write_block (struct i2c_client *client,
 151                      const u8          *data,
 152                      unsigned int       len)
 153 {
 154         int ret = -1;
 155         u8 reg;
 156
 157         /* the saa7114 has an autoincrement function, use it if
 158          * the adapter understands raw I2C */
 159         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 160                 /* do raw I2C, not smbus compatible */
 161                 /*struct saa7114 *decoder = i2c_get_clientdata(client);*/
 162                 struct i2c_msg msg;
 163                 u8 block_data[32];
 164
 165                 msg.addr = client->addr;
 166                 msg.flags = client->flags;
 167                 while (len >= 2) {
 168                         msg.buf = (char *) block_data;
 169                         msg.len = 0;
 170                         block_data[msg.len++] = reg = data[0];
 171                         do {
 172                                 block_data[msg.len++] =
 173                                     /*decoder->reg[reg++] =*/ data[1];
 174                                 len -= 2;
 175                                 data += 2;
 176                         } while (len >= 2 && data[0] == reg &&
 177                                  msg.len < 32);
 178                         if ((ret = i2c_transfer(client->adapter,
 179                                                 &msg, 1)) < 0)
 180                                 break;
 181                 }
 182         } else {
 183                 /* do some slow I2C emulation kind of thing */
 184                 while (len >= 2) {
 185                         reg = *data++;
 186                         if ((ret = saa7114_write(client, reg,
 187                                                  *data++)) < 0)
 188                                 break;
 189                         len -= 2;
 190                 }
 191         }
 192
 193         return ret;
 194 }
 195
 196 static inline int
 197 saa7114_read (struct i2c_client *client,
 198               u8                 reg)
 199 {
 200         return i2c_smbus_read_byte_data(client, reg);
 201 }
 202
 203 /* ----------------------------------------------------------------------- */
 204
 205 // initially set NTSC, composite
 206
 207
 208 static const unsigned char init[] = {
 209         0x00, 0x00,             /* 00 - ID byte , chip version,
 210                                  * read only */
 211         0x01, 0x08,             /* 01 - X,X,X,X, IDEL3 to IDEL0 -
 212                                  * horizontal increment delay,
 213                                  * recommended position */
 214         0x02, 0x00,             /* 02 - FUSE=3, GUDL=2, MODE=0 ;
 215                                  * input control */
 216         0x03, 0x10,             /* 03 - HLNRS=0, VBSL=1, WPOFF=0,
 217                                  * HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
 218         0x04, 0x90,             /* 04 - GAI1=256 */
 219         0x05, 0x90,             /* 05 - GAI2=256 */
 220         0x06, SAA_7114_NTSC_HSYNC_START,        /* 06 - HSB: hsync start,
 221                                  * depends on the video standard */
 222         0x07, SAA_7114_NTSC_HSYNC_STOP, /* 07 - HSS: hsync stop, depends
 223                                  *on the video standard */
 224         0x08, 0xb8,             /* 08 - AUFD=1, FSEL=1, EXFIL=0, VTRC=1,
 225                                  * HPLL: free running in playback, locked
 226                                  * in capture, VNOI=0 */
 227         0x09, 0x80,             /* 09 - BYPS=0, PREF=0, BPSS=0, VBLB=0,
 228                                  * UPTCV=0, APER=1; depends from input */
 229         0x0a, 0x80,             /* 0a - BRIG=128 */
 230         0x0b, 0x44,             /* 0b - CONT=1.109 */
 231         0x0c, 0x40,             /* 0c - SATN=1.0 */
 232         0x0d, 0x00,             /* 0d - HUE=0 */
 233         0x0e, 0x84,             /* 0e - CDTO, CSTD2 to 0, DCVF, FCTC,
 234                                  * CCOMB; depends from video standard */
 235         0x0f, 0x24,             /* 0f - ACGC,CGAIN6 to CGAIN0; depends
 236                                  * from video standard */
 237         0x10, 0x03,             /* 10 - OFFU1 to 0, OFFV1 to 0, CHBW,
 238                                  * LCBW2 to 0 */
 239         0x11, 0x59,             /* 11 - COLO, RTP1, HEDL1 to 0, RTP0,
 240                                  * YDEL2 to 0 */
 241         0x12, 0xc9,             /* 12 - RT signal control RTSE13 to 10
 242                                  * and 03 to 00 */
 243         0x13, 0x80,             /* 13 - RT/X port output control  */
 244         0x14, 0x00,             /* 14 - analog, ADC, compatibility control */
 245         0x15, 0x00,             /* 15 - VGATE start FID change  */
 246         0x16, 0xfe,             /* 16 - VGATE stop */
 247         0x17, 0x00,             /* 17 - Misc., VGATE MSBs */
 248         0x18, 0x40,             /* RAWG */
 249         0x19, 0x80,             /* RAWO */
 250         0x1a, 0x00,
 251         0x1b, 0x00,
 252         0x1c, 0x00,
 253         0x1d, 0x00,
 254         0x1e, 0x00,
 255         0x1f, 0x00,             /* status byte, read only */
 256         0x20, 0x00,             /* video decoder reserved part */
 257         0x21, 0x00,
 258         0x22, 0x00,
 259         0x23, 0x00,
 260         0x24, 0x00,
 261         0x25, 0x00,
 262         0x26, 0x00,
 263         0x27, 0x00,
 264         0x28, 0x00,
 265         0x29, 0x00,
 266         0x2a, 0x00,
 267         0x2b, 0x00,
 268         0x2c, 0x00,
 269         0x2d, 0x00,
 270         0x2e, 0x00,
 271         0x2f, 0x00,
 272         0x30, 0xbc,             /* audio clock generator */
 273         0x31, 0xdf,
 274         0x32, 0x02,
 275         0x33, 0x00,
 276         0x34, 0xcd,
 277         0x35, 0xcc,
 278         0x36, 0x3a,
 279         0x37, 0x00,
 280         0x38, 0x03,
 281         0x39, 0x10,
 282         0x3a, 0x00,
 283         0x3b, 0x00,
 284         0x3c, 0x00,
 285         0x3d, 0x00,
 286         0x3e, 0x00,
 287         0x3f, 0x00,
 288         0x40, 0x00,             /* VBI data slicer */
 289         0x41, 0xff,
 290         0x42, 0xff,
 291         0x43, 0xff,
 292         0x44, 0xff,
 293         0x45, 0xff,
 294         0x46, 0xff,
 295         0x47, 0xff,
 296         0x48, 0xff,
 297         0x49, 0xff,
 298         0x4a, 0xff,
 299         0x4b, 0xff,
 300         0x4c, 0xff,
 301         0x4d, 0xff,
 302         0x4e, 0xff,
 303         0x4f, 0xff,
 304         0x50, 0xff,
 305         0x51, 0xff,
 306         0x52, 0xff,
 307         0x53, 0xff,
 308         0x54, 0xff,
 309         0x55, 0xff,
 310         0x56, 0xff,
 311         0x57, 0xff,
 312         0x58, 0x40,             // framing code
 313         0x59, 0x47,             // horizontal offset
 314         0x5a, 0x06,             // vertical offset
 315         0x5b, 0x83,             // field offset
 316         0x5c, 0x00,             // reserved
 317         0x5d, 0x3e,             // header and data
 318         0x5e, 0x00,             // sliced data
 319         0x5f, 0x00,             // reserved
 320         0x60, 0x00,             /* video decoder reserved part */
 321         0x61, 0x00,
 322         0x62, 0x00,
 323         0x63, 0x00,
 324         0x64, 0x00,
 325         0x65, 0x00,
 326         0x66, 0x00,
 327         0x67, 0x00,
 328         0x68, 0x00,
 329         0x69, 0x00,
 330         0x6a, 0x00,
 331         0x6b, 0x00,
 332         0x6c, 0x00,
 333         0x6d, 0x00,
 334         0x6e, 0x00,
 335         0x6f, 0x00,
 336         0x70, 0x00,             /* video decoder reserved part */
 337         0x71, 0x00,
 338         0x72, 0x00,
 339         0x73, 0x00,
 340         0x74, 0x00,
 341         0x75, 0x00,
 342         0x76, 0x00,
 343         0x77, 0x00,
 344         0x78, 0x00,
 345         0x79, 0x00,
 346         0x7a, 0x00,
 347         0x7b, 0x00,
 348         0x7c, 0x00,
 349         0x7d, 0x00,
 350         0x7e, 0x00,
 351         0x7f, 0x00,
 352         0x80, 0x00,             /* X-port, I-port and scaler */
 353         0x81, 0x00,
 354         0x82, 0x00,
 355         0x83, 0x00,
 356         0x84, 0xc5,
 357         0x85, 0x0d,             // hsync and vsync ?
 358         0x86, 0x40,
 359         0x87, 0x01,
 360         0x88, 0x00,
 361         0x89, 0x00,
 362         0x8a, 0x00,
 363         0x8b, 0x00,
 364         0x8c, 0x00,
 365         0x8d, 0x00,
 366         0x8e, 0x00,
 367         0x8f, 0x00,
 368         0x90, 0x03,             /* Task A definition           */
 369         0x91, 0x08,
 370         0x92, 0x00,
 371         0x93, 0x40,
 372         0x94, 0x00,             // window settings
 373         0x95, 0x00,
 374         0x96, 0x00,
 375         0x97, 0x00,
 376         0x98, 0x00,
 377         0x99, 0x00,
 378         0x9a, 0x00,
 379         0x9b, 0x00,
 380         0x9c, 0x00,
 381         0x9d, 0x00,
 382         0x9e, 0x00,
 383         0x9f, 0x00,
 384         0xa0, 0x01,             /* horizontal integer prescaling ratio */
 385         0xa1, 0x00,             /* horizontal prescaler accumulation
 386                                  * sequence length */
 387         0xa2, 0x00,             /* UV FIR filter, Y FIR filter, prescaler
 388                                  * DC gain */
 389         0xa3, 0x00,
 390         0xa4, 0x80,             // luminance brightness
 391         0xa5, 0x40,             // luminance gain
 392         0xa6, 0x40,             // chrominance saturation
 393         0xa7, 0x00,
 394         0xa8, 0x00,             // horizontal luminance scaling increment
 395         0xa9, 0x04,
 396         0xaa, 0x00,             // horizontal luminance phase offset
 397         0xab, 0x00,
 398         0xac, 0x00,             // horizontal chrominance scaling increment
 399         0xad, 0x02,
 400         0xae, 0x00,             // horizontal chrominance phase offset
 401         0xaf, 0x00,
 402         0xb0, 0x00,             // vertical luminance scaling increment
 403         0xb1, 0x04,
 404         0xb2, 0x00,             // vertical chrominance scaling increment
 405         0xb3, 0x04,
 406         0xb4, 0x00,
 407         0xb5, 0x00,
 408         0xb6, 0x00,
 409         0xb7, 0x00,
 410         0xb8, 0x00,
 411         0xb9, 0x00,
 412         0xba, 0x00,
 413         0xbb, 0x00,
 414         0xbc, 0x00,
 415         0xbd, 0x00,
 416         0xbe, 0x00,
 417         0xbf, 0x00,
 418         0xc0, 0x02,             // Task B definition
 419         0xc1, 0x08,
 420         0xc2, 0x00,
 421         0xc3, 0x40,
 422         0xc4, 0x00,             // window settings
 423         0xc5, 0x00,
 424         0xc6, 0x00,
 425         0xc7, 0x00,
 426         0xc8, 0x00,
 427         0xc9, 0x00,
 428         0xca, 0x00,
 429         0xcb, 0x00,
 430         0xcc, 0x00,
 431         0xcd, 0x00,
 432         0xce, 0x00,
 433         0xcf, 0x00,
 434         0xd0, 0x01,             // horizontal integer prescaling ratio
 435         0xd1, 0x00,             // horizontal prescaler accumulation sequence length
 436         0xd2, 0x00,             // UV FIR filter, Y FIR filter, prescaler DC gain
 437         0xd3, 0x00,
 438         0xd4, 0x80,             // luminance brightness
 439         0xd5, 0x40,             // luminance gain
 440         0xd6, 0x40,             // chrominance saturation
 441         0xd7, 0x00,
 442         0xd8, 0x00,             // horizontal luminance scaling increment
 443         0xd9, 0x04,
 444         0xda, 0x00,             // horizontal luminance phase offset
 445         0xdb, 0x00,
 446         0xdc, 0x00,             // horizontal chrominance scaling increment
 447         0xdd, 0x02,
 448         0xde, 0x00,             // horizontal chrominance phase offset
 449         0xdf, 0x00,
 450         0xe0, 0x00,             // vertical luminance scaling increment
 451         0xe1, 0x04,
 452         0xe2, 0x00,             // vertical chrominance scaling increment
 453         0xe3, 0x04,
 454         0xe4, 0x00,
 455         0xe5, 0x00,
 456         0xe6, 0x00,
 457         0xe7, 0x00,
 458         0xe8, 0x00,
 459         0xe9, 0x00,
 460         0xea, 0x00,
 461         0xeb, 0x00,
 462         0xec, 0x00,
 463         0xed, 0x00,
 464         0xee, 0x00,
 465         0xef, 0x00
 466 };
 467
 468 static int
 469 saa7114_command (struct i2c_client *client,
 470                  unsigned int       cmd,
 471                  void              *arg)
 472 {
 473         struct saa7114 *decoder = i2c_get_clientdata(client);
 474
 475         switch (cmd) {
 476
 477         case 0:
 478                 //dprintk(1, KERN_INFO "%s: writing init\n", I2C_NAME(client));
 479                 //saa7114_write_block(client, init, sizeof(init));
 480                 break;
 481
 482         case DECODER_DUMP:
 483         {
 484                 int i;
 485
 486                 dprintk(1, KERN_INFO "%s: decoder dump\n", I2C_NAME(client));
 487
 488                 for (i = 0; i < 32; i += 16) {
 489                         int j;
 490
 491                         printk(KERN_DEBUG "%s: %03x", I2C_NAME(client), i);
 492                         for (j = 0; j < 16; ++j) {
 493                                 printk(" %02x",
 494                                        saa7114_read(client, i + j));
 495                         }
 496                         printk("\n");
 497                 }
 498         }
 499                 break;
 500
 501         case DECODER_GET_CAPABILITIES:
 502         {
 503                 struct video_decoder_capability *cap = arg;
 504
 505                 dprintk(1, KERN_DEBUG "%s: decoder get capabilities\n",
 506                         I2C_NAME(client));
 507
 508                 cap->flags = VIDEO_DECODER_PAL |
 509                              VIDEO_DECODER_NTSC |
 510                              VIDEO_DECODER_AUTO |
 511                              VIDEO_DECODER_CCIR;
 512                 cap->inputs = 8;
 513                 cap->outputs = 1;
 514         }
 515                 break;
 516
 517         case DECODER_GET_STATUS:
 518         {
 519                 int *iarg = arg;
 520                 int status;
 521                 int res;
 522
 523                 status = saa7114_read(client, 0x1f);
 524
 525                 dprintk(1, KERN_DEBUG "%s status: 0x%02x\n", I2C_NAME(client),
 526                         status);
 527                 res = 0;
 528                 if ((status & (1 << 6)) == 0) {
 529                         res |= DECODER_STATUS_GOOD;
 530                 }
 531                 switch (decoder->norm) {
 532                 case VIDEO_MODE_NTSC:
 533                         res |= DECODER_STATUS_NTSC;
 534                         break;
 535                 case VIDEO_MODE_PAL:
 536                         res |= DECODER_STATUS_PAL;
 537                         break;
 538                 case VIDEO_MODE_SECAM:
 539                         res |= DECODER_STATUS_SECAM;
 540                         break;
 541                 default:
 542                 case VIDEO_MODE_AUTO:
 543                         if ((status & (1 << 5)) != 0) {
 544                                 res |= DECODER_STATUS_NTSC;
 545                         } else {
 546                                 res |= DECODER_STATUS_PAL;
 547                         }
 548                         break;
 549                 }
 550                 if ((status & (1 << 0)) != 0) {
 551                         res |= DECODER_STATUS_COLOR;
 552                 }
 553                 *iarg = res;
 554         }
 555                 break;
 556
 557         case DECODER_SET_NORM:
 558         {
 559                 int *iarg = arg;
 560
 561                 short int hoff = 0, voff = 0, w = 0, h = 0;
 562
 563                 dprintk(1, KERN_DEBUG "%s: decoder set norm ",
 564                         I2C_NAME(client));
 565                 switch (*iarg) {
 566
 567                 case VIDEO_MODE_NTSC:
 568                         dprintk(1, "NTSC\n");
 569                         decoder->reg[REG_ADDR(0x06)] =
 570                             SAA_7114_NTSC_HSYNC_START;
 571                         decoder->reg[REG_ADDR(0x07)] =
 572                             SAA_7114_NTSC_HSYNC_STOP;
 573
 574                         decoder->reg[REG_ADDR(0x08)] = decoder->playback ? 0x7c : 0xb8; // PLL free when playback, PLL close when capture
 575
 576                         decoder->reg[REG_ADDR(0x0e)] = 0x85;
 577                         decoder->reg[REG_ADDR(0x0f)] = 0x24;
 578
 579                         hoff = SAA_7114_NTSC_HOFFSET;
 580                         voff = SAA_7114_NTSC_VOFFSET;
 581                         w = SAA_7114_NTSC_WIDTH;
 582                         h = SAA_7114_NTSC_HEIGHT;
 583
 584                         break;
 585
 586                 case VIDEO_MODE_PAL:
 587                         dprintk(1, "PAL\n");
 588                         decoder->reg[REG_ADDR(0x06)] =
 589                             SAA_7114_PAL_HSYNC_START;
 590                         decoder->reg[REG_ADDR(0x07)] =
 591                             SAA_7114_PAL_HSYNC_STOP;
 592
 593                         decoder->reg[REG_ADDR(0x08)] = decoder->playback ? 0x7c : 0xb8; // PLL free when playback, PLL close when capture
 594
 595                         decoder->reg[REG_ADDR(0x0e)] = 0x81;
 596                         decoder->reg[REG_ADDR(0x0f)] = 0x24;
 597
 598                         hoff = SAA_7114_PAL_HOFFSET;
 599                         voff = SAA_7114_PAL_VOFFSET;
 600                         w = SAA_7114_PAL_WIDTH;
 601                         h = SAA_7114_PAL_HEIGHT;
 602
 603                         break;
 604
 605                 default:
 606                         dprintk(1, " Unknown video mode!!!\n");
 607                         return -EINVAL;
 608
 609                 }
 610
 611
 612                 decoder->reg[REG_ADDR(0x94)] = LOBYTE(hoff);    // hoffset low
 613                 decoder->reg[REG_ADDR(0x95)] = HIBYTE(hoff) & 0x0f;     // hoffset high
 614                 decoder->reg[REG_ADDR(0x96)] = LOBYTE(w);       // width low
 615                 decoder->reg[REG_ADDR(0x97)] = HIBYTE(w) & 0x0f;        // width high
 616                 decoder->reg[REG_ADDR(0x98)] = LOBYTE(voff);    // voffset low
 617                 decoder->reg[REG_ADDR(0x99)] = HIBYTE(voff) & 0x0f;     // voffset high
 618                 decoder->reg[REG_ADDR(0x9a)] = LOBYTE(h + 2);   // height low
 619                 decoder->reg[REG_ADDR(0x9b)] = HIBYTE(h + 2) & 0x0f;    // height high
 620                 decoder->reg[REG_ADDR(0x9c)] = LOBYTE(w);       // out width low
 621                 decoder->reg[REG_ADDR(0x9d)] = HIBYTE(w) & 0x0f;        // out width high
 622                 decoder->reg[REG_ADDR(0x9e)] = LOBYTE(h);       // out height low
 623                 decoder->reg[REG_ADDR(0x9f)] = HIBYTE(h) & 0x0f;        // out height high
 624
 625                 decoder->reg[REG_ADDR(0xc4)] = LOBYTE(hoff);    // hoffset low
 626                 decoder->reg[REG_ADDR(0xc5)] = HIBYTE(hoff) & 0x0f;     // hoffset high
 627                 decoder->reg[REG_ADDR(0xc6)] = LOBYTE(w);       // width low
 628                 decoder->reg[REG_ADDR(0xc7)] = HIBYTE(w) & 0x0f;        // width high
 629                 decoder->reg[REG_ADDR(0xc8)] = LOBYTE(voff);    // voffset low
 630                 decoder->reg[REG_ADDR(0xc9)] = HIBYTE(voff) & 0x0f;     // voffset high
 631                 decoder->reg[REG_ADDR(0xca)] = LOBYTE(h + 2);   // height low
 632                 decoder->reg[REG_ADDR(0xcb)] = HIBYTE(h + 2) & 0x0f;    // height high
 633                 decoder->reg[REG_ADDR(0xcc)] = LOBYTE(w);       // out width low
 634                 decoder->reg[REG_ADDR(0xcd)] = HIBYTE(w) & 0x0f;        // out width high
 635                 decoder->reg[REG_ADDR(0xce)] = LOBYTE(h);       // out height low
 636                 decoder->reg[REG_ADDR(0xcf)] = HIBYTE(h) & 0x0f;        // out height high
 637
 638
 639                 saa7114_write(client, 0x80, 0x06);      // i-port and scaler back end clock selection, task A&B off
 640                 saa7114_write(client, 0x88, 0xd8);      // sw reset scaler
 641                 saa7114_write(client, 0x88, 0xf8);      // sw reset scaler release
 642
 643                 saa7114_write_block(client, decoder->reg + (0x06 << 1),
 644                                     3 << 1);
 645                 saa7114_write_block(client, decoder->reg + (0x0e << 1),
 646                                     2 << 1);
 647                 saa7114_write_block(client, decoder->reg + (0x5a << 1),
 648                                     2 << 1);
 649
 650                 saa7114_write_block(client, decoder->reg + (0x94 << 1),
 651                                     (0x9f + 1 - 0x94) << 1);
 652                 saa7114_write_block(client, decoder->reg + (0xc4 << 1),
 653                                     (0xcf + 1 - 0xc4) << 1);
 654
 655                 saa7114_write(client, 0x88, 0xd8);      // sw reset scaler
 656                 saa7114_write(client, 0x88, 0xf8);      // sw reset scaler release
 657                 saa7114_write(client, 0x80, 0x36);      // i-port and scaler back end clock selection
 658
 659                 decoder->norm = *iarg;
 660         }
 661                 break;
 662
 663         case DECODER_SET_INPUT:
 664         {
 665                 int *iarg = arg;
 666
 667                 dprintk(1, KERN_DEBUG "%s: decoder set input (%d)\n",
 668                         I2C_NAME(client), *iarg);
 669                 if (*iarg < 0 || *iarg > 7) {
 670                         return -EINVAL;
 671                 }
 672
 673                 if (decoder->input != *iarg) {
 674                         dprintk(1, KERN_DEBUG "%s: now setting %s input\n",
 675                                 I2C_NAME(client),
 676                                 *iarg >= 6 ? "S-Video" : "Composite");
 677                         decoder->input = *iarg;
 678
 679                         /* select mode */
 680                         decoder->reg[REG_ADDR(0x02)] =
 681                             (decoder->
 682                              reg[REG_ADDR(0x02)] & 0xf0) | (decoder->
 683                                                             input <
 684                                                             6 ? 0x0 : 0x9);
 685                         saa7114_write(client, 0x02,
 686                                       decoder->reg[REG_ADDR(0x02)]);
 687
 688                         /* bypass chrominance trap for modes 6..9 */
 689                         decoder->reg[REG_ADDR(0x09)] =
 690                             (decoder->
 691                              reg[REG_ADDR(0x09)] & 0x7f) | (decoder->
 692                                                             input <
 693                                                             6 ? 0x0 :
 694                                                             0x80);
 695                         saa7114_write(client, 0x09,
 696                                       decoder->reg[REG_ADDR(0x09)]);
 697
 698                         decoder->reg[REG_ADDR(0x0e)] =
 699                             decoder->input <
 700                             6 ? decoder->
 701                             reg[REG_ADDR(0x0e)] | 1 : decoder->
 702                             reg[REG_ADDR(0x0e)] & ~1;
 703                         saa7114_write(client, 0x0e,
 704                                       decoder->reg[REG_ADDR(0x0e)]);
 705                 }
 706         }
 707                 break;
 708
 709         case DECODER_SET_OUTPUT:
 710         {
 711                 int *iarg = arg;
 712
 713                 dprintk(1, KERN_DEBUG "%s: decoder set output\n",
 714                         I2C_NAME(client));
 715
 716                 /* not much choice of outputs */
 717                 if (*iarg != 0) {
 718                         return -EINVAL;
 719                 }
 720         }
 721                 break;
 722
 723         case DECODER_ENABLE_OUTPUT:
 724         {
 725                 int *iarg = arg;
 726                 int enable = (*iarg != 0);
 727
 728                 dprintk(1, KERN_DEBUG "%s: decoder %s output\n",
 729                         I2C_NAME(client), enable ? "enable" : "disable");
 730
 731                 decoder->playback = !enable;
 732
 733                 if (decoder->enable != enable) {
 734                         decoder->enable = enable;
 735
 736                         /* RJ: If output should be disabled (for
 737                          * playing videos), we also need a open PLL.
 738                          * The input is set to 0 (where no input
 739                          * source is connected), although this
 740                          * is not necessary.
 741                          *
 742                          * If output should be enabled, we have to
 743                          * reverse the above.
 744                          */
 745
 746                         if (decoder->enable) {
 747                                 decoder->reg[REG_ADDR(0x08)] = 0xb8;
 748                                 decoder->reg[REG_ADDR(0x12)] = 0xc9;
 749                                 decoder->reg[REG_ADDR(0x13)] = 0x80;
 750                                 decoder->reg[REG_ADDR(0x87)] = 0x01;
 751                         } else {
 752                                 decoder->reg[REG_ADDR(0x08)] = 0x7c;
 753                                 decoder->reg[REG_ADDR(0x12)] = 0x00;
 754                                 decoder->reg[REG_ADDR(0x13)] = 0x00;
 755                                 decoder->reg[REG_ADDR(0x87)] = 0x00;
 756                         }
 757
 758                         saa7114_write_block(client,
 759                                             decoder->reg + (0x12 << 1),
 760                                             2 << 1);
 761                         saa7114_write(client, 0x08,
 762                                       decoder->reg[REG_ADDR(0x08)]);
 763                         saa7114_write(client, 0x87,
 764                                       decoder->reg[REG_ADDR(0x87)]);
 765                         saa7114_write(client, 0x88, 0xd8);      // sw reset scaler
 766                         saa7114_write(client, 0x88, 0xf8);      // sw reset scaler release
 767                         saa7114_write(client, 0x80, 0x36);
 768
 769                 }
 770         }
 771                 break;
 772
 773         case DECODER_SET_PICTURE:
 774         {
 775                 struct video_picture *pic = arg;
 776
 777                 dprintk(1,
 778                         KERN_DEBUG
 779                         "%s: decoder set picture bright=%d contrast=%d saturation=%d hue=%d\n",
 780                         I2C_NAME(client), pic->brightness, pic->contrast,
 781                         pic->colour, pic->hue);
 782
 783                 if (decoder->bright != pic->brightness) {
 784                         /* We want 0 to 255 we get 0-65535 */
 785                         decoder->bright = pic->brightness;
 786                         saa7114_write(client, 0x0a, decoder->bright >> 8);
 787                 }
 788                 if (decoder->contrast != pic->contrast) {
 789                         /* We want 0 to 127 we get 0-65535 */
 790                         decoder->contrast = pic->contrast;
 791                         saa7114_write(client, 0x0b,
 792                                       decoder->contrast >> 9);
 793                 }
 794                 if (decoder->sat != pic->colour) {
 795                         /* We want 0 to 127 we get 0-65535 */
 796                         decoder->sat = pic->colour;
 797                         saa7114_write(client, 0x0c, decoder->sat >> 9);
 798                 }
 799                 if (decoder->hue != pic->hue) {
 800                         /* We want -128 to 127 we get 0-65535 */
 801                         decoder->hue = pic->hue;
 802                         saa7114_write(client, 0x0d,
 803                                       (decoder->hue - 32768) >> 8);
 804                 }
 805         }
 806                 break;
 807
 808         default:
 809                 return -EINVAL;
 810         }
 811
 812         return 0;
 813 }
 814
 815 /* ----------------------------------------------------------------------- */
 816
 817 /*
 818  * Generic i2c probe
 819  * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
 820  */
 821 static unsigned short normal_i2c[] =
 822     { I2C_SAA7114 >> 1, I2C_SAA7114A >> 1, I2C_CLIENT_END };
 823 static unsigned short normal_i2c_range[] = { I2C_CLIENT_END };
 824
 825 static unsigned short probe[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
 826 static unsigned short probe_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
 827 static unsigned short ignore[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
 828 static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
 829 static unsigned short force[2] = { I2C_CLIENT_END , I2C_CLIENT_END };
 830
 831 static struct i2c_client_address_data addr_data = {
 832         .normal_i2c             = normal_i2c,
 833         .normal_i2c_range       = normal_i2c_range,
 834         .probe                  = probe,
 835         .probe_range            = probe_range,
 836         .ignore                 = ignore,
 837         .ignore_range           = ignore_range,
 838         .force                  = force
 839 };
 840
 841 static int saa7114_i2c_id = 0;
 842 static struct i2c_driver i2c_driver_saa7114;
 843
 844 static int
 845 saa7114_detect_client (struct i2c_adapter *adapter,
 846                        int                 address,
 847                        int                 kind)
 848 {
 849         int i, err[30];
 850         short int hoff = SAA_7114_NTSC_HOFFSET;
 851         short int voff = SAA_7114_NTSC_VOFFSET;
 852         short int w = SAA_7114_NTSC_WIDTH;
 853         short int h = SAA_7114_NTSC_HEIGHT;
 854         struct i2c_client *client;
 855         struct saa7114 *decoder;
 856
 857         dprintk(1,
 858                 KERN_INFO
 859                 "saa7114.c: detecting saa7114 client on address 0x%x\n",
 860                 address << 1);
 861
 862         /* Check if the adapter supports the needed features */
 863         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 864                 return 0;
 865
 866         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 867         if (client == 0)
 868                 return -ENOMEM;
 869         memset(client, 0, sizeof(struct i2c_client));
 870         client->addr = address;
 871         client->adapter = adapter;
 872         client->driver = &i2c_driver_saa7114;
 873         client->flags = I2C_CLIENT_ALLOW_USE;
 874         client->id = saa7114_i2c_id++;
 875         snprintf(I2C_NAME(client), sizeof(I2C_NAME(client)) - 1,
 876                 "saa7114[%d]", client->id);
 877
 878         decoder = kmalloc(sizeof(struct saa7114), GFP_KERNEL);
 879         if (decoder == NULL) {
 880                 kfree(client);
 881                 return -ENOMEM;
 882         }
 883         memset(decoder, 0, sizeof(struct saa7114));
 884         decoder->norm = VIDEO_MODE_NTSC;
 885         decoder->input = -1;
 886         decoder->enable = 1;
 887         decoder->bright = 32768;
 888         decoder->contrast = 32768;
 889         decoder->hue = 32768;
 890         decoder->sat = 32768;
 891         decoder->playback = 0;  // initially capture mode useda
 892         i2c_set_clientdata(client, decoder);
 893
 894         memcpy(decoder->reg, init, sizeof(init));
 895
 896         decoder->reg[REG_ADDR(0x94)] = LOBYTE(hoff);    // hoffset low
 897         decoder->reg[REG_ADDR(0x95)] = HIBYTE(hoff) & 0x0f;     // hoffset high
 898         decoder->reg[REG_ADDR(0x96)] = LOBYTE(w);       // width low
 899         decoder->reg[REG_ADDR(0x97)] = HIBYTE(w) & 0x0f;        // width high
 900         decoder->reg[REG_ADDR(0x98)] = LOBYTE(voff);    // voffset low
 901         decoder->reg[REG_ADDR(0x99)] = HIBYTE(voff) & 0x0f;     // voffset high
 902         decoder->reg[REG_ADDR(0x9a)] = LOBYTE(h + 2);   // height low
 903         decoder->reg[REG_ADDR(0x9b)] = HIBYTE(h + 2) & 0x0f;    // height high
 904         decoder->reg[REG_ADDR(0x9c)] = LOBYTE(w);       // out width low
 905         decoder->reg[REG_ADDR(0x9d)] = HIBYTE(w) & 0x0f;        // out width high
 906         decoder->reg[REG_ADDR(0x9e)] = LOBYTE(h);       // out height low
 907         decoder->reg[REG_ADDR(0x9f)] = HIBYTE(h) & 0x0f;        // out height high
 908
 909         decoder->reg[REG_ADDR(0xc4)] = LOBYTE(hoff);    // hoffset low
 910         decoder->reg[REG_ADDR(0xc5)] = HIBYTE(hoff) & 0x0f;     // hoffset high
 911         decoder->reg[REG_ADDR(0xc6)] = LOBYTE(w);       // width low
 912         decoder->reg[REG_ADDR(0xc7)] = HIBYTE(w) & 0x0f;        // width high
 913         decoder->reg[REG_ADDR(0xc8)] = LOBYTE(voff);    // voffset low
 914         decoder->reg[REG_ADDR(0xc9)] = HIBYTE(voff) & 0x0f;     // voffset high
 915         decoder->reg[REG_ADDR(0xca)] = LOBYTE(h + 2);   // height low
 916         decoder->reg[REG_ADDR(0xcb)] = HIBYTE(h + 2) & 0x0f;    // height high
 917         decoder->reg[REG_ADDR(0xcc)] = LOBYTE(w);       // out width low
 918         decoder->reg[REG_ADDR(0xcd)] = HIBYTE(w) & 0x0f;        // out width high
 919         decoder->reg[REG_ADDR(0xce)] = LOBYTE(h);       // out height low
 920         decoder->reg[REG_ADDR(0xcf)] = HIBYTE(h) & 0x0f;        // out height high
 921
 922         decoder->reg[REG_ADDR(0xb8)] =
 923             LOBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 924         decoder->reg[REG_ADDR(0xb9)] =
 925             HIBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 926         decoder->reg[REG_ADDR(0xba)] =
 927             LOBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 928         decoder->reg[REG_ADDR(0xbb)] =
 929             HIBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 930
 931         decoder->reg[REG_ADDR(0xbc)] =
 932             LOBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 933         decoder->reg[REG_ADDR(0xbd)] =
 934             HIBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 935         decoder->reg[REG_ADDR(0xbe)] =
 936             LOBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 937         decoder->reg[REG_ADDR(0xbf)] =
 938             HIBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 939
 940         decoder->reg[REG_ADDR(0xe8)] =
 941             LOBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 942         decoder->reg[REG_ADDR(0xe9)] =
 943             HIBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 944         decoder->reg[REG_ADDR(0xea)] =
 945             LOBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 946         decoder->reg[REG_ADDR(0xeb)] =
 947             HIBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
 948
 949         decoder->reg[REG_ADDR(0xec)] =
 950             LOBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 951         decoder->reg[REG_ADDR(0xed)] =
 952             HIBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 953         decoder->reg[REG_ADDR(0xee)] =
 954             LOBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 955         decoder->reg[REG_ADDR(0xef)] =
 956             HIBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
 957
 958
 959         decoder->reg[REG_ADDR(0x13)] = 0x80;    // RTC0 on
 960         decoder->reg[REG_ADDR(0x87)] = 0x01;    // I-Port
 961         decoder->reg[REG_ADDR(0x12)] = 0xc9;    // RTS0
 962
 963         decoder->reg[REG_ADDR(0x02)] = 0xc0;    // set composite1 input, aveasy
 964         decoder->reg[REG_ADDR(0x09)] = 0x00;    // chrominance trap
 965         decoder->reg[REG_ADDR(0x0e)] |= 1;      // combfilter on
 966
 967
 968         dprintk(1, KERN_DEBUG "%s_attach: starting decoder init\n",
 969                 I2C_NAME(client));
 970
 971         err[0] =
 972             saa7114_write_block(client, decoder->reg + (0x20 << 1),
 973                                 0x10 << 1);
 974         err[1] =
 975             saa7114_write_block(client, decoder->reg + (0x30 << 1),
 976                                 0x10 << 1);
 977         err[2] =
 978             saa7114_write_block(client, decoder->reg + (0x63 << 1),
 979                                 (0x7f + 1 - 0x63) << 1);
 980         err[3] =
 981             saa7114_write_block(client, decoder->reg + (0x89 << 1),
 982                                 6 << 1);
 983         err[4] =
 984             saa7114_write_block(client, decoder->reg + (0xb8 << 1),
 985                                 8 << 1);
 986         err[5] =
 987             saa7114_write_block(client, decoder->reg + (0xe8 << 1),
 988                                 8 << 1);
 989
 990
 991         for (i = 0; i <= 5; i++) {
 992                 if (err[i] < 0) {
 993                         dprintk(1,
 994                                 KERN_ERR
 995                                 "%s_attach: init error %d at stage %d, leaving attach.\n",
 996                                 I2C_NAME(client), i, err[i]);
 997                         kfree(decoder);
 998                         kfree(client);
 999                         return 0;
1000                 }
1001         }
1002
1003         for (i = 6; i < 8; i++) {
1004                 dprintk(1,
1005                         KERN_DEBUG
1006                         "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1007                         I2C_NAME(client), i, saa7114_read(client, i),
1008                         decoder->reg[REG_ADDR(i)]);
1009         }
1010
1011         dprintk(1,
1012                 KERN_DEBUG
1013                 "%s_attach: performing decoder reset sequence\n",
1014                 I2C_NAME(client));
1015
1016         err[6] = saa7114_write(client, 0x80, 0x06);     // i-port and scaler backend clock selection, task A&B off
1017         err[7] = saa7114_write(client, 0x88, 0xd8);     // sw reset scaler
1018         err[8] = saa7114_write(client, 0x88, 0xf8);     // sw reset scaler release
1019
1020         for (i = 6; i <= 8; i++) {
1021                 if (err[i] < 0) {
1022                         dprintk(1,
1023                                 KERN_ERR
1024                                 "%s_attach: init error %d at stage %d, leaving attach.\n",
1025                                 I2C_NAME(client), i, err[i]);
1026                         kfree(decoder);
1027                         kfree(client);
1028                         return 0;
1029                 }
1030         }
1031
1032         dprintk(1, KERN_INFO "%s_attach: performing the rest of init\n",
1033                 I2C_NAME(client));
1034
1035
1036         err[9] = saa7114_write(client, 0x01, decoder->reg[REG_ADDR(0x01)]);
1037         err[10] = saa7114_write_block(client, decoder->reg + (0x03 << 1), (0x1e + 1 - 0x03) << 1);      // big seq
1038         err[11] = saa7114_write_block(client, decoder->reg + (0x40 << 1), (0x5f + 1 - 0x40) << 1);      // slicer
1039         err[12] = saa7114_write_block(client, decoder->reg + (0x81 << 1), 2 << 1);      // ?
1040         err[13] = saa7114_write_block(client, decoder->reg + (0x83 << 1), 5 << 1);      // ?
1041         err[14] = saa7114_write_block(client, decoder->reg + (0x90 << 1), 4 << 1);      // Task A
1042         err[15] =
1043             saa7114_write_block(client, decoder->reg + (0x94 << 1),
1044                                 12 << 1);
1045         err[16] =
1046             saa7114_write_block(client, decoder->reg + (0xa0 << 1),
1047                                 8 << 1);
1048         err[17] =
1049             saa7114_write_block(client, decoder->reg + (0xa8 << 1),
1050                                 8 << 1);
1051         err[18] =
1052             saa7114_write_block(client, decoder->reg + (0xb0 << 1),
1053                                 8 << 1);
1054         err[19] = saa7114_write_block(client, decoder->reg + (0xc0 << 1), 4 << 1);      // Task B
1055         err[15] =
1056             saa7114_write_block(client, decoder->reg + (0xc4 << 1),
1057                                 12 << 1);
1058         err[16] =
1059             saa7114_write_block(client, decoder->reg + (0xd0 << 1),
1060                                 8 << 1);
1061         err[17] =
1062             saa7114_write_block(client, decoder->reg + (0xd8 << 1),
1063                                 8 << 1);
1064         err[18] =
1065             saa7114_write_block(client, decoder->reg + (0xe0 << 1),
1066                                 8 << 1);
1067
1068         for (i = 9; i <= 18; i++) {
1069                 if (err[i] < 0) {
1070                         dprintk(1,
1071                                 KERN_ERR
1072                                 "%s_attach: init error %d at stage %d, leaving attach.\n",
1073                                 I2C_NAME(client), i, err[i]);
1074                         kfree(decoder);
1075                         kfree(client);
1076                         return 0;
1077                 }
1078         }
1079
1080
1081         for (i = 6; i < 8; i++) {
1082                 dprintk(1,
1083                         KERN_DEBUG
1084                         "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1085                         I2C_NAME(client), i, saa7114_read(client, i),
1086                         decoder->reg[REG_ADDR(i)]);
1087         }
1088
1089
1090         for (i = 0x11; i <= 0x13; i++) {
1091                 dprintk(1,
1092                         KERN_DEBUG
1093                         "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1094                         I2C_NAME(client), i, saa7114_read(client, i),
1095                         decoder->reg[REG_ADDR(i)]);
1096         }
1097
1098
1099         dprintk(1, KERN_DEBUG "%s_attach: setting video input\n",
1100                 I2C_NAME(client));
1101
1102         err[19] =
1103             saa7114_write(client, 0x02, decoder->reg[REG_ADDR(0x02)]);
1104         err[20] =
1105             saa7114_write(client, 0x09, decoder->reg[REG_ADDR(0x09)]);
1106         err[21] =
1107             saa7114_write(client, 0x0e, decoder->reg[REG_ADDR(0x0e)]);
1108
1109         for (i = 19; i <= 21; i++) {
1110                 if (err[i] < 0) {
1111                         dprintk(1,
1112                                 KERN_ERR
1113                                 "%s_attach: init error %d at stage %d, leaving attach.\n",
1114                                 I2C_NAME(client), i, err[i]);
1115                         kfree(decoder);
1116                         kfree(client);
1117                         return 0;
1118                 }
1119         }
1120
1121         dprintk(1,
1122                 KERN_DEBUG
1123                 "%s_attach: performing decoder reset sequence\n",
1124                 I2C_NAME(client));
1125
1126         err[22] = saa7114_write(client, 0x88, 0xd8);    // sw reset scaler
1127         err[23] = saa7114_write(client, 0x88, 0xf8);    // sw reset scaler release
1128         err[24] = saa7114_write(client, 0x80, 0x36);    // i-port and scaler backend clock selection, task A&B off
1129
1130
1131         for (i = 22; i <= 24; i++) {
1132                 if (err[i] < 0) {
1133                         dprintk(1,
1134                                 KERN_ERR
1135                                 "%s_attach: init error %d at stage %d, leaving attach.\n",
1136                                 I2C_NAME(client), i, err[i]);
1137                         kfree(decoder);
1138                         kfree(client);
1139                         return 0;
1140                 }
1141         }
1142
1143         err[25] = saa7114_write(client, 0x06, init[REG_ADDR(0x06)]);
1144         err[26] = saa7114_write(client, 0x07, init[REG_ADDR(0x07)]);
1145         err[27] = saa7114_write(client, 0x10, init[REG_ADDR(0x10)]);
1146
1147         dprintk(1,
1148                 KERN_INFO
1149                 "%s_attach: chip version %x, decoder status 0x%02x\n",
1150                 I2C_NAME(client), saa7114_read(client, 0x00) >> 4,
1151                 saa7114_read(client, 0x1f));
1152         dprintk(1,
1153                 KERN_DEBUG
1154                 "%s_attach: power save control: 0x%02x, scaler status: 0x%02x\n",
1155                 I2C_NAME(client), saa7114_read(client, 0x88),
1156                 saa7114_read(client, 0x8f));
1157
1158
1159         for (i = 0x94; i < 0x96; i++) {
1160                 dprintk(1,
1161                         KERN_DEBUG
1162                         "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1163                         I2C_NAME(client), i, saa7114_read(client, i),
1164                         decoder->reg[REG_ADDR(i)]);
1165         }
1166
1167         i = i2c_attach_client(client);
1168         if (i) {
1169                 kfree(client);
1170                 kfree(decoder);
1171                 return i;
1172         }
1173
1174         //i = saa7114_write_block(client, init, sizeof(init));
1175         i = 0;
1176         if (i < 0) {
1177                 dprintk(1, KERN_ERR "%s_attach error: init status %d\n",
1178                         I2C_NAME(client), i);
1179         } else {
1180                 dprintk(1,
1181                         KERN_INFO
1182                         "%s_attach: chip version %x at address 0x%x\n",
1183                         I2C_NAME(client), saa7114_read(client, 0x00) >> 4,
1184                         client->addr << 1);
1185         }
1186
1187         return 0;
1188 }
1189
1190 static int
1191 saa7114_attach_adapter (struct i2c_adapter *adapter)
1192 {
1193         dprintk(1,
1194                 KERN_INFO
1195                 "saa7114.c: starting probe for adapter %s (0x%x)\n",
1196                 I2C_NAME(adapter), adapter->id);
1197         return i2c_probe(adapter, &addr_data, &saa7114_detect_client);
1198 }
1199
1200 static int
1201 saa7114_detach_client (struct i2c_client *client)
1202 {
1203         struct saa7114 *decoder = i2c_get_clientdata(client);
1204         int err;
1205
1206         err = i2c_detach_client(client);
1207         if (err) {
1208                 return err;
1209         }
1210
1211         kfree(decoder);
1212         kfree(client);
1213
1214         return 0;
1215 }
1216
1217 /* ----------------------------------------------------------------------- */
1218
1219 static struct i2c_driver i2c_driver_saa7114 = {
1220         .owner = THIS_MODULE,
1221         .name = "saa7114",
1222
1223         .id = I2C_DRIVERID_SAA7114,
1224         .flags = I2C_DF_NOTIFY,
1225
1226         .attach_adapter = saa7114_attach_adapter,
1227         .detach_client = saa7114_detach_client,
1228         .command = saa7114_command,
1229 };
1230
1231 static int __init
1232 saa7114_init (void)
1233 {
1234         return i2c_add_driver(&i2c_driver_saa7114);
1235 }
1236
1237 static void __exit
1238 saa7114_exit (void)
1239 {
1240         i2c_del_driver(&i2c_driver_saa7114);
1241 }
1242
1243 module_init(saa7114_init);
1244 module_exit(saa7114_exit);