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