tuner-core.c 31.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 *
 * i2c tv tuner chip device driver
 * core core, i.e. kernel interfaces, registering and so on
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/i2c.h>
#include <linux/types.h>
#include <linux/init.h>
18
#include <linux/videodev2.h>
L
Linus Torvalds 已提交
19
#include <media/tuner.h>
20
#include <media/tuner-types.h>
21
#include <media/v4l2-device.h>
22
#include <media/v4l2-ioctl.h>
23
#include <media/v4l2-i2c-drv.h>
24
#include "mt20xx.h"
25
#include "tda8290.h"
26
#include "tea5761.h"
27
#include "tea5767.h"
28
#include "tuner-xc2028.h"
29
#include "tuner-simple.h"
30
#include "tda9887.h"
31
#include "xc5000.h"
L
Linus Torvalds 已提交
32 33 34

#define UNSET (-1U)

35
#define PREFIX t->i2c->driver->driver.name
36

37
/** This macro allows us to probe dynamically, avoiding static links */
38
#ifdef CONFIG_MEDIA_ATTACH
39 40 41 42 43
#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
	int __r = -EINVAL; \
	typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
	if (__a) { \
		__r = (int) __a(ARGS); \
44
		symbol_put(FUNCTION); \
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
	} else { \
		printk(KERN_ERR "TUNER: Unable to find " \
				"symbol "#FUNCTION"()\n"); \
	} \
	__r; \
})

static void tuner_detach(struct dvb_frontend *fe)
{
	if (fe->ops.tuner_ops.release) {
		fe->ops.tuner_ops.release(fe);
		symbol_put_addr(fe->ops.tuner_ops.release);
	}
	if (fe->ops.analog_ops.release) {
		fe->ops.analog_ops.release(fe);
		symbol_put_addr(fe->ops.analog_ops.release);
	}
}
#else
#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
	FUNCTION(ARGS); \
})

static void tuner_detach(struct dvb_frontend *fe)
{
	if (fe->ops.tuner_ops.release)
		fe->ops.tuner_ops.release(fe);
	if (fe->ops.analog_ops.release)
		fe->ops.analog_ops.release(fe);
}
#endif

77 78 79 80
struct tuner {
	/* device */
	struct dvb_frontend fe;
	struct i2c_client   *i2c;
81
	struct v4l2_subdev  sd;
82 83 84 85 86 87 88 89 90 91 92 93 94 95
	struct list_head    list;
	unsigned int        using_v4l2:1;

	/* keep track of the current settings */
	v4l2_std_id         std;
	unsigned int        tv_freq;
	unsigned int        radio_freq;
	unsigned int        audmode;

	unsigned int        mode;
	unsigned int        mode_mask; /* Combination of allowable modes */

	unsigned int        type; /* chip type id */
	unsigned int        config;
96
	const char          *name;
97 98
};

99 100 101 102 103
static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
{
	return container_of(sd, struct tuner, sd);
}

L
Linus Torvalds 已提交
104 105

/* insmod options used at init time => read/only */
106 107 108
static unsigned int addr;
static unsigned int no_autodetect;
static unsigned int show_i2c;
109

L
Linus Torvalds 已提交
110
/* insmod options used at runtime => read/write */
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
static int tuner_debug;

#define tuner_warn(fmt, arg...) do {			\
	printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
	       i2c_adapter_id(t->i2c->adapter),		\
	       t->i2c->addr, ##arg);			\
	 } while (0)

#define tuner_info(fmt, arg...) do {			\
	printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,	\
	       i2c_adapter_id(t->i2c->adapter),		\
	       t->i2c->addr, ##arg);			\
	 } while (0)

#define tuner_err(fmt, arg...) do {			\
	printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,	\
	       i2c_adapter_id(t->i2c->adapter),		\
	       t->i2c->addr, ##arg);			\
	 } while (0)

#define tuner_dbg(fmt, arg...) do {				\
	if (tuner_debug)					\
		printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,	\
		       i2c_adapter_id(t->i2c->adapter),		\
		       t->i2c->addr, ##arg);			\
	 } while (0)

/* ------------------------------------------------------------------------ */
L
Linus Torvalds 已提交
139

M
Mauro Carvalho Chehab 已提交
140
static unsigned int tv_range[2] = { 44, 958 };
L
Linus Torvalds 已提交
141 142
static unsigned int radio_range[2] = { 65, 108 };

143 144 145 146
static char pal[] = "--";
static char secam[] = "--";
static char ntsc[] = "-";

147

148 149 150
module_param(addr, int, 0444);
module_param(no_autodetect, int, 0444);
module_param(show_i2c, int, 0444);
151
module_param_named(debug,tuner_debug, int, 0644);
152 153 154
module_param_string(pal, pal, sizeof(pal), 0644);
module_param_string(secam, secam, sizeof(secam), 0644);
module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
M
Mauro Carvalho Chehab 已提交
155
module_param_array(tv_range, int, NULL, 0644);
L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163
module_param_array(radio_range, int, NULL, 0644);

MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
MODULE_LICENSE("GPL");

/* ---------------------------------------------------------------------- */

164 165
static void fe_set_params(struct dvb_frontend *fe,
			  struct analog_parameters *params)
