tuner-core.c 35.3 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
455
		xc5000_cfg.i2c_address	  = t->i2c->addr;
		xc5000_cfg.if_khz	  = 5380;
456
		if (!dvb_attach(xc5000_attach,
457
				&t->fe, t->i2c->adapter, &xc5000_cfg))
458
459
			goto attach_failed;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	t->mode = mode;

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

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

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

759
static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
Linus Torvalds's avatar
Linus Torvalds committed
760
{
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
	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);
790
	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
Linus Torvalds's avatar
Linus Torvalds committed
791

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

794
795
796
797
798
799
800
	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;
}
801

802
#ifdef CONFIG_VIDEO_ALLOW_V4L1
803
static long tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
804
805
806
807
808
809
810
{
	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) {
811
	case VIDIOCSAUDIO:
812
		if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
813
			return 0;
814
		if (check_v4l2(t) == -EINVAL)
815
816
817
818
			return 0;

		/* Should be implemented, since bttv calls it */
		tuner_dbg("VIDIOCSAUDIO not implemented.\n");
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
819
		break;
Linus Torvalds's avatar
Linus Torvalds committed
820
	case VIDIOCSCHAN:
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
821
822
823
824
825
826
827
828
829
830
831
		{
			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;

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

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

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

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

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

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

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

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

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

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

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

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

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

910
911
912
913
914
915
916
			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;
917
918
				} else if (analog_ops->is_stereo)
					va->mode = analog_ops->is_stereo(&t->fe)
919
920
					    ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
			}
Mauro Carvalho Chehab's avatar
Mauro Carvalho Chehab committed
921
922
			return 0;
		}
923
924
925
	}
	return -ENOIOCTLCMD;
}
926
#endif
927

928
929
930
931
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
932

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

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

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

945
946
947
948
949
950
951
/* --- 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
952

953
954
955
	if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
			== -EINVAL)
		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
972
973
974
975
	if (set_mode(client, t, f->type, "VIDIOC_S_FREQUENCY")
			== -EINVAL)
		return 0;
	switch_v4l2();
	set_freq(client, f->frequency);
976

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

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

985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
	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
1002

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
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;
1041
		}
Linus Torvalds's avatar
Linus Torvalds committed
1042
	}
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
	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
1075

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

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

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

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