?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'io_uring-5.11-2021-01-16' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / media / pci / ttpci / av7110_v4l.c
blobc89f536f699c88ce9920eb77674e2b60ea60d32c
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 < 16U * 16825 / 100)
164 config = 0xa0;
165 else if (freq < 16U * 44725 / 100)
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_VIDEO)) {
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
Linux with added FPC-III support