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