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