[PATCH] dvb: make needlessly global code static or drop it
[linux-2.6.git] / 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/sched.h>
30 #include <linux/types.h>
31 #include <linux/delay.h>
32 #include <linux/fs.h>
33 #include <linux/timer.h>
34 #include <linux/poll.h>
35 #include <linux/byteorder/swabb.h>
36 #include <linux/smp_lock.h>
37
38 #include "av7110.h"
39 #include "av7110_hw.h"
40 #include "av7110_av.h"
41
42 int msp_writereg(struct av7110 *av7110, u8 dev, u16 reg, u16 val)
43 {
44         u8 msg[5] = { dev, reg >> 8, reg & 0xff, val >> 8 , val & 0xff };
45         struct i2c_msg msgs = { .flags = 0, .addr = 0x40, .len = 5, .buf = msg };
46
47         if (i2c_transfer(&av7110->i2c_adap, &msgs, 1) != 1) {
48                 dprintk(1, "dvb-ttpci: failed @ card %d, %u = %u\n",
49                        av7110->dvb_adapter->num, reg, val);
50                 return -EIO;
51         }
52         return 0;
53 }
54
55 static int msp_readreg(struct av7110 *av7110, u8 dev, u16 reg, u16 *val)
56 {
57         u8 msg1[3] = { dev, reg >> 8, reg & 0xff };
58         u8 msg2[2];
59         struct i2c_msg msgs[2] = {
60                 { .flags = 0,        .addr = 0x40, .len = 3, .buf = msg1 },
61                 { .flags = I2C_M_RD, .addr = 0x40, .len = 2, .buf = msg2 }
62         };
63
64         if (i2c_transfer(&av7110->i2c_adap, &msgs[0], 2) != 2) {
65                 dprintk(1, "dvb-ttpci: failed @ card %d, %u\n",
66                        av7110->dvb_adapter->num, reg);
67                 return -EIO;
68         }
69         *val = (msg2[0] << 8) | msg2[1];
70         return 0;
71 }
72
73 static struct v4l2_input inputs[2] = {
74         {
75                 .index          = 0,
76                 .name           = "DVB",
77                 .type           = V4L2_INPUT_TYPE_CAMERA,
78                 .audioset       = 1,
79                 .tuner          = 0, /* ignored */
80                 .std            = V4L2_STD_PAL_BG|V4L2_STD_NTSC_M,
81                 .status         = 0,
82         }, {
83                 .index          = 1,
84                 .name           = "Television",
85                 .type           = V4L2_INPUT_TYPE_TUNER,
86                 .audioset       = 2,
87                 .tuner          = 0,
88                 .std            = V4L2_STD_PAL_BG|V4L2_STD_NTSC_M,
89                 .status         = 0,
90         }
91 };
92
93 static int ves1820_writereg(struct saa7146_dev *dev, u8 addr, u8 reg, u8 data)
94 {
95         u8 buf[] = { 0x00, reg, data };
96         struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = buf, .len = 3 };
97
98         dprintk(4, "dev: %p\n", dev);
99
100         if (1 != saa7146_i2c_transfer(dev, &msg, 1, 1))
101                 return -1;
102         return 0;
103 }
104
105 static int stv0297_writereg(struct saa7146_dev *dev, u8 addr, u8 reg, u8 data)
106 {
107         u8 buf [] = { reg, data };
108         struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = buf, .len = 2 };
109
110         if (1 != saa7146_i2c_transfer(dev, &msg, 1, 1))
111                 return -1;
112         return 0;
113 }
114
115
116 static int tuner_write(struct saa7146_dev *dev, u8 addr, u8 data [4])
117 {
118         struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = data, .len = 4 };
119
120         dprintk(4, "dev: %p\n", dev);
121
122         if (1 != saa7146_i2c_transfer(dev, &msg, 1, 1))
123                 return -1;
124         return 0;
125 }
126
127 static int ves1820_set_tv_freq(struct saa7146_dev *dev, u32 freq)
128 {
129         u32 div;
130         u8 config;
131         u8 buf[4];
132
133         dprintk(4, "freq: 0x%08x\n", freq);
134
135         /* magic number: 614. tuning with the frequency given by v4l2
136            is always off by 614*62.5 = 38375 kHz...*/
137         div = freq + 614;
138
139         buf[0] = (div >> 8) & 0x7f;
140         buf[1] = div & 0xff;
141         buf[2] = 0x8e;
142
143         if (freq < (u32) (16 * 168.25))
144                 config = 0xa0;
145         else if (freq < (u32) (16 * 447.25))
146                 config = 0x90;
147         else
148                 config = 0x30;
149         config &= ~0x02;
150
151         buf[3] = config;
152
153         return tuner_write(dev, 0x61, buf);
154 }
155
156 static int stv0297_set_tv_freq(struct saa7146_dev *dev, u32 freq)
157 {
158         u32 div;
159         u8 data[4];
160
161         div = (freq + 38900000 + 31250) / 62500;
162
163         data[0] = (div >> 8) & 0x7f;
164         data[1] = div & 0xff;
165         data[2] = 0xce;
166
167         if (freq < 45000000)
168                 return -EINVAL;
169         else if (freq < 137000000)
170                 data[3] = 0x01;
171         else if (freq < 403000000)
172                 data[3] = 0x02;
173         else if (freq < 860000000)
174                 data[3] = 0x04;
175         else
176                 return -EINVAL;
177
178         stv0297_writereg(dev, 0x1C, 0x87, 0x78);
179         stv0297_writereg(dev, 0x1C, 0x86, 0xc8);
180         return tuner_write(dev, 0x63, data);
181 }
182
183
184
185 static struct saa7146_standard analog_standard[];
186 static struct saa7146_standard dvb_standard[];
187 static struct saa7146_standard standard[];
188
189 static struct v4l2_audio msp3400_v4l2_audio = {
190         .index = 0,
191         .name = "Television",
192         .capability = V4L2_AUDCAP_STEREO
193 };
194
195 static int av7110_dvb_c_switch(struct saa7146_fh *fh)
196 {
197         struct saa7146_dev *dev = fh->dev;
198         struct saa7146_vv *vv = dev->vv_data;
199         struct av7110 *av7110 = (struct av7110*)dev->ext_priv;
200         u16 adswitch;
201         int source, sync, err;
202
203         dprintk(4, "%p\n", av7110);
204
205         if ((vv->video_status & STATUS_OVERLAY) != 0) {
206                 vv->ov_suspend = vv->video_fh;
207                 err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */
208                 if (err != 0) {
209                         dprintk(2, "suspending video failed\n");
210                         vv->ov_suspend = NULL;
211                 }
212         }
213
214         if (0 != av7110->current_input) {
215                 adswitch = 1;
216                 source = SAA7146_HPS_SOURCE_PORT_B;
217                 sync = SAA7146_HPS_SYNC_PORT_B;
218                 memcpy(standard, analog_standard, sizeof(struct saa7146_standard) * 2);
219                 dprintk(1, "switching to analog TV\n");
220                 msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0000); // loudspeaker source
221                 msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0000); // headphone source
222                 msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0000); // SCART 1 source
223                 msp_writereg(av7110, MSP_WR_DSP, 0x000e, 0x3000); // FM matrix, mono
224                 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x4f00); // loudspeaker + headphone
225                 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x4f00); // SCART 1 volume
226
227                 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
228                         if (ves1820_writereg(dev, 0x09, 0x0f, 0x60))
229                                 dprintk(1, "setting band in demodulator failed.\n");
230                 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
231                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // TDA9198 pin9(STD)
232                         saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI); // TDA9198 pin30(VIF)
233                 }
234         } else {
235                 adswitch = 0;
236                 source = SAA7146_HPS_SOURCE_PORT_A;
237                 sync = SAA7146_HPS_SYNC_PORT_A;
238                 memcpy(standard, dvb_standard, sizeof(struct saa7146_standard) * 2);
239                 dprintk(1, "switching DVB mode\n");
240                 msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220); // loudspeaker source
241                 msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0220); // headphone source
242                 msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0220); // SCART 1 source
243                 msp_writereg(av7110, MSP_WR_DSP, 0x000e, 0x3000); // FM matrix, mono
244                 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x7f00); // loudspeaker + headphone
245                 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x7f00); // SCART 1 volume
246
247                 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
248                         if (ves1820_writereg(dev, 0x09, 0x0f, 0x20))
249                                 dprintk(1, "setting band in demodulator failed.\n");
250                 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
251                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTLO); // TDA9198 pin9(STD)
252                         saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // TDA9198 pin30(VIF)
253                 }
254         }
255
256         /* hmm, this does not do anything!? */
257         if (av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, adswitch))
258                 dprintk(1, "ADSwitch error\n");
259
260         saa7146_set_hps_source_and_sync(dev, source, sync);
261
262         if (vv->ov_suspend != NULL) {
263                 saa7146_start_preview(vv->ov_suspend);
264                 vv->ov_suspend = NULL;
265         }
266
267         return 0;
268 }
269
270 static int av7110_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
271 {
272         struct saa7146_dev *dev = fh->dev;
273         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
274         dprintk(4, "saa7146_dev: %p\n", dev);
275
276         switch (cmd) {
277         case VIDIOC_G_TUNER:
278         {
279                 struct v4l2_tuner *t = arg;
280                 u16 stereo_det;
281                 s8 stereo;
282
283                 dprintk(2, "VIDIOC_G_TUNER: %d\n", t->index);
284
285                 if (!av7110->analog_tuner_flags || t->index != 0)
286                         return -EINVAL;
287
288                 memset(t, 0, sizeof(*t));
289                 strcpy(t->name, "Television");
290
291                 t->type = V4L2_TUNER_ANALOG_TV;
292                 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO |
293                         V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
294                 t->rangelow = 772;      /* 48.25 MHZ / 62.5 kHz = 772, see fi1216mk2-specs, page 2 */
295                 t->rangehigh = 13684;   /* 855.25 MHz / 62.5 kHz = 13684 */
296                 /* FIXME: add the real signal strength here */
297                 t->signal = 0xffff;
298                 t->afc = 0;
299
300                 // FIXME: standard / stereo detection is still broken
301                 msp_readreg(av7110, MSP_RD_DEM, 0x007e, &stereo_det);
302                 dprintk(1, "VIDIOC_G_TUNER: msp3400 TV standard detection: 0x%04x\n", stereo_det);
303
304                 msp_readreg(av7110, MSP_RD_DSP, 0x0018, &stereo_det);
305                 dprintk(1, "VIDIOC_G_TUNER: msp3400 stereo detection: 0x%04x\n", stereo_det);
306                 stereo = (s8)(stereo_det >> 8);
307                 if (stereo > 0x10) {
308                         /* stereo */
309                         t->rxsubchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_MONO;
310                         t->audmode = V4L2_TUNER_MODE_STEREO;
311                 }
312                 else if (stereo < -0x10) {
313                         /* bilingual*/
314                         t->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
315                         t->audmode = V4L2_TUNER_MODE_LANG1;
316                 }
317                 else /* mono */
318                         t->rxsubchans = V4L2_TUNER_SUB_MONO;
319
320                 return 0;
321         }
322         case VIDIOC_S_TUNER:
323         {
324                 struct v4l2_tuner *t = arg;
325                 u16 fm_matrix, src;
326                 dprintk(2, "VIDIOC_S_TUNER: %d\n", t->index);
327
328                 if (!av7110->analog_tuner_flags || av7110->current_input != 1)
329                         return -EINVAL;
330
331                 switch (t->audmode) {
332                 case V4L2_TUNER_MODE_STEREO:
333                         dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_STEREO\n");
334                         fm_matrix = 0x3001; // stereo
335                         src = 0x0020;
336                         break;
337                 case V4L2_TUNER_MODE_LANG1:
338                         dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1\n");
339                         fm_matrix = 0x3000; // mono
340                         src = 0x0000;
341                         break;
342                 case V4L2_TUNER_MODE_LANG2:
343                         dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG2\n");
344                         fm_matrix = 0x3000; // mono
345                         src = 0x0010;
346                         break;
347                 default: /* case V4L2_TUNER_MODE_MONO: {*/
348                         dprintk(2, "VIDIOC_S_TUNER: TDA9840_SET_MONO\n");
349                         fm_matrix = 0x3000; // mono
350                         src = 0x0030;
351                         break;
352                 }
353                 msp_writereg(av7110, MSP_WR_DSP, 0x000e, fm_matrix);
354                 msp_writereg(av7110, MSP_WR_DSP, 0x0008, src);
355                 msp_writereg(av7110, MSP_WR_DSP, 0x0009, src);
356                 msp_writereg(av7110, MSP_WR_DSP, 0x000a, src);
357                 return 0;
358         }
359         case VIDIOC_G_FREQUENCY:
360         {
361                 struct v4l2_frequency *f = arg;
362
363                 dprintk(2, "VIDIOC_G_FREQ: freq:0x%08x.\n", f->frequency);
364
365                 if (!av7110->analog_tuner_flags || av7110->current_input != 1)
366                         return -EINVAL;
367
368                 memset(f, 0, sizeof(*f));
369                 f->type = V4L2_TUNER_ANALOG_TV;
370                 f->frequency =  av7110->current_freq;
371                 return 0;
372         }
373         case VIDIOC_S_FREQUENCY:
374         {
375                 struct v4l2_frequency *f = arg;
376
377                 dprintk(2, "VIDIOC_S_FREQUENCY: freq:0x%08x.\n", f->frequency);
378
379                 if (!av7110->analog_tuner_flags || av7110->current_input != 1)
380                         return -EINVAL;
381
382                 if (V4L2_TUNER_ANALOG_TV != f->type)
383                         return -EINVAL;
384
385                 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0xffe0); // fast mute
386                 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0xffe0);
387
388                 /* tune in desired frequency */
389                 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
390                         ves1820_set_tv_freq(dev, f->frequency);
391                 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
392                         stv0297_set_tv_freq(dev, f->frequency);
393                 }
394                 av7110->current_freq = f->frequency;
395
396                 msp_writereg(av7110, MSP_WR_DSP, 0x0015, 0x003f); // start stereo detection
397                 msp_writereg(av7110, MSP_WR_DSP, 0x0015, 0x0000);
398                 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x4f00); // loudspeaker + headphone
399                 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x4f00); // SCART 1 volume
400                 return 0;
401         }
402         case VIDIOC_ENUMINPUT:
403         {
404                 struct v4l2_input *i = arg;
405
406                 dprintk(2, "VIDIOC_ENUMINPUT: %d\n", i->index);
407
408                 if (av7110->analog_tuner_flags) {
409                         if (i->index < 0 || i->index >= 2)
410                                 return -EINVAL;
411                 } else {
412                         if (i->index != 0)
413                                 return -EINVAL;
414                 }
415
416                 memcpy(i, &inputs[i->index], sizeof(struct v4l2_input));
417
418                 return 0;
419         }
420         case VIDIOC_G_INPUT:
421         {
422                 int *input = (int *)arg;
423                 *input = av7110->current_input;
424                 dprintk(2, "VIDIOC_G_INPUT: %d\n", *input);
425                 return 0;
426         }
427         case VIDIOC_S_INPUT:
428         {
429                 int input = *(int *)arg;
430
431                 dprintk(2, "VIDIOC_S_INPUT: %d\n", input);
432
433                 if (!av7110->analog_tuner_flags)
434                         return 0;
435
436                 if (input < 0 || input >= 2)
437                         return -EINVAL;
438
439                 /* FIXME: switch inputs here */
440                 av7110->current_input = input;
441                 return av7110_dvb_c_switch(fh);
442         }
443         case VIDIOC_G_AUDIO:
444         {
445                 struct v4l2_audio *a = arg;
446
447                 dprintk(2, "VIDIOC_G_AUDIO: %d\n", a->index);
448                 if (a->index != 0)
449                         return -EINVAL;
450                 memcpy(a, &msp3400_v4l2_audio, sizeof(struct v4l2_audio));
451                 break;
452         }
453         case VIDIOC_S_AUDIO:
454         {
455                 struct v4l2_audio *a = arg;
456                 dprintk(2, "VIDIOC_S_AUDIO: %d\n", a->index);
457                 break;
458         }
459         default:
460                 printk("no such ioctl\n");
461                 return -ENOIOCTLCMD;
462         }
463         return 0;
464 }
465
466
467 /****************************************************************************
468  * INITIALIZATION
469  ****************************************************************************/
470
471 static struct saa7146_extension_ioctls ioctls[] = {
472         { VIDIOC_ENUMINPUT,     SAA7146_EXCLUSIVE },
473         { VIDIOC_G_INPUT,       SAA7146_EXCLUSIVE },
474         { VIDIOC_S_INPUT,       SAA7146_EXCLUSIVE },
475         { VIDIOC_G_FREQUENCY,   SAA7146_EXCLUSIVE },
476         { VIDIOC_S_FREQUENCY,   SAA7146_EXCLUSIVE },
477         { VIDIOC_G_TUNER,       SAA7146_EXCLUSIVE },
478         { VIDIOC_S_TUNER,       SAA7146_EXCLUSIVE },
479         { VIDIOC_G_AUDIO,       SAA7146_EXCLUSIVE },
480         { VIDIOC_S_AUDIO,       SAA7146_EXCLUSIVE },
481         { 0, 0 }
482 };
483
484 static u8 saa7113_init_regs[] = {
485         0x02, 0xd0,
486         0x03, 0x23,
487         0x04, 0x00,
488         0x05, 0x00,
489         0x06, 0xe9,
490         0x07, 0x0d,
491         0x08, 0x98,
492         0x09, 0x02,
493         0x0a, 0x80,
494         0x0b, 0x40,
495         0x0c, 0x40,
496         0x0d, 0x00,
497         0x0e, 0x01,
498         0x0f, 0x7c,
499         0x10, 0x48,
500         0x11, 0x0c,
501         0x12, 0x8b,
502         0x13, 0x1a,
503         0x14, 0x00,
504         0x15, 0x00,
505         0x16, 0x00,
506         0x17, 0x00,
507         0x18, 0x00,
508         0x19, 0x00,
509         0x1a, 0x00,
510         0x1b, 0x00,
511         0x1c, 0x00,
512         0x1d, 0x00,
513         0x1e, 0x00,
514
515         0x41, 0x77,
516         0x42, 0x77,
517         0x43, 0x77,
518         0x44, 0x77,
519         0x45, 0x77,
520         0x46, 0x77,
521         0x47, 0x77,
522         0x48, 0x77,
523         0x49, 0x77,
524         0x4a, 0x77,
525         0x4b, 0x77,
526         0x4c, 0x77,
527         0x4d, 0x77,
528         0x4e, 0x77,
529         0x4f, 0x77,
530         0x50, 0x77,
531         0x51, 0x77,
532         0x52, 0x77,
533         0x53, 0x77,
534         0x54, 0x77,
535         0x55, 0x77,
536         0x56, 0x77,
537         0x57, 0xff,
538
539         0xff
540 };
541
542
543 static struct saa7146_ext_vv av7110_vv_data_st;
544 static struct saa7146_ext_vv av7110_vv_data_c;
545
546 int av7110_init_analog_module(struct av7110 *av7110)
547 {
548         u16 version1, version2;
549
550         if (i2c_writereg(av7110, 0x80, 0x0, 0x80) != 1
551             || i2c_writereg(av7110, 0x80, 0x0, 0) != 1)
552                 return -ENODEV;
553
554         printk("dvb-ttpci: DVB-C analog module @ card %d detected, initializing MSP3400\n",
555                 av7110->dvb_adapter->num);
556         av7110->adac_type = DVB_ADAC_MSP;
557         msleep(100); // the probing above resets the msp...
558         msp_readreg(av7110, MSP_RD_DSP, 0x001e, &version1);
559         msp_readreg(av7110, MSP_RD_DSP, 0x001f, &version2);
560         dprintk(1, "dvb-ttpci: @ card %d MSP3400 version 0x%04x 0x%04x\n",
561                 av7110->dvb_adapter->num, version1, version2);
562         msp_writereg(av7110, MSP_WR_DSP, 0x0013, 0x0c00);
563         msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x7f00); // loudspeaker + headphone
564         msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220); // loudspeaker source
565         msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0220); // headphone source
566         msp_writereg(av7110, MSP_WR_DSP, 0x0004, 0x7f00); // loudspeaker volume
567         msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0220); // SCART 1 source
568         msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x7f00); // SCART 1 volume
569         msp_writereg(av7110, MSP_WR_DSP, 0x000d, 0x4800); // prescale SCART
570
571         if (i2c_writereg(av7110, 0x48, 0x01, 0x00)!=1) {
572                 INFO(("saa7113 not accessible.\n"));
573         } else {
574                 u8 *i = saa7113_init_regs;
575
576                 if ((av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
577                         /* Fujitsu/Siemens DVB-Cable */
578                         av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
579                 } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x0002)) {
580                         /* Hauppauge/TT DVB-C premium */
581                         av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
582                 } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x000A)) {
583                         /* Hauppauge/TT DVB-C premium */
584                         av7110->analog_tuner_flags |= ANALOG_TUNER_STV0297;
585                 }
586
587                 /* setup for DVB by default */
588                 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
589                         if (ves1820_writereg(av7110->dev, 0x09, 0x0f, 0x20))
590                                 dprintk(1, "setting band in demodulator failed.\n");
591                 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
592                         saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9198 pin9(STD)
593                         saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9198 pin30(VIF)
594                 }
595
596                 /* init the saa7113 */
597                 while (*i != 0xff) {
598                         if (i2c_writereg(av7110, 0x48, i[0], i[1]) != 1) {
599                                 dprintk(1, "saa7113 initialization failed @ card %d", av7110->dvb_adapter->num);
600                                 break;
601                         }
602                         i += 2;
603                 }
604                 /* setup msp for analog sound: B/G Dual-FM */
605                 msp_writereg(av7110, MSP_WR_DEM, 0x00bb, 0x02d0); // AD_CV
606                 msp_writereg(av7110, MSP_WR_DEM, 0x0001,  3); // FIR1
607                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 18); // FIR1
608                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 27); // FIR1
609                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 48); // FIR1
610                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 66); // FIR1
611                 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 72); // FIR1
612                 msp_writereg(av7110, MSP_WR_DEM, 0x0005,  4); // FIR2
613                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 64); // FIR2
614                 msp_writereg(av7110, MSP_WR_DEM, 0x0005,  0); // FIR2
615                 msp_writereg(av7110, MSP_WR_DEM, 0x0005,  3); // FIR2
616                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 18); // FIR2
617                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 27); // FIR2
618                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 48); // FIR2
619                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 66); // FIR2
620                 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 72); // FIR2
621                 msp_writereg(av7110, MSP_WR_DEM, 0x0083, 0xa000); // MODE_REG
622                 msp_writereg(av7110, MSP_WR_DEM, 0x0093, 0x00aa); // DCO1_LO 5.74MHz
623                 msp_writereg(av7110, MSP_WR_DEM, 0x009b, 0x04fc); // DCO1_HI
624                 msp_writereg(av7110, MSP_WR_DEM, 0x00a3, 0x038e); // DCO2_LO 5.5MHz
625                 msp_writereg(av7110, MSP_WR_DEM, 0x00ab, 0x04c6); // DCO2_HI
626                 msp_writereg(av7110, MSP_WR_DEM, 0x0056, 0); // LOAD_REG 1/2
627         }
628
629         memcpy(standard, dvb_standard, sizeof(struct saa7146_standard) * 2);
630         /* set dd1 stream a & b */
631         saa7146_write(av7110->dev, DD1_STREAM_B, 0x00000000);
632         saa7146_write(av7110->dev, DD1_INIT, 0x03000700);
633         saa7146_write(av7110->dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
634
635         return 0;
636 }
637
638 int av7110_init_v4l(struct av7110 *av7110)
639 {
640         struct saa7146_dev* dev = av7110->dev;
641         int ret;
642
643         /* special case DVB-C: these cards have an analog tuner
644            plus need some special handling, so we have separate
645            saa7146_ext_vv data for these... */
646         if (av7110->analog_tuner_flags)
647                 ret = saa7146_vv_init(dev, &av7110_vv_data_c);
648         else
649                 ret = saa7146_vv_init(dev, &av7110_vv_data_st);
650
651         if (ret) {
652                 ERR(("cannot init capture device. skipping.\n"));
653                 return -ENODEV;
654         }
655
656         if (saa7146_register_device(&av7110->v4l_dev, dev, "av7110", VFL_TYPE_GRABBER)) {
657                 ERR(("cannot register capture device. skipping.\n"));
658                 saa7146_vv_release(dev);
659                 return -ENODEV;
660         }
661         if (av7110->analog_tuner_flags) {
662                 if (saa7146_register_device(&av7110->vbi_dev, dev, "av7110", VFL_TYPE_VBI)) {
663                         ERR(("cannot register vbi v4l2 device. skipping.\n"));
664                 } else {
665                         av7110->analog_tuner_flags |= ANALOG_TUNER_VBI;
666                 }
667         }
668         return 0;
669 }
670
671 int av7110_exit_v4l(struct av7110 *av7110)
672 {
673         saa7146_unregister_device(&av7110->v4l_dev, av7110->dev);
674         if (av7110->analog_tuner_flags & ANALOG_TUNER_VBI)
675                 saa7146_unregister_device(&av7110->vbi_dev, av7110->dev);
676         return 0;
677 }
678
679
680
681 /* FIXME: these values are experimental values that look better than the
682    values from the latest "official" driver -- at least for me... (MiHu) */
683 static struct saa7146_standard standard[] = {
684         {
685                 .name   = "PAL",        .id             = V4L2_STD_PAL_BG,
686                 .v_offset       = 0x15, .v_field        = 288,
687                 .h_offset       = 0x48, .h_pixels       = 708,
688                 .v_max_out      = 576,  .h_max_out      = 768,
689         }, {
690                 .name   = "NTSC",       .id             = V4L2_STD_NTSC,
691                 .v_offset       = 0x10, .v_field        = 244,
692                 .h_offset       = 0x40, .h_pixels       = 708,
693                 .v_max_out      = 480,  .h_max_out      = 640,
694         }
695 };
696
697 static struct saa7146_standard analog_standard[] = {
698         {
699                 .name   = "PAL",        .id             = V4L2_STD_PAL_BG,
700                 .v_offset       = 0x1b, .v_field        = 288,
701                 .h_offset       = 0x08, .h_pixels       = 708,
702                 .v_max_out      = 576,  .h_max_out      = 768,
703         }, {
704                 .name   = "NTSC",       .id             = V4L2_STD_NTSC,
705                 .v_offset       = 0x10, .v_field        = 244,
706                 .h_offset       = 0x40, .h_pixels       = 708,
707                 .v_max_out      = 480,  .h_max_out      = 640,
708         }
709 };
710
711 static struct saa7146_standard dvb_standard[] = {
712         {
713                 .name   = "PAL",        .id             = V4L2_STD_PAL_BG,
714                 .v_offset       = 0x14, .v_field        = 288,
715                 .h_offset       = 0x48, .h_pixels       = 708,
716                 .v_max_out      = 576,  .h_max_out      = 768,
717         }, {
718                 .name   = "NTSC",       .id             = V4L2_STD_NTSC,
719                 .v_offset       = 0x10, .v_field        = 244,
720                 .h_offset       = 0x40, .h_pixels       = 708,
721                 .v_max_out      = 480,  .h_max_out      = 640,
722         }
723 };
724
725 static int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
726 {
727         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
728
729         if (std->id & V4L2_STD_PAL) {
730                 av7110->vidmode = VIDEO_MODE_PAL;
731                 av7110_set_vidmode(av7110, av7110->vidmode);
732         }
733         else if (std->id & V4L2_STD_NTSC) {
734                 av7110->vidmode = VIDEO_MODE_NTSC;
735                 av7110_set_vidmode(av7110, av7110->vidmode);
736         }
737         else
738                 return -1;
739
740         return 0;
741 }
742
743
744 static struct saa7146_ext_vv av7110_vv_data_st = {
745         .inputs         = 1,
746         .audios         = 1,
747         .capabilities   = 0,
748         .flags          = 0,
749
750         .stds           = &standard[0],
751         .num_stds       = ARRAY_SIZE(standard),
752         .std_callback   = &std_callback,
753
754         .ioctls         = &ioctls[0],
755         .ioctl          = av7110_ioctl,
756 };
757
758 static struct saa7146_ext_vv av7110_vv_data_c = {
759         .inputs         = 1,
760         .audios         = 1,
761         .capabilities   = V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE,
762         .flags          = SAA7146_USE_PORT_B_FOR_VBI,
763
764         .stds           = &standard[0],
765         .num_stds       = ARRAY_SIZE(standard),
766         .std_callback   = &std_callback,
767
768         .ioctls         = &ioctls[0],
769         .ioctl          = av7110_ioctl,
770 };
771