Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tuner-simple.c
Go to the documentation of this file.
1 /*
2  * i2c tv tuner chip device driver
3  * controls all those simple 4-control-bytes style tuners.
4  *
5  * This "tuner-simple" module was split apart from the original "tuner" module.
6  */
7 #include <linux/delay.h>
8 #include <linux/i2c.h>
9 #include <linux/videodev2.h>
10 #include <media/tuner.h>
11 #include <media/v4l2-common.h>
12 #include <media/tuner-types.h>
13 #include "tuner-i2c.h"
14 #include "tuner-simple.h"
15 
16 static int debug;
17 module_param(debug, int, 0644);
18 MODULE_PARM_DESC(debug, "enable verbose debug messages");
19 
20 #define TUNER_SIMPLE_MAX 64
21 static unsigned int simple_devcount;
22 
23 static int offset;
24 module_param(offset, int, 0664);
25 MODULE_PARM_DESC(offset, "Allows to specify an offset for tuner");
26 
27 static unsigned int atv_input[TUNER_SIMPLE_MAX] = \
28  { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 };
29 static unsigned int dtv_input[TUNER_SIMPLE_MAX] = \
30  { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 };
31 module_param_array(atv_input, int, NULL, 0644);
32 module_param_array(dtv_input, int, NULL, 0644);
33 MODULE_PARM_DESC(atv_input, "specify atv rf input, 0 for autoselect");
34 MODULE_PARM_DESC(dtv_input, "specify dtv rf input, 0 for autoselect");
35 
36 /* ---------------------------------------------------------------------- */
37 
38 /* tv standard selection for Temic 4046 FM5
39  this value takes the low bits of control byte 2
40  from datasheet Rev.01, Feb.00
41  standard BG I L L2 D
42  picture IF 38.9 38.9 38.9 33.95 38.9
43  sound 1 33.4 32.9 32.4 40.45 32.4
44  sound 2 33.16
45  NICAM 33.05 32.348 33.05 33.05
46  */
47 #define TEMIC_SET_PAL_I 0x05
48 #define TEMIC_SET_PAL_DK 0x09
49 #define TEMIC_SET_PAL_L 0x0a /* SECAM ? */
50 #define TEMIC_SET_PAL_L2 0x0b /* change IF ! */
51 #define TEMIC_SET_PAL_BG 0x0c
52 
53 /* tv tuner system standard selection for Philips FQ1216ME
54  this value takes the low bits of control byte 2
55  from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
56  standard BG DK I L L`
57  picture carrier 38.90 38.90 38.90 38.90 33.95
58  colour 34.47 34.47 34.47 34.47 38.38
59  sound 1 33.40 32.40 32.90 32.40 40.45
60  sound 2 33.16 - - - -
61  NICAM 33.05 33.05 32.35 33.05 39.80
62  */
63 #define PHILIPS_SET_PAL_I 0x01 /* Bit 2 always zero !*/
64 #define PHILIPS_SET_PAL_BGDK 0x09
65 #define PHILIPS_SET_PAL_L2 0x0a
66 #define PHILIPS_SET_PAL_L 0x0b
67 
68 /* system switching for Philips FI1216MF MK2
69  from datasheet "1996 Jul 09",
70  standard BG L L'
71  picture carrier 38.90 38.90 33.95
72  colour 34.47 34.37 38.38
73  sound 1 33.40 32.40 40.45
74  sound 2 33.16 - -
75  NICAM 33.05 33.05 39.80
76  */
77 #define PHILIPS_MF_SET_STD_BG 0x01 /* Bit 2 must be zero, Bit 3 is system output */
78 #define PHILIPS_MF_SET_STD_L 0x03 /* Used on Secam France */
79 #define PHILIPS_MF_SET_STD_LC 0x02 /* Used on SECAM L' */
80 
81 /* Control byte */
82 
83 #define TUNER_RATIO_MASK 0x06 /* Bit cb1:cb2 */
84 #define TUNER_RATIO_SELECT_50 0x00
85 #define TUNER_RATIO_SELECT_32 0x02
86 #define TUNER_RATIO_SELECT_166 0x04
87 #define TUNER_RATIO_SELECT_62 0x06
88 
89 #define TUNER_CHARGE_PUMP 0x40 /* Bit cb6 */
90 
91 /* Status byte */
92 
93 #define TUNER_POR 0x80
94 #define TUNER_FL 0x40
95 #define TUNER_MODE 0x38
96 #define TUNER_AFC 0x07
97 #define TUNER_SIGNAL 0x07
98 #define TUNER_STEREO 0x10
99 
100 #define TUNER_PLL_LOCKED 0x40
101 #define TUNER_STEREO_MK3 0x04
102 
103 static DEFINE_MUTEX(tuner_simple_list_mutex);
104 static LIST_HEAD(hybrid_tuner_instance_list);
105 
106 struct tuner_simple_priv {
107  unsigned int nr;
108  u16 last_div;
109 
110  struct tuner_i2c_props i2c_props;
111  struct list_head hybrid_tuner_instance_list;
112 
113  unsigned int type;
114  struct tunertype *tun;
115 
116  u32 frequency;
117  u32 bandwidth;
118 };
119 
120 /* ---------------------------------------------------------------------- */
121 
122 static int tuner_read_status(struct dvb_frontend *fe)
123 {
124  struct tuner_simple_priv *priv = fe->tuner_priv;
125  unsigned char byte;
126 
127  if (1 != tuner_i2c_xfer_recv(&priv->i2c_props, &byte, 1))
128  return 0;
129 
130  return byte;
131 }
132 
133 static inline int tuner_signal(const int status)
134 {
135  return (status & TUNER_SIGNAL) << 13;
136 }
137 
138 static inline int tuner_stereo(const int type, const int status)
139 {
140  switch (type) {
141  case TUNER_PHILIPS_FM1216ME_MK3:
142  case TUNER_PHILIPS_FM1236_MK3:
143  case TUNER_PHILIPS_FM1256_IH3:
144  case TUNER_LG_NTSC_TAPE:
145  case TUNER_TCL_MF02GIP_5N:
146  return ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);
147  case TUNER_PHILIPS_FM1216MK5:
148  return status | TUNER_STEREO;
149  default:
150  return status & TUNER_STEREO;
151  }
152 }
153 
154 static inline int tuner_islocked(const int status)
155 {
156  return (status & TUNER_FL);
157 }
158 
159 static inline int tuner_afcstatus(const int status)
160 {
161  return (status & TUNER_AFC) - 2;
162 }
163 
164 
165 static int simple_get_status(struct dvb_frontend *fe, u32 *status)
166 {
167  struct tuner_simple_priv *priv = fe->tuner_priv;
168  int tuner_status;
169 
170  if (priv->i2c_props.adap == NULL)
171  return -EINVAL;
172 
173  tuner_status = tuner_read_status(fe);
174 
175  *status = 0;
176 
177  if (tuner_islocked(tuner_status))
178  *status = TUNER_STATUS_LOCKED;
179  if (tuner_stereo(priv->type, tuner_status))
180  *status |= TUNER_STATUS_STEREO;
181 
182  tuner_dbg("AFC Status: %d\n", tuner_afcstatus(tuner_status));
183 
184  return 0;
185 }
186 
187 static int simple_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
188 {
189  struct tuner_simple_priv *priv = fe->tuner_priv;
190  int signal;
191 
192  if (priv->i2c_props.adap == NULL)
193  return -EINVAL;
194 
195  signal = tuner_signal(tuner_read_status(fe));
196 
197  *strength = signal;
198 
199  tuner_dbg("Signal strength: %d\n", signal);
200 
201  return 0;
202 }
203 
204 /* ---------------------------------------------------------------------- */
205 
206 static inline char *tuner_param_name(enum param_type type)
207 {
208  char *name;
209 
210  switch (type) {
211  case TUNER_PARAM_TYPE_RADIO:
212  name = "radio";
213  break;
214  case TUNER_PARAM_TYPE_PAL:
215  name = "pal";
216  break;
217  case TUNER_PARAM_TYPE_SECAM:
218  name = "secam";
219  break;
220  case TUNER_PARAM_TYPE_NTSC:
221  name = "ntsc";
222  break;
223  case TUNER_PARAM_TYPE_DIGITAL:
224  name = "digital";
225  break;
226  default:
227  name = "unknown";
228  break;
229  }
230  return name;
231 }
232 
233 static struct tuner_params *simple_tuner_params(struct dvb_frontend *fe,
234  enum param_type desired_type)
235 {
236  struct tuner_simple_priv *priv = fe->tuner_priv;
237  struct tunertype *tun = priv->tun;
238  int i;
239 
240  for (i = 0; i < tun->count; i++)
241  if (desired_type == tun->params[i].type)
242  break;
243 
244  /* use default tuner params if desired_type not available */
245  if (i == tun->count) {
246  tuner_dbg("desired params (%s) undefined for tuner %d\n",
247  tuner_param_name(desired_type), priv->type);
248  i = 0;
249  }
250 
251  tuner_dbg("using tuner params #%d (%s)\n", i,
252  tuner_param_name(tun->params[i].type));
253 
254  return &tun->params[i];
255 }
256 
257 static int simple_config_lookup(struct dvb_frontend *fe,
258  struct tuner_params *t_params,
259  unsigned *frequency, u8 *config, u8 *cb)
260 {
261  struct tuner_simple_priv *priv = fe->tuner_priv;
262  int i;
263 
264  for (i = 0; i < t_params->count; i++) {
265  if (*frequency > t_params->ranges[i].limit)
266  continue;
267  break;
268  }
269  if (i == t_params->count) {
270  tuner_dbg("frequency out of range (%d > %d)\n",
271  *frequency, t_params->ranges[i - 1].limit);
272  *frequency = t_params->ranges[--i].limit;
273  }
274  *config = t_params->ranges[i].config;
275  *cb = t_params->ranges[i].cb;
276 
277  tuner_dbg("freq = %d.%02d (%d), range = %d, "
278  "config = 0x%02x, cb = 0x%02x\n",
279  *frequency / 16, *frequency % 16 * 100 / 16, *frequency,
280  i, *config, *cb);
281 
282  return i;
283 }
284 
285 /* ---------------------------------------------------------------------- */
286 
287 static void simple_set_rf_input(struct dvb_frontend *fe,
288  u8 *config, u8 *cb, unsigned int rf)
289 {
290  struct tuner_simple_priv *priv = fe->tuner_priv;
291 
292  switch (priv->type) {
293  case TUNER_PHILIPS_TUV1236D:
294  switch (rf) {
295  case 1:
296  *cb |= 0x08;
297  break;
298  default:
299  *cb &= ~0x08;
300  break;
301  }
302  break;
303  case TUNER_PHILIPS_FCV1236D:
304  switch (rf) {
305  case 1:
306  *cb |= 0x01;
307  break;
308  default:
309  *cb &= ~0x01;
310  break;
311  }
312  break;
313  default:
314  break;
315  }
316 }
317 
318 static int simple_std_setup(struct dvb_frontend *fe,
319  struct analog_parameters *params,
320  u8 *config, u8 *cb)
321 {
322  struct tuner_simple_priv *priv = fe->tuner_priv;
323  int rc;
324 
325  /* tv norm specific stuff for multi-norm tuners */
326  switch (priv->type) {
327  case TUNER_PHILIPS_SECAM: /* FI1216MF */
328  /* 0x01 -> ??? no change ??? */
329  /* 0x02 -> PAL BDGHI / SECAM L */
330  /* 0x04 -> ??? PAL others / SECAM others ??? */
331  *cb &= ~0x03;
332  if (params->std & V4L2_STD_SECAM_L)
333  /* also valid for V4L2_STD_SECAM */
334  *cb |= PHILIPS_MF_SET_STD_L;
335  else if (params->std & V4L2_STD_SECAM_LC)
336  *cb |= PHILIPS_MF_SET_STD_LC;
337  else /* V4L2_STD_B|V4L2_STD_GH */
338  *cb |= PHILIPS_MF_SET_STD_BG;
339  break;
340 
341  case TUNER_TEMIC_4046FM5:
342  *cb &= ~0x0f;
343 
344  if (params->std & V4L2_STD_PAL_BG) {
345  *cb |= TEMIC_SET_PAL_BG;
346 
347  } else if (params->std & V4L2_STD_PAL_I) {
348  *cb |= TEMIC_SET_PAL_I;
349 
350  } else if (params->std & V4L2_STD_PAL_DK) {
351  *cb |= TEMIC_SET_PAL_DK;
352 
353  } else if (params->std & V4L2_STD_SECAM_L) {
354  *cb |= TEMIC_SET_PAL_L;
355 
356  }
357  break;
358 
359  case TUNER_PHILIPS_FQ1216ME:
360  *cb &= ~0x0f;
361 
362  if (params->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
363  *cb |= PHILIPS_SET_PAL_BGDK;
364 
365  } else if (params->std & V4L2_STD_PAL_I) {
366  *cb |= PHILIPS_SET_PAL_I;
367 
368  } else if (params->std & V4L2_STD_SECAM_L) {
369  *cb |= PHILIPS_SET_PAL_L;
370 
371  }
372  break;
373 
374  case TUNER_PHILIPS_FCV1236D:
375  /* 0x00 -> ATSC antenna input 1 */
376  /* 0x01 -> ATSC antenna input 2 */
377  /* 0x02 -> NTSC antenna input 1 */
378  /* 0x03 -> NTSC antenna input 2 */
379  *cb &= ~0x03;
380  if (!(params->std & V4L2_STD_ATSC))
381  *cb |= 2;
382  break;
383 
384  case TUNER_MICROTUNE_4042FI5:
385  /* Set the charge pump for fast tuning */
386  *config |= TUNER_CHARGE_PUMP;
387  break;
388 
389  case TUNER_PHILIPS_TUV1236D:
390  {
391  struct tuner_i2c_props i2c = priv->i2c_props;
392  /* 0x40 -> ATSC antenna input 1 */
393  /* 0x48 -> ATSC antenna input 2 */
394  /* 0x00 -> NTSC antenna input 1 */
395  /* 0x08 -> NTSC antenna input 2 */
396  u8 buffer[4] = { 0x14, 0x00, 0x17, 0x00};
397  *cb &= ~0x40;
398  if (params->std & V4L2_STD_ATSC) {
399  *cb |= 0x40;
400  buffer[1] = 0x04;
401  }
402  /* set to the correct mode (analog or digital) */
403  i2c.addr = 0x0a;
404  rc = tuner_i2c_xfer_send(&i2c, &buffer[0], 2);
405  if (2 != rc)
406  tuner_warn("i2c i/o error: rc == %d "
407  "(should be 2)\n", rc);
408  rc = tuner_i2c_xfer_send(&i2c, &buffer[2], 2);
409  if (2 != rc)
410  tuner_warn("i2c i/o error: rc == %d "
411  "(should be 2)\n", rc);
412  break;
413  }
414  }
415  if (atv_input[priv->nr])
416  simple_set_rf_input(fe, config, cb, atv_input[priv->nr]);
417 
418  return 0;
419 }
420 
421 static int simple_set_aux_byte(struct dvb_frontend *fe, u8 config, u8 aux)
422 {
423  struct tuner_simple_priv *priv = fe->tuner_priv;
424  int rc;
425  u8 buffer[2];
426 
427  buffer[0] = (config & ~0x38) | 0x18;
428  buffer[1] = aux;
429 
430  tuner_dbg("setting aux byte: 0x%02x 0x%02x\n", buffer[0], buffer[1]);
431 
432  rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 2);
433  if (2 != rc)
434  tuner_warn("i2c i/o error: rc == %d (should be 2)\n", rc);
435 
436  return rc == 2 ? 0 : rc;
437 }
438 
439 static int simple_post_tune(struct dvb_frontend *fe, u8 *buffer,
440  u16 div, u8 config, u8 cb)
441 {
442  struct tuner_simple_priv *priv = fe->tuner_priv;
443  int rc;
444 
445  switch (priv->type) {
446  case TUNER_LG_TDVS_H06XF:
447  simple_set_aux_byte(fe, config, 0x20);
448  break;
449  case TUNER_PHILIPS_FQ1216LME_MK3:
450  simple_set_aux_byte(fe, config, 0x60); /* External AGC */
451  break;
452  case TUNER_MICROTUNE_4042FI5:
453  {
454  /* FIXME - this may also work for other tuners */
455  unsigned long timeout = jiffies + msecs_to_jiffies(1);
456  u8 status_byte = 0;
457 
458  /* Wait until the PLL locks */
459  for (;;) {
460  if (time_after(jiffies, timeout))
461  return 0;
462  rc = tuner_i2c_xfer_recv(&priv->i2c_props,
463  &status_byte, 1);
464  if (1 != rc) {
465  tuner_warn("i2c i/o read error: rc == %d "
466  "(should be 1)\n", rc);
467  break;
468  }
469  if (status_byte & TUNER_PLL_LOCKED)
470  break;
471  udelay(10);
472  }
473 
474  /* Set the charge pump for optimized phase noise figure */
475  config &= ~TUNER_CHARGE_PUMP;
476  buffer[0] = (div>>8) & 0x7f;
477  buffer[1] = div & 0xff;
478  buffer[2] = config;
479  buffer[3] = cb;
480  tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
481  buffer[0], buffer[1], buffer[2], buffer[3]);
482 
483  rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
484  if (4 != rc)
485  tuner_warn("i2c i/o error: rc == %d "
486  "(should be 4)\n", rc);
487  break;
488  }
489  }
490 
491  return 0;
492 }
493 
494 static int simple_radio_bandswitch(struct dvb_frontend *fe, u8 *buffer)
495 {
496  struct tuner_simple_priv *priv = fe->tuner_priv;
497 
498  switch (priv->type) {
499  case TUNER_TENA_9533_DI:
500  case TUNER_YMEC_TVF_5533MF:
501  tuner_dbg("This tuner doesn't have FM. "
502  "Most cards have a TEA5767 for FM\n");
503  return 0;
504  case TUNER_PHILIPS_FM1216ME_MK3:
505  case TUNER_PHILIPS_FM1236_MK3:
506  case TUNER_PHILIPS_FMD1216ME_MK3:
507  case TUNER_PHILIPS_FMD1216MEX_MK3:
508  case TUNER_LG_NTSC_TAPE:
509  case TUNER_PHILIPS_FM1256_IH3:
510  case TUNER_TCL_MF02GIP_5N:
511  buffer[3] = 0x19;
512  break;
513  case TUNER_PHILIPS_FM1216MK5:
514  buffer[2] = 0x88;
515  buffer[3] = 0x09;
516  break;
517  case TUNER_TNF_5335MF:
518  buffer[3] = 0x11;
519  break;
520  case TUNER_LG_PAL_FM:
521  buffer[3] = 0xa5;
522  break;
523  case TUNER_THOMSON_DTT761X:
524  buffer[3] = 0x39;
525  break;
526  case TUNER_PHILIPS_FQ1216LME_MK3:
527  case TUNER_PHILIPS_FQ1236_MK5:
528  tuner_err("This tuner doesn't have FM\n");
529  /* Set the low band for sanity, since it covers 88-108 MHz */
530  buffer[3] = 0x01;
531  break;
532  case TUNER_MICROTUNE_4049FM5:
533  default:
534  buffer[3] = 0xa4;
535  break;
536  }
537 
538  return 0;
539 }
540 
541 /* ---------------------------------------------------------------------- */
542 
543 static int simple_set_tv_freq(struct dvb_frontend *fe,
544  struct analog_parameters *params)
545 {
546  struct tuner_simple_priv *priv = fe->tuner_priv;
547  u8 config, cb;
548  u16 div;
549  u8 buffer[4];
550  int rc, IFPCoff, i;
551  enum param_type desired_type;
552  struct tuner_params *t_params;
553 
554  /* IFPCoff = Video Intermediate Frequency - Vif:
555  940 =16*58.75 NTSC/J (Japan)
556  732 =16*45.75 M/N STD
557  704 =16*44 ATSC (at DVB code)
558  632 =16*39.50 I U.K.
559  622.4=16*38.90 B/G D/K I, L STD
560  592 =16*37.00 D China
561  590 =16.36.875 B Australia
562  543.2=16*33.95 L' STD
563  171.2=16*10.70 FM Radio (at set_radio_freq)
564  */
565 
566  if (params->std == V4L2_STD_NTSC_M_JP) {
567  IFPCoff = 940;
568  desired_type = TUNER_PARAM_TYPE_NTSC;
569  } else if ((params->std & V4L2_STD_MN) &&
570  !(params->std & ~V4L2_STD_MN)) {
571  IFPCoff = 732;
572  desired_type = TUNER_PARAM_TYPE_NTSC;
573  } else if (params->std == V4L2_STD_SECAM_LC) {
574  IFPCoff = 543;
575  desired_type = TUNER_PARAM_TYPE_SECAM;
576  } else {
577  IFPCoff = 623;
578  desired_type = TUNER_PARAM_TYPE_PAL;
579  }
580 
581  t_params = simple_tuner_params(fe, desired_type);
582 
583  i = simple_config_lookup(fe, t_params, &params->frequency,
584  &config, &cb);
585 
586  div = params->frequency + IFPCoff + offset;
587 
588  tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, "
589  "Offset=%d.%02d MHz, div=%0d\n",
590  params->frequency / 16, params->frequency % 16 * 100 / 16,
591  IFPCoff / 16, IFPCoff % 16 * 100 / 16,
592  offset / 16, offset % 16 * 100 / 16, div);
593 
594  /* tv norm specific stuff for multi-norm tuners */
595  simple_std_setup(fe, params, &config, &cb);
596 
597  if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
598  buffer[0] = config;
599  buffer[1] = cb;
600  buffer[2] = (div>>8) & 0x7f;
601  buffer[3] = div & 0xff;
602  } else {
603  buffer[0] = (div>>8) & 0x7f;
604  buffer[1] = div & 0xff;
605  buffer[2] = config;
606  buffer[3] = cb;
607  }
608  priv->last_div = div;
609  if (t_params->has_tda9887) {
610  struct v4l2_priv_tun_config tda9887_cfg;
611  int tda_config = 0;
612  int is_secam_l = (params->std & (V4L2_STD_SECAM_L |
613  V4L2_STD_SECAM_LC)) &&
614  !(params->std & ~(V4L2_STD_SECAM_L |
615  V4L2_STD_SECAM_LC));
616 
617  tda9887_cfg.tuner = TUNER_TDA9887;
618  tda9887_cfg.priv = &tda_config;
619 
620  if (params->std == V4L2_STD_SECAM_LC) {
621  if (t_params->port1_active ^ t_params->port1_invert_for_secam_lc)
622  tda_config |= TDA9887_PORT1_ACTIVE;
623  if (t_params->port2_active ^ t_params->port2_invert_for_secam_lc)
624  tda_config |= TDA9887_PORT2_ACTIVE;
625  } else {
626  if (t_params->port1_active)
627  tda_config |= TDA9887_PORT1_ACTIVE;
628  if (t_params->port2_active)
629  tda_config |= TDA9887_PORT2_ACTIVE;
630  }
631  if (t_params->intercarrier_mode)
632  tda_config |= TDA9887_INTERCARRIER;
633  if (is_secam_l) {
634  if (i == 0 && t_params->default_top_secam_low)
635  tda_config |= TDA9887_TOP(t_params->default_top_secam_low);
636  else if (i == 1 && t_params->default_top_secam_mid)
637  tda_config |= TDA9887_TOP(t_params->default_top_secam_mid);
638  else if (t_params->default_top_secam_high)
639  tda_config |= TDA9887_TOP(t_params->default_top_secam_high);
640  } else {
641  if (i == 0 && t_params->default_top_low)
642  tda_config |= TDA9887_TOP(t_params->default_top_low);
643  else if (i == 1 && t_params->default_top_mid)
644  tda_config |= TDA9887_TOP(t_params->default_top_mid);
645  else if (t_params->default_top_high)
646  tda_config |= TDA9887_TOP(t_params->default_top_high);
647  }
648  if (t_params->default_pll_gating_18)
649  tda_config |= TDA9887_GATING_18;
650  i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG,
651  &tda9887_cfg);
652  }
653  tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
654  buffer[0], buffer[1], buffer[2], buffer[3]);
655 
656  rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
657  if (4 != rc)
658  tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
659 
660  simple_post_tune(fe, &buffer[0], div, config, cb);
661 
662  return 0;
663 }
664 
665 static int simple_set_radio_freq(struct dvb_frontend *fe,
666  struct analog_parameters *params)
667 {
668  struct tunertype *tun;
669  struct tuner_simple_priv *priv = fe->tuner_priv;
670  u8 buffer[4];
671  u16 div;
672  int rc, j;
673  struct tuner_params *t_params;
674  unsigned int freq = params->frequency;
675 
676  tun = priv->tun;
677 
678  for (j = tun->count-1; j > 0; j--)
679  if (tun->params[j].type == TUNER_PARAM_TYPE_RADIO)
680  break;
681  /* default t_params (j=0) will be used if desired type wasn't found */
682  t_params = &tun->params[j];
683 
684  /* Select Radio 1st IF used */
685  switch (t_params->radio_if) {
686  case 0: /* 10.7 MHz */
687  freq += (unsigned int)(10.7*16000);
688  break;
689  case 1: /* 33.3 MHz */
690  freq += (unsigned int)(33.3*16000);
691  break;
692  case 2: /* 41.3 MHz */
693  freq += (unsigned int)(41.3*16000);
694  break;
695  default:
696  tuner_warn("Unsupported radio_if value %d\n",
697  t_params->radio_if);
698  return 0;
699  }
700 
701  buffer[2] = (t_params->ranges[0].config & ~TUNER_RATIO_MASK) |
702  TUNER_RATIO_SELECT_50; /* 50 kHz step */
703 
704  /* Bandswitch byte */
705  simple_radio_bandswitch(fe, &buffer[0]);
706 
707  /* Convert from 1/16 kHz V4L steps to 1/20 MHz (=50 kHz) PLL steps
708  freq * (1 Mhz / 16000 V4L steps) * (20 PLL steps / 1 MHz) =
709  freq * (1/800) */
710  div = (freq + 400) / 800;
711 
712  if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
713  buffer[0] = buffer[2];
714  buffer[1] = buffer[3];
715  buffer[2] = (div>>8) & 0x7f;
716  buffer[3] = div & 0xff;
717  } else {
718  buffer[0] = (div>>8) & 0x7f;
719  buffer[1] = div & 0xff;
720  }
721 
722  tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
723  buffer[0], buffer[1], buffer[2], buffer[3]);
724  priv->last_div = div;
725 
726  if (t_params->has_tda9887) {
727  int config = 0;
728  struct v4l2_priv_tun_config tda9887_cfg;
729 
730  tda9887_cfg.tuner = TUNER_TDA9887;
731  tda9887_cfg.priv = &config;
732 
733  if (t_params->port1_active &&
734  !t_params->port1_fm_high_sensitivity)
735  config |= TDA9887_PORT1_ACTIVE;
736  if (t_params->port2_active &&
737  !t_params->port2_fm_high_sensitivity)
738  config |= TDA9887_PORT2_ACTIVE;
739  if (t_params->intercarrier_mode)
740  config |= TDA9887_INTERCARRIER;
741 /* if (t_params->port1_set_for_fm_mono)
742  config &= ~TDA9887_PORT1_ACTIVE;*/
743  if (t_params->fm_gain_normal)
744  config |= TDA9887_GAIN_NORMAL;
745  if (t_params->radio_if == 2)
746  config |= TDA9887_RIF_41_3;
747  i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG,
748  &tda9887_cfg);
749  }
750  rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
751  if (4 != rc)
752  tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
753 
754  /* Write AUX byte */
755  switch (priv->type) {
756  case TUNER_PHILIPS_FM1216ME_MK3:
757  buffer[2] = 0x98;
758  buffer[3] = 0x20; /* set TOP AGC */
759  rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
760  if (4 != rc)
761  tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
762  break;
763  }
764 
765  return 0;
766 }
767 
768 static int simple_set_params(struct dvb_frontend *fe,
769  struct analog_parameters *params)
770 {
771  struct tuner_simple_priv *priv = fe->tuner_priv;
772  int ret = -EINVAL;
773 
774  if (priv->i2c_props.adap == NULL)
775  return -EINVAL;
776 
777  switch (params->mode) {
778  case V4L2_TUNER_RADIO:
779  ret = simple_set_radio_freq(fe, params);
780  priv->frequency = params->frequency * 125 / 2;
781  break;
782  case V4L2_TUNER_ANALOG_TV:
783  case V4L2_TUNER_DIGITAL_TV:
784  ret = simple_set_tv_freq(fe, params);
785  priv->frequency = params->frequency * 62500;
786  break;
787  }
788  priv->bandwidth = 0;
789 
790  return ret;
791 }
792 
793 static void simple_set_dvb(struct dvb_frontend *fe, u8 *buf,
794  const u32 delsys,
795  const u32 frequency,
796  const u32 bandwidth)
797 {
798  struct tuner_simple_priv *priv = fe->tuner_priv;
799 
800  switch (priv->type) {
801  case TUNER_PHILIPS_FMD1216ME_MK3:
802  case TUNER_PHILIPS_FMD1216MEX_MK3:
803  if (bandwidth == 8000000 &&
804  frequency >= 158870000)
805  buf[3] |= 0x08;
806  break;
807  case TUNER_PHILIPS_TD1316:
808  /* determine band */
809  buf[3] |= (frequency < 161000000) ? 1 :
810  (frequency < 444000000) ? 2 : 4;
811 
812  /* setup PLL filter */
813  if (bandwidth == 8000000)
814  buf[3] |= 1 << 3;
815  break;
816  case TUNER_PHILIPS_TUV1236D:
817  case TUNER_PHILIPS_FCV1236D:
818  {
819  unsigned int new_rf;
820 
821  if (dtv_input[priv->nr])
822  new_rf = dtv_input[priv->nr];
823  else
824  switch (delsys) {
825  case SYS_DVBC_ANNEX_B:
826  new_rf = 1;
827  break;
828  case SYS_ATSC:
829  default:
830  new_rf = 0;
831  break;
832  }
833  simple_set_rf_input(fe, &buf[2], &buf[3], new_rf);
834  break;
835  }
836  default:
837  break;
838  }
839 }
840 
841 static u32 simple_dvb_configure(struct dvb_frontend *fe, u8 *buf,
842  const u32 delsys,
843  const u32 freq,
844  const u32 bw)
845 {
846  /* This function returns the tuned frequency on success, 0 on error */
847  struct tuner_simple_priv *priv = fe->tuner_priv;
848  struct tunertype *tun = priv->tun;
849  static struct tuner_params *t_params;
850  u8 config, cb;
851  u32 div;
852  int ret;
853  u32 frequency = freq / 62500;
854 
855  if (!tun->stepsize) {
856  /* tuner-core was loaded before the digital tuner was
857  * configured and somehow picked the wrong tuner type */
858  tuner_err("attempt to treat tuner %d (%s) as digital tuner "
859  "without stepsize defined.\n",
860  priv->type, priv->tun->name);
861  return 0; /* failure */
862  }
863 
864  t_params = simple_tuner_params(fe, TUNER_PARAM_TYPE_DIGITAL);
865  ret = simple_config_lookup(fe, t_params, &frequency, &config, &cb);
866  if (ret < 0)
867  return 0; /* failure */
868 
869  div = ((frequency + t_params->iffreq) * 62500 + offset +
870  tun->stepsize/2) / tun->stepsize;
871 
872  buf[0] = div >> 8;
873  buf[1] = div & 0xff;
874  buf[2] = config;
875  buf[3] = cb;
876 
877  simple_set_dvb(fe, buf, delsys, freq, bw);
878 
879  tuner_dbg("%s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
880  tun->name, div, buf[0], buf[1], buf[2], buf[3]);
881 
882  /* calculate the frequency we set it to */
883  return (div * tun->stepsize) - t_params->iffreq;
884 }
885 
886 static int simple_dvb_calc_regs(struct dvb_frontend *fe,
887  u8 *buf, int buf_len)
888 {
889  struct dtv_frontend_properties *c = &fe->dtv_property_cache;
890  u32 delsys = c->delivery_system;
891  u32 bw = c->bandwidth_hz;
892  struct tuner_simple_priv *priv = fe->tuner_priv;
893  u32 frequency;
894 
895  if (buf_len < 5)
896  return -EINVAL;
897 
898  frequency = simple_dvb_configure(fe, buf+1, delsys, c->frequency, bw);
899  if (frequency == 0)
900  return -EINVAL;
901 
902  buf[0] = priv->i2c_props.addr;
903 
904  priv->frequency = frequency;
905  priv->bandwidth = c->bandwidth_hz;
906 
907  return 5;
908 }
909 
910 static int simple_dvb_set_params(struct dvb_frontend *fe)
911 {
912  struct dtv_frontend_properties *c = &fe->dtv_property_cache;
913  u32 delsys = c->delivery_system;
914  u32 bw = c->bandwidth_hz;
915  u32 freq = c->frequency;
916  struct tuner_simple_priv *priv = fe->tuner_priv;
917  u32 frequency;
918  u32 prev_freq, prev_bw;
919  int ret;
920  u8 buf[5];
921 
922  if (priv->i2c_props.adap == NULL)
923  return -EINVAL;
924 
925  prev_freq = priv->frequency;
926  prev_bw = priv->bandwidth;
927 
928  frequency = simple_dvb_configure(fe, buf+1, delsys, freq, bw);
929  if (frequency == 0)
930  return -EINVAL;
931 
932  buf[0] = priv->i2c_props.addr;
933 
934  priv->frequency = frequency;
935  priv->bandwidth = bw;
936 
937  /* put analog demod in standby when tuning digital */
938  if (fe->ops.analog_ops.standby)
939  fe->ops.analog_ops.standby(fe);
940 
941  if (fe->ops.i2c_gate_ctrl)
942  fe->ops.i2c_gate_ctrl(fe, 1);
943 
944  /* buf[0] contains the i2c address, but *
945  * we already have it in i2c_props.addr */
946  ret = tuner_i2c_xfer_send(&priv->i2c_props, buf+1, 4);
947  if (ret != 4)
948  goto fail;
949 
950  return 0;
951 fail:
952  /* calc_regs sets frequency and bandwidth. if we failed, unset them */
953  priv->frequency = prev_freq;
954  priv->bandwidth = prev_bw;
955 
956  return ret;
957 }
958 
959 static int simple_init(struct dvb_frontend *fe)
960 {
961  struct tuner_simple_priv *priv = fe->tuner_priv;
962 
963  if (priv->i2c_props.adap == NULL)
964  return -EINVAL;
965 
966  if (priv->tun->initdata) {
967  int ret;
968 
969  if (fe->ops.i2c_gate_ctrl)
970  fe->ops.i2c_gate_ctrl(fe, 1);
971 
972  ret = tuner_i2c_xfer_send(&priv->i2c_props,
973  priv->tun->initdata + 1,
974  priv->tun->initdata[0]);
975  if (ret != priv->tun->initdata[0])
976  return ret;
977  }
978 
979  return 0;
980 }
981 
982 static int simple_sleep(struct dvb_frontend *fe)
983 {
984  struct tuner_simple_priv *priv = fe->tuner_priv;
985 
986  if (priv->i2c_props.adap == NULL)
987  return -EINVAL;
988 
989  if (priv->tun->sleepdata) {
990  int ret;
991 
992  if (fe->ops.i2c_gate_ctrl)
993  fe->ops.i2c_gate_ctrl(fe, 1);
994 
995  ret = tuner_i2c_xfer_send(&priv->i2c_props,
996  priv->tun->sleepdata + 1,
997  priv->tun->sleepdata[0]);
998  if (ret != priv->tun->sleepdata[0])
999  return ret;
1000  }
1001 
1002  return 0;
1003 }
1004 
1005 static int simple_release(struct dvb_frontend *fe)
1006 {
1007  struct tuner_simple_priv *priv = fe->tuner_priv;
1008 
1009  mutex_lock(&tuner_simple_list_mutex);
1010 
1011  if (priv)
1012  hybrid_tuner_release_state(priv);
1013 
1014  mutex_unlock(&tuner_simple_list_mutex);
1015 
1016  fe->tuner_priv = NULL;
1017 
1018  return 0;
1019 }
1020 
1021 static int simple_get_frequency(struct dvb_frontend *fe, u32 *frequency)
1022 {
1023  struct tuner_simple_priv *priv = fe->tuner_priv;
1024  *frequency = priv->frequency;
1025  return 0;
1026 }
1027 
1028 static int simple_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
1029 {
1030  struct tuner_simple_priv *priv = fe->tuner_priv;
1031  *bandwidth = priv->bandwidth;
1032  return 0;
1033 }
1034 
1035 static struct dvb_tuner_ops simple_tuner_ops = {
1036  .init = simple_init,
1037  .sleep = simple_sleep,
1038  .set_analog_params = simple_set_params,
1039  .set_params = simple_dvb_set_params,
1040  .calc_regs = simple_dvb_calc_regs,
1041  .release = simple_release,
1042  .get_frequency = simple_get_frequency,
1043  .get_bandwidth = simple_get_bandwidth,
1044  .get_status = simple_get_status,
1045  .get_rf_strength = simple_get_rf_strength,
1046 };
1047 
1048 struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
1049  struct i2c_adapter *i2c_adap,
1050  u8 i2c_addr,
1051  unsigned int type)
1052 {
1053  struct tuner_simple_priv *priv = NULL;
1054  int instance;
1055 
1056  if (type >= tuner_count) {
1057  printk(KERN_WARNING "%s: invalid tuner type: %d (max: %d)\n",
1058  __func__, type, tuner_count-1);
1059  return NULL;
1060  }
1061 
1062  /* If i2c_adap is set, check that the tuner is at the correct address.
1063  * Otherwise, if i2c_adap is NULL, the tuner will be programmed directly
1064  * by the digital demod via calc_regs.
1065  */
1066  if (i2c_adap != NULL) {
1067  u8 b[1];
1068  struct i2c_msg msg = {
1069  .addr = i2c_addr, .flags = I2C_M_RD,
1070  .buf = b, .len = 1,
1071  };
1072 
1073  if (fe->ops.i2c_gate_ctrl)
1074  fe->ops.i2c_gate_ctrl(fe, 1);
1075 
1076  if (1 != i2c_transfer(i2c_adap, &msg, 1))
1077  printk(KERN_WARNING "tuner-simple %d-%04x: "
1078  "unable to probe %s, proceeding anyway.",
1079  i2c_adapter_id(i2c_adap), i2c_addr,
1080  tuners[type].name);
1081 
1082  if (fe->ops.i2c_gate_ctrl)
1083  fe->ops.i2c_gate_ctrl(fe, 0);
1084  }
1085 
1086  mutex_lock(&tuner_simple_list_mutex);
1087 
1088  instance = hybrid_tuner_request_state(struct tuner_simple_priv, priv,
1089  hybrid_tuner_instance_list,
1090  i2c_adap, i2c_addr,
1091  "tuner-simple");
1092  switch (instance) {
1093  case 0:
1094  mutex_unlock(&tuner_simple_list_mutex);
1095  return NULL;
1096  case 1:
1097  fe->tuner_priv = priv;
1098 
1099  priv->type = type;
1100  priv->tun = &tuners[type];
1101  priv->nr = simple_devcount++;
1102  break;
1103  default:
1104  fe->tuner_priv = priv;
1105  break;
1106  }
1107 
1108  mutex_unlock(&tuner_simple_list_mutex);
1109 
1110  memcpy(&fe->ops.tuner_ops, &simple_tuner_ops,
1111  sizeof(struct dvb_tuner_ops));
1112 
1113  if (type != priv->type)
1114  tuner_warn("couldn't set type to %d. Using %d (%s) instead\n",
1115  type, priv->type, priv->tun->name);
1116  else
1117  tuner_info("type set to %d (%s)\n",
1118  priv->type, priv->tun->name);
1119 
1120  if ((debug) || ((atv_input[priv->nr] > 0) ||
1121  (dtv_input[priv->nr] > 0))) {
1122  if (0 == atv_input[priv->nr])
1123  tuner_info("tuner %d atv rf input will be "
1124  "autoselected\n", priv->nr);
1125  else
1126  tuner_info("tuner %d atv rf input will be "
1127  "set to input %d (insmod option)\n",
1128  priv->nr, atv_input[priv->nr]);
1129  if (0 == dtv_input[priv->nr])
1130  tuner_info("tuner %d dtv rf input will be "
1131  "autoselected\n", priv->nr);
1132  else
1133  tuner_info("tuner %d dtv rf input will be "
1134  "set to input %d (insmod option)\n",
1135  priv->nr, dtv_input[priv->nr]);
1136  }
1137 
1138  strlcpy(fe->ops.tuner_ops.info.name, priv->tun->name,
1139  sizeof(fe->ops.tuner_ops.info.name));
1140 
1141  return fe;
1142 }
1143 EXPORT_SYMBOL_GPL(simple_tuner_attach);
1144 
1145 MODULE_DESCRIPTION("Simple 4-control-bytes style tuner driver");
1146 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1147 MODULE_LICENSE("GPL");
1148 
1149 /*
1150  * Overrides for Emacs so that we follow Linus's tabbing style.
1151  * ---------------------------------------------------------------------------
1152  * Local variables:
1153  * c-basic-offset: 8
1154  * End:
1155  */
Generated on Thu Jan 10 2013 13:50:48 for Linux Kernel by   doxygen 1.8.2