drivers/media/i2c/saa717x.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * saa717x - Philips SAA717xHL video decoder driver
   4  *
   5  * Based on the saa7115 driver
   6  *
   7  * Changes by Ohta Kyuma <[email protected]>
   8  *    - Apply to SAA717x,NEC uPD64031,uPD64083. (1/31/2004)
   9  *
  10  * Changes by T.Adachi ([email protected])
  11  *    - support audio, video scaler etc, and checked the initialize sequence.
  12  *
  13  * Cleaned up by Hans Verkuil <[email protected]>
  14  *
  15  * Note: this is a reversed engineered driver based on captures from
  16  * the I2C bus under Windows. This chip is very similar to the saa7134,
  17  * though. Unfortunately, this driver is currently only working for NTSC.
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/slab.h>
  23 #include <linux/sched.h>
  24
  25 #include <linux/videodev2.h>
  26 #include <linux/i2c.h>
  27 #include <media/v4l2-device.h>
  28 #include <media/v4l2-ctrls.h>
  29
  30 MODULE_DESCRIPTION("Philips SAA717x audio/video decoder driver");
  31 MODULE_AUTHOR("K. Ohta, T. Adachi, Hans Verkuil");
  32 MODULE_LICENSE("GPL");
  33
  34 static int debug;
  35 module_param(debug, int, 0644);
  36 MODULE_PARM_DESC(debug, "Debug level (0-1)");
  37
  38 /*
  39  * Generic i2c probe
  40  * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
  41  */
  42
  43 struct saa717x_state {
  44         struct v4l2_subdev sd;
  45         struct v4l2_ctrl_handler hdl;
  46         v4l2_std_id std;
  47         int input;
  48         int enable;
  49         int radio;
  50         int playback;
  51         int audio;
  52         int tuner_audio_mode;
  53         int audio_main_mute;
  54         int audio_main_vol_r;
  55         int audio_main_vol_l;
  56         u16 audio_main_bass;
  57         u16 audio_main_treble;
  58         u16 audio_main_volume;
  59         u16 audio_main_balance;
  60         int audio_input;
  61 };
  62
  63 static inline struct saa717x_state *to_state(struct v4l2_subdev *sd)
  64 {
  65         return container_of(sd, struct saa717x_state, sd);
  66 }
  67
  68 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
  69 {
  70         return &container_of(ctrl->handler, struct saa717x_state, hdl)->sd;
  71 }
  72
  73 /* ----------------------------------------------------------------------- */
  74
  75 /* for audio mode */
  76 #define TUNER_AUDIO_MONO        0  /* LL */
  77 #define TUNER_AUDIO_STEREO      1  /* LR */
  78 #define TUNER_AUDIO_LANG1       2  /* LL */
  79 #define TUNER_AUDIO_LANG2       3  /* RR */
  80
  81 #define SAA717X_NTSC_WIDTH      (704)
  82 #define SAA717X_NTSC_HEIGHT     (480)
  83
  84 /* ----------------------------------------------------------------------- */
  85
  86 static int saa717x_write(struct v4l2_subdev *sd, u32 reg, u32 value)
  87 {
  88         struct i2c_client *client = v4l2_get_subdevdata(sd);
  89         struct i2c_adapter *adap = client->adapter;
  90         int fw_addr = reg == 0x454 || (reg >= 0x464 && reg <= 0x478) || reg == 0x480 || reg == 0x488;
  91         unsigned char mm1[6];
  92         struct i2c_msg msg;
  93
  94         msg.flags = 0;
  95         msg.addr = client->addr;
  96         mm1[0] = (reg >> 8) & 0xff;
  97         mm1[1] = reg & 0xff;
  98
  99         if (fw_addr) {
 100                 mm1[4] = (value >> 16) & 0xff;
 101                 mm1[3] = (value >> 8) & 0xff;
 102                 mm1[2] = value & 0xff;
 103         } else {
 104                 mm1[2] = value & 0xff;
 105         }
 106         msg.len = fw_addr ? 5 : 3; /* Long Registers have *only* three bytes! */
 107         msg.buf = mm1;
 108         v4l2_dbg(2, debug, sd, "wrote:  reg 0x%03x=%08x\n", reg, value);
 109         return i2c_transfer(adap, &msg, 1) == 1;
 110 }
 111
 112 static void saa717x_write_regs(struct v4l2_subdev *sd, u32 *data)
 113 {
 114         while (data[0] || data[1]) {
 115                 saa717x_write(sd, data[0], data[1]);
 116                 data += 2;
 117         }
 118 }
 119
 120 static u32 saa717x_read(struct v4l2_subdev *sd, u32 reg)
 121 {
 122         struct i2c_client *client = v4l2_get_subdevdata(sd);
 123         struct i2c_adapter *adap = client->adapter;
 124         int fw_addr = (reg >= 0x404 && reg <= 0x4b8) || reg == 0x528;
 125         unsigned char mm1[2];
 126         unsigned char mm2[4] = { 0, 0, 0, 0 };
 127         struct i2c_msg msgs[2];
 128         u32 value;
 129
 130         msgs[0].flags = 0;
 131         msgs[1].flags = I2C_M_RD;
 132         msgs[0].addr = msgs[1].addr = client->addr;
 133         mm1[0] = (reg >> 8) & 0xff;
 134         mm1[1] = reg & 0xff;
 135         msgs[0].len = 2;
 136         msgs[0].buf = mm1;
 137         msgs[1].len = fw_addr ? 3 : 1; /* Multibyte Registers contains *only* 3 bytes */
 138         msgs[1].buf = mm2;
 139         i2c_transfer(adap, msgs, 2);
 140
 141         if (fw_addr)
 142                 value = (mm2[2] << 16)  | (mm2[1] << 8) | mm2[0];
 143         else
 144                 value = mm2[0];
 145
 146         v4l2_dbg(2, debug, sd, "read:  reg 0x%03x=0x%08x\n", reg, value);
 147         return value;
 148 }
 149
 150 /* ----------------------------------------------------------------------- */
 151
 152 static u32 reg_init_initialize[] =
 153 {
 154         /* from linux driver */
 155         0x101, 0x008, /* Increment delay */
 156
 157         0x103, 0x000, /* Analog input control 2 */
 158         0x104, 0x090, /* Analog input control 3 */
 159         0x105, 0x090, /* Analog input control 4 */
 160         0x106, 0x0eb, /* Horizontal sync start */
 161         0x107, 0x0e0, /* Horizontal sync stop */
 162         0x109, 0x055, /* Luminance control */
 163
 164         0x10f, 0x02a, /* Chroma gain control */
 165         0x110, 0x000, /* Chroma control 2 */
 166
 167         0x114, 0x045, /* analog/ADC */
 168
 169         0x118, 0x040, /* RAW data gain */
 170         0x119, 0x080, /* RAW data offset */
 171
 172         0x044, 0x000, /* VBI horizontal input window start (L) TASK A */
 173         0x045, 0x000, /* VBI horizontal input window start (H) TASK A */
 174         0x046, 0x0cf, /* VBI horizontal input window stop (L) TASK A */
 175         0x047, 0x002, /* VBI horizontal input window stop (H) TASK A */
 176
 177         0x049, 0x000, /* VBI vertical input window start (H) TASK A */
 178
 179         0x04c, 0x0d0, /* VBI horizontal output length (L) TASK A */
 180         0x04d, 0x002, /* VBI horizontal output length (H) TASK A */
 181
 182         0x064, 0x080, /* Lumina brightness TASK A */
 183         0x065, 0x040, /* Luminance contrast TASK A */
 184         0x066, 0x040, /* Chroma saturation TASK A */
 185         /* 067H: Reserved */
 186         0x068, 0x000, /* VBI horizontal scaling increment (L) TASK A */
 187         0x069, 0x004, /* VBI horizontal scaling increment (H) TASK A */
 188         0x06a, 0x000, /* VBI phase offset TASK A */
 189
 190         0x06e, 0x000, /* Horizontal phase offset Luma TASK A */
 191         0x06f, 0x000, /* Horizontal phase offset Chroma TASK A */
 192
 193         0x072, 0x000, /* Vertical filter mode TASK A */
 194
 195         0x084, 0x000, /* VBI horizontal input window start (L) TAKS B */
 196         0x085, 0x000, /* VBI horizontal input window start (H) TAKS B */
 197         0x086, 0x0cf, /* VBI horizontal input window stop (L) TAKS B */
 198         0x087, 0x002, /* VBI horizontal input window stop (H) TAKS B */
 199
 200         0x089, 0x000, /* VBI vertical input window start (H) TAKS B */
 201
 202         0x08c, 0x0d0, /* VBI horizontal output length (L) TASK B */
 203         0x08d, 0x002, /* VBI horizontal output length (H) TASK B */
 204
 205         0x0a4, 0x080, /* Lumina brightness TASK B */
 206         0x0a5, 0x040, /* Luminance contrast TASK B */
 207         0x0a6, 0x040, /* Chroma saturation TASK B */
 208         /* 0A7H reserved */
 209         0x0a8, 0x000, /* VBI horizontal scaling increment (L) TASK B */
 210         0x0a9, 0x004, /* VBI horizontal scaling increment (H) TASK B */
 211         0x0aa, 0x000, /* VBI phase offset TASK B */
 212
 213         0x0ae, 0x000, /* Horizontal phase offset Luma TASK B */
 214         0x0af, 0x000, /*Horizontal phase offset Chroma TASK B */
 215
 216         0x0b2, 0x000, /* Vertical filter mode TASK B */
 217
 218         0x00c, 0x000, /* Start point GREEN path */
 219         0x00d, 0x000, /* Start point BLUE path */
 220         0x00e, 0x000, /* Start point RED path */
 221
 222         0x010, 0x010, /* GREEN path gamma curve --- */
 223         0x011, 0x020,
 224         0x012, 0x030,
 225         0x013, 0x040,
 226         0x014, 0x050,
 227         0x015, 0x060,
 228         0x016, 0x070,
 229         0x017, 0x080,
 230         0x018, 0x090,
 231         0x019, 0x0a0,
 232         0x01a, 0x0b0,
 233         0x01b, 0x0c0,
 234         0x01c, 0x0d0,
 235         0x01d, 0x0e0,
 236         0x01e, 0x0f0,
 237         0x01f, 0x0ff, /* --- GREEN path gamma curve */
 238
 239         0x020, 0x010, /* BLUE path gamma curve --- */
 240         0x021, 0x020,
 241         0x022, 0x030,
 242         0x023, 0x040,
 243         0x024, 0x050,
 244         0x025, 0x060,
 245         0x026, 0x070,
 246         0x027, 0x080,
 247         0x028, 0x090,
 248         0x029, 0x0a0,
 249         0x02a, 0x0b0,
 250         0x02b, 0x0c0,
 251         0x02c, 0x0d0,
 252         0x02d, 0x0e0,
 253         0x02e, 0x0f0,
 254         0x02f, 0x0ff, /* --- BLUE path gamma curve */
 255
 256         0x030, 0x010, /* RED path gamma curve --- */
 257         0x031, 0x020,
 258         0x032, 0x030,
 259         0x033, 0x040,
 260         0x034, 0x050,
 261         0x035, 0x060,
 262         0x036, 0x070,
 263         0x037, 0x080,
 264         0x038, 0x090,
 265         0x039, 0x0a0,
 266         0x03a, 0x0b0,
 267         0x03b, 0x0c0,
 268         0x03c, 0x0d0,
 269         0x03d, 0x0e0,
 270         0x03e, 0x0f0,
 271         0x03f, 0x0ff, /* --- RED path gamma curve */
 272
 273         0x109, 0x085, /* Luminance control  */
 274
 275         /**** from app start ****/
 276         0x584, 0x000, /* AGC gain control */
 277         0x585, 0x000, /* Program count */
 278         0x586, 0x003, /* Status reset */
 279         0x588, 0x0ff, /* Number of audio samples (L) */
 280         0x589, 0x00f, /* Number of audio samples (M) */
 281         0x58a, 0x000, /* Number of audio samples (H) */
 282         0x58b, 0x000, /* Audio select */
 283         0x58c, 0x010, /* Audio channel assign1 */
 284         0x58d, 0x032, /* Audio channel assign2 */
 285         0x58e, 0x054, /* Audio channel assign3 */
 286         0x58f, 0x023, /* Audio format */
 287         0x590, 0x000, /* SIF control */
 288
 289         0x595, 0x000, /* ?? */
 290         0x596, 0x000, /* ?? */
 291         0x597, 0x000, /* ?? */
 292
 293         0x464, 0x00, /* Digital input crossbar1 */
 294
 295         0x46c, 0xbbbb10, /* Digital output selection1-3 */
 296         0x470, 0x101010, /* Digital output selection4-6 */
 297
 298         0x478, 0x00, /* Sound feature control */
 299
 300         0x474, 0x18, /* Softmute control */
 301
 302         0x454, 0x0425b9, /* Sound Easy programming(reset) */
 303         0x454, 0x042539, /* Sound Easy programming(reset) */
 304
 305
 306         /**** common setting( of DVD play, including scaler commands) ****/
 307         0x042, 0x003, /* Data path configuration for VBI (TASK A) */
 308
 309         0x082, 0x003, /* Data path configuration for VBI (TASK B) */
 310
 311         0x108, 0x0f8, /* Sync control */
 312         0x2a9, 0x0fd, /* ??? */
 313         0x102, 0x089, /* select video input "mode 9" */
 314         0x111, 0x000, /* Mode/delay control */
 315
 316         0x10e, 0x00a, /* Chroma control 1 */
 317
 318         0x594, 0x002, /* SIF, analog I/O select */
 319
 320         0x454, 0x0425b9, /* Sound  */
 321         0x454, 0x042539,
 322
 323         0x111, 0x000,
 324         0x10e, 0x00a,
 325         0x464, 0x000,
 326         0x300, 0x000,
 327         0x301, 0x006,
 328         0x302, 0x000,
 329         0x303, 0x006,
 330         0x308, 0x040,
 331         0x309, 0x000,
 332         0x30a, 0x000,
 333         0x30b, 0x000,
 334         0x000, 0x002,
 335         0x001, 0x000,
 336         0x002, 0x000,
 337         0x003, 0x000,
 338         0x004, 0x033,
 339         0x040, 0x01d,
 340         0x041, 0x001,
 341         0x042, 0x004,
 342         0x043, 0x000,
 343         0x080, 0x01e,
 344         0x081, 0x001,
 345         0x082, 0x004,
 346         0x083, 0x000,
 347         0x190, 0x018,
 348         0x115, 0x000,
 349         0x116, 0x012,
 350         0x117, 0x018,
 351         0x04a, 0x011,
 352         0x08a, 0x011,
 353         0x04b, 0x000,
 354         0x08b, 0x000,
 355         0x048, 0x000,
 356         0x088, 0x000,
 357         0x04e, 0x012,
 358         0x08e, 0x012,
 359         0x058, 0x012,
 360         0x098, 0x012,
 361         0x059, 0x000,
 362         0x099, 0x000,
 363         0x05a, 0x003,
 364         0x09a, 0x003,
 365         0x05b, 0x001,
 366         0x09b, 0x001,
 367         0x054, 0x008,
 368         0x094, 0x008,
 369         0x055, 0x000,
 370         0x095, 0x000,
 371         0x056, 0x0c7,
 372         0x096, 0x0c7,
 373         0x057, 0x002,
 374         0x097, 0x002,
 375         0x0ff, 0x0ff,
 376         0x060, 0x001,
 377         0x0a0, 0x001,
 378         0x061, 0x000,
 379         0x0a1, 0x000,
 380         0x062, 0x000,
 381         0x0a2, 0x000,
 382         0x063, 0x000,
 383         0x0a3, 0x000,
 384         0x070, 0x000,
 385         0x0b0, 0x000,
 386         0x071, 0x004,
 387         0x0b1, 0x004,
 388         0x06c, 0x0e9,
 389         0x0ac, 0x0e9,
 390         0x06d, 0x003,
 391         0x0ad, 0x003,
 392         0x05c, 0x0d0,
 393         0x09c, 0x0d0,
 394         0x05d, 0x002,
 395         0x09d, 0x002,
 396         0x05e, 0x0f2,
 397         0x09e, 0x0f2,
 398         0x05f, 0x000,
 399         0x09f, 0x000,
 400         0x074, 0x000,
 401         0x0b4, 0x000,
 402         0x075, 0x000,
 403         0x0b5, 0x000,
 404         0x076, 0x000,
 405         0x0b6, 0x000,
 406         0x077, 0x000,
 407         0x0b7, 0x000,
 408         0x195, 0x008,
 409         0x0ff, 0x0ff,
 410         0x108, 0x0f8,
 411         0x111, 0x000,
 412         0x10e, 0x00a,
 413         0x2a9, 0x0fd,
 414         0x464, 0x001,
 415         0x454, 0x042135,
 416         0x598, 0x0e7,
 417         0x599, 0x07d,
 418         0x59a, 0x018,
 419         0x59c, 0x066,
 420         0x59d, 0x090,
 421         0x59e, 0x001,
 422         0x584, 0x000,
 423         0x585, 0x000,
 424         0x586, 0x003,
 425         0x588, 0x0ff,
 426         0x589, 0x00f,
 427         0x58a, 0x000,
 428         0x58b, 0x000,
 429         0x58c, 0x010,
 430         0x58d, 0x032,
 431         0x58e, 0x054,
 432         0x58f, 0x023,
 433         0x590, 0x000,
 434         0x595, 0x000,
 435         0x596, 0x000,
 436         0x597, 0x000,
 437         0x464, 0x000,
 438         0x46c, 0xbbbb10,
 439         0x470, 0x101010,
 440
 441
 442         0x478, 0x000,
 443         0x474, 0x018,
 444         0x454, 0x042135,
 445         0x598, 0x0e7,
 446         0x599, 0x07d,
 447         0x59a, 0x018,
 448         0x59c, 0x066,
 449         0x59d, 0x090,
 450         0x59e, 0x001,
 451         0x584, 0x000,
 452         0x585, 0x000,
 453         0x586, 0x003,
 454         0x588, 0x0ff,
 455         0x589, 0x00f,
 456         0x58a, 0x000,
 457         0x58b, 0x000,
 458         0x58c, 0x010,
 459         0x58d, 0x032,
 460         0x58e, 0x054,
 461         0x58f, 0x023,
 462         0x590, 0x000,
 463         0x595, 0x000,
 464         0x596, 0x000,
 465         0x597, 0x000,
 466         0x464, 0x000,
 467         0x46c, 0xbbbb10,
 468         0x470, 0x101010,
 469
 470         0x478, 0x000,
 471         0x474, 0x018,
 472         0x454, 0x042135,
 473         0x598, 0x0e7,
 474         0x599, 0x07d,
 475         0x59a, 0x018,
 476         0x59c, 0x066,
 477         0x59d, 0x090,
 478         0x59e, 0x001,
 479         0x584, 0x000,
 480         0x585, 0x000,
 481         0x586, 0x003,
 482         0x588, 0x0ff,
 483         0x589, 0x00f,
 484         0x58a, 0x000,
 485         0x58b, 0x000,
 486         0x58c, 0x010,
 487         0x58d, 0x032,
 488         0x58e, 0x054,
 489         0x58f, 0x023,
 490         0x590, 0x000,
 491         0x595, 0x000,
 492         0x596, 0x000,
 493         0x597, 0x000,
 494         0x464, 0x000,
 495         0x46c, 0xbbbb10,
 496         0x470, 0x101010,
 497         0x478, 0x000,
 498         0x474, 0x018,
 499         0x454, 0x042135,
 500         0x193, 0x000,
 501         0x300, 0x000,
 502         0x301, 0x006,
 503         0x302, 0x000,
 504         0x303, 0x006,
 505         0x308, 0x040,
 506         0x309, 0x000,
 507         0x30a, 0x000,
 508         0x30b, 0x000,
 509         0x000, 0x002,
 510         0x001, 0x000,
 511         0x002, 0x000,
 512         0x003, 0x000,
 513         0x004, 0x033,
 514         0x040, 0x01d,
 515         0x041, 0x001,
 516         0x042, 0x004,
 517         0x043, 0x000,
 518         0x080, 0x01e,
 519         0x081, 0x001,
 520         0x082, 0x004,
 521         0x083, 0x000,
 522         0x190, 0x018,
 523         0x115, 0x000,
 524         0x116, 0x012,
 525         0x117, 0x018,
 526         0x04a, 0x011,
 527         0x08a, 0x011,
 528         0x04b, 0x000,
 529         0x08b, 0x000,
 530         0x048, 0x000,
 531         0x088, 0x000,
 532         0x04e, 0x012,
 533         0x08e, 0x012,
 534         0x058, 0x012,
 535         0x098, 0x012,
 536         0x059, 0x000,
 537         0x099, 0x000,
 538         0x05a, 0x003,
 539         0x09a, 0x003,
 540         0x05b, 0x001,
 541         0x09b, 0x001,
 542         0x054, 0x008,
 543         0x094, 0x008,
 544         0x055, 0x000,
 545         0x095, 0x000,
 546         0x056, 0x0c7,
 547         0x096, 0x0c7,
 548         0x057, 0x002,
 549         0x097, 0x002,
 550         0x060, 0x001,
 551         0x0a0, 0x001,
 552         0x061, 0x000,
 553         0x0a1, 0x000,
 554         0x062, 0x000,
 555         0x0a2, 0x000,
 556         0x063, 0x000,
 557         0x0a3, 0x000,
 558         0x070, 0x000,
 559         0x0b0, 0x000,
 560         0x071, 0x004,
 561         0x0b1, 0x004,
 562         0x06c, 0x0e9,
 563         0x0ac, 0x0e9,
 564         0x06d, 0x003,
 565         0x0ad, 0x003,
 566         0x05c, 0x0d0,
 567         0x09c, 0x0d0,
 568         0x05d, 0x002,
 569         0x09d, 0x002,
 570         0x05e, 0x0f2,
 571         0x09e, 0x0f2,
 572         0x05f, 0x000,
 573         0x09f, 0x000,
 574         0x074, 0x000,
 575         0x0b4, 0x000,
 576         0x075, 0x000,
 577         0x0b5, 0x000,
 578         0x076, 0x000,
 579         0x0b6, 0x000,
 580         0x077, 0x000,
 581         0x0b7, 0x000,
 582         0x195, 0x008,
 583         0x598, 0x0e7,
 584         0x599, 0x07d,
 585         0x59a, 0x018,
 586         0x59c, 0x066,
 587         0x59d, 0x090,
 588         0x59e, 0x001,
 589         0x584, 0x000,
 590         0x585, 0x000,
 591         0x586, 0x003,
 592         0x588, 0x0ff,
 593         0x589, 0x00f,
 594         0x58a, 0x000,
 595         0x58b, 0x000,
 596         0x58c, 0x010,
 597         0x58d, 0x032,
 598         0x58e, 0x054,
 599         0x58f, 0x023,
 600         0x590, 0x000,
 601         0x595, 0x000,
 602         0x596, 0x000,
 603         0x597, 0x000,
 604         0x464, 0x000,
 605         0x46c, 0xbbbb10,
 606         0x470, 0x101010,
 607         0x478, 0x000,
 608         0x474, 0x018,
 609         0x454, 0x042135,
 610         0x193, 0x0a6,
 611         0x108, 0x0f8,
 612         0x042, 0x003,
 613         0x082, 0x003,
 614         0x454, 0x0425b9,
 615         0x454, 0x042539,
 616         0x193, 0x000,
 617         0x193, 0x0a6,
 618         0x464, 0x000,
 619
 620         0, 0
 621 };
 622
 623 /* Tuner */
 624 static u32 reg_init_tuner_input[] = {
 625         0x108, 0x0f8, /* Sync control */
 626         0x111, 0x000, /* Mode/delay control */
 627         0x10e, 0x00a, /* Chroma control 1 */
 628         0, 0
 629 };
 630
 631 /* Composite */
 632 static u32 reg_init_composite_input[] = {
 633         0x108, 0x0e8, /* Sync control */
 634         0x111, 0x000, /* Mode/delay control */
 635         0x10e, 0x04a, /* Chroma control 1 */
 636         0, 0
 637 };
 638
 639 /* S-Video */
 640 static u32 reg_init_svideo_input[] = {
 641         0x108, 0x0e8, /* Sync control */
 642         0x111, 0x000, /* Mode/delay control */
 643         0x10e, 0x04a, /* Chroma control 1 */
 644         0, 0
 645 };
 646
 647 static u32 reg_set_audio_template[4][2] =
 648 {
 649         { /* for MONO
 650                 tadachi 6/29 DMA audio output select?
 651                 Register 0x46c
 652                 7-4: DMA2, 3-0: DMA1 ch. DMA4, DMA3 DMA2, DMA1
 653                 0: MAIN left,  1: MAIN right
 654                 2: AUX1 left,  3: AUX1 right
 655                 4: AUX2 left,  5: AUX2 right
 656                 6: DPL left,   7: DPL  right
 657                 8: DPL center, 9: DPL surround
 658                 A: monitor output, B: digital sense */
 659                 0xbbbb00,
 660
 661                 /* tadachi 6/29 DAC and I2S output select?
 662                    Register 0x470
 663                    7-4:DAC right ch. 3-0:DAC left ch.
 664                    I2S1 right,left  I2S2 right,left */
 665                 0x00,
 666         },
 667         { /* for STEREO */
 668                 0xbbbb10, 0x101010,
 669         },
 670         { /* for LANG1 */
 671                 0xbbbb00, 0x00,
 672         },
 673         { /* for LANG2/SAP */
 674                 0xbbbb11, 0x111111,
 675         }
 676 };
 677
 678
 679 /* Get detected audio flags (from saa7134 driver) */
 680 static void get_inf_dev_status(struct v4l2_subdev *sd,
 681                 int *dual_flag, int *stereo_flag)
 682 {
 683         u32 reg_data3;
 684
 685         static char *stdres[0x20] = {
 686                 [0x00] = "no standard detected",
 687                 [0x01] = "B/G (in progress)",
 688                 [0x02] = "D/K (in progress)",
 689                 [0x03] = "M (in progress)",
 690
 691                 [0x04] = "B/G A2",
 692                 [0x05] = "B/G NICAM",
 693                 [0x06] = "D/K A2 (1)",
 694                 [0x07] = "D/K A2 (2)",
 695                 [0x08] = "D/K A2 (3)",
 696                 [0x09] = "D/K NICAM",
 697                 [0x0a] = "L NICAM",
 698                 [0x0b] = "I NICAM",
 699
 700                 [0x0c] = "M Korea",
 701                 [0x0d] = "M BTSC ",
 702                 [0x0e] = "M EIAJ",
 703
 704                 [0x0f] = "FM radio / IF 10.7 / 50 deemp",
 705                 [0x10] = "FM radio / IF 10.7 / 75 deemp",
 706                 [0x11] = "FM radio / IF sel / 50 deemp",
 707                 [0x12] = "FM radio / IF sel / 75 deemp",
 708
 709                 [0x13 ... 0x1e] = "unknown",
 710                 [0x1f] = "??? [in progress]",
 711         };
 712
 713
 714         *dual_flag = *stereo_flag = 0;
 715
 716         /* (demdec status: 0x528) */
 717
 718         /* read current status */
 719         reg_data3 = saa717x_read(sd, 0x0528);
 720
 721         v4l2_dbg(1, debug, sd, "tvaudio thread status: 0x%x [%s%s%s]\n",
 722                 reg_data3, stdres[reg_data3 & 0x1f],
 723                 (reg_data3 & 0x000020) ? ",stereo" : "",
 724                 (reg_data3 & 0x000040) ? ",dual"   : "");
 725         v4l2_dbg(1, debug, sd, "detailed status: "
 726                 "%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n",
 727                 (reg_data3 & 0x000080) ? " A2/EIAJ pilot tone "     : "",
 728                 (reg_data3 & 0x000100) ? " A2/EIAJ dual "           : "",
 729                 (reg_data3 & 0x000200) ? " A2/EIAJ stereo "         : "",
 730                 (reg_data3 & 0x000400) ? " A2/EIAJ noise mute "     : "",
 731
 732                 (reg_data3 & 0x000800) ? " BTSC/FM radio pilot "    : "",
 733                 (reg_data3 & 0x001000) ? " SAP carrier "            : "",
 734                 (reg_data3 & 0x002000) ? " BTSC stereo noise mute " : "",
 735                 (reg_data3 & 0x004000) ? " SAP noise mute "         : "",
 736                 (reg_data3 & 0x008000) ? " VDSP "                   : "",
 737
 738                 (reg_data3 & 0x010000) ? " NICST "                  : "",
 739                 (reg_data3 & 0x020000) ? " NICDU "                  : "",
 740                 (reg_data3 & 0x040000) ? " NICAM muted "            : "",
 741                 (reg_data3 & 0x080000) ? " NICAM reserve sound "    : "",
 742
 743                 (reg_data3 & 0x100000) ? " init done "              : "");
 744
 745         if (reg_data3 & 0x000220) {
 746                 v4l2_dbg(1, debug, sd, "ST!!!\n");
 747                 *stereo_flag = 1;
 748         }
 749
 750         if (reg_data3 & 0x000140) {
 751                 v4l2_dbg(1, debug, sd, "DUAL!!!\n");
 752                 *dual_flag = 1;
 753         }
 754 }
 755
 756 /* regs write to set audio mode */
 757 static void set_audio_mode(struct v4l2_subdev *sd, int audio_mode)
 758 {
 759         v4l2_dbg(1, debug, sd, "writing registers to set audio mode by set %d\n",
 760                         audio_mode);
 761
 762         saa717x_write(sd, 0x46c, reg_set_audio_template[audio_mode][0]);
 763         saa717x_write(sd, 0x470, reg_set_audio_template[audio_mode][1]);
 764 }
 765
 766 /* write regs to set audio volume, bass and treble */
 767 static int set_audio_regs(struct v4l2_subdev *sd,
 768                 struct saa717x_state *decoder)
 769 {
 770         u8 mute = 0xac; /* -84 dB */
 771         u32 val;
 772         unsigned int work_l, work_r;
 773
 774         /* set SIF analog I/O select */
 775         saa717x_write(sd, 0x0594, decoder->audio_input);
 776         v4l2_dbg(1, debug, sd, "set audio input %d\n",
 777                         decoder->audio_input);
 778
 779         /* normalize ( 65535 to 0 -> 24 to -40 (not -84)) */
 780         work_l = (min(65536 - decoder->audio_main_balance, 32768) * decoder->audio_main_volume) / 32768;
 781         work_r = (min(decoder->audio_main_balance, (u16)32768) * decoder->audio_main_volume) / 32768;
 782         decoder->audio_main_vol_l = (long)work_l * (24 - (-40)) / 65535 - 40;
 783         decoder->audio_main_vol_r = (long)work_r * (24 - (-40)) / 65535 - 40;
 784
 785         /* set main volume */
 786         /* main volume L[7-0],R[7-0],0x00  24=24dB,-83dB, -84(mute) */
 787         /*    def:0dB->6dB(MPG600GR) */
 788         /* if mute is on, set mute */
 789         if (decoder->audio_main_mute) {
 790                 val = mute | (mute << 8);
 791         } else {
 792                 val = (u8)decoder->audio_main_vol_l |
 793                         ((u8)decoder->audio_main_vol_r << 8);
 794         }
 795
 796         saa717x_write(sd, 0x480, val);
 797
 798         /* set bass and treble */
 799         val = decoder->audio_main_bass & 0x1f;
 800         val |= (decoder->audio_main_treble & 0x1f) << 5;
 801         saa717x_write(sd, 0x488, val);
 802         return 0;
 803 }
 804
 805 /********** scaling staff ***********/
 806 static void set_h_prescale(struct v4l2_subdev *sd,
 807                 int task, int prescale)
 808 {
 809         static const struct {
 810                 int xpsc;
 811                 int xacl;
 812                 int xc2_1;
 813                 int xdcg;
 814                 int vpfy;
 815         } vals[] = {
 816                 /* XPSC XACL XC2_1 XDCG VPFY */
 817                 {    1,   0,    0,    0,   0 },
 818                 {    2,   2,    1,    2,   2 },
 819                 {    3,   4,    1,    3,   2 },
 820                 {    4,   8,    1,    4,   2 },
 821                 {    5,   8,    1,    4,   2 },
 822                 {    6,   8,    1,    4,   3 },
 823                 {    7,   8,    1,    4,   3 },
 824                 {    8,  15,    0,    4,   3 },
 825                 {    9,  15,    0,    4,   3 },
 826                 {   10,  16,    1,    5,   3 },
 827         };
 828         static const int count = ARRAY_SIZE(vals);
 829         int i, task_shift;
 830
 831         task_shift = task * 0x40;
 832         for (i = 0; i < count; i++)
 833                 if (vals[i].xpsc == prescale)
 834                         break;
 835         if (i == count)
 836                 return;
 837
 838         /* horizontal prescaling */
 839         saa717x_write(sd, 0x60 + task_shift, vals[i].xpsc);
 840         /* accumulation length */
 841         saa717x_write(sd, 0x61 + task_shift, vals[i].xacl);
 842         /* level control */
 843         saa717x_write(sd, 0x62 + task_shift,
 844                         (vals[i].xc2_1 << 3) | vals[i].xdcg);
 845         /*FIR prefilter control */
 846         saa717x_write(sd, 0x63 + task_shift,
 847                         (vals[i].vpfy << 2) | vals[i].vpfy);
 848 }
 849
 850 /********** scaling staff ***********/
 851 static void set_v_scale(struct v4l2_subdev *sd, int task, int yscale)
 852 {
 853         int task_shift;
 854
 855         task_shift = task * 0x40;
 856         /* Vertical scaling ratio (LOW) */
 857         saa717x_write(sd, 0x70 + task_shift, yscale & 0xff);
 858         /* Vertical scaling ratio (HI) */
 859         saa717x_write(sd, 0x71 + task_shift, yscale >> 8);
 860 }
 861
 862 static int saa717x_s_ctrl(struct v4l2_ctrl *ctrl)
 863 {
 864         struct v4l2_subdev *sd = to_sd(ctrl);
 865         struct saa717x_state *state = to_state(sd);
 866
 867         switch (ctrl->id) {
 868         case V4L2_CID_BRIGHTNESS:
 869                 saa717x_write(sd, 0x10a, ctrl->val);
 870                 return 0;
 871
 872         case V4L2_CID_CONTRAST:
 873                 saa717x_write(sd, 0x10b, ctrl->val);
 874                 return 0;
 875
 876         case V4L2_CID_SATURATION:
 877                 saa717x_write(sd, 0x10c, ctrl->val);
 878                 return 0;
 879
 880         case V4L2_CID_HUE:
 881                 saa717x_write(sd, 0x10d, ctrl->val);
 882                 return 0;
 883
 884         case V4L2_CID_AUDIO_MUTE:
 885                 state->audio_main_mute = ctrl->val;
 886                 break;
 887
 888         case V4L2_CID_AUDIO_VOLUME:
 889                 state->audio_main_volume = ctrl->val;
 890                 break;
 891
 892         case V4L2_CID_AUDIO_BALANCE:
 893                 state->audio_main_balance = ctrl->val;
 894                 break;
 895
 896         case V4L2_CID_AUDIO_TREBLE:
 897                 state->audio_main_treble = ctrl->val;
 898                 break;
 899
 900         case V4L2_CID_AUDIO_BASS:
 901                 state->audio_main_bass = ctrl->val;
 902                 break;
 903
 904         default:
 905                 return 0;
 906         }
 907         set_audio_regs(sd, state);
 908         return 0;
 909 }
 910
 911 static int saa717x_s_video_routing(struct v4l2_subdev *sd,
 912                                    u32 input, u32 output, u32 config)
 913 {
 914         struct saa717x_state *decoder = to_state(sd);
 915         int is_tuner = input & 0x80;  /* tuner input flag */
 916
 917         input &= 0x7f;
 918
 919         v4l2_dbg(1, debug, sd, "decoder set input (%d)\n", input);
 920         /* inputs from 0-9 are available*/
 921         /* saa717x have mode0-mode9 but mode5 is reserved. */
 922         if (input > 9 || input == 5)
 923                 return -EINVAL;
 924
 925         if (decoder->input != input) {
 926                 int input_line = input;
 927
 928                 decoder->input = input_line;
 929                 v4l2_dbg(1, debug, sd,  "now setting %s input %d\n",
 930                                 input_line >= 6 ? "S-Video" : "Composite",
 931                                 input_line);
 932
 933                 /* select mode */
 934                 saa717x_write(sd, 0x102,
 935                                 (saa717x_read(sd, 0x102) & 0xf0) |
 936                                 input_line);
 937
 938                 /* bypass chrominance trap for modes 6..9 */
 939                 saa717x_write(sd, 0x109,
 940                                 (saa717x_read(sd, 0x109) & 0x7f) |
 941                                 (input_line < 6 ? 0x0 : 0x80));
 942
 943                 /* change audio_mode */
 944                 if (is_tuner) {
 945                         /* tuner */
 946                         set_audio_mode(sd, decoder->tuner_audio_mode);
 947                 } else {
 948                         /* Force to STEREO mode if Composite or
 949                          * S-Video were chosen */
 950                         set_audio_mode(sd, TUNER_AUDIO_STEREO);
 951                 }
 952                 /* change initialize procedure (Composite/S-Video) */
 953                 if (is_tuner)
 954                         saa717x_write_regs(sd, reg_init_tuner_input);
 955                 else if (input_line >= 6)
 956                         saa717x_write_regs(sd, reg_init_svideo_input);
 957                 else
 958                         saa717x_write_regs(sd, reg_init_composite_input);
 959         }
 960
 961         return 0;
 962 }
 963
 964 #ifdef CONFIG_VIDEO_ADV_DEBUG
 965 static int saa717x_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 966 {
 967         reg->val = saa717x_read(sd, reg->reg);
 968         reg->size = 1;
 969         return 0;
 970 }
 971
 972 static int saa717x_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
 973 {
 974         u16 addr = reg->reg & 0xffff;
 975         u8 val = reg->val & 0xff;
 976
 977         saa717x_write(sd, addr, val);
 978         return 0;
 979 }
 980 #endif
 981
 982 static int saa717x_set_fmt(struct v4l2_subdev *sd,
 983                 struct v4l2_subdev_state *sd_state,
 984                 struct v4l2_subdev_format *format)
 985 {
 986         struct v4l2_mbus_framefmt *fmt = &format->format;
 987         int prescale, h_scale, v_scale;
 988
 989         v4l2_dbg(1, debug, sd, "decoder set size\n");
 990
 991         if (format->pad || fmt->code != MEDIA_BUS_FMT_FIXED)
 992                 return -EINVAL;
 993
 994         /* FIXME need better bounds checking here */
 995         if (fmt->width < 1 || fmt->width > 1440)
 996                 return -EINVAL;
 997         if (fmt->height < 1 || fmt->height > 960)
 998                 return -EINVAL;
 999
1000         fmt->field = V4L2_FIELD_INTERLACED;
1001         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
1002
1003         if (format->which == V4L2_SUBDEV_FORMAT_TRY)
1004                 return 0;
1005
1006         /* scaling setting */
1007         /* NTSC and interlace only */
1008         prescale = SAA717X_NTSC_WIDTH / fmt->width;
1009         if (prescale == 0)
1010                 prescale = 1;
1011         h_scale = 1024 * SAA717X_NTSC_WIDTH / prescale / fmt->width;
1012         /* interlace */
1013         v_scale = 512 * 2 * SAA717X_NTSC_HEIGHT / fmt->height;
1014
1015         /* Horizontal prescaling etc */
1016         set_h_prescale(sd, 0, prescale);
1017         set_h_prescale(sd, 1, prescale);
1018
1019         /* Horizontal scaling increment */
1020         /* TASK A */
1021         saa717x_write(sd, 0x6C, (u8)(h_scale & 0xFF));
1022         saa717x_write(sd, 0x6D, (u8)((h_scale >> 8) & 0xFF));
1023         /* TASK B */
1024         saa717x_write(sd, 0xAC, (u8)(h_scale & 0xFF));
1025         saa717x_write(sd, 0xAD, (u8)((h_scale >> 8) & 0xFF));
1026
1027         /* Vertical prescaling etc */
1028         set_v_scale(sd, 0, v_scale);
1029         set_v_scale(sd, 1, v_scale);
1030
1031         /* set video output size */
1032         /* video number of pixels at output */
1033         /* TASK A */
1034         saa717x_write(sd, 0x5C, (u8)(fmt->width & 0xFF));
1035         saa717x_write(sd, 0x5D, (u8)((fmt->width >> 8) & 0xFF));
1036         /* TASK B */
1037         saa717x_write(sd, 0x9C, (u8)(fmt->width & 0xFF));
1038         saa717x_write(sd, 0x9D, (u8)((fmt->width >> 8) & 0xFF));
1039
1040         /* video number of lines at output */
1041         /* TASK A */
1042         saa717x_write(sd, 0x5E, (u8)(fmt->height & 0xFF));
1043         saa717x_write(sd, 0x5F, (u8)((fmt->height >> 8) & 0xFF));
1044         /* TASK B */
1045         saa717x_write(sd, 0x9E, (u8)(fmt->height & 0xFF));
1046         saa717x_write(sd, 0x9F, (u8)((fmt->height >> 8) & 0xFF));
1047         return 0;
1048 }
1049
1050 static int saa717x_s_radio(struct v4l2_subdev *sd)
1051 {
1052         struct saa717x_state *decoder = to_state(sd);
1053
1054         decoder->radio = 1;
1055         return 0;
1056 }
1057
1058 static int saa717x_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1059 {
1060         struct saa717x_state *decoder = to_state(sd);
1061
1062         v4l2_dbg(1, debug, sd, "decoder set norm ");
1063         v4l2_dbg(1, debug, sd, "(not yet implemented)\n");
1064
1065         decoder->radio = 0;
1066         decoder->std = std;
1067         return 0;
1068 }
1069
1070 static int saa717x_s_audio_routing(struct v4l2_subdev *sd,
1071                                    u32 input, u32 output, u32 config)
1072 {
1073         struct saa717x_state *decoder = to_state(sd);
1074
1075         if (input < 3) { /* FIXME! --tadachi */
1076                 decoder->audio_input = input;
1077                 v4l2_dbg(1, debug, sd,
1078                                 "set decoder audio input to %d\n",
1079                                 decoder->audio_input);
1080                 set_audio_regs(sd, decoder);
1081                 return 0;
1082         }
1083         return -ERANGE;
1084 }
1085
1086 static int saa717x_s_stream(struct v4l2_subdev *sd, int enable)
1087 {
1088         struct saa717x_state *decoder = to_state(sd);
1089
1090         v4l2_dbg(1, debug, sd, "decoder %s output\n",
1091                         enable ? "enable" : "disable");
1092         decoder->enable = enable;
1093         saa717x_write(sd, 0x193, enable ? 0xa6 : 0x26);
1094         return 0;
1095 }
1096
1097 /* change audio mode */
1098 static int saa717x_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1099 {
1100         struct saa717x_state *decoder = to_state(sd);
1101         int audio_mode;
1102         char *mes[4] = {
1103                 "MONO", "STEREO", "LANG1", "LANG2/SAP"
1104         };
1105
1106         audio_mode = TUNER_AUDIO_STEREO;
1107
1108         switch (vt->audmode) {
1109                 case V4L2_TUNER_MODE_MONO:
1110                         audio_mode = TUNER_AUDIO_MONO;
1111                         break;
1112                 case V4L2_TUNER_MODE_STEREO:
1113                         audio_mode = TUNER_AUDIO_STEREO;
1114                         break;
1115                 case V4L2_TUNER_MODE_LANG2:
1116                         audio_mode = TUNER_AUDIO_LANG2;
1117                         break;
1118                 case V4L2_TUNER_MODE_LANG1:
1119                         audio_mode = TUNER_AUDIO_LANG1;
1120                         break;
1121         }
1122
1123         v4l2_dbg(1, debug, sd, "change audio mode to %s\n",
1124                         mes[audio_mode]);
1125         decoder->tuner_audio_mode = audio_mode;
1126         /* The registers are not changed here. */
1127         /* See DECODER_ENABLE_OUTPUT section. */
1128         set_audio_mode(sd, decoder->tuner_audio_mode);
1129         return 0;
1130 }
1131
1132 static int saa717x_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1133 {
1134         struct saa717x_state *decoder = to_state(sd);
1135         int dual_f, stereo_f;
1136
1137         if (decoder->radio)
1138                 return 0;
1139         get_inf_dev_status(sd, &dual_f, &stereo_f);
1140
1141         v4l2_dbg(1, debug, sd, "DETECT==st:%d dual:%d\n",
1142                         stereo_f, dual_f);
1143
1144         /* mono */
1145         if ((dual_f == 0) && (stereo_f == 0)) {
1146                 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
1147                 v4l2_dbg(1, debug, sd, "DETECT==MONO\n");
1148         }
1149
1150         /* stereo */
1151         if (stereo_f == 1) {
1152                 if (vt->audmode == V4L2_TUNER_MODE_STEREO ||
1153                                 vt->audmode == V4L2_TUNER_MODE_LANG1) {
1154                         vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
1155                         v4l2_dbg(1, debug, sd, "DETECT==ST(ST)\n");
1156                 } else {
1157                         vt->rxsubchans = V4L2_TUNER_SUB_MONO;
1158                         v4l2_dbg(1, debug, sd, "DETECT==ST(MONO)\n");
1159                 }
1160         }
1161
1162         /* dual */
1163         if (dual_f == 1) {
1164                 if (vt->audmode == V4L2_TUNER_MODE_LANG2) {
1165                         vt->rxsubchans = V4L2_TUNER_SUB_LANG2 | V4L2_TUNER_SUB_MONO;
1166                         v4l2_dbg(1, debug, sd, "DETECT==DUAL1\n");
1167                 } else {
1168                         vt->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_MONO;
1169                         v4l2_dbg(1, debug, sd, "DETECT==DUAL2\n");
1170                 }
1171         }
1172         return 0;
1173 }
1174
1175 static int saa717x_log_status(struct v4l2_subdev *sd)
1176 {
1177         struct saa717x_state *state = to_state(sd);
1178
1179         v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
1180         return 0;
1181 }
1182
1183 /* ----------------------------------------------------------------------- */
1184
1185 static const struct v4l2_ctrl_ops saa717x_ctrl_ops = {
1186         .s_ctrl = saa717x_s_ctrl,
1187 };
1188
1189 static const struct v4l2_subdev_core_ops saa717x_core_ops = {
1190 #ifdef CONFIG_VIDEO_ADV_DEBUG
1191         .g_register = saa717x_g_register,
1192         .s_register = saa717x_s_register,
1193 #endif
1194         .log_status = saa717x_log_status,
1195 };
1196
1197 static const struct v4l2_subdev_tuner_ops saa717x_tuner_ops = {
1198         .g_tuner = saa717x_g_tuner,
1199         .s_tuner = saa717x_s_tuner,
1200         .s_radio = saa717x_s_radio,
1201 };
1202
1203 static const struct v4l2_subdev_video_ops saa717x_video_ops = {
1204         .s_std = saa717x_s_std,
1205         .s_routing = saa717x_s_video_routing,
1206         .s_stream = saa717x_s_stream,
1207 };
1208
1209 static const struct v4l2_subdev_audio_ops saa717x_audio_ops = {
1210         .s_routing = saa717x_s_audio_routing,
1211 };
1212
1213 static const struct v4l2_subdev_pad_ops saa717x_pad_ops = {
1214         .set_fmt = saa717x_set_fmt,
1215 };
1216
1217 static const struct v4l2_subdev_ops saa717x_ops = {
1218         .core = &saa717x_core_ops,
1219         .tuner = &saa717x_tuner_ops,
1220         .audio = &saa717x_audio_ops,
1221         .video = &saa717x_video_ops,
1222         .pad = &saa717x_pad_ops,
1223 };
1224
1225 /* ----------------------------------------------------------------------- */
1226
1227
1228 /* i2c implementation */
1229
1230 /* ----------------------------------------------------------------------- */
1231 static int saa717x_probe(struct i2c_client *client)
1232 {
1233         struct saa717x_state *decoder;
1234         struct v4l2_ctrl_handler *hdl;
1235         struct v4l2_subdev *sd;
1236         u8 id = 0;
1237         char *p = "";
1238
1239         /* Check if the adapter supports the needed features */
1240         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1241                 return -EIO;
1242
1243         decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
1244         if (decoder == NULL)
1245                 return -ENOMEM;
1246
1247         sd = &decoder->sd;
1248         v4l2_i2c_subdev_init(sd, client, &saa717x_ops);
1249
1250         if (saa717x_write(sd, 0x5a4, 0xfe) &&
1251                         saa717x_write(sd, 0x5a5, 0x0f) &&
1252                         saa717x_write(sd, 0x5a6, 0x00) &&
1253                         saa717x_write(sd, 0x5a7, 0x01))
1254                 id = saa717x_read(sd, 0x5a0);
1255         if (id != 0xc2 && id != 0x32 && id != 0xf2 && id != 0x6c) {
1256                 v4l2_dbg(1, debug, sd, "saa717x not found (id=%02x)\n", id);
1257                 return -ENODEV;
1258         }
1259         if (id == 0xc2)
1260                 p = "saa7173";
1261         else if (id == 0x32)
1262                 p = "saa7174A";
1263         else if (id == 0x6c)
1264                 p = "saa7174HL";
1265         else
1266                 p = "saa7171";
1267         v4l2_info(sd, "%s found @ 0x%x (%s)\n", p,
1268                         client->addr << 1, client->adapter->name);
1269
1270         hdl = &decoder->hdl;
1271         v4l2_ctrl_handler_init(hdl, 9);
1272         /* add in ascending ID order */
1273         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1274                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1275         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1276                         V4L2_CID_CONTRAST, 0, 255, 1, 68);
1277         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1278                         V4L2_CID_SATURATION, 0, 255, 1, 64);
1279         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1280                         V4L2_CID_HUE, -128, 127, 1, 0);
1281         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1282                         V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 42000);
1283         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1284                         V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768);
1285         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1286                         V4L2_CID_AUDIO_BASS, -16, 15, 1, 0);
1287         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1288                         V4L2_CID_AUDIO_TREBLE, -16, 15, 1, 0);
1289         v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1290                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
1291         sd->ctrl_handler = hdl;
1292         if (hdl->error) {
1293                 int err = hdl->error;
1294
1295                 v4l2_ctrl_handler_free(hdl);
1296                 return err;
1297         }
1298
1299         decoder->std = V4L2_STD_NTSC;
1300         decoder->input = -1;
1301         decoder->enable = 1;
1302
1303         /* FIXME!! */
1304         decoder->playback = 0;  /* initially capture mode used */
1305         decoder->audio = 1; /* DECODER_AUDIO_48_KHZ */
1306
1307         decoder->audio_input = 2; /* FIXME!! */
1308
1309         decoder->tuner_audio_mode = TUNER_AUDIO_STEREO;
1310         /* set volume, bass and treble */
1311         decoder->audio_main_vol_l = 6;
1312         decoder->audio_main_vol_r = 6;
1313
1314         v4l2_dbg(1, debug, sd, "writing init values\n");
1315
1316         /* FIXME!! */
1317         saa717x_write_regs(sd, reg_init_initialize);
1318
1319         v4l2_ctrl_handler_setup(hdl);
1320
1321         set_current_state(TASK_INTERRUPTIBLE);
1322         schedule_timeout(2*HZ);
1323         return 0;
1324 }
1325
1326 static void saa717x_remove(struct i2c_client *client)
1327 {
1328         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1329
1330         v4l2_device_unregister_subdev(sd);
1331         v4l2_ctrl_handler_free(sd->ctrl_handler);
1332 }
1333
1334 /* ----------------------------------------------------------------------- */
1335
1336 static const struct i2c_device_id saa717x_id[] = {
1337         { "saa717x", 0 },
1338         { }
1339 };
1340 MODULE_DEVICE_TABLE(i2c, saa717x_id);
1341
1342 static struct i2c_driver saa717x_driver = {
1343         .driver = {
1344                 .name   = "saa717x",
1345         },
1346         .probe_new      = saa717x_probe,
1347         .remove         = saa717x_remove,
1348         .id_table       = saa717x_id,
1349 };
1350
1351 module_i2c_driver(saa717x_driver);