166
{
167 168
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
	struct tuner *t = fe->analog_demod_priv;
169 170 171 172 173

	if (NULL == fe_tuner_ops->set_analog_params) {
		tuner_warn("Tuner frontend module has no way to set freq\n");
		return;
	}
174
	fe_tuner_ops->set_analog_params(fe, params);
175 176
}

177
static void fe_standby(struct dvb_frontend *fe)
178
{
179
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
180 181

	if (fe_tuner_ops->sleep)
182
		fe_tuner_ops->sleep(fe);
183 184
}

185
static int fe_has_signal(struct dvb_frontend *fe)
186
{
187
	u16 strength = 0;
188

189 190
	if (fe->ops.tuner_ops.get_rf_strength)
		fe->ops.tuner_ops.get_rf_strength(fe, &strength);
191 192 193 194

	return strength;
}

195 196 197 198 199 200 201 202 203 204 205 206 207
static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
{
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
	struct tuner *t = fe->analog_demod_priv;

	if (fe_tuner_ops->set_config)
		return fe_tuner_ops->set_config(fe, priv_cfg);

	tuner_warn("Tuner frontend module has no way to set config\n");

	return 0;
}

208
static void tuner_status(struct dvb_frontend *fe);
209

210
static struct analog_demod_ops tuner_analog_ops = {
211
	.set_params     = fe_set_params,
212 213
	.standby        = fe_standby,
	.has_signal     = fe_has_signal,
214
	.set_config     = fe_set_config,
215 216 217
	.tuner_status   = tuner_status
};

218
/* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
L
Linus Torvalds 已提交
219 220
static void set_tv_freq(struct i2c_client *c, unsigned int freq)
{
221
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
222
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
L
Linus Torvalds 已提交
223

224 225 226 227 228 229
	struct analog_parameters params = {
		.mode      = t->mode,
		.audmode   = t->audmode,
		.std       = t->std
	};

L
Linus Torvalds 已提交
230
	if (t->type == UNSET) {
M
Mauro Carvalho Chehab 已提交
231
		tuner_warn ("tuner type not set\n");
L
Linus Torvalds 已提交
232 233
		return;
	}
234
	if (NULL == analog_ops->set_params) {
M
Mauro Carvalho Chehab 已提交
235
		tuner_warn ("Tuner has no way to set tv freq\n");
L
Linus Torvalds 已提交
236 237
		return;
	}
M
Mauro Carvalho Chehab 已提交
238 239 240 241
	if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
		tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
			   freq / 16, freq % 16 * 100 / 16, tv_range[0],
			   tv_range[1]);
242 243 244 245 246 247
		/* V4L2 spec: if the freq is not possible then the closest
		   possible value should be selected */
		if (freq < tv_range[0] * 16)
			freq = tv_range[0] * 16;
		else
			freq = tv_range[1] * 16;
L
Linus Torvalds 已提交
248
	}
249 250
	params.frequency = freq;

251
	analog_ops->set_params(&t->fe, &params);
L
Linus Torvalds 已提交
252 253 254 255
}

static void set_radio_freq(struct i2c_client *c, unsigned int freq)
{
256
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
257
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
L
Linus Torvalds 已提交
258

259 260 261 262 263 264
	struct analog_parameters params = {
		.mode      = t->mode,
		.audmode   = t->audmode,
		.std       = t->std
	};

L
Linus Torvalds 已提交
265
	if (t->type == UNSET) {
M
Mauro Carvalho Chehab 已提交
266
		tuner_warn ("tuner type not set\n");
L
Linus Torvalds 已提交
267 268
		return;
	}
269
	if (NULL == analog_ops->set_params) {
M
Mauro Carvalho Chehab 已提交
270
		tuner_warn ("tuner has no way to set radio frequency\n");
L
Linus Torvalds 已提交
271 272
		return;
	}
273
	if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
M
Mauro Carvalho Chehab 已提交
274 275 276
		tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
			   freq / 16000, freq % 16000 * 100 / 16000,
			   radio_range[0], radio_range[1]);
277 278 279 280 281 282
		/* V4L2 spec: if the freq is not possible then the closest
		   possible value should be selected */
		if (freq < radio_range[0] * 16000)
			freq = radio_range[0] * 16000;
		else
			freq = radio_range[1] * 16000;
L
Linus Torvalds 已提交
283
	}
284
	params.frequency = freq;
285

286
	analog_ops->set_params(&t->fe, &params);
L
Linus Torvalds 已提交
287 288 289 290
}

static void set_freq(struct i2c_client *c, unsigned long freq)
{
291
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
L
Linus Torvalds 已提交
292 293 294 295

	switch (t->mode) {
	case V4L2_TUNER_RADIO:
		tuner_dbg("radio freq set to %lu.%02lu\n",
M
Mauro Carvalho Chehab 已提交
296 297
			  freq / 16000, freq % 16000 * 100 / 16000);
		set_radio_freq(c, freq);
298
		t->radio_freq = freq;
L
Linus Torvalds 已提交
299 300 301 302
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		tuner_dbg("tv freq set to %lu.%02lu\n",
M
Mauro Carvalho Chehab 已提交
303
			  freq / 16, freq % 16 * 100 / 16);
L
Linus Torvalds 已提交
304
		set_tv_freq(c, freq);
305
		t->tv_freq = freq;
L
Linus Torvalds 已提交
306
		break;
307 308
	default:
		tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
L
Linus Torvalds 已提交
309 310 311
	}
}

