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