[mirror_ubuntu-artful-kernel.git] / drivers / media / video / tuner-core.c

/*
 * $Id: tuner-core.c,v 1.15 2005/06/12 01:36:14 mchehab Exp $
 *
 * i2c tv tuner chip device driver
 * core core, i.e. kernel interfaces, registering and so on
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/sched.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/videodev.h>
#include <linux/init.h>

#include <media/tuner.h>
#include <media/audiochip.h>

/*
 * comment line bellow to return to old behavor, where only one I2C device is supported
 */
#define CONFIG_TUNER_MULTI_I2C /**/

#define UNSET (-1U)

/* standard i2c insmod options */
static unsigned short normal_i2c[] = {
	0x4b, /* tda8290 */
	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
	0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
	I2C_CLIENT_END
};
I2C_CLIENT_INSMOD;

/* insmod options used at init time => read/only */
static unsigned int addr  =  0;
module_param(addr, int, 0444);

/* insmod options used at runtime => read/write */
unsigned int tuner_debug   = 0;
module_param(tuner_debug,       int, 0644);

static unsigned int tv_range[2]    = { 44, 958 };
static unsigned int radio_range[2] = { 65, 108 };

module_param_array(tv_range,    int, NULL, 0644);
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");

static int this_adap;
#ifdef CONFIG_TUNER_MULTI_I2C
static unsigned short first_tuner, tv_tuner, radio_tuner;
#endif

static struct i2c_driver driver;
static struct i2c_client client_template;

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

/* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
static void set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type == UNSET) {
		tuner_info("tuner type not set\n");
		return;
	}
	if (NULL == t->tv_freq) {
		tuner_info("Huh? tv_set is NULL?\n");
		return;
	}
	if (freq < tv_range[0]*16 || freq > tv_range[1]*16) {

		if (freq >= tv_range[0]*16364 && freq <= tv_range[1]*16384) {
			/* V4L2_TUNER_CAP_LOW frequency */

			tuner_dbg("V4L2_TUNER_CAP_LOW freq selected for TV. Tuners yet doesn't support converting it to valid freq.\n");

			t->tv_freq(c,freq>>10);

			return;
                } else {
			/* FIXME: better do that chip-specific, but
			   right now we don't have that in the config
			   struct and this way is still better than no
			   check at all */
			tuner_info("TV freq (%d.%02d) out of range (%d-%d)\n",
				   freq/16,freq%16*100/16,tv_range[0],tv_range[1]);
			return;
		}
	}
	tuner_dbg("62.5 Khz freq step selected for TV.\n");
	t->tv_freq(c,freq);
}

static void set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type == UNSET) {
		tuner_info("tuner type not set\n");
		return;
	}
	if (NULL == t->radio_freq) {
		tuner_info("no radio tuning for this one, sorry.\n");
		return;
	}
	if (freq < radio_range[0]*16 || freq > radio_range[1]*16) {
		if (freq >= tv_range[0]*16364 && freq <= tv_range[1]*16384) {
			/* V4L2_TUNER_CAP_LOW frequency */
			if (t->type == TUNER_TEA5767) {
				tuner_info("radio freq step 62.5Hz (%d.%06d)\n",(freq>>14),freq%(1<<14)*10000);
				t->radio_freq(c,freq>>10);
				return;
			}

			tuner_dbg("V4L2_TUNER_CAP_LOW freq selected for Radio. Tuners yet doesn't support converting it to valid freq.\n");

			tuner_info("radio freq (%d.%06d)\n",(freq>>14),freq%(1<<14)*10000);

			t->radio_freq(c,freq>>10);
			return;

                } else {
			tuner_info("radio freq (%d.%02d) out of range (%d-%d)\n",
			   freq/16,freq%16*100/16,
				   radio_range[0],radio_range[1]);
			return;
		}
	}
	tuner_dbg("62.5 Khz freq step selected for Radio.\n");
	t->radio_freq(c,freq);
}

static void set_freq(struct i2c_client *c, unsigned long freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	switch (t->mode) {
	case V4L2_TUNER_RADIO:
		tuner_dbg("radio freq set to %lu.%02lu\n",
			  freq/16,freq%16*100/16);
		set_radio_freq(c,freq);
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		tuner_dbg("tv freq set to %lu.%02lu\n",
			  freq/16,freq%16*100/16);
		set_tv_freq(c, freq);
		break;
	}
	t->freq = freq;
}

static void set_type(struct i2c_client *c, unsigned int type)
{
	struct tuner *t = i2c_get_clientdata(c);

	tuner_dbg ("I2C addr 0x%02x with type %d\n",c->addr<<1,type);
	/* sanity check */
	if (type == UNSET || type == TUNER_ABSENT)
		return;
	if (type >= tuner_count)
		return;

	if (NULL == t->i2c.dev.driver) {
		/* not registered yet */
		t->type = type;
		return;
	}
	if (t->initialized)
		/* run only once */
		return;

	t->initialized = 1;

	t->type = type;
	switch (t->type) {
	case TUNER_MT2032:
		microtune_init(c);
		break;
	case TUNER_PHILIPS_TDA8290:
		tda8290_init(c);
		break;
	default:
		default_tuner_init(c);
		break;
	}
}

