?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC56 3.0.0.4.374.37 core
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / media / dvb / ttpci / av7110_v4l.c
blobb4a3061d5458006b444d2eebcf992248a290bb2f
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
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
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
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
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
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
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
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
319 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *t)
320 {
321 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
322 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
323 u16 stereo_det;
324 s8 stereo;
325
326 dprintk(2, "VIDIOC_G_TUNER: %d\n", t->index);
327
328 if (!av7110->analog_tuner_flags || t->index != 0)
329 return -EINVAL;
330
331 memset(t, 0, sizeof(*t));
332 strcpy((char *)t->name, "Television");
333
334 t->type = V4L2_TUNER_ANALOG_TV;
335 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO |
336 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
337 t->rangelow = 772; /* 48.25 MHZ / 62.5 kHz = 772, see fi1216mk2-specs, page 2 */
338 t->rangehigh = 13684; /* 855.25 MHz / 62.5 kHz = 13684 */
339 t->signal = 0xffff;
340 t->afc = 0;
341
342 msp_readreg(av7110, MSP_RD_DEM, 0x007e, &stereo_det);
343 dprintk(1, "VIDIOC_G_TUNER: msp3400 TV standard detection: 0x%04x\n", stereo_det);
344 msp_readreg(av7110, MSP_RD_DSP, 0x0018, &stereo_det);
345 dprintk(1, "VIDIOC_G_TUNER: msp3400 stereo detection: 0x%04x\n", stereo_det);
346 stereo = (s8)(stereo_det >> 8);
347 if (stereo > 0x10) {
348 /* stereo */
349 t->rxsubchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_MONO;
350 t->audmode = V4L2_TUNER_MODE_STEREO;
351 } else if (stereo < -0x10) {
352 /* bilingual */
353 t->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
354 t->audmode = V4L2_TUNER_MODE_LANG1;
355 } else /* mono */
356 t->rxsubchans = V4L2_TUNER_SUB_MONO;
357
358 return 0;
359 }
360
361 static int vidioc_s_tuner(struct file *file, void *fh, struct v4l2_tuner *t)
362 {
363 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
364 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
365 u16 fm_matrix, src;
366 dprintk(2, "VIDIOC_S_TUNER: %d\n", t->index);
367
368 if (!av7110->analog_tuner_flags || av7110->current_input != 1)
369 return -EINVAL;
370
371 switch (t->audmode) {
372 case V4L2_TUNER_MODE_STEREO:
373 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_STEREO\n");
374 fm_matrix = 0x3001; /* stereo */
375 src = 0x0020;
376 break;
377 case V4L2_TUNER_MODE_LANG1_LANG2:
378 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1_LANG2\n");
379 fm_matrix = 0x3000; /* bilingual */
380 src = 0x0020;
381 break;
382 case V4L2_TUNER_MODE_LANG1:
383 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1\n");
384 fm_matrix = 0x3000; /* mono */
385 src = 0x0000;
386 break;
387 case V4L2_TUNER_MODE_LANG2:
388 dprintk(2, "VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG2\n");
389 fm_matrix = 0x3000; /* mono */
390 src = 0x0010;
391 break;
392 default: /* case V4L2_TUNER_MODE_MONO: */
393 dprintk(2, "VIDIOC_S_TUNER: TDA9840_SET_MONO\n");
394 fm_matrix = 0x3000; /* mono */
395 src = 0x0030;
396 break;
397 }
398 msp_writereg(av7110, MSP_WR_DSP, 0x000e, fm_matrix);
399 msp_writereg(av7110, MSP_WR_DSP, 0x0008, src);
400 msp_writereg(av7110, MSP_WR_DSP, 0x0009, src);
401 msp_writereg(av7110, MSP_WR_DSP, 0x000a, src);
402 return 0;
403 }
404
405 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *f)
406 {
407 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
408 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
409
410 dprintk(2, "VIDIOC_G_FREQ: freq:0x%08x.\n", f->frequency);
411
412 if (!av7110->analog_tuner_flags || av7110->current_input != 1)
413 return -EINVAL;
414
415 memset(f, 0, sizeof(*f));
416 f->type = V4L2_TUNER_ANALOG_TV;
417 f->frequency = av7110->current_freq;
418 return 0;
419 }
420
421 static int vidioc_s_frequency(struct file *file, void *fh, struct v4l2_frequency *f)
422 {
423 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
424 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
425
426 dprintk(2, "VIDIOC_S_FREQUENCY: freq:0x%08x.\n", f->frequency);
427
428 if (!av7110->analog_tuner_flags || av7110->current_input != 1)
429 return -EINVAL;
430
431 if (V4L2_TUNER_ANALOG_TV != f->type)
432 return -EINVAL;
433
434 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0xffe0); /* fast mute */
435 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0xffe0);
436
437 /* tune in desired frequency */
438 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820)
439 ves1820_set_tv_freq(dev, f->frequency);
440 else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297)
441 stv0297_set_tv_freq(dev, f->frequency);
442 av7110->current_freq = f->frequency;
443
444 msp_writereg(av7110, MSP_WR_DSP, 0x0015, 0x003f); /* start stereo detection */
445 msp_writereg(av7110, MSP_WR_DSP, 0x0015, 0x0000);
446 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x4f00); /* loudspeaker + headphone */
447 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x4f00); /* SCART 1 volume */
448 return 0;
449 }
450
451 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
452 {
453 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
454 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
455
456 dprintk(2, "VIDIOC_ENUMINPUT: %d\n", i->index);
457
458 if (av7110->analog_tuner_flags) {
459 if (i->index >= 4)
460 return -EINVAL;
461 } else {
462 if (i->index != 0)
463 return -EINVAL;
464 }
465
466 memcpy(i, &inputs[i->index], sizeof(struct v4l2_input));
467
468 return 0;
469 }
470
471 static int vidioc_g_input(struct file *file, void *fh, unsigned int *input)
472 {
473 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
474 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
475
476 *input = av7110->current_input;
477 dprintk(2, "VIDIOC_G_INPUT: %d\n", *input);
478 return 0;
479 }
480
481 static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
482 {
483 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
484 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
485
486 dprintk(2, "VIDIOC_S_INPUT: %d\n", input);
487
488 if (!av7110->analog_tuner_flags)
489 return 0;
490
491 if (input >= 4)
492 return -EINVAL;
493
494 av7110->current_input = input;
495 return av7110_dvb_c_switch(fh);
496 }
497
498 static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
499 {
500 dprintk(2, "VIDIOC_G_AUDIO: %d\n", a->index);
501 if (a->index != 0)
502 return -EINVAL;
503 memcpy(a, &msp3400_v4l2_audio, sizeof(struct v4l2_audio));
504 return 0;
505 }
506
507 static int vidioc_s_audio(struct file *file, void *fh, struct v4l2_audio *a)
508 {
509 dprintk(2, "VIDIOC_S_AUDIO: %d\n", a->index);
510 return 0;
511 }
512
513 static int vidioc_g_sliced_vbi_cap(struct file *file, void *fh,
514 struct v4l2_sliced_vbi_cap *cap)
515 {
516 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
517 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
518
519 dprintk(2, "VIDIOC_G_SLICED_VBI_CAP\n");
520 if (cap->type != V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
521 return -EINVAL;
522 if (FW_VERSION(av7110->arm_app) >= 0x2623) {
523 cap->service_set = V4L2_SLICED_WSS_625;
524 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
525 }
526 return 0;
527 }
528
529 static int vidioc_g_fmt_sliced_vbi_out(struct file *file, void *fh,
530 struct v4l2_format *f)
531 {
532 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
533 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
534
535 dprintk(2, "VIDIOC_G_FMT:\n");
536 if (FW_VERSION(av7110->arm_app) < 0x2623)
537 return -EINVAL;
538 memset(&f->fmt.sliced, 0, sizeof f->fmt.sliced);
539 if (av7110->wssMode) {
540 f->fmt.sliced.service_set = V4L2_SLICED_WSS_625;
541 f->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
542 f->fmt.sliced.io_size = sizeof(struct v4l2_sliced_vbi_data);
543 }
544 return 0;
545 }
546
547 static int vidioc_s_fmt_sliced_vbi_out(struct file *file, void *fh,
548 struct v4l2_format *f)
549 {
550 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
551 struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
552
553 dprintk(2, "VIDIOC_S_FMT\n");
554 if (FW_VERSION(av7110->arm_app) < 0x2623)
555 return -EINVAL;
556 if (f->fmt.sliced.service_set != V4L2_SLICED_WSS_625 &&
557 f->fmt.sliced.service_lines[0][23] != V4L2_SLICED_WSS_625) {
558 memset(&f->fmt.sliced, 0, sizeof(f->fmt.sliced));
559 /* WSS controlled by firmware */
560 av7110->wssMode = 0;
561 av7110->wssData = 0;
562 return av7110_fw_cmd(av7110, COMTYPE_ENCODER,
563 SetWSSConfig, 1, 0);
564 } else {
565 memset(&f->fmt.sliced, 0, sizeof(f->fmt.sliced));
566 f->fmt.sliced.service_set = V4L2_SLICED_WSS_625;
567 f->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
568 f->fmt.sliced.io_size = sizeof(struct v4l2_sliced_vbi_data);
569 /* WSS controlled by userspace */
570 av7110->wssMode = 1;
571 av7110->wssData = 0;
572 }
573 return 0;
574 }
575
576 static int av7110_vbi_reset(struct file *file)
577 {
578 struct saa7146_fh *fh = file->private_data;
579 struct saa7146_dev *dev = fh->dev;
580 struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
581
582 dprintk(2, "%s\n", __func__);
583 av7110->wssMode = 0;
584 av7110->wssData = 0;
585 if (FW_VERSION(av7110->arm_app) < 0x2623)
586 return 0;
587 else
588 return av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 1, 0);
589 }
590
591 static ssize_t av7110_vbi_write(struct file *file, const char __user *data, size_t count, loff_t *ppos)
592 {
593 struct saa7146_fh *fh = file->private_data;
594 struct saa7146_dev *dev = fh->dev;
595 struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
596 struct v4l2_sliced_vbi_data d;
597 int rc;
598
599 dprintk(2, "%s\n", __func__);
600 if (FW_VERSION(av7110->arm_app) < 0x2623 || !av7110->wssMode || count != sizeof d)
601 return -EINVAL;
602 if (copy_from_user(&d, data, count))
603 return -EFAULT;
604 if ((d.id != 0 && d.id != V4L2_SLICED_WSS_625) || d.field != 0 || d.line != 23)
605 return -EINVAL;
606 if (d.id)
607 av7110->wssData = ((d.data[1] << 8) & 0x3f00) | d.data[0];
608 else
609 av7110->wssData = 0x8000;
610 rc = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 1, av7110->wssData);
611 return (rc < 0) ? rc : count;
612 }
613
614 /****************************************************************************
615 * INITIALIZATION
616 ****************************************************************************/
617
618 static u8 saa7113_init_regs[] = {
619 0x02, 0xd0,
620 0x03, 0x23,
621 0x04, 0x00,
622 0x05, 0x00,
623 0x06, 0xe9,
624 0x07, 0x0d,
625 0x08, 0x98,
626 0x09, 0x02,
627 0x0a, 0x80,
628 0x0b, 0x40,
629 0x0c, 0x40,
630 0x0d, 0x00,
631 0x0e, 0x01,
632 0x0f, 0x7c,
633 0x10, 0x48,
634 0x11, 0x0c,
635 0x12, 0x8b,
636 0x13, 0x1a,
637 0x14, 0x00,
638 0x15, 0x00,
639 0x16, 0x00,
640 0x17, 0x00,
641 0x18, 0x00,
642 0x19, 0x00,
643 0x1a, 0x00,
644 0x1b, 0x00,
645 0x1c, 0x00,
646 0x1d, 0x00,
647 0x1e, 0x00,
648
649 0x41, 0x77,
650 0x42, 0x77,
651 0x43, 0x77,
652 0x44, 0x77,
653 0x45, 0x77,
654 0x46, 0x77,
655 0x47, 0x77,
656 0x48, 0x77,
657 0x49, 0x77,
658 0x4a, 0x77,
659 0x4b, 0x77,
660 0x4c, 0x77,
661 0x4d, 0x77,
662 0x4e, 0x77,
663 0x4f, 0x77,
664 0x50, 0x77,
665 0x51, 0x77,
666 0x52, 0x77,
667 0x53, 0x77,
668 0x54, 0x77,
669 0x55, 0x77,
670 0x56, 0x77,
671 0x57, 0xff,
672
673 0xff
674 };
675
676
677 static struct saa7146_ext_vv av7110_vv_data_st;
678 static struct saa7146_ext_vv av7110_vv_data_c;
679
680 int av7110_init_analog_module(struct av7110 *av7110)
681 {
682 u16 version1, version2;
683
684 if (i2c_writereg(av7110, 0x80, 0x0, 0x80) == 1 &&
685 i2c_writereg(av7110, 0x80, 0x0, 0) == 1) {
686 printk("dvb-ttpci: DVB-C analog module @ card %d detected, initializing MSP3400\n",
687 av7110->dvb_adapter.num);
688 av7110->adac_type = DVB_ADAC_MSP34x0;
689 } else if (i2c_writereg(av7110, 0x84, 0x0, 0x80) == 1 &&
690 i2c_writereg(av7110, 0x84, 0x0, 0) == 1) {
691 printk("dvb-ttpci: DVB-C analog module @ card %d detected, initializing MSP3415\n",
692 av7110->dvb_adapter.num);
693 av7110->adac_type = DVB_ADAC_MSP34x5;
694 } else
695 return -ENODEV;
696
697 msleep(100); // the probing above resets the msp...
698 msp_readreg(av7110, MSP_RD_DSP, 0x001e, &version1);
699 msp_readreg(av7110, MSP_RD_DSP, 0x001f, &version2);
700 dprintk(1, "dvb-ttpci: @ card %d MSP34xx version 0x%04x 0x%04x\n",
701 av7110->dvb_adapter.num, version1, version2);
702 msp_writereg(av7110, MSP_WR_DSP, 0x0013, 0x0c00);
703 msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x7f00); // loudspeaker + headphone
704 msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220); // loudspeaker source
705 msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0220); // headphone source
706 msp_writereg(av7110, MSP_WR_DSP, 0x0004, 0x7f00); // loudspeaker volume
707 msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0220); // SCART 1 source
708 msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x7f00); // SCART 1 volume
709 msp_writereg(av7110, MSP_WR_DSP, 0x000d, 0x1900); // prescale SCART
710
711 if (i2c_writereg(av7110, 0x48, 0x01, 0x00)!=1) {
712 INFO(("saa7113 not accessible.\n"));
713 } else {
714 u8 *i = saa7113_init_regs;
715
716 if ((av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
717 /* Fujitsu/Siemens DVB-Cable */
718 av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
719 } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x0002)) {
720 /* Hauppauge/TT DVB-C premium */
721 av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
722 } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x000A)) {
723 /* Hauppauge/TT DVB-C premium */
724 av7110->analog_tuner_flags |= ANALOG_TUNER_STV0297;
725 }
726
727 /* setup for DVB by default */
728 if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
729 if (ves1820_writereg(av7110->dev, 0x09, 0x0f, 0x20))
730 dprintk(1, "setting band in demodulator failed.\n");
731 } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
732 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
733 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
734 }
735
736 /* init the saa7113 */
737 while (*i != 0xff) {
738 if (i2c_writereg(av7110, 0x48, i[0], i[1]) != 1) {
739 dprintk(1, "saa7113 initialization failed @ card %d", av7110->dvb_adapter.num);
740 break;
741 }
742 i += 2;
743 }
744 /* setup msp for analog sound: B/G Dual-FM */
745 msp_writereg(av7110, MSP_WR_DEM, 0x00bb, 0x02d0); // AD_CV
746 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 3); // FIR1
747 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 18); // FIR1
748 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 27); // FIR1
749 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 48); // FIR1
750 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 66); // FIR1
751 msp_writereg(av7110, MSP_WR_DEM, 0x0001, 72); // FIR1
752 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 4); // FIR2
753 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 64); // FIR2
754 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 0); // FIR2
755 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 3); // FIR2
756 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 18); // FIR2
757 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 27); // FIR2
758 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 48); // FIR2
759 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 66); // FIR2
760 msp_writereg(av7110, MSP_WR_DEM, 0x0005, 72); // FIR2
761 msp_writereg(av7110, MSP_WR_DEM, 0x0083, 0xa000); // MODE_REG
762 msp_writereg(av7110, MSP_WR_DEM, 0x0093, 0x00aa); // DCO1_LO 5.74MHz
763 msp_writereg(av7110, MSP_WR_DEM, 0x009b, 0x04fc); // DCO1_HI
764 msp_writereg(av7110, MSP_WR_DEM, 0x00a3, 0x038e); // DCO2_LO 5.5MHz
765 msp_writereg(av7110, MSP_WR_DEM, 0x00ab, 0x04c6); // DCO2_HI
766 msp_writereg(av7110, MSP_WR_DEM, 0x0056, 0); // LOAD_REG 1/2
767 }
768
769 memcpy(standard, dvb_standard, sizeof(struct saa7146_standard) * 2);
770 /* set dd1 stream a & b */
771 saa7146_write(av7110->dev, DD1_STREAM_B, 0x00000000);
772 saa7146_write(av7110->dev, DD1_INIT, 0x03000700);
773 saa7146_write(av7110->dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
774
775 return 0;
776 }
777
778 int av7110_init_v4l(struct av7110 *av7110)
779 {
780 struct saa7146_dev* dev = av7110->dev;
781 struct saa7146_ext_vv *vv_data;
782 int ret;
783
784 /* special case DVB-C: these cards have an analog tuner
785 plus need some special handling, so we have separate
786 saa7146_ext_vv data for these... */
787 if (av7110->analog_tuner_flags)
788 vv_data = &av7110_vv_data_c;
789 else
790 vv_data = &av7110_vv_data_st;
791 ret = saa7146_vv_init(dev, vv_data);
792
793 if (ret) {
794 ERR(("cannot init capture device. skipping.\n"));
795 return -ENODEV;
796 }
797 vv_data->ops.vidioc_enum_input = vidioc_enum_input;
798 vv_data->ops.vidioc_g_input = vidioc_g_input;
799 vv_data->ops.vidioc_s_input = vidioc_s_input;
800 vv_data->ops.vidioc_g_tuner = vidioc_g_tuner;
801 vv_data->ops.vidioc_s_tuner = vidioc_s_tuner;
802 vv_data->ops.vidioc_g_frequency = vidioc_g_frequency;
803 vv_data->ops.vidioc_s_frequency = vidioc_s_frequency;
804 vv_data->ops.vidioc_g_audio = vidioc_g_audio;
805 vv_data->ops.vidioc_s_audio = vidioc_s_audio;
806 vv_data->ops.vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap;
807 vv_data->ops.vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out;
808 vv_data->ops.vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out;
809
810 if (saa7146_register_device(&av7110->v4l_dev, dev, "av7110", VFL_TYPE_GRABBER)) {
811 ERR(("cannot register capture device. skipping.\n"));
812 saa7146_vv_release(dev);
813 return -ENODEV;
814 }
815 if (saa7146_register_device(&av7110->vbi_dev, dev, "av7110", VFL_TYPE_VBI))
816 ERR(("cannot register vbi v4l2 device. skipping.\n"));
817 return 0;
818 }
819
820 int av7110_exit_v4l(struct av7110 *av7110)
821 {
822 struct saa7146_dev* dev = av7110->dev;
823
824 saa7146_unregister_device(&av7110->v4l_dev, av7110->dev);
825 saa7146_unregister_device(&av7110->vbi_dev, av7110->dev);
826
827 saa7146_vv_release(dev);
828
829 return 0;
830 }
831
832
833
834 static struct saa7146_standard standard[] = {
835 {
836 .name = "PAL", .id = V4L2_STD_PAL_BG,
837 .v_offset = 0x15, .v_field = 288,
838 .h_offset = 0x48, .h_pixels = 708,
839 .v_max_out = 576, .h_max_out = 768,
840 }, {
841 .name = "NTSC", .id = V4L2_STD_NTSC,
842 .v_offset = 0x10, .v_field = 244,
843 .h_offset = 0x40, .h_pixels = 708,
844 .v_max_out = 480, .h_max_out = 640,
845 }
846 };
847
848 static struct saa7146_standard analog_standard[] = {
849 {
850 .name = "PAL", .id = V4L2_STD_PAL_BG,
851 .v_offset = 0x1b, .v_field = 288,
852 .h_offset = 0x08, .h_pixels = 708,
853 .v_max_out = 576, .h_max_out = 768,
854 }, {
855 .name = "NTSC", .id = V4L2_STD_NTSC,
856 .v_offset = 0x10, .v_field = 244,
857 .h_offset = 0x40, .h_pixels = 708,
858 .v_max_out = 480, .h_max_out = 640,
859 }
860 };
861
862 static struct saa7146_standard dvb_standard[] = {
863 {
864 .name = "PAL", .id = V4L2_STD_PAL_BG,
865 .v_offset = 0x14, .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 int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
877 {
878 struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
879
880 if (std->id & V4L2_STD_PAL) {
881 av7110->vidmode = AV7110_VIDEO_MODE_PAL;
882 av7110_set_vidmode(av7110, av7110->vidmode);
883 }
884 else if (std->id & V4L2_STD_NTSC) {
885 av7110->vidmode = AV7110_VIDEO_MODE_NTSC;
886 av7110_set_vidmode(av7110, av7110->vidmode);
887 }
888 else
889 return -1;
890
891 return 0;
892 }
893
894
895 static struct saa7146_ext_vv av7110_vv_data_st = {
896 .inputs = 1,
897 .audios = 1,
898 .capabilities = V4L2_CAP_SLICED_VBI_OUTPUT,
899 .flags = 0,
900
901 .stds = &standard[0],
902 .num_stds = ARRAY_SIZE(standard),
903 .std_callback = &std_callback,
904
905 .vbi_fops.open = av7110_vbi_reset,
906 .vbi_fops.release = av7110_vbi_reset,
907 .vbi_fops.write = av7110_vbi_write,
908 };
909
910 static struct saa7146_ext_vv av7110_vv_data_c = {
911 .inputs = 1,
912 .audios = 1,
913 .capabilities = V4L2_CAP_TUNER | V4L2_CAP_SLICED_VBI_OUTPUT,
914 .flags = SAA7146_USE_PORT_B_FOR_VBI,
915
916 .stds = &standard[0],
917 .num_stds = ARRAY_SIZE(standard),
918 .std_callback = &std_callback,
919
920 .vbi_fops.open = av7110_vbi_reset,
921 .vbi_fops.release = av7110_vbi_reset,
922 .vbi_fops.write = av7110_vbi_write,
923 };
Tomato firmware and modifications.