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