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