Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tuner-core.c
Go to the documentation of this file.
1 /*
2  * i2c tv tuner chip device driver
3  * core core, i.e. kernel interfaces, registering and so on
4  *
5  * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
6  *
7  * Copyright(c) 2005-2011 by Mauro Carvalho Chehab
8  * - Added support for a separate Radio tuner
9  * - Major rework and cleanups at the code
10  *
11  * This driver supports many devices and the idea is to let the driver
12  * detect which device is present. So rather than listing all supported
13  * devices here, we pretend to support a single, fake device type that will
14  * handle both radio and analog TV tuning.
15  */
16 
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/timer.h>
21 #include <linux/delay.h>
22 #include <linux/errno.h>
23 #include <linux/slab.h>
24 #include <linux/poll.h>
25 #include <linux/i2c.h>
26 #include <linux/types.h>
27 #include <linux/init.h>
28 #include <linux/videodev2.h>
29 #include <media/tuner.h>
30 #include <media/tuner-types.h>
31 #include <media/v4l2-device.h>
32 #include <media/v4l2-ioctl.h>
33 #include "mt20xx.h"
34 #include "tda8290.h"
35 #include "tea5761.h"
36 #include "tea5767.h"
37 #include "tuner-xc2028.h"
38 #include "tuner-simple.h"
39 #include "tda9887.h"
40 #include "xc5000.h"
41 #include "tda18271.h"
42 #include "xc4000.h"
43 
44 #define UNSET (-1U)
45 
46 #define PREFIX (t->i2c->driver->driver.name)
47 
48 /*
49  * Driver modprobe parameters
50  */
51 
52 /* insmod options used at init time => read/only */
53 static unsigned int addr;
54 static unsigned int no_autodetect;
55 static unsigned int show_i2c;
56 
57 module_param(addr, int, 0444);
58 module_param(no_autodetect, int, 0444);
59 module_param(show_i2c, int, 0444);
60 
61 /* insmod options used at runtime => read/write */
62 static int tuner_debug;
63 static unsigned int tv_range[2] = { 44, 958 };
64 static unsigned int radio_range[2] = { 65, 108 };
65 static char pal[] = "--";
66 static char secam[] = "--";
67 static char ntsc[] = "-";
68 
69 module_param_named(debug, tuner_debug, int, 0644);
70 module_param_array(tv_range, int, NULL, 0644);
71 module_param_array(radio_range, int, NULL, 0644);
72 module_param_string(pal, pal, sizeof(pal), 0644);
73 module_param_string(secam, secam, sizeof(secam), 0644);
74 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
75 
76 /*
77  * Static vars
78  */
79 
80 static LIST_HEAD(tuner_list);
81 static const struct v4l2_subdev_ops tuner_ops;
82 
83 /*
84  * Debug macros
85  */
86 
87 #define tuner_warn(fmt, arg...) do { \
88  printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
89  i2c_adapter_id(t->i2c->adapter), \
90  t->i2c->addr, ##arg); \
91  } while (0)
92 
93 #define tuner_info(fmt, arg...) do { \
94  printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
95  i2c_adapter_id(t->i2c->adapter), \
96  t->i2c->addr, ##arg); \
97  } while (0)
98 
99 #define tuner_err(fmt, arg...) do { \
100  printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
101  i2c_adapter_id(t->i2c->adapter), \
102  t->i2c->addr, ##arg); \
103  } while (0)
104 
105 #define tuner_dbg(fmt, arg...) do { \
106  if (tuner_debug) \
107  printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
108  i2c_adapter_id(t->i2c->adapter), \
109  t->i2c->addr, ##arg); \
110  } while (0)
111 
112 /*
113  * Internal struct used inside the driver
114  */
115 
116 struct tuner {
117  /* device */
118  struct dvb_frontend fe;
119  struct i2c_client *i2c;
120  struct v4l2_subdev sd;
121  struct list_head list;
122 
123  /* keep track of the current settings */
125  unsigned int tv_freq;
126  unsigned int radio_freq;
127  unsigned int audmode;
128 
130  unsigned int mode_mask; /* Combination of allowable modes */
131 
132  bool standby; /* Standby mode */
133 
134  unsigned int type; /* chip type id */
135  unsigned int config;
136  const char *name;
137 };
138 
139 /*
140  * Function prototypes
141  */
142 
143 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
144 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
145 
146 /*
147  * tuner attach/detach logic
148  */
149 
150 /* This macro allows us to probe dynamically, avoiding static links */
151 #ifdef CONFIG_MEDIA_ATTACH
152 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
153  int __r = -EINVAL; \
154  typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
155  if (__a) { \
156  __r = (int) __a(ARGS); \
157  symbol_put(FUNCTION); \
158  } else { \
159  printk(KERN_ERR "TUNER: Unable to find " \
160  "symbol "#FUNCTION"()\n"); \
161  } \
162  __r; \
163 })
164 
165 static void tuner_detach(struct dvb_frontend *fe)
166 {
167  if (fe->ops.tuner_ops.release) {
168  fe->ops.tuner_ops.release(fe);
169  symbol_put_addr(fe->ops.tuner_ops.release);
170  }
171  if (fe->ops.analog_ops.release) {
172  fe->ops.analog_ops.release(fe);
173  symbol_put_addr(fe->ops.analog_ops.release);
174  }
175 }
176 #else
177 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
178  FUNCTION(ARGS); \
179 })
180 
181 static void tuner_detach(struct dvb_frontend *fe)
182 {
183  if (fe->ops.tuner_ops.release)
184  fe->ops.tuner_ops.release(fe);
185  if (fe->ops.analog_ops.release)
186  fe->ops.analog_ops.release(fe);
187 }
188 #endif
189 
190 
191 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
192 {
193  return container_of(sd, struct tuner, sd);
194 }
195 
196 /*
197  * struct analog_demod_ops callbacks
198  */
199 
200 static void fe_set_params(struct dvb_frontend *fe,
201  struct analog_parameters *params)
202 {
203  struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
204  struct tuner *t = fe->analog_demod_priv;
205 
206  if (NULL == fe_tuner_ops->set_analog_params) {
207  tuner_warn("Tuner frontend module has no way to set freq\n");
208  return;
209  }
210  fe_tuner_ops->set_analog_params(fe, params);
211 }
212 
213 static void fe_standby(struct dvb_frontend *fe)
214 {
215  struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
216 
217  if (fe_tuner_ops->sleep)
218  fe_tuner_ops->sleep(fe);
219 }
220 
221 static int fe_has_signal(struct dvb_frontend *fe)
222 {
223  u16 strength = 0;
224 
225  if (fe->ops.tuner_ops.get_rf_strength)
226  fe->ops.tuner_ops.get_rf_strength(fe, &strength);
227 
228  return strength;
229 }
230 
231 static int fe_get_afc(struct dvb_frontend *fe)
232 {
233  s32 afc = 0;
234 
235  if (fe->ops.tuner_ops.get_afc)
236  fe->ops.tuner_ops.get_afc(fe, &afc);
237 
238  return 0;
239 }
240 
241 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
242 {
243  struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
244  struct tuner *t = fe->analog_demod_priv;
245 
246  if (fe_tuner_ops->set_config)
247  return fe_tuner_ops->set_config(fe, priv_cfg);
248 
249  tuner_warn("Tuner frontend module has no way to set config\n");
250 
251  return 0;
252 }
253 
254 static void tuner_status(struct dvb_frontend *fe);
255 
256 static struct analog_demod_ops tuner_analog_ops = {
257  .set_params = fe_set_params,
258  .standby = fe_standby,
259  .has_signal = fe_has_signal,
260  .get_afc = fe_get_afc,
261  .set_config = fe_set_config,
262  .tuner_status = tuner_status
263 };
264 
265 /*
266  * Functions to select between radio and TV and tuner probe/remove functions
267  */
268 
284 static void set_type(struct i2c_client *c, unsigned int type,
285  unsigned int new_mode_mask, unsigned int new_config,
286  int (*tuner_callback) (void *dev, int component, int cmd, int arg))
287 {
288  struct tuner *t = to_tuner(i2c_get_clientdata(c));
289  struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
290  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
291  unsigned char buffer[4];
292  int tune_now = 1;
293 
294  if (type == UNSET || type == TUNER_ABSENT) {
295  tuner_dbg("tuner 0x%02x: Tuner type absent\n", c->addr);
296  return;
297  }
298 
299  t->type = type;
300  /* prevent invalid config values */
301  t->config = new_config < 256 ? new_config : 0;
302  if (tuner_callback != NULL) {
303  tuner_dbg("defining GPIO callback\n");
304  t->fe.callback = tuner_callback;
305  }
306 
307  /* discard private data, in case set_type() was previously called */
308  tuner_detach(&t->fe);
309  t->fe.analog_demod_priv = NULL;
310 
311  switch (t->type) {
312  case TUNER_MT2032:
314  &t->fe, t->i2c->adapter, t->i2c->addr))
315  goto attach_failed;
316  break;
317  case TUNER_PHILIPS_TDA8290:
318  {
319  struct tda829x_config cfg = {
320  .lna_cfg = t->config,
321  };
322  if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
323  t->i2c->addr, &cfg))
324  goto attach_failed;
325  break;
326  }
327  case TUNER_TEA5767:
328  if (!dvb_attach(tea5767_attach, &t->fe,
329  t->i2c->adapter, t->i2c->addr))
330  goto attach_failed;
331  t->mode_mask = T_RADIO;
332  break;
333  case TUNER_TEA5761:
334  if (!dvb_attach(tea5761_attach, &t->fe,
335  t->i2c->adapter, t->i2c->addr))
336  goto attach_failed;
337  t->mode_mask = T_RADIO;
338  break;
339  case TUNER_PHILIPS_FMD1216ME_MK3:
340  case TUNER_PHILIPS_FMD1216MEX_MK3:
341  buffer[0] = 0x0b;
342  buffer[1] = 0xdc;
343  buffer[2] = 0x9c;
344  buffer[3] = 0x60;
345  i2c_master_send(c, buffer, 4);
346  mdelay(1);
347  buffer[2] = 0x86;
348  buffer[3] = 0x54;
349  i2c_master_send(c, buffer, 4);
351  t->i2c->adapter, t->i2c->addr, t->type))
352  goto attach_failed;
353  break;
354  case TUNER_PHILIPS_TD1316:
355  buffer[0] = 0x0b;
356  buffer[1] = 0xdc;
357  buffer[2] = 0x86;
358  buffer[3] = 0xa4;
359  i2c_master_send(c, buffer, 4);
361  t->i2c->adapter, t->i2c->addr, t->type))
362  goto attach_failed;
363  break;
364  case TUNER_XC2028:
365  {
366  struct xc2028_config cfg = {
367  .i2c_adap = t->i2c->adapter,
368  .i2c_addr = t->i2c->addr,
369  };
370  if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
371  goto attach_failed;
372  tune_now = 0;
373  break;
374  }
375  case TUNER_TDA9887:
377  &t->fe, t->i2c->adapter, t->i2c->addr))
378  goto attach_failed;
379  break;
380  case TUNER_XC5000:
381  {
382  struct xc5000_config xc5000_cfg = {
383  .i2c_address = t->i2c->addr,
384  /* if_khz will be set at dvb_attach() */
385  .if_khz = 0,
386  };
387 
389  &t->fe, t->i2c->adapter, &xc5000_cfg))
390  goto attach_failed;
391  tune_now = 0;
392  break;
393  }
394  case TUNER_XC5000C:
395  {
396  struct xc5000_config xc5000c_cfg = {
397  .i2c_address = t->i2c->addr,
398  /* if_khz will be set at dvb_attach() */
399  .if_khz = 0,
400  .chip_id = XC5000C,
401  };
402 
404  &t->fe, t->i2c->adapter, &xc5000c_cfg))
405  goto attach_failed;
406  tune_now = 0;
407  break;
408  }
409  case TUNER_NXP_TDA18271:
410  {
411  struct tda18271_config cfg = {
412  .config = t->config,
413  .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
414  };
415 
416  if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
417  t->i2c->adapter, &cfg))
418  goto attach_failed;
419  tune_now = 0;
420  break;
421  }
422  case TUNER_XC4000:
423  {
424  struct xc4000_config xc4000_cfg = {
425  .i2c_address = t->i2c->addr,
426  /* FIXME: the correct parameters will be set */
427  /* only when the digital dvb_attach() occurs */
428  .default_pm = 0,
429  .dvb_amplitude = 0,
430  .set_smoothedcvbs = 0,
431  .if_khz = 0
432  };
434  &t->fe, t->i2c->adapter, &xc4000_cfg))
435  goto attach_failed;
436  tune_now = 0;
437  break;
438  }
439  default:
441  t->i2c->adapter, t->i2c->addr, t->type))
442  goto attach_failed;
443 
444  break;
445  }
446 
447  if ((NULL == analog_ops->set_params) &&
448  (fe_tuner_ops->set_analog_params)) {
449 
450  t->name = fe_tuner_ops->info.name;
451 
452  t->fe.analog_demod_priv = t;
453  memcpy(analog_ops, &tuner_analog_ops,
454  sizeof(struct analog_demod_ops));
455 
456  } else {
457  t->name = analog_ops->info.name;
458  }
459 
460  tuner_dbg("type set to %s\n", t->name);
461 
462  t->mode_mask = new_mode_mask;
463 
464  /* Some tuners require more initialization setup before use,
465  such as firmware download or device calibration.
466  trying to set a frequency here will just fail
467  FIXME: better to move set_freq to the tuner code. This is needed
468  on analog tuners for PLL to properly work
469  */
470  if (tune_now) {
471  if (V4L2_TUNER_RADIO == t->mode)
472  set_radio_freq(c, t->radio_freq);
473  else
474  set_tv_freq(c, t->tv_freq);
475  }
476 
477  tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
478  c->adapter->name, c->driver->driver.name, c->addr << 1, type,
479  t->mode_mask);
480  return;
481 
482 attach_failed:
483  tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
484  t->type = TUNER_ABSENT;
485 
486  return;
487 }
488 
503 static int tuner_s_type_addr(struct v4l2_subdev *sd,
504  struct tuner_setup *tun_setup)
505 {
506  struct tuner *t = to_tuner(sd);
507  struct i2c_client *c = v4l2_get_subdevdata(sd);
508 
509  tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
510  tun_setup->type,
511  tun_setup->addr,
512  tun_setup->mode_mask,
513  tun_setup->config);
514 
515  if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
516  (t->mode_mask & tun_setup->mode_mask))) ||
517  (tun_setup->addr == c->addr)) {
518  set_type(c, tun_setup->type, tun_setup->mode_mask,
519  tun_setup->config, tun_setup->tuner_callback);
520  } else
521  tuner_dbg("set addr discarded for type %i, mask %x. "
522  "Asked to change tuner at addr 0x%02x, with mask %x\n",
523  t->type, t->mode_mask,
524  tun_setup->addr, tun_setup->mode_mask);
525 
526  return 0;
527 }
528 
538 static int tuner_s_config(struct v4l2_subdev *sd,
539  const struct v4l2_priv_tun_config *cfg)
540 {
541  struct tuner *t = to_tuner(sd);
542  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
543 
544  if (t->type != cfg->tuner)
545  return 0;
546 
547  if (analog_ops->set_config) {
548  analog_ops->set_config(&t->fe, cfg->priv);
549  return 0;
550  }
551 
552  tuner_dbg("Tuner frontend module has no way to set config\n");
553  return 0;
554 }
555 
570 static void tuner_lookup(struct i2c_adapter *adap,
571  struct tuner **radio, struct tuner **tv)
572 {
573  struct tuner *pos;
574 
575  *radio = NULL;
576  *tv = NULL;
577 
578  list_for_each_entry(pos, &tuner_list, list) {
579  int mode_mask;
580 
581  if (pos->i2c->adapter != adap ||
582  strcmp(pos->i2c->driver->driver.name, "tuner"))
583  continue;
584 
585  mode_mask = pos->mode_mask;
586  if (*radio == NULL && mode_mask == T_RADIO)
587  *radio = pos;
588  /* Note: currently TDA9887 is the only demod-only
589  device. If other devices appear then we need to
590  make this test more general. */
591  else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
592  (pos->mode_mask & T_ANALOG_TV))
593  *tv = pos;
594  }
595 }
596 
612 static int tuner_probe(struct i2c_client *client,
613  const struct i2c_device_id *id)
614 {
615  struct tuner *t;
616  struct tuner *radio;
617  struct tuner *tv;
618 
619  t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
620  if (NULL == t)
621  return -ENOMEM;
622  v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
623  t->i2c = client;
624  t->name = "(tuner unset)";
625  t->type = UNSET;
627  t->standby = 1;
628  t->radio_freq = 87.5 * 16000; /* Initial freq range */
629  t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
630 
631  if (show_i2c) {
632  unsigned char buffer[16];
633  int i, rc;
634 
635  memset(buffer, 0, sizeof(buffer));
636  rc = i2c_master_recv(client, buffer, sizeof(buffer));
637  tuner_info("I2C RECV = ");
638  for (i = 0; i < rc; i++)
639  printk(KERN_CONT "%02x ", buffer[i]);
640  printk("\n");
641  }
642 
643  /* autodetection code based on the i2c addr */
644  if (!no_autodetect) {
645  switch (client->addr) {
646  case 0x10:
648  t->i2c->adapter,
649  t->i2c->addr) >= 0) {
650  t->type = TUNER_TEA5761;
651  t->mode_mask = T_RADIO;
652  tuner_lookup(t->i2c->adapter, &radio, &tv);
653  if (tv)
654  tv->mode_mask &= ~T_RADIO;
655 
656  goto register_client;
657  }
658  kfree(t);
659  return -ENODEV;
660  case 0x42:
661  case 0x43:
662  case 0x4a:
663  case 0x4b:
664  /* If chip is not tda8290, don't register.
665  since it can be tda9887*/
666  if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
667  t->i2c->addr) >= 0) {
668  tuner_dbg("tda829x detected\n");
669  } else {
670  /* Default is being tda9887 */
671  t->type = TUNER_TDA9887;
672  t->mode_mask = T_RADIO | T_ANALOG_TV;
673  goto register_client;
674  }
675  break;
676  case 0x60:
678  t->i2c->adapter, t->i2c->addr)
679  >= 0) {
680  t->type = TUNER_TEA5767;
681  t->mode_mask = T_RADIO;
682  /* Sets freq to FM range */
683  tuner_lookup(t->i2c->adapter, &radio, &tv);
684  if (tv)
685  tv->mode_mask &= ~T_RADIO;
686 
687  goto register_client;
688  }
689  break;
690  }
691  }
692 
693  /* Initializes only the first TV tuner on this adapter. Why only the
694  first? Because there are some devices (notably the ones with TI
695  tuners) that have more than one i2c address for the *same* device.
696  Experience shows that, except for just one case, the first
697  address is the right one. The exception is a Russian tuner
698  (ACORP_Y878F). So, the desired behavior is just to enable the
699  first found TV tuner. */
700  tuner_lookup(t->i2c->adapter, &radio, &tv);
701  if (tv == NULL) {
702  t->mode_mask = T_ANALOG_TV;
703  if (radio == NULL)
704  t->mode_mask |= T_RADIO;
705  tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
706  }
707 
708  /* Should be just before return */
709 register_client:
710  /* Sets a default mode */
711  if (t->mode_mask & T_ANALOG_TV)
713  else
714  t->mode = V4L2_TUNER_RADIO;
715  set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
716  list_add_tail(&t->list, &tuner_list);
717 
718  tuner_info("Tuner %d found with type(s)%s%s.\n",
719  t->type,
720  t->mode_mask & T_RADIO ? " Radio" : "",
721  t->mode_mask & T_ANALOG_TV ? " TV" : "");
722  return 0;
723 }
724 
731 static int tuner_remove(struct i2c_client *client)
732 {
733  struct tuner *t = to_tuner(i2c_get_clientdata(client));
734 
736  tuner_detach(&t->fe);
737  t->fe.analog_demod_priv = NULL;
738 
739  list_del(&t->list);
740  kfree(t);
741  return 0;
742 }
743 
744 /*
745  * Functions to switch between Radio and TV
746  *
747  * A few cards have a separate I2C tuner for radio. Those routines
748  * take care of switching between TV/Radio mode, filtering only the
749  * commands that apply to the Radio or TV tuner.
750  */
751 
766 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
767 {
768  int t_mode;
769  if (mode == V4L2_TUNER_RADIO)
770  t_mode = T_RADIO;
771  else
772  t_mode = T_ANALOG_TV;
773 
774  if ((t_mode & t->mode_mask) == 0)
775  return -EINVAL;
776 
777  return 0;
778 }
779 
789 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
790 {
791  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
792 
793  if (mode != t->mode) {
794  if (check_mode(t, mode) == -EINVAL) {
795  tuner_dbg("Tuner doesn't support mode %d. "
796  "Putting tuner to sleep\n", mode);
797  t->standby = true;
798  if (analog_ops->standby)
799  analog_ops->standby(&t->fe);
800  return -EINVAL;
801  }
802  t->mode = mode;
803  tuner_dbg("Changing to mode %d\n", mode);
804  }
805  return 0;
806 }
807 
813 static void set_freq(struct tuner *t, unsigned int freq)
814 {
815  struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
816 
817  if (t->mode == V4L2_TUNER_RADIO) {
818  if (!freq)
819  freq = t->radio_freq;
820  set_radio_freq(client, freq);
821  } else {
822  if (!freq)
823  freq = t->tv_freq;
824  set_tv_freq(client, freq);
825  }
826 }
827 
828 /*
829  * Functions that are specific for TV mode
830  */
831 
838 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
839 {
840  struct tuner *t = to_tuner(i2c_get_clientdata(c));
841  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
842 
843  struct analog_parameters params = {
844  .mode = t->mode,
845  .audmode = t->audmode,
846  .std = t->std
847  };
848 
849  if (t->type == UNSET) {
850  tuner_warn("tuner type not set\n");
851  return;
852  }
853  if (NULL == analog_ops->set_params) {
854  tuner_warn("Tuner has no way to set tv freq\n");
855  return;
856  }
857  if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
858  tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
859  freq / 16, freq % 16 * 100 / 16, tv_range[0],
860  tv_range[1]);
861  /* V4L2 spec: if the freq is not possible then the closest
862  possible value should be selected */
863  if (freq < tv_range[0] * 16)
864  freq = tv_range[0] * 16;
865  else
866  freq = tv_range[1] * 16;
867  }
868  params.frequency = freq;
869  tuner_dbg("tv freq set to %d.%02d\n",
870  freq / 16, freq % 16 * 100 / 16);
871  t->tv_freq = freq;
872  t->standby = false;
873 
874  analog_ops->set_params(&t->fe, &params);
875 }
876 
891 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
892 {
893  if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
894  switch (pal[0]) {
895  case '6':
896  return V4L2_STD_PAL_60;
897  case 'b':
898  case 'B':
899  case 'g':
900  case 'G':
901  return V4L2_STD_PAL_BG;
902  case 'i':
903  case 'I':
904  return V4L2_STD_PAL_I;
905  case 'd':
906  case 'D':
907  case 'k':
908  case 'K':
909  return V4L2_STD_PAL_DK;
910  case 'M':
911  case 'm':
912  return V4L2_STD_PAL_M;
913  case 'N':
914  case 'n':
915  if (pal[1] == 'c' || pal[1] == 'C')
916  return V4L2_STD_PAL_Nc;
917  return V4L2_STD_PAL_N;
918  default:
919  tuner_warn("pal= argument not recognised\n");
920  break;
921  }
922  }
923  if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
924  switch (secam[0]) {
925  case 'b':
926  case 'B':
927  case 'g':
928  case 'G':
929  case 'h':
930  case 'H':
931  return V4L2_STD_SECAM_B |
934  case 'd':
935  case 'D':
936  case 'k':
937  case 'K':
938  return V4L2_STD_SECAM_DK;
939  case 'l':
940  case 'L':
941  if ((secam[1] == 'C') || (secam[1] == 'c'))
942  return V4L2_STD_SECAM_LC;
943  return V4L2_STD_SECAM_L;
944  default:
945  tuner_warn("secam= argument not recognised\n");
946  break;
947  }
948  }
949 
950  if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
951  switch (ntsc[0]) {
952  case 'm':
953  case 'M':
954  return V4L2_STD_NTSC_M;
955  case 'j':
956  case 'J':
957  return V4L2_STD_NTSC_M_JP;
958  case 'k':
959  case 'K':
960  return V4L2_STD_NTSC_M_KR;
961  default:
962  tuner_info("ntsc= argument not recognised\n");
963  break;
964  }
965  }
966  return std;
967 }
968 
969 /*
970  * Functions that are specific for Radio mode
971  */
972 
979 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
980 {
981  struct tuner *t = to_tuner(i2c_get_clientdata(c));
982  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
983 
984  struct analog_parameters params = {
985  .mode = t->mode,
986  .audmode = t->audmode,
987  .std = t->std
988  };
989 
990  if (t->type == UNSET) {
991  tuner_warn("tuner type not set\n");
992  return;
993  }
994  if (NULL == analog_ops->set_params) {
995  tuner_warn("tuner has no way to set radio frequency\n");
996  return;
997  }
998  if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
999  tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
1000  freq / 16000, freq % 16000 * 100 / 16000,
1001  radio_range[0], radio_range[1]);
1002  /* V4L2 spec: if the freq is not possible then the closest
1003  possible value should be selected */
1004  if (freq < radio_range[0] * 16000)
1005  freq = radio_range[0] * 16000;
1006  else
1007  freq = radio_range[1] * 16000;
1008  }
1009  params.frequency = freq;
1010  tuner_dbg("radio freq set to %d.%02d\n",
1011  freq / 16000, freq % 16000 * 100 / 16000);
1012  t->radio_freq = freq;
1013  t->standby = false;
1014 
1015  analog_ops->set_params(&t->fe, &params);
1016 }
1017 
1018 /*
1019  * Debug function for reporting tuner status to userspace
1020  */
1021 
1029 static void tuner_status(struct dvb_frontend *fe)
1030 {
1031  struct tuner *t = fe->analog_demod_priv;
1032  unsigned long freq, freq_fraction;
1033  struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1034  struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1035  const char *p;
1036 
1037  switch (t->mode) {
1038  case V4L2_TUNER_RADIO:
1039  p = "radio";
1040  break;
1041  case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1042  p = "digital TV";
1043  break;
1044  case V4L2_TUNER_ANALOG_TV:
1045  default:
1046  p = "analog TV";
1047  break;
1048  }
1049  if (t->mode == V4L2_TUNER_RADIO) {
1050  freq = t->radio_freq / 16000;
1051  freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1052  } else {
1053  freq = t->tv_freq / 16;
1054  freq_fraction = (t->tv_freq % 16) * 100 / 16;
1055  }
1056  tuner_info("Tuner mode: %s%s\n", p,
1057  t->standby ? " on standby mode" : "");
1058  tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
1059  tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
1060  if (t->mode != V4L2_TUNER_RADIO)
1061  return;
1062  if (fe_tuner_ops->get_status) {
1063  u32 tuner_status;
1064 
1065  fe_tuner_ops->get_status(&t->fe, &tuner_status);
1066  if (tuner_status & TUNER_STATUS_LOCKED)
1067  tuner_info("Tuner is locked.\n");
1068  if (tuner_status & TUNER_STATUS_STEREO)
1069  tuner_info("Stereo: yes\n");
1070  }
1071  if (analog_ops->has_signal)
1072  tuner_info("Signal strength: %d\n",
1073  analog_ops->has_signal(fe));
1074 }
1075 
1076 /*
1077  * Function to splicitly change mode to radio. Probably not needed anymore
1078  */
1079 
1080 static int tuner_s_radio(struct v4l2_subdev *sd)
1081 {
1082  struct tuner *t = to_tuner(sd);
1083 
1084  if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1085  set_freq(t, 0);
1086  return 0;
1087 }
1088 
1089 /*
1090  * Tuner callbacks to handle userspace ioctl's
1091  */
1092 
1098 static int tuner_s_power(struct v4l2_subdev *sd, int on)
1099 {
1100  struct tuner *t = to_tuner(sd);
1101  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1102 
1103  if (on) {
1104  if (t->standby && set_mode(t, t->mode) == 0) {
1105  tuner_dbg("Waking up tuner\n");
1106  set_freq(t, 0);
1107  }
1108  return 0;
1109  }
1110 
1111  tuner_dbg("Putting tuner to sleep\n");
1112  t->standby = true;
1113  if (analog_ops->standby)
1114  analog_ops->standby(&t->fe);
1115  return 0;
1116 }
1117 
1118 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1119 {
1120  struct tuner *t = to_tuner(sd);
1121 
1123  return 0;
1124 
1125  t->std = tuner_fixup_std(t, std);
1126  if (t->std != std)
1127  tuner_dbg("Fixup standard %llx to %llx\n", std, t->std);
1128  set_freq(t, 0);
1129  return 0;
1130 }
1131 
1132 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1133 {
1134  struct tuner *t = to_tuner(sd);
1135 
1136  if (set_mode(t, f->type) == 0)
1137  set_freq(t, f->frequency);
1138  return 0;
1139 }
1140 
1151 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1152 {
1153  struct tuner *t = to_tuner(sd);
1154  struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1155 
1156  if (check_mode(t, f->type) == -EINVAL)
1157  return 0;
1158  if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1159  u32 abs_freq;
1160 
1161  fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1162  f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1163  DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1164  DIV_ROUND_CLOSEST(abs_freq, 62500);
1165  } else {
1166  f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1167  t->radio_freq : t->tv_freq;
1168  }
1169  return 0;
1170 }
1171 
1182 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1183 {
1184  struct tuner *t = to_tuner(sd);
1185  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1186  struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1187 
1188  if (check_mode(t, vt->type) == -EINVAL)
1189  return 0;
1190  if (vt->type == t->mode && analog_ops->get_afc)
1191  vt->afc = analog_ops->get_afc(&t->fe);
1192  if (analog_ops->has_signal)
1193  vt->signal = analog_ops->has_signal(&t->fe);
1194  if (vt->type != V4L2_TUNER_RADIO) {
1196  vt->rangelow = tv_range[0] * 16;
1197  vt->rangehigh = tv_range[1] * 16;
1198  return 0;
1199  }
1200 
1201  /* radio mode */
1202  if (vt->type == t->mode) {
1204  if (fe_tuner_ops->get_status) {
1205  u32 tuner_status;
1206 
1207  fe_tuner_ops->get_status(&t->fe, &tuner_status);
1208  vt->rxsubchans =
1209  (tuner_status & TUNER_STATUS_STEREO) ?
1212  }
1213  vt->audmode = t->audmode;
1214  }
1216  vt->rangelow = radio_range[0] * 16000;
1217  vt->rangehigh = radio_range[1] * 16000;
1218 
1219  return 0;
1220 }
1221 
1231 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1232 {
1233  struct tuner *t = to_tuner(sd);
1234 
1235  if (set_mode(t, vt->type))
1236  return 0;
1237 
1238  if (t->mode == V4L2_TUNER_RADIO)
1239  t->audmode = vt->audmode;
1240  set_freq(t, 0);
1241 
1242  return 0;
1243 }
1244 
1245 static int tuner_log_status(struct v4l2_subdev *sd)
1246 {
1247  struct tuner *t = to_tuner(sd);
1248  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1249 
1250  if (analog_ops->tuner_status)
1251  analog_ops->tuner_status(&t->fe);
1252  return 0;
1253 }
1254 
1255 #ifdef CONFIG_PM_SLEEP
1256 static int tuner_suspend(struct device *dev)
1257 {
1258  struct i2c_client *c = to_i2c_client(dev);
1259  struct tuner *t = to_tuner(i2c_get_clientdata(c));
1260  struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1261 
1262  tuner_dbg("suspend\n");
1263 
1264  if (!t->standby && analog_ops->standby)
1265  analog_ops->standby(&t->fe);
1266 
1267  return 0;
1268 }
1269 
1270 static int tuner_resume(struct device *dev)
1271 {
1272  struct i2c_client *c = to_i2c_client(dev);
1273  struct tuner *t = to_tuner(i2c_get_clientdata(c));
1274 
1275  tuner_dbg("resume\n");
1276 
1277  if (!t->standby)
1278  if (set_mode(t, t->mode) == 0)
1279  set_freq(t, 0);
1280 
1281  return 0;
1282 }
1283 #endif
1284 
1285 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1286 {
1287  struct v4l2_subdev *sd = i2c_get_clientdata(client);
1288 
1289  /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1290  to handle it here.
1291  There must be a better way of doing this... */
1292  switch (cmd) {
1293  case TUNER_SET_CONFIG:
1294  return tuner_s_config(sd, arg);
1295  }
1296  return -ENOIOCTLCMD;
1297 }
1298 
1299 /*
1300  * Callback structs
1301  */
1302 
1303 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1304  .log_status = tuner_log_status,
1305  .s_std = tuner_s_std,
1306  .s_power = tuner_s_power,
1307 };
1308 
1309 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1310  .s_radio = tuner_s_radio,
1311  .g_tuner = tuner_g_tuner,
1312  .s_tuner = tuner_s_tuner,
1313  .s_frequency = tuner_s_frequency,
1314  .g_frequency = tuner_g_frequency,
1315  .s_type_addr = tuner_s_type_addr,
1316  .s_config = tuner_s_config,
1317 };
1318 
1319 static const struct v4l2_subdev_ops tuner_ops = {
1320  .core = &tuner_core_ops,
1321  .tuner = &tuner_tuner_ops,
1322 };
1323 
1324 /*
1325  * I2C structs and module init functions
1326  */
1327 
1328 static const struct dev_pm_ops tuner_pm_ops = {
1329  SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1330 };
1331 
1332 static const struct i2c_device_id tuner_id[] = {
1333  { "tuner", }, /* autodetect */
1334  { }
1335 };
1336 MODULE_DEVICE_TABLE(i2c, tuner_id);
1337 
1338 static struct i2c_driver tuner_driver = {
1339  .driver = {
1340  .owner = THIS_MODULE,
1341  .name = "tuner",
1342  .pm = &tuner_pm_ops,
1343  },
1344  .probe = tuner_probe,
1345  .remove = tuner_remove,
1346  .command = tuner_command,
1347  .id_table = tuner_id,
1348 };
1349 
1350 module_i2c_driver(tuner_driver);
1351 
1352 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1353 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1354 MODULE_LICENSE("GPL");