blob: 694087bfa77db4a671c729ec4cc16235fe87b11c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
3 * i2c tv tuner chip device driver
4 * core core, i.e. kernel interfaces, registering and so on
5 */
6
7#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/string.h>
10#include <linux/timer.h>
11#include <linux/delay.h>
12#include <linux/errno.h>
13#include <linux/slab.h>
14#include <linux/poll.h>
15#include <linux/i2c.h>
16#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/init.h>
Michael Krufkyffbb8072007-08-21 01:14:12 -030018#include <linux/videodev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <media/tuner.h>
Michael Krufky4adad282007-08-27 21:59:08 -030020#include <media/tuner-types.h>
Hans Verkuile8a4a9e2008-11-24 18:21:40 -030021#include <media/v4l2-device.h>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030022#include <media/v4l2-ioctl.h>
Hans Verkuil9dd659d2007-11-04 11:03:36 -030023#include <media/v4l2-i2c-drv-legacy.h>
Michael Krufky96c0b7c2007-08-27 21:23:08 -030024#include "mt20xx.h"
Michael Krufky910bb3e2007-08-27 21:22:20 -030025#include "tda8290.h"
Michael Krufky7ab10bf2007-08-27 21:23:40 -030026#include "tea5761.h"
Michael Krufky8d0936e2007-08-27 21:24:27 -030027#include "tea5767.h"
Mauro Carvalho Chehab215b95b2007-10-23 15:24:06 -030028#include "tuner-xc2028.h"
Michael Krufky4adad282007-08-27 21:59:08 -030029#include "tuner-simple.h"
Michael Krufky31c95842007-10-21 20:48:48 -030030#include "tda9887.h"
Steven Toth27c685a2008-01-05 16:50:14 -030031#include "xc5000.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#define UNSET (-1U)
34
Hans Verkuil9dd659d2007-11-04 11:03:36 -030035#define PREFIX t->i2c->driver->driver.name
Michael Krufky241020d2007-10-30 09:46:10 -030036
Michael Krufkya07c8772008-04-29 03:54:19 -030037/** This macro allows us to probe dynamically, avoiding static links */
Mauro Carvalho Chehabff138172008-04-29 23:02:33 -030038#ifdef CONFIG_MEDIA_ATTACH
Michael Krufkya07c8772008-04-29 03:54:19 -030039#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
40 int __r = -EINVAL; \
41 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
42 if (__a) { \
43 __r = (int) __a(ARGS); \
Andrew Mortona1355e52008-04-30 11:40:17 -030044 symbol_put(FUNCTION); \
Michael Krufkya07c8772008-04-29 03:54:19 -030045 } else { \
46 printk(KERN_ERR "TUNER: Unable to find " \
47 "symbol "#FUNCTION"()\n"); \
48 } \
Michael Krufkya07c8772008-04-29 03:54:19 -030049 __r; \
50})
51
52static void tuner_detach(struct dvb_frontend *fe)
53{
54 if (fe->ops.tuner_ops.release) {
55 fe->ops.tuner_ops.release(fe);
56 symbol_put_addr(fe->ops.tuner_ops.release);
57 }
58 if (fe->ops.analog_ops.release) {
59 fe->ops.analog_ops.release(fe);
60 symbol_put_addr(fe->ops.analog_ops.release);
61 }
62}
63#else
64#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
65 FUNCTION(ARGS); \
66})
67
68static void tuner_detach(struct dvb_frontend *fe)
69{
70 if (fe->ops.tuner_ops.release)
71 fe->ops.tuner_ops.release(fe);
72 if (fe->ops.analog_ops.release)
73 fe->ops.analog_ops.release(fe);
74}
75#endif
76
Michael Krufkyf7f427e2007-12-16 22:02:26 -030077struct tuner {
78 /* device */
79 struct dvb_frontend fe;
80 struct i2c_client *i2c;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -030081 struct v4l2_subdev sd;
Michael Krufkyf7f427e2007-12-16 22:02:26 -030082 struct list_head list;
83 unsigned int using_v4l2:1;
84
85 /* keep track of the current settings */
86 v4l2_std_id std;
87 unsigned int tv_freq;
88 unsigned int radio_freq;
89 unsigned int audmode;
90
91 unsigned int mode;
92 unsigned int mode_mask; /* Combination of allowable modes */
93
94 unsigned int type; /* chip type id */
95 unsigned int config;
Michael Krufky7271e602008-05-26 16:08:40 +020096 const char *name;
Michael Krufkyf7f427e2007-12-16 22:02:26 -030097};
98
Hans Verkuile8a4a9e2008-11-24 18:21:40 -030099static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
100{
101 return container_of(sd, struct tuner, sd);
102}
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104/* standard i2c insmod options */
105static unsigned short normal_i2c[] = {
Mauro Carvalho Chehab149ef722008-04-29 21:38:46 -0300106#if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300107 0x10,
108#endif
Hartmut Hackmannde48eeb2005-11-08 21:37:48 -0800109 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
Mauro Carvalho Chehabf5bec392005-06-23 22:05:13 -0700110 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
111 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 I2C_CLIENT_END
113};
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115I2C_CLIENT_INSMOD;
116
117/* insmod options used at init time => read/only */
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -0300118static unsigned int addr;
119static unsigned int no_autodetect;
120static unsigned int show_i2c;
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122/* insmod options used at runtime => read/write */
Michael Krufkyab166052007-12-09 02:26:48 -0300123static int tuner_debug;
124
125#define tuner_warn(fmt, arg...) do { \
126 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
127 i2c_adapter_id(t->i2c->adapter), \
128 t->i2c->addr, ##arg); \
129 } while (0)
130
131#define tuner_info(fmt, arg...) do { \
132 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
133 i2c_adapter_id(t->i2c->adapter), \
134 t->i2c->addr, ##arg); \
135 } while (0)
136
137#define tuner_err(fmt, arg...) do { \
138 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
139 i2c_adapter_id(t->i2c->adapter), \
140 t->i2c->addr, ##arg); \
141 } while (0)
142
143#define tuner_dbg(fmt, arg...) do { \
144 if (tuner_debug) \
145 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
146 i2c_adapter_id(t->i2c->adapter), \
147 t->i2c->addr, ##arg); \
148 } while (0)
149
150/* ------------------------------------------------------------------------ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700152static unsigned int tv_range[2] = { 44, 958 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153static unsigned int radio_range[2] = { 65, 108 };
154
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200155static char pal[] = "--";
156static char secam[] = "--";
157static char ntsc[] = "-";
158
Hans Verkuilf9195de2006-01-11 19:01:01 -0200159
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200160module_param(addr, int, 0444);
161module_param(no_autodetect, int, 0444);
162module_param(show_i2c, int, 0444);
Hans Verkuilf9195de2006-01-11 19:01:01 -0200163module_param_named(debug,tuner_debug, int, 0644);
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200164module_param_string(pal, pal, sizeof(pal), 0644);
165module_param_string(secam, secam, sizeof(secam), 0644);
166module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700167module_param_array(tv_range, int, NULL, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168module_param_array(radio_range, int, NULL, 0644);
169
170MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
171MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
172MODULE_LICENSE("GPL");
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174/* ---------------------------------------------------------------------- */
175
Michael Krufkyc7919d52007-12-08 17:06:30 -0300176static void fe_set_params(struct dvb_frontend *fe,
177 struct analog_parameters *params)
Michael Krufkye18f9442007-08-21 01:25:48 -0300178{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300179 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
180 struct tuner *t = fe->analog_demod_priv;
Michael Krufkye18f9442007-08-21 01:25:48 -0300181
Michael Krufkye18f9442007-08-21 01:25:48 -0300182 if (NULL == fe_tuner_ops->set_analog_params) {
183 tuner_warn("Tuner frontend module has no way to set freq\n");
184 return;
185 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300186 fe_tuner_ops->set_analog_params(fe, params);
Michael Krufkye18f9442007-08-21 01:25:48 -0300187}
188
Michael Krufky4e9154b2007-10-21 19:39:50 -0300189static void fe_standby(struct dvb_frontend *fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300190{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300191 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
Michael Krufkye18f9442007-08-21 01:25:48 -0300192
193 if (fe_tuner_ops->sleep)
Michael Krufky4e9154b2007-10-21 19:39:50 -0300194 fe_tuner_ops->sleep(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300195}
196
Michael Krufky4e9154b2007-10-21 19:39:50 -0300197static int fe_has_signal(struct dvb_frontend *fe)
Michael Krufky1f5ef192007-08-31 17:38:02 -0300198{
Michael Krufky14196832007-10-14 18:11:53 -0300199 u16 strength = 0;
Michael Krufky1f5ef192007-08-31 17:38:02 -0300200
Michael Krufky4e9154b2007-10-21 19:39:50 -0300201 if (fe->ops.tuner_ops.get_rf_strength)
202 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300203
204 return strength;
205}
206
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300207static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
208{
209 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
210 struct tuner *t = fe->analog_demod_priv;
211
212 if (fe_tuner_ops->set_config)
213 return fe_tuner_ops->set_config(fe, priv_cfg);
214
215 tuner_warn("Tuner frontend module has no way to set config\n");
216
217 return 0;
218}
219
Michael Krufky4e9154b2007-10-21 19:39:50 -0300220static void tuner_status(struct dvb_frontend *fe);
Michael Krufky1dde7a42007-10-21 13:40:56 -0300221
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300222static struct analog_demod_ops tuner_analog_ops = {
Michael Krufkyc7919d52007-12-08 17:06:30 -0300223 .set_params = fe_set_params,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300224 .standby = fe_standby,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300225 .has_signal = fe_has_signal,
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300226 .set_config = fe_set_config,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300227 .tuner_status = tuner_status
228};
229
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700230/* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231static void set_tv_freq(struct i2c_client *c, unsigned int freq)
232{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300233 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300234 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
Michael Krufkyc7919d52007-12-08 17:06:30 -0300236 struct analog_parameters params = {
237 .mode = t->mode,
238 .audmode = t->audmode,
239 .std = t->std
240 };
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700243 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return;
245 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300246 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700247 tuner_warn ("Tuner has no way to set tv freq\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return;
249 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700250 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
251 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
252 freq / 16, freq % 16 * 100 / 16, tv_range[0],
253 tv_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200254 /* V4L2 spec: if the freq is not possible then the closest
255 possible value should be selected */
256 if (freq < tv_range[0] * 16)
257 freq = tv_range[0] * 16;
258 else
259 freq = tv_range[1] * 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300261 params.frequency = freq;
262
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300263 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
266static void set_radio_freq(struct i2c_client *c, unsigned int freq)
267{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300268 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300269 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Michael Krufkyc7919d52007-12-08 17:06:30 -0300271 struct analog_parameters params = {
272 .mode = t->mode,
273 .audmode = t->audmode,
274 .std = t->std
275 };
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700278 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return;
280 }
Mauro Carvalho Chehabe545d6e2008-01-05 16:37:04 -0300281 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700282 tuner_warn ("tuner has no way to set radio frequency\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 return;
284 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200285 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700286 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
287 freq / 16000, freq % 16000 * 100 / 16000,
288 radio_range[0], radio_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200289 /* V4L2 spec: if the freq is not possible then the closest
290 possible value should be selected */
291 if (freq < radio_range[0] * 16000)
292 freq = radio_range[0] * 16000;
293 else
294 freq = radio_range[1] * 16000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300296 params.frequency = freq;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700297
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300298 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
301static void set_freq(struct i2c_client *c, unsigned long freq)
302{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300303 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 switch (t->mode) {
306 case V4L2_TUNER_RADIO:
307 tuner_dbg("radio freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700308 freq / 16000, freq % 16000 * 100 / 16000);
309 set_radio_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200310 t->radio_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 break;
312 case V4L2_TUNER_ANALOG_TV:
313 case V4L2_TUNER_DIGITAL_TV:
314 tuner_dbg("tv freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700315 freq / 16, freq % 16 * 100 / 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 set_tv_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200317 t->tv_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 break;
Mauro Carvalho Chehab6cb45872007-10-02 11:57:03 -0300319 default:
320 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
323
Michael Krufky293197c2007-08-28 17:20:42 -0300324static void tuner_i2c_address_check(struct tuner *t)
325{
326 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300327 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
Michael Krufky293197c2007-08-28 17:20:42 -0300328 return;
329
Michael Krufky16410022008-01-21 12:01:34 -0300330 /* We already know that the XC5000 can only be located at
331 * i2c address 0x61, 0x62, 0x63 or 0x64 */
332 if ((t->type == TUNER_XC5000) &&
333 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
334 return;
335
Michael Krufky293197c2007-08-28 17:20:42 -0300336 tuner_warn("====================== WARNING! ======================\n");
337 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
338 tuner_warn("will soon be dropped. This message indicates that your\n");
339 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
Michael Krufky7271e602008-05-26 16:08:40 +0200340 t->name, t->i2c->addr);
Michael Krufky293197c2007-08-28 17:20:42 -0300341 tuner_warn("To ensure continued support for your device, please\n");
342 tuner_warn("send a copy of this message, along with full dmesg\n");
343 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
344 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
345 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
Michael Krufky7271e602008-05-26 16:08:40 +0200346 t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
Michael Krufky293197c2007-08-28 17:20:42 -0300347 tuner_warn("====================== WARNING! ======================\n");
348}
349
Steven Toth27c685a2008-01-05 16:50:14 -0300350static struct xc5000_config xc5000_cfg;
351
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700352static void set_type(struct i2c_client *c, unsigned int type,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300353 unsigned int new_mode_mask, unsigned int new_config,
Michael Krufkyd7cba042008-09-12 13:31:45 -0300354 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300356 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkye18f9442007-08-21 01:25:48 -0300357 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300358 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700359 unsigned char buffer[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700361 if (type == UNSET || type == TUNER_ABSENT) {
362 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return;
364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 t->type = type;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300367 t->config = new_config;
368 if (tuner_callback != NULL) {
369 tuner_dbg("defining GPIO callback\n");
Michael Krufkyd7cba042008-09-12 13:31:45 -0300370 t->fe.callback = tuner_callback;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300371 }
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300372
Mauro Carvalho Chehab48aa3362007-10-29 11:33:18 -0300373 if (t->mode == T_UNINITIALIZED) {
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300374 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
375
376 return;
377 }
378
Michael Krufkyb2083192007-05-29 22:54:06 -0300379 /* discard private data, in case set_type() was previously called */
Michael Krufkya07c8772008-04-29 03:54:19 -0300380 tuner_detach(&t->fe);
381 t->fe.analog_demod_priv = NULL;
Michael Krufkybe2b85a2007-06-04 14:40:27 -0300382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 switch (t->type) {
384 case TUNER_MT2032:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300385 if (!dvb_attach(microtune_attach,
386 &t->fe, t->i2c->adapter, t->i2c->addr))
387 goto attach_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 break;
389 case TUNER_PHILIPS_TDA8290:
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300390 {
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300391 struct tda829x_config cfg = {
392 .lna_cfg = t->config,
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300393 };
394 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
395 t->i2c->addr, &cfg))
396 goto attach_failed;
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300397 break;
398 }
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700399 case TUNER_TEA5767:
Michael Krufkya07c8772008-04-29 03:54:19 -0300400 if (!dvb_attach(tea5767_attach, &t->fe,
401 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300402 goto attach_failed;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700403 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700404 break;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300405 case TUNER_TEA5761:
Michael Krufkya07c8772008-04-29 03:54:19 -0300406 if (!dvb_attach(tea5761_attach, &t->fe,
407 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300408 goto attach_failed;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300409 t->mode_mask = T_RADIO;
410 break;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700411 case TUNER_PHILIPS_FMD1216ME_MK3:
412 buffer[0] = 0x0b;
413 buffer[1] = 0xdc;
414 buffer[2] = 0x9c;
415 buffer[3] = 0x60;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700416 i2c_master_send(c, buffer, 4);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700417 mdelay(1);
418 buffer[2] = 0x86;
419 buffer[3] = 0x54;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700420 i2c_master_send(c, buffer, 4);
Michael Krufkya07c8772008-04-29 03:54:19 -0300421 if (!dvb_attach(simple_tuner_attach, &t->fe,
422 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300423 goto attach_failed;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700424 break;
Hartmut Hackmann93df3412005-11-08 21:36:31 -0800425 case TUNER_PHILIPS_TD1316:
426 buffer[0] = 0x0b;
427 buffer[1] = 0xdc;
428 buffer[2] = 0x86;
429 buffer[3] = 0xa4;
Michael Krufkya07c8772008-04-29 03:54:19 -0300430 i2c_master_send(c, buffer, 4);
431 if (!dvb_attach(simple_tuner_attach, &t->fe,
432 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300433 goto attach_failed;
Markus Rechbergerac272ed2006-01-23 17:11:09 -0200434 break;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300435 case TUNER_XC2028:
436 {
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300437 struct xc2028_config cfg = {
438 .i2c_adap = t->i2c->adapter,
439 .i2c_addr = t->i2c->addr,
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300440 };
Michael Krufkya07c8772008-04-29 03:54:19 -0300441 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300442 goto attach_failed;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300443 break;
444 }
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300445 case TUNER_TDA9887:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300446 if (!dvb_attach(tda9887_attach,
447 &t->fe, t->i2c->adapter, t->i2c->addr))
448 goto attach_failed;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300449 break;
Steven Toth27c685a2008-01-05 16:50:14 -0300450 case TUNER_XC5000:
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300451 {
452 struct dvb_tuner_ops *xc_tuner_ops;
453
Steven Toth27c685a2008-01-05 16:50:14 -0300454 xc5000_cfg.i2c_address = t->i2c->addr;
455 xc5000_cfg.if_khz = 5380;
Michael Krufkya07c8772008-04-29 03:54:19 -0300456 if (!dvb_attach(xc5000_attach,
Michael Krufky30650962008-09-06 14:56:58 -0300457 &t->fe, t->i2c->adapter, &xc5000_cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300458 goto attach_failed;
459
Steven Toth27c685a2008-01-05 16:50:14 -0300460 xc_tuner_ops = &t->fe.ops.tuner_ops;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300461 if (xc_tuner_ops->init)
Steven Toth27c685a2008-01-05 16:50:14 -0300462 xc_tuner_ops->init(&t->fe);
Steven Toth27c685a2008-01-05 16:50:14 -0300463 break;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 default:
Michael Krufkya07c8772008-04-29 03:54:19 -0300466 if (!dvb_attach(simple_tuner_attach, &t->fe,
467 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300468 goto attach_failed;
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 break;
471 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700472
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300473 if ((NULL == analog_ops->set_params) &&
Michael Krufky1dde7a42007-10-21 13:40:56 -0300474 (fe_tuner_ops->set_analog_params)) {
Michael Krufkya07c8772008-04-29 03:54:19 -0300475
Michael Krufky7271e602008-05-26 16:08:40 +0200476 t->name = fe_tuner_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300477
Michael Krufky4e9154b2007-10-21 19:39:50 -0300478 t->fe.analog_demod_priv = t;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300479 memcpy(analog_ops, &tuner_analog_ops,
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300480 sizeof(struct analog_demod_ops));
Michael Krufkya07c8772008-04-29 03:54:19 -0300481
Michael Krufkya55db8c2007-12-09 13:52:51 -0300482 } else {
Michael Krufky7271e602008-05-26 16:08:40 +0200483 t->name = analog_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300484 }
485
Michael Krufky7271e602008-05-26 16:08:40 +0200486 tuner_dbg("type set to %s\n", t->name);
Michael Krufkye18f9442007-08-21 01:25:48 -0300487
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700488 if (t->mode_mask == T_UNINITIALIZED)
489 t->mode_mask = new_mode_mask;
490
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300491 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
492 trying to set a frequency here will just fail
493 FIXME: better to move set_freq to the tuner code. This is needed
494 on analog tuners for PLL to properly work
495 */
496 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
497 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
498 t->radio_freq : t->tv_freq);
499
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700500 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100501 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700502 t->mode_mask);
Michael Krufky293197c2007-08-28 17:20:42 -0300503 tuner_i2c_address_check(t);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300504 return;
505
506attach_failed:
507 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
508 t->type = TUNER_ABSENT;
509 t->mode_mask = T_UNINITIALIZED;
510
511 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512}
513
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700514/*
515 * This function apply tuner config to tuner specified
516 * by tun_setup structure. I addr is unset, then admin status
517 * and tun addr status is more precise then current status,
518 * it's applied. Otherwise status and type are applied only to
519 * tuner with exactly the same addr.
520*/
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700521
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700522static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700523{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300524 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700525
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300526 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
527 (t->mode_mask & tun_setup->mode_mask))) ||
528 (tun_setup->addr == c->addr)) {
529 set_type(c, tun_setup->type, tun_setup->mode_mask,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300530 tun_setup->config, tun_setup->tuner_callback);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300531 } else
532 tuner_dbg("set addr discarded for type %i, mask %x. "
533 "Asked to change tuner at addr 0x%02x, with mask %x\n",
534 t->type, t->mode_mask,
535 tun_setup->addr, tun_setup->mode_mask);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700536}
537
538static inline int check_mode(struct tuner *t, char *cmd)
539{
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700540 if ((1 << t->mode & t->mode_mask) == 0) {
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300541 return -EINVAL;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700542 }
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700543
544 switch (t->mode) {
545 case V4L2_TUNER_RADIO:
546 tuner_dbg("Cmd %s accepted for radio\n", cmd);
547 break;
548 case V4L2_TUNER_ANALOG_TV:
549 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
550 break;
551 case V4L2_TUNER_DIGITAL_TV:
552 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
553 break;
554 }
555 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700556}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700557
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700558/* get more precise norm info from insmod option */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559static int tuner_fixup_std(struct tuner *t)
560{
561 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 switch (pal[0]) {
Hans Verkuile71ced12006-12-11 15:51:43 -0300563 case '6':
564 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
565 t->std = V4L2_STD_PAL_60;
566 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 case 'b':
568 case 'B':
569 case 'g':
570 case 'G':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700571 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 t->std = V4L2_STD_PAL_BG;
573 break;
574 case 'i':
575 case 'I':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700576 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 t->std = V4L2_STD_PAL_I;
578 break;
579 case 'd':
580 case 'D':
581 case 'k':
582 case 'K':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700583 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 t->std = V4L2_STD_PAL_DK;
585 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700586 case 'M':
587 case 'm':
588 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
589 t->std = V4L2_STD_PAL_M;
590 break;
591 case 'N':
592 case 'n':
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200593 if (pal[1] == 'c' || pal[1] == 'C') {
594 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
595 t->std = V4L2_STD_PAL_Nc;
596 } else {
597 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
598 t->std = V4L2_STD_PAL_N;
599 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700600 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700601 case '-':
602 /* default parameter, do nothing */
603 break;
604 default:
605 tuner_warn ("pal= argument not recognised\n");
606 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 }
608 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700609 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
610 switch (secam[0]) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200611 case 'b':
612 case 'B':
613 case 'g':
614 case 'G':
615 case 'h':
616 case 'H':
617 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
618 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
619 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700620 case 'd':
621 case 'D':
622 case 'k':
623 case 'K':
624 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
625 t->std = V4L2_STD_SECAM_DK;
626 break;
627 case 'l':
628 case 'L':
Mauro Carvalho Chehab800d3c62005-11-13 16:07:48 -0800629 if ((secam[1]=='C')||(secam[1]=='c')) {
630 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
631 t->std = V4L2_STD_SECAM_LC;
632 } else {
633 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
634 t->std = V4L2_STD_SECAM_L;
635 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700636 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700637 case '-':
638 /* default parameter, do nothing */
639 break;
640 default:
641 tuner_warn ("secam= argument not recognised\n");
642 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700643 }
644 }
645
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200646 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
647 switch (ntsc[0]) {
648 case 'm':
649 case 'M':
650 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
651 t->std = V4L2_STD_NTSC_M;
652 break;
653 case 'j':
654 case 'J':
655 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
656 t->std = V4L2_STD_NTSC_M_JP;
657 break;
Hans Verkuild97a11e2006-02-07 06:48:40 -0200658 case 'k':
659 case 'K':
660 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
661 t->std = V4L2_STD_NTSC_M_KR;
662 break;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200663 case '-':
664 /* default parameter, do nothing */
665 break;
666 default:
667 tuner_info("ntsc= argument not recognised\n");
668 break;
669 }
670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 return 0;
672}
673
Michael Krufky4e9154b2007-10-21 19:39:50 -0300674static void tuner_status(struct dvb_frontend *fe)
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200675{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300676 struct tuner *t = fe->analog_demod_priv;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200677 unsigned long freq, freq_fraction;
Michael Krufkya07c8772008-04-29 03:54:19 -0300678 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
679 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200680 const char *p;
681
682 switch (t->mode) {
683 case V4L2_TUNER_RADIO: p = "radio"; break;
684 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
685 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
686 default: p = "undefined"; break;
687 }
688 if (t->mode == V4L2_TUNER_RADIO) {
Hans Verkuil27487d42006-01-15 15:04:52 -0200689 freq = t->radio_freq / 16000;
690 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200691 } else {
Hans Verkuil27487d42006-01-15 15:04:52 -0200692 freq = t->tv_freq / 16;
693 freq_fraction = (t->tv_freq % 16) * 100 / 16;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200694 }
695 tuner_info("Tuner mode: %s\n", p);
696 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
Mauro Carvalho Chehab4ae5c2e2006-03-25 15:53:38 -0300697 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200698 if (t->mode != V4L2_TUNER_RADIO)
699 return;
Michael Krufkye18f9442007-08-21 01:25:48 -0300700 if (fe_tuner_ops->get_status) {
701 u32 tuner_status;
702
703 fe_tuner_ops->get_status(&t->fe, &tuner_status);
704 if (tuner_status & TUNER_STATUS_LOCKED)
705 tuner_info("Tuner is locked.\n");
706 if (tuner_status & TUNER_STATUS_STEREO)
707 tuner_info("Stereo: yes\n");
708 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300709 if (analog_ops->has_signal)
710 tuner_info("Signal strength: %d\n",
711 analog_ops->has_signal(fe));
712 if (analog_ops->is_stereo)
713 tuner_info("Stereo: %s\n",
714 analog_ops->is_stereo(fe) ? "yes" : "no");
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200715}
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717/* ---------------------------------------------------------------------- */
718
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700719/*
720 * Switch tuner to other mode. If tuner support both tv and radio,
721 * set another frequency to some value (This is needed for some pal
722 * tuners to avoid locking). Otherwise, just put second tuner in
723 * standby mode.
724 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700726static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
727{
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300728 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Michael Krufky1dde7a42007-10-21 13:40:56 -0300729
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800730 if (mode == t->mode)
731 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700732
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800733 t->mode = mode;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700734
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300735 if (check_mode(t, cmd) == -EINVAL) {
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -0300736 tuner_dbg("Tuner doesn't support this mode. "
737 "Putting tuner to sleep\n");
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800738 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300739 if (analog_ops->standby)
740 analog_ops->standby(&t->fe);
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300741 return -EINVAL;
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800742 }
743 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700744}
745
746#define switch_v4l2() if (!t->using_v4l2) \
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800747 tuner_dbg("switching to v4l2\n"); \
748 t->using_v4l2 = 1;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700749
750static inline int check_v4l2(struct tuner *t)
751{
Hans Verkuil3bbe5a82006-04-01 15:27:52 -0300752 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
753 TV, v4l1 for radio), until that is fixed this code is disabled.
754 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
755 first. */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700756 return 0;
757}
758
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300759static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300761 struct tuner *t = to_tuner(sd);
762 struct i2c_client *client = v4l2_get_subdevdata(sd);
763
764 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
765 type->type,
766 type->addr,
767 type->mode_mask,
768 type->config);
769
770 set_addr(client, type);
771 return 0;
772}
773
774static int tuner_s_radio(struct v4l2_subdev *sd)
775{
776 struct tuner *t = to_tuner(sd);
777 struct i2c_client *client = v4l2_get_subdevdata(sd);
778
779 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
780 == -EINVAL)
781 return 0;
782 if (t->radio_freq)
783 set_freq(client, t->radio_freq);
784 return 0;
785}
786
787static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
788{
789 struct tuner *t = to_tuner(sd);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300790 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -0300792 tuner_dbg("Putting tuner to sleep\n");
793
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300794 if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
795 return 0;
796 t->mode = T_STANDBY;
797 if (analog_ops->standby)
798 analog_ops->standby(&t->fe);
799 return 0;
800}
801
802#ifdef CONFIG_VIDEO_ALLOW_V4L1
803static int tuner_ioctl(struct v4l2_subdev *sd, int cmd, void *arg)
804{
805 struct tuner *t = to_tuner(sd);
806 struct i2c_client *client = v4l2_get_subdevdata(sd);
807 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
808 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufky5e453dc2006-01-09 15:32:31 -0200809
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700810 switch (cmd) {
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700811 case VIDIOCSAUDIO:
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300812 if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700813 return 0;
Marcin Slusarz427aad62008-05-11 19:58:59 -0300814 if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700815 return 0;
816
817 /* Should be implemented, since bttv calls it */
818 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700819 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 case VIDIOCSCHAN:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700821 {
822 static const v4l2_std_id map[] = {
823 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
824 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
825 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
826 [4 /* bttv */ ] = V4L2_STD_PAL_M,
827 [5 /* bttv */ ] = V4L2_STD_PAL_N,
828 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
829 };
830 struct video_channel *vc = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Marcin Slusarz427aad62008-05-11 19:58:59 -0300832 if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700833 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700834
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300835 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700836 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700838 if (vc->norm < ARRAY_SIZE(map))
839 t->std = map[vc->norm];
840 tuner_fixup_std(t);
Hans Verkuil27487d42006-01-15 15:04:52 -0200841 if (t->tv_freq)
842 set_tv_freq(client, t->tv_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700843 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700844 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700845 case VIDIOCSFREQ:
846 {
847 unsigned long *v = arg;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700848
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300849 if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700850 return 0;
Marcin Slusarz427aad62008-05-11 19:58:59 -0300851 if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700852 return 0;
853
854 set_freq(client, *v);
855 return 0;
856 }
857 case VIDIOCGTUNER:
858 {
859 struct video_tuner *vt = arg;
860
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300861 if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700862 return 0;
Marcin Slusarz427aad62008-05-11 19:58:59 -0300863 if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700864 return 0;
865
866 if (V4L2_TUNER_RADIO == t->mode) {
Michael Krufkye18f9442007-08-21 01:25:48 -0300867 if (fe_tuner_ops->get_status) {
868 u32 tuner_status;
869
870 fe_tuner_ops->get_status(&t->fe, &tuner_status);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300871 if (tuner_status & TUNER_STATUS_STEREO)
872 vt->flags |= VIDEO_TUNER_STEREO_ON;
873 else
874 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
Michael Krufkye18f9442007-08-21 01:25:48 -0300875 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300876 if (analog_ops->is_stereo) {
877 if (analog_ops->is_stereo(&t->fe))
Michael Krufkye18f9442007-08-21 01:25:48 -0300878 vt->flags |=
879 VIDEO_TUNER_STEREO_ON;
880 else
881 vt->flags &=
882 ~VIDEO_TUNER_STEREO_ON;
883 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700884 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300885 if (analog_ops->has_signal)
886 vt->signal =
887 analog_ops->has_signal(&t->fe);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300888
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700889 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
890
891 vt->rangelow = radio_range[0] * 16000;
892 vt->rangehigh = radio_range[1] * 16000;
893
894 } else {
895 vt->rangelow = tv_range[0] * 16;
896 vt->rangehigh = tv_range[1] * 16;
897 }
898
899 return 0;
900 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 case VIDIOCGAUDIO:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700902 {
903 struct video_audio *va = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300905 if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700906 return 0;
Marcin Slusarz427aad62008-05-11 19:58:59 -0300907 if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700908 return 0;
909
Michael Krufkye18f9442007-08-21 01:25:48 -0300910 if (V4L2_TUNER_RADIO == t->mode) {
911 if (fe_tuner_ops->get_status) {
912 u32 tuner_status;
913
914 fe_tuner_ops->get_status(&t->fe, &tuner_status);
915 va->mode = (tuner_status & TUNER_STATUS_STEREO)
916 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300917 } else if (analog_ops->is_stereo)
918 va->mode = analog_ops->is_stereo(&t->fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300919 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
920 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700921 return 0;
922 }
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300923 }
924 return -ENOIOCTLCMD;
925}
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300926#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300928static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
929{
930 struct tuner *t = to_tuner(sd);
931 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300932
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300933 if (t->type != cfg->tuner)
934 return 0;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300935
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300936 if (analog_ops->set_config) {
937 analog_ops->set_config(&t->fe, cfg->priv);
938 return 0;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300941 tuner_dbg("Tuner frontend module has no way to set config\n");
942 return 0;
943}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700944
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300945/* --- v4l ioctls --- */
946/* take care: bttv does userspace copying, we'll get a
947 kernel pointer here... */
948static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
949{
950 struct tuner *t = to_tuner(sd);
951 struct i2c_client *client = v4l2_get_subdevdata(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300953 if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
954 == -EINVAL)
955 return 0;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700956
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300957 switch_v4l2();
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700958
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300959 t->std = std;
960 tuner_fixup_std(t);
961 if (t->tv_freq)
962 set_freq(client, t->tv_freq);
963 return 0;
964}
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700965
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300966static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
967{
968 struct tuner *t = to_tuner(sd);
969 struct i2c_client *client = v4l2_get_subdevdata(sd);
Michael Krufkye18f9442007-08-21 01:25:48 -0300970
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300971 if (set_mode(client, t, f->type, "VIDIOC_S_FREQUENCY")
972 == -EINVAL)
973 return 0;
974 switch_v4l2();
975 set_freq(client, f->frequency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
977 return 0;
978}
979
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300980static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
981{
982 struct tuner *t = to_tuner(sd);
983 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
984
985 if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
986 return 0;
987 switch_v4l2();
988 f->type = t->mode;
989 if (fe_tuner_ops->get_frequency) {
990 u32 abs_freq;
991
992 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
993 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
994 (abs_freq * 2 + 125/2) / 125 :
995 (abs_freq + 62500/2) / 62500;
996 return 0;
997 }
998 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
999 t->radio_freq : t->tv_freq;
1000 return 0;
1001}
1002
1003static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1004{
1005 struct tuner *t = to_tuner(sd);
1006 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1007 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1008
1009 if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
1010 return 0;
1011 switch_v4l2();
1012
1013 vt->type = t->mode;
1014 if (analog_ops->get_afc)
1015 vt->afc = analog_ops->get_afc(&t->fe);
1016 if (t->mode == V4L2_TUNER_ANALOG_TV)
1017 vt->capability |= V4L2_TUNER_CAP_NORM;
1018 if (t->mode != V4L2_TUNER_RADIO) {
1019 vt->rangelow = tv_range[0] * 16;
1020 vt->rangehigh = tv_range[1] * 16;
1021 return 0;
1022 }
1023
1024 /* radio mode */
1025 vt->rxsubchans =
1026 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1027 if (fe_tuner_ops->get_status) {
1028 u32 tuner_status;
1029
1030 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1031 vt->rxsubchans =
1032 (tuner_status & TUNER_STATUS_STEREO) ?
1033 V4L2_TUNER_SUB_STEREO :
1034 V4L2_TUNER_SUB_MONO;
1035 } else {
1036 if (analog_ops->is_stereo) {
1037 vt->rxsubchans =
1038 analog_ops->is_stereo(&t->fe) ?
1039 V4L2_TUNER_SUB_STEREO :
1040 V4L2_TUNER_SUB_MONO;
1041 }
1042 }
1043 if (analog_ops->has_signal)
1044 vt->signal = analog_ops->has_signal(&t->fe);
1045 vt->capability |=
1046 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1047 vt->audmode = t->audmode;
1048 vt->rangelow = radio_range[0] * 16000;
1049 vt->rangehigh = radio_range[1] * 16000;
1050 return 0;
1051}
1052
1053static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1054{
1055 struct tuner *t = to_tuner(sd);
1056 struct i2c_client *client = v4l2_get_subdevdata(sd);
1057
1058 if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1059 return 0;
1060
1061 switch_v4l2();
1062
1063 /* do nothing unless we're a radio tuner */
1064 if (t->mode != V4L2_TUNER_RADIO)
1065 return 0;
1066 t->audmode = vt->audmode;
1067 set_radio_freq(client, t->radio_freq);
1068 return 0;
1069}
1070
1071static int tuner_log_status(struct v4l2_subdev *sd)
1072{
1073 struct tuner *t = to_tuner(sd);
1074 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1075
1076 if (analog_ops->tuner_status)
1077 analog_ops->tuner_status(&t->fe);
1078 return 0;
1079}
1080
1081static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1082{
1083 return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1084}
1085
Jean Delvare21b48a72007-03-12 19:20:15 -03001086static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001088 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001090 tuner_dbg("suspend\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 /* FIXME: power down ??? */
1092 return 0;
1093}
1094
Jean Delvare21b48a72007-03-12 19:20:15 -03001095static int tuner_resume(struct i2c_client *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001097 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001099 tuner_dbg("resume\n");
Hans Verkuil27487d42006-01-15 15:04:52 -02001100 if (V4L2_TUNER_RADIO == t->mode) {
1101 if (t->radio_freq)
1102 set_freq(c, t->radio_freq);
1103 } else {
1104 if (t->tv_freq)
1105 set_freq(c, t->tv_freq);
1106 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 return 0;
1108}
1109
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001110/* ----------------------------------------------------------------------- */
1111
1112static const struct v4l2_subdev_core_ops tuner_core_ops = {
1113 .log_status = tuner_log_status,
1114 .s_standby = tuner_s_standby,
Hans Verkuil49dd1312008-12-19 07:07:56 -03001115#ifdef CONFIG_VIDEO_ALLOW_V4L1
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001116 .ioctl = tuner_ioctl,
Hans Verkuil49dd1312008-12-19 07:07:56 -03001117#endif
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001118};
1119
1120static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1121 .s_std = tuner_s_std,
1122 .s_radio = tuner_s_radio,
1123 .g_tuner = tuner_g_tuner,
1124 .s_tuner = tuner_s_tuner,
1125 .s_frequency = tuner_s_frequency,
1126 .g_frequency = tuner_g_frequency,
1127 .s_type_addr = tuner_s_type_addr,
1128 .s_config = tuner_s_config,
1129};
1130
1131static const struct v4l2_subdev_ops tuner_ops = {
1132 .core = &tuner_core_ops,
1133 .tuner = &tuner_tuner_ops,
1134};
1135
Hans Verkuil92de1f12007-11-04 10:53:09 -03001136/* ---------------------------------------------------------------------- */
1137
Adrian Bunkc52c4d02008-01-28 22:11:15 -03001138static LIST_HEAD(tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001139
1140/* Search for existing radio and/or TV tuners on the given I2C adapter.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001141 Note that when this function is called from tuner_probe you can be
Hans Verkuil92de1f12007-11-04 10:53:09 -03001142 certain no other devices will be added/deleted at the same time, I2C
1143 core protects against that. */
1144static void tuner_lookup(struct i2c_adapter *adap,
1145 struct tuner **radio, struct tuner **tv)
1146{
1147 struct tuner *pos;
1148
1149 *radio = NULL;
1150 *tv = NULL;
1151
1152 list_for_each_entry(pos, &tuner_list, list) {
1153 int mode_mask;
1154
1155 if (pos->i2c->adapter != adap ||
1156 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1157 continue;
1158
1159 mode_mask = pos->mode_mask & ~T_STANDBY;
1160 if (*radio == NULL && mode_mask == T_RADIO)
1161 *radio = pos;
1162 /* Note: currently TDA9887 is the only demod-only
1163 device. If other devices appear then we need to
1164 make this test more general. */
1165 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1166 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1167 *tv = pos;
1168 }
1169}
1170
1171/* During client attach, set_type is called by adapter's attach_inform callback.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001172 set_type must then be completed by tuner_probe.
Hans Verkuil92de1f12007-11-04 10:53:09 -03001173 */
Jean Delvared2653e92008-04-29 23:11:39 +02001174static int tuner_probe(struct i2c_client *client,
1175 const struct i2c_device_id *id)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001176{
Hans Verkuil92de1f12007-11-04 10:53:09 -03001177 struct tuner *t;
1178 struct tuner *radio;
1179 struct tuner *tv;
1180
Hans Verkuil92de1f12007-11-04 10:53:09 -03001181 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001182 if (NULL == t)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001183 return -ENOMEM;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001184 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001185 t->i2c = client;
Michael Krufky7271e602008-05-26 16:08:40 +02001186 t->name = "(tuner unset)";
Hans Verkuil92de1f12007-11-04 10:53:09 -03001187 t->type = UNSET;
1188 t->audmode = V4L2_TUNER_MODE_STEREO;
1189 t->mode_mask = T_UNINITIALIZED;
1190
1191 if (show_i2c) {
1192 unsigned char buffer[16];
1193 int i, rc;
1194
1195 memset(buffer, 0, sizeof(buffer));
1196 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1197 tuner_info("I2C RECV = ");
1198 for (i = 0; i < rc; i++)
1199 printk(KERN_CONT "%02x ", buffer[i]);
1200 printk("\n");
1201 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001202 /* HACK: This test was added to avoid tuner to probe tda9840 and
Hans Verkuil92de1f12007-11-04 10:53:09 -03001203 tea6415c on the MXB card */
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001204 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1205 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001206 return -ENODEV;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001207 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001208
1209 /* autodetection code based on the i2c addr */
1210 if (!no_autodetect) {
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001211 switch (client->addr) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001212 case 0x10:
Michael Krufkya07c8772008-04-29 03:54:19 -03001213 if (tuner_symbol_probe(tea5761_autodetection,
1214 t->i2c->adapter,
1215 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001216 t->type = TUNER_TEA5761;
1217 t->mode_mask = T_RADIO;
1218 t->mode = T_STANDBY;
1219 /* Sets freq to FM range */
1220 t->radio_freq = 87.5 * 16000;
1221 tuner_lookup(t->i2c->adapter, &radio, &tv);
1222 if (tv)
1223 tv->mode_mask &= ~T_RADIO;
1224
1225 goto register_client;
1226 }
Mauro Carvalho Chehab867e8352008-04-23 17:27:27 -03001227 return -ENODEV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001228 case 0x42:
1229 case 0x43:
1230 case 0x4a:
1231 case 0x4b:
1232 /* If chip is not tda8290, don't register.
1233 since it can be tda9887*/
Michael Krufkya07c8772008-04-29 03:54:19 -03001234 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001235 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001236 tuner_dbg("tda829x detected\n");
1237 } else {
1238 /* Default is being tda9887 */
1239 t->type = TUNER_TDA9887;
1240 t->mode_mask = T_RADIO | T_ANALOG_TV |
1241 T_DIGITAL_TV;
1242 t->mode = T_STANDBY;
1243 goto register_client;
1244 }
1245 break;
1246 case 0x60:
Michael Krufkya07c8772008-04-29 03:54:19 -03001247 if (tuner_symbol_probe(tea5767_autodetection,
1248 t->i2c->adapter, t->i2c->addr)
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001249 >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001250 t->type = TUNER_TEA5767;
1251 t->mode_mask = T_RADIO;
1252 t->mode = T_STANDBY;
1253 /* Sets freq to FM range */
1254 t->radio_freq = 87.5 * 16000;
1255 tuner_lookup(t->i2c->adapter, &radio, &tv);
1256 if (tv)
1257 tv->mode_mask &= ~T_RADIO;
1258
1259 goto register_client;
1260 }
1261 break;
1262 }
1263 }
1264
1265 /* Initializes only the first TV tuner on this adapter. Why only the
1266 first? Because there are some devices (notably the ones with TI
1267 tuners) that have more than one i2c address for the *same* device.
1268 Experience shows that, except for just one case, the first
1269 address is the right one. The exception is a Russian tuner
1270 (ACORP_Y878F). So, the desired behavior is just to enable the
1271 first found TV tuner. */
1272 tuner_lookup(t->i2c->adapter, &radio, &tv);
1273 if (tv == NULL) {
1274 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1275 if (radio == NULL)
1276 t->mode_mask |= T_RADIO;
1277 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1278 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1279 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1280 }
1281
1282 /* Should be just before return */
1283register_client:
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001284 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1285 client->adapter->name);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001286
1287 /* Sets a default mode */
1288 if (t->mode_mask & T_ANALOG_TV) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001289 t->mode = V4L2_TUNER_ANALOG_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001290 } else if (t->mode_mask & T_RADIO) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001291 t->mode = V4L2_TUNER_RADIO;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001292 } else {
Michael Krufky864a6b82007-12-09 17:21:54 -03001293 t->mode = V4L2_TUNER_DIGITAL_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001294 }
Michael Krufkyd7cba042008-09-12 13:31:45 -03001295 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001296 list_add_tail(&t->list, &tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001297 return 0;
1298}
1299
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001300static int tuner_legacy_probe(struct i2c_adapter *adap)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001301{
1302 if (0 != addr) {
1303 normal_i2c[0] = addr;
1304 normal_i2c[1] = I2C_CLIENT_END;
1305 }
1306
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001307 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1308 return 0;
1309
Hans Verkuil92de1f12007-11-04 10:53:09 -03001310 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1311 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1312 * and an RTC at 0x6f which can get corrupted if probed.
1313 */
1314 if ((adap->id == I2C_HW_B_CX2388x) ||
1315 (adap->id == I2C_HW_B_CX23885)) {
1316 unsigned int i = 0;
1317
1318 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1319 i += 2;
1320 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1321 ignore[i+0] = adap->nr;
1322 ignore[i+1] = 0x6b;
1323 ignore[i+2] = adap->nr;
1324 ignore[i+3] = 0x6f;
1325 ignore[i+4] = I2C_CLIENT_END;
1326 } else
1327 printk(KERN_WARNING "tuner: "
1328 "too many options specified "
1329 "in i2c probe ignore list!\n");
1330 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001331 return 1;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001332}
1333
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001334static int tuner_remove(struct i2c_client *client)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001335{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001336 struct tuner *t = to_tuner(i2c_get_clientdata(client));
Hans Verkuil92de1f12007-11-04 10:53:09 -03001337
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001338 v4l2_device_unregister_subdev(&t->sd);
Michael Krufkya07c8772008-04-29 03:54:19 -03001339 tuner_detach(&t->fe);
1340 t->fe.analog_demod_priv = NULL;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001341
1342 list_del(&t->list);
1343 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001344 return 0;
1345}
1346
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347/* ----------------------------------------------------------------------- */
1348
Jean Delvareaf294862008-05-18 20:49:40 +02001349/* This driver supports many devices and the idea is to let the driver
1350 detect which device is present. So rather than listing all supported
1351 devices here, we pretend to support a single, fake device type. */
1352static const struct i2c_device_id tuner_id[] = {
1353 { "tuner", }, /* autodetect */
1354 { }
1355};
1356MODULE_DEVICE_TABLE(i2c, tuner_id);
1357
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001358static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1359 .name = "tuner",
1360 .driverid = I2C_DRIVERID_TUNER,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -07001361 .command = tuner_command,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001362 .probe = tuner_probe,
1363 .remove = tuner_remove,
Jean Delvare21b48a72007-03-12 19:20:15 -03001364 .suspend = tuner_suspend,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001365 .resume = tuner_resume,
1366 .legacy_probe = tuner_legacy_probe,
Jean Delvareaf294862008-05-18 20:49:40 +02001367 .id_table = tuner_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368};
1369
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370/*
1371 * Overrides for Emacs so that we follow Linus's tabbing style.
1372 * ---------------------------------------------------------------------------
1373 * Local variables:
1374 * c-basic-offset: 8
1375 * End:
1376 */