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