1/* 2 * 3 * device driver for philips saa7134 based TV cards 4 * tv audio decoder (fm stereo, nicam, ...) 5 * 6 * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs] 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23#include <linux/init.h> 24#include <linux/list.h> 25#include <linux/module.h> 26#include <linux/moduleparam.h> 27#include <linux/kernel.h> 28#include <linux/slab.h> 29#include <linux/delay.h> 30#include <asm/div64.h> 31 32#include "saa7134-reg.h" 33#include "saa7134.h" 34 35/* ------------------------------------------------------------------ */ 36 37static unsigned int audio_debug = 0; 38module_param(audio_debug, int, 0644); 39MODULE_PARM_DESC(audio_debug,"enable debug messages [tv audio]"); 40 41static unsigned int audio_ddep = 0; 42module_param(audio_ddep, int, 0644); 43MODULE_PARM_DESC(audio_ddep,"audio ddep overwrite"); 44 45static int audio_clock_override = UNSET; 46module_param(audio_clock_override, int, 0644); 47 48static int audio_clock_tweak = 0; 49module_param(audio_clock_tweak, int, 0644); 50MODULE_PARM_DESC(audio_clock_tweak, "Audio clock tick fine tuning for cards with audio crystal that's slightly off (range [-1024 .. 1024])"); 51 52#define dprintk(fmt, arg...) if (audio_debug) \ 53 printk(KERN_DEBUG "%s/audio: " fmt, dev->name , ## arg) 54#define d2printk(fmt, arg...) if (audio_debug > 1) \ 55 printk(KERN_DEBUG "%s/audio: " fmt, dev->name, ## arg) 56 57#define print_regb(reg) printk("%s: reg 0x%03x [%-16s]: 0x%02x\n", \ 58 dev->name,(SAA7134_##reg),(#reg),saa_readb((SAA7134_##reg))) 59 60/* msecs */ 61#define SCAN_INITIAL_DELAY 1000 62#define SCAN_SAMPLE_DELAY 200 63#define SCAN_SUBCARRIER_DELAY 2000 64 65/* ------------------------------------------------------------------ */ 66/* saa7134 code */ 67 68static struct mainscan { 69 char *name; 70 v4l2_std_id std; 71 int carr; 72} mainscan[] = { 73 { 74 .name = "MN", 75 .std = V4L2_STD_MN, 76 .carr = 4500, 77 },{ 78 .name = "BGH", 79 .std = V4L2_STD_B | V4L2_STD_GH, 80 .carr = 5500, 81 },{ 82 .name = "I", 83 .std = V4L2_STD_PAL_I, 84 .carr = 6000, 85 },{ 86 .name = "DKL", 87 .std = V4L2_STD_DK | V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC, 88 .carr = 6500, 89 } 90}; 91 92static struct saa7134_tvaudio tvaudio[] = { 93 { 94 .name = "PAL-B/G FM-stereo", 95 .std = V4L2_STD_PAL_BG, 96 .mode = TVAUDIO_FM_BG_STEREO, 97 .carr1 = 5500, 98 .carr2 = 5742, 99 },{ 100 .name = "PAL-D/K1 FM-stereo", 101 .std = V4L2_STD_PAL_DK, 102 .carr1 = 6500, 103 .carr2 = 6258, 104 .mode = TVAUDIO_FM_BG_STEREO, 105 },{ 106 .name = "PAL-D/K2 FM-stereo", 107 .std = V4L2_STD_PAL_DK, 108 .carr1 = 6500, 109 .carr2 = 6742, 110 .mode = TVAUDIO_FM_BG_STEREO, 111 },{ 112 .name = "PAL-D/K3 FM-stereo", 113 .std = V4L2_STD_PAL_DK, 114 .carr1 = 6500, 115 .carr2 = 5742, 116 .mode = TVAUDIO_FM_BG_STEREO, 117 },{ 118 .name = "PAL-B/G NICAM", 119 .std = V4L2_STD_PAL_BG, 120 .carr1 = 5500, 121 .carr2 = 5850, 122 .mode = TVAUDIO_NICAM_FM, 123 },{ 124 .name = "PAL-I NICAM", 125 .std = V4L2_STD_PAL_I, 126 .carr1 = 6000, 127 .carr2 = 6552, 128 .mode = TVAUDIO_NICAM_FM, 129 },{ 130 .name = "PAL-D/K NICAM", 131 .std = V4L2_STD_PAL_DK, 132 .carr1 = 6500, 133 .carr2 = 5850, 134 .mode = TVAUDIO_NICAM_FM, 135 },{ 136 .name = "SECAM-L NICAM", 137 .std = V4L2_STD_SECAM_L, 138 .carr1 = 6500, 139 .carr2 = 5850, 140 .mode = TVAUDIO_NICAM_AM, 141 },{ 142 .name = "SECAM-D/K NICAM", 143 .std = V4L2_STD_SECAM_DK, 144 .carr1 = 6500, 145 .carr2 = 5850, 146 .mode = TVAUDIO_NICAM_FM, 147 },{ 148 .name = "NTSC-A2 FM-stereo", 149 .std = V4L2_STD_NTSC, 150 .carr1 = 4500, 151 .carr2 = 4724, 152 .mode = TVAUDIO_FM_K_STEREO, 153 },{ 154 .name = "NTSC-M", 155 .std = V4L2_STD_NTSC, 156 .carr1 = 4500, 157 .carr2 = -1, 158 .mode = TVAUDIO_FM_MONO, 159 } 160}; 161#define TVAUDIO (sizeof(tvaudio)/sizeof(struct saa7134_tvaudio)) 162 163/* ------------------------------------------------------------------ */ 164 165static void tvaudio_init(struct saa7134_dev *dev) 166{ 167 int clock = saa7134_boards[dev->board].audio_clock; 168 169 if (UNSET != audio_clock_override) 170 clock = audio_clock_override; 171 172 /* init all audio registers */ 173 saa_writeb(SAA7134_AUDIO_PLL_CTRL, 0x00); 174 if (need_resched()) 175 schedule(); 176 else 177 udelay(10); 178 179 saa_writeb(SAA7134_AUDIO_CLOCK0, clock & 0xff); 180 saa_writeb(SAA7134_AUDIO_CLOCK1, (clock >> 8) & 0xff); 181 saa_writeb(SAA7134_AUDIO_CLOCK2, (clock >> 16) & 0xff); 182 /* frame locked audio is mandatory for NICAM */ 183 saa_writeb(SAA7134_AUDIO_PLL_CTRL, 0x01); 184 185 saa_writeb(SAA7134_NICAM_ERROR_LOW, 0x14); 186 saa_writeb(SAA7134_NICAM_ERROR_HIGH, 0x50); 187 saa_writeb(SAA7134_MONITOR_SELECT, 0xa0); 188 saa_writeb(SAA7134_FM_DEMATRIX, 0x80); 189} 190 191static u32 tvaudio_carr2reg(u32 carrier) 192{ 193 u64 a = carrier; 194 195 a <<= 24; 196 do_div(a,12288); 197 return a; 198} 199 200static void tvaudio_setcarrier(struct saa7134_dev *dev, 201 int primary, int secondary) 202{ 203 if (-1 == secondary) 204 secondary = primary; 205 saa_writel(SAA7134_CARRIER1_FREQ0 >> 2, tvaudio_carr2reg(primary)); 206 saa_writel(SAA7134_CARRIER2_FREQ0 >> 2, tvaudio_carr2reg(secondary)); 207} 208 209#define SAA7134_MUTE_MASK 0xbb 210#define SAA7134_MUTE_ANALOG 0x04 211#define SAA7134_MUTE_I2S 0x40 212 213static void mute_input_7134(struct saa7134_dev *dev) 214{ 215 unsigned int mute; 216 struct saa7134_input *in; 217 int ausel=0, ics=0, ocs=0; 218 int mask; 219 220 /* look what is to do ... */ 221 in = dev->input; 222 mute = (dev->ctl_mute || 223 (dev->automute && (&card(dev).radio) != in)); 224 if (card(dev).mute.name) { 225 /* 226 * 7130 - we'll mute using some unconnected audio input 227 * 7134 - we'll probably should switch external mux with gpio 228 */ 229 if (mute) 230 in = &card(dev).mute; 231 } 232 233 if (dev->hw_mute == mute && 234 dev->hw_input == in) { 235 dprintk("mute/input: nothing to do [mute=%d,input=%s]\n", 236 mute,in->name); 237 return; 238 } 239 240 dprintk("ctl_mute=%d automute=%d input=%s => mute=%d input=%s\n", 241 dev->ctl_mute,dev->automute,dev->input->name,mute,in->name); 242 dev->hw_mute = mute; 243 dev->hw_input = in; 244 245 if (PCI_DEVICE_ID_PHILIPS_SAA7134 == dev->pci->device) 246 /* 7134 mute */ 247 saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ? 248 SAA7134_MUTE_MASK | 249 SAA7134_MUTE_ANALOG | 250 SAA7134_MUTE_I2S : 251 SAA7134_MUTE_MASK); 252 253 /* switch internal audio mux */ 254 switch (in->amux) { 255 case TV: ausel=0xc0; ics=0x00; ocs=0x02; break; 256 case LINE1: ausel=0x80; ics=0x00; ocs=0x00; break; 257 case LINE2: ausel=0x80; ics=0x08; ocs=0x01; break; 258 case LINE2_LEFT: ausel=0x80; ics=0x08; ocs=0x05; break; 259 } 260 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, ausel); 261 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, ics); 262 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, ocs); 263 // for oss, we need to change the clock configuration 264 if (in->amux == TV) 265 saa_andorb(SAA7134_SIF_SAMPLE_FREQ, 0x03, 0x00); 266 else 267 saa_andorb(SAA7134_SIF_SAMPLE_FREQ, 0x03, 0x01); 268 269 /* switch gpio-connected external audio mux */ 270 if (0 == card(dev).gpiomask) 271 return; 272 273 mask = card(dev).gpiomask; 274 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, mask, mask); 275 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, mask, in->gpio); 276 saa7134_track_gpio(dev,in->name); 277} 278 279static void tvaudio_setmode(struct saa7134_dev *dev, 280 struct saa7134_tvaudio *audio, 281 char *note) 282{ 283 int acpf, tweak = 0; 284 285 if (dev->tvnorm->id == V4L2_STD_NTSC) { 286 acpf = 0x19066; 287 } else { 288 acpf = 0x1e000; 289 } 290 if (audio_clock_tweak > -1024 && audio_clock_tweak < 1024) 291 tweak = audio_clock_tweak; 292 293 if (note) 294 dprintk("tvaudio_setmode: %s %s [%d.%03d/%d.%03d MHz] acpf=%d%+d\n", 295 note,audio->name, 296 audio->carr1 / 1000, audio->carr1 % 1000, 297 audio->carr2 / 1000, audio->carr2 % 1000, 298 acpf, tweak); 299 300 acpf += tweak; 301 saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD0, (acpf & 0x0000ff) >> 0); 302 saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD1, (acpf & 0x00ff00) >> 8); 303 saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD2, (acpf & 0x030000) >> 16); 304 tvaudio_setcarrier(dev,audio->carr1,audio->carr2); 305 306 switch (audio->mode) { 307 case TVAUDIO_FM_MONO: 308 case TVAUDIO_FM_BG_STEREO: 309 saa_writeb(SAA7134_DEMODULATOR, 0x00); 310 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x00); 311 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x22); 312 saa_writeb(SAA7134_FM_DEMATRIX, 0x80); 313 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa0); 314 break; 315 case TVAUDIO_FM_K_STEREO: 316 saa_writeb(SAA7134_DEMODULATOR, 0x00); 317 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x01); 318 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x22); 319 saa_writeb(SAA7134_FM_DEMATRIX, 0x80); 320 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa0); 321 break; 322 case TVAUDIO_NICAM_FM: 323 saa_writeb(SAA7134_DEMODULATOR, 0x10); 324 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x00); 325 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x44); 326 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa1); 327 saa_writeb(SAA7134_NICAM_CONFIG, 0x00); 328 break; 329 case TVAUDIO_NICAM_AM: 330 saa_writeb(SAA7134_DEMODULATOR, 0x12); 331 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x00); 332 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x44); 333 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa1); 334 saa_writeb(SAA7134_NICAM_CONFIG, 0x00); 335 break; 336 case TVAUDIO_FM_SAT_STEREO: 337 /* not implemented (yet) */ 338 break; 339 } 340} 341 342static int tvaudio_sleep(struct saa7134_dev *dev, int timeout) 343{ 344 DECLARE_WAITQUEUE(wait, current); 345 346 add_wait_queue(&dev->thread.wq, &wait); 347 if (dev->thread.scan1 == dev->thread.scan2 && !dev->thread.shutdown) { 348 if (timeout < 0) { 349 set_current_state(TASK_INTERRUPTIBLE); 350 schedule(); 351 } else { 352 schedule_timeout_interruptible 353 (msecs_to_jiffies(timeout)); 354 } 355 } 356 remove_wait_queue(&dev->thread.wq, &wait); 357 return dev->thread.scan1 != dev->thread.scan2; 358} 359 360static int tvaudio_checkcarrier(struct saa7134_dev *dev, struct mainscan *scan) 361{ 362 __s32 left,right,value; 363 364 if (audio_debug > 1) { 365 int i; 366 dprintk("debug %d:",scan->carr); 367 for (i = -150; i <= 150; i += 30) { 368 tvaudio_setcarrier(dev,scan->carr+i,scan->carr+i); 369 saa_readl(SAA7134_LEVEL_READOUT1 >> 2); 370 if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY)) 371 return -1; 372 value = saa_readl(SAA7134_LEVEL_READOUT1 >> 2); 373 if (0 == i) 374 printk(" # %6d # ",value >> 16); 375 else 376 printk(" %6d",value >> 16); 377 } 378 printk("\n"); 379 } 380 if (dev->tvnorm->id & scan->std) { 381 tvaudio_setcarrier(dev,scan->carr-90,scan->carr-90); 382 saa_readl(SAA7134_LEVEL_READOUT1 >> 2); 383 if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY)) 384 return -1; 385 left = saa_readl(SAA7134_LEVEL_READOUT1 >> 2); 386 387 tvaudio_setcarrier(dev,scan->carr+90,scan->carr+90); 388 saa_readl(SAA7134_LEVEL_READOUT1 >> 2); 389 if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY)) 390 return -1; 391 right = saa_readl(SAA7134_LEVEL_READOUT1 >> 2); 392 393 left >>= 16; 394 right >>= 16; 395 value = left > right ? left - right : right - left; 396 dprintk("scanning %d.%03d MHz [%4s] => dc is %5d [%d/%d]\n", 397 scan->carr / 1000, scan->carr % 1000, 398 scan->name, value, left, right); 399 } else { 400 value = 0; 401 dprintk("skipping %d.%03d MHz [%4s]\n", 402 scan->carr / 1000, scan->carr % 1000, scan->name); 403 } 404 return value; 405} 406 407 408static int tvaudio_getstereo(struct saa7134_dev *dev, struct saa7134_tvaudio *audio) 409{ 410 __u32 idp, nicam, nicam_status; 411 int retval = -1; 412 413 switch (audio->mode) { 414 case TVAUDIO_FM_MONO: 415 return V4L2_TUNER_SUB_MONO; 416 case TVAUDIO_FM_K_STEREO: 417 case TVAUDIO_FM_BG_STEREO: 418 idp = (saa_readb(SAA7134_IDENT_SIF) & 0xe0) >> 5; 419 dprintk("getstereo: fm/stereo: idp=0x%x\n",idp); 420 if (0x03 == (idp & 0x03)) 421 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; 422 else if (0x05 == (idp & 0x05)) 423 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 424 else if (0x01 == (idp & 0x01)) 425 retval = V4L2_TUNER_SUB_MONO; 426 break; 427 case TVAUDIO_FM_SAT_STEREO: 428 /* not implemented (yet) */ 429 break; 430 case TVAUDIO_NICAM_FM: 431 case TVAUDIO_NICAM_AM: 432 nicam = saa_readb(SAA7134_AUDIO_STATUS); 433 dprintk("getstereo: nicam=0x%x\n",nicam); 434 if (nicam & 0x1) { 435 nicam_status = saa_readb(SAA7134_NICAM_STATUS); 436 dprintk("getstereo: nicam_status=0x%x\n", nicam_status); 437 438 switch (nicam_status & 0x03) { 439 case 0x01: 440 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; 441 break; 442 case 0x02: 443 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 444 break; 445 default: 446 retval = V4L2_TUNER_SUB_MONO; 447 } 448 } else { 449 /* No nicam detected */ 450 } 451 break; 452 } 453 if (retval != -1) 454 dprintk("found audio subchannels:%s%s%s%s\n", 455 (retval & V4L2_TUNER_SUB_MONO) ? " mono" : "", 456 (retval & V4L2_TUNER_SUB_STEREO) ? " stereo" : "", 457 (retval & V4L2_TUNER_SUB_LANG1) ? " lang1" : "", 458 (retval & V4L2_TUNER_SUB_LANG2) ? " lang2" : ""); 459 return retval; 460} 461 462static int tvaudio_setstereo(struct saa7134_dev *dev, struct saa7134_tvaudio *audio, 463 u32 mode) 464{ 465 static char *name[] = { 466 [ V4L2_TUNER_MODE_MONO ] = "mono", 467 [ V4L2_TUNER_MODE_STEREO ] = "stereo", 468 [ V4L2_TUNER_MODE_LANG1 ] = "lang1", 469 [ V4L2_TUNER_MODE_LANG2 ] = "lang2", 470 [ V4L2_TUNER_MODE_LANG1_LANG2 ] = "lang1+lang2", 471 }; 472 static u32 fm[] = { 473 [ V4L2_TUNER_MODE_MONO ] = 0x00, /* ch1 */ 474 [ V4L2_TUNER_MODE_STEREO ] = 0x80, /* auto */ 475 [ V4L2_TUNER_MODE_LANG1 ] = 0x00, /* ch1 */ 476 [ V4L2_TUNER_MODE_LANG2 ] = 0x01, /* ch2 */ 477 [ V4L2_TUNER_MODE_LANG1_LANG2 ] = 0x80, /* auto */ 478 }; 479 u32 reg; 480 481 switch (audio->mode) { 482 case TVAUDIO_FM_MONO: 483 /* nothing to do ... */ 484 break; 485 case TVAUDIO_FM_K_STEREO: 486 case TVAUDIO_FM_BG_STEREO: 487 case TVAUDIO_NICAM_AM: 488 case TVAUDIO_NICAM_FM: 489 dprintk("setstereo [fm] => %s\n", 490 name[ mode % ARRAY_SIZE(name) ]); 491 reg = fm[ mode % ARRAY_SIZE(fm) ]; 492 saa_writeb(SAA7134_FM_DEMATRIX, reg); 493 break; 494 case TVAUDIO_FM_SAT_STEREO: 495 /* Not implemented */ 496 break; 497 } 498 return 0; 499} 500 501static int tvaudio_thread(void *data) 502{ 503 struct saa7134_dev *dev = data; 504 int carr_vals[ARRAY_SIZE(mainscan)]; 505 unsigned int i, audio, nscan; 506 int max1,max2,carrier,rx,mode,lastmode,default_carrier; 507 508 daemonize("%s", dev->name); 509 allow_signal(SIGTERM); 510 for (;;) { 511 tvaudio_sleep(dev,-1); 512 if (dev->thread.shutdown || signal_pending(current)) 513 goto done; 514 515 restart: 516 dev->thread.scan1 = dev->thread.scan2; 517 dprintk("tvaudio thread scan start [%d]\n",dev->thread.scan1); 518 dev->tvaudio = NULL; 519 tvaudio_init(dev); 520 if (dev->ctl_automute) 521 dev->automute = 1; 522 mute_input_7134(dev); 523 524 /* give the tuner some time */ 525 if (tvaudio_sleep(dev,SCAN_INITIAL_DELAY)) 526 goto restart; 527 528 max1 = 0; 529 max2 = 0; 530 nscan = 0; 531 carrier = 0; 532 default_carrier = 0; 533 for (i = 0; i < ARRAY_SIZE(mainscan); i++) { 534 if (!(dev->tvnorm->id & mainscan[i].std)) 535 continue; 536 if (!default_carrier) 537 default_carrier = mainscan[i].carr; 538 nscan++; 539 } 540 541 if (1 == nscan) { 542 /* only one candidate -- skip scan ;) */ 543 dprintk("only one main carrier candidate - skipping scan\n"); 544 max1 = 12345; 545 carrier = default_carrier; 546 } else { 547 /* scan for the main carrier */ 548 saa_writeb(SAA7134_MONITOR_SELECT,0x00); 549 tvaudio_setmode(dev,&tvaudio[0],NULL); 550 for (i = 0; i < ARRAY_SIZE(mainscan); i++) { 551 carr_vals[i] = tvaudio_checkcarrier(dev, mainscan+i); 552 if (dev->thread.scan1 != dev->thread.scan2) 553 goto restart; 554 } 555 for (max1 = 0, max2 = 0, i = 0; i < ARRAY_SIZE(mainscan); i++) { 556 if (max1 < carr_vals[i]) { 557 max2 = max1; 558 max1 = carr_vals[i]; 559 carrier = mainscan[i].carr; 560 } else if (max2 < carr_vals[i]) { 561 max2 = carr_vals[i]; 562 } 563 } 564 } 565 566 if (0 != carrier && max1 > 2000 && max1 > max2*3) { 567 /* found good carrier */ 568 dprintk("found %s main sound carrier @ %d.%03d MHz [%d/%d]\n", 569 dev->tvnorm->name, carrier/1000, carrier%1000, 570 max1, max2); 571 dev->last_carrier = carrier; 572 573 } else if (0 != dev->last_carrier) { 574 /* no carrier -- try last detected one as fallback */ 575 carrier = dev->last_carrier; 576 dprintk(KERN_WARNING "%s/audio: audio carrier scan failed, " 577 "using %d.%03d MHz [last detected]\n", 578 dev->name, carrier/1000, carrier%1000); 579 580 } else { 581 /* no carrier + no fallback -- use default */ 582 carrier = default_carrier; 583 dprintk(KERN_WARNING "%s/audio: audio carrier scan failed, " 584 "using %d.%03d MHz [default]\n", 585 dev->name, carrier/1000, carrier%1000); 586 } 587 tvaudio_setcarrier(dev,carrier,carrier); 588 dev->automute = 0; 589 saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x00); 590 saa7134_tvaudio_setmute(dev); 591 /* find the exact tv audio norm */ 592 for (audio = UNSET, i = 0; i < TVAUDIO; i++) { 593 if (dev->tvnorm->id != UNSET && 594 !(dev->tvnorm->id & tvaudio[i].std)) 595 continue; 596 if (tvaudio[i].carr1 != carrier) 597 continue; 598 /* Note: at least the primary carrier is right here */ 599 if (UNSET == audio) 600 audio = i; 601 tvaudio_setmode(dev,&tvaudio[i],"trying"); 602 if (tvaudio_sleep(dev,SCAN_SUBCARRIER_DELAY)) 603 goto restart; 604 if (-1 != tvaudio_getstereo(dev,&tvaudio[i])) { 605 audio = i; 606 break; 607 } 608 } 609 saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x30); 610 if (UNSET == audio) 611 continue; 612 tvaudio_setmode(dev,&tvaudio[audio],"using"); 613 614 tvaudio_setstereo(dev,&tvaudio[audio],V4L2_TUNER_MODE_MONO); 615 dev->tvaudio = &tvaudio[audio]; 616 617 lastmode = 42; 618 for (;;) { 619 if (tvaudio_sleep(dev,5000)) 620 goto restart; 621 if (dev->thread.shutdown || signal_pending(current)) 622 break; 623 if (UNSET == dev->thread.mode) { 624 rx = tvaudio_getstereo(dev,&tvaudio[i]); 625 mode = saa7134_tvaudio_rx2mode(rx); 626 } else { 627 mode = dev->thread.mode; 628 } 629 if (lastmode != mode) { 630 tvaudio_setstereo(dev,&tvaudio[audio],mode); 631 lastmode = mode; 632 } 633 } 634 } 635 636 done: 637 complete_and_exit(&dev->thread.exit, 0); 638 return 0; 639} 640 641/* ------------------------------------------------------------------ */ 642/* saa7133 / saa7135 code */ 643 644static char *stdres[0x20] = { 645 [0x00] = "no standard detected", 646 [0x01] = "B/G (in progress)", 647 [0x02] = "D/K (in progress)", 648 [0x03] = "M (in progress)", 649 650 [0x04] = "B/G A2", 651 [0x05] = "B/G NICAM", 652 [0x06] = "D/K A2 (1)", 653 [0x07] = "D/K A2 (2)", 654 [0x08] = "D/K A2 (3)", 655 [0x09] = "D/K NICAM", 656 [0x0a] = "L NICAM", 657 [0x0b] = "I NICAM", 658 659 [0x0c] = "M Korea", 660 [0x0d] = "M BTSC ", 661 [0x0e] = "M EIAJ", 662 663 [0x0f] = "FM radio / IF 10.7 / 50 deemp", 664 [0x10] = "FM radio / IF 10.7 / 75 deemp", 665 [0x11] = "FM radio / IF sel / 50 deemp", 666 [0x12] = "FM radio / IF sel / 75 deemp", 667 668 [0x13 ... 0x1e ] = "unknown", 669 [0x1f] = "??? [in progress]", 670}; 671 672#define DSP_RETRY 32 673#define DSP_DELAY 16 674 675static inline int saa_dsp_wait_bit(struct saa7134_dev *dev, int bit) 676{ 677 int state, count = DSP_RETRY; 678 679 state = saa_readb(SAA7135_DSP_RWSTATE); 680 if (unlikely(state & SAA7135_DSP_RWSTATE_ERR)) { 681 printk("%s: dsp access error\n",dev->name); 682 return -EIO; 683 } 684 while (0 == (state & bit)) { 685 if (unlikely(0 == count)) { 686 printk("%s: dsp access wait timeout [bit=%s]\n", 687 dev->name, 688 (bit & SAA7135_DSP_RWSTATE_WRR) ? "WRR" : 689 (bit & SAA7135_DSP_RWSTATE_RDB) ? "RDB" : 690 (bit & SAA7135_DSP_RWSTATE_IDA) ? "IDA" : 691 "???"); 692 return -EIO; 693 } 694 saa_wait(DSP_DELAY); 695 state = saa_readb(SAA7135_DSP_RWSTATE); 696 count--; 697 } 698 return 0; 699} 700 701 702int saa_dsp_writel(struct saa7134_dev *dev, int reg, u32 value) 703{ 704 int err; 705 706 d2printk("dsp write reg 0x%x = 0x%06x\n",reg<<2,value); 707 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR); 708 if (err < 0) 709 return err; 710 saa_writel(reg,value); 711 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR); 712 if (err < 0) 713 return err; 714 return 0; 715} 716 717static int getstereo_7133(struct saa7134_dev *dev) 718{ 719 int retval = V4L2_TUNER_SUB_MONO; 720 u32 value; 721 722 value = saa_readl(0x528 >> 2); 723 if (value & 0x20) 724 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 725 if (value & 0x40) 726 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; 727 return retval; 728} 729 730static int mute_input_7133(struct saa7134_dev *dev) 731{ 732 u32 reg = 0; 733 u32 xbarin, xbarout; 734 int mask; 735 struct saa7134_input *in; 736 737 xbarin = 0x03; 738 switch (dev->input->amux) { 739 case TV: 740 reg = 0x02; 741 xbarin = 0; 742 break; 743 case LINE1: 744 reg = 0x00; 745 break; 746 case LINE2: 747 case LINE2_LEFT: 748 reg = 0x09; 749 break; 750 } 751 saa_dsp_writel(dev, 0x464 >> 2, xbarin); 752 if (dev->ctl_mute) { 753 reg = 0x07; 754 xbarout = 0xbbbbbb; 755 } else 756 xbarout = 0xbbbb10; 757 saa_dsp_writel(dev, 0x46c >> 2, xbarout); 758 759 saa_writel(0x594 >> 2, reg); 760 761 762 /* switch gpio-connected external audio mux */ 763 if (0 != card(dev).gpiomask) { 764 mask = card(dev).gpiomask; 765 766 if (card(dev).mute.name && dev->ctl_mute) 767 in = &card(dev).mute; 768 else 769 in = dev->input; 770 771 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, mask, mask); 772 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, mask, in->gpio); 773 saa7134_track_gpio(dev,in->name); 774 } 775 776 return 0; 777} 778 779static int tvaudio_thread_ddep(void *data) 780{ 781 struct saa7134_dev *dev = data; 782 u32 value, norms, clock; 783 784 daemonize("%s", dev->name); 785 allow_signal(SIGTERM); 786 787 clock = saa7134_boards[dev->board].audio_clock; 788 if (UNSET != audio_clock_override) 789 clock = audio_clock_override; 790 saa_writel(0x598 >> 2, clock); 791 792 /* unmute */ 793 saa_dsp_writel(dev, 0x474 >> 2, 0x00); 794 saa_dsp_writel(dev, 0x450 >> 2, 0x00); 795 796 for (;;) { 797 tvaudio_sleep(dev,-1); 798 if (dev->thread.shutdown || signal_pending(current)) 799 goto done; 800 801 restart: 802 dev->thread.scan1 = dev->thread.scan2; 803 dprintk("tvaudio thread scan start [%d]\n",dev->thread.scan1); 804 805 if (audio_ddep >= 0x04 && audio_ddep <= 0x0e) { 806 /* insmod option override */ 807 norms = (audio_ddep << 2) | 0x01; 808 dprintk("ddep override: %s\n",stdres[audio_ddep]); 809 } else if (&card(dev).radio == dev->input) { 810 dprintk("FM Radio\n"); 811 if (dev->tuner_type == TUNER_PHILIPS_TDA8290) { 812 norms = (0x11 << 2) | 0x01; 813 saa_dsp_writel(dev, 0x42c >> 2, 0x729555); 814 } else { 815 norms = (0x0f << 2) | 0x01; 816 } 817 } else { 818 /* (let chip) scan for sound carrier */ 819 norms = 0; 820 if (dev->tvnorm->id & (V4L2_STD_B | V4L2_STD_GH)) 821 norms |= 0x04; 822 if (dev->tvnorm->id & V4L2_STD_PAL_I) 823 norms |= 0x20; 824 if (dev->tvnorm->id & V4L2_STD_DK) 825 norms |= 0x08; 826 if (dev->tvnorm->id & V4L2_STD_MN) 827 norms |= 0x40; 828 if (dev->tvnorm->id & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC)) 829 norms |= 0x10; 830 if (0 == norms) 831 norms = 0x7c; /* all */ 832 dprintk("scanning:%s%s%s%s%s\n", 833 (norms & 0x04) ? " B/G" : "", 834 (norms & 0x08) ? " D/K" : "", 835 (norms & 0x10) ? " L/L'" : "", 836 (norms & 0x20) ? " I" : "", 837 (norms & 0x40) ? " M" : ""); 838 } 839 840 /* kick automatic standard detection */ 841 saa_dsp_writel(dev, 0x454 >> 2, 0); 842 saa_dsp_writel(dev, 0x454 >> 2, norms | 0x80); 843 844 /* setup crossbars */ 845 saa_dsp_writel(dev, 0x464 >> 2, 0x000000); 846 saa_dsp_writel(dev, 0x470 >> 2, 0x101010); 847 848 if (tvaudio_sleep(dev,3000)) 849 goto restart; 850 value = saa_readl(0x528 >> 2) & 0xffffff; 851 852 dprintk("tvaudio thread status: 0x%x [%s%s%s]\n", 853 value, stdres[value & 0x1f], 854 (value & 0x000020) ? ",stereo" : "", 855 (value & 0x000040) ? ",dual" : ""); 856 dprintk("detailed status: " 857 "%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n", 858 (value & 0x000080) ? " A2/EIAJ pilot tone " : "", 859 (value & 0x000100) ? " A2/EIAJ dual " : "", 860 (value & 0x000200) ? " A2/EIAJ stereo " : "", 861 (value & 0x000400) ? " A2/EIAJ noise mute " : "", 862 863 (value & 0x000800) ? " BTSC/FM radio pilot " : "", 864 (value & 0x001000) ? " SAP carrier " : "", 865 (value & 0x002000) ? " BTSC stereo noise mute " : "", 866 (value & 0x004000) ? " SAP noise mute " : "", 867 (value & 0x008000) ? " VDSP " : "", 868 869 (value & 0x010000) ? " NICST " : "", 870 (value & 0x020000) ? " NICDU " : "", 871 (value & 0x040000) ? " NICAM muted " : "", 872 (value & 0x080000) ? " NICAM reserve sound " : "", 873 874 (value & 0x100000) ? " init done " : ""); 875 } 876 877 done: 878 complete_and_exit(&dev->thread.exit, 0); 879 return 0; 880} 881 882/* ------------------------------------------------------------------ */ 883/* common stuff + external entry points */ 884 885static void saa7134_enable_i2s(struct saa7134_dev *dev) 886{ 887 int i2s_format; 888 889 if (!card_is_empress(dev)) 890 return; 891 i2s_format = (dev->input->amux == TV) ? 0x00 : 0x01; 892 893 /* enable I2S audio output for the mpeg encoder */ 894 saa_writeb(SAA7134_I2S_OUTPUT_SELECT, 0x80); 895 saa_writeb(SAA7134_I2S_OUTPUT_FORMAT, i2s_format); 896 saa_writeb(SAA7134_I2S_OUTPUT_LEVEL, 0x0F); 897 saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x01); 898} 899 900int saa7134_tvaudio_rx2mode(u32 rx) 901{ 902 u32 mode; 903 904 mode = V4L2_TUNER_MODE_MONO; 905 if (rx & V4L2_TUNER_SUB_STEREO) 906 mode = V4L2_TUNER_MODE_STEREO; 907 else if (rx & V4L2_TUNER_SUB_LANG1) 908 mode = V4L2_TUNER_MODE_LANG1; 909 else if (rx & V4L2_TUNER_SUB_LANG2) 910 mode = V4L2_TUNER_MODE_LANG2; 911 return mode; 912} 913 914void saa7134_tvaudio_setmute(struct saa7134_dev *dev) 915{ 916 switch (dev->pci->device) { 917 case PCI_DEVICE_ID_PHILIPS_SAA7130: 918 case PCI_DEVICE_ID_PHILIPS_SAA7134: 919 mute_input_7134(dev); 920 break; 921 case PCI_DEVICE_ID_PHILIPS_SAA7133: 922 case PCI_DEVICE_ID_PHILIPS_SAA7135: 923 mute_input_7133(dev); 924 break; 925 } 926} 927 928void saa7134_tvaudio_setinput(struct saa7134_dev *dev, 929 struct saa7134_input *in) 930{ 931 dev->input = in; 932 switch (dev->pci->device) { 933 case PCI_DEVICE_ID_PHILIPS_SAA7130: 934 case PCI_DEVICE_ID_PHILIPS_SAA7134: 935 mute_input_7134(dev); 936 break; 937 case PCI_DEVICE_ID_PHILIPS_SAA7133: 938 case PCI_DEVICE_ID_PHILIPS_SAA7135: 939 mute_input_7133(dev); 940 break; 941 } 942 saa7134_enable_i2s(dev); 943} 944 945void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level) 946{ 947 switch (dev->pci->device) { 948 case PCI_DEVICE_ID_PHILIPS_SAA7134: 949 saa_writeb(SAA7134_CHANNEL1_LEVEL, level & 0x1f); 950 saa_writeb(SAA7134_CHANNEL2_LEVEL, level & 0x1f); 951 saa_writeb(SAA7134_NICAM_LEVEL_ADJUST, level & 0x1f); 952 break; 953 } 954} 955 956int saa7134_tvaudio_getstereo(struct saa7134_dev *dev) 957{ 958 int retval = V4L2_TUNER_SUB_MONO; 959 960 switch (dev->pci->device) { 961 case PCI_DEVICE_ID_PHILIPS_SAA7134: 962 if (dev->tvaudio) 963 retval = tvaudio_getstereo(dev,dev->tvaudio); 964 break; 965 case PCI_DEVICE_ID_PHILIPS_SAA7133: 966 case PCI_DEVICE_ID_PHILIPS_SAA7135: 967 retval = getstereo_7133(dev); 968 break; 969 } 970 return retval; 971} 972 973int saa7134_tvaudio_init2(struct saa7134_dev *dev) 974{ 975 DECLARE_MUTEX_LOCKED(sem); 976 int (*my_thread)(void *data) = NULL; 977 978 switch (dev->pci->device) { 979 case PCI_DEVICE_ID_PHILIPS_SAA7134: 980 my_thread = tvaudio_thread; 981 break; 982 case PCI_DEVICE_ID_PHILIPS_SAA7133: 983 case PCI_DEVICE_ID_PHILIPS_SAA7135: 984 my_thread = tvaudio_thread_ddep; 985 break; 986 } 987 988 dev->thread.pid = -1; 989 if (my_thread) { 990 /* start tvaudio thread */ 991 init_waitqueue_head(&dev->thread.wq); 992 init_completion(&dev->thread.exit); 993 dev->thread.pid = kernel_thread(my_thread,dev,0); 994 if (dev->thread.pid < 0) 995 printk(KERN_WARNING "%s: kernel_thread() failed\n", 996 dev->name); 997 saa7134_tvaudio_do_scan(dev); 998 } 999 1000 saa7134_enable_i2s(dev); 1001 return 0; 1002} 1003 1004int saa7134_tvaudio_fini(struct saa7134_dev *dev) 1005{ 1006 /* shutdown tvaudio thread */ 1007 if (dev->thread.pid > 0) { 1008 dev->thread.shutdown = 1; 1009 wake_up_interruptible(&dev->thread.wq); 1010 wait_for_completion(&dev->thread.exit); 1011 } 1012 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, 0x00); /* LINE1 */ 1013 return 0; 1014} 1015 1016int saa7134_tvaudio_do_scan(struct saa7134_dev *dev) 1017{ 1018 if (dev->input->amux != TV) { 1019 dprintk("sound IF not in use, skipping scan\n"); 1020 dev->automute = 0; 1021 saa7134_tvaudio_setmute(dev); 1022 } else if (dev->thread.pid >= 0) { 1023 dev->thread.mode = UNSET; 1024 dev->thread.scan2++; 1025 wake_up_interruptible(&dev->thread.wq); 1026 } else { 1027 dev->automute = 0; 1028 saa7134_tvaudio_setmute(dev); 1029 } 1030 return 0; 1031} 1032 1033EXPORT_SYMBOL(saa_dsp_writel); 1034EXPORT_SYMBOL(saa7134_tvaudio_setmute); 1035 1036/* ----------------------------------------------------------- */ 1037/* 1038 * Local variables: 1039 * c-basic-offset: 8 1040 * End: 1041 */ 1042