#ifdef CONFIG_TUNER_MULTI_I2C
#define CHECK_ADDR(tp,cmd,tun)	if (client->addr!=tp) { \
			  return 0; } else \
			  tuner_info ("Cmd %s accepted to "tun"\n",cmd);
#define CHECK_MODE(cmd)	if (t->mode == V4L2_TUNER_RADIO) { \
		 	CHECK_ADDR(radio_tuner,cmd,"radio") } else \
			{ CHECK_ADDR(tv_tuner,cmd,"TV"); }
#else
#define CHECK_ADDR(tp,cmd,tun) tuner_info ("Cmd %s accepted to "tun"\n",cmd);
#define CHECK_MODE(cmd) tuner_info ("Cmd %s accepted\n",cmd);
#endif

#ifdef CONFIG_TUNER_MULTI_I2C

static void set_addr(struct i2c_client *c, struct tuner_addr *tun_addr)
{
	/* ADDR_UNSET defaults to first available tuner */
	if ( tun_addr->addr == ADDR_UNSET ) {
		if (first_tuner != c->addr)
			return;
		switch (tun_addr->v4l2_tuner) {
		case V4L2_TUNER_RADIO:
	 		radio_tuner=c->addr;
			break;
		default:
			tv_tuner=c->addr;
			break;
		}
	} else {
		/* Sets tuner to its configured value */
		switch (tun_addr->v4l2_tuner) {
		case V4L2_TUNER_RADIO:
 			radio_tuner=tun_addr->addr;
			if ( tun_addr->addr == c->addr ) set_type(c,tun_addr->type);
			return;
		default:
			tv_tuner=tun_addr->addr;
			if ( tun_addr->addr == c->addr ) set_type(c,tun_addr->type);
			return;
		}
	}
	set_type(c,tun_addr->type);
}
#else
#define set_addr(c,tun_addr) set_type(c,(tun_addr)->type)
#endif

static char pal[] = "-";
module_param_string(pal, pal, sizeof(pal), 0644);

static int tuner_fixup_std(struct tuner *t)
{
	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
		/* get more precise norm info from insmod option */
		switch (pal[0]) {
		case 'b':
		case 'B':
		case 'g':
		case 'G':
			tuner_dbg("insmod fixup: PAL => PAL-BG\n");
			t->std = V4L2_STD_PAL_BG;
			break;
		case 'i':
		case 'I':
			tuner_dbg("insmod fixup: PAL => PAL-I\n");
			t->std = V4L2_STD_PAL_I;
			break;
		case 'd':
		case 'D':
		case 'k':
		case 'K':
			tuner_dbg("insmod fixup: PAL => PAL-DK\n");
			t->std = V4L2_STD_PAL_DK;
			break;
		}
	}
	return 0;
}

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

static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
{
	struct tuner *t;

#ifndef CONFIG_TUNER_MULTI_I2C
	if (this_adap > 0)
		return -1;
#else
	/* by default, first I2C card is both tv and radio tuner */
	if (this_adap == 0) {
		first_tuner = addr;
		tv_tuner = addr;
		radio_tuner = addr;
	}
#endif
	this_adap++;

        client_template.adapter = adap;
        client_template.addr = addr;

        t = kmalloc(sizeof(struct tuner),GFP_KERNEL);
        if (NULL == t)
                return -ENOMEM;
        memset(t,0,sizeof(struct tuner));
        memcpy(&t->i2c,&client_template,sizeof(struct i2c_client));
	i2c_set_clientdata(&t->i2c, t);
	t->type       = UNSET;
	t->radio_if2  = 10700*1000; /* 10.7MHz - FM radio */

        i2c_attach_client(&t->i2c);
	tuner_info("chip found @ 0x%x (%s)\n",
		   addr << 1, adap->name);

	set_type(&t->i2c, t->type);
	return 0;
}

static int tuner_probe(struct i2c_adapter *adap)
{
	if (0 != addr) {
		normal_i2c[0] = addr;
		normal_i2c[1] = I2C_CLIENT_END;
	}
	this_adap = 0;

#ifdef CONFIG_TUNER_MULTI_I2C
	first_tuner = 0;
	tv_tuner = 0;
	radio_tuner = 0;
#endif

	if (adap->class & I2C_CLASS_TV_ANALOG)
		return i2c_probe(adap, &addr_data, tuner_attach);
	return 0;
}

static int tuner_detach(struct i2c_client *client)
{
	struct tuner *t = i2c_get_clientdata(client);
	int err;

	err=i2c_detach_client(&t->i2c);
	if (err) {
		tuner_warn ("Client deregistration failed, client not detached.\n");
		return err;
	}

	kfree(t);
	return 0;
}

#define SWITCH_V4L2	if (!t->using_v4l2 && tuner_debug) \
		          tuner_info("switching to v4l2\n"); \
	                  t->using_v4l2 = 1;
#define CHECK_V4L2	if (t->using_v4l2) { if (tuner_debug) \
			  tuner_info("ignore v4l1 call\n"); \
		          return 0; }

