Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
av7110_v4l.c
Go to the documentation of this file.
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 <[email protected]>
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 = 1,
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 input ? -EINVAL : 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_enumaudio(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  *a = msp3400_v4l2_audio;
512  return 0;
513 }
514 
515 static int vidioc_g_audio(struct file *file, void *fh, 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_G_AUDIO: %d\n", a->index);
521  if (a->index != 0)
522  return -EINVAL;
523  if (av7110->current_input >= 2)
524  return -EINVAL;
525  *a = msp3400_v4l2_audio;
526  return 0;
527 }
528 
529 static int vidioc_s_audio(struct file *file, void *fh, const struct v4l2_audio *a)
530 {
531  struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
532  struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
533 
534  dprintk(2, "VIDIOC_S_AUDIO: %d\n", a->index);
535  if (av7110->current_input >= 2)
536  return -EINVAL;
537  return a->index ? -EINVAL : 0;
538 }
539 
540 static int vidioc_g_sliced_vbi_cap(struct file *file, void *fh,
541  struct v4l2_sliced_vbi_cap *cap)
542 {
543  struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
544  struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
545 
546  dprintk(2, "VIDIOC_G_SLICED_VBI_CAP\n");
547  if (cap->type != V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
548  return -EINVAL;
549  if (FW_VERSION(av7110->arm_app) >= 0x2623) {
550  cap->service_set = V4L2_SLICED_WSS_625;
551  cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
552  }
553  return 0;
554 }
555 
556 static int vidioc_g_fmt_sliced_vbi_out(struct file *file, void *fh,
557  struct v4l2_format *f)
558 {
559  struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
560  struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
561 
562  dprintk(2, "VIDIOC_G_FMT:\n");
563  if (FW_VERSION(av7110->arm_app) < 0x2623)
564  return -EINVAL;
565  memset(&f->fmt.sliced, 0, sizeof f->fmt.sliced);
566  if (av7110->wssMode) {
567  f->fmt.sliced.service_set = V4L2_SLICED_WSS_625;
568  f->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
569  f->fmt.sliced.io_size = sizeof(struct v4l2_sliced_vbi_data);
570  }
571  return 0;
572 }
573 
574 static int vidioc_s_fmt_sliced_vbi_out(struct file *file, void *fh,
575  struct v4l2_format *f)
576 {
577  struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
578  struct av7110 *av7110 = (struct av7110 *)dev->ext_priv;
579 
580  dprintk(2, "VIDIOC_S_FMT\n");
581  if (FW_VERSION(av7110->arm_app) < 0x2623)
582  return -EINVAL;
583  if (f->fmt.sliced.service_set != V4L2_SLICED_WSS_625 &&
584  f->fmt.sliced.service_lines[0][23] != V4L2_SLICED_WSS_625) {
585  memset(&f->fmt.sliced, 0, sizeof(f->fmt.sliced));
586  /* WSS controlled by firmware */
587  av7110->wssMode = 0;
588  av7110->wssData = 0;
589  return av7110_fw_cmd(av7110, COMTYPE_ENCODER,
590  SetWSSConfig, 1, 0);
591  } else {
592  memset(&f->fmt.sliced, 0, sizeof(f->fmt.sliced));
593  f->fmt.sliced.service_set = V4L2_SLICED_WSS_625;
594  f->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
595  f->fmt.sliced.io_size = sizeof(struct v4l2_sliced_vbi_data);
596  /* WSS controlled by userspace */
597  av7110->wssMode = 1;
598  av7110->wssData = 0;
599  }
600  return 0;
601 }
602 
603 static int av7110_vbi_reset(struct file *file)
604 {
605  struct saa7146_fh *fh = file->private_data;
606  struct saa7146_dev *dev = fh->dev;
607  struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
608 
609  dprintk(2, "%s\n", __func__);
610  av7110->wssMode = 0;
611  av7110->wssData = 0;
612  if (FW_VERSION(av7110->arm_app) < 0x2623)
613  return 0;
614  else
615  return av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 1, 0);
616 }
617 
618 static ssize_t av7110_vbi_write(struct file *file, const char __user *data, size_t count, loff_t *ppos)
619 {
620  struct saa7146_fh *fh = file->private_data;
621  struct saa7146_dev *dev = fh->dev;
622  struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
623  struct v4l2_sliced_vbi_data d;
624  int rc;
625 
626  dprintk(2, "%s\n", __func__);
627  if (FW_VERSION(av7110->arm_app) < 0x2623 || !av7110->wssMode || count != sizeof d)
628  return -EINVAL;
629  if (copy_from_user(&d, data, count))
630  return -EFAULT;
631  if ((d.id != 0 && d.id != V4L2_SLICED_WSS_625) || d.field != 0 || d.line != 23)
632  return -EINVAL;
633  if (d.id)
634  av7110->wssData = ((d.data[1] << 8) & 0x3f00) | d.data[0];
635  else
636  av7110->wssData = 0x8000;
637  rc = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 1, av7110->wssData);
638  return (rc < 0) ? rc : count;
639 }
640 
641 /****************************************************************************
642  * INITIALIZATION
643  ****************************************************************************/
644 
645 static u8 saa7113_init_regs[] = {
646  0x02, 0xd0,
647  0x03, 0x23,
648  0x04, 0x00,
649  0x05, 0x00,
650  0x06, 0xe9,
651  0x07, 0x0d,
652  0x08, 0x98,
653  0x09, 0x02,
654  0x0a, 0x80,
655  0x0b, 0x40,
656  0x0c, 0x40,
657  0x0d, 0x00,
658  0x0e, 0x01,
659  0x0f, 0x7c,
660  0x10, 0x48,
661  0x11, 0x0c,
662  0x12, 0x8b,
663  0x13, 0x1a,
664  0x14, 0x00,
665  0x15, 0x00,
666  0x16, 0x00,
667  0x17, 0x00,
668  0x18, 0x00,
669  0x19, 0x00,
670  0x1a, 0x00,
671  0x1b, 0x00,
672  0x1c, 0x00,
673  0x1d, 0x00,
674  0x1e, 0x00,
675 
676  0x41, 0x77,
677  0x42, 0x77,
678  0x43, 0x77,
679  0x44, 0x77,
680  0x45, 0x77,
681  0x46, 0x77,
682  0x47, 0x77,
683  0x48, 0x77,
684  0x49, 0x77,
685  0x4a, 0x77,
686  0x4b, 0x77,
687  0x4c, 0x77,
688  0x4d, 0x77,
689  0x4e, 0x77,
690  0x4f, 0x77,
691  0x50, 0x77,
692  0x51, 0x77,
693  0x52, 0x77,
694  0x53, 0x77,
695  0x54, 0x77,
696  0x55, 0x77,
697  0x56, 0x77,
698  0x57, 0xff,
699 
700  0xff
701 };
702 
703 
704 static struct saa7146_ext_vv av7110_vv_data_st;
705 static struct saa7146_ext_vv av7110_vv_data_c;
706 
707 int av7110_init_analog_module(struct av7110 *av7110)
708 {
709  u16 version1, version2;
710 
711  if (i2c_writereg(av7110, 0x80, 0x0, 0x80) == 1 &&
712  i2c_writereg(av7110, 0x80, 0x0, 0) == 1) {
713  pr_info("DVB-C analog module @ card %d detected, initializing MSP3400\n",
714  av7110->dvb_adapter.num);
715  av7110->adac_type = DVB_ADAC_MSP34x0;
716  } else if (i2c_writereg(av7110, 0x84, 0x0, 0x80) == 1 &&
717  i2c_writereg(av7110, 0x84, 0x0, 0) == 1) {
718  pr_info("DVB-C analog module @ card %d detected, initializing MSP3415\n",
719  av7110->dvb_adapter.num);
720  av7110->adac_type = DVB_ADAC_MSP34x5;
721  } else
722  return -ENODEV;
723 
724  msleep(100); // the probing above resets the msp...
725  msp_readreg(av7110, MSP_RD_DSP, 0x001e, &version1);
726  msp_readreg(av7110, MSP_RD_DSP, 0x001f, &version2);
727  dprintk(1, "dvb-ttpci: @ card %d MSP34xx version 0x%04x 0x%04x\n",
728  av7110->dvb_adapter.num, version1, version2);
729  msp_writereg(av7110, MSP_WR_DSP, 0x0013, 0x0c00);
730  msp_writereg(av7110, MSP_WR_DSP, 0x0000, 0x7f00); // loudspeaker + headphone
731  msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220); // loudspeaker source
732  msp_writereg(av7110, MSP_WR_DSP, 0x0009, 0x0220); // headphone source
733  msp_writereg(av7110, MSP_WR_DSP, 0x0004, 0x7f00); // loudspeaker volume
734  msp_writereg(av7110, MSP_WR_DSP, 0x000a, 0x0220); // SCART 1 source
735  msp_writereg(av7110, MSP_WR_DSP, 0x0007, 0x7f00); // SCART 1 volume
736  msp_writereg(av7110, MSP_WR_DSP, 0x000d, 0x1900); // prescale SCART
737 
738  if (i2c_writereg(av7110, 0x48, 0x01, 0x00)!=1) {
739  pr_info("saa7113 not accessible\n");
740  } else {
741  u8 *i = saa7113_init_regs;
742 
743  if ((av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
744  /* Fujitsu/Siemens DVB-Cable */
745  av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
746  } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x0002)) {
747  /* Hauppauge/TT DVB-C premium */
748  av7110->analog_tuner_flags |= ANALOG_TUNER_VES1820;
749  } else if ((av7110->dev->pci->subsystem_vendor == 0x13c2) && (av7110->dev->pci->subsystem_device == 0x000A)) {
750  /* Hauppauge/TT DVB-C premium */
751  av7110->analog_tuner_flags |= ANALOG_TUNER_STV0297;
752  }
753 
754  /* setup for DVB by default */
755  if (av7110->analog_tuner_flags & ANALOG_TUNER_VES1820) {
756  if (ves1820_writereg(av7110->dev, 0x09, 0x0f, 0x20))
757  dprintk(1, "setting band in demodulator failed\n");
758  } else if (av7110->analog_tuner_flags & ANALOG_TUNER_STV0297) {
759  saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
760  saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
761  }
762 
763  /* init the saa7113 */
764  while (*i != 0xff) {
765  if (i2c_writereg(av7110, 0x48, i[0], i[1]) != 1) {
766  dprintk(1, "saa7113 initialization failed @ card %d", av7110->dvb_adapter.num);
767  break;
768  }
769  i += 2;
770  }
771  /* setup msp for analog sound: B/G Dual-FM */
772  msp_writereg(av7110, MSP_WR_DEM, 0x00bb, 0x02d0); // AD_CV
773  msp_writereg(av7110, MSP_WR_DEM, 0x0001, 3); // FIR1
774  msp_writereg(av7110, MSP_WR_DEM, 0x0001, 18); // FIR1
775  msp_writereg(av7110, MSP_WR_DEM, 0x0001, 27); // FIR1
776  msp_writereg(av7110, MSP_WR_DEM, 0x0001, 48); // FIR1
777  msp_writereg(av7110, MSP_WR_DEM, 0x0001, 66); // FIR1
778  msp_writereg(av7110, MSP_WR_DEM, 0x0001, 72); // FIR1
779  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 4); // FIR2
780  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 64); // FIR2
781  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 0); // FIR2
782  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 3); // FIR2
783  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 18); // FIR2
784  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 27); // FIR2
785  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 48); // FIR2
786  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 66); // FIR2
787  msp_writereg(av7110, MSP_WR_DEM, 0x0005, 72); // FIR2
788  msp_writereg(av7110, MSP_WR_DEM, 0x0083, 0xa000); // MODE_REG
789  msp_writereg(av7110, MSP_WR_DEM, 0x0093, 0x00aa); // DCO1_LO 5.74MHz
790  msp_writereg(av7110, MSP_WR_DEM, 0x009b, 0x04fc); // DCO1_HI
791  msp_writereg(av7110, MSP_WR_DEM, 0x00a3, 0x038e); // DCO2_LO 5.5MHz
792  msp_writereg(av7110, MSP_WR_DEM, 0x00ab, 0x04c6); // DCO2_HI
793  msp_writereg(av7110, MSP_WR_DEM, 0x0056, 0); // LOAD_REG 1/2
794  }
795 
796  memcpy(standard, dvb_standard, sizeof(struct saa7146_standard) * 2);
797  /* set dd1 stream a & b */
798  saa7146_write(av7110->dev, DD1_STREAM_B, 0x00000000);
799  saa7146_write(av7110->dev, DD1_INIT, 0x03000700);
800  saa7146_write(av7110->dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
801 
802  return 0;
803 }
804 
805 int av7110_init_v4l(struct av7110 *av7110)
806 {
807  struct saa7146_dev* dev = av7110->dev;
808  struct saa7146_ext_vv *vv_data;
809  int ret;
810 
811  /* special case DVB-C: these cards have an analog tuner
812  plus need some special handling, so we have separate
813  saa7146_ext_vv data for these... */
814  if (av7110->analog_tuner_flags)
815  vv_data = &av7110_vv_data_c;
816  else
817  vv_data = &av7110_vv_data_st;
818  ret = saa7146_vv_init(dev, vv_data);
819 
820  if (ret) {
821  ERR("cannot init capture device. skipping\n");
822  return -ENODEV;
823  }
824  vv_data->vid_ops.vidioc_enum_input = vidioc_enum_input;
825  vv_data->vid_ops.vidioc_g_input = vidioc_g_input;
826  vv_data->vid_ops.vidioc_s_input = vidioc_s_input;
827  vv_data->vid_ops.vidioc_g_tuner = vidioc_g_tuner;
828  vv_data->vid_ops.vidioc_s_tuner = vidioc_s_tuner;
829  vv_data->vid_ops.vidioc_g_frequency = vidioc_g_frequency;
830  vv_data->vid_ops.vidioc_s_frequency = vidioc_s_frequency;
831  vv_data->vid_ops.vidioc_enumaudio = vidioc_enumaudio;
832  vv_data->vid_ops.vidioc_g_audio = vidioc_g_audio;
833  vv_data->vid_ops.vidioc_s_audio = vidioc_s_audio;
834  vv_data->vid_ops.vidioc_g_fmt_vbi_cap = NULL;
835 
836  vv_data->vbi_ops.vidioc_g_tuner = vidioc_g_tuner;
837  vv_data->vbi_ops.vidioc_s_tuner = vidioc_s_tuner;
838  vv_data->vbi_ops.vidioc_g_frequency = vidioc_g_frequency;
839  vv_data->vbi_ops.vidioc_s_frequency = vidioc_s_frequency;
840  vv_data->vbi_ops.vidioc_g_fmt_vbi_cap = NULL;
841  vv_data->vbi_ops.vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap;
842  vv_data->vbi_ops.vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out;
843  vv_data->vbi_ops.vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out;
844 
845  if (FW_VERSION(av7110->arm_app) < 0x2623)
846  vv_data->capabilities &= ~V4L2_CAP_SLICED_VBI_OUTPUT;
847 
848  if (saa7146_register_device(&av7110->v4l_dev, dev, "av7110", VFL_TYPE_GRABBER)) {
849  ERR("cannot register capture device. skipping\n");
850  saa7146_vv_release(dev);
851  return -ENODEV;
852  }
853  if (FW_VERSION(av7110->arm_app) >= 0x2623) {
854  if (saa7146_register_device(&av7110->vbi_dev, dev, "av7110", VFL_TYPE_VBI))
855  ERR("cannot register vbi v4l2 device. skipping\n");
856  }
857  return 0;
858 }
859 
860 int av7110_exit_v4l(struct av7110 *av7110)
861 {
862  struct saa7146_dev* dev = av7110->dev;
863 
864  saa7146_unregister_device(&av7110->v4l_dev, av7110->dev);
865  saa7146_unregister_device(&av7110->vbi_dev, av7110->dev);
866 
867  saa7146_vv_release(dev);
868 
869  return 0;
870 }
871 
872 
873 
874 /* FIXME: these values are experimental values that look better than the
875  values from the latest "official" driver -- at least for me... (MiHu) */
876 static struct saa7146_standard standard[] = {
877  {
878  .name = "PAL", .id = V4L2_STD_PAL_BG,
879  .v_offset = 0x15, .v_field = 288,
880  .h_offset = 0x48, .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 analog_standard[] = {
891  {
892  .name = "PAL", .id = V4L2_STD_PAL_BG,
893  .v_offset = 0x1b, .v_field = 288,
894  .h_offset = 0x08, .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 struct saa7146_standard dvb_standard[] = {
905  {
906  .name = "PAL", .id = V4L2_STD_PAL_BG,
907  .v_offset = 0x14, .v_field = 288,
908  .h_offset = 0x48, .h_pixels = 708,
909  .v_max_out = 576, .h_max_out = 768,
910  }, {
911  .name = "NTSC", .id = V4L2_STD_NTSC,
912  .v_offset = 0x10, .v_field = 244,
913  .h_offset = 0x40, .h_pixels = 708,
914  .v_max_out = 480, .h_max_out = 640,
915  }
916 };
917 
918 static int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
919 {
920  struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
921 
922  if (std->id & V4L2_STD_PAL) {
923  av7110->vidmode = AV7110_VIDEO_MODE_PAL;
924  av7110_set_vidmode(av7110, av7110->vidmode);
925  }
926  else if (std->id & V4L2_STD_NTSC) {
927  av7110->vidmode = AV7110_VIDEO_MODE_NTSC;
928  av7110_set_vidmode(av7110, av7110->vidmode);
929  }
930  else
931  return -1;
932 
933  return 0;
934 }
935 
936 
937 static struct saa7146_ext_vv av7110_vv_data_st = {
938  .inputs = 1,
939  .audios = 1,
940  .capabilities = V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO,
941  .flags = 0,
942 
943  .stds = &standard[0],
944  .num_stds = ARRAY_SIZE(standard),
945  .std_callback = &std_callback,
946 
947  .vbi_fops.open = av7110_vbi_reset,
948  .vbi_fops.release = av7110_vbi_reset,
949  .vbi_fops.write = av7110_vbi_write,
950 };
951 
952 static struct saa7146_ext_vv av7110_vv_data_c = {
953  .inputs = 1,
954  .audios = 1,
955  .capabilities = V4L2_CAP_TUNER | V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO,
956  .flags = SAA7146_USE_PORT_B_FOR_VBI,
957 
958  .stds = &standard[0],
959  .num_stds = ARRAY_SIZE(standard),
960  .std_callback = &std_callback,
961 
962  .vbi_fops.open = av7110_vbi_reset,
963  .vbi_fops.release = av7110_vbi_reset,
964  .vbi_fops.write = av7110_vbi_write,
965 };
966 
Generated on Thu Jan 10 2013 13:48:58 for Linux Kernel by   doxygen 1.8.2