blob: 67b9ed1ac71a4accf655822acf1e9597a20c2d47 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
3 * i2c tv tuner chip device driver
4 * core core, i.e. kernel interfaces, registering and so on
5 */
6
7#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/string.h>
10#include <linux/timer.h>
11#include <linux/delay.h>
12#include <linux/errno.h>
13#include <linux/slab.h>
14#include <linux/poll.h>
15#include <linux/i2c.h>
16#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/init.h>
Michael Krufkyffbb8072007-08-21 01:14:12 -030018#include <linux/videodev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <media/tuner.h>
Michael Krufky4adad282007-08-27 21:59:08 -030020#include <media/tuner-types.h>
Michael Krufky5e453dc2006-01-09 15:32:31 -020021#include <media/v4l2-common.h>
Hans Verkuil9dd659d2007-11-04 11:03:36 -030022#include <media/v4l2-i2c-drv-legacy.h>
Michael Krufky96c0b7c2007-08-27 21:23:08 -030023#include "mt20xx.h"
Michael Krufky910bb3e2007-08-27 21:22:20 -030024#include "tda8290.h"
Michael Krufky7ab10bf2007-08-27 21:23:40 -030025#include "tea5761.h"
Michael Krufky8d0936e2007-08-27 21:24:27 -030026#include "tea5767.h"
Mauro Carvalho Chehab215b95b2007-10-23 15:24:06 -030027#include "tuner-xc2028.h"
Michael Krufky4adad282007-08-27 21:59:08 -030028#include "tuner-simple.h"
Michael Krufky31c95842007-10-21 20:48:48 -030029#include "tda9887.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#define UNSET (-1U)
32
Hans Verkuil9dd659d2007-11-04 11:03:36 -030033#define PREFIX t->i2c->driver->driver.name
Michael Krufky241020d2007-10-30 09:46:10 -030034
Michael Krufkyf7f427e2007-12-16 22:02:26 -030035struct tuner {
36 /* device */
37 struct dvb_frontend fe;
38 struct i2c_client *i2c;
39 struct list_head list;
40 unsigned int using_v4l2:1;
41
42 /* keep track of the current settings */
43 v4l2_std_id std;
44 unsigned int tv_freq;
45 unsigned int radio_freq;
46 unsigned int audmode;
47
48 unsigned int mode;
49 unsigned int mode_mask; /* Combination of allowable modes */
50
51 unsigned int type; /* chip type id */
52 unsigned int config;
53 int (*tuner_callback) (void *dev, int command, int arg);
54};
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056/* standard i2c insmod options */
57static unsigned short normal_i2c[] = {
Adrian Bunk04d934f2007-10-24 09:06:47 -030058#if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -030059 0x10,
60#endif
Hartmut Hackmannde48eeb2005-11-08 21:37:48 -080061 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
Mauro Carvalho Chehabf5bec392005-06-23 22:05:13 -070062 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
63 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 I2C_CLIENT_END
65};
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -070066
Linus Torvalds1da177e2005-04-16 15:20:36 -070067I2C_CLIENT_INSMOD;
68
69/* insmod options used at init time => read/only */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -070070static unsigned int addr = 0;
Mauro Carvalho Chehabc5287ba2005-07-15 03:56:28 -070071static unsigned int no_autodetect = 0;
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -070072static unsigned int show_i2c = 0;
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -070073
Linus Torvalds1da177e2005-04-16 15:20:36 -070074/* insmod options used at runtime => read/write */
Michael Krufkyab166052007-12-09 02:26:48 -030075static int tuner_debug;
76
77#define tuner_warn(fmt, arg...) do { \
78 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
79 i2c_adapter_id(t->i2c->adapter), \
80 t->i2c->addr, ##arg); \
81 } while (0)
82
83#define tuner_info(fmt, arg...) do { \
84 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
85 i2c_adapter_id(t->i2c->adapter), \
86 t->i2c->addr, ##arg); \
87 } while (0)
88
89#define tuner_err(fmt, arg...) do { \
90 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
91 i2c_adapter_id(t->i2c->adapter), \
92 t->i2c->addr, ##arg); \
93 } while (0)
94
95#define tuner_dbg(fmt, arg...) do { \
96 if (tuner_debug) \
97 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
98 i2c_adapter_id(t->i2c->adapter), \
99 t->i2c->addr, ##arg); \
100 } while (0)
101
102/* ------------------------------------------------------------------------ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700104static unsigned int tv_range[2] = { 44, 958 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static unsigned int radio_range[2] = { 65, 108 };
106
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200107static char pal[] = "--";
108static char secam[] = "--";
109static char ntsc[] = "-";
110
Hans Verkuilf9195de2006-01-11 19:01:01 -0200111
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200112module_param(addr, int, 0444);
113module_param(no_autodetect, int, 0444);
114module_param(show_i2c, int, 0444);
Hans Verkuilf9195de2006-01-11 19:01:01 -0200115module_param_named(debug,tuner_debug, int, 0644);
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200116module_param_string(pal, pal, sizeof(pal), 0644);
117module_param_string(secam, secam, sizeof(secam), 0644);
118module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700119module_param_array(tv_range, int, NULL, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120module_param_array(radio_range, int, NULL, 0644);
121
122MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
123MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
124MODULE_LICENSE("GPL");
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126/* ---------------------------------------------------------------------- */
127
Michael Krufkyc7919d52007-12-08 17:06:30 -0300128static void fe_set_params(struct dvb_frontend *fe,
129 struct analog_parameters *params)
Michael Krufkye18f9442007-08-21 01:25:48 -0300130{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300131 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
132 struct tuner *t = fe->analog_demod_priv;
Michael Krufkye18f9442007-08-21 01:25:48 -0300133
Michael Krufkye18f9442007-08-21 01:25:48 -0300134 if (NULL == fe_tuner_ops->set_analog_params) {
135 tuner_warn("Tuner frontend module has no way to set freq\n");
136 return;
137 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300138 fe_tuner_ops->set_analog_params(fe, params);
Michael Krufkye18f9442007-08-21 01:25:48 -0300139}
140
Michael Krufky4e9154b2007-10-21 19:39:50 -0300141static void fe_release(struct dvb_frontend *fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300142{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300143 if (fe->ops.tuner_ops.release)
144 fe->ops.tuner_ops.release(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300145
Michael Krufky4524c1a2007-10-22 18:15:39 -0300146 /* DO NOT kfree(fe->analog_demod_priv)
147 *
148 * If we are in this function, analog_demod_priv contains a pointer
149 * to struct tuner *t. This will be kfree'd in tuner_detach().
150 *
151 * Otherwise, fe->ops.analog_demod_ops->release will
152 * handle the cleanup for analog demodulator modules.
153 */
Michael Krufky4e9154b2007-10-21 19:39:50 -0300154 fe->analog_demod_priv = NULL;
Michael Krufkye18f9442007-08-21 01:25:48 -0300155}
156
Michael Krufky4e9154b2007-10-21 19:39:50 -0300157static void fe_standby(struct dvb_frontend *fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300158{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300159 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
Michael Krufkye18f9442007-08-21 01:25:48 -0300160
161 if (fe_tuner_ops->sleep)
Michael Krufky4e9154b2007-10-21 19:39:50 -0300162 fe_tuner_ops->sleep(fe);
Michael Krufkye18f9442007-08-21 01:25:48 -0300163}
164
Michael Krufky4e9154b2007-10-21 19:39:50 -0300165static int fe_has_signal(struct dvb_frontend *fe)
Michael Krufky1f5ef192007-08-31 17:38:02 -0300166{
Michael Krufky14196832007-10-14 18:11:53 -0300167 u16 strength = 0;
Michael Krufky1f5ef192007-08-31 17:38:02 -0300168
Michael Krufky4e9154b2007-10-21 19:39:50 -0300169 if (fe->ops.tuner_ops.get_rf_strength)
170 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300171
172 return strength;
173}
174
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300175static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
176{
177 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
178 struct tuner *t = fe->analog_demod_priv;
179
180 if (fe_tuner_ops->set_config)
181 return fe_tuner_ops->set_config(fe, priv_cfg);
182
183 tuner_warn("Tuner frontend module has no way to set config\n");
184
185 return 0;
186}
187
Michael Krufky4e9154b2007-10-21 19:39:50 -0300188static void tuner_status(struct dvb_frontend *fe);
Michael Krufky1dde7a42007-10-21 13:40:56 -0300189
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300190static struct analog_demod_ops tuner_core_ops = {
Michael Krufkyc7919d52007-12-08 17:06:30 -0300191 .set_params = fe_set_params,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300192 .standby = fe_standby,
193 .release = fe_release,
194 .has_signal = fe_has_signal,
Michael Krufkyf1c9a282007-12-16 19:27:23 -0300195 .set_config = fe_set_config,
Michael Krufky1dde7a42007-10-21 13:40:56 -0300196 .tuner_status = tuner_status
197};
198
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700199/* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200static void set_tv_freq(struct i2c_client *c, unsigned int freq)
201{
202 struct tuner *t = i2c_get_clientdata(c);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300203 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Michael Krufkyc7919d52007-12-08 17:06:30 -0300205 struct analog_parameters params = {
206 .mode = t->mode,
207 .audmode = t->audmode,
208 .std = t->std
209 };
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700212 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return;
214 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300215 if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700216 tuner_warn ("Tuner has no way to set tv freq\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return;
218 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700219 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
220 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
221 freq / 16, freq % 16 * 100 / 16, tv_range[0],
222 tv_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200223 /* V4L2 spec: if the freq is not possible then the closest
224 possible value should be selected */
225 if (freq < tv_range[0] * 16)
226 freq = tv_range[0] * 16;
227 else
228 freq = tv_range[1] * 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300230 params.frequency = freq;
231
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300232 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
234
235static void set_radio_freq(struct i2c_client *c, unsigned int freq)
236{
237 struct tuner *t = i2c_get_clientdata(c);
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300238 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Michael Krufkyc7919d52007-12-08 17:06:30 -0300240 struct analog_parameters params = {
241 .mode = t->mode,
242 .audmode = t->audmode,
243 .std = t->std
244 };
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 if (t->type == UNSET) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700247 tuner_warn ("tuner type not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return;
249 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300250 if (analog_ops->set_params) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700251 tuner_warn ("tuner has no way to set radio frequency\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 return;
253 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200254 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700255 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
256 freq / 16000, freq % 16000 * 100 / 16000,
257 radio_range[0], radio_range[1]);
Hans Verkuil27487d42006-01-15 15:04:52 -0200258 /* V4L2 spec: if the freq is not possible then the closest
259 possible value should be selected */
260 if (freq < radio_range[0] * 16000)
261 freq = radio_range[0] * 16000;
262 else
263 freq = radio_range[1] * 16000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 }
Michael Krufkyc7919d52007-12-08 17:06:30 -0300265 params.frequency = freq;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700266
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300267 analog_ops->set_params(&t->fe, &params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
270static void set_freq(struct i2c_client *c, unsigned long freq)
271{
272 struct tuner *t = i2c_get_clientdata(c);
273
274 switch (t->mode) {
275 case V4L2_TUNER_RADIO:
276 tuner_dbg("radio freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700277 freq / 16000, freq % 16000 * 100 / 16000);
278 set_radio_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200279 t->radio_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 break;
281 case V4L2_TUNER_ANALOG_TV:
282 case V4L2_TUNER_DIGITAL_TV:
283 tuner_dbg("tv freq set to %lu.%02lu\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700284 freq / 16, freq % 16 * 100 / 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 set_tv_freq(c, freq);
Hans Verkuil27487d42006-01-15 15:04:52 -0200286 t->tv_freq = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 break;
Mauro Carvalho Chehab6cb45872007-10-02 11:57:03 -0300288 default:
289 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
Michael Krufky293197c2007-08-28 17:20:42 -0300293static void tuner_i2c_address_check(struct tuner *t)
294{
295 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300296 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
Michael Krufky293197c2007-08-28 17:20:42 -0300297 return;
298
299 tuner_warn("====================== WARNING! ======================\n");
300 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
301 tuner_warn("will soon be dropped. This message indicates that your\n");
302 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300303 t->i2c->name, t->i2c->addr);
Michael Krufky293197c2007-08-28 17:20:42 -0300304 tuner_warn("To ensure continued support for your device, please\n");
305 tuner_warn("send a copy of this message, along with full dmesg\n");
306 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
307 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
308 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300309 t->i2c->adapter->name, t->i2c->addr, t->type,
Michael Krufky293197c2007-08-28 17:20:42 -0300310 tuners[t->type].name);
311 tuner_warn("====================== WARNING! ======================\n");
312}
313
Michael Krufky4adad282007-08-27 21:59:08 -0300314static void attach_simple_tuner(struct tuner *t)
315{
316 struct simple_tuner_config cfg = {
317 .type = t->type,
318 .tun = &tuners[t->type]
319 };
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300320 simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
Michael Krufky4adad282007-08-27 21:59:08 -0300321}
322
Michael Krufkyab166052007-12-09 02:26:48 -0300323static void attach_tda829x(struct tuner *t)
324{
325 struct tda829x_config cfg = {
326 .lna_cfg = &t->config,
327 .tuner_callback = t->tuner_callback,
328 };
329 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
330}
331
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700332static void set_type(struct i2c_client *c, unsigned int type,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300333 unsigned int new_mode_mask, unsigned int new_config,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300334 int (*tuner_callback) (void *dev, int command,int arg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
336 struct tuner *t = i2c_get_clientdata(c);
Michael Krufkye18f9442007-08-21 01:25:48 -0300337 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300338 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700339 unsigned char buffer[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700341 if (type == UNSET || type == TUNER_ABSENT) {
342 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 return;
344 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700346 if (type >= tuner_count) {
347 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
348 return;
349 }
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 t->type = type;
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300352 t->config = new_config;
353 if (tuner_callback != NULL) {
354 tuner_dbg("defining GPIO callback\n");
355 t->tuner_callback = tuner_callback;
356 }
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300357
Mauro Carvalho Chehab48aa3362007-10-29 11:33:18 -0300358 if (t->mode == T_UNINITIALIZED) {
Hartmut Hackmann80f90fb2007-04-27 12:31:18 -0300359 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
360
361 return;
362 }
363
Michael Krufkyb2083192007-05-29 22:54:06 -0300364 /* discard private data, in case set_type() was previously called */
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300365 if (analog_ops->release)
366 analog_ops->release(&t->fe);
Michael Krufkybe2b85a2007-06-04 14:40:27 -0300367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 switch (t->type) {
369 case TUNER_MT2032:
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300370 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 break;
372 case TUNER_PHILIPS_TDA8290:
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300373 {
Michael Krufkyab166052007-12-09 02:26:48 -0300374 attach_tda829x(t);
Michael Krufky5bea1cd2007-10-22 09:56:38 -0300375 break;
376 }
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700377 case TUNER_TEA5767:
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300378 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700379 t->type = TUNER_ABSENT;
380 t->mode_mask = T_UNINITIALIZED;
381 return;
382 }
383 t->mode_mask = T_RADIO;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700384 break;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300385 case TUNER_TEA5761:
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300386 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300387 t->type = TUNER_ABSENT;
388 t->mode_mask = T_UNINITIALIZED;
Adrian Bunk9ee476a2007-06-05 05:22:00 -0300389 return;
Mauro Carvalho Chehab8573a9e2007-04-08 01:09:11 -0300390 }
391 t->mode_mask = T_RADIO;
392 break;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700393 case TUNER_PHILIPS_FMD1216ME_MK3:
394 buffer[0] = 0x0b;
395 buffer[1] = 0xdc;
396 buffer[2] = 0x9c;
397 buffer[3] = 0x60;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700398 i2c_master_send(c, buffer, 4);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700399 mdelay(1);
400 buffer[2] = 0x86;
401 buffer[3] = 0x54;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700402 i2c_master_send(c, buffer, 4);
Michael Krufky4adad282007-08-27 21:59:08 -0300403 attach_simple_tuner(t);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700404 break;
Hartmut Hackmann93df3412005-11-08 21:36:31 -0800405 case TUNER_PHILIPS_TD1316:
406 buffer[0] = 0x0b;
407 buffer[1] = 0xdc;
408 buffer[2] = 0x86;
409 buffer[3] = 0xa4;
410 i2c_master_send(c,buffer,4);
Michael Krufky4adad282007-08-27 21:59:08 -0300411 attach_simple_tuner(t);
Markus Rechbergerac272ed2006-01-23 17:11:09 -0200412 break;
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300413 case TUNER_XC2028:
414 {
Michel Ludwiga37b4c92007-11-16 07:46:14 -0300415 struct xc2028_config cfg = {
416 .i2c_adap = t->i2c->adapter,
417 .i2c_addr = t->i2c->addr,
418 .video_dev = c->adapter->algo_data,
419 .callback = t->tuner_callback,
420 };
421 if (!xc2028_attach(&t->fe, &cfg)) {
Mauro Carvalho Chehab690c5442007-10-29 11:33:18 -0300422 t->type = TUNER_ABSENT;
423 t->mode_mask = T_UNINITIALIZED;
424 return;
425 }
426 break;
427 }
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300428 case TUNER_TDA9887:
Michael Krufky8ca40832007-12-16 20:11:46 -0300429 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300430 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 default:
Michael Krufky4adad282007-08-27 21:59:08 -0300432 attach_simple_tuner(t);
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)) {
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300438 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
439 sizeof(t->i2c->name));
Michael Krufkye18f9442007-08-21 01:25:48 -0300440
Michael Krufky4e9154b2007-10-21 19:39:50 -0300441 t->fe.analog_demod_priv = t;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300442 memcpy(analog_ops, &tuner_core_ops,
443 sizeof(struct analog_demod_ops));
Michael Krufkya55db8c2007-12-09 13:52:51 -0300444 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300445 strlcpy(t->i2c->name, analog_ops->info.name,
Michael Krufkya55db8c2007-12-09 13:52:51 -0300446 sizeof(t->i2c->name));
Michael Krufkye18f9442007-08-21 01:25:48 -0300447 }
448
Michael Krufky49427442007-10-30 09:44:12 -0300449 tuner_dbg("type set to %s\n", t->i2c->name);
Michael Krufkye18f9442007-08-21 01:25:48 -0300450
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700451 if (t->mode_mask == T_UNINITIALIZED)
452 t->mode_mask = new_mode_mask;
453
Hans Verkuil27487d42006-01-15 15:04:52 -0200454 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700455 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100456 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700457 t->mode_mask);
Michael Krufky293197c2007-08-28 17:20:42 -0300458 tuner_i2c_address_check(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
460
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700461/*
462 * This function apply tuner config to tuner specified
463 * by tun_setup structure. I addr is unset, then admin status
464 * and tun addr status is more precise then current status,
465 * it's applied. Otherwise status and type are applied only to
466 * tuner with exactly the same addr.
467*/
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700468
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700469static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700470{
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700471 struct tuner *t = i2c_get_clientdata(c);
472
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300473 tuner_dbg("set addr for type %i\n", t->type);
474
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300475 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
476 (t->mode_mask & tun_setup->mode_mask))) ||
477 (tun_setup->addr == c->addr)) {
478 set_type(c, tun_setup->type, tun_setup->mode_mask,
Hartmut Hackmanncfeb8832007-04-27 12:31:17 -0300479 tun_setup->config, tun_setup->tuner_callback);
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700480 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700481}
482
483static inline int check_mode(struct tuner *t, char *cmd)
484{
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700485 if ((1 << t->mode & t->mode_mask) == 0) {
486 return EINVAL;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700487 }
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700488
489 switch (t->mode) {
490 case V4L2_TUNER_RADIO:
491 tuner_dbg("Cmd %s accepted for radio\n", cmd);
492 break;
493 case V4L2_TUNER_ANALOG_TV:
494 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
495 break;
496 case V4L2_TUNER_DIGITAL_TV:
497 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
498 break;
499 }
500 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700501}
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700502
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700503/* get more precise norm info from insmod option */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504static int tuner_fixup_std(struct tuner *t)
505{
506 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 switch (pal[0]) {
Hans Verkuile71ced12006-12-11 15:51:43 -0300508 case '6':
509 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
510 t->std = V4L2_STD_PAL_60;
511 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 case 'b':
513 case 'B':
514 case 'g':
515 case 'G':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700516 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 t->std = V4L2_STD_PAL_BG;
518 break;
519 case 'i':
520 case 'I':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700521 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 t->std = V4L2_STD_PAL_I;
523 break;
524 case 'd':
525 case 'D':
526 case 'k':
527 case 'K':
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700528 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 t->std = V4L2_STD_PAL_DK;
530 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700531 case 'M':
532 case 'm':
533 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
534 t->std = V4L2_STD_PAL_M;
535 break;
536 case 'N':
537 case 'n':
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200538 if (pal[1] == 'c' || pal[1] == 'C') {
539 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
540 t->std = V4L2_STD_PAL_Nc;
541 } else {
542 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
543 t->std = V4L2_STD_PAL_N;
544 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700545 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700546 case '-':
547 /* default parameter, do nothing */
548 break;
549 default:
550 tuner_warn ("pal= argument not recognised\n");
551 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 }
553 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700554 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
555 switch (secam[0]) {
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200556 case 'b':
557 case 'B':
558 case 'g':
559 case 'G':
560 case 'h':
561 case 'H':
562 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
563 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
564 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700565 case 'd':
566 case 'D':
567 case 'k':
568 case 'K':
569 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
570 t->std = V4L2_STD_SECAM_DK;
571 break;
572 case 'l':
573 case 'L':
Mauro Carvalho Chehab800d3c62005-11-13 16:07:48 -0800574 if ((secam[1]=='C')||(secam[1]=='c')) {
575 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
576 t->std = V4L2_STD_SECAM_LC;
577 } else {
578 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
579 t->std = V4L2_STD_SECAM_L;
580 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700581 break;
Mauro Carvalho Chehab21d4df32005-09-09 13:03:59 -0700582 case '-':
583 /* default parameter, do nothing */
584 break;
585 default:
586 tuner_warn ("secam= argument not recognised\n");
587 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700588 }
589 }
590
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200591 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
592 switch (ntsc[0]) {
593 case 'm':
594 case 'M':
595 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
596 t->std = V4L2_STD_NTSC_M;
597 break;
598 case 'j':
599 case 'J':
600 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
601 t->std = V4L2_STD_NTSC_M_JP;
602 break;
Hans Verkuild97a11e2006-02-07 06:48:40 -0200603 case 'k':
604 case 'K':
605 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
606 t->std = V4L2_STD_NTSC_M_KR;
607 break;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200608 case '-':
609 /* default parameter, do nothing */
610 break;
611 default:
612 tuner_info("ntsc= argument not recognised\n");
613 break;
614 }
615 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 return 0;
617}
618
Michael Krufky4e9154b2007-10-21 19:39:50 -0300619static void tuner_status(struct dvb_frontend *fe)
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200620{
Michael Krufky4e9154b2007-10-21 19:39:50 -0300621 struct tuner *t = fe->analog_demod_priv;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200622 unsigned long freq, freq_fraction;
Michael Krufkye18f9442007-08-21 01:25:48 -0300623 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300624 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200625 const char *p;
626
627 switch (t->mode) {
628 case V4L2_TUNER_RADIO: p = "radio"; break;
629 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
630 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
631 default: p = "undefined"; break;
632 }
633 if (t->mode == V4L2_TUNER_RADIO) {
Hans Verkuil27487d42006-01-15 15:04:52 -0200634 freq = t->radio_freq / 16000;
635 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200636 } else {
Hans Verkuil27487d42006-01-15 15:04:52 -0200637 freq = t->tv_freq / 16;
638 freq_fraction = (t->tv_freq % 16) * 100 / 16;
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200639 }
640 tuner_info("Tuner mode: %s\n", p);
641 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
Mauro Carvalho Chehab4ae5c2e2006-03-25 15:53:38 -0300642 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200643 if (t->mode != V4L2_TUNER_RADIO)
644 return;
Michael Krufkye18f9442007-08-21 01:25:48 -0300645 if (fe_tuner_ops->get_status) {
646 u32 tuner_status;
647
648 fe_tuner_ops->get_status(&t->fe, &tuner_status);
649 if (tuner_status & TUNER_STATUS_LOCKED)
650 tuner_info("Tuner is locked.\n");
651 if (tuner_status & TUNER_STATUS_STEREO)
652 tuner_info("Stereo: yes\n");
653 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300654 if (analog_ops->has_signal)
655 tuner_info("Signal strength: %d\n",
656 analog_ops->has_signal(fe));
657 if (analog_ops->is_stereo)
658 tuner_info("Stereo: %s\n",
659 analog_ops->is_stereo(fe) ? "yes" : "no");
Mauro Carvalho Chehab7e578192006-01-09 15:25:27 -0200660}
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662/* ---------------------------------------------------------------------- */
663
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700664/*
665 * Switch tuner to other mode. If tuner support both tv and radio,
666 * set another frequency to some value (This is needed for some pal
667 * tuners to avoid locking). Otherwise, just put second tuner in
668 * standby mode.
669 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700671static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
672{
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300673 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Michael Krufky1dde7a42007-10-21 13:40:56 -0300674
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800675 if (mode == t->mode)
676 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700677
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800678 t->mode = mode;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700679
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800680 if (check_mode(t, cmd) == EINVAL) {
681 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300682 if (analog_ops->standby)
683 analog_ops->standby(&t->fe);
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800684 return EINVAL;
685 }
686 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700687}
688
689#define switch_v4l2() if (!t->using_v4l2) \
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800690 tuner_dbg("switching to v4l2\n"); \
691 t->using_v4l2 = 1;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700692
693static inline int check_v4l2(struct tuner *t)
694{
Hans Verkuil3bbe5a82006-04-01 15:27:52 -0300695 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
696 TV, v4l1 for radio), until that is fixed this code is disabled.
697 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
698 first. */
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700699 return 0;
700}
701
702static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
704 struct tuner *t = i2c_get_clientdata(client);
Michael Krufkye18f9442007-08-21 01:25:48 -0300705 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300706 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Hans Verkuilf9195de2006-01-11 19:01:01 -0200708 if (tuner_debug>1)
Hans Verkuil1cba97d72007-09-14 05:13:54 -0300709 v4l_i2c_print_ioctl(client,cmd);
Michael Krufky5e453dc2006-01-09 15:32:31 -0200710
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700711 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 /* --- configuration --- */
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700713 case TUNER_SET_TYPE_ADDR:
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300714 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700715 ((struct tuner_setup *)arg)->type,
716 ((struct tuner_setup *)arg)->addr,
Hartmut Hackmannde956c12007-04-27 12:31:12 -0300717 ((struct tuner_setup *)arg)->mode_mask,
718 ((struct tuner_setup *)arg)->config);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700719
720 set_addr(client, (struct tuner_setup *)arg);
Mauro Carvalho Chehab391cd722005-06-23 22:02:43 -0700721 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 case AUDC_SET_RADIO:
Hans Verkuil27487d42006-01-15 15:04:52 -0200723 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
724 == EINVAL)
725 return 0;
726 if (t->radio_freq)
727 set_freq(client, t->radio_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 break;
Mauro Carvalho Chehab793cf9e2005-09-09 13:03:37 -0700729 case TUNER_SET_STANDBY:
Hans Verkuil27487d42006-01-15 15:04:52 -0200730 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
731 return 0;
Mauro Carvalho Chehab15396232006-06-23 16:13:56 -0300732 t->mode = T_STANDBY;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300733 if (analog_ops->standby)
734 analog_ops->standby(&t->fe);
Hans Verkuil27487d42006-01-15 15:04:52 -0200735 break;
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300736#ifdef CONFIG_VIDEO_V4L1
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700737 case VIDIOCSAUDIO:
738 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
739 return 0;
740 if (check_v4l2(t) == EINVAL)
741 return 0;
742
743 /* Should be implemented, since bttv calls it */
744 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
Mauro Carvalho Chehabfd3113e2005-07-31 22:34:43 -0700745 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 case VIDIOCSCHAN:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700747 {
748 static const v4l2_std_id map[] = {
749 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
750 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
751 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
752 [4 /* bttv */ ] = V4L2_STD_PAL_M,
753 [5 /* bttv */ ] = V4L2_STD_PAL_N,
754 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
755 };
756 struct video_channel *vc = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700758 if (check_v4l2(t) == EINVAL)
759 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700760
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700761 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
762 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700764 if (vc->norm < ARRAY_SIZE(map))
765 t->std = map[vc->norm];
766 tuner_fixup_std(t);
Hans Verkuil27487d42006-01-15 15:04:52 -0200767 if (t->tv_freq)
768 set_tv_freq(client, t->tv_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700769 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700770 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700771 case VIDIOCSFREQ:
772 {
773 unsigned long *v = arg;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700774
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700775 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
776 return 0;
777 if (check_v4l2(t) == EINVAL)
778 return 0;
779
780 set_freq(client, *v);
781 return 0;
782 }
783 case VIDIOCGTUNER:
784 {
785 struct video_tuner *vt = arg;
786
787 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
788 return 0;
789 if (check_v4l2(t) == EINVAL)
790 return 0;
791
792 if (V4L2_TUNER_RADIO == t->mode) {
Michael Krufkye18f9442007-08-21 01:25:48 -0300793 if (fe_tuner_ops->get_status) {
794 u32 tuner_status;
795
796 fe_tuner_ops->get_status(&t->fe, &tuner_status);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300797 if (tuner_status & TUNER_STATUS_STEREO)
798 vt->flags |= VIDEO_TUNER_STEREO_ON;
799 else
800 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
Michael Krufkye18f9442007-08-21 01:25:48 -0300801 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300802 if (analog_ops->is_stereo) {
803 if (analog_ops->is_stereo(&t->fe))
Michael Krufkye18f9442007-08-21 01:25:48 -0300804 vt->flags |=
805 VIDEO_TUNER_STEREO_ON;
806 else
807 vt->flags &=
808 ~VIDEO_TUNER_STEREO_ON;
809 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700810 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300811 if (analog_ops->has_signal)
812 vt->signal =
813 analog_ops->has_signal(&t->fe);
Michael Krufky1f5ef192007-08-31 17:38:02 -0300814
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700815 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
816
817 vt->rangelow = radio_range[0] * 16000;
818 vt->rangehigh = radio_range[1] * 16000;
819
820 } else {
821 vt->rangelow = tv_range[0] * 16;
822 vt->rangehigh = tv_range[1] * 16;
823 }
824
825 return 0;
826 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 case VIDIOCGAUDIO:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700828 {
829 struct video_audio *va = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700831 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
832 return 0;
833 if (check_v4l2(t) == EINVAL)
834 return 0;
835
Michael Krufkye18f9442007-08-21 01:25:48 -0300836 if (V4L2_TUNER_RADIO == t->mode) {
837 if (fe_tuner_ops->get_status) {
838 u32 tuner_status;
839
840 fe_tuner_ops->get_status(&t->fe, &tuner_status);
841 va->mode = (tuner_status & TUNER_STATUS_STEREO)
842 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300843 } else if (analog_ops->is_stereo)
844 va->mode = analog_ops->is_stereo(&t->fe)
Michael Krufkye18f9442007-08-21 01:25:48 -0300845 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
846 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700847 return 0;
848 }
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300849#endif
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300850 case TUNER_SET_CONFIG:
851 {
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300852 struct v4l2_priv_tun_config *cfg = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300854 if (t->type != cfg->tuner)
855 break;
856
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300857 if (analog_ops->set_config) {
Michael Krufky67d52e22007-12-24 16:05:39 -0300858 analog_ops->set_config(&t->fe, cfg->priv);
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300859 break;
860 }
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300861
Michael Krufky67d52e22007-12-24 16:05:39 -0300862 tuner_dbg("Tuner frontend module has no way to set config\n");
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300863 break;
Mauro Carvalho Chehab7f171122007-10-18 19:56:47 -0300864 }
Mauro Carvalho Chehab985bc962006-07-23 06:31:19 -0300865 /* --- v4l ioctls --- */
866 /* take care: bttv does userspace copying, we'll get a
867 kernel pointer here... */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 case VIDIOC_S_STD:
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700869 {
870 v4l2_std_id *id = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700872 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
873 == EINVAL)
874 return 0;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700875
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700876 switch_v4l2();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700878 t->std = *id;
879 tuner_fixup_std(t);
Hans Verkuil27487d42006-01-15 15:04:52 -0200880 if (t->tv_freq)
881 set_freq(client, t->tv_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700882 break;
Mauro Carvalho Chehab56fc08c2005-06-23 22:05:07 -0700883 }
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700884 case VIDIOC_S_FREQUENCY:
885 {
886 struct v4l2_frequency *f = arg;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700887
Hans Verkuil4f725cb2006-06-24 09:47:56 -0300888 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
889 == EINVAL)
890 return 0;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700891 switch_v4l2();
Hans Verkuil27487d42006-01-15 15:04:52 -0200892 set_freq(client,f->frequency);
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700893
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700894 break;
895 }
896 case VIDIOC_G_FREQUENCY:
897 {
898 struct v4l2_frequency *f = arg;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700899
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700900 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
901 return 0;
902 switch_v4l2();
903 f->type = t->mode;
Michael Krufkye18f9442007-08-21 01:25:48 -0300904 if (fe_tuner_ops->get_frequency) {
905 u32 abs_freq;
906
907 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
908 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
909 (abs_freq * 2 + 125/2) / 125 :
910 (abs_freq + 62500/2) / 62500;
911 break;
912 }
Hans Verkuil27487d42006-01-15 15:04:52 -0200913 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
914 t->radio_freq : t->tv_freq;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700915 break;
916 }
917 case VIDIOC_G_TUNER:
918 {
919 struct v4l2_tuner *tuner = arg;
Mauro Carvalho Chehab586b0ca2005-06-28 20:45:21 -0700920
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700921 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
922 return 0;
923 switch_v4l2();
924
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200925 tuner->type = t->mode;
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300926 if (analog_ops->get_afc)
927 tuner->afc = analog_ops->get_afc(&t->fe);
Hans Verkuilab4cecf2006-04-01 16:40:21 -0300928 if (t->mode == V4L2_TUNER_ANALOG_TV)
929 tuner->capability |= V4L2_TUNER_CAP_NORM;
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200930 if (t->mode != V4L2_TUNER_RADIO) {
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700931 tuner->rangelow = tv_range[0] * 16;
932 tuner->rangehigh = tv_range[1] * 16;
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200933 break;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700934 }
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200935
936 /* radio mode */
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200937 tuner->rxsubchans =
938 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
Michael Krufkye18f9442007-08-21 01:25:48 -0300939 if (fe_tuner_ops->get_status) {
940 u32 tuner_status;
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200941
Michael Krufkye18f9442007-08-21 01:25:48 -0300942 fe_tuner_ops->get_status(&t->fe, &tuner_status);
Michael Krufky4e9154b2007-10-21 19:39:50 -0300943 tuner->rxsubchans =
944 (tuner_status & TUNER_STATUS_STEREO) ?
945 V4L2_TUNER_SUB_STEREO :
946 V4L2_TUNER_SUB_MONO;
Michael Krufkye18f9442007-08-21 01:25:48 -0300947 } else {
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300948 if (analog_ops->is_stereo) {
Michael Krufky4e9154b2007-10-21 19:39:50 -0300949 tuner->rxsubchans =
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300950 analog_ops->is_stereo(&t->fe) ?
Michael Krufky4e9154b2007-10-21 19:39:50 -0300951 V4L2_TUNER_SUB_STEREO :
952 V4L2_TUNER_SUB_MONO;
Michael Krufkye18f9442007-08-21 01:25:48 -0300953 }
Michael Krufkye18f9442007-08-21 01:25:48 -0300954 }
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300955 if (analog_ops->has_signal)
956 tuner->signal = analog_ops->has_signal(&t->fe);
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200957 tuner->capability |=
958 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
959 tuner->audmode = t->audmode;
960 tuner->rangelow = radio_range[0] * 16000;
961 tuner->rangehigh = radio_range[1] * 16000;
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700962 break;
963 }
964 case VIDIOC_S_TUNER:
965 {
966 struct v4l2_tuner *tuner = arg;
967
968 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
969 return 0;
970
971 switch_v4l2();
972
Hans Verkuil8a4b2752006-01-23 17:11:09 -0200973 /* do nothing unless we're a radio tuner */
974 if (t->mode != V4L2_TUNER_RADIO)
975 break;
976 t->audmode = tuner->audmode;
977 set_radio_freq(client, t->radio_freq);
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -0700978 break;
979 }
Hans Verkuilcd43c3f2006-01-09 15:25:15 -0200980 case VIDIOC_LOG_STATUS:
Michael Krufkybc3e5c72007-12-21 11:18:32 -0300981 if (analog_ops->tuner_status)
982 analog_ops->tuner_status(&t->fe);
Hans Verkuilcd43c3f2006-01-09 15:25:15 -0200983 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985
986 return 0;
987}
988
Jean Delvare21b48a72007-03-12 19:20:15 -0300989static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990{
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300991 struct tuner *t = i2c_get_clientdata(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
Hans Verkuil9dd659d2007-11-04 11:03:36 -0300993 tuner_dbg("suspend\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 /* FIXME: power down ??? */
995 return 0;
996}
997
Jean Delvare21b48a72007-03-12 19:20:15 -0300998static int tuner_resume(struct i2c_client *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999{
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001000 struct tuner *t = i2c_get_clientdata(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001002 tuner_dbg("resume\n");
Hans Verkuil27487d42006-01-15 15:04:52 -02001003 if (V4L2_TUNER_RADIO == t->mode) {
1004 if (t->radio_freq)
1005 set_freq(c, t->radio_freq);
1006 } else {
1007 if (t->tv_freq)
1008 set_freq(c, t->tv_freq);
1009 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 return 0;
1011}
1012
Hans Verkuil92de1f12007-11-04 10:53:09 -03001013/* ---------------------------------------------------------------------- */
1014
1015LIST_HEAD(tuner_list);
1016
1017/* Search for existing radio and/or TV tuners on the given I2C adapter.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001018 Note that when this function is called from tuner_probe you can be
Hans Verkuil92de1f12007-11-04 10:53:09 -03001019 certain no other devices will be added/deleted at the same time, I2C
1020 core protects against that. */
1021static void tuner_lookup(struct i2c_adapter *adap,
1022 struct tuner **radio, struct tuner **tv)
1023{
1024 struct tuner *pos;
1025
1026 *radio = NULL;
1027 *tv = NULL;
1028
1029 list_for_each_entry(pos, &tuner_list, list) {
1030 int mode_mask;
1031
1032 if (pos->i2c->adapter != adap ||
1033 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1034 continue;
1035
1036 mode_mask = pos->mode_mask & ~T_STANDBY;
1037 if (*radio == NULL && mode_mask == T_RADIO)
1038 *radio = pos;
1039 /* Note: currently TDA9887 is the only demod-only
1040 device. If other devices appear then we need to
1041 make this test more general. */
1042 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1043 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1044 *tv = pos;
1045 }
1046}
1047
1048/* During client attach, set_type is called by adapter's attach_inform callback.
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001049 set_type must then be completed by tuner_probe.
Hans Verkuil92de1f12007-11-04 10:53:09 -03001050 */
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001051static int tuner_probe(struct i2c_client *client)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001052{
Hans Verkuil92de1f12007-11-04 10:53:09 -03001053 struct tuner *t;
1054 struct tuner *radio;
1055 struct tuner *tv;
1056
Hans Verkuil92de1f12007-11-04 10:53:09 -03001057 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001058 if (NULL == t)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001059 return -ENOMEM;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001060 t->i2c = client;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001061 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
Hans Verkuil92de1f12007-11-04 10:53:09 -03001062 i2c_set_clientdata(client, t);
1063 t->type = UNSET;
1064 t->audmode = V4L2_TUNER_MODE_STEREO;
1065 t->mode_mask = T_UNINITIALIZED;
1066
1067 if (show_i2c) {
1068 unsigned char buffer[16];
1069 int i, rc;
1070
1071 memset(buffer, 0, sizeof(buffer));
1072 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1073 tuner_info("I2C RECV = ");
1074 for (i = 0; i < rc; i++)
1075 printk(KERN_CONT "%02x ", buffer[i]);
1076 printk("\n");
1077 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001078 /* HACK: This test was added to avoid tuner to probe tda9840 and
Hans Verkuil92de1f12007-11-04 10:53:09 -03001079 tea6415c on the MXB card */
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001080 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1081 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001082 return -ENODEV;
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001083 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001084
1085 /* autodetection code based on the i2c addr */
1086 if (!no_autodetect) {
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001087 switch (client->addr) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001088 case 0x10:
1089 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1090 != EINVAL) {
1091 t->type = TUNER_TEA5761;
1092 t->mode_mask = T_RADIO;
1093 t->mode = T_STANDBY;
1094 /* Sets freq to FM range */
1095 t->radio_freq = 87.5 * 16000;
1096 tuner_lookup(t->i2c->adapter, &radio, &tv);
1097 if (tv)
1098 tv->mode_mask &= ~T_RADIO;
1099
1100 goto register_client;
1101 }
1102 break;
1103 case 0x42:
1104 case 0x43:
1105 case 0x4a:
1106 case 0x4b:
1107 /* If chip is not tda8290, don't register.
1108 since it can be tda9887*/
Michael Krufkyab166052007-12-09 02:26:48 -03001109 if (tda829x_probe(t->i2c->adapter,
1110 t->i2c->addr) == 0) {
Hans Verkuil92de1f12007-11-04 10:53:09 -03001111 tuner_dbg("tda829x detected\n");
1112 } else {
1113 /* Default is being tda9887 */
1114 t->type = TUNER_TDA9887;
1115 t->mode_mask = T_RADIO | T_ANALOG_TV |
1116 T_DIGITAL_TV;
1117 t->mode = T_STANDBY;
1118 goto register_client;
1119 }
1120 break;
1121 case 0x60:
1122 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1123 != EINVAL) {
1124 t->type = TUNER_TEA5767;
1125 t->mode_mask = T_RADIO;
1126 t->mode = T_STANDBY;
1127 /* Sets freq to FM range */
1128 t->radio_freq = 87.5 * 16000;
1129 tuner_lookup(t->i2c->adapter, &radio, &tv);
1130 if (tv)
1131 tv->mode_mask &= ~T_RADIO;
1132
1133 goto register_client;
1134 }
1135 break;
1136 }
1137 }
1138
1139 /* Initializes only the first TV tuner on this adapter. Why only the
1140 first? Because there are some devices (notably the ones with TI
1141 tuners) that have more than one i2c address for the *same* device.
1142 Experience shows that, except for just one case, the first
1143 address is the right one. The exception is a Russian tuner
1144 (ACORP_Y878F). So, the desired behavior is just to enable the
1145 first found TV tuner. */
1146 tuner_lookup(t->i2c->adapter, &radio, &tv);
1147 if (tv == NULL) {
1148 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1149 if (radio == NULL)
1150 t->mode_mask |= T_RADIO;
1151 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1152 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1153 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1154 }
1155
1156 /* Should be just before return */
1157register_client:
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001158 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1159 client->adapter->name);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001160
1161 /* Sets a default mode */
1162 if (t->mode_mask & T_ANALOG_TV) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001163 t->mode = V4L2_TUNER_ANALOG_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001164 } else if (t->mode_mask & T_RADIO) {
Michael Krufky864a6b82007-12-09 17:21:54 -03001165 t->mode = V4L2_TUNER_RADIO;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001166 } else {
Michael Krufky864a6b82007-12-09 17:21:54 -03001167 t->mode = V4L2_TUNER_DIGITAL_TV;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001168 }
Hans Verkuil92de1f12007-11-04 10:53:09 -03001169 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001170 list_add_tail(&t->list, &tuner_list);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001171 return 0;
1172}
1173
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001174static int tuner_legacy_probe(struct i2c_adapter *adap)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001175{
1176 if (0 != addr) {
1177 normal_i2c[0] = addr;
1178 normal_i2c[1] = I2C_CLIENT_END;
1179 }
1180
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001181 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1182 return 0;
1183
Hans Verkuil92de1f12007-11-04 10:53:09 -03001184 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1185 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1186 * and an RTC at 0x6f which can get corrupted if probed.
1187 */
1188 if ((adap->id == I2C_HW_B_CX2388x) ||
1189 (adap->id == I2C_HW_B_CX23885)) {
1190 unsigned int i = 0;
1191
1192 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1193 i += 2;
1194 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1195 ignore[i+0] = adap->nr;
1196 ignore[i+1] = 0x6b;
1197 ignore[i+2] = adap->nr;
1198 ignore[i+3] = 0x6f;
1199 ignore[i+4] = I2C_CLIENT_END;
1200 } else
1201 printk(KERN_WARNING "tuner: "
1202 "too many options specified "
1203 "in i2c probe ignore list!\n");
1204 }
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001205 return 1;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001206}
1207
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001208static int tuner_remove(struct i2c_client *client)
Hans Verkuil92de1f12007-11-04 10:53:09 -03001209{
1210 struct tuner *t = i2c_get_clientdata(client);
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001211 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Hans Verkuil92de1f12007-11-04 10:53:09 -03001212
Michael Krufkybc3e5c72007-12-21 11:18:32 -03001213 if (analog_ops->release)
1214 analog_ops->release(&t->fe);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001215
1216 list_del(&t->list);
1217 kfree(t);
Hans Verkuil92de1f12007-11-04 10:53:09 -03001218 return 0;
1219}
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221/* ----------------------------------------------------------------------- */
1222
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001223static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1224 .name = "tuner",
1225 .driverid = I2C_DRIVERID_TUNER,
Mauro Carvalho Chehabf7ce3cc2005-07-12 13:58:55 -07001226 .command = tuner_command,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001227 .probe = tuner_probe,
1228 .remove = tuner_remove,
Jean Delvare21b48a72007-03-12 19:20:15 -03001229 .suspend = tuner_suspend,
Hans Verkuil9dd659d2007-11-04 11:03:36 -03001230 .resume = tuner_resume,
1231 .legacy_probe = tuner_legacy_probe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232};
1233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234
1235/*
1236 * Overrides for Emacs so that we follow Linus's tabbing style.
1237 * ---------------------------------------------------------------------------
1238 * Local variables:
1239 * c-basic-offset: 8
1240 * End:
1241 */