static int
tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
{
	struct tuner *t = i2c_get_clientdata(client);
        unsigned int *iarg = (int*)arg;

        switch (cmd) {
	/* --- configuration --- */
	case TUNER_SET_TYPE:
		set_type(client,*iarg);
		break;
	case TUNER_SET_TYPE_ADDR:
		set_addr(client,(struct tuner_addr *)arg);
		break;
	case AUDC_SET_RADIO:
		t->mode = V4L2_TUNER_RADIO;
		CHECK_ADDR(tv_tuner,"AUDC_SET_RADIO","TV");

		if (V4L2_TUNER_RADIO != t->mode) {
			set_tv_freq(client,400 * 16);
		}
		break;
	case AUDC_CONFIG_PINNACLE:
		CHECK_ADDR(tv_tuner,"AUDC_CONFIG_PINNACLE","TV");
		switch (*iarg) {
		case 2:
			tuner_dbg("pinnacle pal\n");
			t->radio_if2 = 33300 * 1000;
			break;
		case 3:
			tuner_dbg("pinnacle ntsc\n");
			t->radio_if2 = 41300 * 1000;
			break;
		}
                break;

	/* --- v4l ioctls --- */
	/* take care: bttv does userspace copying, we'll get a
	   kernel pointer here... */
	case VIDIOCSCHAN:
	{
		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;

		CHECK_V4L2;
		t->mode = V4L2_TUNER_ANALOG_TV;
		CHECK_ADDR(tv_tuner,"VIDIOCSCHAN","TV");

		if (vc->norm < ARRAY_SIZE(map))
			t->std = map[vc->norm];
		tuner_fixup_std(t);
		if (t->freq)
			set_tv_freq(client,t->freq);
		return 0;
	}
	case VIDIOCSFREQ:
	{
		unsigned long *v = arg;

		CHECK_MODE("VIDIOCSFREQ");
		CHECK_V4L2;
		set_freq(client,*v);
		return 0;
	}
	case VIDIOCGTUNER:
	{
		struct video_tuner *vt = arg;

		CHECK_ADDR(radio_tuner,"VIDIOCGTUNER","radio");
		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode) {
			if (t->has_signal)
				vt->signal = t->has_signal(client);
			if (t->is_stereo) {
				if (t->is_stereo(client))
					vt-> flags |= VIDEO_TUNER_STEREO_ON;
				else
					vt-> flags &= 0xffff ^ VIDEO_TUNER_STEREO_ON;
			}
			vt->flags |= V4L2_TUNER_CAP_LOW; /* Allow freqs at 62.5 Hz */
		}

		return 0;
	}
	case VIDIOCGAUDIO:
	{
		struct video_audio *va = arg;

		CHECK_ADDR(radio_tuner,"VIDIOCGAUDIO","radio");
		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode  &&  t->is_stereo)
			va->mode = t->is_stereo(client)
				? VIDEO_SOUND_STEREO
				: VIDEO_SOUND_MONO;
		return 0;
	}

	case VIDIOC_S_STD:
	{
		v4l2_std_id *id = arg;

		SWITCH_V4L2;
		t->mode = V4L2_TUNER_ANALOG_TV;
		CHECK_ADDR(tv_tuner,"VIDIOC_S_STD","TV");

		t->std = *id;
		tuner_fixup_std(t);
		if (t->freq)
			set_freq(client,t->freq);
		break;
	}
	case VIDIOC_S_FREQUENCY:
	{
		struct v4l2_frequency *f = arg;

		CHECK_MODE("VIDIOC_S_FREQUENCY");
		SWITCH_V4L2;
		if (V4L2_TUNER_RADIO == f->type &&
		    V4L2_TUNER_RADIO != t->mode)
			set_tv_freq(client,400*16);
		t->mode  = f->type;
		set_freq(client,f->frequency);
		break;
	}
	case VIDIOC_G_FREQUENCY:
	{
		struct v4l2_frequency *f = arg;

		CHECK_MODE("VIDIOC_G_FREQUENCY");
		SWITCH_V4L2;
		f->type = t->mode;
		f->frequency = t->freq;
		break;
	}
	case VIDIOC_G_TUNER:
	{
		struct v4l2_tuner *tuner = arg;

		CHECK_MODE("VIDIOC_G_TUNER");
		SWITCH_V4L2;
		if (V4L2_TUNER_RADIO == t->mode) {
			if (t->has_signal)
				tuner -> signal = t->has_signal(client);
			if (t->is_stereo) {
				if (t->is_stereo(client)) {
					tuner -> capability |= V4L2_TUNER_CAP_STEREO;
					tuner -> rxsubchans |= V4L2_TUNER_SUB_STEREO;
				} else {
					tuner -> rxsubchans &= 0xffff ^ V4L2_TUNER_SUB_STEREO;
				}
			}
		}
		/* Wow to deal with V4L2_TUNER_CAP_LOW ? For now, it accepts from low at 62.5KHz step  to high at 62.5 Hz */
		tuner->rangelow = tv_range[0] * 16;
//		tuner->rangehigh = tv_range[1] * 16;
//		tuner->rangelow = tv_range[0] * 16384;
		tuner->rangehigh = tv_range[1] * 16384;
		break;
	}
	default:
		tuner_dbg ("Unimplemented IOCTL 0x%08x called to tuner.\n", cmd);
		/* nothing */
		break;
	}

	return 0;
}

