blob: 5b3eaa16afd2261f1253b702b81dad9362604f6c [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"
Michael Krufky93463892009-09-15 23:04:18 -030032#include "tda18271.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34#define UNSET (-1U)
35
Hans Verkuil9dd659d2007-11-04 11:03:36 -030036#define PREFIX t->i2c->driver->driver.name
Michael Krufky241020d2007-10-30 09:46:10 -030037
Michael Krufkya07c8772008-04-29 03:54:19 -030038/** This macro allows us to probe dynamically, avoiding static links */
Mauro Carvalho Chehabff138172008-04-29 23:02:33 -030039#ifdef CONFIG_MEDIA_ATTACH
Michael Krufkya07c8772008-04-29 03:54:19 -030040#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
41 int __r = -EINVAL; \
42 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
43 if (__a) { \
44 __r = (int) __a(ARGS); \
Andrew Mortona1355e52008-04-30 11:40:17 -030045 symbol_put(FUNCTION); \
Michael Krufkya07c8772008-04-29 03:54:19 -030046 } else { \
47 printk(KERN_ERR "TUNER: Unable to find " \
48 "symbol "#FUNCTION"()\n"); \
49 } \
Michael Krufkya07c8772008-04-29 03:54:19 -030050 __r; \
51})
52
53static void tuner_detach(struct dvb_frontend *fe)
54{
55 if (fe->ops.tuner_ops.release) {
56 fe->ops.tuner_ops.release(fe);
57 symbol_put_addr(fe->ops.tuner_ops.release);
58 }
59 if (fe->ops.analog_ops.release) {
60 fe->ops.analog_ops.release(fe);
61 symbol_put_addr(fe->ops.analog_ops.release);
62 }
63}
64#else
65#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
66 FUNCTION(ARGS); \
67})
68
69static void tuner_detach(struct dvb_frontend *fe)
70{
71 if (fe->ops.tuner_ops.release)
72 fe->ops.tuner_ops.release(fe);
73 if (fe->ops.analog_ops.release)
74 fe->ops.analog_ops.release(fe);
75}
76#endif
77
Michael Krufkyf7f427e2007-12-16 22:02:26 -030078struct tuner {
79 /* device */
80 struct dvb_frontend fe;
81 struct i2c_client *i2c;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -030082 struct v4l2_subdev sd;
Michael Krufkyf7f427e2007-12-16 22:02:26 -030083 struct list_head list;
84 unsigned int using_v4l2:1;
85
86 /* keep track of the current settings */
87 v4l2_std_id std;
88 unsigned int tv_freq;
89 unsigned int radio_freq;
90 unsigned int audmode;
91
92 unsigned int mode;
93 unsigned int mode_mask; /* Combination of allowable modes */
94
95 unsigned int type; /* chip type id */
96 unsigned int config;
Michael Krufky7271e602008-05-26 16:08:40 +020097 const char *name;
Michael Krufkyf7f427e2007-12-16 22:02:26 -030098};
99
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300100static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
101{
102 return container_of(sd, struct tuner, sd);
103}
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106/* insmod options used at init time => read/only */
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -0300107static unsigned int addr;
108static unsigned int no_autodetect;
109static unsigned int show_i2c;
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111/* insmod options used at runtime => read/write */
Michael Krufkyab166052007-12-09 02:26:48 -0300112static int tuner_debug;
113
114#define tuner_warn(fmt, arg...) do { \
115 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
116 i2c_adapter_id(t->i2c->adapter), \
117 t->i2c->addr, ##arg); \
118 } while (0)
119
120#define tuner_info(fmt, arg...) do { \
121 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
122 i2c_adapter_id(t->i2c->adapter), \
123 t->i2c->addr, ##arg); \
124 } while (0)
125
126#define tuner_err(fmt, arg...) do { \
127 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
128 i2c_adapter_id(t->i2c->adapter), \
129 t->i2c->addr, ##arg); \
130 } while (0)
131
132#define tuner_dbg(fmt, arg...) do { \
133 if (tuner_debug) \
134 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
135 i2c_adapter_id(t->i2c->adapter), \
136 t->i2c->addr, ##arg); \
137 } while (0)
138
139/* ------------------------------------------------------------------------ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700141static unsigned int tv_range[2] = { 44, 958 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static unsigned int radio_range[2] = { 65, 108 };
143
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200144static char pal[] = "--";
145static char secam[] = "--";
146static char ntsc[] = "-";
147
Hans Verkuilf9195de2006-01-11 19:01:01 -0200148
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200149module_param(addr, int, 0444);
150module_param(no_autodetect, int, 0444);
151module_param(show_i2c, int, 0444);
Hans Verkuilf9195de2006-01-11 19:01:01 -0200152module_param_named(debug,tuner_debug, int, 0644);
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200153module_param_string(pal, pal, sizeof(pal), 0644);
154module_param_string(secam, secam, sizeof(secam), 0644);
155module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700156module_param_array(tv_range, int, NULL, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157module_param_array(radio_range, int, NULL, 0644);
158
159MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
160MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
161MODULE_LICENSE("GPL");
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163/* ---------------------------------------------------------------------- */
164
Michael Krufkyc7919d52007-12-08 17:06:30 -0300165static void fe_set_params(struct dvb_frontend *fe,
166 struct analog_parameters *params)
Michael Krufkye18f9442007-08-21 01:25:48 -0300167{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300168 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
169 struct tuner *t = fe->analog_demod_priv;
Michael Krufkye18f9442007-08-21 01:25:48 -0300170
Michael Krufkye18f9442007-08-21 01:25:48 -0300171 if (NULL == fe_tuner_ops->set_analog_params) {
172 tuner_warn("Tuner frontend module has no way to set freq\n");
173 return;
174 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300175 fe_tuner_ops->set_analog_params(fe, params);
Michael Krufkye18f9442007-08-21 01:25:48 -0300176}
177
Michael Krufky4e9154b2007-10-21 19:39:50 -0300178static void fe_standby(struct dvb_frontend *fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300179{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300180 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
Michael Krufkye18f9442007-08-21 01:25:48 -0300181
182 if (fe_tuner_ops->sleep)
Michael Krufky4e9154b2007-10-21 19:39:50 -0300183 fe_tuner_ops->sleep(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300184}
185
Michael Krufky4e9154b2007-10-21 19:39:50 -0300186static int fe_has_signal(struct dvb_frontend *fe)
Michael Krufky1f5ef192007-08-31 17:38:02 -0300187{
Michael Krufky14196832007-10-14 18:11:53 -0300188 u16 strength = 0;
Michael Krufky1f5ef192007-08-31 17:38:02 -0300189
Michael Krufky4e9154b2007-10-21 19:39:50 -0300190 if (fe->ops.tuner_ops.get_rf_strength)
191 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300192
193 return strength;
194}
195
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300196static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
197{
198 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
199 struct tuner *t = fe->analog_demod_priv;
200
201 if (fe_tuner_ops->set_config)
202 return fe_tuner_ops->set_config(fe, priv_cfg);
203
204 tuner_warn("Tuner frontend module has no way to set config\n");
205
206 return 0;
207}
208
Michael Krufky4e9154b2007-10-21 19:39:50 -0300209static void tuner_status(struct dvb_frontend *fe);
Michael Krufky1dde7a42007-10-21 13:40:56 -0300210
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300211static struct analog_demod_ops tuner_analog_ops = {
Michael Krufkyc7919d52007-12-08 17:06:30 -0300212 .set_params = fe_set_params,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300213 .standby = fe_standby,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300214 .has_signal = fe_has_signal,
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300215 .set_config = fe_set_config,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300216 .tuner_status = tuner_status
217};
218
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700219/* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220static void set_tv_freq(struct i2c_client *c, unsigned int freq)
221{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300222 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300223 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Michael Krufkyc7919d52007-12-08 17:06:30 -0300225 struct analog_parameters params = {
226 .mode = t->mode,
227 .audmode = t->audmode,
228 .std = t->std
229 };
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700232 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return;
234 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300235 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700236 tuner_warn ("Tuner has no way to set tv freq\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 return;
238 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700239 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
240 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
241 freq / 16, freq % 16 * 100 / 16, tv_range[0],
242 tv_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200243 /* V4L2 spec: if the freq is not possible then the closest
244 possible value should be selected */
245 if (freq < tv_range[0] * 16)
246 freq = tv_range[0] * 16;
247 else
248 freq = tv_range[1] * 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300250 params.frequency = freq;
251
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300252 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
255static void set_radio_freq(struct i2c_client *c, unsigned int freq)
256{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300257 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300258 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Michael Krufkyc7919d52007-12-08 17:06:30 -0300260 struct analog_parameters params = {
261 .mode = t->mode,
262 .audmode = t->audmode,
263 .std = t->std
264 };
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700267 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return;
269 }
Mauro Carvalho Chehabe545d6e2008-01-05 16:37:04 -0300270 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700271 tuner_warn ("tuner has no way to set radio frequency\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return;
273 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200274 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700275 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
276 freq / 16000, freq % 16000 * 100 / 16000,
277 radio_range[0], radio_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200278 /* V4L2 spec: if the freq is not possible then the closest
279 possible value should be selected */
280 if (freq < radio_range[0] * 16000)
281 freq = radio_range[0] * 16000;
282 else
283 freq = radio_range[1] * 16000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300285 params.frequency = freq;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700286
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300287 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
290static void set_freq(struct i2c_client *c, unsigned long freq)
291{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300292 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 switch (t->mode) {
295 case V4L2_TUNER_RADIO:
296 tuner_dbg("radio freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700297 freq / 16000, freq % 16000 * 100 / 16000);
298 set_radio_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200299 t->radio_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 break;
301 case V4L2_TUNER_ANALOG_TV:
302 case V4L2_TUNER_DIGITAL_TV:
303 tuner_dbg("tv freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700304 freq / 16, freq % 16 * 100 / 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 set_tv_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200306 t->tv_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 break;
Mauro Carvalho Chehab6cb45872007-10-02 11:57:03 -0300308 default:
309 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
Steven Toth27c685a2008-01-05 16:50:14 -0300313static struct xc5000_config xc5000_cfg;
314
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700315static void set_type(struct i2c_client *c, unsigned int type,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300316 unsigned int new_mode_mask, unsigned int new_config,
Michael Krufkyd7cba042008-09-12 13:31:45 -0300317 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300319 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkye18f9442007-08-21 01:25:48 -0300320 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300321 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700322 unsigned char buffer[4];
Michael Krufkyd6eef492009-10-24 16:42:16 -0300323 int tune_now = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700325 if (type == UNSET || type == TUNER_ABSENT) {
326 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return;
328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 t->type = type;
Michael Krufkye7ddcd92009-03-28 15:35:26 -0300331 /* prevent invalid config values */
Roel Kluinf14a2972009-10-23 07:59:42 -0300332 t->config = new_config < 256 ? new_config : 0;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300333 if (tuner_callback != NULL) {
334 tuner_dbg("defining GPIO callback\n");
Michael Krufkyd7cba042008-09-12 13:31:45 -0300335 t->fe.callback = tuner_callback;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300336 }
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300337
Mauro Carvalho Chehab48aa3362007-10-29 11:33:18 -0300338 if (t->mode == T_UNINITIALIZED) {
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300339 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
340
341 return;
342 }
343
Michael Krufkyb2083192007-05-29 22:54:06 -0300344 /* discard private data, in case set_type() was previously called */
Michael Krufkya07c8772008-04-29 03:54:19 -0300345 tuner_detach(&t->fe);
346 t->fe.analog_demod_priv = NULL;
Michael Krufkybe2b85a2007-06-04 14:40:27 -0300347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 switch (t->type) {
349 case TUNER_MT2032:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300350 if (!dvb_attach(microtune_attach,
351 &t->fe, t->i2c->adapter, t->i2c->addr))
352 goto attach_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 break;
354 case TUNER_PHILIPS_TDA8290:
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300355 {
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300356 struct tda829x_config cfg = {
357 .lna_cfg = t->config,
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300358 };
359 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
360 t->i2c->addr, &cfg))
361 goto attach_failed;
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300362 break;
363 }
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700364 case TUNER_TEA5767:
Michael Krufkya07c8772008-04-29 03:54:19 -0300365 if (!dvb_attach(tea5767_attach, &t->fe,
366 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300367 goto attach_failed;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700368 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700369 break;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300370 case TUNER_TEA5761:
Michael Krufkya07c8772008-04-29 03:54:19 -0300371 if (!dvb_attach(tea5761_attach, &t->fe,
372 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300373 goto attach_failed;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300374 t->mode_mask = T_RADIO;
375 break;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700376 case TUNER_PHILIPS_FMD1216ME_MK3:
377 buffer[0] = 0x0b;
378 buffer[1] = 0xdc;
379 buffer[2] = 0x9c;
380 buffer[3] = 0x60;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700381 i2c_master_send(c, buffer, 4);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700382 mdelay(1);
383 buffer[2] = 0x86;
384 buffer[3] = 0x54;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700385 i2c_master_send(c, buffer, 4);
Michael Krufkya07c8772008-04-29 03:54:19 -0300386 if (!dvb_attach(simple_tuner_attach, &t->fe,
387 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300388 goto attach_failed;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700389 break;
Hartmut Hackmann93df3412005-11-08 21:36:31 -0800390 case TUNER_PHILIPS_TD1316:
391 buffer[0] = 0x0b;
392 buffer[1] = 0xdc;
393 buffer[2] = 0x86;
394 buffer[3] = 0xa4;
Michael Krufkya07c8772008-04-29 03:54:19 -0300395 i2c_master_send(c, buffer, 4);
396 if (!dvb_attach(simple_tuner_attach, &t->fe,
397 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300398 goto attach_failed;
Markus Rechbergerac272ed2006-01-23 17:11:09 -0200399 break;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300400 case TUNER_XC2028:
401 {
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300402 struct xc2028_config cfg = {
403 .i2c_adap = t->i2c->adapter,
404 .i2c_addr = t->i2c->addr,
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300405 };
Michael Krufkya07c8772008-04-29 03:54:19 -0300406 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300407 goto attach_failed;
Michael Krufkyd6eef492009-10-24 16:42:16 -0300408 tune_now = 0;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300409 break;
410 }
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300411 case TUNER_TDA9887:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300412 if (!dvb_attach(tda9887_attach,
413 &t->fe, t->i2c->adapter, t->i2c->addr))
414 goto attach_failed;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300415 break;
Steven Toth27c685a2008-01-05 16:50:14 -0300416 case TUNER_XC5000:
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300417 {
Steven Toth27c685a2008-01-05 16:50:14 -0300418 xc5000_cfg.i2c_address = t->i2c->addr;
Devin Heitmuellerea227862009-03-11 02:58:53 -0300419 /* if_khz will be set when the digital dvb_attach() occurs */
420 xc5000_cfg.if_khz = 0;
Michael Krufkya07c8772008-04-29 03:54:19 -0300421 if (!dvb_attach(xc5000_attach,
Michael Krufky30650962008-09-06 14:56:58 -0300422 &t->fe, t->i2c->adapter, &xc5000_cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300423 goto attach_failed;
Michael Krufkyd6eef492009-10-24 16:42:16 -0300424 tune_now = 0;
Steven Toth27c685a2008-01-05 16:50:14 -0300425 break;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300426 }
Michael Krufky93463892009-09-15 23:04:18 -0300427 case TUNER_NXP_TDA18271:
428 {
429 struct tda18271_config cfg = {
430 .config = t->config,
431 };
432
433 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
434 t->i2c->adapter, &cfg))
435 goto attach_failed;
Michael Krufkyd6eef492009-10-24 16:42:16 -0300436 tune_now = 0;
Michael Krufky93463892009-09-15 23:04:18 -0300437 break;
438 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 default:
Michael Krufkya07c8772008-04-29 03:54:19 -0300440 if (!dvb_attach(simple_tuner_attach, &t->fe,
441 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300442 goto attach_failed;
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 break;
445 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700446
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300447 if ((NULL == analog_ops->set_params) &&
Michael Krufky1dde7a42007-10-21 13:40:56 -0300448 (fe_tuner_ops->set_analog_params)) {
Michael Krufkya07c8772008-04-29 03:54:19 -0300449
Michael Krufky7271e602008-05-26 16:08:40 +0200450 t->name = fe_tuner_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300451
Michael Krufky4e9154b2007-10-21 19:39:50 -0300452 t->fe.analog_demod_priv = t;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300453 memcpy(analog_ops, &tuner_analog_ops,
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300454 sizeof(struct analog_demod_ops));
Michael Krufkya07c8772008-04-29 03:54:19 -0300455
Michael Krufkya55db8c2007-12-09 13:52:51 -0300456 } else {
Michael Krufky7271e602008-05-26 16:08:40 +0200457 t->name = analog_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300458 }
459
Michael Krufky7271e602008-05-26 16:08:40 +0200460 tuner_dbg("type set to %s\n", t->name);
Michael Krufkye18f9442007-08-21 01:25:48 -0300461
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700462 if (t->mode_mask == T_UNINITIALIZED)
463 t->mode_mask = new_mode_mask;
464
Michael Krufkyd6eef492009-10-24 16:42:16 -0300465 /* Some tuners require more initialization setup before use,
466 such as firmware download or device calibration.
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300467 trying to set a frequency here will just fail
468 FIXME: better to move set_freq to the tuner code. This is needed
469 on analog tuners for PLL to properly work
470 */
Michael Krufkyd6eef492009-10-24 16:42:16 -0300471 if (tune_now)
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300472 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
473 t->radio_freq : t->tv_freq);
474
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700475 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100476 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700477 t->mode_mask);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300478 return;
479
480attach_failed:
481 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
482 t->type = TUNER_ABSENT;
483 t->mode_mask = T_UNINITIALIZED;
484
485 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486}
487
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700488/*
489 * This function apply tuner config to tuner specified
490 * by tun_setup structure. I addr is unset, then admin status
491 * and tun addr status is more precise then current status,
492 * it's applied. Otherwise status and type are applied only to
493 * tuner with exactly the same addr.
494*/
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700495
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700496static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700497{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300498 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700499
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300500 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
501 (t->mode_mask & tun_setup->mode_mask))) ||
502 (tun_setup->addr == c->addr)) {
503 set_type(c, tun_setup->type, tun_setup->mode_mask,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300504 tun_setup->config, tun_setup->tuner_callback);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300505 } else
506 tuner_dbg("set addr discarded for type %i, mask %x. "
507 "Asked to change tuner at addr 0x%02x, with mask %x\n",
508 t->type, t->mode_mask,
509 tun_setup->addr, tun_setup->mode_mask);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700510}
511
512static inline int check_mode(struct tuner *t, char *cmd)
513{
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700514 if ((1 << t->mode & t->mode_mask) == 0) {
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300515 return -EINVAL;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700516 }
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700517
518 switch (t->mode) {
519 case V4L2_TUNER_RADIO:
520 tuner_dbg("Cmd %s accepted for radio\n", cmd);
521 break;
522 case V4L2_TUNER_ANALOG_TV:
523 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
524 break;
525 case V4L2_TUNER_DIGITAL_TV:
526 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
527 break;
528 }
529 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700530}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700531
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700532/* get more precise norm info from insmod option */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533static int tuner_fixup_std(struct tuner *t)
534{
535 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 switch (pal[0]) {
Hans Verkuile71ced12006-12-11 15:51:43 -0300537 case '6':
538 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
539 t->std = V4L2_STD_PAL_60;
540 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 case 'b':
542 case 'B':
543 case 'g':
544 case 'G':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700545 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 t->std = V4L2_STD_PAL_BG;
547 break;
548 case 'i':
549 case 'I':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700550 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 t->std = V4L2_STD_PAL_I;
552 break;
553 case 'd':
554 case 'D':
555 case 'k':
556 case 'K':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700557 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 t->std = V4L2_STD_PAL_DK;
559 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700560 case 'M':
561 case 'm':
562 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
563 t->std = V4L2_STD_PAL_M;
564 break;
565 case 'N':
566 case 'n':
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200567 if (pal[1] == 'c' || pal[1] == 'C') {
568 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
569 t->std = V4L2_STD_PAL_Nc;
570 } else {
571 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
572 t->std = V4L2_STD_PAL_N;
573 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700574 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700575 case '-':
576 /* default parameter, do nothing */
577 break;
578 default:
579 tuner_warn ("pal= argument not recognised\n");
580 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
582 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700583 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
584 switch (secam[0]) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200585 case 'b':
586 case 'B':
587 case 'g':
588 case 'G':
589 case 'h':
590 case 'H':
591 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
592 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
593 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700594 case 'd':
595 case 'D':
596 case 'k':
597 case 'K':
598 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
599 t->std = V4L2_STD_SECAM_DK;
600 break;
601 case 'l':
602 case 'L':
Mauro Carvalho Chehab800d3c62005-11-13 16:07:48 -0800603 if ((secam[1]=='C')||(secam[1]=='c')) {
604 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
605 t->std = V4L2_STD_SECAM_LC;
606 } else {
607 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
608 t->std = V4L2_STD_SECAM_L;
609 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700610 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700611 case '-':
612 /* default parameter, do nothing */
613 break;
614 default:
615 tuner_warn ("secam= argument not recognised\n");
616 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700617 }
618 }
619
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200620 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
621 switch (ntsc[0]) {
622 case 'm':
623 case 'M':
624 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
625 t->std = V4L2_STD_NTSC_M;
626 break;
627 case 'j':
628 case 'J':
629 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
630 t->std = V4L2_STD_NTSC_M_JP;
631 break;
Hans Verkuild97a11e2006-02-07 06:48:40 -0200632 case 'k':
633 case 'K':
634 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
635 t->std = V4L2_STD_NTSC_M_KR;
636 break;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200637 case '-':
638 /* default parameter, do nothing */
639 break;
640 default:
641 tuner_info("ntsc= argument not recognised\n");
642 break;
643 }
644 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 return 0;
646}
647
Michael Krufky4e9154b2007-10-21 19:39:50 -0300648static void tuner_status(struct dvb_frontend *fe)
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200649{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300650 struct tuner *t = fe->analog_demod_priv;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200651 unsigned long freq, freq_fraction;
Michael Krufkya07c8772008-04-29 03:54:19 -0300652 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
653 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200654 const char *p;
655
656 switch (t->mode) {
657 case V4L2_TUNER_RADIO: p = "radio"; break;
658 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
659 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
660 default: p = "undefined"; break;
661 }
662 if (t->mode == V4L2_TUNER_RADIO) {
Hans Verkuil27487d42006-01-15 15:04:52 -0200663 freq = t->radio_freq / 16000;
664 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200665 } else {
Hans Verkuil27487d42006-01-15 15:04:52 -0200666 freq = t->tv_freq / 16;
667 freq_fraction = (t->tv_freq % 16) * 100 / 16;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200668 }
669 tuner_info("Tuner mode: %s\n", p);
670 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
Mauro Carvalho Chehab4ae5c2e2006-03-25 15:53:38 -0300671 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200672 if (t->mode != V4L2_TUNER_RADIO)
673 return;
Michael Krufkye18f9442007-08-21 01:25:48 -0300674 if (fe_tuner_ops->get_status) {
675 u32 tuner_status;
676
677 fe_tuner_ops->get_status(&t->fe, &tuner_status);
678 if (tuner_status & TUNER_STATUS_LOCKED)
679 tuner_info("Tuner is locked.\n");
680 if (tuner_status & TUNER_STATUS_STEREO)
681 tuner_info("Stereo: yes\n");
682 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300683 if (analog_ops->has_signal)
684 tuner_info("Signal strength: %d\n",
685 analog_ops->has_signal(fe));
686 if (analog_ops->is_stereo)
687 tuner_info("Stereo: %s\n",
688 analog_ops->is_stereo(fe) ? "yes" : "no");
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200689}
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691/* ---------------------------------------------------------------------- */
692
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700693/*
694 * Switch tuner to other mode. If tuner support both tv and radio,
695 * set another frequency to some value (This is needed for some pal
696 * tuners to avoid locking). Otherwise, just put second tuner in
697 * standby mode.
698 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700700static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
701{
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300702 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Michael Krufky1dde7a42007-10-21 13:40:56 -0300703
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800704 if (mode == t->mode)
705 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700706
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800707 t->mode = mode;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700708
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300709 if (check_mode(t, cmd) == -EINVAL) {
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -0300710 tuner_dbg("Tuner doesn't support this mode. "
711 "Putting tuner to sleep\n");
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800712 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300713 if (analog_ops->standby)
714 analog_ops->standby(&t->fe);
Marcin Slusarz4d3437d2008-05-26 14:03:02 -0300715 return -EINVAL;
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800716 }
717 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700718}
719
720#define switch_v4l2() if (!t->using_v4l2) \
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800721 tuner_dbg("switching to v4l2\n"); \
722 t->using_v4l2 = 1;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700723
724static inline int check_v4l2(struct tuner *t)
725{
Hans Verkuil3bbe5a82006-04-01 15:27:52 -0300726 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
727 TV, v4l1 for radio), until that is fixed this code is disabled.
728 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
729 first. */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700730 return 0;
731}
732
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300733static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300735 struct tuner *t = to_tuner(sd);
736 struct i2c_client *client = v4l2_get_subdevdata(sd);
737
738 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
739 type->type,
740 type->addr,
741 type->mode_mask,
742 type->config);
743
744 set_addr(client, type);
745 return 0;
746}
747
748static int tuner_s_radio(struct v4l2_subdev *sd)
749{
750 struct tuner *t = to_tuner(sd);
751 struct i2c_client *client = v4l2_get_subdevdata(sd);
752
Hans Verkuilbccfa442009-03-30 06:55:27 -0300753 if (set_mode(client, t, V4L2_TUNER_RADIO, "s_radio") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300754 return 0;
755 if (t->radio_freq)
756 set_freq(client, t->radio_freq);
757 return 0;
758}
759
Laurent Pinchart622b8282009-10-05 10:48:17 -0300760static int tuner_s_power(struct v4l2_subdev *sd, int on)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300761{
762 struct tuner *t = to_tuner(sd);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300763 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Laurent Pinchart622b8282009-10-05 10:48:17 -0300765 if (on)
766 return 0;
767
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -0300768 tuner_dbg("Putting tuner to sleep\n");
769
Laurent Pinchart622b8282009-10-05 10:48:17 -0300770 if (check_mode(t, "s_power") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300771 return 0;
772 t->mode = T_STANDBY;
773 if (analog_ops->standby)
774 analog_ops->standby(&t->fe);
775 return 0;
776}
777
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300778static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
779{
780 struct tuner *t = to_tuner(sd);
781 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300782
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300783 if (t->type != cfg->tuner)
784 return 0;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300785
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300786 if (analog_ops->set_config) {
787 analog_ops->set_config(&t->fe, cfg->priv);
788 return 0;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300789 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300791 tuner_dbg("Tuner frontend module has no way to set config\n");
792 return 0;
793}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700794
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300795/* --- v4l ioctls --- */
796/* take care: bttv does userspace copying, we'll get a
797 kernel pointer here... */
798static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
799{
800 struct tuner *t = to_tuner(sd);
801 struct i2c_client *client = v4l2_get_subdevdata(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Hans Verkuilbccfa442009-03-30 06:55:27 -0300803 if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "s_std") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300804 return 0;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700805
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300806 switch_v4l2();
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700807
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300808 t->std = std;
809 tuner_fixup_std(t);
810 if (t->tv_freq)
811 set_freq(client, t->tv_freq);
812 return 0;
813}
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700814
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300815static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
816{
817 struct tuner *t = to_tuner(sd);
818 struct i2c_client *client = v4l2_get_subdevdata(sd);
Michael Krufkye18f9442007-08-21 01:25:48 -0300819
Hans Verkuilbccfa442009-03-30 06:55:27 -0300820 if (set_mode(client, t, f->type, "s_frequency") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300821 return 0;
822 switch_v4l2();
823 set_freq(client, f->frequency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 return 0;
826}
827
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300828static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
829{
830 struct tuner *t = to_tuner(sd);
831 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
832
Hans Verkuilbccfa442009-03-30 06:55:27 -0300833 if (check_mode(t, "g_frequency") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300834 return 0;
835 switch_v4l2();
836 f->type = t->mode;
837 if (fe_tuner_ops->get_frequency) {
838 u32 abs_freq;
839
840 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
841 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
Julia Lawall75b697f2009-08-01 16:48:41 -0300842 DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
843 DIV_ROUND_CLOSEST(abs_freq, 62500);
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300844 return 0;
845 }
846 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
847 t->radio_freq : t->tv_freq;
848 return 0;
849}
850
851static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
852{
853 struct tuner *t = to_tuner(sd);
854 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
855 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
856
Hans Verkuilbccfa442009-03-30 06:55:27 -0300857 if (check_mode(t, "g_tuner") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300858 return 0;
859 switch_v4l2();
860
861 vt->type = t->mode;
862 if (analog_ops->get_afc)
863 vt->afc = analog_ops->get_afc(&t->fe);
864 if (t->mode == V4L2_TUNER_ANALOG_TV)
865 vt->capability |= V4L2_TUNER_CAP_NORM;
866 if (t->mode != V4L2_TUNER_RADIO) {
867 vt->rangelow = tv_range[0] * 16;
868 vt->rangehigh = tv_range[1] * 16;
869 return 0;
870 }
871
872 /* radio mode */
873 vt->rxsubchans =
874 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
875 if (fe_tuner_ops->get_status) {
876 u32 tuner_status;
877
878 fe_tuner_ops->get_status(&t->fe, &tuner_status);
879 vt->rxsubchans =
880 (tuner_status & TUNER_STATUS_STEREO) ?
881 V4L2_TUNER_SUB_STEREO :
882 V4L2_TUNER_SUB_MONO;
883 } else {
884 if (analog_ops->is_stereo) {
885 vt->rxsubchans =
886 analog_ops->is_stereo(&t->fe) ?
887 V4L2_TUNER_SUB_STEREO :
888 V4L2_TUNER_SUB_MONO;
889 }
890 }
891 if (analog_ops->has_signal)
892 vt->signal = analog_ops->has_signal(&t->fe);
893 vt->capability |=
894 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
895 vt->audmode = t->audmode;
896 vt->rangelow = radio_range[0] * 16000;
897 vt->rangehigh = radio_range[1] * 16000;
898 return 0;
899}
900
901static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
902{
903 struct tuner *t = to_tuner(sd);
904 struct i2c_client *client = v4l2_get_subdevdata(sd);
905
Hans Verkuilbccfa442009-03-30 06:55:27 -0300906 if (check_mode(t, "s_tuner") == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300907 return 0;
908
909 switch_v4l2();
910
911 /* do nothing unless we're a radio tuner */
912 if (t->mode != V4L2_TUNER_RADIO)
913 return 0;
914 t->audmode = vt->audmode;
915 set_radio_freq(client, t->radio_freq);
916 return 0;
917}
918
919static int tuner_log_status(struct v4l2_subdev *sd)
920{
921 struct tuner *t = to_tuner(sd);
922 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
923
924 if (analog_ops->tuner_status)
925 analog_ops->tuner_status(&t->fe);
926 return 0;
927}
928
Jean Delvare21b48a72007-03-12 19:20:15 -0300929static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300931 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300933 tuner_dbg("suspend\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 /* FIXME: power down ??? */
935 return 0;
936}
937
Jean Delvare21b48a72007-03-12 19:20:15 -0300938static int tuner_resume(struct i2c_client *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300940 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300942 tuner_dbg("resume\n");
Hans Verkuil27487d42006-01-15 15:04:52 -0200943 if (V4L2_TUNER_RADIO == t->mode) {
944 if (t->radio_freq)
945 set_freq(c, t->radio_freq);
946 } else {
947 if (t->tv_freq)
948 set_freq(c, t->tv_freq);
949 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 return 0;
951}
952
Hans Verkuil75b4c262009-04-01 03:32:22 -0300953static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
954{
955 struct v4l2_subdev *sd = i2c_get_clientdata(client);
956
957 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
958 to handle it here.
959 There must be a better way of doing this... */
960 switch (cmd) {
961 case TUNER_SET_CONFIG:
962 return tuner_s_config(sd, arg);
963 }
964 return -ENOIOCTLCMD;
965}
966
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300967/* ----------------------------------------------------------------------- */
968
969static const struct v4l2_subdev_core_ops tuner_core_ops = {
970 .log_status = tuner_log_status,
Hans Verkuilf41737e2009-04-01 03:52:39 -0300971 .s_std = tuner_s_std,
Laurent Pinchart622b8282009-10-05 10:48:17 -0300972 .s_power = tuner_s_power,
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300973};
974
975static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300976 .s_radio = tuner_s_radio,
977 .g_tuner = tuner_g_tuner,
978 .s_tuner = tuner_s_tuner,
979 .s_frequency = tuner_s_frequency,
980 .g_frequency = tuner_g_frequency,
981 .s_type_addr = tuner_s_type_addr,
982 .s_config = tuner_s_config,
983};
984
985static const struct v4l2_subdev_ops tuner_ops = {
986 .core = &tuner_core_ops,
987 .tuner = &tuner_tuner_ops,
988};
989
Hans Verkuil92de1f12007-11-04 10:53:09 -0300990/* ---------------------------------------------------------------------- */
991
Adrian Bunkc52c4d02008-01-28 22:11:15 -0300992static LIST_HEAD(tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -0300993
994/* Search for existing radio and/or TV tuners on the given I2C adapter.
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300995 Note that when this function is called from tuner_probe you can be
Hans Verkuil92de1f12007-11-04 10:53:09 -0300996 certain no other devices will be added/deleted at the same time, I2C
997 core protects against that. */
998static void tuner_lookup(struct i2c_adapter *adap,
999 struct tuner **radio, struct tuner **tv)
1000{
1001 struct tuner *pos;
1002
1003 *radio = NULL;
1004 *tv = NULL;
1005
1006 list_for_each_entry(pos, &tuner_list, list) {
1007 int mode_mask;
1008
1009 if (pos->i2c->adapter != adap ||
Hans Verkuil0c846742009-03-29 19:40:01 -03001010 strcmp(pos->i2c->driver->driver.name, "tuner"))
Hans Verkuil92de1f12007-11-04 10:53:09 -03001011 continue;
1012
1013 mode_mask = pos->mode_mask & ~T_STANDBY;
1014 if (*radio == NULL && mode_mask == T_RADIO)
1015 *radio = pos;
1016 /* Note: currently TDA9887 is the only demod-only
1017 device. If other devices appear then we need to
1018 make this test more general. */
1019 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1020 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1021 *tv = pos;
1022 }
1023}
1024
1025/* During client attach, set_type is called by adapter's attach_inform callback.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001026 set_type must then be completed by tuner_probe.
Hans Verkuil92de1f12007-11-04 10:53:09 -03001027 */
Jean Delvared2653e92008-04-29 23:11:39 +02001028static int tuner_probe(struct i2c_client *client,
1029 const struct i2c_device_id *id)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001030{
Hans Verkuil92de1f12007-11-04 10:53:09 -03001031 struct tuner *t;
1032 struct tuner *radio;
1033 struct tuner *tv;
1034
Hans Verkuil92de1f12007-11-04 10:53:09 -03001035 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001036 if (NULL == t)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001037 return -ENOMEM;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001038 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001039 t->i2c = client;
Michael Krufky7271e602008-05-26 16:08:40 +02001040 t->name = "(tuner unset)";
Hans Verkuil92de1f12007-11-04 10:53:09 -03001041 t->type = UNSET;
1042 t->audmode = V4L2_TUNER_MODE_STEREO;
1043 t->mode_mask = T_UNINITIALIZED;
1044
1045 if (show_i2c) {
1046 unsigned char buffer[16];
1047 int i, rc;
1048
1049 memset(buffer, 0, sizeof(buffer));
1050 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1051 tuner_info("I2C RECV = ");
1052 for (i = 0; i < rc; i++)
1053 printk(KERN_CONT "%02x ", buffer[i]);
1054 printk("\n");
1055 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001056 /* HACK: This test was added to avoid tuner to probe tda9840 and
Hans Verkuil92de1f12007-11-04 10:53:09 -03001057 tea6415c on the MXB card */
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001058 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1059 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001060 return -ENODEV;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001061 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001062
1063 /* autodetection code based on the i2c addr */
1064 if (!no_autodetect) {
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001065 switch (client->addr) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001066 case 0x10:
Michael Krufkya07c8772008-04-29 03:54:19 -03001067 if (tuner_symbol_probe(tea5761_autodetection,
1068 t->i2c->adapter,
1069 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001070 t->type = TUNER_TEA5761;
1071 t->mode_mask = T_RADIO;
1072 t->mode = T_STANDBY;
1073 /* Sets freq to FM range */
1074 t->radio_freq = 87.5 * 16000;
1075 tuner_lookup(t->i2c->adapter, &radio, &tv);
1076 if (tv)
1077 tv->mode_mask &= ~T_RADIO;
1078
1079 goto register_client;
1080 }
Mauro Carvalho Chehab867e8352008-04-23 17:27:27 -03001081 return -ENODEV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001082 case 0x42:
1083 case 0x43:
1084 case 0x4a:
1085 case 0x4b:
1086 /* If chip is not tda8290, don't register.
1087 since it can be tda9887*/
Michael Krufkya07c8772008-04-29 03:54:19 -03001088 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001089 t->i2c->addr) >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001090 tuner_dbg("tda829x detected\n");
1091 } else {
1092 /* Default is being tda9887 */
1093 t->type = TUNER_TDA9887;
1094 t->mode_mask = T_RADIO | T_ANALOG_TV |
1095 T_DIGITAL_TV;
1096 t->mode = T_STANDBY;
1097 goto register_client;
1098 }
1099 break;
1100 case 0x60:
Michael Krufkya07c8772008-04-29 03:54:19 -03001101 if (tuner_symbol_probe(tea5767_autodetection,
1102 t->i2c->adapter, t->i2c->addr)
Mauro Carvalho Chehabb538d282008-04-30 15:45:00 -03001103 >= 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001104 t->type = TUNER_TEA5767;
1105 t->mode_mask = T_RADIO;
1106 t->mode = T_STANDBY;
1107 /* Sets freq to FM range */
1108 t->radio_freq = 87.5 * 16000;
1109 tuner_lookup(t->i2c->adapter, &radio, &tv);
1110 if (tv)
1111 tv->mode_mask &= ~T_RADIO;
1112
1113 goto register_client;
1114 }
1115 break;
1116 }
1117 }
1118
1119 /* Initializes only the first TV tuner on this adapter. Why only the
1120 first? Because there are some devices (notably the ones with TI
1121 tuners) that have more than one i2c address for the *same* device.
1122 Experience shows that, except for just one case, the first
1123 address is the right one. The exception is a Russian tuner
1124 (ACORP_Y878F). So, the desired behavior is just to enable the
1125 first found TV tuner. */
1126 tuner_lookup(t->i2c->adapter, &radio, &tv);
1127 if (tv == NULL) {
1128 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1129 if (radio == NULL)
1130 t->mode_mask |= T_RADIO;
1131 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1132 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1133 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1134 }
1135
1136 /* Should be just before return */
1137register_client:
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001138 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1139 client->adapter->name);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001140
1141 /* Sets a default mode */
1142 if (t->mode_mask & T_ANALOG_TV) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001143 t->mode = V4L2_TUNER_ANALOG_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001144 } else if (t->mode_mask & T_RADIO) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001145 t->mode = V4L2_TUNER_RADIO;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001146 } else {
Michael Krufky864a6b82007-12-09 17:21:54 -03001147 t->mode = V4L2_TUNER_DIGITAL_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001148 }
Michael Krufkyd7cba042008-09-12 13:31:45 -03001149 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001150 list_add_tail(&t->list, &tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001151 return 0;
1152}
1153
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001154static int tuner_remove(struct i2c_client *client)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001155{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001156 struct tuner *t = to_tuner(i2c_get_clientdata(client));
Hans Verkuil92de1f12007-11-04 10:53:09 -03001157
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001158 v4l2_device_unregister_subdev(&t->sd);
Michael Krufkya07c8772008-04-29 03:54:19 -03001159 tuner_detach(&t->fe);
1160 t->fe.analog_demod_priv = NULL;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001161
1162 list_del(&t->list);
1163 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001164 return 0;
1165}
1166
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167/* ----------------------------------------------------------------------- */
1168
Jean Delvareaf294862008-05-18 20:49:40 +02001169/* This driver supports many devices and the idea is to let the driver
1170 detect which device is present. So rather than listing all supported
1171 devices here, we pretend to support a single, fake device type. */
1172static const struct i2c_device_id tuner_id[] = {
1173 { "tuner", }, /* autodetect */
1174 { }
1175};
1176MODULE_DEVICE_TABLE(i2c, tuner_id);
1177
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001178static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1179 .name = "tuner",
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001180 .probe = tuner_probe,
1181 .remove = tuner_remove,
Hans Verkuil75b4c262009-04-01 03:32:22 -03001182 .command = tuner_command,
Jean Delvare21b48a72007-03-12 19:20:15 -03001183 .suspend = tuner_suspend,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001184 .resume = tuner_resume,
Jean Delvareaf294862008-05-18 20:49:40 +02001185 .id_table = tuner_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186};
1187
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188/*
1189 * Overrides for Emacs so that we follow Linus's tabbing style.
1190 * ---------------------------------------------------------------------------
1191 * Local variables:
1192 * c-basic-offset: 8
1193 * End:
1194 */