blob: 4ca686fad55786597a2e857f5d13174b2e5074c5 [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>
Michael Krufky5e453dc2006-01-09 15:32:31 -020021#include <media/v4l2-common.h>
Hans Verkuil9dd659d2007-11-04 11:03:36 -030022#include <media/v4l2-i2c-drv-legacy.h>
Michael Krufky96c0b7c2007-08-27 21:23:08 -030023#include "mt20xx.h"
Michael Krufky910bb3e2007-08-27 21:22:20 -030024#include "tda8290.h"
Michael Krufky7ab10bf2007-08-27 21:23:40 -030025#include "tea5761.h"
Michael Krufky8d0936e2007-08-27 21:24:27 -030026#include "tea5767.h"
Mauro Carvalho Chehab215b95b2007-10-23 15:24:06 -030027#include "tuner-xc2028.h"
Michael Krufky4adad282007-08-27 21:59:08 -030028#include "tuner-simple.h"
Michael Krufky31c95842007-10-21 20:48:48 -030029#include "tda9887.h"
Steven Toth27c685a2008-01-05 16:50:14 -030030#include "xc5000.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#define UNSET (-1U)
33
Hans Verkuil9dd659d2007-11-04 11:03:36 -030034#define PREFIX t->i2c->driver->driver.name
Michael Krufky241020d2007-10-30 09:46:10 -030035
Michael Krufkya07c8772008-04-29 03:54:19 -030036/** This macro allows us to probe dynamically, avoiding static links */
Mauro Carvalho Chehabff138172008-04-29 23:02:33 -030037#ifdef CONFIG_MEDIA_ATTACH
Michael Krufkya07c8772008-04-29 03:54:19 -030038#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
39 int __r = -EINVAL; \
40 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
41 if (__a) { \
42 __r = (int) __a(ARGS); \
Andrew Mortona1355e52008-04-30 11:40:17 -030043 symbol_put(FUNCTION); \
Michael Krufkya07c8772008-04-29 03:54:19 -030044 } else { \
45 printk(KERN_ERR "TUNER: Unable to find " \
46 "symbol "#FUNCTION"()\n"); \
47 } \
Michael Krufkya07c8772008-04-29 03:54:19 -030048 __r; \
49})
50
51static void tuner_detach(struct dvb_frontend *fe)
52{
53 if (fe->ops.tuner_ops.release) {
54 fe->ops.tuner_ops.release(fe);
55 symbol_put_addr(fe->ops.tuner_ops.release);
56 }
57 if (fe->ops.analog_ops.release) {
58 fe->ops.analog_ops.release(fe);
59 symbol_put_addr(fe->ops.analog_ops.release);
60 }
61}
62#else
63#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
64 FUNCTION(ARGS); \
65})
66
67static void tuner_detach(struct dvb_frontend *fe)
68{
69 if (fe->ops.tuner_ops.release)
70 fe->ops.tuner_ops.release(fe);
71 if (fe->ops.analog_ops.release)
72 fe->ops.analog_ops.release(fe);
73}
74#endif
75
Michael Krufkyf7f427e2007-12-16 22:02:26 -030076struct tuner {
77 /* device */
78 struct dvb_frontend fe;
79 struct i2c_client *i2c;
80 struct list_head list;
81 unsigned int using_v4l2:1;
82
83 /* keep track of the current settings */
84 v4l2_std_id std;
85 unsigned int tv_freq;
86 unsigned int radio_freq;
87 unsigned int audmode;
88
89 unsigned int mode;
90 unsigned int mode_mask; /* Combination of allowable modes */
91
92 unsigned int type; /* chip type id */
93 unsigned int config;
94 int (*tuner_callback) (void *dev, int command, int arg);
95};
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097/* standard i2c insmod options */
98static unsigned short normal_i2c[] = {
Mauro Carvalho Chehab149ef722008-04-29 21:38:46 -030099#if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300100 0x10,
101#endif
Hartmut Hackmannde48eeb2005-11-08 21:37:48 -0800102 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
Mauro Carvalho Chehabf5bec392005-06-23 22:05:13 -0700103 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
104 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 I2C_CLIENT_END
106};
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108I2C_CLIENT_INSMOD;
109
110/* insmod options used at init time => read/only */
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -0300111static unsigned int addr;
112static unsigned int no_autodetect;
113static unsigned int show_i2c;
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115/* insmod options used at runtime => read/write */
Michael Krufkyab166052007-12-09 02:26:48 -0300116static int tuner_debug;
117
118#define tuner_warn(fmt, arg...) do { \
119 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
120 i2c_adapter_id(t->i2c->adapter), \
121 t->i2c->addr, ##arg); \
122 } while (0)
123
124#define tuner_info(fmt, arg...) do { \
125 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
126 i2c_adapter_id(t->i2c->adapter), \
127 t->i2c->addr, ##arg); \
128 } while (0)
129
130#define tuner_err(fmt, arg...) do { \
131 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
132 i2c_adapter_id(t->i2c->adapter), \
133 t->i2c->addr, ##arg); \
134 } while (0)
135
136#define tuner_dbg(fmt, arg...) do { \
137 if (tuner_debug) \
138 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
139 i2c_adapter_id(t->i2c->adapter), \
140 t->i2c->addr, ##arg); \
141 } while (0)
142
143/* ------------------------------------------------------------------------ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700145static unsigned int tv_range[2] = { 44, 958 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146static unsigned int radio_range[2] = { 65, 108 };
147
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200148static char pal[] = "--";
149static char secam[] = "--";
150static char ntsc[] = "-";
151
Hans Verkuilf9195de2006-01-11 19:01:01 -0200152
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200153module_param(addr, int, 0444);
154module_param(no_autodetect, int, 0444);
155module_param(show_i2c, int, 0444);
Hans Verkuilf9195de2006-01-11 19:01:01 -0200156module_param_named(debug,tuner_debug, int, 0644);
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200157module_param_string(pal, pal, sizeof(pal), 0644);
158module_param_string(secam, secam, sizeof(secam), 0644);
159module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700160module_param_array(tv_range, int, NULL, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161module_param_array(radio_range, int, NULL, 0644);
162
163MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
164MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
165MODULE_LICENSE("GPL");
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167/* ---------------------------------------------------------------------- */
168
Michael Krufkyc7919d52007-12-08 17:06:30 -0300169static void fe_set_params(struct dvb_frontend *fe,
170 struct analog_parameters *params)
Michael Krufkye18f9442007-08-21 01:25:48 -0300171{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300172 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
173 struct tuner *t = fe->analog_demod_priv;
Michael Krufkye18f9442007-08-21 01:25:48 -0300174
Michael Krufkye18f9442007-08-21 01:25:48 -0300175 if (NULL == fe_tuner_ops->set_analog_params) {
176 tuner_warn("Tuner frontend module has no way to set freq\n");
177 return;
178 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300179 fe_tuner_ops->set_analog_params(fe, params);
Michael Krufkye18f9442007-08-21 01:25:48 -0300180}
181
Michael Krufky4e9154b2007-10-21 19:39:50 -0300182static void fe_standby(struct dvb_frontend *fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300183{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300184 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
Michael Krufkye18f9442007-08-21 01:25:48 -0300185
186 if (fe_tuner_ops->sleep)
Michael Krufky4e9154b2007-10-21 19:39:50 -0300187 fe_tuner_ops->sleep(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300188}
189
Michael Krufky4e9154b2007-10-21 19:39:50 -0300190static int fe_has_signal(struct dvb_frontend *fe)
Michael Krufky1f5ef192007-08-31 17:38:02 -0300191{
Michael Krufky14196832007-10-14 18:11:53 -0300192 u16 strength = 0;
Michael Krufky1f5ef192007-08-31 17:38:02 -0300193
Michael Krufky4e9154b2007-10-21 19:39:50 -0300194 if (fe->ops.tuner_ops.get_rf_strength)
195 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300196
197 return strength;
198}
199
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300200static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
201{
202 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
203 struct tuner *t = fe->analog_demod_priv;
204
205 if (fe_tuner_ops->set_config)
206 return fe_tuner_ops->set_config(fe, priv_cfg);
207
208 tuner_warn("Tuner frontend module has no way to set config\n");
209
210 return 0;
211}
212
Michael Krufky4e9154b2007-10-21 19:39:50 -0300213static void tuner_status(struct dvb_frontend *fe);
Michael Krufky1dde7a42007-10-21 13:40:56 -0300214
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300215static struct analog_demod_ops tuner_core_ops = {
Michael Krufkyc7919d52007-12-08 17:06:30 -0300216 .set_params = fe_set_params,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300217 .standby = fe_standby,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300218 .has_signal = fe_has_signal,
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300219 .set_config = fe_set_config,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300220 .tuner_status = tuner_status
221};
222
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700223/* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224static void set_tv_freq(struct i2c_client *c, unsigned int freq)
225{
226 struct tuner *t = i2c_get_clientdata(c);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300227 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Michael Krufkyc7919d52007-12-08 17:06:30 -0300229 struct analog_parameters params = {
230 .mode = t->mode,
231 .audmode = t->audmode,
232 .std = t->std
233 };
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700236 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 return;
238 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300239 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700240 tuner_warn ("Tuner has no way to set tv freq\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 return;
242 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700243 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
244 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
245 freq / 16, freq % 16 * 100 / 16, tv_range[0],
246 tv_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200247 /* V4L2 spec: if the freq is not possible then the closest
248 possible value should be selected */
249 if (freq < tv_range[0] * 16)
250 freq = tv_range[0] * 16;
251 else
252 freq = tv_range[1] * 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300254 params.frequency = freq;
255
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300256 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257}
258
259static void set_radio_freq(struct i2c_client *c, unsigned int freq)
260{
261 struct tuner *t = i2c_get_clientdata(c);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300262 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Michael Krufkyc7919d52007-12-08 17:06:30 -0300264 struct analog_parameters params = {
265 .mode = t->mode,
266 .audmode = t->audmode,
267 .std = t->std
268 };
269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700271 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return;
273 }
Mauro Carvalho Chehabe545d6e2008-01-05 16:37:04 -0300274 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700275 tuner_warn ("tuner has no way to set radio frequency\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return;
277 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200278 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700279 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
280 freq / 16000, freq % 16000 * 100 / 16000,
281 radio_range[0], radio_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200282 /* V4L2 spec: if the freq is not possible then the closest
283 possible value should be selected */
284 if (freq < radio_range[0] * 16000)
285 freq = radio_range[0] * 16000;
286 else
287 freq = radio_range[1] * 16000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300289 params.frequency = freq;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700290
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300291 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
294static void set_freq(struct i2c_client *c, unsigned long freq)
295{
296 struct tuner *t = i2c_get_clientdata(c);
297
298 switch (t->mode) {
299 case V4L2_TUNER_RADIO:
300 tuner_dbg("radio freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700301 freq / 16000, freq % 16000 * 100 / 16000);
302 set_radio_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200303 t->radio_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 break;
305 case V4L2_TUNER_ANALOG_TV:
306 case V4L2_TUNER_DIGITAL_TV:
307 tuner_dbg("tv freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700308 freq / 16, freq % 16 * 100 / 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 set_tv_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200310 t->tv_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 break;
Mauro Carvalho Chehab6cb45872007-10-02 11:57:03 -0300312 default:
313 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315}
316
Michael Krufky293197c2007-08-28 17:20:42 -0300317static void tuner_i2c_address_check(struct tuner *t)
318{
319 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300320 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
Michael Krufky293197c2007-08-28 17:20:42 -0300321 return;
322
Michael Krufky16410022008-01-21 12:01:34 -0300323 /* We already know that the XC5000 can only be located at
324 * i2c address 0x61, 0x62, 0x63 or 0x64 */
325 if ((t->type == TUNER_XC5000) &&
326 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
327 return;
328
Michael Krufky293197c2007-08-28 17:20:42 -0300329 tuner_warn("====================== WARNING! ======================\n");
330 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
331 tuner_warn("will soon be dropped. This message indicates that your\n");
332 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300333 t->i2c->name, t->i2c->addr);
Michael Krufky293197c2007-08-28 17:20:42 -0300334 tuner_warn("To ensure continued support for your device, please\n");
335 tuner_warn("send a copy of this message, along with full dmesg\n");
336 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
337 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
338 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
Michael Krufky060a5bd2008-04-22 14:41:51 -0300339 t->i2c->adapter->name, t->i2c->addr, t->type, t->i2c->name);
Michael Krufky293197c2007-08-28 17:20:42 -0300340 tuner_warn("====================== WARNING! ======================\n");
341}
342
Steven Toth27c685a2008-01-05 16:50:14 -0300343static struct xc5000_config xc5000_cfg;
344
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700345static void set_type(struct i2c_client *c, unsigned int type,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300346 unsigned int new_mode_mask, unsigned int new_config,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300347 int (*tuner_callback) (void *dev, int command,int arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
349 struct tuner *t = i2c_get_clientdata(c);
Michael Krufkye18f9442007-08-21 01:25:48 -0300350 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300351 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700352 unsigned char buffer[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700354 if (type == UNSET || type == TUNER_ABSENT) {
355 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return;
357 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 t->type = type;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300360 t->config = new_config;
361 if (tuner_callback != NULL) {
362 tuner_dbg("defining GPIO callback\n");
363 t->tuner_callback = tuner_callback;
364 }
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300365
Mauro Carvalho Chehab48aa3362007-10-29 11:33:18 -0300366 if (t->mode == T_UNINITIALIZED) {
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300367 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
368
369 return;
370 }
371
Michael Krufkyb2083192007-05-29 22:54:06 -0300372 /* discard private data, in case set_type() was previously called */
Michael Krufkya07c8772008-04-29 03:54:19 -0300373 tuner_detach(&t->fe);
374 t->fe.analog_demod_priv = NULL;
Michael Krufkybe2b85a2007-06-04 14:40:27 -0300375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 switch (t->type) {
377 case TUNER_MT2032:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300378 if (!dvb_attach(microtune_attach,
379 &t->fe, t->i2c->adapter, t->i2c->addr))
380 goto attach_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 break;
382 case TUNER_PHILIPS_TDA8290:
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300383 {
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300384 struct tda829x_config cfg = {
385 .lna_cfg = t->config,
386 .tuner_callback = t->tuner_callback,
387 };
388 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
389 t->i2c->addr, &cfg))
390 goto attach_failed;
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300391 break;
392 }
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700393 case TUNER_TEA5767:
Michael Krufkya07c8772008-04-29 03:54:19 -0300394 if (!dvb_attach(tea5767_attach, &t->fe,
395 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300396 goto attach_failed;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700397 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700398 break;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300399 case TUNER_TEA5761:
Michael Krufkya07c8772008-04-29 03:54:19 -0300400 if (!dvb_attach(tea5761_attach, &t->fe,
401 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300402 goto attach_failed;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300403 t->mode_mask = T_RADIO;
404 break;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700405 case TUNER_PHILIPS_FMD1216ME_MK3:
406 buffer[0] = 0x0b;
407 buffer[1] = 0xdc;
408 buffer[2] = 0x9c;
409 buffer[3] = 0x60;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700410 i2c_master_send(c, buffer, 4);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700411 mdelay(1);
412 buffer[2] = 0x86;
413 buffer[3] = 0x54;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700414 i2c_master_send(c, buffer, 4);
Michael Krufkya07c8772008-04-29 03:54:19 -0300415 if (!dvb_attach(simple_tuner_attach, &t->fe,
416 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300417 goto attach_failed;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700418 break;
Hartmut Hackmann93df3412005-11-08 21:36:31 -0800419 case TUNER_PHILIPS_TD1316:
420 buffer[0] = 0x0b;
421 buffer[1] = 0xdc;
422 buffer[2] = 0x86;
423 buffer[3] = 0xa4;
Michael Krufkya07c8772008-04-29 03:54:19 -0300424 i2c_master_send(c, buffer, 4);
425 if (!dvb_attach(simple_tuner_attach, &t->fe,
426 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300427 goto attach_failed;
Markus Rechbergerac272ed2006-01-23 17:11:09 -0200428 break;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300429 case TUNER_XC2028:
430 {
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300431 struct xc2028_config cfg = {
432 .i2c_adap = t->i2c->adapter,
433 .i2c_addr = t->i2c->addr,
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300434 .callback = t->tuner_callback,
435 };
Michael Krufkya07c8772008-04-29 03:54:19 -0300436 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300437 goto attach_failed;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300438 break;
439 }
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300440 case TUNER_TDA9887:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300441 if (!dvb_attach(tda9887_attach,
442 &t->fe, t->i2c->adapter, t->i2c->addr))
443 goto attach_failed;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300444 break;
Steven Toth27c685a2008-01-05 16:50:14 -0300445 case TUNER_XC5000:
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300446 {
447 struct dvb_tuner_ops *xc_tuner_ops;
448
Steven Toth27c685a2008-01-05 16:50:14 -0300449 xc5000_cfg.i2c_address = t->i2c->addr;
450 xc5000_cfg.if_khz = 5380;
Steven Toth73c993a2008-01-05 17:08:05 -0300451 xc5000_cfg.priv = c->adapter->algo_data;
Steven Toth27c685a2008-01-05 16:50:14 -0300452 xc5000_cfg.tuner_callback = t->tuner_callback;
Michael Krufkya07c8772008-04-29 03:54:19 -0300453 if (!dvb_attach(xc5000_attach,
454 &t->fe, t->i2c->adapter, &xc5000_cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300455 goto attach_failed;
456
Steven Toth27c685a2008-01-05 16:50:14 -0300457 xc_tuner_ops = &t->fe.ops.tuner_ops;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300458 if (xc_tuner_ops->init)
Steven Toth27c685a2008-01-05 16:50:14 -0300459 xc_tuner_ops->init(&t->fe);
Steven Toth27c685a2008-01-05 16:50:14 -0300460 break;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300461 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 default:
Michael Krufkya07c8772008-04-29 03:54:19 -0300463 if (!dvb_attach(simple_tuner_attach, &t->fe,
464 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300465 goto attach_failed;
466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 break;
468 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700469
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300470 if ((NULL == analog_ops->set_params) &&
Michael Krufky1dde7a42007-10-21 13:40:56 -0300471 (fe_tuner_ops->set_analog_params)) {
Michael Krufkya07c8772008-04-29 03:54:19 -0300472
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300473 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
474 sizeof(t->i2c->name));
Michael Krufkye18f9442007-08-21 01:25:48 -0300475
Michael Krufky4e9154b2007-10-21 19:39:50 -0300476 t->fe.analog_demod_priv = t;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300477 memcpy(analog_ops, &tuner_core_ops,
478 sizeof(struct analog_demod_ops));
Michael Krufkya07c8772008-04-29 03:54:19 -0300479
Michael Krufkya55db8c2007-12-09 13:52:51 -0300480 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300481 strlcpy(t->i2c->name, analog_ops->info.name,
Michael Krufkya55db8c2007-12-09 13:52:51 -0300482 sizeof(t->i2c->name));
Michael Krufkye18f9442007-08-21 01:25:48 -0300483 }
484
Michael Krufky49427442007-10-30 09:44:12 -0300485 tuner_dbg("type set to %s\n", t->i2c->name);
Michael Krufkye18f9442007-08-21 01:25:48 -0300486
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700487 if (t->mode_mask == T_UNINITIALIZED)
488 t->mode_mask = new_mode_mask;
489
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300490 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
491 trying to set a frequency here will just fail
492 FIXME: better to move set_freq to the tuner code. This is needed
493 on analog tuners for PLL to properly work
494 */
495 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
496 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
497 t->radio_freq : t->tv_freq);
498
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700499 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100500 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700501 t->mode_mask);
Michael Krufky293197c2007-08-28 17:20:42 -0300502 tuner_i2c_address_check(t);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300503 return;
504
505attach_failed:
506 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
507 t->type = TUNER_ABSENT;
508 t->mode_mask = T_UNINITIALIZED;
509
510 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511}
512
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700513/*
514 * This function apply tuner config to tuner specified
515 * by tun_setup structure. I addr is unset, then admin status
516 * and tun addr status is more precise then current status,
517 * it's applied. Otherwise status and type are applied only to
518 * tuner with exactly the same addr.
519*/
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700520
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700521static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700522{
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700523 struct tuner *t = i2c_get_clientdata(c);
524
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300525 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
526 (t->mode_mask & tun_setup->mode_mask))) ||
527 (tun_setup->addr == c->addr)) {
528 set_type(c, tun_setup->type, tun_setup->mode_mask,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300529 tun_setup->config, tun_setup->tuner_callback);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300530 } else
531 tuner_dbg("set addr discarded for type %i, mask %x. "
532 "Asked to change tuner at addr 0x%02x, with mask %x\n",
533 t->type, t->mode_mask,
534 tun_setup->addr, tun_setup->mode_mask);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700535}
536
537static inline int check_mode(struct tuner *t, char *cmd)
538{
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700539 if ((1 << t->mode & t->mode_mask) == 0) {
540 return EINVAL;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700541 }
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700542
543 switch (t->mode) {
544 case V4L2_TUNER_RADIO:
545 tuner_dbg("Cmd %s accepted for radio\n", cmd);
546 break;
547 case V4L2_TUNER_ANALOG_TV:
548 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
549 break;
550 case V4L2_TUNER_DIGITAL_TV:
551 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
552 break;
553 }
554 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700555}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700556
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700557/* get more precise norm info from insmod option */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558static int tuner_fixup_std(struct tuner *t)
559{
560 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 switch (pal[0]) {
Hans Verkuile71ced12006-12-11 15:51:43 -0300562 case '6':
563 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
564 t->std = V4L2_STD_PAL_60;
565 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 case 'b':
567 case 'B':
568 case 'g':
569 case 'G':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700570 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 t->std = V4L2_STD_PAL_BG;
572 break;
573 case 'i':
574 case 'I':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700575 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 t->std = V4L2_STD_PAL_I;
577 break;
578 case 'd':
579 case 'D':
580 case 'k':
581 case 'K':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700582 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 t->std = V4L2_STD_PAL_DK;
584 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700585 case 'M':
586 case 'm':
587 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
588 t->std = V4L2_STD_PAL_M;
589 break;
590 case 'N':
591 case 'n':
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200592 if (pal[1] == 'c' || pal[1] == 'C') {
593 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
594 t->std = V4L2_STD_PAL_Nc;
595 } else {
596 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
597 t->std = V4L2_STD_PAL_N;
598 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700599 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700600 case '-':
601 /* default parameter, do nothing */
602 break;
603 default:
604 tuner_warn ("pal= argument not recognised\n");
605 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
607 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700608 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
609 switch (secam[0]) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200610 case 'b':
611 case 'B':
612 case 'g':
613 case 'G':
614 case 'h':
615 case 'H':
616 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
617 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
618 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700619 case 'd':
620 case 'D':
621 case 'k':
622 case 'K':
623 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
624 t->std = V4L2_STD_SECAM_DK;
625 break;
626 case 'l':
627 case 'L':
Mauro Carvalho Chehab800d3c62005-11-13 16:07:48 -0800628 if ((secam[1]=='C')||(secam[1]=='c')) {
629 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
630 t->std = V4L2_STD_SECAM_LC;
631 } else {
632 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
633 t->std = V4L2_STD_SECAM_L;
634 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700635 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700636 case '-':
637 /* default parameter, do nothing */
638 break;
639 default:
640 tuner_warn ("secam= argument not recognised\n");
641 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700642 }
643 }
644
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200645 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
646 switch (ntsc[0]) {
647 case 'm':
648 case 'M':
649 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
650 t->std = V4L2_STD_NTSC_M;
651 break;
652 case 'j':
653 case 'J':
654 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
655 t->std = V4L2_STD_NTSC_M_JP;
656 break;
Hans Verkuild97a11e2006-02-07 06:48:40 -0200657 case 'k':
658 case 'K':
659 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
660 t->std = V4L2_STD_NTSC_M_KR;
661 break;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200662 case '-':
663 /* default parameter, do nothing */
664 break;
665 default:
666 tuner_info("ntsc= argument not recognised\n");
667 break;
668 }
669 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return 0;
671}
672
Michael Krufky4e9154b2007-10-21 19:39:50 -0300673static void tuner_status(struct dvb_frontend *fe)
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200674{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300675 struct tuner *t = fe->analog_demod_priv;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200676 unsigned long freq, freq_fraction;
Michael Krufkya07c8772008-04-29 03:54:19 -0300677 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
678 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200679 const char *p;
680
681 switch (t->mode) {
682 case V4L2_TUNER_RADIO: p = "radio"; break;
683 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
684 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
685 default: p = "undefined"; break;
686 }
687 if (t->mode == V4L2_TUNER_RADIO) {
Hans Verkuil27487d42006-01-15 15:04:52 -0200688 freq = t->radio_freq / 16000;
689 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200690 } else {
Hans Verkuil27487d42006-01-15 15:04:52 -0200691 freq = t->tv_freq / 16;
692 freq_fraction = (t->tv_freq % 16) * 100 / 16;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200693 }
694 tuner_info("Tuner mode: %s\n", p);
695 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
Mauro Carvalho Chehab4ae5c2e2006-03-25 15:53:38 -0300696 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200697 if (t->mode != V4L2_TUNER_RADIO)
698 return;
Michael Krufkye18f9442007-08-21 01:25:48 -0300699 if (fe_tuner_ops->get_status) {
700 u32 tuner_status;
701
702 fe_tuner_ops->get_status(&t->fe, &tuner_status);
703 if (tuner_status & TUNER_STATUS_LOCKED)
704 tuner_info("Tuner is locked.\n");
705 if (tuner_status & TUNER_STATUS_STEREO)
706 tuner_info("Stereo: yes\n");
707 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300708 if (analog_ops->has_signal)
709 tuner_info("Signal strength: %d\n",
710 analog_ops->has_signal(fe));
711 if (analog_ops->is_stereo)
712 tuner_info("Stereo: %s\n",
713 analog_ops->is_stereo(fe) ? "yes" : "no");
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200714}
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716/* ---------------------------------------------------------------------- */
717
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700718/*
719 * Switch tuner to other mode. If tuner support both tv and radio,
720 * set another frequency to some value (This is needed for some pal
721 * tuners to avoid locking). Otherwise, just put second tuner in
722 * standby mode.
723 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700725static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
726{
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300727 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Michael Krufky1dde7a42007-10-21 13:40:56 -0300728
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800729 if (mode == t->mode)
730 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700731
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800732 t->mode = mode;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700733
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800734 if (check_mode(t, cmd) == EINVAL) {
735 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300736 if (analog_ops->standby)
737 analog_ops->standby(&t->fe);
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800738 return EINVAL;
739 }
740 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700741}
742
743#define switch_v4l2() if (!t->using_v4l2) \
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800744 tuner_dbg("switching to v4l2\n"); \
745 t->using_v4l2 = 1;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700746
747static inline int check_v4l2(struct tuner *t)
748{
Hans Verkuil3bbe5a82006-04-01 15:27:52 -0300749 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
750 TV, v4l1 for radio), until that is fixed this code is disabled.
751 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
752 first. */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700753 return 0;
754}
755
756static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
758 struct tuner *t = i2c_get_clientdata(client);
Michael Krufkye18f9442007-08-21 01:25:48 -0300759 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300760 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Mauro Carvalho Chehab397be5c2008-04-26 14:04:10 -0300762 if (tuner_debug > 1) {
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300763 v4l_i2c_print_ioctl(client,cmd);
Mauro Carvalho Chehab397be5c2008-04-26 14:04:10 -0300764 printk("\n");
765 }
Michael Krufky5e453dc2006-01-09 15:32:31 -0200766
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700767 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 /* --- configuration --- */
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700769 case TUNER_SET_TYPE_ADDR:
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300770 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700771 ((struct tuner_setup *)arg)->type,
772 ((struct tuner_setup *)arg)->addr,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300773 ((struct tuner_setup *)arg)->mode_mask,
774 ((struct tuner_setup *)arg)->config);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700775
776 set_addr(client, (struct tuner_setup *)arg);
Mauro Carvalho Chehab391cd722005-06-23 22:02:43 -0700777 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 case AUDC_SET_RADIO:
Hans Verkuil27487d42006-01-15 15:04:52 -0200779 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 break;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700785 case TUNER_SET_STANDBY:
Hans Verkuil27487d42006-01-15 15:04:52 -0200786 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
787 return 0;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300788 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300789 if (analog_ops->standby)
790 analog_ops->standby(&t->fe);
Hans Verkuil27487d42006-01-15 15:04:52 -0200791 break;
Mauro Carvalho Chehab17de9a42008-04-15 18:11:50 -0300792#ifdef CONFIG_VIDEO_ALLOW_V4L1
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700793 case VIDIOCSAUDIO:
794 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
795 return 0;
796 if (check_v4l2(t) == EINVAL)
797 return 0;
798
799 /* Should be implemented, since bttv calls it */
800 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700801 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 case VIDIOCSCHAN:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700803 {
804 static const v4l2_std_id map[] = {
805 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
806 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
807 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
808 [4 /* bttv */ ] = V4L2_STD_PAL_M,
809 [5 /* bttv */ ] = V4L2_STD_PAL_N,
810 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
811 };
812 struct video_channel *vc = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700814 if (check_v4l2(t) == EINVAL)
815 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700816
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700817 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
818 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700820 if (vc->norm < ARRAY_SIZE(map))
821 t->std = map[vc->norm];
822 tuner_fixup_std(t);
Hans Verkuil27487d42006-01-15 15:04:52 -0200823 if (t->tv_freq)
824 set_tv_freq(client, t->tv_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700825 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700826 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700827 case VIDIOCSFREQ:
828 {
829 unsigned long *v = arg;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700830
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700831 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
832 return 0;
833 if (check_v4l2(t) == EINVAL)
834 return 0;
835
836 set_freq(client, *v);
837 return 0;
838 }
839 case VIDIOCGTUNER:
840 {
841 struct video_tuner *vt = arg;
842
843 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
844 return 0;
845 if (check_v4l2(t) == EINVAL)
846 return 0;
847
848 if (V4L2_TUNER_RADIO == t->mode) {
Michael Krufkye18f9442007-08-21 01:25:48 -0300849 if (fe_tuner_ops->get_status) {
850 u32 tuner_status;
851
852 fe_tuner_ops->get_status(&t->fe, &tuner_status);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300853 if (tuner_status & TUNER_STATUS_STEREO)
854 vt->flags |= VIDEO_TUNER_STEREO_ON;
855 else
856 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
Michael Krufkye18f9442007-08-21 01:25:48 -0300857 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300858 if (analog_ops->is_stereo) {
859 if (analog_ops->is_stereo(&t->fe))
Michael Krufkye18f9442007-08-21 01:25:48 -0300860 vt->flags |=
861 VIDEO_TUNER_STEREO_ON;
862 else
863 vt->flags &=
864 ~VIDEO_TUNER_STEREO_ON;
865 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700866 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300867 if (analog_ops->has_signal)
868 vt->signal =
869 analog_ops->has_signal(&t->fe);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300870
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700871 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
872
873 vt->rangelow = radio_range[0] * 16000;
874 vt->rangehigh = radio_range[1] * 16000;
875
876 } else {
877 vt->rangelow = tv_range[0] * 16;
878 vt->rangehigh = tv_range[1] * 16;
879 }
880
881 return 0;
882 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 case VIDIOCGAUDIO:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700884 {
885 struct video_audio *va = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700887 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
888 return 0;
889 if (check_v4l2(t) == EINVAL)
890 return 0;
891
Michael Krufkye18f9442007-08-21 01:25:48 -0300892 if (V4L2_TUNER_RADIO == t->mode) {
893 if (fe_tuner_ops->get_status) {
894 u32 tuner_status;
895
896 fe_tuner_ops->get_status(&t->fe, &tuner_status);
897 va->mode = (tuner_status & TUNER_STATUS_STEREO)
898 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300899 } else if (analog_ops->is_stereo)
900 va->mode = analog_ops->is_stereo(&t->fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300901 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
902 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700903 return 0;
904 }
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300905#endif
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300906 case TUNER_SET_CONFIG:
907 {
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300908 struct v4l2_priv_tun_config *cfg = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300910 if (t->type != cfg->tuner)
911 break;
912
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300913 if (analog_ops->set_config) {
Michael Krufky67d52e22007-12-24 16:05:39 -0300914 analog_ops->set_config(&t->fe, cfg->priv);
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300915 break;
916 }
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300917
Michael Krufky67d52e22007-12-24 16:05:39 -0300918 tuner_dbg("Tuner frontend module has no way to set config\n");
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300919 break;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300920 }
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300921 /* --- v4l ioctls --- */
922 /* take care: bttv does userspace copying, we'll get a
923 kernel pointer here... */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 case VIDIOC_S_STD:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700925 {
926 v4l2_std_id *id = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700928 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
929 == EINVAL)
930 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700931
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700932 switch_v4l2();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700934 t->std = *id;
935 tuner_fixup_std(t);
Hans Verkuil27487d42006-01-15 15:04:52 -0200936 if (t->tv_freq)
937 set_freq(client, t->tv_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700938 break;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700939 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700940 case VIDIOC_S_FREQUENCY:
941 {
942 struct v4l2_frequency *f = arg;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700943
Hans Verkuil4f725cb2006-06-24 09:47:56 -0300944 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
945 == EINVAL)
946 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700947 switch_v4l2();
Hans Verkuil27487d42006-01-15 15:04:52 -0200948 set_freq(client,f->frequency);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700949
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700950 break;
951 }
952 case VIDIOC_G_FREQUENCY:
953 {
954 struct v4l2_frequency *f = arg;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700955
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700956 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
957 return 0;
958 switch_v4l2();
959 f->type = t->mode;
Michael Krufkye18f9442007-08-21 01:25:48 -0300960 if (fe_tuner_ops->get_frequency) {
961 u32 abs_freq;
962
963 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
964 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
965 (abs_freq * 2 + 125/2) / 125 :
966 (abs_freq + 62500/2) / 62500;
967 break;
968 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200969 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
970 t->radio_freq : t->tv_freq;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700971 break;
972 }
973 case VIDIOC_G_TUNER:
974 {
975 struct v4l2_tuner *tuner = arg;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700976
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700977 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
978 return 0;
979 switch_v4l2();
980
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200981 tuner->type = t->mode;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300982 if (analog_ops->get_afc)
983 tuner->afc = analog_ops->get_afc(&t->fe);
Hans Verkuilab4cecf2006-04-01 16:40:21 -0300984 if (t->mode == V4L2_TUNER_ANALOG_TV)
985 tuner->capability |= V4L2_TUNER_CAP_NORM;
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200986 if (t->mode != V4L2_TUNER_RADIO) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700987 tuner->rangelow = tv_range[0] * 16;
988 tuner->rangehigh = tv_range[1] * 16;
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200989 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700990 }
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200991
992 /* radio mode */
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200993 tuner->rxsubchans =
994 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
Michael Krufkye18f9442007-08-21 01:25:48 -0300995 if (fe_tuner_ops->get_status) {
996 u32 tuner_status;
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200997
Michael Krufkye18f9442007-08-21 01:25:48 -0300998 fe_tuner_ops->get_status(&t->fe, &tuner_status);
Michael Krufky4e9154b2007-10-21 19:39:50 -0300999 tuner->rxsubchans =
1000 (tuner_status & TUNER_STATUS_STEREO) ?
1001 V4L2_TUNER_SUB_STEREO :
1002 V4L2_TUNER_SUB_MONO;
Michael Krufkye18f9442007-08-21 01:25:48 -03001003 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001004 if (analog_ops->is_stereo) {
Michael Krufky4e9154b2007-10-21 19:39:50 -03001005 tuner->rxsubchans =
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001006 analog_ops->is_stereo(&t->fe) ?
Michael Krufky4e9154b2007-10-21 19:39:50 -03001007 V4L2_TUNER_SUB_STEREO :
1008 V4L2_TUNER_SUB_MONO;
Michael Krufkye18f9442007-08-21 01:25:48 -03001009 }
Michael Krufkye18f9442007-08-21 01:25:48 -03001010 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001011 if (analog_ops->has_signal)
1012 tuner->signal = analog_ops->has_signal(&t->fe);
Hans Verkuil8a4b2752006-01-23 17:11:09 -02001013 tuner->capability |=
1014 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1015 tuner->audmode = t->audmode;
1016 tuner->rangelow = radio_range[0] * 16000;
1017 tuner->rangehigh = radio_range[1] * 16000;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -07001018 break;
1019 }
1020 case VIDIOC_S_TUNER:
1021 {
1022 struct v4l2_tuner *tuner = arg;
1023
1024 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1025 return 0;
1026
1027 switch_v4l2();
1028
Hans Verkuil8a4b2752006-01-23 17:11:09 -02001029 /* do nothing unless we're a radio tuner */
1030 if (t->mode != V4L2_TUNER_RADIO)
1031 break;
1032 t->audmode = tuner->audmode;
1033 set_radio_freq(client, t->radio_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -07001034 break;
1035 }
Hans Verkuilcd43c3f2006-01-09 15:25:15 -02001036 case VIDIOC_LOG_STATUS:
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001037 if (analog_ops->tuner_status)
1038 analog_ops->tuner_status(&t->fe);
Hans Verkuilcd43c3f2006-01-09 15:25:15 -02001039 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 }
1041
1042 return 0;
1043}
1044
Jean Delvare21b48a72007-03-12 19:20:15 -03001045static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046{
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001047 struct tuner *t = i2c_get_clientdata(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001049 tuner_dbg("suspend\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 /* FIXME: power down ??? */
1051 return 0;
1052}
1053
Jean Delvare21b48a72007-03-12 19:20:15 -03001054static int tuner_resume(struct i2c_client *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001056 struct tuner *t = i2c_get_clientdata(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001058 tuner_dbg("resume\n");
Hans Verkuil27487d42006-01-15 15:04:52 -02001059 if (V4L2_TUNER_RADIO == t->mode) {
1060 if (t->radio_freq)
1061 set_freq(c, t->radio_freq);
1062 } else {
1063 if (t->tv_freq)
1064 set_freq(c, t->tv_freq);
1065 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 return 0;
1067}
1068
Hans Verkuil92de1f12007-11-04 10:53:09 -03001069/* ---------------------------------------------------------------------- */
1070
Adrian Bunkc52c4d02008-01-28 22:11:15 -03001071static LIST_HEAD(tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001072
1073/* Search for existing radio and/or TV tuners on the given I2C adapter.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001074 Note that when this function is called from tuner_probe you can be
Hans Verkuil92de1f12007-11-04 10:53:09 -03001075 certain no other devices will be added/deleted at the same time, I2C
1076 core protects against that. */
1077static void tuner_lookup(struct i2c_adapter *adap,
1078 struct tuner **radio, struct tuner **tv)
1079{
1080 struct tuner *pos;
1081
1082 *radio = NULL;
1083 *tv = NULL;
1084
1085 list_for_each_entry(pos, &tuner_list, list) {
1086 int mode_mask;
1087
1088 if (pos->i2c->adapter != adap ||
1089 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1090 continue;
1091
1092 mode_mask = pos->mode_mask & ~T_STANDBY;
1093 if (*radio == NULL && mode_mask == T_RADIO)
1094 *radio = pos;
1095 /* Note: currently TDA9887 is the only demod-only
1096 device. If other devices appear then we need to
1097 make this test more general. */
1098 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1099 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1100 *tv = pos;
1101 }
1102}
1103
1104/* During client attach, set_type is called by adapter's attach_inform callback.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001105 set_type must then be completed by tuner_probe.
Hans Verkuil92de1f12007-11-04 10:53:09 -03001106 */
Jean Delvared2653e92008-04-29 23:11:39 +02001107static int tuner_probe(struct i2c_client *client,
1108 const struct i2c_device_id *id)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001109{
Hans Verkuil92de1f12007-11-04 10:53:09 -03001110 struct tuner *t;
1111 struct tuner *radio;
1112 struct tuner *tv;
1113
Hans Verkuil92de1f12007-11-04 10:53:09 -03001114 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001115 if (NULL == t)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001116 return -ENOMEM;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001117 t->i2c = client;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001118 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
Hans Verkuil92de1f12007-11-04 10:53:09 -03001119 i2c_set_clientdata(client, t);
1120 t->type = UNSET;
1121 t->audmode = V4L2_TUNER_MODE_STEREO;
1122 t->mode_mask = T_UNINITIALIZED;
1123
1124 if (show_i2c) {
1125 unsigned char buffer[16];
1126 int i, rc;
1127
1128 memset(buffer, 0, sizeof(buffer));
1129 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1130 tuner_info("I2C RECV = ");
1131 for (i = 0; i < rc; i++)
1132 printk(KERN_CONT "%02x ", buffer[i]);
1133 printk("\n");
1134 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001135 /* HACK: This test was added to avoid tuner to probe tda9840 and
Hans Verkuil92de1f12007-11-04 10:53:09 -03001136 tea6415c on the MXB card */
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001137 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1138 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001139 return -ENODEV;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001140 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001141
1142 /* autodetection code based on the i2c addr */
1143 if (!no_autodetect) {
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001144 switch (client->addr) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001145 case 0x10:
Michael Krufkya07c8772008-04-29 03:54:19 -03001146 if (tuner_symbol_probe(tea5761_autodetection,
1147 t->i2c->adapter,
1148 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001149 t->type = TUNER_TEA5761;
1150 t->mode_mask = T_RADIO;
1151 t->mode = T_STANDBY;
1152 /* Sets freq to FM range */
1153 t->radio_freq = 87.5 * 16000;
1154 tuner_lookup(t->i2c->adapter, &radio, &tv);
1155 if (tv)
1156 tv->mode_mask &= ~T_RADIO;
1157
1158 goto register_client;
1159 }
Mauro Carvalho Chehab867e8352008-04-23 17:27:27 -03001160 return -ENODEV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001161 case 0x42:
1162 case 0x43:
1163 case 0x4a:
1164 case 0x4b:
1165 /* If chip is not tda8290, don't register.
1166 since it can be tda9887*/
Michael Krufkya07c8772008-04-29 03:54:19 -03001167 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001168 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001169 tuner_dbg("tda829x detected\n");
1170 } else {
1171 /* Default is being tda9887 */
1172 t->type = TUNER_TDA9887;
1173 t->mode_mask = T_RADIO | T_ANALOG_TV |
1174 T_DIGITAL_TV;
1175 t->mode = T_STANDBY;
1176 goto register_client;
1177 }
1178 break;
1179 case 0x60:
Michael Krufkya07c8772008-04-29 03:54:19 -03001180 if (tuner_symbol_probe(tea5767_autodetection,
1181 t->i2c->adapter, t->i2c->addr)
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001182 >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001183 t->type = TUNER_TEA5767;
1184 t->mode_mask = T_RADIO;
1185 t->mode = T_STANDBY;
1186 /* Sets freq to FM range */
1187 t->radio_freq = 87.5 * 16000;
1188 tuner_lookup(t->i2c->adapter, &radio, &tv);
1189 if (tv)
1190 tv->mode_mask &= ~T_RADIO;
1191
1192 goto register_client;
1193 }
1194 break;
1195 }
1196 }
1197
1198 /* Initializes only the first TV tuner on this adapter. Why only the
1199 first? Because there are some devices (notably the ones with TI
1200 tuners) that have more than one i2c address for the *same* device.
1201 Experience shows that, except for just one case, the first
1202 address is the right one. The exception is a Russian tuner
1203 (ACORP_Y878F). So, the desired behavior is just to enable the
1204 first found TV tuner. */
1205 tuner_lookup(t->i2c->adapter, &radio, &tv);
1206 if (tv == NULL) {
1207 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1208 if (radio == NULL)
1209 t->mode_mask |= T_RADIO;
1210 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1211 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1212 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1213 }
1214
1215 /* Should be just before return */
1216register_client:
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001217 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1218 client->adapter->name);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001219
1220 /* Sets a default mode */
1221 if (t->mode_mask & T_ANALOG_TV) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001222 t->mode = V4L2_TUNER_ANALOG_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001223 } else if (t->mode_mask & T_RADIO) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001224 t->mode = V4L2_TUNER_RADIO;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001225 } else {
Michael Krufky864a6b82007-12-09 17:21:54 -03001226 t->mode = V4L2_TUNER_DIGITAL_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001227 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001228 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001229 list_add_tail(&t->list, &tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001230 return 0;
1231}
1232
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001233static int tuner_legacy_probe(struct i2c_adapter *adap)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001234{
1235 if (0 != addr) {
1236 normal_i2c[0] = addr;
1237 normal_i2c[1] = I2C_CLIENT_END;
1238 }
1239
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001240 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1241 return 0;
1242
Hans Verkuil92de1f12007-11-04 10:53:09 -03001243 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1244 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1245 * and an RTC at 0x6f which can get corrupted if probed.
1246 */
1247 if ((adap->id == I2C_HW_B_CX2388x) ||
1248 (adap->id == I2C_HW_B_CX23885)) {
1249 unsigned int i = 0;
1250
1251 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1252 i += 2;
1253 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1254 ignore[i+0] = adap->nr;
1255 ignore[i+1] = 0x6b;
1256 ignore[i+2] = adap->nr;
1257 ignore[i+3] = 0x6f;
1258 ignore[i+4] = I2C_CLIENT_END;
1259 } else
1260 printk(KERN_WARNING "tuner: "
1261 "too many options specified "
1262 "in i2c probe ignore list!\n");
1263 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001264 return 1;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001265}
1266
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001267static int tuner_remove(struct i2c_client *client)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001268{
1269 struct tuner *t = i2c_get_clientdata(client);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001270
Michael Krufkya07c8772008-04-29 03:54:19 -03001271 tuner_detach(&t->fe);
1272 t->fe.analog_demod_priv = NULL;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001273
1274 list_del(&t->list);
1275 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001276 return 0;
1277}
1278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279/* ----------------------------------------------------------------------- */
1280
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001281static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1282 .name = "tuner",
1283 .driverid = I2C_DRIVERID_TUNER,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -07001284 .command = tuner_command,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001285 .probe = tuner_probe,
1286 .remove = tuner_remove,
Jean Delvare21b48a72007-03-12 19:20:15 -03001287 .suspend = tuner_suspend,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001288 .resume = tuner_resume,
1289 .legacy_probe = tuner_legacy_probe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290};
1291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
1293/*
1294 * Overrides for Emacs so that we follow Linus's tabbing style.
1295 * ---------------------------------------------------------------------------
1296 * Local variables:
1297 * c-basic-offset: 8
1298 * End:
1299 */