static int tuner_suspend(struct device * dev, u32 state, u32 level)
{
	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	struct tuner *t = i2c_get_clientdata(c);

	tuner_dbg("suspend\n");
	/* FIXME: power down ??? */
	return 0;
}

static int tuner_resume(struct device * dev, u32 level)
{
	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	struct tuner *t = i2c_get_clientdata(c);

	tuner_dbg("resume\n");
	if (t->freq)
		set_freq(c,t->freq);
	return 0;
}

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

static struct i2c_driver driver = {
	.owner          = THIS_MODULE,
        .name           = "tuner",
        .id             = I2C_DRIVERID_TUNER,
        .flags          = I2C_DF_NOTIFY,
        .attach_adapter = tuner_probe,
        .detach_client  = tuner_detach,
        .command        = tuner_command,
	.driver = {
		.suspend = tuner_suspend,
		.resume  = tuner_resume,
	},
};
static struct i2c_client client_template =
{
	I2C_DEVNAME("(tuner unset)"),
	.flags      = I2C_CLIENT_ALLOW_USE,
        .driver     = &driver,
};

static int __init tuner_init_module(void)
{
	return i2c_add_driver(&driver);
}

static void __exit tuner_cleanup_module(void)
{
	i2c_del_driver(&driver);
}

module_init(tuner_init_module);
module_exit(tuner_cleanup_module);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
Commit	Line	Data
1da177e4	1	/*
56fc08ca	2	* $Id: tuner-core.c,v 1.15 2005/06/12 01:36:14 mchehab Exp $
1da177e4 LT	3	*
	4	* i2c tv tuner chip device driver
	5	* core core, i.e. kernel interfaces, registering and so on
	6	*/
	7
	8	#include <linux/module.h>
	9	#include <linux/moduleparam.h>
	10	#include <linux/kernel.h>
	11	#include <linux/sched.h>
	12	#include <linux/string.h>
	13	#include <linux/timer.h>
	14	#include <linux/delay.h>
	15	#include <linux/errno.h>
	16	#include <linux/slab.h>
	17	#include <linux/poll.h>
	18	#include <linux/i2c.h>
	19	#include <linux/types.h>
	20	#include <linux/videodev.h>
	21	#include <linux/init.h>
	22
	23	#include <media/tuner.h>
	24	#include <media/audiochip.h>
	25
391cd727 MCC	26	/*
	27	* comment line bellow to return to old behavor, where only one I2C device is supported
	28	*/
56fc08ca	29	#define CONFIG_TUNER_MULTI_I2C /**/
391cd727	30
1da177e4 LT	31	#define UNSET (-1U)
	32
	33	/* standard i2c insmod options */
	34	static unsigned short normal_i2c[] = {
	35	0x4b, /* tda8290 */
f5bec396 MCC	36	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
f5bec396 MCC	37	0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
1da177e4 LT	38	I2C_CLIENT_END
	39	};
	40	I2C_CLIENT_INSMOD;
	41
	42	/* insmod options used at init time => read/only */
	43	static unsigned int addr = 0;
	44	module_param(addr, int, 0444);
	45
	46	/* insmod options used at runtime => read/write */
	47	unsigned int tuner_debug = 0;
	48	module_param(tuner_debug, int, 0644);
	49
	50	static unsigned int tv_range[2] = { 44, 958 };
	51	static unsigned int radio_range[2] = { 65, 108 };
	52
	53	module_param_array(tv_range, int, NULL, 0644);
	54	module_param_array(radio_range, int, NULL, 0644);
	55
	56	MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
	57	MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
	58	MODULE_LICENSE("GPL");
	59
	60	static int this_adap;
391cd727	61	#ifdef CONFIG_TUNER_MULTI_I2C
56fc08ca	62	static unsigned short first_tuner, tv_tuner, radio_tuner;
391cd727	63	#endif
1da177e4 LT	64
	65	static struct i2c_driver driver;
	66	static struct i2c_client client_template;
	67
	68	/* ---------------------------------------------------------------------- */
	69
56fc08ca	70	/* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
1da177e4 LT	71	static void set_tv_freq(struct i2c_client *c, unsigned int freq)
	72	{
	73	struct tuner *t = i2c_get_clientdata(c);
	74
	75	if (t->type == UNSET) {
	76	tuner_info("tuner type not set\n");
	77	return;
	78	}
	79	if (NULL == t->tv_freq) {
	80	tuner_info("Huh? tv_set is NULL?\n");
	81	return;
	82	}
	83	if (freq < tv_range[0]16 \|\| freq > tv_range[1]16) {
56fc08ca MCC	84
	85	if (freq >= tv_range[0]16364 && freq <= tv_range[1]16384) {
	86	/* V4L2_TUNER_CAP_LOW frequency */
	87
	88	tuner_dbg("V4L2_TUNER_CAP_LOW freq selected for TV. Tuners yet doesn't support converting it to valid freq.\n");
	89
	90	t->tv_freq(c,freq>>10);
	91
	92	return;
	93	} else {
	94	/* FIXME: better do that chip-specific, but
	95	right now we don't have that in the config
	96	struct and this way is still better than no
	97	check at all */
	98	tuner_info("TV freq (%d.%02d) out of range (%d-%d)\n",
	99	freq/16,freq%16*100/16,tv_range[0],tv_range[1]);
	100	return;
	101	}
