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