LXR linux/drivers/media/dvb/ttpci/av7110

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