1da177e4	102	}
56fc08ca	103	tuner_dbg("62.5 Khz freq step selected for TV.\n");
1da177e4 LT	104	t->tv_freq(c,freq);
	105	}
	106
	107	static void set_radio_freq(struct i2c_client *c, unsigned int freq)
	108	{
	109	struct tuner *t = i2c_get_clientdata(c);
	110
	111	if (t->type == UNSET) {
	112	tuner_info("tuner type not set\n");
	113	return;
	114	}
	115	if (NULL == t->radio_freq) {
	116	tuner_info("no radio tuning for this one, sorry.\n");
	117	return;
	118	}
	119	if (freq < radio_range[0]16 \|\| freq > radio_range[1]16) {
56fc08ca MCC	120	if (freq >= tv_range[0]16364 && freq <= tv_range[1]16384) {
	121	/* V4L2_TUNER_CAP_LOW frequency */
	122	if (t->type == TUNER_TEA5767) {
	123	tuner_info("radio freq step 62.5Hz (%d.%06d)\n",(freq>>14),freq%(1<<14)*10000);
	124	t->radio_freq(c,freq>>10);
	125	return;
	126	}
	127
	128	tuner_dbg("V4L2_TUNER_CAP_LOW freq selected for Radio. Tuners yet doesn't support converting it to valid freq.\n");
	129
	130	tuner_info("radio freq (%d.%06d)\n",(freq>>14),freq%(1<<14)*10000);
	131
	132	t->radio_freq(c,freq>>10);
	133	return;
	134
	135	} else {
	136	tuner_info("radio freq (%d.%02d) out of range (%d-%d)\n",
1da177e4	137	freq/16,freq%16*100/16,
56fc08ca MCC	138	radio_range[0],radio_range[1]);
	139	return;
	140	}
1da177e4	141	}
56fc08ca	142	tuner_dbg("62.5 Khz freq step selected for Radio.\n");
1da177e4 LT	143	t->radio_freq(c,freq);
	144	}
	145
	146	static void set_freq(struct i2c_client *c, unsigned long freq)
	147	{
	148	struct tuner *t = i2c_get_clientdata(c);
	149
	150	switch (t->mode) {
	151	case V4L2_TUNER_RADIO:
	152	tuner_dbg("radio freq set to %lu.%02lu\n",
	153	freq/16,freq%16*100/16);
	154	set_radio_freq(c,freq);
	155	break;
	156	case V4L2_TUNER_ANALOG_TV:
	157	case V4L2_TUNER_DIGITAL_TV:
	158	tuner_dbg("tv freq set to %lu.%02lu\n",
	159	freq/16,freq%16*100/16);
	160	set_tv_freq(c, freq);
	161	break;
	162	}
	163	t->freq = freq;
	164	}
	165
	166	static void set_type(struct i2c_client *c, unsigned int type)
	167	{
	168	struct tuner *t = i2c_get_clientdata(c);
	169
56fc08ca	170	tuner_dbg ("I2C addr 0x%02x with type %d\n",c->addr<<1,type);
1da177e4	171	/* sanity check */
56fc08ca	172	if (type == UNSET \|\| type == TUNER_ABSENT)
1da177e4 LT	173	return;
	174	if (type >= tuner_count)
	175	return;
	176
	177	if (NULL == t->i2c.dev.driver) {
	178	/* not registered yet */
	179	t->type = type;
	180	return;
	181	}
	182	if (t->initialized)
	183	/* run only once */
	184	return;
	185
	186	t->initialized = 1;
56fc08ca	187
1da177e4 LT	188	t->type = type;
	189	switch (t->type) {
	190	case TUNER_MT2032:
	191	microtune_init(c);
	192	break;
	193	case TUNER_PHILIPS_TDA8290:
	194	tda8290_init(c);
	195	break;
	196	default:
	197	default_tuner_init(c);
	198	break;
	199	}
	200	}
	201
