git.oblomov.eu Git - linux-2.6/blob - drivers/media/dvb/ttpci/av7110_v4l.c

   1 /*
   2  * av7110_v4l.c: av7110 video4linux interface for DVB and Siemens DVB-C analog module
   3  *
   4  * Copyright (C) 1999-2002 Ralph  Metzler
   5  *                       & Marcus Metzler for convergence integrated media GmbH
   6  *
   7  * originally based on code by:
   8  * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * the project's page is at http://www.linuxtv.org/dvb/
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/types.h>
  30 #include <linux/delay.h>
  31 #include <linux/fs.h>
  32 #include <linux/timer.h>
  33 #include <linux/poll.h>
  34
  35 #include "av7110.h"
  36 #include "av7110_hw.h"
  37 #include "av7110_av.h"
  38
  39 int msp_writereg(struct av7110 *av7110, u8 dev, u16 reg, u16 val)
  40 {
  41         u8 msg[5] = { dev, reg >> 8, reg & 0xff, val >> 8 , val & 0xff };
  42         struct i2c_msg msgs = { .flags = 0, .len = 5, .buf = msg };
  43
  44         switch (av7110->adac_type) {
  45         case DVB_ADAC_MSP34x0:
  46                 msgs.addr = 0x40;
  47                 break;
  48         case DVB_ADAC_MSP34x5:
  49                 msgs.addr = 0x42;
  50                 break;
  51         default:
  52                 return 0;
  53         }
  54
  55         if (i2c_transfer(&av7110->i2c_adap, &msgs, 1) != 1) {
  56                 dprintk(1, "dvb-ttpci: failed @ card %d, %u = %u\n",
  57                        av7110->dvb_adapter.num, reg, val);
  58                 return -EIO;
  59         }
  60         return 0;
  61 }
  62
  63 static int msp_readreg(struct av7110 *av7110, u8 dev, u16 reg, u16 *val)
  64 {
  65         u8 msg1[3] = { dev, reg >> 8, reg & 0xff };
  66         u8 msg2[2];
  67         struct i2c_msg msgs[2] = {
  68                 { .flags = 0       , .len = 3, .buf = msg1 },
  69                 { .flags = I2C_M_RD, .len = 2, .buf = msg2 }
  70         };
  71
  72         switch (av7110->adac_type) {
  73         case DVB_ADAC_MSP34x0:
  74                 msgs[0].addr = 0x40;
  75                 msgs[1].addr = 0x40;
  76                 break;
  77         case DVB_ADAC_MSP34x5:
  78                 msgs[0].addr = 0x42;
  79                 msgs[1].addr = 0x42;
  80                 break;
  81         default:
  82                 return 0;
  83         }
  84
  85         if (i2c_transfer(&av7110->i2c_adap, &msgs[0], 2) != 2) {
  86                 dprintk(1, "dvb-ttpci: failed @ card %d, %u\n",
  87                        av7110->dvb_adapter.num, reg);
  88                 return -EIO;
  89         }
  90         *val = (msg2[0] << 8) | msg2[1];
  91         return 0;
  92 }
  93
  94 static struct v4l2_input inputs[4] = {
  95         {
  96                 .index          = 0,
  97                 .name           = "DVB",
  98                 .type           = V4L2_INPUT_TYPE_CAMERA,
  99                 .audioset       = 1,
 100                 .tuner          = 0, /* ignored */
 101                 .std            = V4L2_STD_PAL_BG|V4L2_STD_NTSC_M,
 102                 .status         = 0,
 103         }, {
 104                 .index          = 1,
 105                 .name           = "Television",
 106                 .type           = V4L2_INPUT_TYPE_TUNER,
 107                 .audioset       = 2,
 108                 .tuner          = 0,
 109                 .std            = V4L2_STD_PAL_BG|V4L2_STD_NTSC_M,
 110                 .status         = 0,
 111         }, {
 112                 .index          = 2,
 113                 .name           = "Video",
 114                 .type           = V4L2_INPUT_TYPE_CAMERA,
 115                 .audioset       = 0,
 116                 .tuner          = 0,
 117                 .std            = V4L2_STD_PAL_BG|V4L2_STD_NTSC_M,
 118                 .status         = 0,
 119         }, {
 120                 .index          = 3,
 121                 .name           = "Y/C",
 122                 .type           = V4L2_INPUT_TYPE_CAMERA,
 123                 .audioset       = 0,
 124                 .tuner          = 0,
 125                 .std            = V4L2_STD_PAL_BG|V4L2_STD_NTSC_M,
 126                 .status         = 0,
 127         }
 128 };
 129
 130 static int ves1820_writereg(struct saa7146_dev *dev, u8 addr, u8 reg, u8 data)
 131 {
 132         struct av7110 *av7110 = dev->ext_priv;
 133         u8 buf[] = { 0x00, reg, data };
 134         struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = buf, .len = 3 };
 135
 136         dprintk(4, "dev: %p\n", dev);
 137
 138         if (1 != i2c_transfer(&av7110->i2c_adap, &msg, 1))
 139                 return -1;
 140         return 0;
 141 }
 142
 143 static int tuner_write(struct saa7146_dev *dev, u8 addr, u8 data [4])
 144 {
 145         struct av7110 *av7110 = dev->ext_priv;
 146         struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = data, .len = 4 };
 147
 148         dprintk(4, "dev: %p\n", dev);
 149
 150         if (1 != i2c_transfer(&av7110->i2c_adap, &msg, 1))
 151                 return -1;
 152         return 0;
 153 }
 154
 155 static int ves1820_set_tv_freq(struct saa7146_dev *dev, u32 freq)
 156 {
 157         u32 div;
 158         u8 config;
 159         u8 buf[4];
 160
 161         dprintk(4, "freq: 0x%08x\n", freq);
 162
 163         /* magic number: 614. tuning with the frequency given by v4l2
 164            is always off by 614*62.5 = 38375 kHz...*/
 165         div = freq + 614;
 166
 167         buf[0] = (div >> 8) & 0x7f;
 168         buf[1] = div & 0xff;
 169         buf[2] = 0x8e;
 170
 171         if (freq < (u32) (16 * 168.25))
 172                 config = 0xa0;
 173         else if (freq < (u32) (16 * 447.25))
 174                 config = 0x90;
 175         else
 176                 config = 0x30;
 177         config &= ~0x02;
 178
 179         buf[3] = config;
 180
 181         return tuner_write(dev, 0x61, buf);
 182 }
 183
 184 static int stv0297_set_tv_freq(struct saa7146_dev *dev, u32 freq)
 185 {
 186         struct av7110 *av7110 = (struct av7110*)dev->ext_priv;
 187         u32 div;
 188         u8 data[4];
 189
 190         div = (freq + 38900000 + 31250) / 62500;
 191
 192         data[0] = (div >> 8) & 0x7f;
 193         data[1] = div & 0xff;
 194         data[2] = 0xce;
 195
 196         if (freq < 45000000)
 197                 return -EINVAL;
 198         else if (freq < 137000000)
 199                 data[3] = 0x01;
 200         else if (freq < 403000000)
 201                 data[3] = 0x02;
 202         else if (freq < 860000000)
 203                 data[3] = 0x04;
 204         else
 205                 return -EINVAL;
 206
 207         if (av7110->fe->ops.i2c_gate_ctrl)
 208                 av7110->fe->ops.i2c_gate_ctrl(av7110->fe, 1);
 209         return tuner_write(dev, 0x63, data);
 210 }
 211
 212
 213
 214 static struct saa7146_standard analog_standard[];
 215 static struct saa7146_standard dvb_standard[];
 216 static struct saa7146_standard standard[];
 217
 218 static struct v4l2_audio msp3400_v4l2_audio = {
 219         .index = 0,
 220         .name = "Television",
 221         .capability = V4L2_AUDCAP_STEREO
 222 };
 223
 224 static int av7110_dvb_c_switch(struct saa7146_fh *fh)
 225 {
 226         struct saa7146_dev *dev = fh->dev;
 227         struct saa7146_vv *vv = dev->vv_data;
 228         struct av7110 *av7110 = (struct av7110*)dev->ext_priv;
 229         u16 adswitch;
 230         int source, sync, err;
 231
 232         dprintk(4, "%p\n", av7110);
 233
 234         if ((vv->video_status & STATUS_OVERLAY) != 0) {
 235                 vv->ov_suspend = vv->video_fh;
 236                 err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */
 237                 if (err != 0) {
 238                         dprintk(2, "suspending video failed\n");
 239                         vv->ov_suspend = NULL;
 240                 }
 241         }
 242
 243         if (0 != av7110->current_input) {
 244                 dprintk(1, "switching to analog TV:\n");
 245                 adswitch = 1;
 246                 source = SAA7146_HPS_SOURCE_PORT_B;
 247                 sync = SAA7146_HPS_SYNC_PORT_B;
 248                 memcpy(standard, analog_standard, sizeof(struct saa7146_standard) * 2);
 249
 250                 switch (av7110->current_input) {
 251                 case 1:
 252                         dprintk(1, "switching SAA7113 to Analog Tuner Input.\n");
 253                         msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0000); // loudspeaker source
 254                         msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0000); // headphone source
 255                         msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0000); // SCART 1 source
 256                         msp_writereg(av7110, MSP_WR_DSP, 0x000e, 0x3000); // FM matrix, mono
 257                         msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x4f00); // loudspeaker + headphone
 258                         msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x4f00); // SCART 1 volume
 259
 260                         if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
 261                                 if (ves1820_writereg(dev, 0x09, 0x0f, 0x60))
 262                                         dprintk(1, "setting band in demodulator failed.\n");
 263                         } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
 264                                 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // TDA9819 pin9(STD)
 265                                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI); // TDA9819 pin30(VIF)
 266                         }
 267                         if (i2c_writereg(av7110, 0x48, 0x02, 0xd0) != 1)
 268                                 dprintk(1, "saa7113 write failed @ card %d", av7110->dvb_adapter.num);
 269                         break;
 270                 case 2:
 271                         dprintk(1, "switching SAA7113 to Video AV CVBS Input.\n");
 272                         if (i2c_writereg(av7110, 0x48, 0x02, 0xd2) != 1)
 273                                 dprintk(1, "saa7113 write failed @ card %d", av7110->dvb_adapter.num);
 274                         break;
 275                 case 3:
 276                         dprintk(1, "switching SAA7113 to Video AV Y/C Input.\n");
 277                         if (i2c_writereg(av7110, 0x48, 0x02, 0xd9) != 1)
 278                                 dprintk(1, "saa7113 write failed @ card %d", av7110->dvb_adapter.num);
 279                         break;
 280                 default:
 281                         dprintk(1, "switching SAA7113 to Input: AV7110: SAA7113: invalid input.\n");
 282                 }
 283         } else {
 284                 adswitch = 0;
 285                 source = SAA7146_HPS_SOURCE_PORT_A;
 286                 sync = SAA7146_HPS_SYNC_PORT_A;
 287                 memcpy(standard, dvb_standard, sizeof(struct saa7146_standard) * 2);
 288                 dprintk(1, "switching DVB mode\n");
 289                 msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220); // loudspeaker source
 290                 msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0220); // headphone source
 291                 msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0220); // SCART 1 source
 292                 msp_writereg(av7110, MSP_WR_DSP, 0x000e, 0x3000); // FM matrix, mono
 293                 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x7f00); // loudspeaker + headphone
 294                 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x7f00); // SCART 1 volume
 295
 296                 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
 297                         if (ves1820_writereg(dev, 0x09, 0x0f, 0x20))
 298                                 dprintk(1, "setting band in demodulator failed.\n");
 299                 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
 300                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
 301                         saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
 302                 }
 303         }
 304
 305         /* hmm, this does not do anything!? */
 306         if (av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, adswitch))
 307                 dprintk(1, "ADSwitch error\n");
 308
 309         saa7146_set_hps_source_and_sync(dev, source, sync);
 310
 311         if (vv->ov_suspend != NULL) {
 312                 saa7146_start_preview(vv->ov_suspend);
 313                 vv->ov_suspend = NULL;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *t)
 320 {
 321         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 322         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 323         u16 stereo_det;
 324         s8 stereo;
 325
 326         dprintk(2, "VIDIOC_G_TUNER: %d\n", t->index);
 327
 328         if (!av7110->analog_tuner_flags || t->index != 0)
 329                 return -EINVAL;
 330
 331         memset(t, 0, sizeof(*t));
 332         strcpy((char *)t->name, "Television");
 333
 334         t->type = V4L2_TUNER_ANALOG_TV;
 335         t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO |
 336                 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
 337         t->rangelow = 772;      /* 48.25 MHZ / 62.5 kHz = 772, see fi1216mk2-specs, page 2 */
 338         t->rangehigh = 13684;   /* 855.25 MHz / 62.5 kHz = 13684 */
 339         /* FIXME: add the real signal strength here */
 340         t->signal = 0xffff;
 341         t->afc = 0;
 342
 343         /* FIXME: standard / stereo detection is still broken */
 344         msp_readreg(av7110, MSP_RD_DEM, 0x007e, &stereo_det);
 345         dprintk(1, "VIDIOC_G_TUNER: msp3400 TV standard detection: 0x%04x\n", stereo_det);
 346         msp_readreg(av7110, MSP_RD_DSP, 0x0018, &stereo_det);
 347         dprintk(1, "VIDIOC_G_TUNER: msp3400 stereo detection: 0x%04x\n", stereo_det);
 348         stereo = (s8)(stereo_det >> 8);
 349         if (stereo > 0x10) {
 350                 /* stereo */
 351                 t->rxsubchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_MONO;
 352                 t->audmode = V4L2_TUNER_MODE_STEREO;
 353         } else if (stereo < -0x10) {
 354                 /* bilingual */
 355                 t->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
 356                 t->audmode = V4L2_TUNER_MODE_LANG1;
 357         } else /* mono */
 358                 t->rxsubchans = V4L2_TUNER_SUB_MONO;
 359
 360         return 0;
 361 }
 362
 363 static int vidioc_s_tuner(struct file *file, void *fh, struct v4l2_tuner *t)
 364 {
 365         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 366         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 367         u16 fm_matrix, src;
 368         dprintk(2, "VIDIOC_S_TUNER: %d\n", t->index);
 369
 370         if (!av7110->analog_tuner_flags || av7110->current_input != 1)
 371                 return -EINVAL;
 372
 373         switch (t->audmode) {
 374         case V4L2_TUNER_MODE_STEREO:
 375                 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_STEREO\n");
 376                 fm_matrix = 0x3001; /* stereo */
 377                 src = 0x0020;
 378                 break;
 379         case V4L2_TUNER_MODE_LANG1_LANG2:
 380                 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1_LANG2\n");
 381                 fm_matrix = 0x3000; /* bilingual */
 382                 src = 0x0020;
 383                 break;
 384         case V4L2_TUNER_MODE_LANG1:
 385                 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1\n");
 386                 fm_matrix = 0x3000; /* mono */
 387                 src = 0x0000;
 388                 break;
 389         case V4L2_TUNER_MODE_LANG2:
 390                 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG2\n");
 391                 fm_matrix = 0x3000; /* mono */
 392                 src = 0x0010;
 393                 break;
 394         default: /* case V4L2_TUNER_MODE_MONO: */
 395                 dprintk(2, "VIDIOC_S_TUNER: TDA9840_SET_MONO\n");
 396                 fm_matrix = 0x3000; /* mono */
 397                 src = 0x0030;
 398                 break;
 399         }
 400         msp_writereg(av7110, MSP_WR_DSP, 0x000e, fm_matrix);
 401         msp_writereg(av7110, MSP_WR_DSP, 0x0008, src);
 402         msp_writereg(av7110, MSP_WR_DSP, 0x0009, src);
 403         msp_writereg(av7110, MSP_WR_DSP, 0x000a, src);
 404         return 0;
 405 }
 406
 407 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *f)
 408 {
 409         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 410         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 411
 412         dprintk(2, "VIDIOC_G_FREQ: freq:0x%08x.\n", f->frequency);
 413
 414         if (!av7110->analog_tuner_flags || av7110->current_input != 1)
 415                 return -EINVAL;
 416
 417         memset(f, 0, sizeof(*f));
 418         f->type = V4L2_TUNER_ANALOG_TV;
 419         f->frequency =  av7110->current_freq;
 420         return 0;
 421 }
 422
 423 static int vidioc_s_frequency(struct file *file, void *fh, struct v4l2_frequency *f)
 424 {
 425         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 426         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 427
 428         dprintk(2, "VIDIOC_S_FREQUENCY: freq:0x%08x.\n", f->frequency);
 429
 430         if (!av7110->analog_tuner_flags || av7110->current_input != 1)
 431                 return -EINVAL;
 432
 433         if (V4L2_TUNER_ANALOG_TV != f->type)
 434                 return -EINVAL;
 435
 436         msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0xffe0); /* fast mute */
 437         msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0xffe0);
 438
 439         /* tune in desired frequency */
 440         if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820)
 441                 ves1820_set_tv_freq(dev, f->frequency);
 442         else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297)
 443                 stv0297_set_tv_freq(dev, f->frequency);
 444         av7110->current_freq = f->frequency;
 445
 446         msp_writereg(av7110, MSP_WR_DSP, 0x0015, 0x003f); /* start stereo detection */
 447         msp_writereg(av7110, MSP_WR_DSP, 0x0015, 0x0000);
 448         msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x4f00); /* loudspeaker + headphone */
 449         msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x4f00); /* SCART 1 volume */
 450         return 0;
 451 }
 452
 453 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
 454 {
 455         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 456         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 457
 458         dprintk(2, "VIDIOC_ENUMINPUT: %d\n", i->index);
 459
 460         if (av7110->analog_tuner_flags) {
 461                 if (i->index < 0 || i->index >= 4)
 462                         return -EINVAL;
 463         } else {
 464                 if (i->index != 0)
 465                         return -EINVAL;
 466         }
 467
 468         memcpy(i, &inputs[i->index], sizeof(struct v4l2_input));
 469
 470         return 0;
 471 }
 472
 473 static int vidioc_g_input(struct file *file, void *fh, unsigned int *input)
 474 {
 475         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 476         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 477
 478         *input = av7110->current_input;
 479         dprintk(2, "VIDIOC_G_INPUT: %d\n", *input);
 480         return 0;
 481 }
 482
 483 static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
 484 {
 485         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 486         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 487
 488         dprintk(2, "VIDIOC_S_INPUT: %d\n", input);
 489
 490         if (!av7110->analog_tuner_flags)
 491                 return 0;
 492
 493         if (input < 0 || input >= 4)
 494                 return -EINVAL;
 495
 496         av7110->current_input = input;
 497         return av7110_dvb_c_switch(fh);
 498 }
 499
 500 static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
 501 {
 502         dprintk(2, "VIDIOC_G_AUDIO: %d\n", a->index);
 503         if (a->index != 0)
 504                 return -EINVAL;
 505         memcpy(a, &msp3400_v4l2_audio, sizeof(struct v4l2_audio));
 506         return 0;
 507 }
 508
 509 static int vidioc_s_audio(struct file *file, void *fh, struct v4l2_audio *a)
 510 {
 511         dprintk(2, "VIDIOC_S_AUDIO: %d\n", a->index);
 512         return 0;
 513 }
 514
 515 static int vidioc_g_sliced_vbi_cap(struct file *file, void *fh,
 516                                         struct v4l2_sliced_vbi_cap *cap)
 517 {
 518         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 519         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 520
 521         dprintk(2, "VIDIOC_G_SLICED_VBI_CAP\n");
 522         if (cap->type != V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
 523                 return -EINVAL;
 524         if (FW_VERSION(av7110->arm_app) >= 0x2623) {
 525                 cap->service_set = V4L2_SLICED_WSS_625;
 526                 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
 527         }
 528         return 0;
 529 }
 530
 531 static int vidioc_g_fmt_sliced_vbi_out(struct file *file, void *fh,
 532                                         struct v4l2_format *f)
 533 {
 534         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 535         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 536
 537         dprintk(2, "VIDIOC_G_FMT:\n");
 538         if (FW_VERSION(av7110->arm_app) < 0x2623)
 539                 return -EINVAL;
 540         memset(&f->fmt.sliced, 0, sizeof f->fmt.sliced);
 541         if (av7110->wssMode) {
 542                 f->fmt.sliced.service_set = V4L2_SLICED_WSS_625;
 543                 f->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
 544                 f->fmt.sliced.io_size = sizeof(struct v4l2_sliced_vbi_data);
 545         }
 546         return 0;
 547 }
 548
 549 static int vidioc_s_fmt_sliced_vbi_out(struct file *file, void *fh,
 550                                         struct v4l2_format *f)
 551 {
 552         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 553         struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
 554
 555         dprintk(2, "VIDIOC_S_FMT\n");
 556         if (FW_VERSION(av7110->arm_app) < 0x2623)
 557                 return -EINVAL;
 558         if (f->fmt.sliced.service_set != V4L2_SLICED_WSS_625 &&
 559             f->fmt.sliced.service_lines[0][23] != V4L2_SLICED_WSS_625) {
 560                 memset(&f->fmt.sliced, 0, sizeof(f->fmt.sliced));
 561                 /* WSS controlled by firmware */
 562                 av7110->wssMode = 0;
 563                 av7110->wssData = 0;
 564                 return av7110_fw_cmd(av7110, COMTYPE_ENCODER,
 565                                      SetWSSConfig, 1, 0);
 566         } else {
 567                 memset(&f->fmt.sliced, 0, sizeof(f->fmt.sliced));
 568                 f->fmt.sliced.service_set = V4L2_SLICED_WSS_625;
 569                 f->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
 570                 f->fmt.sliced.io_size = sizeof(struct v4l2_sliced_vbi_data);
 571                 /* WSS controlled by userspace */
 572                 av7110->wssMode = 1;
 573                 av7110->wssData = 0;
 574         }
 575         return 0;
 576 }
 577
 578 static int av7110_vbi_reset(struct file *file)
 579 {
 580         struct saa7146_fh *fh = file->private_data;
 581         struct saa7146_dev *dev = fh->dev;
 582         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
 583
 584         dprintk(2, "%s\n", __func__);
 585         av7110->wssMode = 0;
 586         av7110->wssData = 0;
 587         if (FW_VERSION(av7110->arm_app) < 0x2623)
 588                 return 0;
 589         else
 590                 return av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 1, 0);
 591 }
 592
 593 static ssize_t av7110_vbi_write(struct file *file, const char __user *data, size_t count, loff_t *ppos)
 594 {
 595         struct saa7146_fh *fh = file->private_data;
 596         struct saa7146_dev *dev = fh->dev;
 597         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
 598         struct v4l2_sliced_vbi_data d;
 599         int rc;
 600
 601         dprintk(2, "%s\n", __func__);
 602         if (FW_VERSION(av7110->arm_app) < 0x2623 || !av7110->wssMode || count != sizeof d)
 603                 return -EINVAL;
 604         if (copy_from_user(&d, data, count))
 605                 return -EFAULT;
 606         if ((d.id != 0 && d.id != V4L2_SLICED_WSS_625) || d.field != 0 || d.line != 23)
 607                 return -EINVAL;
 608         if (d.id)
 609                 av7110->wssData = ((d.data[1] << 8) & 0x3f00) | d.data[0];
 610         else
 611                 av7110->wssData = 0x8000;
 612         rc = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 1, av7110->wssData);
 613         return (rc < 0) ? rc : count;
 614 }
 615
 616 /****************************************************************************
 617  * INITIALIZATION
 618  ****************************************************************************/
 619
 620 static u8 saa7113_init_regs[] = {
 621         0x02, 0xd0,
 622         0x03, 0x23,
 623         0x04, 0x00,
 624         0x05, 0x00,
 625         0x06, 0xe9,
 626         0x07, 0x0d,
 627         0x08, 0x98,
 628         0x09, 0x02,
 629         0x0a, 0x80,
 630         0x0b, 0x40,
 631         0x0c, 0x40,
 632         0x0d, 0x00,
 633         0x0e, 0x01,
 634         0x0f, 0x7c,
 635         0x10, 0x48,
 636         0x11, 0x0c,
 637         0x12, 0x8b,
 638         0x13, 0x1a,
 639         0x14, 0x00,
 640         0x15, 0x00,
 641         0x16, 0x00,
 642         0x17, 0x00,
 643         0x18, 0x00,
 644         0x19, 0x00,
 645         0x1a, 0x00,
 646         0x1b, 0x00,
 647         0x1c, 0x00,
 648         0x1d, 0x00,
 649         0x1e, 0x00,
 650
 651         0x41, 0x77,
 652         0x42, 0x77,
 653         0x43, 0x77,
 654         0x44, 0x77,
 655         0x45, 0x77,
 656         0x46, 0x77,
 657         0x47, 0x77,
 658         0x48, 0x77,
 659         0x49, 0x77,
 660         0x4a, 0x77,
 661         0x4b, 0x77,
 662         0x4c, 0x77,
 663         0x4d, 0x77,
 664         0x4e, 0x77,
 665         0x4f, 0x77,
 666         0x50, 0x77,
 667         0x51, 0x77,
 668         0x52, 0x77,
 669         0x53, 0x77,
 670         0x54, 0x77,
 671         0x55, 0x77,
 672         0x56, 0x77,
 673         0x57, 0xff,
 674
 675         0xff
 676 };
 677
 678
 679 static struct saa7146_ext_vv av7110_vv_data_st;
 680 static struct saa7146_ext_vv av7110_vv_data_c;
 681
 682 int av7110_init_analog_module(struct av7110 *av7110)
 683 {
 684         u16 version1, version2;
 685
 686         if (i2c_writereg(av7110, 0x80, 0x0, 0x80) == 1 &&
 687             i2c_writereg(av7110, 0x80, 0x0, 0) == 1) {
 688                 printk("dvb-ttpci: DVB-C analog module @ card %d detected, initializing MSP3400\n",
 689                         av7110->dvb_adapter.num);
 690                 av7110->adac_type = DVB_ADAC_MSP34x0;
 691         } else if (i2c_writereg(av7110, 0x84, 0x0, 0x80) == 1 &&
 692                    i2c_writereg(av7110, 0x84, 0x0, 0) == 1) {
 693                 printk("dvb-ttpci: DVB-C analog module @ card %d detected, initializing MSP3415\n",
 694                         av7110->dvb_adapter.num);
 695                 av7110->adac_type = DVB_ADAC_MSP34x5;
 696         } else
 697                 return -ENODEV;
 698
 699         msleep(100); // the probing above resets the msp...
 700         msp_readreg(av7110, MSP_RD_DSP, 0x001e, &version1);
 701         msp_readreg(av7110, MSP_RD_DSP, 0x001f, &version2);
 702         dprintk(1, "dvb-ttpci: @ card %d MSP34xx version 0x%04x 0x%04x\n",
 703                 av7110->dvb_adapter.num, version1, version2);
 704         msp_writereg(av7110, MSP_WR_DSP, 0x0013, 0x0c00);
 705         msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x7f00); // loudspeaker + headphone
 706         msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220); // loudspeaker source
 707         msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0220); // headphone source
 708         msp_writereg(av7110, MSP_WR_DSP, 0x0004, 0x7f00); // loudspeaker volume
 709         msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0220); // SCART 1 source
 710         msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x7f00); // SCART 1 volume
 711         msp_writereg(av7110, MSP_WR_DSP, 0x000d, 0x1900); // prescale SCART
 712
 713         if (i2c_writereg(av7110, 0x48, 0x01, 0x00)!=1) {
 714                 INFO(("saa7113 not accessible.\n"));
 715         } else {
 716                 u8 *i = saa7113_init_regs;
 717
 718                 if ((av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
 719                         /* Fujitsu/Siemens DVB-Cable */
 720                         av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
 721                 } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x0002)) {
 722                         /* Hauppauge/TT DVB-C premium */
 723                         av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
 724                 } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x000A)) {
 725                         /* Hauppauge/TT DVB-C premium */
 726                         av7110->analog_tuner_flags |= ANALOG_TUNER_STV0297;
 727                 }
 728
 729                 /* setup for DVB by default */
 730                 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
 731                         if (ves1820_writereg(av7110->dev, 0x09, 0x0f, 0x20))
 732                                 dprintk(1, "setting band in demodulator failed.\n");
 733                 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
 734                         saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
 735                         saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
 736                 }
 737
 738                 /* init the saa7113 */
 739                 while (*i != 0xff) {
 740                         if (i2c_writereg(av7110, 0x48, i[0], i[1]) != 1) {
 741                                 dprintk(1, "saa7113 initialization failed @ card %d", av7110->dvb_adapter.num);
 742                                 break;
 743                         }
 744                         i += 2;
 745                 }
 746                 /* setup msp for analog sound: B/G Dual-FM */
 747                 msp_writereg(av7110, MSP_WR_DEM, 0x00bb, 0x02d0); // AD_CV
 748                 msp_writereg(av7110, MSP_WR_DEM, 0x0001,  3); // FIR1
 749                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 18); // FIR1
 750                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 27); // FIR1
 751                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 48); // FIR1
 752                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 66); // FIR1
 753                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 72); // FIR1
 754                 msp_writereg(av7110, MSP_WR_DEM, 0x0005,  4); // FIR2
 755                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 64); // FIR2
 756                 msp_writereg(av7110, MSP_WR_DEM, 0x0005,  0); // FIR2
 757                 msp_writereg(av7110, MSP_WR_DEM, 0x0005,  3); // FIR2
 758                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 18); // FIR2
 759                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 27); // FIR2
 760                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 48); // FIR2
 761                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 66); // FIR2
 762                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 72); // FIR2
 763                 msp_writereg(av7110, MSP_WR_DEM, 0x0083, 0xa000); // MODE_REG
 764                 msp_writereg(av7110, MSP_WR_DEM, 0x0093, 0x00aa); // DCO1_LO 5.74MHz
 765                 msp_writereg(av7110, MSP_WR_DEM, 0x009b, 0x04fc); // DCO1_HI
 766                 msp_writereg(av7110, MSP_WR_DEM, 0x00a3, 0x038e); // DCO2_LO 5.5MHz
 767                 msp_writereg(av7110, MSP_WR_DEM, 0x00ab, 0x04c6); // DCO2_HI
 768                 msp_writereg(av7110, MSP_WR_DEM, 0x0056, 0); // LOAD_REG 1/2
 769         }
 770
 771         memcpy(standard, dvb_standard, sizeof(struct saa7146_standard) * 2);
 772         /* set dd1 stream a & b */
 773         saa7146_write(av7110->dev, DD1_STREAM_B, 0x00000000);
 774         saa7146_write(av7110->dev, DD1_INIT, 0x03000700);
 775         saa7146_write(av7110->dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
 776
 777         return 0;
 778 }
 779
 780 int av7110_init_v4l(struct av7110 *av7110)
 781 {
 782         struct saa7146_dev* dev = av7110->dev;
 783         struct saa7146_ext_vv *vv_data;
 784         int ret;
 785
 786         /* special case DVB-C: these cards have an analog tuner
 787            plus need some special handling, so we have separate
 788            saa7146_ext_vv data for these... */
 789         if (av7110->analog_tuner_flags)
 790                 vv_data = &av7110_vv_data_c;
 791         else
 792                 vv_data = &av7110_vv_data_st;
 793         ret = saa7146_vv_init(dev, vv_data);
 794
 795         if (ret) {
 796                 ERR(("cannot init capture device. skipping.\n"));
 797                 return -ENODEV;
 798         }
 799         vv_data->ops.vidioc_enum_input = vidioc_enum_input;
 800         vv_data->ops.vidioc_g_input = vidioc_g_input;
 801         vv_data->ops.vidioc_s_input = vidioc_s_input;
 802         vv_data->ops.vidioc_g_tuner = vidioc_g_tuner;
 803         vv_data->ops.vidioc_s_tuner = vidioc_s_tuner;
 804         vv_data->ops.vidioc_g_frequency = vidioc_g_frequency;
 805         vv_data->ops.vidioc_s_frequency = vidioc_s_frequency;
 806         vv_data->ops.vidioc_g_audio = vidioc_g_audio;
 807         vv_data->ops.vidioc_s_audio = vidioc_s_audio;
 808         vv_data->ops.vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap;
 809         vv_data->ops.vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out;
 810         vv_data->ops.vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out;
 811
 812         if (saa7146_register_device(&av7110->v4l_dev, dev, "av7110", VFL_TYPE_GRABBER)) {
 813                 ERR(("cannot register capture device. skipping.\n"));
 814                 saa7146_vv_release(dev);
 815                 return -ENODEV;
 816         }
 817         if (saa7146_register_device(&av7110->vbi_dev, dev, "av7110", VFL_TYPE_VBI))
 818                 ERR(("cannot register vbi v4l2 device. skipping.\n"));
 819         return 0;
 820 }
 821
 822 int av7110_exit_v4l(struct av7110 *av7110)
 823 {
 824         struct saa7146_dev* dev = av7110->dev;
 825
 826         saa7146_unregister_device(&av7110->v4l_dev, av7110->dev);
 827         saa7146_unregister_device(&av7110->vbi_dev, av7110->dev);
 828
 829         saa7146_vv_release(dev);
 830
 831         return 0;
 832 }
 833
 834
 835
 836 /* FIXME: these values are experimental values that look better than the
 837    values from the latest "official" driver -- at least for me... (MiHu) */
 838 static struct saa7146_standard standard[] = {
 839         {
 840                 .name   = "PAL",        .id             = V4L2_STD_PAL_BG,
 841                 .v_offset       = 0x15, .v_field        = 288,
 842                 .h_offset       = 0x48, .h_pixels       = 708,
 843                 .v_max_out      = 576,  .h_max_out      = 768,
 844         }, {
 845                 .name   = "NTSC",       .id             = V4L2_STD_NTSC,
 846                 .v_offset       = 0x10, .v_field        = 244,
 847                 .h_offset       = 0x40, .h_pixels       = 708,
 848                 .v_max_out      = 480,  .h_max_out      = 640,
 849         }
 850 };
 851
 852 static struct saa7146_standard analog_standard[] = {
 853         {
 854                 .name   = "PAL",        .id             = V4L2_STD_PAL_BG,
 855                 .v_offset       = 0x1b, .v_field        = 288,
 856                 .h_offset       = 0x08, .h_pixels       = 708,
 857                 .v_max_out      = 576,  .h_max_out      = 768,
 858         }, {
 859                 .name   = "NTSC",       .id             = V4L2_STD_NTSC,
 860                 .v_offset       = 0x10, .v_field        = 244,
 861                 .h_offset       = 0x40, .h_pixels       = 708,
 862                 .v_max_out      = 480,  .h_max_out      = 640,
 863         }
 864 };
 865
 866 static struct saa7146_standard dvb_standard[] = {
 867         {
 868                 .name   = "PAL",        .id             = V4L2_STD_PAL_BG,
 869                 .v_offset       = 0x14, .v_field        = 288,
 870                 .h_offset       = 0x48, .h_pixels       = 708,
 871                 .v_max_out      = 576,  .h_max_out      = 768,
 872         }, {
 873                 .name   = "NTSC",       .id             = V4L2_STD_NTSC,
 874                 .v_offset       = 0x10, .v_field        = 244,
 875                 .h_offset       = 0x40, .h_pixels       = 708,
 876                 .v_max_out      = 480,  .h_max_out      = 640,
 877         }
 878 };
 879
 880 static int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
 881 {
 882         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
 883
 884         if (std->id & V4L2_STD_PAL) {
 885                 av7110->vidmode = AV7110_VIDEO_MODE_PAL;
 886                 av7110_set_vidmode(av7110, av7110->vidmode);
 887         }
 888         else if (std->id & V4L2_STD_NTSC) {
 889                 av7110->vidmode = AV7110_VIDEO_MODE_NTSC;
 890                 av7110_set_vidmode(av7110, av7110->vidmode);
 891         }
 892         else
 893                 return -1;
 894
 895         return 0;
 896 }
 897
 898
 899 static struct saa7146_ext_vv av7110_vv_data_st = {
 900         .inputs         = 1,
 901         .audios         = 1,
 902         .capabilities   = V4L2_CAP_SLICED_VBI_OUTPUT,
 903         .flags          = 0,
 904
 905         .stds           = &standard[0],
 906         .num_stds       = ARRAY_SIZE(standard),
 907         .std_callback   = &std_callback,
 908
 909         .vbi_fops.open  = av7110_vbi_reset,
 910         .vbi_fops.release = av7110_vbi_reset,
 911         .vbi_fops.write = av7110_vbi_write,
 912 };
 913
 914 static struct saa7146_ext_vv av7110_vv_data_c = {
 915         .inputs         = 1,
 916         .audios         = 1,
 917         .capabilities   = V4L2_CAP_TUNER | V4L2_CAP_SLICED_VBI_OUTPUT,
 918         .flags          = SAA7146_USE_PORT_B_FOR_VBI,
 919
 920         .stds           = &standard[0],
 921         .num_stds       = ARRAY_SIZE(standard),
 922         .std_callback   = &std_callback,
 923
 924         .vbi_fops.open  = av7110_vbi_reset,
 925         .vbi_fops.release = av7110_vbi_reset,
 926         .vbi_fops.write = av7110_vbi_write,
 927 };
 928