312 313 314
static void tuner_i2c_address_check(struct tuner *t)
{
	if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
315
	    ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
316 317
		return;

318 319 320 321 322 323
	/* We already know that the XC5000 can only be located at
	 * i2c address 0x61, 0x62, 0x63 or 0x64 */
	if ((t->type == TUNER_XC5000) &&
	    ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
		return;

324 325 326 327
	tuner_warn("====================== WARNING! ======================\n");
	tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
	tuner_warn("will soon be dropped. This message indicates that your\n");
	tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
328
		   t->name, t->i2c->addr);
329 330 331 332 333
	tuner_warn("To ensure continued support for your device, please\n");
	tuner_warn("send a copy of this message, along with full dmesg\n");
	tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
	tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
	tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
334
		   t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
335 336 337
	tuner_warn("====================== WARNING! ======================\n");
}

338 339
static struct xc5000_config xc5000_cfg;

M
Mauro Carvalho Chehab 已提交
340
static void set_type(struct i2c_client *c, unsigned int type,
341
		     unsigned int new_mode_mask, unsigned int new_config,
342
		     int (*tuner_callback) (void *dev, int component, int cmd, int arg))
L
Linus Torvalds 已提交
343
{
344
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
345
	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
346
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
347
	unsigned char buffer[4];
L
Linus Torvalds 已提交
348

M
Mauro Carvalho Chehab 已提交
349 350
	if (type == UNSET || type == TUNER_ABSENT) {
		tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
L
Linus Torvalds 已提交
351
		return;
M
Mauro Carvalho Chehab 已提交
352 353
	}

354
	t->type = type;
355 356
	/* prevent invalid config values */
	t->config = ((new_config >= 0) && (new_config < 256)) ? new_config : 0;
357 358
	if (tuner_callback != NULL) {
		tuner_dbg("defining GPIO callback\n");
359
		t->fe.callback = tuner_callback;
360 361
	}

362
	if (t->mode == T_UNINITIALIZED) {
M
Mauro Carvalho Chehab 已提交
363 364
		tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);

L
Linus Torvalds 已提交
365 366
		return;
	}
367

368
	/* discard private data, in case set_type() was previously called */
369 370
	tuner_detach(&t->fe);
	t->fe.analog_demod_priv = NULL;
371

L
Linus Torvalds 已提交
372 373
	switch (t->type) {
	case TUNER_MT2032:
374 375 376
		if (!dvb_attach(microtune_attach,
			   &t->fe, t->i2c->adapter, t->i2c->addr))
			goto attach_failed;
L
Linus Torvalds 已提交
377 378
		break;
	case TUNER_PHILIPS_TDA8290:
379
	{
380 381 382 383 384 385
		struct tda829x_config cfg = {
			.lna_cfg        = t->config,
		};
		if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
				t->i2c->addr, &cfg))
			goto attach_failed;
386 387
		break;
	}
388
	case TUNER_TEA5767:
389 390
		if (!dvb_attach(tea5767_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr))
391
			goto attach_failed;
M
Mauro Carvalho Chehab 已提交
392
		t->mode_mask = T_RADIO;
393
		break;
394
	case TUNER_TEA5761:
395 396
		if (!dvb_attach(tea5761_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr))
397
			goto attach_failed;
398 399
		t->mode_mask = T_RADIO;
		break;
400 401 402 403 404
	case TUNER_PHILIPS_FMD1216ME_MK3:
		buffer[0] = 0x0b;
		buffer[1] = 0xdc;
		buffer[2] = 0x9c;
		buffer[3] = 0x60;
M
Mauro Carvalho Chehab 已提交
405
		i2c_master_send(c, buffer, 4);
406 407 408
		mdelay(1);
		buffer[2] = 0x86;
		buffer[3] = 0x54;
M
Mauro Carvalho Chehab 已提交
409
		i2c_master_send(c, buffer, 4);
410 411
		if (!dvb_attach(simple_tuner_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr, t->type))
412
			goto attach_failed;
413
		break;
414 415 416 417 418
	case TUNER_PHILIPS_TD1316:
		buffer[0] = 0x0b;
		buffer[1] = 0xdc;
		buffer[2] = 0x86;
		buffer[3] = 0xa4;
419 420 421
		i2c_master_send(c, buffer, 4);
		if (!dvb_attach(simple_tuner_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr, t->type))
422
			goto attach_failed;
423
		break;
424 425
	case TUNER_XC2028:
	{
426 427 428 429
		struct xc2028_config cfg = {
			.i2c_adap  = t->i2c->adapter,
			.i2c_addr  = t->i2c->addr,
		};
430
		if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
431
			goto attach_failed;
432 433
		break;
	}
434
	case TUNER_TDA9887:
435 436 437
		if (!dvb_attach(tda9887_attach,
			   &t->fe, t->i2c->adapter, t->i2c->addr))
			goto attach_failed;
438
		break;
439
	case TUNER_XC5000:
440 441 442
	{
		struct dvb_tuner_ops *xc_tuner_ops;

443
		xc5000_cfg.i2c_address	  = t->i2c->addr;
444 445
		/* if_khz will be set when the digital dvb_attach() occurs */
		xc5000_cfg.if_khz	  = 0;
446
		if (!dvb_attach(xc5000_attach,
447
				&t->fe, t->i2c->adapter, &xc5000_cfg))
448 449
			goto attach_failed;

450
		xc_tuner_ops = &t->fe.ops.tuner_ops;
451
		if (xc_tuner_ops->init)
452 453
			xc_tuner_ops->init(&t->fe);
		break;
454
	}
L
Linus Torvalds 已提交
455
	default:
456 457
		if (!dvb_attach(simple_tuner_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr, t->type))
458 459
			goto attach_failed;

L
Linus Torvalds 已提交
460 461
		break;
	}
M
Mauro Carvalho Chehab 已提交
462

463
	if ((NULL == analog_ops->set_params) &&
464
	    (fe_tuner_ops->set_analog_params)) {
465

466
		t->name = fe_tuner_ops->info.name;
467

468
		t->fe.analog_demod_priv = t;
469
		memcpy(analog_ops, &tuner_analog_ops,
470
		       sizeof(struct analog_demod_ops));
471

472
	} else {
473
		t->name = analog_ops->info.name;
474 475
	}

476
	tuner_dbg("type set to %s\n", t->name);
477

M
Mauro Carvalho Chehab 已提交
478 479 480
	if (t->mode_mask == T_UNINITIALIZED)
		t->mode_mask = new_mode_mask;

481 482 483 484 485 486 487 488 489
	/* xc2028/3028 and xc5000 requires a firmware to be set-up later
	   trying to set a frequency here will just fail
	   FIXME: better to move set_freq to the tuner code. This is needed
	   on analog tuners for PLL to properly work
	 */
	if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
		set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
			    t->radio_freq : t->tv_freq);

M
Mauro Carvalho Chehab 已提交
490
	tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
491
		  c->adapter->name, c->driver->driver.name, c->addr << 1, type,
M
Mauro Carvalho Chehab 已提交
492
		  t->mode_mask);
493
	tuner_i2c_address_check(t);
494 495 496 497 498 499 500 501
	return;

attach_failed:
	tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
	t->type = TUNER_ABSENT;
	t->mode_mask = T_UNINITIALIZED;

	return;
L
Linus Torvalds 已提交
502 503
}

M
Mauro Carvalho Chehab 已提交
504 505 506 507 508 509 510 511 512 513
/*
 * This function apply tuner config to tuner specified
 * by tun_setup structure. I addr is unset, then admin status
 * and tun addr status is more precise then current status,
 * it's applied. Otherwise status and type are applied only to
 * tuner with exactly the same addr.
*/

static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
{
514
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
M
Mauro Carvalho Chehab 已提交
515

516 517 518 519
	if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
		(t->mode_mask & tun_setup->mode_mask))) ||
		(tun_setup->addr == c->addr)) {
			set_type(c, tun_setup->type, tun_setup->mode_mask,
520
				 tun_setup->config, tun_setup->tuner_callback);
521 522 523 524 525
	} else
		tuner_dbg("set addr discarded for type %i, mask %x. "
			  "Asked to change tuner at addr 0x%02x, with mask %x\n",
			  t->type, t->mode_mask,
			  tun_setup->addr, tun_setup->mode_mask);
M
Mauro Carvalho Chehab 已提交
526
}
527

M
Mauro Carvalho Chehab 已提交
528
static inline int check_mode(struct tuner *t, char *cmd)
529
{
530
	if ((1 << t->mode & t->mode_mask) == 0) {
531
		return -EINVAL;
532 533 534 535 536 537 538 539 540 541 542 543
	}

	switch (t->mode) {
	case V4L2_TUNER_RADIO:
		tuner_dbg("Cmd %s accepted for radio\n", cmd);
		break;
	case V4L2_TUNER_ANALOG_TV:
		tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
		break;
	case V4L2_TUNER_DIGITAL_TV:
		tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
		break;
544
	}
545
	return 0;
546 547
}

M
Mauro Carvalho Chehab 已提交
548
/* get more precise norm info from insmod option */
L
Linus Torvalds 已提交
549 550 551 552
static int tuner_fixup_std(struct tuner *t)
{
	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
		switch (pal[0]) {
553 554 555 556
		case '6':
			tuner_dbg ("insmod fixup: PAL => PAL-60\n");
			t->std = V4L2_STD_PAL_60;
			break;
L
Linus Torvalds 已提交
557 558 559 560
		case 'b':
		case 'B':
		case 'g':
		case 'G':
M
Mauro Carvalho Chehab 已提交
561
			tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
L
Linus Torvalds 已提交
562 563 564 565
			t->std = V4L2_STD_PAL_BG;
			break;
		case 'i':
		case 'I':
M
Mauro Carvalho Chehab 已提交
566
			tuner_dbg ("insmod fixup: PAL => PAL-I\n");
L
Linus Torvalds 已提交
567 568 569 570 571 572
			t->std = V4L2_STD_PAL_I;
			break;
		case 'd':
		case 'D':
		case 'k':
		case 'K':
M
Mauro Carvalho Chehab 已提交
573
			tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
L
Linus Torvalds 已提交
574 575
			t->std = V4L2_STD_PAL_DK;
			break;
M
Mauro Carvalho Chehab 已提交
576 577 578 579 580 581 582
		case 'M':
		case 'm':
			tuner_dbg ("insmod fixup: PAL => PAL-M\n");
			t->std = V4L2_STD_PAL_M;
			break;
		case 'N':
		case 'n':
583 584 585 586 587 588 589
			if (pal[1] == 'c' || pal[1] == 'C') {
				tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
				t->std = V4L2_STD_PAL_Nc;
			} else {
				tuner_dbg ("insmod fixup: PAL => PAL-N\n");
				t->std = V4L2_STD_PAL_N;
			}
M
Mauro Carvalho Chehab 已提交
590
			break;
591 592 593 594 595 596
		case '-':
			/* default parameter, do nothing */
			break;
		default:
			tuner_warn ("pal= argument not recognised\n");
			break;
L
Linus Torvalds 已提交
597 598
		}
	}
