Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  * device driver for philips saa7134 based TV cards
0005  * tv audio decoder (fm stereo, nicam, ...)
0006  *
0007  * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
0008  */
0009 
0010 #include "saa7134.h"
0011 #include "saa7134-reg.h"
0012 
0013 #include <linux/init.h>
0014 #include <linux/list.h>
0015 #include <linux/module.h>
0016 #include <linux/kernel.h>
0017 #include <linux/kthread.h>
0018 #include <linux/delay.h>
0019 #include <linux/freezer.h>
0020 #include <asm/div64.h>
0021 
0022 /* ------------------------------------------------------------------ */
0023 
0024 static unsigned int audio_debug;
0025 module_param(audio_debug, int, 0644);
0026 MODULE_PARM_DESC(audio_debug,"enable debug messages [tv audio]");
0027 
0028 static unsigned int audio_ddep;
0029 module_param(audio_ddep, int, 0644);
0030 MODULE_PARM_DESC(audio_ddep,"audio ddep overwrite");
0031 
0032 static int audio_clock_override = UNSET;
0033 module_param(audio_clock_override, int, 0644);
0034 
0035 static int audio_clock_tweak;
0036 module_param(audio_clock_tweak, int, 0644);
0037 MODULE_PARM_DESC(audio_clock_tweak, "Audio clock tick fine tuning for cards with audio crystal that's slightly off (range [-1024 .. 1024])");
0038 
0039 #define audio_dbg(level, fmt, arg...) do { \
0040     if (audio_debug >= level) \
0041         printk(KERN_DEBUG pr_fmt("audio: " fmt), ## arg); \
0042     } while (0)
0043 
0044 /* msecs */
0045 #define SCAN_INITIAL_DELAY     1000
0046 #define SCAN_SAMPLE_DELAY       200
0047 #define SCAN_SUBCARRIER_DELAY  2000
0048 
0049 /* ------------------------------------------------------------------ */
0050 /* saa7134 code                                                       */
0051 
0052 static struct mainscan {
0053     char         *name;
0054     v4l2_std_id  std;
0055     int          carr;
0056 } mainscan[] = {
0057     {
0058         .name = "MN",
0059         .std  = V4L2_STD_MN,
0060         .carr = 4500,
0061     },{
0062         .name = "BGH",
0063         .std  = V4L2_STD_B | V4L2_STD_GH,
0064         .carr = 5500,
0065     },{
0066         .name = "I",
0067         .std  = V4L2_STD_PAL_I,
0068         .carr = 6000,
0069     },{
0070         .name = "DKL",
0071         .std  = V4L2_STD_DK | V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC,
0072         .carr = 6500,
0073     }
0074 };
0075 
0076 static struct saa7134_tvaudio tvaudio[] = {
0077     {
0078         .name          = "PAL-B/G FM-stereo",
0079         .std           = V4L2_STD_PAL_BG,
0080         .mode          = TVAUDIO_FM_BG_STEREO,
0081         .carr1         = 5500,
0082         .carr2         = 5742,
0083     },{
0084         .name          = "PAL-D/K1 FM-stereo",
0085         .std           = V4L2_STD_PAL_DK,
0086         .carr1         = 6500,
0087         .carr2         = 6258,
0088         .mode          = TVAUDIO_FM_BG_STEREO,
0089     },{
0090         .name          = "PAL-D/K2 FM-stereo",
0091         .std           = V4L2_STD_PAL_DK,
0092         .carr1         = 6500,
0093         .carr2         = 6742,
0094         .mode          = TVAUDIO_FM_BG_STEREO,
0095     },{
0096         .name          = "PAL-D/K3 FM-stereo",
0097         .std           = V4L2_STD_PAL_DK,
0098         .carr1         = 6500,
0099         .carr2         = 5742,
0100         .mode          = TVAUDIO_FM_BG_STEREO,
0101     },{
0102         .name          = "PAL-B/G NICAM",
0103         .std           = V4L2_STD_PAL_BG,
0104         .carr1         = 5500,
0105         .carr2         = 5850,
0106         .mode          = TVAUDIO_NICAM_FM,
0107     },{
0108         .name          = "PAL-I NICAM",
0109         .std           = V4L2_STD_PAL_I,
0110         .carr1         = 6000,
0111         .carr2         = 6552,
0112         .mode          = TVAUDIO_NICAM_FM,
0113     },{
0114         .name          = "PAL-D/K NICAM",
0115         .std           = V4L2_STD_PAL_DK,
0116         .carr1         = 6500,
0117         .carr2         = 5850,
0118         .mode          = TVAUDIO_NICAM_FM,
0119     },{
0120         .name          = "SECAM-L NICAM",
0121         .std           = V4L2_STD_SECAM_L,
0122         .carr1         = 6500,
0123         .carr2         = 5850,
0124         .mode          = TVAUDIO_NICAM_AM,
0125     },{
0126         .name          = "SECAM-D/K NICAM",
0127         .std           = V4L2_STD_SECAM_DK,
0128         .carr1         = 6500,
0129         .carr2         = 5850,
0130         .mode          = TVAUDIO_NICAM_FM,
0131     },{
0132         .name          = "NTSC-A2 FM-stereo",
0133         .std           = V4L2_STD_NTSC,
0134         .carr1         = 4500,
0135         .carr2         = 4724,
0136         .mode          = TVAUDIO_FM_K_STEREO,
0137     },{
0138         .name          = "NTSC-M",
0139         .std           = V4L2_STD_NTSC,
0140         .carr1         = 4500,
0141         .carr2         = -1,
0142         .mode          = TVAUDIO_FM_MONO,
0143     }
0144 };
0145 #define TVAUDIO ARRAY_SIZE(tvaudio)
0146 
0147 /* ------------------------------------------------------------------ */
0148 
0149 static u32 tvaudio_carr2reg(u32 carrier)
0150 {
0151     u64 a = carrier;
0152 
0153     a <<= 24;
0154     do_div(a,12288);
0155     return a;
0156 }
0157 
0158 static void tvaudio_setcarrier(struct saa7134_dev *dev,
0159                    int primary, int secondary)
0160 {
0161     if (-1 == secondary)
0162         secondary = primary;
0163     saa_writel(SAA7134_CARRIER1_FREQ0 >> 2, tvaudio_carr2reg(primary));
0164     saa_writel(SAA7134_CARRIER2_FREQ0 >> 2, tvaudio_carr2reg(secondary));
0165 }
0166 
0167 #define SAA7134_MUTE_MASK 0xbb
0168 #define SAA7134_MUTE_ANALOG 0x04
0169 #define SAA7134_MUTE_I2S 0x40
0170 
0171 static void mute_input_7134(struct saa7134_dev *dev)
0172 {
0173     unsigned int mute;
0174     struct saa7134_input *in;
0175     int ausel=0, ics=0, ocs=0;
0176     int mask;
0177 
0178     /* look what is to do ... */
0179     in   = dev->input;
0180     mute = (dev->ctl_mute ||
0181         (dev->automute  &&  (&card(dev).radio) != in));
0182     if (card(dev).mute.type) {
0183         /*
0184          * 7130 - we'll mute using some unconnected audio input
0185          * 7134 - we'll probably should switch external mux with gpio
0186          */
0187         if (mute)
0188             in = &card(dev).mute;
0189     }
0190 
0191     if (dev->hw_mute  == mute &&
0192         dev->hw_input == in && !dev->insuspend) {
0193         audio_dbg(1, "mute/input: nothing to do [mute=%d,input=%s]\n",
0194               mute, saa7134_input_name[in->type]);
0195         return;
0196     }
0197 
0198     audio_dbg(1, "ctl_mute=%d automute=%d input=%s  =>  mute=%d input=%s\n",
0199           dev->ctl_mute, dev->automute,
0200           saa7134_input_name[dev->input->type], mute,
0201           saa7134_input_name[in->type]);
0202     dev->hw_mute  = mute;
0203     dev->hw_input = in;
0204 
0205     if (PCI_DEVICE_ID_PHILIPS_SAA7134 == dev->pci->device)
0206         /* 7134 mute */
0207         saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ?
0208                             SAA7134_MUTE_MASK |
0209                             SAA7134_MUTE_ANALOG |
0210                             SAA7134_MUTE_I2S :
0211                             SAA7134_MUTE_MASK);
0212 
0213     /* switch internal audio mux */
0214     switch (in->amux) {
0215     case TV:         ausel=0xc0; ics=0x00; ocs=0x02; break;
0216     case LINE1:      ausel=0x80; ics=0x00; ocs=0x00; break;
0217     case LINE2:      ausel=0x80; ics=0x08; ocs=0x01; break;
0218     case LINE2_LEFT: ausel=0x80; ics=0x08; ocs=0x05; break;
0219     }
0220     saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, ausel);
0221     saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, ics);
0222     saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, ocs);
0223     // for oss, we need to change the clock configuration
0224     if (in->amux == TV)
0225         saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, 0x00);
0226     else
0227         saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, 0x01);
0228 
0229     /* switch gpio-connected external audio mux */
0230     if (0 == card(dev).gpiomask)
0231         return;
0232 
0233     mask = card(dev).gpiomask;
0234     saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   mask, mask);
0235     saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, mask, in->gpio);
0236     saa7134_track_gpio(dev, saa7134_input_name[in->type]);
0237 }
0238 
0239 static void tvaudio_setmode(struct saa7134_dev *dev,
0240                 struct saa7134_tvaudio *audio,
0241                 char *note)
0242 {
0243     int acpf, tweak = 0;
0244 
0245     if (dev->tvnorm->id == V4L2_STD_NTSC) {
0246         acpf = 0x19066;
0247     } else {
0248         acpf = 0x1e000;
0249     }
0250     if (audio_clock_tweak > -1024 && audio_clock_tweak < 1024)
0251         tweak = audio_clock_tweak;
0252 
0253     if (note)
0254         audio_dbg(1, "tvaudio_setmode: %s %s [%d.%03d/%d.%03d MHz] acpf=%d%+d\n",
0255             note, audio->name,
0256             audio->carr1 / 1000, audio->carr1 % 1000,
0257             audio->carr2 / 1000, audio->carr2 % 1000,
0258             acpf, tweak);
0259 
0260     acpf += tweak;
0261     saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD0, (acpf & 0x0000ff) >> 0);
0262     saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD1, (acpf & 0x00ff00) >> 8);
0263     saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD2, (acpf & 0x030000) >> 16);
0264     tvaudio_setcarrier(dev,audio->carr1,audio->carr2);
0265 
0266     switch (audio->mode) {
0267     case TVAUDIO_FM_MONO:
0268     case TVAUDIO_FM_BG_STEREO:
0269         saa_writeb(SAA7134_DEMODULATOR,               0x00);
0270         saa_writeb(SAA7134_DCXO_IDENT_CTRL,           0x00);
0271         saa_writeb(SAA7134_FM_DEEMPHASIS,             0x22);
0272         saa_writeb(SAA7134_FM_DEMATRIX,               0x80);
0273         saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT,  0xa0);
0274         break;
0275     case TVAUDIO_FM_K_STEREO:
0276         saa_writeb(SAA7134_DEMODULATOR,               0x00);
0277         saa_writeb(SAA7134_DCXO_IDENT_CTRL,           0x01);
0278         saa_writeb(SAA7134_FM_DEEMPHASIS,             0x22);
0279         saa_writeb(SAA7134_FM_DEMATRIX,               0x80);
0280         saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT,  0xa0);
0281         break;
0282     case TVAUDIO_NICAM_FM:
0283         saa_writeb(SAA7134_DEMODULATOR,               0x10);
0284         saa_writeb(SAA7134_DCXO_IDENT_CTRL,           0x00);
0285         saa_writeb(SAA7134_FM_DEEMPHASIS,             0x44);
0286         saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT,  0xa1);
0287         saa_writeb(SAA7134_NICAM_CONFIG,              0x00);
0288         break;
0289     case TVAUDIO_NICAM_AM:
0290         saa_writeb(SAA7134_DEMODULATOR,               0x12);
0291         saa_writeb(SAA7134_DCXO_IDENT_CTRL,           0x00);
0292         saa_writeb(SAA7134_FM_DEEMPHASIS,             0x44);
0293         saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT,  0xa1);
0294         saa_writeb(SAA7134_NICAM_CONFIG,              0x00);
0295         break;
0296     case TVAUDIO_FM_SAT_STEREO:
0297         /* not implemented (yet) */
0298         break;
0299     }
0300 }
0301 
0302 static int tvaudio_sleep(struct saa7134_dev *dev, int timeout)
0303 {
0304     if (dev->thread.scan1 == dev->thread.scan2 &&
0305         !kthread_should_stop()) {
0306         if (timeout < 0) {
0307             set_current_state(TASK_INTERRUPTIBLE);
0308             schedule();
0309         } else {
0310             schedule_timeout_interruptible
0311                         (msecs_to_jiffies(timeout));
0312         }
0313     }
0314     return dev->thread.scan1 != dev->thread.scan2;
0315 }
0316 
0317 static int tvaudio_checkcarrier(struct saa7134_dev *dev, struct mainscan *scan)
0318 {
0319     __s32 left,right,value;
0320 
0321     if (!(dev->tvnorm->id & scan->std)) {
0322         audio_dbg(1, "skipping %d.%03d MHz [%4s]\n",
0323               scan->carr / 1000, scan->carr % 1000, scan->name);
0324         return 0;
0325     }
0326 
0327     if (audio_debug > 1) {
0328         int i;
0329         audio_dbg(1, "debug %d:", scan->carr);
0330         for (i = -150; i <= 150; i += 30) {
0331             tvaudio_setcarrier(dev,scan->carr+i,scan->carr+i);
0332             saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
0333             if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
0334                 return -1;
0335             value = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
0336             if (0 == i)
0337                 pr_cont("  #  %6d  # ", value >> 16);
0338             else
0339                 pr_cont(" %6d", value >> 16);
0340         }
0341         pr_cont("\n");
0342     }
0343 
0344     tvaudio_setcarrier(dev,scan->carr-90,scan->carr-90);
0345     saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
0346     if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
0347         return -1;
0348     left = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
0349 
0350     tvaudio_setcarrier(dev,scan->carr+90,scan->carr+90);
0351     saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
0352     if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
0353         return -1;
0354     right = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
0355 
0356     left >>= 16;
0357     right >>= 16;
0358     value = left > right ? left - right : right - left;
0359     audio_dbg(1, "scanning %d.%03d MHz [%4s] =>  dc is %5d [%d/%d]\n",
0360           scan->carr / 1000, scan->carr % 1000,
0361           scan->name, value, left, right);
0362     return value;
0363 }
0364 
0365 
0366 static int tvaudio_getstereo(struct saa7134_dev *dev, struct saa7134_tvaudio *audio)
0367 {
0368     __u32 idp, nicam, nicam_status;
0369     int retval = -1;
0370 
0371     switch (audio->mode) {
0372     case TVAUDIO_FM_MONO:
0373         return V4L2_TUNER_SUB_MONO;
0374     case TVAUDIO_FM_K_STEREO:
0375     case TVAUDIO_FM_BG_STEREO:
0376         idp = (saa_readb(SAA7134_IDENT_SIF) & 0xe0) >> 5;
0377         audio_dbg(1, "getstereo: fm/stereo: idp=0x%x\n", idp);
0378         if (0x03 == (idp & 0x03))
0379             retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
0380         else if (0x05 == (idp & 0x05))
0381             retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
0382         else if (0x01 == (idp & 0x01))
0383             retval = V4L2_TUNER_SUB_MONO;
0384         break;
0385     case TVAUDIO_FM_SAT_STEREO:
0386         /* not implemented (yet) */
0387         break;
0388     case TVAUDIO_NICAM_FM:
0389     case TVAUDIO_NICAM_AM:
0390         nicam = saa_readb(SAA7134_AUDIO_STATUS);
0391         audio_dbg(1, "getstereo: nicam=0x%x\n", nicam);
0392         if (nicam & 0x1) {
0393             nicam_status = saa_readb(SAA7134_NICAM_STATUS);
0394             audio_dbg(1, "getstereo: nicam_status=0x%x\n",
0395                   nicam_status);
0396 
0397             switch (nicam_status & 0x03) {
0398                 case 0x01:
0399                 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
0400                 break;
0401                 case 0x02:
0402                 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
0403                 break;
0404                 default:
0405                 retval = V4L2_TUNER_SUB_MONO;
0406             }
0407         } else {
0408             /* No nicam detected */
0409         }
0410         break;
0411     }
0412     if (retval != -1)
0413         audio_dbg(1, "found audio subchannels:%s%s%s%s\n",
0414             (retval & V4L2_TUNER_SUB_MONO)   ? " mono"   : "",
0415             (retval & V4L2_TUNER_SUB_STEREO) ? " stereo" : "",
0416             (retval & V4L2_TUNER_SUB_LANG1)  ? " lang1"  : "",
0417             (retval & V4L2_TUNER_SUB_LANG2)  ? " lang2"  : "");
0418     return retval;
0419 }
0420 
0421 static int tvaudio_setstereo(struct saa7134_dev *dev, struct saa7134_tvaudio *audio,
0422                  u32 mode)
0423 {
0424     static char *name[] = {
0425         [ V4L2_TUNER_MODE_MONO   ] = "mono",
0426         [ V4L2_TUNER_MODE_STEREO ] = "stereo",
0427         [ V4L2_TUNER_MODE_LANG1  ] = "lang1",
0428         [ V4L2_TUNER_MODE_LANG2  ] = "lang2",
0429         [ V4L2_TUNER_MODE_LANG1_LANG2  ] = "lang1+lang2",
0430     };
0431     static u32 fm[] = {
0432         [ V4L2_TUNER_MODE_MONO   ] = 0x00,  /* ch1  */
0433         [ V4L2_TUNER_MODE_STEREO ] = 0x80,  /* auto */
0434         [ V4L2_TUNER_MODE_LANG1  ] = 0x00,  /* ch1  */
0435         [ V4L2_TUNER_MODE_LANG2  ] = 0x01,  /* ch2  */
0436         [ V4L2_TUNER_MODE_LANG1_LANG2 ] = 0x80,  /* auto */
0437     };
0438     u32 reg;
0439 
0440     switch (audio->mode) {
0441     case TVAUDIO_FM_MONO:
0442         /* nothing to do ... */
0443         break;
0444     case TVAUDIO_FM_K_STEREO:
0445     case TVAUDIO_FM_BG_STEREO:
0446     case TVAUDIO_NICAM_AM:
0447     case TVAUDIO_NICAM_FM:
0448         audio_dbg(1, "setstereo [fm] => %s\n",
0449               name[mode % ARRAY_SIZE(name)]);
0450         reg = fm[ mode % ARRAY_SIZE(fm) ];
0451         saa_writeb(SAA7134_FM_DEMATRIX, reg);
0452         break;
0453     case TVAUDIO_FM_SAT_STEREO:
0454         /* Not implemented */
0455         break;
0456     }
0457     return 0;
0458 }
0459 
0460 static int tvaudio_thread(void *data)
0461 {
0462     struct saa7134_dev *dev = data;
0463     int carr_vals[ARRAY_SIZE(mainscan)];
0464     unsigned int i, audio, nscan;
0465     int max1,max2,carrier,rx,mode,lastmode,default_carrier;
0466 
0467     set_freezable();
0468 
0469     for (;;) {
0470         tvaudio_sleep(dev,-1);
0471         if (kthread_should_stop())
0472             goto done;
0473 
0474     restart:
0475         try_to_freeze();
0476 
0477         dev->thread.scan1 = dev->thread.scan2;
0478         audio_dbg(1, "tvaudio thread scan start [%d]\n",
0479               dev->thread.scan1);
0480         dev->tvaudio  = NULL;
0481 
0482         saa_writeb(SAA7134_MONITOR_SELECT,   0xa0);
0483         saa_writeb(SAA7134_FM_DEMATRIX,      0x80);
0484 
0485         if (dev->ctl_automute)
0486             dev->automute = 1;
0487 
0488         mute_input_7134(dev);
0489 
0490         /* give the tuner some time */
0491         if (tvaudio_sleep(dev,SCAN_INITIAL_DELAY))
0492             goto restart;
0493 
0494         max1 = 0;
0495         max2 = 0;
0496         nscan = 0;
0497         carrier = 0;
0498         default_carrier = 0;
0499         for (i = 0; i < ARRAY_SIZE(mainscan); i++) {
0500             if (!(dev->tvnorm->id & mainscan[i].std))
0501                 continue;
0502             if (!default_carrier)
0503                 default_carrier = mainscan[i].carr;
0504             nscan++;
0505         }
0506 
0507         if (1 == nscan) {
0508             /* only one candidate -- skip scan ;) */
0509             audio_dbg(1, "only one main carrier candidate - skipping scan\n");
0510             max1 = 12345;
0511             carrier = default_carrier;
0512         } else {
0513             /* scan for the main carrier */
0514             saa_writeb(SAA7134_MONITOR_SELECT,0x00);
0515             tvaudio_setmode(dev,&tvaudio[0],NULL);
0516             for (i = 0; i < ARRAY_SIZE(mainscan); i++) {
0517                 carr_vals[i] = tvaudio_checkcarrier(dev, mainscan+i);
0518                 if (dev->thread.scan1 != dev->thread.scan2)
0519                     goto restart;
0520             }
0521             for (max1 = 0, max2 = 0, i = 0; i < ARRAY_SIZE(mainscan); i++) {
0522                 if (max1 < carr_vals[i]) {
0523                     max2 = max1;
0524                     max1 = carr_vals[i];
0525                     carrier = mainscan[i].carr;
0526                 } else if (max2 < carr_vals[i]) {
0527                     max2 = carr_vals[i];
0528                 }
0529             }
0530         }
0531 
0532         if (0 != carrier && max1 > 2000 && max1 > max2*3) {
0533             /* found good carrier */
0534             audio_dbg(1, "found %s main sound carrier @ %d.%03d MHz [%d/%d]\n",
0535                   dev->tvnorm->name, carrier/1000, carrier%1000,
0536                   max1, max2);
0537             dev->last_carrier = carrier;
0538             dev->automute = 0;
0539 
0540         } else if (0 != dev->last_carrier) {
0541             /* no carrier -- try last detected one as fallback */
0542             carrier = dev->last_carrier;
0543             audio_dbg(1, "audio carrier scan failed, using %d.%03d MHz [last detected]\n",
0544                   carrier/1000, carrier%1000);
0545             dev->automute = 1;
0546 
0547         } else {
0548             /* no carrier + no fallback -- use default */
0549             carrier = default_carrier;
0550             audio_dbg(1, "audio carrier scan failed, using %d.%03d MHz [default]\n",
0551                   carrier/1000, carrier%1000);
0552             dev->automute = 1;
0553         }
0554         tvaudio_setcarrier(dev,carrier,carrier);
0555         saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x00);
0556         saa7134_tvaudio_setmute(dev);
0557         /* find the exact tv audio norm */
0558         for (audio = UNSET, i = 0; i < TVAUDIO; i++) {
0559             if (dev->tvnorm->id != UNSET &&
0560                 !(dev->tvnorm->id & tvaudio[i].std))
0561                 continue;
0562             if (tvaudio[i].carr1 != carrier)
0563                 continue;
0564             /* Note: at least the primary carrier is right here */
0565             if (UNSET == audio)
0566                 audio = i;
0567             tvaudio_setmode(dev,&tvaudio[i],"trying");
0568             if (tvaudio_sleep(dev,SCAN_SUBCARRIER_DELAY))
0569                 goto restart;
0570             if (-1 != tvaudio_getstereo(dev,&tvaudio[i])) {
0571                 audio = i;
0572                 break;
0573             }
0574         }
0575         saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x30);
0576         if (UNSET == audio)
0577             continue;
0578         tvaudio_setmode(dev,&tvaudio[audio],"using");
0579 
0580         tvaudio_setstereo(dev,&tvaudio[audio],V4L2_TUNER_MODE_MONO);
0581         dev->tvaudio = &tvaudio[audio];
0582 
0583         lastmode = 42;
0584         for (;;) {
0585 
0586             try_to_freeze();
0587 
0588             if (tvaudio_sleep(dev,5000))
0589                 goto restart;
0590             if (kthread_should_stop())
0591                 break;
0592             if (UNSET == dev->thread.mode) {
0593                 rx = tvaudio_getstereo(dev, &tvaudio[audio]);
0594                 mode = saa7134_tvaudio_rx2mode(rx);
0595             } else {
0596                 mode = dev->thread.mode;
0597             }
0598             if (lastmode != mode) {
0599                 tvaudio_setstereo(dev,&tvaudio[audio],mode);
0600                 lastmode = mode;
0601             }
0602         }
0603     }
0604 
0605  done:
0606     dev->thread.stopped = 1;
0607     return 0;
0608 }
0609 
0610 /* ------------------------------------------------------------------ */
0611 /* saa7133 / saa7135 code                                             */
0612 
0613 static char *stdres[0x20] = {
0614     [0x00] = "no standard detected",
0615     [0x01] = "B/G (in progress)",
0616     [0x02] = "D/K (in progress)",
0617     [0x03] = "M (in progress)",
0618 
0619     [0x04] = "B/G A2",
0620     [0x05] = "B/G NICAM",
0621     [0x06] = "D/K A2 (1)",
0622     [0x07] = "D/K A2 (2)",
0623     [0x08] = "D/K A2 (3)",
0624     [0x09] = "D/K NICAM",
0625     [0x0a] = "L NICAM",
0626     [0x0b] = "I NICAM",
0627 
0628     [0x0c] = "M Korea",
0629     [0x0d] = "M BTSC ",
0630     [0x0e] = "M EIAJ",
0631 
0632     [0x0f] = "FM radio / IF 10.7 / 50 deemp",
0633     [0x10] = "FM radio / IF 10.7 / 75 deemp",
0634     [0x11] = "FM radio / IF sel / 50 deemp",
0635     [0x12] = "FM radio / IF sel / 75 deemp",
0636 
0637     [0x13 ... 0x1e ] = "unknown",
0638     [0x1f] = "??? [in progress]",
0639 };
0640 
0641 #define DSP_RETRY 32
0642 #define DSP_DELAY 16
0643 #define SAA7135_DSP_RWCLEAR_RERR 1
0644 
0645 static inline int saa_dsp_reset_error_bit(struct saa7134_dev *dev)
0646 {
0647     int state = saa_readb(SAA7135_DSP_RWSTATE);
0648     if (unlikely(state & SAA7135_DSP_RWSTATE_ERR)) {
0649         audio_dbg(2, "%s: resetting error bit\n", dev->name);
0650         saa_writeb(SAA7135_DSP_RWCLEAR, SAA7135_DSP_RWCLEAR_RERR);
0651     }
0652     return 0;
0653 }
0654 
0655 static inline int saa_dsp_wait_bit(struct saa7134_dev *dev, int bit)
0656 {
0657     int state, count = DSP_RETRY;
0658 
0659     state = saa_readb(SAA7135_DSP_RWSTATE);
0660     if (unlikely(state & SAA7135_DSP_RWSTATE_ERR)) {
0661         pr_warn("%s: dsp access error\n", dev->name);
0662         saa_dsp_reset_error_bit(dev);
0663         return -EIO;
0664     }
0665     while (0 == (state & bit)) {
0666         if (unlikely(0 == count)) {
0667             pr_err("dsp access wait timeout [bit=%s]\n",
0668                  (bit & SAA7135_DSP_RWSTATE_WRR) ? "WRR" :
0669                  (bit & SAA7135_DSP_RWSTATE_RDB) ? "RDB" :
0670                  (bit & SAA7135_DSP_RWSTATE_IDA) ? "IDA" :
0671                  "???");
0672             return -EIO;
0673         }
0674         saa_wait(DSP_DELAY);
0675         state = saa_readb(SAA7135_DSP_RWSTATE);
0676         count--;
0677     }
0678     return 0;
0679 }
0680 
0681 
0682 int saa_dsp_writel(struct saa7134_dev *dev, int reg, u32 value)
0683 {
0684     int err;
0685 
0686     audio_dbg(2, "dsp write reg 0x%x = 0x%06x\n",
0687           (reg << 2) & 0xffffffff, value);
0688     err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR);
0689     if (err < 0)
0690         return err;
0691     saa_writel(reg,value);
0692     err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR);
0693     if (err < 0)
0694         return err;
0695     return 0;
0696 }
0697 
0698 static int getstereo_7133(struct saa7134_dev *dev)
0699 {
0700     int retval = V4L2_TUNER_SUB_MONO;
0701     u32 value;
0702 
0703     value = saa_readl(0x528 >> 2);
0704     if (value & 0x20)
0705         retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
0706     if (value & 0x40)
0707         retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
0708     return retval;
0709 }
0710 
0711 static int mute_input_7133(struct saa7134_dev *dev)
0712 {
0713     u32 reg = 0;
0714     u32 xbarin, xbarout;
0715     int mask;
0716     struct saa7134_input *in;
0717 
0718     xbarin = 0x03;
0719     switch (dev->input->amux) {
0720     case TV:
0721         reg = 0x02;
0722         xbarin = 0;
0723         break;
0724     case LINE1:
0725         reg = 0x00;
0726         break;
0727     case LINE2:
0728     case LINE2_LEFT:
0729         reg = 0x09;
0730         break;
0731     }
0732     saa_dsp_writel(dev, 0x464 >> 2, xbarin);
0733     if (dev->ctl_mute) {
0734         reg = 0x07;
0735         xbarout = 0xbbbbbb;
0736     } else
0737         xbarout = 0xbbbb10;
0738     saa_dsp_writel(dev, 0x46c >> 2, xbarout);
0739 
0740     saa_writel(0x594 >> 2, reg);
0741 
0742 
0743     /* switch gpio-connected external audio mux */
0744     if (0 != card(dev).gpiomask) {
0745         mask = card(dev).gpiomask;
0746 
0747         if (card(dev).mute.type && dev->ctl_mute)
0748             in = &card(dev).mute;
0749         else
0750             in = dev->input;
0751 
0752         saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   mask, mask);
0753         saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, mask, in->gpio);
0754         saa7134_track_gpio(dev, saa7134_input_name[in->type]);
0755     }
0756 
0757     return 0;
0758 }
0759 
0760 static int tvaudio_thread_ddep(void *data)
0761 {
0762     struct saa7134_dev *dev = data;
0763     u32 value, norms;
0764 
0765     set_freezable();
0766     for (;;) {
0767         tvaudio_sleep(dev,-1);
0768         if (kthread_should_stop())
0769             goto done;
0770     restart:
0771         try_to_freeze();
0772 
0773         dev->thread.scan1 = dev->thread.scan2;
0774         audio_dbg(1, "tvaudio thread scan start [%d]\n",
0775               dev->thread.scan1);
0776 
0777         if (audio_ddep >= 0x04 && audio_ddep <= 0x0e) {
0778             /* insmod option override */
0779             norms = (audio_ddep << 2) | 0x01;
0780             audio_dbg(1, "ddep override: %s\n",
0781                   stdres[audio_ddep]);
0782         } else if (&card(dev).radio == dev->input) {
0783             audio_dbg(1, "FM Radio\n");
0784             if (dev->tuner_type == TUNER_PHILIPS_TDA8290) {
0785                 norms = (0x11 << 2) | 0x01;
0786                 /* set IF frequency to 5.5 MHz */
0787                 saa_dsp_writel(dev, 0x42c >> 2, 0x729555);
0788             } else {
0789                 norms = (0x0f << 2) | 0x01;
0790             }
0791         } else {
0792             /* (let chip) scan for sound carrier */
0793             norms = 0;
0794             if (dev->tvnorm->id & (V4L2_STD_B | V4L2_STD_GH))
0795                 norms |= 0x04;
0796             if (dev->tvnorm->id & V4L2_STD_PAL_I)
0797                 norms |= 0x20;
0798             if (dev->tvnorm->id & V4L2_STD_DK)
0799                 norms |= 0x08;
0800             if (dev->tvnorm->id & V4L2_STD_MN)
0801                 norms |= 0x40;
0802             if (dev->tvnorm->id & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC))
0803                 norms |= 0x10;
0804             if (0 == norms)
0805                 norms = 0x7c; /* all */
0806             audio_dbg(1, "scanning:%s%s%s%s%s\n",
0807                   (norms & 0x04) ? " B/G"  : "",
0808                   (norms & 0x08) ? " D/K"  : "",
0809                   (norms & 0x10) ? " L/L'" : "",
0810                   (norms & 0x20) ? " I"    : "",
0811                   (norms & 0x40) ? " M"    : "");
0812         }
0813 
0814         /* kick automatic standard detection */
0815         saa_dsp_writel(dev, 0x454 >> 2, 0);
0816         saa_dsp_writel(dev, 0x454 >> 2, norms | 0x80);
0817 
0818         /* setup crossbars */
0819         saa_dsp_writel(dev, 0x464 >> 2, 0x000000);
0820         saa_dsp_writel(dev, 0x470 >> 2, 0x101010);
0821 
0822         if (tvaudio_sleep(dev,3000))
0823             goto restart;
0824         value = saa_readl(0x528 >> 2) & 0xffffff;
0825 
0826         audio_dbg(1, "tvaudio thread status: 0x%x [%s%s%s]\n",
0827               value, stdres[value & 0x1f],
0828               (value & 0x000020) ? ",stereo" : "",
0829               (value & 0x000040) ? ",dual"   : "");
0830         audio_dbg(1, "detailed status: %s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n",
0831               (value & 0x000080) ? " A2/EIAJ pilot tone "     : "",
0832               (value & 0x000100) ? " A2/EIAJ dual "           : "",
0833               (value & 0x000200) ? " A2/EIAJ stereo "         : "",
0834               (value & 0x000400) ? " A2/EIAJ noise mute "     : "",
0835 
0836               (value & 0x000800) ? " BTSC/FM radio pilot "    : "",
0837               (value & 0x001000) ? " SAP carrier "            : "",
0838               (value & 0x002000) ? " BTSC stereo noise mute " : "",
0839               (value & 0x004000) ? " SAP noise mute "         : "",
0840               (value & 0x008000) ? " VDSP "                   : "",
0841 
0842               (value & 0x010000) ? " NICST "                  : "",
0843               (value & 0x020000) ? " NICDU "                  : "",
0844               (value & 0x040000) ? " NICAM muted "            : "",
0845               (value & 0x080000) ? " NICAM reserve sound "    : "",
0846 
0847               (value & 0x100000) ? " init done "              : "");
0848     }
0849 
0850  done:
0851     dev->thread.stopped = 1;
0852     return 0;
0853 }
0854 
0855 /* ------------------------------------------------------------------ */
0856 /* common stuff + external entry points                               */
0857 
0858 void saa7134_enable_i2s(struct saa7134_dev *dev)
0859 {
0860     int i2s_format;
0861 
0862     if (!card_is_empress(dev))
0863         return;
0864 
0865     if (dev->pci->device == PCI_DEVICE_ID_PHILIPS_SAA7130)
0866         return;
0867 
0868     /* configure GPIO for out */
0869     saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x0E000000, 0x00000000);
0870 
0871     switch (dev->pci->device) {
0872     case PCI_DEVICE_ID_PHILIPS_SAA7133:
0873     case PCI_DEVICE_ID_PHILIPS_SAA7135:
0874         /* Set I2S format (SONY) */
0875         saa_writeb(SAA7133_I2S_AUDIO_CONTROL, 0x00);
0876         /* Start I2S */
0877         saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x11);
0878         break;
0879 
0880     case PCI_DEVICE_ID_PHILIPS_SAA7134:
0881         i2s_format = (dev->input->amux == TV) ? 0x00 : 0x01;
0882 
0883         /* enable I2S audio output for the mpeg encoder */
0884         saa_writeb(SAA7134_I2S_OUTPUT_SELECT, 0x80);
0885         saa_writeb(SAA7134_I2S_OUTPUT_FORMAT, i2s_format);
0886         saa_writeb(SAA7134_I2S_OUTPUT_LEVEL,  0x0F);
0887         saa_writeb(SAA7134_I2S_AUDIO_OUTPUT,  0x01);
0888         break;
0889 
0890     default:
0891         break;
0892     }
0893 }
0894 
0895 int saa7134_tvaudio_rx2mode(u32 rx)
0896 {
0897     u32 mode;
0898 
0899     mode = V4L2_TUNER_MODE_MONO;
0900     if (rx & V4L2_TUNER_SUB_STEREO)
0901         mode = V4L2_TUNER_MODE_STEREO;
0902     else if (rx & V4L2_TUNER_SUB_LANG1)
0903         mode = V4L2_TUNER_MODE_LANG1;
0904     else if (rx & V4L2_TUNER_SUB_LANG2)
0905         mode = V4L2_TUNER_MODE_LANG2;
0906     return mode;
0907 }
0908 
0909 void saa7134_tvaudio_setmute(struct saa7134_dev *dev)
0910 {
0911     switch (dev->pci->device) {
0912     case PCI_DEVICE_ID_PHILIPS_SAA7130:
0913     case PCI_DEVICE_ID_PHILIPS_SAA7134:
0914         mute_input_7134(dev);
0915         break;
0916     case PCI_DEVICE_ID_PHILIPS_SAA7133:
0917     case PCI_DEVICE_ID_PHILIPS_SAA7135:
0918         mute_input_7133(dev);
0919         break;
0920     }
0921 }
0922 
0923 void saa7134_tvaudio_setinput(struct saa7134_dev *dev,
0924                   struct saa7134_input *in)
0925 {
0926     dev->input = in;
0927     switch (dev->pci->device) {
0928     case PCI_DEVICE_ID_PHILIPS_SAA7130:
0929     case PCI_DEVICE_ID_PHILIPS_SAA7134:
0930         mute_input_7134(dev);
0931         break;
0932     case PCI_DEVICE_ID_PHILIPS_SAA7133:
0933     case PCI_DEVICE_ID_PHILIPS_SAA7135:
0934         mute_input_7133(dev);
0935         break;
0936     }
0937     saa7134_enable_i2s(dev);
0938 }
0939 
0940 void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level)
0941 {
0942     switch (dev->pci->device) {
0943     case PCI_DEVICE_ID_PHILIPS_SAA7134:
0944         saa_writeb(SAA7134_CHANNEL1_LEVEL,     level & 0x1f);
0945         saa_writeb(SAA7134_CHANNEL2_LEVEL,     level & 0x1f);
0946         saa_writeb(SAA7134_NICAM_LEVEL_ADJUST, level & 0x1f);
0947         break;
0948     }
0949 }
0950 
0951 int saa7134_tvaudio_getstereo(struct saa7134_dev *dev)
0952 {
0953     int retval = V4L2_TUNER_SUB_MONO;
0954 
0955     switch (dev->pci->device) {
0956     case PCI_DEVICE_ID_PHILIPS_SAA7134:
0957         if (dev->tvaudio)
0958             retval = tvaudio_getstereo(dev,dev->tvaudio);
0959         break;
0960     case PCI_DEVICE_ID_PHILIPS_SAA7133:
0961     case PCI_DEVICE_ID_PHILIPS_SAA7135:
0962         retval = getstereo_7133(dev);
0963         break;
0964     }
0965     return retval;
0966 }
0967 
0968 void saa7134_tvaudio_init(struct saa7134_dev *dev)
0969 {
0970     int clock = saa7134_boards[dev->board].audio_clock;
0971 
0972     if (UNSET != audio_clock_override)
0973         clock = audio_clock_override;
0974 
0975     switch (dev->pci->device) {
0976     case PCI_DEVICE_ID_PHILIPS_SAA7134:
0977         /* init all audio registers */
0978         saa_writeb(SAA7134_AUDIO_PLL_CTRL,   0x00);
0979         if (need_resched())
0980             schedule();
0981         else
0982             udelay(10);
0983 
0984         saa_writeb(SAA7134_AUDIO_CLOCK0,      clock        & 0xff);
0985         saa_writeb(SAA7134_AUDIO_CLOCK1,     (clock >>  8) & 0xff);
0986         saa_writeb(SAA7134_AUDIO_CLOCK2,     (clock >> 16) & 0xff);
0987         /* frame locked audio is mandatory for NICAM */
0988         saa_writeb(SAA7134_AUDIO_PLL_CTRL,   0x01);
0989         saa_writeb(SAA7134_NICAM_ERROR_LOW,  0x14);
0990         saa_writeb(SAA7134_NICAM_ERROR_HIGH, 0x50);
0991         break;
0992     case PCI_DEVICE_ID_PHILIPS_SAA7133:
0993     case PCI_DEVICE_ID_PHILIPS_SAA7135:
0994         saa_writel(0x598 >> 2, clock);
0995         saa_dsp_writel(dev, 0x474 >> 2, 0x00);
0996         saa_dsp_writel(dev, 0x450 >> 2, 0x00);
0997     }
0998 }
0999 
1000 int saa7134_tvaudio_init2(struct saa7134_dev *dev)
1001 {
1002     int (*my_thread)(void *data) = NULL;
1003 
1004     switch (dev->pci->device) {
1005     case PCI_DEVICE_ID_PHILIPS_SAA7134:
1006         my_thread = tvaudio_thread;
1007         break;
1008     case PCI_DEVICE_ID_PHILIPS_SAA7133:
1009     case PCI_DEVICE_ID_PHILIPS_SAA7135:
1010         my_thread = tvaudio_thread_ddep;
1011         break;
1012     }
1013 
1014     dev->thread.thread = NULL;
1015     dev->thread.scan1 = dev->thread.scan2 = 0;
1016     if (my_thread) {
1017         saa7134_tvaudio_init(dev);
1018         /* start tvaudio thread */
1019         dev->thread.thread = kthread_run(my_thread, dev, "%s", dev->name);
1020         if (IS_ERR(dev->thread.thread)) {
1021             pr_warn("%s: kernel_thread() failed\n",
1022                    dev->name);
1023             /* XXX: missing error handling here */
1024         }
1025     }
1026 
1027     saa7134_enable_i2s(dev);
1028     return 0;
1029 }
1030 
1031 int saa7134_tvaudio_close(struct saa7134_dev *dev)
1032 {
1033     dev->automute = 1;
1034     /* anything else to undo? */
1035     return 0;
1036 }
1037 
1038 int saa7134_tvaudio_fini(struct saa7134_dev *dev)
1039 {
1040     /* shutdown tvaudio thread */
1041     if (dev->thread.thread && !dev->thread.stopped)
1042         kthread_stop(dev->thread.thread);
1043 
1044     saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, 0x00); /* LINE1 */
1045     return 0;
1046 }
1047 
1048 int saa7134_tvaudio_do_scan(struct saa7134_dev *dev)
1049 {
1050     if (dev->input->amux != TV) {
1051         audio_dbg(1, "sound IF not in use, skipping scan\n");
1052         dev->automute = 0;
1053         saa7134_tvaudio_setmute(dev);
1054     } else if (dev->thread.thread) {
1055         dev->thread.mode = UNSET;
1056         dev->thread.scan2++;
1057 
1058         if (!dev->insuspend && !dev->thread.stopped)
1059             wake_up_process(dev->thread.thread);
1060     } else {
1061         dev->automute = 0;
1062         saa7134_tvaudio_setmute(dev);
1063     }
1064     return 0;
1065 }
1066 
1067 EXPORT_SYMBOL(saa_dsp_writel);
1068 EXPORT_SYMBOL(saa7134_tvaudio_setmute);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!