56fc08ca MCC	202	#ifdef CONFIG_TUNER_MULTI_I2C
	203	#define CHECK_ADDR(tp,cmd,tun) if (client->addr!=tp) { \
	204	return 0; } else \
	205	tuner_info ("Cmd %s accepted to "tun"\n",cmd);
	206	#define CHECK_MODE(cmd) if (t->mode == V4L2_TUNER_RADIO) { \
	207	CHECK_ADDR(radio_tuner,cmd,"radio") } else \
	208	{ CHECK_ADDR(tv_tuner,cmd,"TV"); }
	209	#else
	210	#define CHECK_ADDR(tp,cmd,tun) tuner_info ("Cmd %s accepted to "tun"\n",cmd);
	211	#define CHECK_MODE(cmd) tuner_info ("Cmd %s accepted\n",cmd);
	212	#endif
	213
	214	#ifdef CONFIG_TUNER_MULTI_I2C
	215
	216	static void set_addr(struct i2c_client c, struct tuner_addr tun_addr)
	217	{
	218	/* ADDR_UNSET defaults to first available tuner */
	219	if ( tun_addr->addr == ADDR_UNSET ) {
	220	if (first_tuner != c->addr)
	221	return;
	222	switch (tun_addr->v4l2_tuner) {
	223	case V4L2_TUNER_RADIO:
	224	radio_tuner=c->addr;
	225	break;
	226	default:
	227	tv_tuner=c->addr;
	228	break;
	229	}
	230	} else {
	231	/* Sets tuner to its configured value */
	232	switch (tun_addr->v4l2_tuner) {
	233	case V4L2_TUNER_RADIO:
	234	radio_tuner=tun_addr->addr;
	235	if ( tun_addr->addr == c->addr ) set_type(c,tun_addr->type);
	236	return;
	237	default:
	238	tv_tuner=tun_addr->addr;
	239	if ( tun_addr->addr == c->addr ) set_type(c,tun_addr->type);
	240	return;
	241	}
	242	}
	243	set_type(c,tun_addr->type);
	244	}
	245	#else
	246	#define set_addr(c,tun_addr) set_type(c,(tun_addr)->type)
	247	#endif
	248