M
Mauro Carvalho Chehab 已提交
599 600
	if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
		switch (secam[0]) {
601 602 603 604 605 606 607 608 609
		case 'b':
		case 'B':
		case 'g':
		case 'G':
		case 'h':
		case 'H':
			tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
			t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
			break;
M
Mauro Carvalho Chehab 已提交
610 611 612 613 614 615 616 617 618
		case 'd':
		case 'D':
		case 'k':
		case 'K':
			tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
			t->std = V4L2_STD_SECAM_DK;
			break;
		case 'l':
		case 'L':
619 620 621 622 623 624 625
			if ((secam[1]=='C')||(secam[1]=='c')) {
				tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
				t->std = V4L2_STD_SECAM_LC;
			} else {
				tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
				t->std = V4L2_STD_SECAM_L;
			}
M
Mauro Carvalho Chehab 已提交
626
			break;
627 628 629 630 631 632
		case '-':
			/* default parameter, do nothing */
			break;
		default:
			tuner_warn ("secam= argument not recognised\n");
			break;
M
Mauro Carvalho Chehab 已提交
633 634 635
		}
	}

636 637 638 639 640 641 642 643 644 645 646 647
	if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
		switch (ntsc[0]) {
		case 'm':
		case 'M':
			tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
			t->std = V4L2_STD_NTSC_M;
			break;
		case 'j':
		case 'J':
			tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
			t->std = V4L2_STD_NTSC_M_JP;
			break;
648 649 650 651 652
		case 'k':
		case 'K':
			tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
			t->std = V4L2_STD_NTSC_M_KR;
			break;
653 654 655 656 657 658 659 660
		case '-':
			/* default parameter, do nothing */
			break;
		default:
			tuner_info("ntsc= argument not recognised\n");
			break;
		}
	}
L
Linus Torvalds 已提交
661 662 663
	return 0;
}

664
static void tuner_status(struct dvb_frontend *fe)
665
{
666
	struct tuner *t = fe->analog_demod_priv;
667
	unsigned long freq, freq_fraction;
668 669
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
	struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
670 671 672 673 674 675 676 677 678
	const char *p;

	switch (t->mode) {
		case V4L2_TUNER_RADIO: 	    p = "radio"; break;
		case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
		case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
		default: p = "undefined"; break;
	}
	if (t->mode == V4L2_TUNER_RADIO) {
679 680
		freq = t->radio_freq / 16000;
		freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
681
	} else {
682 683
		freq = t->tv_freq / 16;
		freq_fraction = (t->tv_freq % 16) * 100 / 16;
684 685 686
	}
	tuner_info("Tuner mode:      %s\n", p);
	tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
687
	tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
688 689
	if (t->mode != V4L2_TUNER_RADIO)
	       return;
690 691 692 693 694 695 696 697 698
	if (fe_tuner_ops->get_status) {
		u32 tuner_status;

		fe_tuner_ops->get_status(&t->fe, &tuner_status);
		if (tuner_status & TUNER_STATUS_LOCKED)
			tuner_info("Tuner is locked.\n");
		if (tuner_status & TUNER_STATUS_STEREO)
			tuner_info("Stereo:          yes\n");
	}
699 700 701 702 703 704
	if (analog_ops->has_signal)
		tuner_info("Signal strength: %d\n",
			   analog_ops->has_signal(fe));
	if (analog_ops->is_stereo)
		tuner_info("Stereo:          %s\n",
			   analog_ops->is_stereo(fe) ? "yes" : "no");
705
}
706

L
Linus Torvalds 已提交
707 708
/* ---------------------------------------------------------------------- */

M
Mauro Carvalho Chehab 已提交
709 710 711 712 713 714 715 716 717
/*
 * Switch tuner to other mode. If tuner support both tv and radio,
 * set another frequency to some value (This is needed for some pal
 * tuners to avoid locking). Otherwise, just put second tuner in
 * standby mode.
 */

