blob: 28af7b7e9512d1e9aad8c1a01fd9bf6dfaa9a963 [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>
Hans Verkuil75b4c262009-04-01 03:32:22 -030018#include <linux/videodev2.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 Verkuil75b4c262009-04-01 03:32:22 -030023#include <media/v4l2-i2c-drv.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
105/* insmod options used at init time => read/only */
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -0300106static unsigned int addr;
107static unsigned int no_autodetect;
108static unsigned int show_i2c;
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110/* insmod options used at runtime => read/write */
Michael Krufkyab166052007-12-09 02:26:48 -0300111static int tuner_debug;
112
113#define tuner_warn(fmt, arg...) do { \
114 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
115 i2c_adapter_id(t->i2c->adapter), \
116 t->i2c->addr, ##arg); \
117 } while (0)
118
119#define tuner_info(fmt, arg...) do { \
120 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
121 i2c_adapter_id(t->i2c->adapter), \
122 t->i2c->addr, ##arg); \
123 } while (0)
124
125#define tuner_err(fmt, arg...) do { \
126 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
127 i2c_adapter_id(t->i2c->adapter), \
128 t->i2c->addr, ##arg); \
129 } while (0)
130
131#define tuner_dbg(fmt, arg...) do { \
132 if (tuner_debug) \
133 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
134 i2c_adapter_id(t->i2c->adapter), \
135 t->i2c->addr, ##arg); \
136 } while (0)
137
138/* ------------------------------------------------------------------------ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700140static unsigned int tv_range[2] = { 44, 958 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141static unsigned int radio_range[2] = { 65, 108 };
142
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200143static char pal[] = "--";
144static char secam[] = "--";
145static char ntsc[] = "-";
146
Hans Verkuilf9195de2006-01-11 19:01:01 -0200147
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200148module_param(addr, int, 0444);
149module_param(no_autodetect, int, 0444);
150module_param(show_i2c, int, 0444);
Hans Verkuilf9195de2006-01-11 19:01:01 -0200151module_param_named(debug,tuner_debug, int, 0644);
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200152module_param_string(pal, pal, sizeof(pal), 0644);
153module_param_string(secam, secam, sizeof(secam), 0644);
154module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700155module_param_array(tv_range, int, NULL, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156module_param_array(radio_range, int, NULL, 0644);
157
158MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
159MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
160MODULE_LICENSE("GPL");
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162/* ---------------------------------------------------------------------- */
163
Michael Krufkyc7919d52007-12-08 17:06:30 -0300164static void fe_set_params(struct dvb_frontend *fe,
165 struct analog_parameters *params)
Michael Krufkye18f9442007-08-21 01:25:48 -0300166{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300167 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
168 struct tuner *t = fe->analog_demod_priv;
Michael Krufkye18f9442007-08-21 01:25:48 -0300169
Michael Krufkye18f9442007-08-21 01:25:48 -0300170 if (NULL == fe_tuner_ops->set_analog_params) {
171 tuner_warn("Tuner frontend module has no way to set freq\n");
172 return;
173 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300174 fe_tuner_ops->set_analog_params(fe, params);
Michael Krufkye18f9442007-08-21 01:25:48 -0300175}
176
Michael Krufky4e9154b2007-10-21 19:39:50 -0300177static void fe_standby(struct dvb_frontend *fe)
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;
Michael Krufkye18f9442007-08-21 01:25:48 -0300180
181 if (fe_tuner_ops->sleep)
Michael Krufky4e9154b2007-10-21 19:39:50 -0300182 fe_tuner_ops->sleep(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300183}
184
Michael Krufky4e9154b2007-10-21 19:39:50 -0300185static int fe_has_signal(struct dvb_frontend *fe)
Michael Krufky1f5ef192007-08-31 17:38:02 -0300186{
Michael Krufky14196832007-10-14 18:11:53 -0300187 u16 strength = 0;
Michael Krufky1f5ef192007-08-31 17:38:02 -0300188
Michael Krufky4e9154b2007-10-21 19:39:50 -0300189 if (fe->ops.tuner_ops.get_rf_strength)
190 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300191
192 return strength;
193}
194
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300195static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
196{
197 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
198 struct tuner *t = fe->analog_demod_priv;
199
200 if (fe_tuner_ops->set_config)
201 return fe_tuner_ops->set_config(fe, priv_cfg);
202
203 tuner_warn("Tuner frontend module has no way to set config\n");
204
205 return 0;
206}
207
Michael Krufky4e9154b2007-10-21 19:39:50 -0300208static void tuner_status(struct dvb_frontend *fe);
Michael Krufky1dde7a42007-10-21 13:40:56 -0300209
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300210static struct analog_demod_ops tuner_analog_ops = {
Michael Krufkyc7919d52007-12-08 17:06:30 -0300211 .set_params = fe_set_params,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300212 .standby = fe_standby,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300213 .has_signal = fe_has_signal,
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300214 .set_config = fe_set_config,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300215 .tuner_status = tuner_status
216};
217
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700218/* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219static void set_tv_freq(struct i2c_client *c, unsigned int freq)
220{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300221 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300222 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Michael Krufkyc7919d52007-12-08 17:06:30 -0300224 struct analog_parameters params = {
225 .mode = t->mode,
226 .audmode = t->audmode,
227 .std = t->std
228 };
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700231 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return;
233 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300234 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700235 tuner_warn ("Tuner has no way to set tv freq\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 return;
237 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700238 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
239 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
240 freq / 16, freq % 16 * 100 / 16, tv_range[0],
241 tv_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200242 /* V4L2 spec: if the freq is not possible then the closest
243 possible value should be selected */
244 if (freq < tv_range[0] * 16)
245 freq = tv_range[0] * 16;
246 else
247 freq = tv_range[1] * 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300249 params.frequency = freq;
250
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300251 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252}
253
254static void set_radio_freq(struct i2c_client *c, unsigned int freq)
255{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300256 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300257 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Michael Krufkyc7919d52007-12-08 17:06:30 -0300259 struct analog_parameters params = {
260 .mode = t->mode,
261 .audmode = t->audmode,
262 .std = t->std
263 };
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700266 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 return;
268 }
Mauro Carvalho Chehabe545d6e2008-01-05 16:37:04 -0300269 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700270 tuner_warn ("tuner has no way to set radio frequency\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 return;
272 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200273 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700274 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
275 freq / 16000, freq % 16000 * 100 / 16000,
276 radio_range[0], radio_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200277 /* V4L2 spec: if the freq is not possible then the closest
278 possible value should be selected */
279 if (freq < radio_range[0] * 16000)
280 freq = radio_range[0] * 16000;
281 else
282 freq = radio_range[1] * 16000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300284 params.frequency = freq;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700285
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300286 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287}
288
289static void set_freq(struct i2c_client *c, unsigned long freq)
290{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300291 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 switch (t->mode) {
294 case V4L2_TUNER_RADIO:
295 tuner_dbg("radio freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700296 freq / 16000, freq % 16000 * 100 / 16000);
297 set_radio_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200298 t->radio_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 break;
300 case V4L2_TUNER_ANALOG_TV:
301 case V4L2_TUNER_DIGITAL_TV:
302 tuner_dbg("tv freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700303 freq / 16, freq % 16 * 100 / 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 set_tv_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200305 t->tv_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 break;
Mauro Carvalho Chehab6cb45872007-10-02 11:57:03 -0300307 default:
308 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
Michael Krufky293197c2007-08-28 17:20:42 -0300312static void tuner_i2c_address_check(struct tuner *t)
313{
314 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300315 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
Michael Krufky293197c2007-08-28 17:20:42 -0300316 return;
317
Michael Krufky16410022008-01-21 12:01:34 -0300318 /* We already know that the XC5000 can only be located at
319 * i2c address 0x61, 0x62, 0x63 or 0x64 */
320 if ((t->type == TUNER_XC5000) &&
321 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
322 return;
323
Michael Krufky293197c2007-08-28 17:20:42 -0300324 tuner_warn("====================== WARNING! ======================\n");
325 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
326 tuner_warn("will soon be dropped. This message indicates that your\n");
327 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
Michael Krufky7271e602008-05-26 16:08:40 +0200328 t->name, t->i2c->addr);
Michael Krufky293197c2007-08-28 17:20:42 -0300329 tuner_warn("To ensure continued support for your device, please\n");
330 tuner_warn("send a copy of this message, along with full dmesg\n");
331 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
332 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
333 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
Michael Krufky7271e602008-05-26 16:08:40 +0200334 t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
Michael Krufky293197c2007-08-28 17:20:42 -0300335 tuner_warn("====================== WARNING! ======================\n");
336}
337
Steven Toth27c685a2008-01-05 16:50:14 -0300338static struct xc5000_config xc5000_cfg;
339
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700340static void set_type(struct i2c_client *c, unsigned int type,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300341 unsigned int new_mode_mask, unsigned int new_config,
Michael Krufkyd7cba042008-09-12 13:31:45 -0300342 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300344 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkye18f9442007-08-21 01:25:48 -0300345 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300346 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700347 unsigned char buffer[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700349 if (type == UNSET || type == TUNER_ABSENT) {
350 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return;
352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 t->type = type;
Michael Krufkye7ddcd92009-03-28 15:35:26 -0300355 /* prevent invalid config values */
356 t->config = ((new_config >= 0) && (new_config < 256)) ? new_config : 0;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300357 if (tuner_callback != NULL) {
358 tuner_dbg("defining GPIO callback\n");
Michael Krufkyd7cba042008-09-12 13:31:45 -0300359 t->fe.callback = tuner_callback;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300360 }
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300361
Mauro Carvalho Chehab48aa3362007-10-29 11:33:18 -0300362 if (t->mode == T_UNINITIALIZED) {
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300363 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
364
365 return;
366 }
367
Michael Krufkyb2083192007-05-29 22:54:06 -0300368 /* discard private data, in case set_type() was previously called */
Michael Krufkya07c8772008-04-29 03:54:19 -0300369 tuner_detach(&t->fe);
370 t->fe.analog_demod_priv = NULL;
Michael Krufkybe2b85a2007-06-04 14:40:27 -0300371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 switch (t->type) {
373 case TUNER_MT2032:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300374 if (!dvb_attach(microtune_attach,
375 &t->fe, t->i2c->adapter, t->i2c->addr))
376 goto attach_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 break;
378 case TUNER_PHILIPS_TDA8290:
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300379 {
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300380 struct tda829x_config cfg = {
381 .lna_cfg = t->config,
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300382 };
383 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
384 t->i2c->addr, &cfg))
385 goto attach_failed;
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300386 break;
387 }
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700388 case TUNER_TEA5767:
Michael Krufkya07c8772008-04-29 03:54:19 -0300389 if (!dvb_attach(tea5767_attach, &t->fe,
390 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300391 goto attach_failed;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700392 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700393 break;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300394 case TUNER_TEA5761:
Michael Krufkya07c8772008-04-29 03:54:19 -0300395 if (!dvb_attach(tea5761_attach, &t->fe,
396 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300397 goto attach_failed;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300398 t->mode_mask = T_RADIO;
399 break;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700400 case TUNER_PHILIPS_FMD1216ME_MK3:
401 buffer[0] = 0x0b;
402 buffer[1] = 0xdc;
403 buffer[2] = 0x9c;
404 buffer[3] = 0x60;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700405 i2c_master_send(c, buffer, 4);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700406 mdelay(1);
407 buffer[2] = 0x86;
408 buffer[3] = 0x54;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700409 i2c_master_send(c, buffer, 4);
Michael Krufkya07c8772008-04-29 03:54:19 -0300410 if (!dvb_attach(simple_tuner_attach, &t->fe,
411 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300412 goto attach_failed;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700413 break;
Hartmut Hackmann93df3412005-11-08 21:36:31 -0800414 case TUNER_PHILIPS_TD1316:
415 buffer[0] = 0x0b;
416 buffer[1] = 0xdc;
417 buffer[2] = 0x86;
418 buffer[3] = 0xa4;
Michael Krufkya07c8772008-04-29 03:54:19 -0300419 i2c_master_send(c, buffer, 4);
420 if (!dvb_attach(simple_tuner_attach, &t->fe,
421 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300422 goto attach_failed;
Markus Rechbergerac272ed2006-01-23 17:11:09 -0200423 break;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300424 case TUNER_XC2028:
425 {
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300426 struct xc2028_config cfg = {
427 .i2c_adap = t->i2c->adapter,
428 .i2c_addr = t->i2c->addr,
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300429 };
Michael Krufkya07c8772008-04-29 03:54:19 -0300430 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300431 goto attach_failed;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300432 break;
433 }
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300434 case TUNER_TDA9887:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300435 if (!dvb_attach(tda9887_attach,
436 &t->fe, t->i2c->adapter, t->i2c->addr))
437 goto attach_failed;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300438 break;
Steven Toth27c685a2008-01-05 16:50:14 -0300439 case TUNER_XC5000:
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300440 {
441 struct dvb_tuner_ops *xc_tuner_ops;
442
Steven Toth27c685a2008-01-05 16:50:14 -0300443 xc5000_cfg.i2c_address = t->i2c->addr;
Devin Heitmuellerea227862009-03-11 02:58:53 -0300444 /* if_khz will be set when the digital dvb_attach() occurs */
445 xc5000_cfg.if_khz = 0;
Michael Krufkya07c8772008-04-29 03:54:19 -0300446 if (!dvb_attach(xc5000_attach,
Michael Krufky30650962008-09-06 14:56:58 -0300447 &t->fe, t->i2c->adapter, &xc5000_cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300448 goto attach_failed;
449
Steven Toth27c685a2008-01-05 16:50:14 -0300450 xc_tuner_ops = &t->fe.ops.tuner_ops;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300451 if (xc_tuner_ops->init)
Steven Toth27c685a2008-01-05 16:50:14 -0300452 xc_tuner_ops->init(&t->fe);
Steven Toth27c685a2008-01-05 16:50:14 -0300453 break;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 default:
Michael Krufkya07c8772008-04-29 03:54:19 -0300456 if (!dvb_attach(simple_tuner_attach, &t->fe,
457 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300458 goto attach_failed;
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 break;
461 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700462
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300463 if ((NULL == analog_ops->set_params) &&
Michael Krufky1dde7a42007-10-21 13:40:56 -0300464 (fe_tuner_ops->set_analog_params)) {
Michael Krufkya07c8772008-04-29 03:54:19 -0300465
Michael Krufky7271e602008-05-26 16:08:40 +0200466 t->name = fe_tuner_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300467
Michael Krufky4e9154b2007-10-21 19:39:50 -0300468 t->fe.analog_demod_priv = t;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300469 memcpy(analog_ops, &tuner_analog_ops,
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300470 sizeof(struct analog_demod_ops));
Michael Krufkya07c8772008-04-29 03:54:19 -0300471
Michael Krufkya55db8c2007-12-09 13:52:51 -0300472 } else {
Michael Krufky7271e602008-05-26 16:08:40 +0200473 t->name = analog_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300474 }
475
Michael Krufky7271e602008-05-26 16:08:40 +0200476 tuner_dbg("type set to %s\n", t->name);
Michael Krufkye18f9442007-08-21 01:25:48 -0300477
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700478 if (t->mode_mask == T_UNINITIALIZED)
479 t->mode_mask = new_mode_mask;
480
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300481 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
482 trying to set a frequency here will just fail
483 FIXME: better to move set_freq to the tuner code. This is needed
484 on analog tuners for PLL to properly work
485 */
486 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
487 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
488 t->radio_freq : t->tv_freq);
489
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700490 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100491 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700492 t->mode_mask);
Michael Krufky293197c2007-08-28 17:20:42 -0300493 tuner_i2c_address_check(t);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300494 return;
495
496attach_failed:
497 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
498 t->type = TUNER_ABSENT;
499 t->mode_mask = T_UNINITIALIZED;
500
501 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
503
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700504/*
505 * This function apply tuner config to tuner specified
506 * by tun_setup structure. I addr is unset, then admin status
507 * and tun addr status is more precise then current status,
508 * it's applied. Otherwise status and type are applied only to
509 * tuner with exactly the same addr.
510*/
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700511
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700512static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700513{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300514 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700515
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300516 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
517 (t->mode_mask & tun_setup->mode_mask))) ||
518 (tun_setup->addr == c->addr)) {
519 set_type(c, tun_setup->type, tun_setup->mode_mask,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300520 tun_setup->config, tun_setup->tuner_callback);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300521 } else
522 tuner_dbg("set addr discarded for type %i, mask %x. "
523 "Asked to change tuner at addr 0x%02x, with mask %x\n",
524 t->type, t->mode_mask,
525 tun_setup->addr, tun_setup->mode_mask);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700526}
527
528static inline int check_mode(struct tuner *t, char *cmd)
529{
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700530 if ((1 << t->mode & t->mode_mask) == 0) {
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300531 return -EINVAL;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700532 }
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700533
534 switch (t->mode) {
535 case V4L2_TUNER_RADIO:
536 tuner_dbg("Cmd %s accepted for radio\n", cmd);
537 break;
538 case V4L2_TUNER_ANALOG_TV:
539 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
540 break;
541 case V4L2_TUNER_DIGITAL_TV:
542 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
543 break;
544 }
545 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700546}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700547
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700548/* get more precise norm info from insmod option */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549static int tuner_fixup_std(struct tuner *t)
550{
551 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 switch (pal[0]) {
Hans Verkuile71ced12006-12-11 15:51:43 -0300553 case '6':
554 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
555 t->std = V4L2_STD_PAL_60;
556 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 case 'b':
558 case 'B':
559 case 'g':
560 case 'G':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700561 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 t->std = V4L2_STD_PAL_BG;
563 break;
564 case 'i':
565 case 'I':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700566 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 t->std = V4L2_STD_PAL_I;
568 break;
569 case 'd':
570 case 'D':
571 case 'k':
572 case 'K':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700573 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 t->std = V4L2_STD_PAL_DK;
575 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700576 case 'M':
577 case 'm':
578 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
579 t->std = V4L2_STD_PAL_M;
580 break;
581 case 'N':
582 case 'n':
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200583 if (pal[1] == 'c' || pal[1] == 'C') {
584 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
585 t->std = V4L2_STD_PAL_Nc;
586 } else {
587 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
588 t->std = V4L2_STD_PAL_N;
589 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700590 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700591 case '-':
592 /* default parameter, do nothing */
593 break;
594 default:
595 tuner_warn ("pal= argument not recognised\n");
596 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 }
598 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700599 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
600 switch (secam[0]) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200601 case 'b':
602 case 'B':
603 case 'g':
604 case 'G':
605 case 'h':
606 case 'H':
607 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
608 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
609 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700610 case 'd':
611 case 'D':
612 case 'k':
613 case 'K':
614 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
615 t->std = V4L2_STD_SECAM_DK;
616 break;
617 case 'l':
618 case 'L':
Mauro Carvalho Chehab800d3c62005-11-13 16:07:48 -0800619 if ((secam[1]=='C')||(secam[1]=='c')) {
620 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
621 t->std = V4L2_STD_SECAM_LC;
622 } else {
623 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
624 t->std = V4L2_STD_SECAM_L;
625 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700626 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700627 case '-':
628 /* default parameter, do nothing */
629 break;
630 default:
631 tuner_warn ("secam= argument not recognised\n");
632 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700633 }
634 }
635
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200636 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
637 switch (ntsc[0]) {
638 case 'm':
639 case 'M':
640 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
641 t->std = V4L2_STD_NTSC_M;
642 break;
643 case 'j':
644 case 'J':
645 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
646 t->std = V4L2_STD_NTSC_M_JP;
647 break;
Hans Verkuild97a11e2006-02-07 06:48:40 -0200648 case 'k':
649 case 'K':
650 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
651 t->std = V4L2_STD_NTSC_M_KR;
652 break;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200653 case '-':
654 /* default parameter, do nothing */
655 break;
656 default:
657 tuner_info("ntsc= argument not recognised\n");
658 break;
659 }
660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 return 0;
662}
663
Michael Krufky4e9154b2007-10-21 19:39:50 -0300664static void tuner_status(struct dvb_frontend *fe)
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200665{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300666 struct tuner *t = fe->analog_demod_priv;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200667 unsigned long freq, freq_fraction;
Michael Krufkya07c8772008-04-29 03:54:19 -0300668 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
669 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200670 const char *p;
671
672 switch (t->mode) {
673 case V4L2_TUNER_RADIO: p = "radio"; break;
674 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
675 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
676 default: p = "undefined"; break;
677 }
678 if (t->mode == V4L2_TUNER_RADIO) {
Hans Verkuil27487d42006-01-15 15:04:52 -0200679 freq = t->radio_freq / 16000;
680 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200681 } else {
Hans Verkuil27487d42006-01-15 15:04:52 -0200682 freq = t->tv_freq / 16;
683 freq_fraction = (t->tv_freq % 16) * 100 / 16;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200684 }
685 tuner_info("Tuner mode: %s\n", p);
686 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
Mauro Carvalho Chehab4ae5c2e2006-03-25 15:53:38 -0300687 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200688 if (t->mode != V4L2_TUNER_RADIO)
689 return;
Michael Krufkye18f9442007-08-21 01:25:48 -0300690 if (fe_tuner_ops->get_status) {
691 u32 tuner_status;
692
693 fe_tuner_ops->get_status(&t->fe, &tuner_status);
694 if (tuner_status & TUNER_STATUS_LOCKED)
695 tuner_info("Tuner is locked.\n");
696 if (tuner_status & TUNER_STATUS_STEREO)
697 tuner_info("Stereo: yes\n");
698 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300699 if (analog_ops->has_signal)
700 tuner_info("Signal strength: %d\n",
701 analog_ops->has_signal(fe));
702 if (analog_ops->is_stereo)
703 tuner_info("Stereo: %s\n",
704 analog_ops->is_stereo(fe) ? "yes" : "no");
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200705}
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707/* ---------------------------------------------------------------------- */
708
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700709/*
710 * Switch tuner to other mode. If tuner support both tv and radio,
711 * set another frequency to some value (This is needed for some pal
712 * tuners to avoid locking). Otherwise, just put second tuner in
713 * standby mode.
714 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700716static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
717{
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300718 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Michael Krufky1dde7a42007-10-21 13:40:56 -0300719
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800720 if (mode == t->mode)
721 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700722
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800723 t->mode = mode;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700724
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300725 if (check_mode(t, cmd) == -EINVAL) {
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -0300726 tuner_dbg("Tuner doesn't support this mode. "
727 "Putting tuner to sleep\n");
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800728 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300729 if (analog_ops->standby)
730 analog_ops->standby(&t->fe);
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300731 return -EINVAL;
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800732 }
733 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700734}
735
736#define switch_v4l2() if (!t->using_v4l2) \
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800737 tuner_dbg("switching to v4l2\n"); \
738 t->using_v4l2 = 1;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700739
740static inline int check_v4l2(struct tuner *t)
741{
Hans Verkuil3bbe5a82006-04-01 15:27:52 -0300742 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
743 TV, v4l1 for radio), until that is fixed this code is disabled.
744 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
745 first. */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700746 return 0;
747}
748
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300749static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300751 struct tuner *t = to_tuner(sd);
752 struct i2c_client *client = v4l2_get_subdevdata(sd);
753
754 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
755 type->type,
756 type->addr,
757 type->mode_mask,
758 type->config);
759
760 set_addr(client, type);
761 return 0;
762}
763
764static int tuner_s_radio(struct v4l2_subdev *sd)
765{
766 struct tuner *t = to_tuner(sd);
767 struct i2c_client *client = v4l2_get_subdevdata(sd);
768
Hans Verkuilbccfa442009-03-30 06:55:27 -0300769 if (set_mode(client, t, V4L2_TUNER_RADIO, "s_radio") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300770 return 0;
771 if (t->radio_freq)
772 set_freq(client, t->radio_freq);
773 return 0;
774}
775
Hans Verkuil7c9fc9d2009-04-01 03:49:59 -0300776static int tuner_s_standby(struct v4l2_subdev *sd)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300777{
778 struct tuner *t = to_tuner(sd);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300779 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -0300781 tuner_dbg("Putting tuner to sleep\n");
782
Hans Verkuilbccfa442009-03-30 06:55:27 -0300783 if (check_mode(t, "s_standby") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300784 return 0;
785 t->mode = T_STANDBY;
786 if (analog_ops->standby)
787 analog_ops->standby(&t->fe);
788 return 0;
789}
790
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300791static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
792{
793 struct tuner *t = to_tuner(sd);
794 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300795
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300796 if (t->type != cfg->tuner)
797 return 0;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300798
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300799 if (analog_ops->set_config) {
800 analog_ops->set_config(&t->fe, cfg->priv);
801 return 0;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300802 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300804 tuner_dbg("Tuner frontend module has no way to set config\n");
805 return 0;
806}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700807
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300808/* --- v4l ioctls --- */
809/* take care: bttv does userspace copying, we'll get a
810 kernel pointer here... */
811static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
812{
813 struct tuner *t = to_tuner(sd);
814 struct i2c_client *client = v4l2_get_subdevdata(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Hans Verkuilbccfa442009-03-30 06:55:27 -0300816 if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "s_std") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300817 return 0;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700818
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300819 switch_v4l2();
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700820
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300821 t->std = std;
822 tuner_fixup_std(t);
823 if (t->tv_freq)
824 set_freq(client, t->tv_freq);
825 return 0;
826}
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700827
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300828static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
829{
830 struct tuner *t = to_tuner(sd);
831 struct i2c_client *client = v4l2_get_subdevdata(sd);
Michael Krufkye18f9442007-08-21 01:25:48 -0300832
Hans Verkuilbccfa442009-03-30 06:55:27 -0300833 if (set_mode(client, t, f->type, "s_frequency") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300834 return 0;
835 switch_v4l2();
836 set_freq(client, f->frequency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 return 0;
839}
840
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300841static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
842{
843 struct tuner *t = to_tuner(sd);
844 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
845
Hans Verkuilbccfa442009-03-30 06:55:27 -0300846 if (check_mode(t, "g_frequency") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300847 return 0;
848 switch_v4l2();
849 f->type = t->mode;
850 if (fe_tuner_ops->get_frequency) {
851 u32 abs_freq;
852
853 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
854 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
855 (abs_freq * 2 + 125/2) / 125 :
856 (abs_freq + 62500/2) / 62500;
857 return 0;
858 }
859 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
860 t->radio_freq : t->tv_freq;
861 return 0;
862}
863
864static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
865{
866 struct tuner *t = to_tuner(sd);
867 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
868 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
869
Hans Verkuilbccfa442009-03-30 06:55:27 -0300870 if (check_mode(t, "g_tuner") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300871 return 0;
872 switch_v4l2();
873
874 vt->type = t->mode;
875 if (analog_ops->get_afc)
876 vt->afc = analog_ops->get_afc(&t->fe);
877 if (t->mode == V4L2_TUNER_ANALOG_TV)
878 vt->capability |= V4L2_TUNER_CAP_NORM;
879 if (t->mode != V4L2_TUNER_RADIO) {
880 vt->rangelow = tv_range[0] * 16;
881 vt->rangehigh = tv_range[1] * 16;
882 return 0;
883 }
884
885 /* radio mode */
886 vt->rxsubchans =
887 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
888 if (fe_tuner_ops->get_status) {
889 u32 tuner_status;
890
891 fe_tuner_ops->get_status(&t->fe, &tuner_status);
892 vt->rxsubchans =
893 (tuner_status & TUNER_STATUS_STEREO) ?
894 V4L2_TUNER_SUB_STEREO :
895 V4L2_TUNER_SUB_MONO;
896 } else {
897 if (analog_ops->is_stereo) {
898 vt->rxsubchans =
899 analog_ops->is_stereo(&t->fe) ?
900 V4L2_TUNER_SUB_STEREO :
901 V4L2_TUNER_SUB_MONO;
902 }
903 }
904 if (analog_ops->has_signal)
905 vt->signal = analog_ops->has_signal(&t->fe);
906 vt->capability |=
907 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
908 vt->audmode = t->audmode;
909 vt->rangelow = radio_range[0] * 16000;
910 vt->rangehigh = radio_range[1] * 16000;
911 return 0;
912}
913
914static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
915{
916 struct tuner *t = to_tuner(sd);
917 struct i2c_client *client = v4l2_get_subdevdata(sd);
918
Hans Verkuilbccfa442009-03-30 06:55:27 -0300919 if (check_mode(t, "s_tuner") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300920 return 0;
921
922 switch_v4l2();
923
924 /* do nothing unless we're a radio tuner */
925 if (t->mode != V4L2_TUNER_RADIO)
926 return 0;
927 t->audmode = vt->audmode;
928 set_radio_freq(client, t->radio_freq);
929 return 0;
930}
931
932static int tuner_log_status(struct v4l2_subdev *sd)
933{
934 struct tuner *t = to_tuner(sd);
935 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
936
937 if (analog_ops->tuner_status)
938 analog_ops->tuner_status(&t->fe);
939 return 0;
940}
941
Jean Delvare21b48a72007-03-12 19:20:15 -0300942static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300944 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300946 tuner_dbg("suspend\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 /* FIXME: power down ??? */
948 return 0;
949}
950
Jean Delvare21b48a72007-03-12 19:20:15 -0300951static int tuner_resume(struct i2c_client *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300953 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300955 tuner_dbg("resume\n");
Hans Verkuil27487d42006-01-15 15:04:52 -0200956 if (V4L2_TUNER_RADIO == t->mode) {
957 if (t->radio_freq)
958 set_freq(c, t->radio_freq);
959 } else {
960 if (t->tv_freq)
961 set_freq(c, t->tv_freq);
962 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 return 0;
964}
965
Hans Verkuil75b4c262009-04-01 03:32:22 -0300966static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
967{
968 struct v4l2_subdev *sd = i2c_get_clientdata(client);
969
970 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
971 to handle it here.
972 There must be a better way of doing this... */
973 switch (cmd) {
974 case TUNER_SET_CONFIG:
975 return tuner_s_config(sd, arg);
976 }
977 return -ENOIOCTLCMD;
978}
979
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300980/* ----------------------------------------------------------------------- */
981
982static const struct v4l2_subdev_core_ops tuner_core_ops = {
983 .log_status = tuner_log_status,
Hans Verkuilf41737e2009-04-01 03:52:39 -0300984 .s_std = tuner_s_std,
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300985};
986
987static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300988 .s_radio = tuner_s_radio,
989 .g_tuner = tuner_g_tuner,
990 .s_tuner = tuner_s_tuner,
991 .s_frequency = tuner_s_frequency,
992 .g_frequency = tuner_g_frequency,
993 .s_type_addr = tuner_s_type_addr,
994 .s_config = tuner_s_config,
Hans Verkuil7c9fc9d2009-04-01 03:49:59 -0300995 .s_standby = tuner_s_standby,
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300996};
997
998static const struct v4l2_subdev_ops tuner_ops = {
999 .core = &tuner_core_ops,
1000 .tuner = &tuner_tuner_ops,
1001};
1002
Hans Verkuil92de1f12007-11-04 10:53:09 -03001003/* ---------------------------------------------------------------------- */
1004
Adrian Bunkc52c4d02008-01-28 22:11:15 -03001005static LIST_HEAD(tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001006
1007/* Search for existing radio and/or TV tuners on the given I2C adapter.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001008 Note that when this function is called from tuner_probe you can be
Hans Verkuil92de1f12007-11-04 10:53:09 -03001009 certain no other devices will be added/deleted at the same time, I2C
1010 core protects against that. */
1011static void tuner_lookup(struct i2c_adapter *adap,
1012 struct tuner **radio, struct tuner **tv)
1013{
1014 struct tuner *pos;
1015
1016 *radio = NULL;
1017 *tv = NULL;
1018
1019 list_for_each_entry(pos, &tuner_list, list) {
1020 int mode_mask;
1021
1022 if (pos->i2c->adapter != adap ||
1023 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1024 continue;
1025
1026 mode_mask = pos->mode_mask & ~T_STANDBY;
1027 if (*radio == NULL && mode_mask == T_RADIO)
1028 *radio = pos;
1029 /* Note: currently TDA9887 is the only demod-only
1030 device. If other devices appear then we need to
1031 make this test more general. */
1032 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1033 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1034 *tv = pos;
1035 }
1036}
1037
1038/* During client attach, set_type is called by adapter's attach_inform callback.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001039 set_type must then be completed by tuner_probe.
Hans Verkuil92de1f12007-11-04 10:53:09 -03001040 */
Jean Delvared2653e92008-04-29 23:11:39 +02001041static int tuner_probe(struct i2c_client *client,
1042 const struct i2c_device_id *id)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001043{
Hans Verkuil92de1f12007-11-04 10:53:09 -03001044 struct tuner *t;
1045 struct tuner *radio;
1046 struct tuner *tv;
1047
Hans Verkuil92de1f12007-11-04 10:53:09 -03001048 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001049 if (NULL == t)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001050 return -ENOMEM;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001051 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001052 t->i2c = client;
Michael Krufky7271e602008-05-26 16:08:40 +02001053 t->name = "(tuner unset)";
Hans Verkuil92de1f12007-11-04 10:53:09 -03001054 t->type = UNSET;
1055 t->audmode = V4L2_TUNER_MODE_STEREO;
1056 t->mode_mask = T_UNINITIALIZED;
1057
1058 if (show_i2c) {
1059 unsigned char buffer[16];
1060 int i, rc;
1061
1062 memset(buffer, 0, sizeof(buffer));
1063 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1064 tuner_info("I2C RECV = ");
1065 for (i = 0; i < rc; i++)
1066 printk(KERN_CONT "%02x ", buffer[i]);
1067 printk("\n");
1068 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001069 /* HACK: This test was added to avoid tuner to probe tda9840 and
Hans Verkuil92de1f12007-11-04 10:53:09 -03001070 tea6415c on the MXB card */
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001071 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1072 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001073 return -ENODEV;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001074 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001075
1076 /* autodetection code based on the i2c addr */
1077 if (!no_autodetect) {
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001078 switch (client->addr) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001079 case 0x10:
Michael Krufkya07c8772008-04-29 03:54:19 -03001080 if (tuner_symbol_probe(tea5761_autodetection,
1081 t->i2c->adapter,
1082 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001083 t->type = TUNER_TEA5761;
1084 t->mode_mask = T_RADIO;
1085 t->mode = T_STANDBY;
1086 /* Sets freq to FM range */
1087 t->radio_freq = 87.5 * 16000;
1088 tuner_lookup(t->i2c->adapter, &radio, &tv);
1089 if (tv)
1090 tv->mode_mask &= ~T_RADIO;
1091
1092 goto register_client;
1093 }
Mauro Carvalho Chehab867e8352008-04-23 17:27:27 -03001094 return -ENODEV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001095 case 0x42:
1096 case 0x43:
1097 case 0x4a:
1098 case 0x4b:
1099 /* If chip is not tda8290, don't register.
1100 since it can be tda9887*/
Michael Krufkya07c8772008-04-29 03:54:19 -03001101 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001102 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001103 tuner_dbg("tda829x detected\n");
1104 } else {
1105 /* Default is being tda9887 */
1106 t->type = TUNER_TDA9887;
1107 t->mode_mask = T_RADIO | T_ANALOG_TV |
1108 T_DIGITAL_TV;
1109 t->mode = T_STANDBY;
1110 goto register_client;
1111 }
1112 break;
1113 case 0x60:
Michael Krufkya07c8772008-04-29 03:54:19 -03001114 if (tuner_symbol_probe(tea5767_autodetection,
1115 t->i2c->adapter, t->i2c->addr)
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001116 >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001117 t->type = TUNER_TEA5767;
1118 t->mode_mask = T_RADIO;
1119 t->mode = T_STANDBY;
1120 /* Sets freq to FM range */
1121 t->radio_freq = 87.5 * 16000;
1122 tuner_lookup(t->i2c->adapter, &radio, &tv);
1123 if (tv)
1124 tv->mode_mask &= ~T_RADIO;
1125
1126 goto register_client;
1127 }
1128 break;
1129 }
1130 }
1131
1132 /* Initializes only the first TV tuner on this adapter. Why only the
1133 first? Because there are some devices (notably the ones with TI
1134 tuners) that have more than one i2c address for the *same* device.
1135 Experience shows that, except for just one case, the first
1136 address is the right one. The exception is a Russian tuner
1137 (ACORP_Y878F). So, the desired behavior is just to enable the
1138 first found TV tuner. */
1139 tuner_lookup(t->i2c->adapter, &radio, &tv);
1140 if (tv == NULL) {
1141 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1142 if (radio == NULL)
1143 t->mode_mask |= T_RADIO;
1144 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1145 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1146 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1147 }
1148
1149 /* Should be just before return */
1150register_client:
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001151 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1152 client->adapter->name);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001153
1154 /* Sets a default mode */
1155 if (t->mode_mask & T_ANALOG_TV) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001156 t->mode = V4L2_TUNER_ANALOG_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001157 } else if (t->mode_mask & T_RADIO) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001158 t->mode = V4L2_TUNER_RADIO;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001159 } else {
Michael Krufky864a6b82007-12-09 17:21:54 -03001160 t->mode = V4L2_TUNER_DIGITAL_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001161 }
Michael Krufkyd7cba042008-09-12 13:31:45 -03001162 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001163 list_add_tail(&t->list, &tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001164 return 0;
1165}
1166
Hans Verkuil92de1f12007-11-04 10:53:09 -03001167
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001168static int tuner_remove(struct i2c_client *client)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001169{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001170 struct tuner *t = to_tuner(i2c_get_clientdata(client));
Hans Verkuil92de1f12007-11-04 10:53:09 -03001171
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001172 v4l2_device_unregister_subdev(&t->sd);
Michael Krufkya07c8772008-04-29 03:54:19 -03001173 tuner_detach(&t->fe);
1174 t->fe.analog_demod_priv = NULL;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001175
1176 list_del(&t->list);
1177 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001178 return 0;
1179}
1180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181/* ----------------------------------------------------------------------- */
1182
Jean Delvareaf294862008-05-18 20:49:40 +02001183/* This driver supports many devices and the idea is to let the driver
1184 detect which device is present. So rather than listing all supported
1185 devices here, we pretend to support a single, fake device type. */
1186static const struct i2c_device_id tuner_id[] = {
1187 { "tuner", }, /* autodetect */
1188 { }
1189};
1190MODULE_DEVICE_TABLE(i2c, tuner_id);
1191
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001192static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1193 .name = "tuner",
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001194 .probe = tuner_probe,
1195 .remove = tuner_remove,
Hans Verkuil75b4c262009-04-01 03:32:22 -03001196 .command = tuner_command,
Jean Delvare21b48a72007-03-12 19:20:15 -03001197 .suspend = tuner_suspend,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001198 .resume = tuner_resume,
Jean Delvareaf294862008-05-18 20:49:40 +02001199 .id_table = tuner_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200};
1201
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202/*
1203 * Overrides for Emacs so that we follow Linus's tabbing style.
1204 * ---------------------------------------------------------------------------
1205 * Local variables:
1206 * c-basic-offset: 8
1207 * End:
1208 */