tuner-core.c 35.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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/videodev.h>
Linus Torvalds's avatar
Linus Torvalds committed
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-legacy.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"
Linus Torvalds's avatar
Linus Torvalds committed
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
104
105
/* standard i2c insmod options */
static unsigned short normal_i2c[] = {
106
#if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
107
108
	0x10,
#endif
109
	0x42, 0x43, 0x4a, 0x4b,			/* tda8290 */
110
111
	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
	0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
Linus Torvalds's avatar
Linus Torvalds committed
112
113
	I2C_CLIENT_END
};
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
114

Linus Torvalds's avatar
Linus Torvalds committed
115
116
117
I2C_CLIENT_INSMOD;

/* insmod options used at init time => read/only */
118
119
120
static unsigned int addr;
static unsigned int no_autodetect;
static unsigned int show_i2c;
121

Linus Torvalds's avatar
Linus Torvalds committed
122
/* insmod options used at runtime => read/write */
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
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)

/* ------------------------------------------------------------------------ */
Linus Torvalds's avatar
Linus Torvalds committed
151

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
152
static unsigned int tv_range[2] = { 44, 958 };
Linus Torvalds's avatar
Linus Torvalds committed
153
154
static unsigned int radio_range[2] = { 65, 108 };

155
156
157
158
static char pal[] = "--";
static char secam[] = "--";
static char ntsc[] = "-";

159

160
161
162
module_param(addr, int, 0444);
module_param(no_autodetect, int, 0444);
module_param(show_i2c, int, 0444);
163
module_param_named(debug,tuner_debug, int, 0644);
164
165
166
module_param_string(pal, pal, sizeof(pal), 0644);
module_param_string(secam, secam, sizeof(secam), 0644);
module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
167
module_param_array(tv_range, int, NULL, 0644);
Linus Torvalds's avatar
Linus Torvalds committed
168
169
170
171
172
173
174
175
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");

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

176
177
static void fe_set_params(struct dvb_frontend *fe,
			  struct analog_parameters *params)
178
{
179
180
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
	struct tuner *t = fe->analog_demod_priv;
181
182
183
184
185

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

189
static void fe_standby(struct dvb_frontend *fe)
190
{
191
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
192
193

	if (fe_tuner_ops->sleep)
194
		fe_tuner_ops->sleep(fe);
195
196
}

197
static int fe_has_signal(struct dvb_frontend *fe)
198
{
199
	u16 strength = 0;
200

201
202
	if (fe->ops.tuner_ops.get_rf_strength)
		fe->ops.tuner_ops.get_rf_strength(fe, &strength);
203
204
205
206

	return strength;
}

207
208
209
210
211
212
213
214
215
216
217
218
219
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;
}

220
static void tuner_status(struct dvb_frontend *fe);
221

222
static struct analog_demod_ops tuner_analog_ops = {
223
	.set_params     = fe_set_params,
224
225
	.standby        = fe_standby,
	.has_signal     = fe_has_signal,
226
	.set_config     = fe_set_config,
227
228
229
	.tuner_status   = tuner_status
};

230
/* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
Linus Torvalds's avatar
Linus Torvalds committed
231
232
static void set_tv_freq(struct i2c_client *c, unsigned int freq)
{
233
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
234
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds's avatar
Linus Torvalds committed
235

236
237
238
239
240
241
	struct analog_parameters params = {
		.mode      = t->mode,
		.audmode   = t->audmode,
		.std       = t->std
	};

Linus Torvalds's avatar
Linus Torvalds committed
242
	if (t->type == UNSET) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
243
		tuner_warn ("tuner type not set\n");
Linus Torvalds's avatar
Linus Torvalds committed
244
245
		return;
	}
246
	if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
247
		tuner_warn ("Tuner has no way to set tv freq\n");
Linus Torvalds's avatar
Linus Torvalds committed
248
249
		return;
	}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
250
251
252
253
	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]);
254
255
256
257
258
259
		/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
260
	}
261
262
	params.frequency = freq;

263
	analog_ops->set_params(&t->fe, &params);
Linus Torvalds's avatar
Linus Torvalds committed
264
265
266
267
}

static void set_radio_freq(struct i2c_client *c, unsigned int freq)
{
268
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
269
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds's avatar
Linus Torvalds committed
270

271
272
273
274
275
276
	struct analog_parameters params = {
		.mode      = t->mode,
		.audmode   = t->audmode,
		.std       = t->std
	};

Linus Torvalds's avatar
Linus Torvalds committed
277
	if (t->type == UNSET) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
278
		tuner_warn ("tuner type not set\n");
Linus Torvalds's avatar
Linus Torvalds committed
279
280
		return;
	}
281
	if (NULL == analog_ops->set_params) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
282
		tuner_warn ("tuner has no way to set radio frequency\n");
Linus Torvalds's avatar
Linus Torvalds committed
283
284
		return;
	}
285
	if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
286
287
288
		tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
			   freq / 16000, freq % 16000 * 100 / 16000,
			   radio_range[0], radio_range[1]);
289
290
291
292
293
294
		/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
295
	}
296
	params.frequency = freq;
297

298
	analog_ops->set_params(&t->fe, &params);
Linus Torvalds's avatar
Linus Torvalds committed
299
300
301
302
}

static void set_freq(struct i2c_client *c, unsigned long freq)
{
303
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds's avatar
Linus Torvalds committed
304
305
306
307

	switch (t->mode) {
	case V4L2_TUNER_RADIO:
		tuner_dbg("radio freq set to %lu.%02lu\n",
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
308
309
			  freq / 16000, freq % 16000 * 100 / 16000);
		set_radio_freq(c, freq);
310
		t->radio_freq = freq;
Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
314
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		tuner_dbg("tv freq set to %lu.%02lu\n",
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
315
			  freq / 16, freq % 16 * 100 / 16);
Linus Torvalds's avatar
Linus Torvalds committed
316
		set_tv_freq(c, freq);
317
		t->tv_freq = freq;
Linus Torvalds's avatar
Linus Torvalds committed
318
		break;
319
320
	default:
		tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
Linus Torvalds's avatar
Linus Torvalds committed
321
322
323
	}
}

324
325
326
static void tuner_i2c_address_check(struct tuner *t)
{
	if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
327
	    ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
328
329
		return;

330
331
332
333
334
335
	/* 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;

336
337
338
339
	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",
340
		   t->name, t->i2c->addr);
341
342
343
344
345
	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",
346
		   t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
347
348
349
	tuner_warn("====================== WARNING! ======================\n");
}

350
351
static struct xc5000_config xc5000_cfg;

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
352
static void set_type(struct i2c_client *c, unsigned int type,
353
		     unsigned int new_mode_mask, unsigned int new_config,
354
		     int (*tuner_callback) (void *dev, int component, int cmd, int arg))
Linus Torvalds's avatar
Linus Torvalds committed
355
{
356
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
357
	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
358
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
359
	unsigned char buffer[4];
Linus Torvalds's avatar
Linus Torvalds committed
360

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
361
362
	if (type == UNSET || type == TUNER_ABSENT) {
		tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
Linus Torvalds's avatar
Linus Torvalds committed
363
		return;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
364
365
	}

366
	t->type = type;
367
368
	/* prevent invalid config values */
	t->config = ((new_config >= 0) && (new_config < 256)) ? new_config : 0;
369
370
	if (tuner_callback != NULL) {
		tuner_dbg("defining GPIO callback\n");
371
		t->fe.callback = tuner_callback;
372
373
	}

374
	if (t->mode == T_UNINITIALIZED) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
375
376
		tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);

Linus Torvalds's avatar
Linus Torvalds committed
377
378
		return;
	}
379

380
	/* discard private data, in case set_type() was previously called */
381
382
	tuner_detach(&t->fe);
	t->fe.analog_demod_priv = NULL;
383

Linus Torvalds's avatar
Linus Torvalds committed
384
385
	switch (t->type) {
	case TUNER_MT2032:
386
387
388
		if (!dvb_attach(microtune_attach,
			   &t->fe, t->i2c->adapter, t->i2c->addr))
			goto attach_failed;
Linus Torvalds's avatar
Linus Torvalds committed
389
390
		break;
	case TUNER_PHILIPS_TDA8290:
391
	{
392
393
394
395
396
397
		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;
398
399
		break;
	}
400
	case TUNER_TEA5767:
401
402
		if (!dvb_attach(tea5767_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr))
403
			goto attach_failed;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
404
		t->mode_mask = T_RADIO;
405
		break;
406
	case TUNER_TEA5761:
407
408
		if (!dvb_attach(tea5761_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr))
409
			goto attach_failed;
410
411
		t->mode_mask = T_RADIO;
		break;
412
413
414
415
416
	case TUNER_PHILIPS_FMD1216ME_MK3:
		buffer[0] = 0x0b;
		buffer[1] = 0xdc;
		buffer[2] = 0x9c;
		buffer[3] = 0x60;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
417
		i2c_master_send(c, buffer, 4);
418
419
420
		mdelay(1);
		buffer[2] = 0x86;
		buffer[3] = 0x54;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
421
		i2c_master_send(c, buffer, 4);
422
423
		if (!dvb_attach(simple_tuner_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr, t->type))
424
			goto attach_failed;
425
		break;
426
427
428
429
430
	case TUNER_PHILIPS_TD1316:
		buffer[0] = 0x0b;
		buffer[1] = 0xdc;
		buffer[2] = 0x86;
		buffer[3] = 0xa4;
431
432
433
		i2c_master_send(c, buffer, 4);
		if (!dvb_attach(simple_tuner_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr, t->type))
434
			goto attach_failed;
435
		break;
436
437
	case TUNER_XC2028:
	{
438
439
440
441
		struct xc2028_config cfg = {
			.i2c_adap  = t->i2c->adapter,
			.i2c_addr  = t->i2c->addr,
		};
442
		if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
443
			goto attach_failed;
444
445
		break;
	}
446
	case TUNER_TDA9887:
447
448
449
		if (!dvb_attach(tda9887_attach,
			   &t->fe, t->i2c->adapter, t->i2c->addr))
			goto attach_failed;
450
		break;
451
	case TUNER_XC5000:
452
453
454
	{
		struct dvb_tuner_ops *xc_tuner_ops;

455
		xc5000_cfg.i2c_address	  = t->i2c->addr;
456
457
		/* if_khz will be set when the digital dvb_attach() occurs */
		xc5000_cfg.if_khz	  = 0;
458
		if (!dvb_attach(xc5000_attach,
459
				&t->fe, t->i2c->adapter, &xc5000_cfg))
460
461
			goto attach_failed;

462
		xc_tuner_ops = &t->fe.ops.tuner_ops;
463
		if (xc_tuner_ops->init)
464
465
			xc_tuner_ops->init(&t->fe);
		break;
466
	}
Linus Torvalds's avatar
Linus Torvalds committed
467
	default:
468
469
		if (!dvb_attach(simple_tuner_attach, &t->fe,
				t->i2c->adapter, t->i2c->addr, t->type))
470
471
			goto attach_failed;

Linus Torvalds's avatar
Linus Torvalds committed
472
473
		break;
	}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
474

475
	if ((NULL == analog_ops->set_params) &&
476
	    (fe_tuner_ops->set_analog_params)) {
477

478
		t->name = fe_tuner_ops->info.name;
479

480
		t->fe.analog_demod_priv = t;
481
		memcpy(analog_ops, &tuner_analog_ops,
482
		       sizeof(struct analog_demod_ops));
483

484
	} else {
485
		t->name = analog_ops->info.name;
486
487
	}

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

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
490
491
492
	if (t->mode_mask == T_UNINITIALIZED)
		t->mode_mask = new_mode_mask;

493
494
495
496
497
498
499
500
501
	/* 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);

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
502
	tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
503
		  c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
504
		  t->mode_mask);
505
	tuner_i2c_address_check(t);
506
507
508
509
510
511
512
513
	return;

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

	return;
Linus Torvalds's avatar
Linus Torvalds committed
514
515
}

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
516
517
518
519
520
521
522
523
524
525
/*
 * 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)
{
526
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
527

528
529
530
531
	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,
532
				 tun_setup->config, tun_setup->tuner_callback);
533
534
535
536
537
	} 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);
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
538
}
539

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
540
static inline int check_mode(struct tuner *t, char *cmd)
541
{
542
	if ((1 << t->mode & t->mode_mask) == 0) {
543
		return -EINVAL;
544
545
546
547
548
549
550
551
552
553
554
555
	}

	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;
556
	}
557
	return 0;
558
559
}

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
560
/* get more precise norm info from insmod option */
Linus Torvalds's avatar
Linus Torvalds committed
561
562
563
564
static int tuner_fixup_std(struct tuner *t)
{
	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
		switch (pal[0]) {
565
566
567
568
		case '6':
			tuner_dbg ("insmod fixup: PAL => PAL-60\n");
			t->std = V4L2_STD_PAL_60;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
569
570
571
572
		case 'b':
		case 'B':
		case 'g':
		case 'G':
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
573
			tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
Linus Torvalds's avatar
Linus Torvalds committed
574
575
576
577
			t->std = V4L2_STD_PAL_BG;
			break;
		case 'i':
		case 'I':
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
578
			tuner_dbg ("insmod fixup: PAL => PAL-I\n");
Linus Torvalds's avatar
Linus Torvalds committed
579
580
581
582
583
584
			t->std = V4L2_STD_PAL_I;
			break;
		case 'd':
		case 'D':
		case 'k':
		case 'K':
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
585
			tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
Linus Torvalds's avatar
Linus Torvalds committed
586
587
			t->std = V4L2_STD_PAL_DK;
			break;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
588
589
590
591
592
593
594
		case 'M':
		case 'm':
			tuner_dbg ("insmod fixup: PAL => PAL-M\n");
			t->std = V4L2_STD_PAL_M;
			break;
		case 'N':
		case 'n':
595
596
597
598
599
600
601
			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;
			}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
602
			break;
603
604
605
606
607
608
		case '-':
			/* default parameter, do nothing */
			break;
		default:
			tuner_warn ("pal= argument not recognised\n");
			break;
Linus Torvalds's avatar
Linus Torvalds committed
609
610
		}
	}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
611
612
	if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
		switch (secam[0]) {
613
614
615
616
617
618
619
620
621
		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;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
622
623
624
625
626
627
628
629
630
		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':
631
632
633
634
635
636
637
			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;
			}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
638
			break;
639
640
641
642
643
644
		case '-':
			/* default parameter, do nothing */
			break;
		default:
			tuner_warn ("secam= argument not recognised\n");
			break;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
645
646
647
		}
	}

648
649
650
651
652
653
654
655
656
657
658
659
	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;
660
661
662
663
664
		case 'k':
		case 'K':
			tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
			t->std = V4L2_STD_NTSC_M_KR;
			break;
665
666
667
668
669
670
671
672
		case '-':
			/* default parameter, do nothing */
			break;
		default:
			tuner_info("ntsc= argument not recognised\n");
			break;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
673
674
675
	return 0;
}

676
static void tuner_status(struct dvb_frontend *fe)
677
{
678
	struct tuner *t = fe->analog_demod_priv;
679
	unsigned long freq, freq_fraction;
680
681
	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
	struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
682
683
684
685
686
687
688
689
690
	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) {
691
692
		freq = t->radio_freq / 16000;
		freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
693
	} else {
694
695
		freq = t->tv_freq / 16;
		freq_fraction = (t->tv_freq % 16) * 100 / 16;
696
697
698
	}
	tuner_info("Tuner mode:      %s\n", p);
	tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
699
	tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
700
701
	if (t->mode != V4L2_TUNER_RADIO)
	       return;
702
703
704
705
706
707
708
709
710
	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");
	}
711
712
713
714
715
716
	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");
717
}
718

Linus Torvalds's avatar
Linus Torvalds committed
719
720
/* ---------------------------------------------------------------------- */

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
721
722
723
724
725
726
727
728
729
/*
 * 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)
{
730
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
731

732
733
734
735
736
	if (mode == t->mode)
		return 0;

	t->mode = mode;

737
	if (check_mode(t, cmd) == -EINVAL) {
738
739
		tuner_dbg("Tuner doesn't support this mode. "
			  "Putting tuner to sleep\n");
740
		t->mode = T_STANDBY;
741
742
		if (analog_ops->standby)
			analog_ops->standby(&t->fe);
743
		return -EINVAL;
744
745
	}
	return 0;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
746
747
748
}

#define switch_v4l2()	if (!t->using_v4l2) \
749
750
			    tuner_dbg("switching to v4l2\n"); \
			t->using_v4l2 = 1;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
751
752
753

static inline int check_v4l2(struct tuner *t)
{
754
755
756
757
	/* 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. */
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
758
759
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
760

761
static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
Linus Torvalds's avatar
Linus Torvalds committed
762
{
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
	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);

781
	if (set_mode(client, t, V4L2_TUNER_RADIO, "s_radio") == -EINVAL)
782
783
784
785
786
787
788
789
790
		return 0;
	if (t->radio_freq)
		set_freq(client, t->radio_freq);
	return 0;
}

static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
{
	struct tuner *t = to_tuner(sd);
791
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds's avatar
Linus Torvalds committed
792

793
794
	tuner_dbg("Putting tuner to sleep\n");

795
	if (check_mode(t, "s_standby") == -EINVAL)
796
797
798
799
800
801
		return 0;
	t->mode = T_STANDBY;
	if (analog_ops->standby)
		analog_ops->standby(&t->fe);
	return 0;
}
802

803
#ifdef CONFIG_VIDEO_ALLOW_V4L1
804
static long tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
805
806
807
808
809
810
811
{
	struct tuner *t = to_tuner(sd);
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;

	switch (cmd) {
812
	case VIDIOCSAUDIO:
813
		if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
814
			return 0;
815
		if (check_v4l2(t) == -EINVAL)
816
817
818
819
			return 0;

		/* Should be implemented, since bttv calls it */
		tuner_dbg("VIDIOCSAUDIO not implemented.\n");
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
820
		break;
Linus Torvalds's avatar
Linus Torvalds committed
821
	case VIDIOCSCHAN:
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
822
823
824
825
826
827
828
829
830
831
832
		{
			static const v4l2_std_id map[] = {
				[VIDEO_MODE_PAL] = V4L2_STD_PAL,
				[VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
				[VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
				[4 /* bttv */ ] = V4L2_STD_PAL_M,
				[5 /* bttv */ ] = V4L2_STD_PAL_N,
				[6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
			};
			struct video_channel *vc = arg;

833
			if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
834
835
				return 0;

836
			if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
837
838
839
840
841
				return 0;

			if (vc->norm < ARRAY_SIZE(map))
				t->std = map[vc->norm];
			tuner_fixup_std(t);
842
843
			if (t->tv_freq)
				set_tv_freq(client, t->tv_freq);
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
844
845
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
846
	case VIDIOCSFREQ:
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
847
848
		{
			unsigned long *v = arg;
Linus Torvalds's avatar
Linus Torvalds committed
849

850
			if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
851
				return 0;
852
			if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
853
854
855
856
857
				return 0;

			set_freq(client, *v);
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
858
	case VIDIOCGTUNER:
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
859
860
861
		{
			struct video_tuner *vt = arg;

862
			if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
863
				return 0;
864
			if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
865
866
867
				return 0;

			if (V4L2_TUNER_RADIO == t->mode) {
868
869
870
871
				if (fe_tuner_ops->get_status) {
					u32 tuner_status;

					fe_tuner_ops->get_status(&t->fe, &tuner_status);
872
873
874
875
					if (tuner_status & TUNER_STATUS_STEREO)
						vt->flags |= VIDEO_TUNER_STEREO_ON;
					else
						vt->flags &= ~VIDEO_TUNER_STEREO_ON;
876
				} else {
877
878
					if (analog_ops->is_stereo) {
						if (analog_ops->is_stereo(&t->fe))
879
880
881
882
883
884
							vt->flags |=
								VIDEO_TUNER_STEREO_ON;
						else
							vt->flags &=
								~VIDEO_TUNER_STEREO_ON;
					}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
885
				}
886
887
888
				if (analog_ops->has_signal)
					vt->signal =
						analog_ops->has_signal(&t->fe);
889

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
890
				vt->flags |= VIDEO_TUNER_LOW;	/* Allow freqs at 62.5 Hz */
891

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
892
893
				vt->rangelow = radio_range[0] * 16000;
				vt->rangehigh = radio_range[1] * 16000;
894

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
895
896
897
898
			} else {
				vt->rangelow = tv_range[0] * 16;
				vt->rangehigh = tv_range[1] * 16;
			}
899

Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
900
901
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
902
	case VIDIOCGAUDIO:
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
903
904
905
		{
			struct video_audio *va = arg;

906
			if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
907
				return 0;
908
			if (check_v4l2(t) == -EINVAL)
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
909
910
				return 0;

911
912
913
914
915
916
917
			if (V4L2_TUNER_RADIO == t->mode) {
				if (fe_tuner_ops->get_status) {
					u32 tuner_status;

					fe_tuner_ops->get_status(&t->fe, &tuner_status);
					va->mode = (tuner_status & TUNER_STATUS_STEREO)
					    ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
918
919
				} else if (analog_ops->is_stereo)
					va->mode = analog_ops->is_stereo(&t->fe)
920
921
					    ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
			}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
922
923
			return 0;
		}
924
925
926
	}
	return -ENOIOCTLCMD;
}
927
#endif
928

929
930
931
932
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;
Linus Torvalds's avatar
Linus Torvalds committed
933

934
935
	if (t->type != cfg->tuner)
		return 0;
936

937
938
939
	if (analog_ops->set_config) {
		analog_ops->set_config(&t->fe, cfg->priv);
		return 0;
940
	}
Linus Torvalds's avatar
Linus Torvalds committed
941

942
943
944
	tuner_dbg("Tuner frontend module has no way to set config\n");
	return 0;
}
945

946
947
948
949
950
951
952
/* --- 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);
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
953

954
	if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "s_std") == -EINVAL)
955
		return 0;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
956

957
	switch_v4l2();
958

959
960
961
962
963
964
	t->std = std;
	tuner_fixup_std(t);
	if (t->tv_freq)
		set_freq(client, t->tv_freq);
	return 0;
}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
965

966
967
968
969
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);
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
970

971
	if (set_mode(client, t, f->type, "s_frequency") == -EINVAL)
972
973
974
		return 0;
	switch_v4l2();
	set_freq(client, f->frequency);
975

976
977
	return 0;
}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
978

979
980
981
982
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;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
983

984
	if (check_mode(t, "g_frequency") == -EINVAL)
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
		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;
}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
1001

1002
1003
1004
1005
1006
1007
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;

1008
	if (check_mode(t, "g_tuner") == -EINVAL)
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
1039
		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;
1040
		}
Linus Torvalds's avatar
Linus Torvalds committed
1041
	}
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
	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);

1057
	if (check_mode(t, "s_tuner") == -EINVAL)
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
		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;
Linus Torvalds's avatar
Linus Torvalds committed
1074

1075
1076
	if (analog_ops->tuner_status)
		analog_ops->tuner_status(&t->fe);
Linus Torvalds's avatar
Linus Torvalds committed
1077
1078
1079
	return 0;
}

1080
1081
1082
1083
1084
static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
{
	return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
}

1085
static int tuner_suspend(struct i2c_client *c, pm_message_t state)
Linus Torvalds's avatar
Linus Torvalds committed
1086
{
1087
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds's avatar
Linus Torvalds committed
1088

1089
	tuner_dbg("suspend\n");
Linus Torvalds's avatar
Linus Torvalds committed
1090
1091
1092
1093
	/* FIXME: power down ??? */
	return 0;
}

1094
static int tuner_resume(struct i2c_client *c)
Linus Torvalds's avatar
Linus Torvalds committed
1095
{
1096
	struct tuner *t = to_tuner(i2c_get_clientdata(c));
Linus Torvalds's avatar
Linus Torvalds committed
1097

1098
	tuner_dbg("resume\n");