static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
{
718
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
719

720 721 722 723 724
	if (mode == t->mode)
		return 0;

	t->mode = mode;

725
	if (check_mode(t, cmd) == -EINVAL) {
726 727
		tuner_dbg("Tuner doesn't support this mode. "
			  "Putting tuner to sleep\n");
728
		t->mode = T_STANDBY;
729 730
		if (analog_ops->standby)
			analog_ops->standby(&t->fe);
731
		return -EINVAL;
732 733
	}
	return 0;
M
Mauro Carvalho Chehab 已提交
734 735 736
}

#define switch_v4l2()	if (!t->using_v4l2) \
737 738
			    tuner_dbg("switching to v4l2\n"); \
			t->using_v4l2 = 1;
M
Mauro Carvalho Chehab 已提交
739 740 741

static inline int check_v4l2(struct tuner *t)
{
742 743 744 745
	/* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
	   TV, v4l1 for radio), until that is fixed this code is disabled.
	   Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
	   first. */
M
Mauro Carvalho Chehab 已提交
746 747
	return 0;
}
L
Linus Torvalds 已提交
748

749
static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
L
Linus Torvalds 已提交
750
{
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
	struct tuner *t = to_tuner(sd);
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
			type->type,
			type->addr,
			type->mode_mask,
			type->config);

	set_addr(client, type);
	return 0;
}

static int tuner_s_radio(struct v4l2_subdev *sd)
{
	struct tuner *t = to_tuner(sd);
	struct i2c_client *client = v4l2_get_subdevdata(sd);

769
	if (set_mode(client, t, V4L2_TUNER_RADIO, "s_radio") == -EINVAL)
770 771 772 773 774 775
		return 0;
	if (t->radio_freq)
		set_freq(client, t->radio_freq);
	return 0;
}

776
static int tuner_s_standby(struct v4l2_subdev *sd)
777 778
{
	struct tuner *t = to_tuner(sd);
779
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
L
Linus Torvalds 已提交
780

781 782
	tuner_dbg("Putting tuner to sleep\n");

783
	if (check_mode(t, "s_standby") == -EINVAL)
784 785 786 787 788 789
		return 0;
	t->mode = T_STANDBY;
	if (analog_ops->standby)
		analog_ops->standby(&t->fe);
	return 0;
}
790

791 792 793 794
static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
{
	struct tuner *t = to_tuner(sd);
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
L
Linus Torvalds 已提交
795

796 797
	if (t->type != cfg->tuner)
		return 0;
798

799 800 801
	if (analog_ops->set_config) {
		analog_ops->set_config(&t->fe, cfg->priv);
		return 0;
802
	}
L
Linus Torvalds 已提交
803

804 805 806
	tuner_dbg("Tuner frontend module has no way to set config\n");
	return 0;
}
807

808 809 810 811 812 813 814
/* --- v4l ioctls --- */
/* take care: bttv does userspace copying, we'll get a
   kernel pointer here... */
static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
{
	struct tuner *t = to_tuner(sd);
	struct i2c_client *client = v4l2_get_subdevdata(sd);
M
Mauro Carvalho Chehab 已提交
815

816
	if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "s_std") == -EINVAL)
817
		return 0;
M
Mauro Carvalho Chehab 已提交
818

819
	switch_v4l2();
820

821 822 823 824 825 826
	t->std = std;
	tuner_fixup_std(t);
	if (t->tv_freq)
		set_freq(client, t->tv_freq);
	return 0;
}
M
Mauro Carvalho Chehab 已提交
827

828 829 830 831
static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
{
	struct tuner *t = to_tuner(sd);
	struct i2c_client *client = v4l2_get_subdevdata(sd);
M
Mauro Carvalho Chehab 已提交
832

833
	if (set_mode(client, t, f->type, "s_frequency") == -EINVAL)
834 835 836
		return 0;
	switch_v4l2();
	set_freq(client, f->frequency);
837

838 839
	return 0;
}
M
Mauro Carvalho Chehab 已提交
840

841 842 843 844
static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
{
	struct tuner *t = to_tuner(sd);
	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
M
Mauro Carvalho Chehab 已提交
845

846
	if (check_mode(t, "g_frequency") == -EINVAL)
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
		return 0;
	switch_v4l2();
	f->type = t->mode;
	if (fe_tuner_ops->get_frequency) {
		u32 abs_freq;

		fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
		f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
			(abs_freq * 2 + 125/2) / 125 :
			(abs_freq + 62500/2) / 62500;
		return 0;
	}
	f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
		t->radio_freq : t->tv_freq;
	return 0;
}
M
Mauro Carvalho Chehab 已提交
863