1da177e4	249	static char pal[] = "-";
975e046c	250	module_param_string(pal, pal, sizeof(pal), 0644);
1da177e4 LT	251
	252	static int tuner_fixup_std(struct tuner *t)
	253	{
	254	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
	255	/* get more precise norm info from insmod option */
	256	switch (pal[0]) {
	257	case 'b':
	258	case 'B':
	259	case 'g':
	260	case 'G':
	261	tuner_dbg("insmod fixup: PAL => PAL-BG\n");
	262	t->std = V4L2_STD_PAL_BG;
	263	break;
	264	case 'i':
	265	case 'I':
	266	tuner_dbg("insmod fixup: PAL => PAL-I\n");
	267	t->std = V4L2_STD_PAL_I;
	268	break;
	269	case 'd':
	270	case 'D':
	271	case 'k':
	272	case 'K':
	273	tuner_dbg("insmod fixup: PAL => PAL-DK\n");
	274	t->std = V4L2_STD_PAL_DK;
	275	break;
	276	}
	277	}
	278	return 0;
	279	}
	280
	281	/* ---------------------------------------------------------------------- */
	282
	283	static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
	284	{
	285	struct tuner *t;
	286
391cd727	287	#ifndef CONFIG_TUNER_MULTI_I2C
1da177e4 LT	288	if (this_adap > 0)
1da177e4 LT	289	return -1;
391cd727 MCC	290	#else
	291	/* by default, first I2C card is both tv and radio tuner */
	292	if (this_adap == 0) {
56fc08ca	293	first_tuner = addr;
391cd727 MCC	294	tv_tuner = addr;
	295	radio_tuner = addr;
	296	}
	297	#endif
1da177e4 LT	298	this_adap++;
	299
	300	client_template.adapter = adap;
	301	client_template.addr = addr;
	302
	303	t = kmalloc(sizeof(struct tuner),GFP_KERNEL);
	304	if (NULL == t)
	305	return -ENOMEM;
	306	memset(t,0,sizeof(struct tuner));
	307	memcpy(&t->i2c,&client_template,sizeof(struct i2c_client));
	308	i2c_set_clientdata(&t->i2c, t);
	309	t->type = UNSET;
56fc08ca	310	t->radio_if2 = 107001000; / 10.7MHz - FM radio */
1da177e4 LT	311
	312	i2c_attach_client(&t->i2c);
	313	tuner_info("chip found @ 0x%x (%s)\n",
	314	addr << 1, adap->name);
56fc08ca	315
1da177e4 LT	316	set_type(&t->i2c, t->type);
	317	return 0;
	318	}
	319
	320	static int tuner_probe(struct i2c_adapter *adap)
	321	{
	322	if (0 != addr) {
f5bec396 MCC	323	normal_i2c[0] = addr;
f5bec396 MCC	324	normal_i2c[1] = I2C_CLIENT_END;
1da177e4 LT	325	}
	326	this_adap = 0;
	327
391cd727	328	#ifdef CONFIG_TUNER_MULTI_I2C
56fc08ca	329	first_tuner = 0;
391cd727 MCC	330	tv_tuner = 0;
	331	radio_tuner = 0;
	332	#endif
	333
1da177e4 LT	334	if (adap->class & I2C_CLASS_TV_ANALOG)
	335	return i2c_probe(adap, &addr_data, tuner_attach);
	336	return 0;
	337	}
	338
	339	static int tuner_detach(struct i2c_client *client)
	340	{
	341	struct tuner *t = i2c_get_clientdata(client);
391cd727 MCC	342	int err;
	343
	344	err=i2c_detach_client(&t->i2c);
	345	if (err) {
	346	tuner_warn ("Client deregistration failed, client not detached.\n");
	347	return err;
	348	}
1da177e4	349
1da177e4 LT	350	kfree(t);
	351	return 0;
	352	}
	353
	354	#define SWITCH_V4L2 if (!t->using_v4l2 && tuner_debug) \
	355	tuner_info("switching to v4l2\n"); \
	356	t->using_v4l2 = 1;
	357	#define CHECK_V4L2 if (t->using_v4l2) { if (tuner_debug) \
	358	tuner_info("ignore v4l1 call\n"); \
	359	return 0; }
	360
	361	static int
	362	tuner_command(struct i2c_client client, unsigned int cmd, void arg)
	363	{
	364	struct tuner *t = i2c_get_clientdata(client);
	365	unsigned int iarg = (int)arg;
	366
	367	switch (cmd) {
1da177e4 LT	368	/* --- configuration --- */
	369	case TUNER_SET_TYPE:
	370	set_type(client,*iarg);
	371	break;
56fc08ca	372	case TUNER_SET_TYPE_ADDR:
391cd727 MCC	373	set_addr(client,(struct tuner_addr *)arg);
391cd727 MCC	374	break;
1da177e4	375	case AUDC_SET_RADIO:
56fc08ca MCC	376	t->mode = V4L2_TUNER_RADIO;
56fc08ca MCC	377	CHECK_ADDR(tv_tuner,"AUDC_SET_RADIO","TV");
391cd727	378
1da177e4 LT	379	if (V4L2_TUNER_RADIO != t->mode) {
1da177e4 LT	380	set_tv_freq(client,400 * 16);
1da177e4 LT	381	}
	382	break;
	383	case AUDC_CONFIG_PINNACLE:
56fc08ca	384	CHECK_ADDR(tv_tuner,"AUDC_CONFIG_PINNACLE","TV");
1da177e4 LT	385	switch (*iarg) {
	386	case 2:
	387	tuner_dbg("pinnacle pal\n");
	388	t->radio_if2 = 33300 * 1000;
	389	break;
	390	case 3:
	391	tuner_dbg("pinnacle ntsc\n");
	392	t->radio_if2 = 41300 * 1000;
	393	break;
	394	}
	395	break;
	396
	397	/* --- v4l ioctls --- */
	398	/* take care: bttv does userspace copying, we'll get a
	399	kernel pointer here... */
	400	case VIDIOCSCHAN:
	401	{
	402	static const v4l2_std_id map[] = {
	403	[ VIDEO_MODE_PAL ] = V4L2_STD_PAL,
	404	[ VIDEO_MODE_NTSC ] = V4L2_STD_NTSC_M,
	405	[ VIDEO_MODE_SECAM ] = V4L2_STD_SECAM,
	406	[ 4 /* bttv */ ] = V4L2_STD_PAL_M,
	407	[ 5 /* bttv */ ] = V4L2_STD_PAL_N,
	408	[ 6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
	409	};
	410	struct video_channel *vc = arg;
	411
	412	CHECK_V4L2;
	413	t->mode = V4L2_TUNER_ANALOG_TV;
56fc08ca MCC	414	CHECK_ADDR(tv_tuner,"VIDIOCSCHAN","TV");
56fc08ca MCC	415
1da177e4 LT	416	if (vc->norm < ARRAY_SIZE(map))
	417	t->std = map[vc->norm];
	418	tuner_fixup_std(t);
	419	if (t->freq)
	420	set_tv_freq(client,t->freq);
	421	return 0;
	422	}
	423	case VIDIOCSFREQ:
	424	{
	425	unsigned long *v = arg;
	426
391cd727	427	CHECK_MODE("VIDIOCSFREQ");
1da177e4 LT	428	CHECK_V4L2;
	429	set_freq(client,*v);
	430	return 0;
	431	}
	432	case VIDIOCGTUNER:
	433	{
	434	struct video_tuner *vt = arg;
	435
56fc08ca	436	CHECK_ADDR(radio_tuner,"VIDIOCGTUNER","radio");
1da177e4	437	CHECK_V4L2;
56fc08ca MCC	438	if (V4L2_TUNER_RADIO == t->mode) {
	439	if (t->has_signal)
	440	vt->signal = t->has_signal(client);
	441	if (t->is_stereo) {
	442	if (t->is_stereo(client))
	443	vt-> flags \|= VIDEO_TUNER_STEREO_ON;
	444	else
	445	vt-> flags &= 0xffff ^ VIDEO_TUNER_STEREO_ON;
	446	}
	447	vt->flags \|= V4L2_TUNER_CAP_LOW; /* Allow freqs at 62.5 Hz */
	448	}
	449
1da177e4 LT	450	return 0;
	451	}
	452	case VIDIOCGAUDIO:
	453	{
	454	struct video_audio *va = arg;
	455
56fc08ca	456	CHECK_ADDR(radio_tuner,"VIDIOCGAUDIO","radio");
1da177e4 LT	457	CHECK_V4L2;
	458	if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
	459	va->mode = t->is_stereo(client)
	460	? VIDEO_SOUND_STEREO
	461	: VIDEO_SOUND_MONO;
	462	return 0;
	463	}
	464
	465	case VIDIOC_S_STD:
	466	{
	467	v4l2_std_id *id = arg;
	468
	469	SWITCH_V4L2;
	470	t->mode = V4L2_TUNER_ANALOG_TV;
56fc08ca MCC	471	CHECK_ADDR(tv_tuner,"VIDIOC_S_STD","TV");
56fc08ca MCC	472
1da177e4 LT	473	t->std = *id;
	474	tuner_fixup_std(t);
	475	if (t->freq)
	476	set_freq(client,t->freq);
	477	break;
	478	}
	479	case VIDIOC_S_FREQUENCY:
	480	{
	481	struct v4l2_frequency *f = arg;
	482
391cd727	483	CHECK_MODE("VIDIOC_S_FREQUENCY");
1da177e4 LT	484	SWITCH_V4L2;
	485	if (V4L2_TUNER_RADIO == f->type &&
	486	V4L2_TUNER_RADIO != t->mode)
	487	set_tv_freq(client,400*16);
	488	t->mode = f->type;
e99d3438	489	set_freq(client,f->frequency);
1da177e4 LT	490	break;
1da177e4 LT	491	}
c184ca36 JB	492	case VIDIOC_G_FREQUENCY:
	493	{
	494	struct v4l2_frequency *f = arg;
	495
391cd727	496	CHECK_MODE("VIDIOC_G_FREQUENCY");
c184ca36 JB	497	SWITCH_V4L2;
	498	f->type = t->mode;
	499	f->frequency = t->freq;
	500	break;
	501	}
1da177e4 LT	502	case VIDIOC_G_TUNER:
	503	{
	504	struct v4l2_tuner *tuner = arg;
	505
391cd727	506	CHECK_MODE("VIDIOC_G_TUNER");
1da177e4	507	SWITCH_V4L2;
56fc08ca MCC	508	if (V4L2_TUNER_RADIO == t->mode) {
	509	if (t->has_signal)
	510	tuner -> signal = t->has_signal(client);
	511	if (t->is_stereo) {
	512	if (t->is_stereo(client)) {
	513	tuner -> capability \|= V4L2_TUNER_CAP_STEREO;
	514	tuner -> rxsubchans \|= V4L2_TUNER_SUB_STEREO;
	515	} else {
	516	tuner -> rxsubchans &= 0xffff ^ V4L2_TUNER_SUB_STEREO;
	517	}
	518	}
	519	}
	520	/* Wow to deal with V4L2_TUNER_CAP_LOW ? For now, it accepts from low at 62.5KHz step to high at 62.5 Hz */
c184ca36	521	tuner->rangelow = tv_range[0] * 16;
56fc08ca MCC	522	// tuner->rangehigh = tv_range[1] * 16;
	523	// tuner->rangelow = tv_range[0] * 16384;
	524	tuner->rangehigh = tv_range[1] * 16384;
1da177e4 LT	525	break;
	526	}
	527	default:
56fc08ca	528	tuner_dbg ("Unimplemented IOCTL 0x%08x called to tuner.\n", cmd);
1da177e4 LT	529	/* nothing */
	530	break;
	531	}
	532
	533	return 0;
	534	}
	535
56fc08ca	536	static int tuner_suspend(struct device * dev, u32 state, u32 level)
1da177e4 LT	537	{
	538	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	539	struct tuner *t = i2c_get_clientdata(c);
	540
	541	tuner_dbg("suspend\n");
	542	/* FIXME: power down ??? */
	543	return 0;
	544	}
	545
	546	static int tuner_resume(struct device * dev, u32 level)
	547	{
	548	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	549	struct tuner *t = i2c_get_clientdata(c);
	550
	551	tuner_dbg("resume\n");
	552	if (t->freq)
	553	set_freq(c,t->freq);
	554	return 0;
	555	}
	556
	557	/* ----------------------------------------------------------------------- */
	558
	559	static struct i2c_driver driver = {
	560	.owner = THIS_MODULE,
	561	.name = "tuner",
	562	.id = I2C_DRIVERID_TUNER,
	563	.flags = I2C_DF_NOTIFY,
	564	.attach_adapter = tuner_probe,
	565	.detach_client = tuner_detach,
	566	.command = tuner_command,
	567	.driver = {
	568	.suspend = tuner_suspend,
	569	.resume = tuner_resume,
	570	},
	571	};
	572	static struct i2c_client client_template =
	573	{
	574	I2C_DEVNAME("(tuner unset)"),
	575	.flags = I2C_CLIENT_ALLOW_USE,
	576	.driver = &driver,
	577	};
	578
	579	static int __init tuner_init_module(void)
	580	{
	581	return i2c_add_driver(&driver);
	582	}
	583
	584	static void __exit tuner_cleanup_module(void)
	585	{
	586	i2c_del_driver(&driver);
	587	}
	588
	589	module_init(tuner_init_module);
	590	module_exit(tuner_cleanup_module);
	591
	592	/*
	593	* Overrides for Emacs so that we follow Linus's tabbing style.
	594	* ---------------------------------------------------------------------------
	595	* Local variables:
	596	* c-basic-offset: 8
	597	* End:
	598	*/