blob: 0628a0ae9da51298d5b2f51d8b80603572352e45 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * i2c tv tuner chip device driver
3 * core core, i.e. kernel interfaces, registering and so on
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -02004 *
5 * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
6 *
7 * Copyright(c) 2005-2011 by Mauro Carvalho Chehab
8 * - Added support for a separate Radio tuner
9 * - Major rework and cleanups at the code
10 *
11 * This driver supports many devices and the idea is to let the driver
12 * detect which device is present. So rather than listing all supported
13 * devices here, we pretend to support a single, fake device type that will
14 * handle both radio and analog TV tuning.
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
17#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/string.h>
20#include <linux/timer.h>
21#include <linux/delay.h>
22#include <linux/errno.h>
23#include <linux/slab.h>
24#include <linux/poll.h>
25#include <linux/i2c.h>
26#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/init.h>
Hans Verkuil75b4c262009-04-01 03:32:22 -030028#include <linux/videodev2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <media/tuner.h>
Michael Krufky4adad282007-08-27 21:59:08 -030030#include <media/tuner-types.h>
Hans Verkuile8a4a9e2008-11-24 18:21:40 -030031#include <media/v4l2-device.h>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030032#include <media/v4l2-ioctl.h>
Michael Krufky96c0b7c2007-08-27 21:23:08 -030033#include "mt20xx.h"
Michael Krufky910bb3e2007-08-27 21:22:20 -030034#include "tda8290.h"
Michael Krufky7ab10bf2007-08-27 21:23:40 -030035#include "tea5761.h"
Michael Krufky8d0936e2007-08-27 21:24:27 -030036#include "tea5767.h"
Mauro Carvalho Chehab215b95b2007-10-23 15:24:06 -030037#include "tuner-xc2028.h"
Michael Krufky4adad282007-08-27 21:59:08 -030038#include "tuner-simple.h"
Michael Krufky31c95842007-10-21 20:48:48 -030039#include "tda9887.h"
Steven Toth27c685a2008-01-05 16:50:14 -030040#include "xc5000.h"
Michael Krufky93463892009-09-15 23:04:18 -030041#include "tda18271.h"
Davide Ferri8d009a02009-06-23 22:34:06 -030042#include "xc4000.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44#define UNSET (-1U)
45
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -030046#define PREFIX (t->i2c->driver->driver.name)
Michael Krufky241020d2007-10-30 09:46:10 -030047
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -030048/*
49 * Driver modprobe parameters
50 */
51
52/* insmod options used at init time => read/only */
53static unsigned int addr;
54static unsigned int no_autodetect;
55static unsigned int show_i2c;
56
57module_param(addr, int, 0444);
58module_param(no_autodetect, int, 0444);
59module_param(show_i2c, int, 0444);
60
61/* insmod options used at runtime => read/write */
62static int tuner_debug;
63static unsigned int tv_range[2] = { 44, 958 };
64static unsigned int radio_range[2] = { 65, 108 };
65static char pal[] = "--";
66static char secam[] = "--";
67static char ntsc[] = "-";
68
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -030069module_param_named(debug, tuner_debug, int, 0644);
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -030070module_param_array(tv_range, int, NULL, 0644);
71module_param_array(radio_range, int, NULL, 0644);
72module_param_string(pal, pal, sizeof(pal), 0644);
73module_param_string(secam, secam, sizeof(secam), 0644);
74module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
75
76/*
77 * Static vars
78 */
79
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -030080static LIST_HEAD(tuner_list);
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -020081static const struct v4l2_subdev_ops tuner_ops;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -030082
83/*
84 * Debug macros
85 */
86
87#define tuner_warn(fmt, arg...) do { \
88 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
89 i2c_adapter_id(t->i2c->adapter), \
90 t->i2c->addr, ##arg); \
91 } while (0)
92
93#define tuner_info(fmt, arg...) do { \
94 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
95 i2c_adapter_id(t->i2c->adapter), \
96 t->i2c->addr, ##arg); \
97 } while (0)
98
99#define tuner_err(fmt, arg...) do { \
100 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
101 i2c_adapter_id(t->i2c->adapter), \
102 t->i2c->addr, ##arg); \
103 } while (0)
104
105#define tuner_dbg(fmt, arg...) do { \
106 if (tuner_debug) \
107 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
108 i2c_adapter_id(t->i2c->adapter), \
109 t->i2c->addr, ##arg); \
110 } while (0)
111
112/*
113 * Internal struct used inside the driver
114 */
115
116struct tuner {
117 /* device */
118 struct dvb_frontend fe;
119 struct i2c_client *i2c;
120 struct v4l2_subdev sd;
121 struct list_head list;
122
123 /* keep track of the current settings */
124 v4l2_std_id std;
125 unsigned int tv_freq;
126 unsigned int radio_freq;
127 unsigned int audmode;
128
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300129 enum v4l2_tuner_type mode;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300130 unsigned int mode_mask; /* Combination of allowable modes */
131
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300132 bool standby; /* Standby mode */
133
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300134 unsigned int type; /* chip type id */
135 unsigned int config;
136 const char *name;
137};
138
139/*
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200140 * Function prototypes
141 */
142
143static void set_tv_freq(struct i2c_client *c, unsigned int freq);
144static void set_radio_freq(struct i2c_client *c, unsigned int freq);
145
146/*
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300147 * tuner attach/detach logic
148 */
149
Mauro Carvalho Chehab0ae79d92011-02-15 01:10:20 -0300150/* This macro allows us to probe dynamically, avoiding static links */
Mauro Carvalho Chehabff138172008-04-29 23:02:33 -0300151#ifdef CONFIG_MEDIA_ATTACH
Michael Krufkya07c8772008-04-29 03:54:19 -0300152#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
153 int __r = -EINVAL; \
154 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
155 if (__a) { \
156 __r = (int) __a(ARGS); \
Andrew Mortona1355e52008-04-30 11:40:17 -0300157 symbol_put(FUNCTION); \
Michael Krufkya07c8772008-04-29 03:54:19 -0300158 } else { \
159 printk(KERN_ERR "TUNER: Unable to find " \
160 "symbol "#FUNCTION"()\n"); \
161 } \
Michael Krufkya07c8772008-04-29 03:54:19 -0300162 __r; \
163})
164
165static void tuner_detach(struct dvb_frontend *fe)
166{
167 if (fe->ops.tuner_ops.release) {
168 fe->ops.tuner_ops.release(fe);
169 symbol_put_addr(fe->ops.tuner_ops.release);
170 }
171 if (fe->ops.analog_ops.release) {
172 fe->ops.analog_ops.release(fe);
173 symbol_put_addr(fe->ops.analog_ops.release);
174 }
175}
176#else
177#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
178 FUNCTION(ARGS); \
179})
180
181static void tuner_detach(struct dvb_frontend *fe)
182{
183 if (fe->ops.tuner_ops.release)
184 fe->ops.tuner_ops.release(fe);
185 if (fe->ops.analog_ops.release)
186 fe->ops.analog_ops.release(fe);
187}
188#endif
189
Michael Krufkyf7f427e2007-12-16 22:02:26 -0300190
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300191static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
192{
193 return container_of(sd, struct tuner, sd);
194}
195
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300196/*
197 * struct analog_demod_ops callbacks
198 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Michael Krufkyc7919d52007-12-08 17:06:30 -0300200static void fe_set_params(struct dvb_frontend *fe,
201 struct analog_parameters *params)
Michael Krufkye18f9442007-08-21 01:25:48 -0300202{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300203 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
204 struct tuner *t = fe->analog_demod_priv;
Michael Krufkye18f9442007-08-21 01:25:48 -0300205
Michael Krufkye18f9442007-08-21 01:25:48 -0300206 if (NULL == fe_tuner_ops->set_analog_params) {
207 tuner_warn("Tuner frontend module has no way to set freq\n");
208 return;
209 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300210 fe_tuner_ops->set_analog_params(fe, params);
Michael Krufkye18f9442007-08-21 01:25:48 -0300211}
212
Michael Krufky4e9154b2007-10-21 19:39:50 -0300213static void fe_standby(struct dvb_frontend *fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300214{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300215 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
Michael Krufkye18f9442007-08-21 01:25:48 -0300216
217 if (fe_tuner_ops->sleep)
Michael Krufky4e9154b2007-10-21 19:39:50 -0300218 fe_tuner_ops->sleep(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300219}
220
Michael Krufky4e9154b2007-10-21 19:39:50 -0300221static int fe_has_signal(struct dvb_frontend *fe)
Michael Krufky1f5ef192007-08-31 17:38:02 -0300222{
Michael Krufky14196832007-10-14 18:11:53 -0300223 u16 strength = 0;
Michael Krufky1f5ef192007-08-31 17:38:02 -0300224
Michael Krufky4e9154b2007-10-21 19:39:50 -0300225 if (fe->ops.tuner_ops.get_rf_strength)
226 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300227
228 return strength;
229}
230
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300231static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
232{
233 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
234 struct tuner *t = fe->analog_demod_priv;
235
236 if (fe_tuner_ops->set_config)
237 return fe_tuner_ops->set_config(fe, priv_cfg);
238
239 tuner_warn("Tuner frontend module has no way to set config\n");
240
241 return 0;
242}
243
Michael Krufky4e9154b2007-10-21 19:39:50 -0300244static void tuner_status(struct dvb_frontend *fe);
Michael Krufky1dde7a42007-10-21 13:40:56 -0300245
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300246static struct analog_demod_ops tuner_analog_ops = {
Michael Krufkyc7919d52007-12-08 17:06:30 -0300247 .set_params = fe_set_params,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300248 .standby = fe_standby,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300249 .has_signal = fe_has_signal,
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300250 .set_config = fe_set_config,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300251 .tuner_status = tuner_status
252};
253
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300254/*
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200255 * Functions to select between radio and TV and tuner probe/remove functions
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300256 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200258/**
259 * set_type - Sets the tuner type for a given device
260 *
261 * @c: i2c_client descriptoy
262 * @type: type of the tuner (e. g. tuner number)
263 * @new_mode_mask: Indicates if tuner supports TV and/or Radio
264 * @new_config: an optional parameter ranging from 0-255 used by
265 a few tuners to adjust an internal parameter,
266 like LNA mode
267 * @tuner_callback: an optional function to be called when switching
268 * to analog mode
269 *
270 * This function applys the tuner config to tuner specified
271 * by tun_setup structure. It contains several per-tuner initialization "magic"
272 */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700273static void set_type(struct i2c_client *c, unsigned int type,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300274 unsigned int new_mode_mask, unsigned int new_config,
Michael Krufkyd7cba042008-09-12 13:31:45 -0300275 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300277 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Michael Krufkye18f9442007-08-21 01:25:48 -0300278 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300279 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700280 unsigned char buffer[4];
Michael Krufkyd6eef492009-10-24 16:42:16 -0300281 int tune_now = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700283 if (type == UNSET || type == TUNER_ABSENT) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300284 tuner_dbg("tuner 0x%02x: Tuner type absent\n", c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return;
286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 t->type = type;
Michael Krufkye7ddcd92009-03-28 15:35:26 -0300289 /* prevent invalid config values */
Roel Kluinf14a2972009-10-23 07:59:42 -0300290 t->config = new_config < 256 ? new_config : 0;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300291 if (tuner_callback != NULL) {
292 tuner_dbg("defining GPIO callback\n");
Michael Krufkyd7cba042008-09-12 13:31:45 -0300293 t->fe.callback = tuner_callback;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300294 }
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300295
Michael Krufkyb2083192007-05-29 22:54:06 -0300296 /* discard private data, in case set_type() was previously called */
Michael Krufkya07c8772008-04-29 03:54:19 -0300297 tuner_detach(&t->fe);
298 t->fe.analog_demod_priv = NULL;
Michael Krufkybe2b85a2007-06-04 14:40:27 -0300299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 switch (t->type) {
301 case TUNER_MT2032:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300302 if (!dvb_attach(microtune_attach,
303 &t->fe, t->i2c->adapter, t->i2c->addr))
304 goto attach_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 break;
306 case TUNER_PHILIPS_TDA8290:
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300307 {
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300308 struct tda829x_config cfg = {
309 .lna_cfg = t->config,
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300310 };
311 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
312 t->i2c->addr, &cfg))
313 goto attach_failed;
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300314 break;
315 }
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700316 case TUNER_TEA5767:
Michael Krufkya07c8772008-04-29 03:54:19 -0300317 if (!dvb_attach(tea5767_attach, &t->fe,
318 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300319 goto attach_failed;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700320 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700321 break;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300322 case TUNER_TEA5761:
Michael Krufkya07c8772008-04-29 03:54:19 -0300323 if (!dvb_attach(tea5761_attach, &t->fe,
324 t->i2c->adapter, t->i2c->addr))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300325 goto attach_failed;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300326 t->mode_mask = T_RADIO;
327 break;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700328 case TUNER_PHILIPS_FMD1216ME_MK3:
Miroslav Slugen27b93d82011-12-13 15:36:15 -0300329 case TUNER_PHILIPS_FMD1216MEX_MK3:
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700330 buffer[0] = 0x0b;
331 buffer[1] = 0xdc;
332 buffer[2] = 0x9c;
333 buffer[3] = 0x60;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700334 i2c_master_send(c, buffer, 4);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700335 mdelay(1);
336 buffer[2] = 0x86;
337 buffer[3] = 0x54;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700338 i2c_master_send(c, buffer, 4);
Michael Krufkya07c8772008-04-29 03:54:19 -0300339 if (!dvb_attach(simple_tuner_attach, &t->fe,
340 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300341 goto attach_failed;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700342 break;
Hartmut Hackmann93df3412005-11-08 21:36:31 -0800343 case TUNER_PHILIPS_TD1316:
344 buffer[0] = 0x0b;
345 buffer[1] = 0xdc;
346 buffer[2] = 0x86;
347 buffer[3] = 0xa4;
Michael Krufkya07c8772008-04-29 03:54:19 -0300348 i2c_master_send(c, buffer, 4);
349 if (!dvb_attach(simple_tuner_attach, &t->fe,
350 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300351 goto attach_failed;
Markus Rechbergerac272ed2006-01-23 17:11:09 -0200352 break;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300353 case TUNER_XC2028:
354 {
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300355 struct xc2028_config cfg = {
356 .i2c_adap = t->i2c->adapter,
357 .i2c_addr = t->i2c->addr,
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300358 };
Michael Krufkya07c8772008-04-29 03:54:19 -0300359 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300360 goto attach_failed;
Michael Krufkyd6eef492009-10-24 16:42:16 -0300361 tune_now = 0;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300362 break;
363 }
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300364 case TUNER_TDA9887:
Mauro Carvalho Chehab09fee5f2008-04-30 15:29:57 -0300365 if (!dvb_attach(tda9887_attach,
366 &t->fe, t->i2c->adapter, t->i2c->addr))
367 goto attach_failed;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300368 break;
Steven Toth27c685a2008-01-05 16:50:14 -0300369 case TUNER_XC5000:
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300370 {
Mauro Carvalho Chehab900f7342011-02-04 12:56:39 -0300371 struct xc5000_config xc5000_cfg = {
372 .i2c_address = t->i2c->addr,
373 /* if_khz will be set at dvb_attach() */
374 .if_khz = 0,
375 };
376
Michael Krufkya07c8772008-04-29 03:54:19 -0300377 if (!dvb_attach(xc5000_attach,
Michael Krufky30650962008-09-06 14:56:58 -0300378 &t->fe, t->i2c->adapter, &xc5000_cfg))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300379 goto attach_failed;
Michael Krufkyd6eef492009-10-24 16:42:16 -0300380 tune_now = 0;
Steven Toth27c685a2008-01-05 16:50:14 -0300381 break;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300382 }
Michael Krufkyf21cfaf2012-02-07 01:22:34 -0300383 case TUNER_XC5000C:
384 {
385 struct xc5000_config xc5000c_cfg = {
386 .i2c_address = t->i2c->addr,
387 /* if_khz will be set at dvb_attach() */
388 .if_khz = 0,
389 .fw = XC5000C_DEFAULT_FIRMWARE,
390 };
391
392 if (!dvb_attach(xc5000_attach,
393 &t->fe, t->i2c->adapter, &xc5000c_cfg))
394 goto attach_failed;
395 tune_now = 0;
396 break;
397 }
Michael Krufky93463892009-09-15 23:04:18 -0300398 case TUNER_NXP_TDA18271:
399 {
400 struct tda18271_config cfg = {
401 .config = t->config,
Mauro Carvalho Chehabe350d442010-09-26 22:58:28 -0300402 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
Michael Krufky93463892009-09-15 23:04:18 -0300403 };
404
405 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
406 t->i2c->adapter, &cfg))
407 goto attach_failed;
Michael Krufkyd6eef492009-10-24 16:42:16 -0300408 tune_now = 0;
Michael Krufky93463892009-09-15 23:04:18 -0300409 break;
410 }
Davide Ferri8d009a02009-06-23 22:34:06 -0300411 case TUNER_XC4000:
412 {
413 struct xc4000_config xc4000_cfg = {
414 .i2c_address = t->i2c->addr,
istvan_v@mailbox.hu8edeb6e2011-06-06 13:03:44 -0300415 /* FIXME: the correct parameters will be set */
416 /* only when the digital dvb_attach() occurs */
417 .default_pm = 0,
418 .dvb_amplitude = 0,
419 .set_smoothedcvbs = 0,
420 .if_khz = 0
Davide Ferri8d009a02009-06-23 22:34:06 -0300421 };
422 if (!dvb_attach(xc4000_attach,
423 &t->fe, t->i2c->adapter, &xc4000_cfg))
424 goto attach_failed;
425 tune_now = 0;
426 break;
427 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 default:
Michael Krufkya07c8772008-04-29 03:54:19 -0300429 if (!dvb_attach(simple_tuner_attach, &t->fe,
430 t->i2c->adapter, t->i2c->addr, t->type))
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300431 goto attach_failed;
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 break;
434 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700435
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300436 if ((NULL == analog_ops->set_params) &&
Michael Krufky1dde7a42007-10-21 13:40:56 -0300437 (fe_tuner_ops->set_analog_params)) {
Michael Krufkya07c8772008-04-29 03:54:19 -0300438
Michael Krufky7271e602008-05-26 16:08:40 +0200439 t->name = fe_tuner_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300440
Michael Krufky4e9154b2007-10-21 19:39:50 -0300441 t->fe.analog_demod_priv = t;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -0300442 memcpy(analog_ops, &tuner_analog_ops,
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300443 sizeof(struct analog_demod_ops));
Michael Krufkya07c8772008-04-29 03:54:19 -0300444
Michael Krufkya55db8c2007-12-09 13:52:51 -0300445 } else {
Michael Krufky7271e602008-05-26 16:08:40 +0200446 t->name = analog_ops->info.name;
Michael Krufkye18f9442007-08-21 01:25:48 -0300447 }
448
Michael Krufky7271e602008-05-26 16:08:40 +0200449 tuner_dbg("type set to %s\n", t->name);
Michael Krufkye18f9442007-08-21 01:25:48 -0300450
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300451 t->mode_mask = new_mode_mask;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700452
Michael Krufkyd6eef492009-10-24 16:42:16 -0300453 /* Some tuners require more initialization setup before use,
454 such as firmware download or device calibration.
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300455 trying to set a frequency here will just fail
456 FIXME: better to move set_freq to the tuner code. This is needed
457 on analog tuners for PLL to properly work
458 */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300459 if (tune_now) {
460 if (V4L2_TUNER_RADIO == t->mode)
461 set_radio_freq(c, t->radio_freq);
462 else
463 set_tv_freq(c, t->tv_freq);
464 }
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300465
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700466 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100467 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700468 t->mode_mask);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300469 return;
470
471attach_failed:
472 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
473 t->type = TUNER_ABSENT;
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300474
475 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476}
477
Mauro Carvalho Chehab0ae79d92011-02-15 01:10:20 -0300478/**
479 * tuner_s_type_addr - Sets the tuner type for a device
480 *
481 * @sd: subdev descriptor
482 * @tun_setup: type to be associated to a given tuner i2c address
483 *
484 * This function applys the tuner config to tuner specified
485 * by tun_setup structure.
486 * If tuner I2C address is UNSET, then it will only set the device
487 * if the tuner supports the mode specified in the call.
488 * If the address is specified, the change will be applied only if
489 * tuner I2C address matches.
490 * The call can change the tuner number and the tuner mode.
491 */
Mauro Carvalho Chehaba34ec5f2011-02-15 00:55:18 -0300492static int tuner_s_type_addr(struct v4l2_subdev *sd,
493 struct tuner_setup *tun_setup)
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700494{
Mauro Carvalho Chehaba34ec5f2011-02-15 00:55:18 -0300495 struct tuner *t = to_tuner(sd);
496 struct i2c_client *c = v4l2_get_subdevdata(sd);
497
498 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
499 tun_setup->type,
500 tun_setup->addr,
501 tun_setup->mode_mask,
502 tun_setup->config);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700503
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300504 if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
505 (t->mode_mask & tun_setup->mode_mask))) ||
506 (tun_setup->addr == c->addr)) {
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300507 set_type(c, tun_setup->type, tun_setup->mode_mask,
508 tun_setup->config, tun_setup->tuner_callback);
Mauro Carvalho Chehabb9ef6bb2008-04-26 11:29:34 -0300509 } else
510 tuner_dbg("set addr discarded for type %i, mask %x. "
511 "Asked to change tuner at addr 0x%02x, with mask %x\n",
512 t->type, t->mode_mask,
513 tun_setup->addr, tun_setup->mode_mask);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700514
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300515 return 0;
516}
517
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200518/**
519 * tuner_s_config - Sets tuner configuration
520 *
521 * @sd: subdev descriptor
522 * @cfg: tuner configuration
523 *
524 * Calls tuner set_config() private function to set some tuner-internal
525 * parameters
526 */
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300527static int tuner_s_config(struct v4l2_subdev *sd,
528 const struct v4l2_priv_tun_config *cfg)
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300529{
530 struct tuner *t = to_tuner(sd);
531 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
532
533 if (t->type != cfg->tuner)
534 return 0;
535
536 if (analog_ops->set_config) {
537 analog_ops->set_config(&t->fe, cfg->priv);
538 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700539 }
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700540
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300541 tuner_dbg("Tuner frontend module has no way to set config\n");
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700542 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700543}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700544
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200545/**
546 * tuner_lookup - Seek for tuner adapters
547 *
548 * @adap: i2c_adapter struct
549 * @radio: pointer to be filled if the adapter is radio
550 * @tv: pointer to be filled if the adapter is TV
551 *
552 * Search for existing radio and/or TV tuners on the given I2C adapter,
553 * discarding demod-only adapters (tda9887).
554 *
555 * Note that when this function is called from tuner_probe you can be
556 * certain no other devices will be added/deleted at the same time, I2C
557 * core protects against that.
558 */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300559static void tuner_lookup(struct i2c_adapter *adap,
560 struct tuner **radio, struct tuner **tv)
561{
562 struct tuner *pos;
563
564 *radio = NULL;
565 *tv = NULL;
566
567 list_for_each_entry(pos, &tuner_list, list) {
568 int mode_mask;
569
570 if (pos->i2c->adapter != adap ||
571 strcmp(pos->i2c->driver->driver.name, "tuner"))
572 continue;
573
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300574 mode_mask = pos->mode_mask;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300575 if (*radio == NULL && mode_mask == T_RADIO)
576 *radio = pos;
577 /* Note: currently TDA9887 is the only demod-only
578 device. If other devices appear then we need to
579 make this test more general. */
580 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
Mauro Carvalho Chehabad020dc2011-02-15 09:30:50 -0200581 (pos->mode_mask & T_ANALOG_TV))
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300582 *tv = pos;
583 }
584}
585
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200586/**
587 *tuner_probe - Probes the existing tuners on an I2C bus
588 *
589 * @client: i2c_client descriptor
590 * @id: not used
591 *
592 * This routine probes for tuners at the expected I2C addresses. On most
593 * cases, if a device answers to a given I2C address, it assumes that the
594 * device is a tuner. On a few cases, however, an additional logic is needed
595 * to double check if the device is really a tuner, or to identify the tuner
596 * type, like on tea5767/5761 devices.
597 *
598 * During client attach, set_type is called by adapter's attach_inform callback.
599 * set_type must then be completed by tuner_probe.
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300600 */
601static int tuner_probe(struct i2c_client *client,
602 const struct i2c_device_id *id)
603{
604 struct tuner *t;
605 struct tuner *radio;
606 struct tuner *tv;
607
608 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
609 if (NULL == t)
610 return -ENOMEM;
611 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
612 t->i2c = client;
613 t->name = "(tuner unset)";
614 t->type = UNSET;
615 t->audmode = V4L2_TUNER_MODE_STEREO;
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300616 t->standby = 1;
617 t->radio_freq = 87.5 * 16000; /* Initial freq range */
618 t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300619
620 if (show_i2c) {
621 unsigned char buffer[16];
622 int i, rc;
623
624 memset(buffer, 0, sizeof(buffer));
625 rc = i2c_master_recv(client, buffer, sizeof(buffer));
626 tuner_info("I2C RECV = ");
627 for (i = 0; i < rc; i++)
628 printk(KERN_CONT "%02x ", buffer[i]);
629 printk("\n");
630 }
631
632 /* autodetection code based on the i2c addr */
633 if (!no_autodetect) {
634 switch (client->addr) {
635 case 0x10:
636 if (tuner_symbol_probe(tea5761_autodetection,
637 t->i2c->adapter,
638 t->i2c->addr) >= 0) {
639 t->type = TUNER_TEA5761;
640 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300641 tuner_lookup(t->i2c->adapter, &radio, &tv);
642 if (tv)
643 tv->mode_mask &= ~T_RADIO;
644
645 goto register_client;
646 }
647 kfree(t);
648 return -ENODEV;
649 case 0x42:
650 case 0x43:
651 case 0x4a:
652 case 0x4b:
653 /* If chip is not tda8290, don't register.
654 since it can be tda9887*/
655 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
656 t->i2c->addr) >= 0) {
657 tuner_dbg("tda829x detected\n");
658 } else {
659 /* Default is being tda9887 */
660 t->type = TUNER_TDA9887;
Mauro Carvalho Chehabad020dc2011-02-15 09:30:50 -0200661 t->mode_mask = T_RADIO | T_ANALOG_TV;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300662 goto register_client;
663 }
664 break;
665 case 0x60:
666 if (tuner_symbol_probe(tea5767_autodetection,
667 t->i2c->adapter, t->i2c->addr)
668 >= 0) {
669 t->type = TUNER_TEA5767;
670 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300671 /* Sets freq to FM range */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300672 tuner_lookup(t->i2c->adapter, &radio, &tv);
673 if (tv)
674 tv->mode_mask &= ~T_RADIO;
675
676 goto register_client;
677 }
678 break;
679 }
680 }
681
682 /* Initializes only the first TV tuner on this adapter. Why only the
683 first? Because there are some devices (notably the ones with TI
684 tuners) that have more than one i2c address for the *same* device.
685 Experience shows that, except for just one case, the first
686 address is the right one. The exception is a Russian tuner
687 (ACORP_Y878F). So, the desired behavior is just to enable the
688 first found TV tuner. */
689 tuner_lookup(t->i2c->adapter, &radio, &tv);
690 if (tv == NULL) {
Mauro Carvalho Chehabad020dc2011-02-15 09:30:50 -0200691 t->mode_mask = T_ANALOG_TV;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300692 if (radio == NULL)
693 t->mode_mask |= T_RADIO;
694 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300695 }
696
697 /* Should be just before return */
698register_client:
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300699 /* Sets a default mode */
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300700 if (t->mode_mask & T_ANALOG_TV)
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300701 t->mode = V4L2_TUNER_ANALOG_TV;
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300702 else
Mauro Carvalho Chehabad020dc2011-02-15 09:30:50 -0200703 t->mode = V4L2_TUNER_RADIO;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300704 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
705 list_add_tail(&t->list, &tuner_list);
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300706
Mauro Carvalho Chehabad020dc2011-02-15 09:30:50 -0200707 tuner_info("Tuner %d found with type(s)%s%s.\n",
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300708 t->type,
Mauro Carvalho Chehabad020dc2011-02-15 09:30:50 -0200709 t->mode_mask & T_RADIO ? " Radio" : "",
710 t->mode_mask & T_ANALOG_TV ? " TV" : "");
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300711 return 0;
712}
713
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200714/**
715 * tuner_remove - detaches a tuner
716 *
717 * @client: i2c_client descriptor
718 */
719
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300720static int tuner_remove(struct i2c_client *client)
721{
722 struct tuner *t = to_tuner(i2c_get_clientdata(client));
723
724 v4l2_device_unregister_subdev(&t->sd);
725 tuner_detach(&t->fe);
726 t->fe.analog_demod_priv = NULL;
727
728 list_del(&t->list);
729 kfree(t);
730 return 0;
731}
732
733/*
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200734 * Functions to switch between Radio and TV
735 *
736 * A few cards have a separate I2C tuner for radio. Those routines
737 * take care of switching between TV/Radio mode, filtering only the
738 * commands that apply to the Radio or TV tuner.
739 */
740
741/**
742 * check_mode - Verify if tuner supports the requested mode
743 * @t: a pointer to the module's internal struct_tuner
744 *
745 * This function checks if the tuner is capable of tuning analog TV,
746 * digital TV or radio, depending on what the caller wants. If the
747 * tuner can't support that mode, it returns -EINVAL. Otherwise, it
748 * returns 0.
749 * This function is needed for boards that have a separate tuner for
750 * radio (like devices with tea5767).
Mauro Carvalho Chehaba1ad5ec2011-07-13 01:23:11 -0300751 * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
752 * select a TV frequency. So, t_mode = T_ANALOG_TV could actually
753 * be used to represent a Digital TV too.
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200754 */
755static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
756{
Mauro Carvalho Chehaba1ad5ec2011-07-13 01:23:11 -0300757 int t_mode;
758 if (mode == V4L2_TUNER_RADIO)
759 t_mode = T_RADIO;
760 else
761 t_mode = T_ANALOG_TV;
762
763 if ((t_mode & t->mode_mask) == 0)
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200764 return -EINVAL;
765
766 return 0;
767}
768
769/**
Hans Verkuil4e4a31f2011-06-14 03:56:09 -0300770 * set_mode - Switch tuner to other mode.
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200771 * @t: a pointer to the module's internal struct_tuner
772 * @mode: enum v4l2_type (radio or TV)
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200773 *
774 * If tuner doesn't support the needed mode (radio or TV), prints a
775 * debug message and returns -EINVAL, changing its state to standby.
Hans Verkuil4e4a31f2011-06-14 03:56:09 -0300776 * Otherwise, changes the mode and returns 0.
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200777 */
Hans Verkuil4e4a31f2011-06-14 03:56:09 -0300778static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200779{
780 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
781
782 if (mode != t->mode) {
783 if (check_mode(t, mode) == -EINVAL) {
784 tuner_dbg("Tuner doesn't support mode %d. "
785 "Putting tuner to sleep\n", mode);
786 t->standby = true;
787 if (analog_ops->standby)
788 analog_ops->standby(&t->fe);
789 return -EINVAL;
790 }
791 t->mode = mode;
792 tuner_dbg("Changing to mode %d\n", mode);
793 }
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200794 return 0;
795}
796
Hans Verkuil4e4a31f2011-06-14 03:56:09 -0300797/**
798 * set_freq - Set the tuner to the desired frequency.
799 * @t: a pointer to the module's internal struct_tuner
800 * @freq: frequency to set (0 means to use the current frequency)
801 */
802static void set_freq(struct tuner *t, unsigned int freq)
803{
804 struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
805
806 if (t->mode == V4L2_TUNER_RADIO) {
807 if (!freq)
808 freq = t->radio_freq;
809 set_radio_freq(client, freq);
810 } else {
811 if (!freq)
812 freq = t->tv_freq;
813 set_tv_freq(client, freq);
814 }
815}
816
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -0200817/*
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300818 * Functions that are specific for TV mode
819 */
820
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200821/**
822 * set_tv_freq - Set tuner frequency, freq in Units of 62.5 kHz = 1/16MHz
823 *
824 * @c: i2c_client descriptor
825 * @freq: frequency
826 */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300827static void set_tv_freq(struct i2c_client *c, unsigned int freq)
828{
829 struct tuner *t = to_tuner(i2c_get_clientdata(c));
830 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
831
832 struct analog_parameters params = {
833 .mode = t->mode,
834 .audmode = t->audmode,
835 .std = t->std
836 };
837
838 if (t->type == UNSET) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300839 tuner_warn("tuner type not set\n");
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300840 return;
841 }
842 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300843 tuner_warn("Tuner has no way to set tv freq\n");
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300844 return;
845 }
846 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300847 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300848 freq / 16, freq % 16 * 100 / 16, tv_range[0],
849 tv_range[1]);
850 /* V4L2 spec: if the freq is not possible then the closest
851 possible value should be selected */
852 if (freq < tv_range[0] * 16)
853 freq = tv_range[0] * 16;
854 else
855 freq = tv_range[1] * 16;
856 }
857 params.frequency = freq;
858 tuner_dbg("tv freq set to %d.%02d\n",
859 freq / 16, freq % 16 * 100 / 16);
860 t->tv_freq = freq;
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -0300861 t->standby = false;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300862
863 analog_ops->set_params(&t->fe, &params);
864}
865
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200866/**
867 * tuner_fixup_std - force a given video standard variant
868 *
Hans Verkuil48783302011-06-13 09:47:56 -0300869 * @t: tuner internal struct
870 * @std: TV standard
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200871 *
872 * A few devices or drivers have problem to detect some standard variations.
873 * On other operational systems, the drivers generally have a per-country
874 * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
875 * such hacks. Instead, it relies on a proper video standard selection from
876 * the userspace application. However, as some apps are buggy, not allowing
877 * to distinguish all video standard variations, a modprobe parameter can
878 * be used to force a video standard match.
879 */
Hans Verkuil48783302011-06-13 09:47:56 -0300880static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
Hans Verkuil48783302011-06-13 09:47:56 -0300882 if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 switch (pal[0]) {
Hans Verkuile71ced12006-12-11 15:51:43 -0300884 case '6':
Hans Verkuil48783302011-06-13 09:47:56 -0300885 return V4L2_STD_PAL_60;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 case 'b':
887 case 'B':
888 case 'g':
889 case 'G':
Hans Verkuil48783302011-06-13 09:47:56 -0300890 return V4L2_STD_PAL_BG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 case 'i':
892 case 'I':
Hans Verkuil48783302011-06-13 09:47:56 -0300893 return V4L2_STD_PAL_I;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 case 'd':
895 case 'D':
896 case 'k':
897 case 'K':
Hans Verkuil48783302011-06-13 09:47:56 -0300898 return V4L2_STD_PAL_DK;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700899 case 'M':
900 case 'm':
Hans Verkuil48783302011-06-13 09:47:56 -0300901 return V4L2_STD_PAL_M;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700902 case 'N':
903 case 'n':
Hans Verkuil48783302011-06-13 09:47:56 -0300904 if (pal[1] == 'c' || pal[1] == 'C')
905 return V4L2_STD_PAL_Nc;
906 return V4L2_STD_PAL_N;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700907 default:
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300908 tuner_warn("pal= argument not recognised\n");
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700909 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 }
911 }
Hans Verkuil48783302011-06-13 09:47:56 -0300912 if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700913 switch (secam[0]) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200914 case 'b':
915 case 'B':
916 case 'g':
917 case 'G':
918 case 'h':
919 case 'H':
Hans Verkuil48783302011-06-13 09:47:56 -0300920 return V4L2_STD_SECAM_B |
921 V4L2_STD_SECAM_G |
922 V4L2_STD_SECAM_H;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700923 case 'd':
924 case 'D':
925 case 'k':
926 case 'K':
Hans Verkuil48783302011-06-13 09:47:56 -0300927 return V4L2_STD_SECAM_DK;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700928 case 'l':
929 case 'L':
Hans Verkuil48783302011-06-13 09:47:56 -0300930 if ((secam[1] == 'C') || (secam[1] == 'c'))
931 return V4L2_STD_SECAM_LC;
932 return V4L2_STD_SECAM_L;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700933 default:
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300934 tuner_warn("secam= argument not recognised\n");
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700935 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700936 }
937 }
938
Hans Verkuil48783302011-06-13 09:47:56 -0300939 if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200940 switch (ntsc[0]) {
941 case 'm':
942 case 'M':
Hans Verkuil48783302011-06-13 09:47:56 -0300943 return V4L2_STD_NTSC_M;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200944 case 'j':
945 case 'J':
Hans Verkuil48783302011-06-13 09:47:56 -0300946 return V4L2_STD_NTSC_M_JP;
Hans Verkuild97a11e2006-02-07 06:48:40 -0200947 case 'k':
948 case 'K':
Hans Verkuil48783302011-06-13 09:47:56 -0300949 return V4L2_STD_NTSC_M_KR;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200950 default:
951 tuner_info("ntsc= argument not recognised\n");
952 break;
953 }
954 }
Hans Verkuil48783302011-06-13 09:47:56 -0300955 return std;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956}
957
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300958/*
959 * Functions that are specific for Radio mode
960 */
961
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -0200962/**
963 * set_radio_freq - Set tuner frequency, freq in Units of 62.5 Hz = 1/16kHz
964 *
965 * @c: i2c_client descriptor
966 * @freq: frequency
967 */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300968static void set_radio_freq(struct i2c_client *c, unsigned int freq)
969{
970 struct tuner *t = to_tuner(i2c_get_clientdata(c));
971 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
972
973 struct analog_parameters params = {
974 .mode = t->mode,
975 .audmode = t->audmode,
976 .std = t->std
977 };
978
979 if (t->type == UNSET) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300980 tuner_warn("tuner type not set\n");
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300981 return;
982 }
983 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300984 tuner_warn("tuner has no way to set radio frequency\n");
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300985 return;
986 }
987 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -0300988 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -0300989 freq / 16000, freq % 16000 * 100 / 16000,
990 radio_range[0], radio_range[1]);
991 /* V4L2 spec: if the freq is not possible then the closest
992 possible value should be selected */
993 if (freq < radio_range[0] * 16000)
994 freq = radio_range[0] * 16000;
995 else
996 freq = radio_range[1] * 16000;
997 }
998 params.frequency = freq;
999 tuner_dbg("radio freq set to %d.%02d\n",
1000 freq / 16000, freq % 16000 * 100 / 16000);
1001 t->radio_freq = freq;
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001002 t->standby = false;
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -03001003
1004 analog_ops->set_params(&t->fe, &params);
1005}
1006
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -02001007/*
1008 * Debug function for reporting tuner status to userspace
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -03001009 */
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -03001010
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001011/**
1012 * tuner_status - Dumps the current tuner status at dmesg
1013 * @fe: pointer to struct dvb_frontend
1014 *
1015 * This callback is used only for driver debug purposes, answering to
1016 * VIDIOC_LOG_STATUS. No changes should happen on this call.
1017 */
Michael Krufky4e9154b2007-10-21 19:39:50 -03001018static void tuner_status(struct dvb_frontend *fe)
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001019{
Michael Krufky4e9154b2007-10-21 19:39:50 -03001020 struct tuner *t = fe->analog_demod_priv;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001021 unsigned long freq, freq_fraction;
Michael Krufkya07c8772008-04-29 03:54:19 -03001022 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1023 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001024 const char *p;
1025
1026 switch (t->mode) {
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -03001027 case V4L2_TUNER_RADIO:
1028 p = "radio";
1029 break;
Mauro Carvalho Chehaba1ad5ec2011-07-13 01:23:11 -03001030 case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -03001031 p = "digital TV";
1032 break;
1033 case V4L2_TUNER_ANALOG_TV:
1034 default:
1035 p = "analog TV";
1036 break;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001037 }
1038 if (t->mode == V4L2_TUNER_RADIO) {
Hans Verkuil27487d42006-01-15 15:04:52 -02001039 freq = t->radio_freq / 16000;
1040 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001041 } else {
Hans Verkuil27487d42006-01-15 15:04:52 -02001042 freq = t->tv_freq / 16;
1043 freq_fraction = (t->tv_freq % 16) * 100 / 16;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001044 }
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001045 tuner_info("Tuner mode: %s%s\n", p,
1046 t->standby ? " on standby mode" : "");
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001047 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
Mauro Carvalho Chehab4ae5c2e2006-03-25 15:53:38 -03001048 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
Hans Verkuil8a4b2752006-01-23 17:11:09 -02001049 if (t->mode != V4L2_TUNER_RADIO)
Mauro Carvalho Chehab7d275bf2011-02-04 11:28:00 -03001050 return;
Michael Krufkye18f9442007-08-21 01:25:48 -03001051 if (fe_tuner_ops->get_status) {
1052 u32 tuner_status;
1053
1054 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1055 if (tuner_status & TUNER_STATUS_LOCKED)
1056 tuner_info("Tuner is locked.\n");
1057 if (tuner_status & TUNER_STATUS_STEREO)
1058 tuner_info("Stereo: yes\n");
1059 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001060 if (analog_ops->has_signal)
1061 tuner_info("Signal strength: %d\n",
1062 analog_ops->has_signal(fe));
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -02001063}
Hans Verkuil8a4b2752006-01-23 17:11:09 -02001064
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -02001065/*
1066 * Function to splicitly change mode to radio. Probably not needed anymore
1067 */
1068
1069static int tuner_s_radio(struct v4l2_subdev *sd)
1070{
1071 struct tuner *t = to_tuner(sd);
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -02001072
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001073 if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1074 set_freq(t, 0);
Mauro Carvalho Chehab0eec66c2011-02-15 10:27:03 -02001075 return 0;
1076}
1077
1078/*
1079 * Tuner callbacks to handle userspace ioctl's
1080 */
1081
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001082/**
1083 * tuner_s_power - controls the power state of the tuner
1084 * @sd: pointer to struct v4l2_subdev
Hans Verkuild16625e2011-06-25 10:24:49 -03001085 * @on: a zero value puts the tuner to sleep, non-zero wakes it up
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001086 */
Laurent Pinchart622b8282009-10-05 10:48:17 -03001087static int tuner_s_power(struct v4l2_subdev *sd, int on)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001088{
1089 struct tuner *t = to_tuner(sd);
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001090 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
Hans Verkuild16625e2011-06-25 10:24:49 -03001092 if (on) {
1093 if (t->standby && set_mode(t, t->mode) == 0) {
1094 tuner_dbg("Waking up tuner\n");
1095 set_freq(t, 0);
1096 }
Laurent Pinchart622b8282009-10-05 10:48:17 -03001097 return 0;
Hans Verkuild16625e2011-06-25 10:24:49 -03001098 }
Laurent Pinchart622b8282009-10-05 10:48:17 -03001099
Mauro Carvalho Chehab16a5e532008-12-20 07:17:10 -03001100 tuner_dbg("Putting tuner to sleep\n");
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001101 t->standby = true;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001102 if (analog_ops->standby)
1103 analog_ops->standby(&t->fe);
1104 return 0;
1105}
1106
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001107static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1108{
1109 struct tuner *t = to_tuner(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001111 if (set_mode(t, V4L2_TUNER_ANALOG_TV))
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001112 return 0;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -07001113
Hans Verkuil48783302011-06-13 09:47:56 -03001114 t->std = tuner_fixup_std(t, std);
1115 if (t->std != std)
1116 tuner_dbg("Fixup standard %llx to %llx\n", std, t->std);
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001117 set_freq(t, 0);
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001118 return 0;
1119}
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -07001120
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001121static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1122{
1123 struct tuner *t = to_tuner(sd);
Michael Krufkye18f9442007-08-21 01:25:48 -03001124
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001125 if (set_mode(t, f->type) == 0)
1126 set_freq(t, f->frequency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 return 0;
1128}
1129
Hans Verkuil338e9e12011-06-13 09:35:56 -03001130/**
1131 * tuner_g_frequency - Get the tuned frequency for the tuner
1132 * @sd: pointer to struct v4l2_subdev
1133 * @f: pointer to struct v4l2_frequency
1134 *
1135 * At return, the structure f will be filled with tuner frequency
1136 * if the tuner matches the f->type.
1137 * Note: f->type should be initialized before calling it.
1138 * This is done by either video_ioctl2 or by the bridge driver.
1139 */
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001140static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1141{
1142 struct tuner *t = to_tuner(sd);
1143 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1144
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001145 if (check_mode(t, f->type) == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001146 return 0;
Hans Verkuil5ad339a2011-06-26 05:35:34 -03001147 if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001148 u32 abs_freq;
1149
1150 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1151 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
Julia Lawall75b697f2009-08-01 16:48:41 -03001152 DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1153 DIV_ROUND_CLOSEST(abs_freq, 62500);
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001154 } else {
Hans Verkuil5ad339a2011-06-26 05:35:34 -03001155 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001156 t->radio_freq : t->tv_freq;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001157 }
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001158 return 0;
1159}
1160
Hans Verkuil338e9e12011-06-13 09:35:56 -03001161/**
1162 * tuner_g_tuner - Fill in tuner information
1163 * @sd: pointer to struct v4l2_subdev
1164 * @vt: pointer to struct v4l2_tuner
1165 *
1166 * At return, the structure vt will be filled with tuner information
1167 * if the tuner matches vt->type.
1168 * Note: vt->type should be initialized before calling it.
1169 * This is done by either video_ioctl2 or by the bridge driver.
1170 */
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001171static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1172{
1173 struct tuner *t = to_tuner(sd);
1174 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1175 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1176
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001177 if (check_mode(t, vt->type) == -EINVAL)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001178 return 0;
Hans Verkuil5ad339a2011-06-26 05:35:34 -03001179 if (vt->type == t->mode && analog_ops->get_afc)
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001180 vt->afc = analog_ops->get_afc(&t->fe);
Mauro Carvalho Chehaba1ad5ec2011-07-13 01:23:11 -03001181 if (t->mode != V4L2_TUNER_RADIO) {
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001182 vt->capability |= V4L2_TUNER_CAP_NORM;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001183 vt->rangelow = tv_range[0] * 16;
1184 vt->rangehigh = tv_range[1] * 16;
1185 return 0;
1186 }
1187
1188 /* radio mode */
Hans Verkuil5ad339a2011-06-26 05:35:34 -03001189 if (vt->type == t->mode) {
1190 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1191 if (fe_tuner_ops->get_status) {
1192 u32 tuner_status;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001193
Hans Verkuil5ad339a2011-06-26 05:35:34 -03001194 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1195 vt->rxsubchans =
1196 (tuner_status & TUNER_STATUS_STEREO) ?
1197 V4L2_TUNER_SUB_STEREO :
1198 V4L2_TUNER_SUB_MONO;
1199 }
1200 if (analog_ops->has_signal)
1201 vt->signal = analog_ops->has_signal(&t->fe);
1202 vt->audmode = t->audmode;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001203 }
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001204 vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001205 vt->rangelow = radio_range[0] * 16000;
1206 vt->rangehigh = radio_range[1] * 16000;
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001207
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001208 return 0;
1209}
1210
Hans Verkuil338e9e12011-06-13 09:35:56 -03001211/**
1212 * tuner_s_tuner - Set the tuner's audio mode
1213 * @sd: pointer to struct v4l2_subdev
1214 * @vt: pointer to struct v4l2_tuner
1215 *
1216 * Sets the audio mode if the tuner matches vt->type.
1217 * Note: vt->type should be initialized before calling it.
1218 * This is done by either video_ioctl2 or by the bridge driver.
1219 */
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001220static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1221{
1222 struct tuner *t = to_tuner(sd);
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001223
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001224 if (set_mode(t, vt->type))
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001225 return 0;
1226
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001227 if (t->mode == V4L2_TUNER_RADIO)
1228 t->audmode = vt->audmode;
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001229 set_freq(t, 0);
Mauro Carvalho Chehabcbde6892011-02-04 10:42:09 -03001230
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001231 return 0;
1232}
1233
1234static int tuner_log_status(struct v4l2_subdev *sd)
1235{
1236 struct tuner *t = to_tuner(sd);
1237 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1238
1239 if (analog_ops->tuner_status)
1240 analog_ops->tuner_status(&t->fe);
1241 return 0;
1242}
1243
Jean Delvare21b48a72007-03-12 19:20:15 -03001244static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001246 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Mauro Carvalho Chehabe2f63d92011-02-04 11:15:21 -03001247 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001249 tuner_dbg("suspend\n");
Mauro Carvalho Chehabe2f63d92011-02-04 11:15:21 -03001250
1251 if (!t->standby && analog_ops->standby)
1252 analog_ops->standby(&t->fe);
1253
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 return 0;
1255}
1256
Jean Delvare21b48a72007-03-12 19:20:15 -03001257static int tuner_resume(struct i2c_client *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258{
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001259 struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001261 tuner_dbg("resume\n");
Mauro Carvalho Chehabe2f63d92011-02-04 11:15:21 -03001262
1263 if (!t->standby)
Hans Verkuil9bf0ef02011-06-13 09:21:56 -03001264 if (set_mode(t, t->mode) == 0)
Hans Verkuil4e4a31f2011-06-14 03:56:09 -03001265 set_freq(t, 0);
Mauro Carvalho Chehabe2f63d92011-02-04 11:15:21 -03001266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 return 0;
1268}
1269
Hans Verkuil75b4c262009-04-01 03:32:22 -03001270static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1271{
1272 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1273
1274 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1275 to handle it here.
1276 There must be a better way of doing this... */
1277 switch (cmd) {
1278 case TUNER_SET_CONFIG:
1279 return tuner_s_config(sd, arg);
1280 }
1281 return -ENOIOCTLCMD;
1282}
1283
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -02001284/*
1285 * Callback structs
1286 */
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001287
1288static const struct v4l2_subdev_core_ops tuner_core_ops = {
1289 .log_status = tuner_log_status,
Hans Verkuilf41737e2009-04-01 03:52:39 -03001290 .s_std = tuner_s_std,
Laurent Pinchart622b8282009-10-05 10:48:17 -03001291 .s_power = tuner_s_power,
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001292};
1293
1294static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
Hans Verkuile8a4a9e2008-11-24 18:21:40 -03001295 .s_radio = tuner_s_radio,
1296 .g_tuner = tuner_g_tuner,
1297 .s_tuner = tuner_s_tuner,
1298 .s_frequency = tuner_s_frequency,
1299 .g_frequency = tuner_g_frequency,
1300 .s_type_addr = tuner_s_type_addr,
1301 .s_config = tuner_s_config,
1302};
1303
1304static const struct v4l2_subdev_ops tuner_ops = {
1305 .core = &tuner_core_ops,
1306 .tuner = &tuner_tuner_ops,
1307};
1308
Mauro Carvalho Chehaba2894e32011-02-15 10:15:19 -02001309/*
1310 * I2C structs and module init functions
1311 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Jean Delvareaf294862008-05-18 20:49:40 +02001313static const struct i2c_device_id tuner_id[] = {
1314 { "tuner", }, /* autodetect */
1315 { }
1316};
1317MODULE_DEVICE_TABLE(i2c, tuner_id);
1318
Hans Verkuil02a20982010-09-15 15:36:23 -03001319static struct i2c_driver tuner_driver = {
1320 .driver = {
1321 .owner = THIS_MODULE,
1322 .name = "tuner",
1323 },
1324 .probe = tuner_probe,
1325 .remove = tuner_remove,
1326 .command = tuner_command,
1327 .suspend = tuner_suspend,
1328 .resume = tuner_resume,
1329 .id_table = tuner_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330};
1331
Hans Verkuil02a20982010-09-15 15:36:23 -03001332static __init int init_tuner(void)
1333{
1334 return i2c_add_driver(&tuner_driver);
1335}
1336
1337static __exit void exit_tuner(void)
1338{
1339 i2c_del_driver(&tuner_driver);
1340}
1341
1342module_init(init_tuner);
1343module_exit(exit_tuner);
1344
Mauro Carvalho Chehab9f3f71e2011-02-03 23:32:07 -03001345MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1346MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1347MODULE_LICENSE("GPL");