864 865 866 867 868 869
static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
{
	struct tuner *t = to_tuner(sd);
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;

870
	if (check_mode(t, "g_tuner") == -EINVAL)
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
		return 0;
	switch_v4l2();

	vt->type = t->mode;
	if (analog_ops->get_afc)
		vt->afc = analog_ops->get_afc(&t->fe);
	if (t->mode == V4L2_TUNER_ANALOG_TV)
		vt->capability |= V4L2_TUNER_CAP_NORM;
	if (t->mode != V4L2_TUNER_RADIO) {
		vt->rangelow = tv_range[0] * 16;
		vt->rangehigh = tv_range[1] * 16;
		return 0;
	}

	/* radio mode */
	vt->rxsubchans =
		V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
	if (fe_tuner_ops->get_status) {
		u32 tuner_status;

		fe_tuner_ops->get_status(&t->fe, &tuner_status);
		vt->rxsubchans =
			(tuner_status & TUNER_STATUS_STEREO) ?
			V4L2_TUNER_SUB_STEREO :
			V4L2_TUNER_SUB_MONO;
	} else {
		if (analog_ops->is_stereo) {
			vt->rxsubchans =
				analog_ops->is_stereo(&t->fe) ?
				V4L2_TUNER_SUB_STEREO :
				V4L2_TUNER_SUB_MONO;
902
		}
L
Linus Torvalds 已提交
903
	}
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918
	if (analog_ops->has_signal)
		vt->signal = analog_ops->has_signal(&t->fe);
	vt->capability |=
		V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
	vt->audmode = t->audmode;
	vt->rangelow = radio_range[0] * 16000;
	vt->rangehigh = radio_range[1] * 16000;
	return 0;
}

static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
{
	struct tuner *t = to_tuner(sd);
	struct i2c_client *client = v4l2_get_subdevdata(sd);

919
	if (check_mode(t, "s_tuner") == -EINVAL)
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
		return 0;

	switch_v4l2();

	/* do nothing unless we're a radio tuner */
	if (t->mode != V4L2_TUNER_RADIO)
		return 0;
	t->audmode = vt->audmode;
	set_radio_freq(client, t->radio_freq);
	return 0;
}

static int tuner_log_status(struct v4l2_subdev *sd)
{
	struct tuner *t = to_tuner(sd);
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
L
Linus Torvalds 已提交
936

937 938
	if (analog_ops->tuner_status)
		analog_ops->tuner_status(&t->fe);
L
Linus Torvalds 已提交
939 940 941
	return 0;
}

942
static int tuner_suspend(struct i2c_client *c, pm_message_t state)
L
Linus Torvalds 已提交
943
{
944
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
L
Linus Torvalds 已提交
945

946
	tuner_dbg("suspend\n");
L
Linus Torvalds 已提交
947 948 949 950
	/* FIXME: power down ??? */
	return 0;
}

951
static int tuner_resume(struct i2c_client *c)
L
Linus Torvalds 已提交
952
{
953
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
L
Linus Torvalds 已提交
954

955
	tuner_dbg("resume\n");
956 957 958 959 960 961 962
	if (V4L2_TUNER_RADIO == t->mode) {
		if (t->radio_freq)
			set_freq(c, t->radio_freq);
	} else {
		if (t->tv_freq)
			set_freq(c, t->tv_freq);
	}
L
Linus Torvalds 已提交
963 964 965
	return 0;
}

966 967 968 969 970 971 972 973 974 975 976 977 978 979
static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);

	/* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
	   to handle it here.
	   There must be a better way of doing this... */
	switch (cmd) {
	case TUNER_SET_CONFIG:
		return tuner_s_config(sd, arg);
	}
	return -ENOIOCTLCMD;
}

980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
/* ----------------------------------------------------------------------- */

static const struct v4l2_subdev_core_ops tuner_core_ops = {
	.log_status = tuner_log_status,
};

static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
	.s_std = tuner_s_std,
	.s_radio = tuner_s_radio,
	.g_tuner = tuner_g_tuner,
	.s_tuner = tuner_s_tuner,
	.s_frequency = tuner_s_frequency,
	.g_frequency = tuner_g_frequency,
	.s_type_addr = tuner_s_type_addr,
	.s_config = tuner_s_config,
995
	.s_standby = tuner_s_standby,
996 997 998 999 1000 1001 1002
};

static const struct v4l2_subdev_ops tuner_ops = {
	.core = &tuner_core_ops,
	.tuner = &tuner_tuner_ops,
};

1003 1004
/* ---------------------------------------------------------------------- */

1005
static LIST_HEAD(tuner_list);
1006 1007

/* Search for existing radio and/or TV tuners on the given I2C adapter.
1008
   Note that when this function is called from tuner_probe you can be
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
   certain no other devices will be added/deleted at the same time, I2C
   core protects against that. */
static void tuner_lookup(struct i2c_adapter *adap,
		struct tuner **radio, struct tuner **tv)
{
	struct tuner *pos;

	*radio = NULL;
	*tv = NULL;

	list_for_each_entry(pos, &tuner_list, list) {
		int mode_mask;

		if (pos->i2c->adapter != adap ||
		    pos->i2c->driver->id != I2C_DRIVERID_TUNER)
			continue;

		mode_mask = pos->mode_mask & ~T_STANDBY;
		if (*radio == NULL && mode_mask == T_RADIO)
			*radio = pos;
		/* Note: currently TDA9887 is the only demod-only
		   device. If other devices appear then we need to
		   make this test more general. */
		else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
			 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
			*tv = pos;
	}
}

/* During client attach, set_type is called by adapter's attach_inform callback.
1039
   set_type must then be completed by tuner_probe.
1040
 */
