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
367
368
369
	t->type = type;
	t->config = new_config;
	if (tuner_callback != NULL) {
		tuner_dbg("defining GPIO callback\n");
370
		t->fe.callback = tuner_callback;
371
372
	}

373
	if (t->mode == T_UNINITIALIZED) {
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
374
375
		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
376
377
		return;
	}
378

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

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

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

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

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

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

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

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

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

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

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

492
493
494
495
496
497
498
499
500
	/* 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
501
	tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
502
		  c->adapter->name, c->driver->driver.name, c->addr << 1, type,
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
503
		  t->mode_mask);
504
	tuner_i2c_address_check(t);
505
506
507
508
509
510
511
512
	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
513
514
}

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

527
528
529
530
	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,
531
				 tun_setup->config, tun_setup->tuner_callback);
532
533
534
535
536
	} 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
537
}
538

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

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

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

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

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

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

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

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

	t->mode = mode;

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

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

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

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

	if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
			== -EINVAL)
		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
796
797
798
799
800
801
	if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
		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
955
956
	if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
			== -EINVAL)
		return 0;
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
957

958
	switch_v4l2();
959

960
961
962
963
964
965
	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
966

967
968
969
970
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
971

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

978
979
	return 0;
}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
980

981
982
983
984
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
985

986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
	if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
		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
1003

1004
1005
1006
1007
1008
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
1040
1041
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;

	if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
		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;
1042
		}
Linus Torvalds's avatar
Linus Torvalds committed
1043
	}
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
	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);

	if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
		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
1076

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

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

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

1091
	tuner_dbg("suspend\n");
Linus Torvalds's avatar
Linus Torvalds committed
1092
1093