1041 1042
static int tuner_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
1043 1044 1045 1046 1047 1048
{
	struct tuner *t;
	struct tuner *radio;
	struct tuner *tv;

	t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1049
	if (NULL == t)
1050
		return -ENOMEM;
1051
	v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1052
	t->i2c = client;
1053
	t->name = "(tuner unset)";
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
	t->type = UNSET;
	t->audmode = V4L2_TUNER_MODE_STEREO;
	t->mode_mask = T_UNINITIALIZED;

	if (show_i2c) {
		unsigned char buffer[16];
		int i, rc;

		memset(buffer, 0, sizeof(buffer));
		rc = i2c_master_recv(client, buffer, sizeof(buffer));
		tuner_info("I2C RECV = ");
		for (i = 0; i < rc; i++)
			printk(KERN_CONT "%02x ", buffer[i]);
		printk("\n");
	}
1069
	/* HACK: This test was added to avoid tuner to probe tda9840 and
1070
	   tea6415c on the MXB card */
1071 1072
	if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
		kfree(t);
1073
		return -ENODEV;
1074
	}
1075 1076 1077

	/* autodetection code based on the i2c addr */
	if (!no_autodetect) {
1078
		switch (client->addr) {
1079
		case 0x10:
1080 1081 1082
			if (tuner_symbol_probe(tea5761_autodetection,
					       t->i2c->adapter,
					       t->i2c->addr) >= 0) {
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
				t->type = TUNER_TEA5761;
				t->mode_mask = T_RADIO;
				t->mode = T_STANDBY;
				/* Sets freq to FM range */
				t->radio_freq = 87.5 * 16000;
				tuner_lookup(t->i2c->adapter, &radio, &tv);
				if (tv)
					tv->mode_mask &= ~T_RADIO;

				goto register_client;
			}
1094
			return -ENODEV;
1095 1096 1097 1098 1099 1100
		case 0x42:
		case 0x43:
		case 0x4a:
		case 0x4b:
			/* If chip is not tda8290, don't register.
			   since it can be tda9887*/
1101
			if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1102
					       t->i2c->addr) >= 0) {
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
				tuner_dbg("tda829x detected\n");
			} else {
				/* Default is being tda9887 */
				t->type = TUNER_TDA9887;
				t->mode_mask = T_RADIO | T_ANALOG_TV |
					       T_DIGITAL_TV;
				t->mode = T_STANDBY;
				goto register_client;
			}
			break;
		case 0x60:
1114 1115
			if (tuner_symbol_probe(tea5767_autodetection,
					       t->i2c->adapter, t->i2c->addr)
1116
					>= 0) {
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
				t->type = TUNER_TEA5767;
				t->mode_mask = T_RADIO;
				t->mode = T_STANDBY;
				/* Sets freq to FM range */
				t->radio_freq = 87.5 * 16000;
				tuner_lookup(t->i2c->adapter, &radio, &tv);
				if (tv)
					tv->mode_mask &= ~T_RADIO;

				goto register_client;
			}
			break;
		}
	}

	/* Initializes only the first TV tuner on this adapter. Why only the
	   first? Because there are some devices (notably the ones with TI
	   tuners) that have more than one i2c address for the *same* device.
	   Experience shows that, except for just one case, the first
	   address is the right one. The exception is a Russian tuner
	   (ACORP_Y878F). So, the desired behavior is just to enable the
	   first found TV tuner. */
	tuner_lookup(t->i2c->adapter, &radio, &tv);
	if (tv == NULL) {
		t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
		if (radio == NULL)
			t->mode_mask |= T_RADIO;
		tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
		t->tv_freq = 400 * 16; /* Sets freq to VHF High */
		t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
	}

	/* Should be just before return */
register_client:
1151 1152
	tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
		       client->adapter->name);
1153 1154 1155

	/* Sets a default mode */
	if (t->mode_mask & T_ANALOG_TV) {
1156
		t->mode = V4L2_TUNER_ANALOG_TV;
1157
	} else  if (t->mode_mask & T_RADIO) {
1158
		t->mode = V4L2_TUNER_RADIO;
1159
	} else {
1160
		t->mode = V4L2_TUNER_DIGITAL_TV;
1161
	}
1162
	set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1163
	list_add_tail(&t->list, &tuner_list);
1164 1165 1166 1167
	return 0;
}


1168
static int tuner_remove(struct i2c_client *client)
1169
{
1170
	struct tuner *t = to_tuner(i2c_get_clientdata(client));
1171

1172
	v4l2_device_unregister_subdev(&t->sd);
1173 1174
	tuner_detach(&t->fe);
	t->fe.analog_demod_priv = NULL;
1175 1176 1177 1178 1179 1180

	list_del(&t->list);
	kfree(t);
	return 0;
}

L
Linus Torvalds 已提交
1181 1182
/* ----------------------------------------------------------------------- */

1183 1184 1185 1186 1187 1188 1189 1190 1191
/* This driver supports many devices and the idea is to let the driver
   detect which device is present. So rather than listing all supported
   devices here, we pretend to support a single, fake device type. */
static const struct i2c_device_id tuner_id[] = {
	{ "tuner", }, /* autodetect */
	{ }
};
MODULE_DEVICE_TABLE(i2c, tuner_id);

1192 1193 1194 1195
static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	.name = "tuner",
	.probe = tuner_probe,
	.remove = tuner_remove,
1196
	.command = tuner_command,
1197
	.suspend = tuner_suspend,
1198
	.resume = tuner_resume,
1199
	.id_table = tuner_id,
L
Linus Torvalds 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208
};

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */