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

/*
 * $Id: tuner-core.c,v 1.7 2005/05/30 02:02:47 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 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) {
		/* 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;
	}
	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) {
		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;
	}
	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;
}

#ifdef CONFIG_TUNER_MULTI_I2C
static void set_addr(struct i2c_client *c, struct tuner_addr *tun_addr)
{
	struct tuner *t = i2c_get_clientdata(c);

	switch (tun_addr->type) {
	case V4L2_TUNER_RADIO:
 		radio_tuner=tun_addr->addr;
		tuner_dbg("radio tuner set to I2C address 0x%02x\n",radio_tuner<<1);

		break;
	default:
		tv_tuner=tun_addr->addr;
		tuner_dbg("TV tuner set to I2C address 0x%02x\n",tv_tuner<<1);
		break;
	}
}
#else
#define set_addr(c,tun_addr) \
		tuner_warn("It is recommended to enable CONFIG_TUNER_MULTI_I2C for this card.\n");
#endif

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

	/* 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;
	}
}

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) {
		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
	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; }

#ifdef CONFIG_TUNER_MULTI_I2C
#define CHECK_ADDR(tp,cmd)	if (client->addr!=tp) { \
			  tuner_info ("Cmd %s to addr 0x%02x rejected.\n",cmd,client->addr<<1); \
			  return 0; }
#define CHECK_MODE(cmd)	if (t->mode == V4L2_TUNER_RADIO) { \
			  CHECK_ADDR(radio_tuner,cmd) } else { CHECK_ADDR(tv_tuner,cmd); }
#else
#define CHECK_ADDR(tp,cmd)
#define CHECK_MODE(cmd)
#endif

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_ADDR:
		set_addr(client,(struct tuner_addr *)arg);
		break;
	case AUDC_SET_RADIO:
		CHECK_ADDR(radio_tuner,"AUDC_SET_RADIO");

		if (V4L2_TUNER_RADIO != t->mode) {
			set_tv_freq(client,400 * 16);
			t->mode = V4L2_TUNER_RADIO;
		}
		break;
	case AUDC_CONFIG_PINNACLE:
		CHECK_ADDR(tv_tuner,"AUDC_CONFIG_PINNACLE");
		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_ADDR(tv_tuner,"VIDIOCSCHAN");
		CHECK_V4L2;
		t->mode = V4L2_TUNER_ANALOG_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:");
		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode  &&  t->has_signal)
			vt->signal = t->has_signal(client);
		return 0;
	}
	case VIDIOCGAUDIO:
	{
		struct video_audio *va = arg;

		CHECK_ADDR(radio_tuner,"VIDIOCGAUDIO");
		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;

		CHECK_ADDR(tv_tuner,"VIDIOC_S_STD");
		SWITCH_V4L2;
		t->mode = V4L2_TUNER_ANALOG_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  &&  t->has_signal)
			tuner->signal = t->has_signal(client);
		tuner->rangelow = tv_range[0] * 16;
		tuner->rangehigh = tv_range[1] * 16;
		break;
	}
	default:
		/* nothing */
		break;
	}

	return 0;
}

static int tuner_suspend(struct device * dev, pm_message_t 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	/*
391cd727	2	* $Id: tuner-core.c,v 1.7 2005/05/30 02:02:47 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	*/
	29	/* #define CONFIG_TUNER_MULTI_I2C */
	30
1da177e4 LT	31	#define UNSET (-1U)
	32
	33	/* standard i2c insmod options */
	34	static unsigned short normal_i2c[] = {
	35	0x4b, /* tda8290 */
b3d5496e JD	36	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
b3d5496e JD	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 MCC	61	#ifdef CONFIG_TUNER_MULTI_I2C
	62	static unsigned short tv_tuner, radio_tuner;
	63	#endif
1da177e4 LT	64
	65	static struct i2c_driver driver;
	66	static struct i2c_client client_template;
	67
	68	/* ---------------------------------------------------------------------- */
	69
	70	// Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz
	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) {
	84	/* FIXME: better do that chip-specific, but
	85	right now we don't have that in the config
	86	struct and this way is still better than no
	87	check at all */
	88	tuner_info("TV freq (%d.%02d) out of range (%d-%d)\n",
	89	freq/16,freq%16*100/16,tv_range[0],tv_range[1]);
	90	return;
	91	}
	92	t->tv_freq(c,freq);
	93	}
	94
	95	static void set_radio_freq(struct i2c_client *c, unsigned int freq)
	96	{
	97	struct tuner *t = i2c_get_clientdata(c);
	98
	99	if (t->type == UNSET) {
	100	tuner_info("tuner type not set\n");
	101	return;
	102	}
	103	if (NULL == t->radio_freq) {
	104	tuner_info("no radio tuning for this one, sorry.\n");
	105	return;
	106	}
	107	if (freq < radio_range[0]16 \|\| freq > radio_range[1]16) {
	108	tuner_info("radio freq (%d.%02d) out of range (%d-%d)\n",
	109	freq/16,freq%16*100/16,
	110	radio_range[0],radio_range[1]);
	111	return;
	112	}
	113	t->radio_freq(c,freq);
	114	}
	115
	116	static void set_freq(struct i2c_client *c, unsigned long freq)
	117	{
	118	struct tuner *t = i2c_get_clientdata(c);
	119
	120	switch (t->mode) {
	121	case V4L2_TUNER_RADIO:
	122	tuner_dbg("radio freq set to %lu.%02lu\n",
	123	freq/16,freq%16*100/16);
	124	set_radio_freq(c,freq);
	125	break;
	126	case V4L2_TUNER_ANALOG_TV:
	127	case V4L2_TUNER_DIGITAL_TV:
128	tuner_dbg("tv freq set to %lu.%02lu\n",
129	freq/16,freq%16*100/16);
130	set_tv_freq(c, freq);
131	break;
132	}
133	t->freq = freq;
134	}
135
391cd727 MCC	136	#ifdef CONFIG_TUNER_MULTI_I2C
	137	static void set_addr(struct i2c_client c, struct tuner_addr tun_addr)
	138	{
	139	struct tuner *t = i2c_get_clientdata(c);
	140
	141	switch (tun_addr->type) {
	142	case V4L2_TUNER_RADIO:
	143	radio_tuner=tun_addr->addr;
	144	tuner_dbg("radio tuner set to I2C address 0x%02x\n",radio_tuner<<1);
	145
	146	break;
	147	default:
	148	tv_tuner=tun_addr->addr;
	149	tuner_dbg("TV tuner set to I2C address 0x%02x\n",tv_tuner<<1);
	150	break;
	151	}
	152	}
	153	#else
	154	#define set_addr(c,tun_addr) \
	155	tuner_warn("It is recommended to enable CONFIG_TUNER_MULTI_I2C for this card.\n");
	156	#endif
	157
1da177e4 LT	158	static void set_type(struct i2c_client *c, unsigned int type)
	159	{
	160	struct tuner *t = i2c_get_clientdata(c);
	161
	162	/* sanity check */
	163	if (type == UNSET \|\| type == TUNER_ABSENT)
	164	return;
	165	if (type >= tuner_count)
	166	return;
	167
	168	if (NULL == t->i2c.dev.driver) {
	169	/* not registered yet */
	170	t->type = type;
	171	return;
	172	}
	173	if (t->initialized)
	174	/* run only once */
	175	return;
	176
	177	t->initialized = 1;
	178	t->type = type;
	179	switch (t->type) {
	180	case TUNER_MT2032:
	181	microtune_init(c);
	182	break;
	183	case TUNER_PHILIPS_TDA8290:
	184	tda8290_init(c);
	185	break;
	186	default:
	187	default_tuner_init(c);
	188	break;
	189	}
	190	}
	191
	192	static char pal[] = "-";
975e046c	193	module_param_string(pal, pal, sizeof(pal), 0644);
1da177e4 LT	194
	195	static int tuner_fixup_std(struct tuner *t)
	196	{
	197	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
	198	/* get more precise norm info from insmod option */
	199	switch (pal[0]) {
	200	case 'b':
	201	case 'B':
	202	case 'g':
	203	case 'G':
	204	tuner_dbg("insmod fixup: PAL => PAL-BG\n");
	205	t->std = V4L2_STD_PAL_BG;
	206	break;
	207	case 'i':
	208	case 'I':
	209	tuner_dbg("insmod fixup: PAL => PAL-I\n");
	210	t->std = V4L2_STD_PAL_I;
	211	break;
	212	case 'd':
	213	case 'D':
	214	case 'k':
	215	case 'K':
	216	tuner_dbg("insmod fixup: PAL => PAL-DK\n");
	217	t->std = V4L2_STD_PAL_DK;
	218	break;
	219	}
	220	}
	221	return 0;
	222	}
	223
	224	/* ---------------------------------------------------------------------- */
	225
	226	static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
	227	{
	228	struct tuner *t;
	229
391cd727	230	#ifndef CONFIG_TUNER_MULTI_I2C
1da177e4 LT	231	if (this_adap > 0)
1da177e4 LT	232	return -1;
391cd727 MCC	233	#else
	234	/* by default, first I2C card is both tv and radio tuner */
	235	if (this_adap == 0) {
	236	tv_tuner = addr;
	237	radio_tuner = addr;
	238	}
	239	#endif
1da177e4 LT	240	this_adap++;
	241
	242	client_template.adapter = adap;
	243	client_template.addr = addr;
	244
	245	t = kmalloc(sizeof(struct tuner),GFP_KERNEL);
	246	if (NULL == t)
	247	return -ENOMEM;
	248	memset(t,0,sizeof(struct tuner));
	249	memcpy(&t->i2c,&client_template,sizeof(struct i2c_client));
	250	i2c_set_clientdata(&t->i2c, t);
	251	t->type = UNSET;
	252	t->radio_if2 = 10700*1000; // 10.7MHz - FM radio
	253
	254	i2c_attach_client(&t->i2c);
	255	tuner_info("chip found @ 0x%x (%s)\n",
	256	addr << 1, adap->name);
	257	set_type(&t->i2c, t->type);
	258	return 0;
	259	}
	260
	261	static int tuner_probe(struct i2c_adapter *adap)
	262	{
	263	if (0 != addr) {
b3d5496e JD	264	normal_i2c[0] = addr;
b3d5496e JD	265	normal_i2c[1] = I2C_CLIENT_END;
1da177e4 LT	266	}
	267	this_adap = 0;
	268
391cd727 MCC	269	#ifdef CONFIG_TUNER_MULTI_I2C
	270	tv_tuner = 0;
	271	radio_tuner = 0;
	272	#endif
	273
1da177e4 LT	274	if (adap->class & I2C_CLASS_TV_ANALOG)
	275	return i2c_probe(adap, &addr_data, tuner_attach);
	276	return 0;
	277	}
	278
	279	static int tuner_detach(struct i2c_client *client)
	280	{
	281	struct tuner *t = i2c_get_clientdata(client);
391cd727 MCC	282	int err;
	283
	284	err=i2c_detach_client(&t->i2c);
	285	if (err) {
	286	tuner_warn ("Client deregistration failed, client not detached.\n");
	287	return err;
	288	}
1da177e4	289
1da177e4 LT	290	kfree(t);
	291	return 0;
	292	}
	293
	294	#define SWITCH_V4L2 if (!t->using_v4l2 && tuner_debug) \
	295	tuner_info("switching to v4l2\n"); \
	296	t->using_v4l2 = 1;
	297	#define CHECK_V4L2 if (t->using_v4l2) { if (tuner_debug) \
	298	tuner_info("ignore v4l1 call\n"); \
	299	return 0; }
	300
391cd727 MCC	301	#ifdef CONFIG_TUNER_MULTI_I2C
	302	#define CHECK_ADDR(tp,cmd) if (client->addr!=tp) { \
	303	tuner_info ("Cmd %s to addr 0x%02x rejected.\n",cmd,client->addr<<1); \
	304	return 0; }
	305	#define CHECK_MODE(cmd) if (t->mode == V4L2_TUNER_RADIO) { \
	306	CHECK_ADDR(radio_tuner,cmd) } else { CHECK_ADDR(tv_tuner,cmd); }
	307	#else
	308	#define CHECK_ADDR(tp,cmd)
	309	#define CHECK_MODE(cmd)
	310	#endif
	311
1da177e4 LT	312	static int
	313	tuner_command(struct i2c_client client, unsigned int cmd, void arg)
	314	{
	315	struct tuner *t = i2c_get_clientdata(client);
	316	unsigned int iarg = (int)arg;
	317
	318	switch (cmd) {
1da177e4 LT	319	/* --- configuration --- */
	320	case TUNER_SET_TYPE:
	321	set_type(client,*iarg);
	322	break;
391cd727 MCC	323	case TUNER_SET_ADDR:
	324	set_addr(client,(struct tuner_addr *)arg);
	325	break;
1da177e4	326	case AUDC_SET_RADIO:
391cd727 MCC	327	CHECK_ADDR(radio_tuner,"AUDC_SET_RADIO");
391cd727 MCC	328
1da177e4 LT	329	if (V4L2_TUNER_RADIO != t->mode) {
	330	set_tv_freq(client,400 * 16);
	331	t->mode = V4L2_TUNER_RADIO;
	332	}
	333	break;
	334	case AUDC_CONFIG_PINNACLE:
391cd727	335	CHECK_ADDR(tv_tuner,"AUDC_CONFIG_PINNACLE");
1da177e4 LT	336	switch (*iarg) {
	337	case 2:
	338	tuner_dbg("pinnacle pal\n");
	339	t->radio_if2 = 33300 * 1000;
	340	break;
	341	case 3:
	342	tuner_dbg("pinnacle ntsc\n");
	343	t->radio_if2 = 41300 * 1000;
	344	break;
	345	}
	346	break;
	347
	348	/* --- v4l ioctls --- */
	349	/* take care: bttv does userspace copying, we'll get a
	350	kernel pointer here... */
	351	case VIDIOCSCHAN:
	352	{
	353	static const v4l2_std_id map[] = {
	354	[ VIDEO_MODE_PAL ] = V4L2_STD_PAL,
	355	[ VIDEO_MODE_NTSC ] = V4L2_STD_NTSC_M,
	356	[ VIDEO_MODE_SECAM ] = V4L2_STD_SECAM,
	357	[ 4 /* bttv */ ] = V4L2_STD_PAL_M,
	358	[ 5 /* bttv */ ] = V4L2_STD_PAL_N,
	359	[ 6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
	360	};
	361	struct video_channel *vc = arg;
	362
391cd727	363	CHECK_ADDR(tv_tuner,"VIDIOCSCHAN");
1da177e4 LT	364	CHECK_V4L2;
	365	t->mode = V4L2_TUNER_ANALOG_TV;
	366	if (vc->norm < ARRAY_SIZE(map))
	367	t->std = map[vc->norm];
	368	tuner_fixup_std(t);
	369	if (t->freq)
	370	set_tv_freq(client,t->freq);
	371	return 0;
	372	}
	373	case VIDIOCSFREQ:
	374	{
	375	unsigned long *v = arg;
	376
391cd727	377	CHECK_MODE("VIDIOCSFREQ");
1da177e4 LT	378	CHECK_V4L2;
	379	set_freq(client,*v);
	380	return 0;
	381	}
	382	case VIDIOCGTUNER:
	383	{
	384	struct video_tuner *vt = arg;
	385
391cd727	386	CHECK_ADDR(radio_tuner,"VIDIOCGTUNER:");
1da177e4 LT	387	CHECK_V4L2;
	388	if (V4L2_TUNER_RADIO == t->mode && t->has_signal)
	389	vt->signal = t->has_signal(client);
	390	return 0;
	391	}
	392	case VIDIOCGAUDIO:
	393	{
	394	struct video_audio *va = arg;
	395
391cd727	396	CHECK_ADDR(radio_tuner,"VIDIOCGAUDIO");
1da177e4 LT	397	CHECK_V4L2;
	398	if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
	399	va->mode = t->is_stereo(client)
	400	? VIDEO_SOUND_STEREO
	401	: VIDEO_SOUND_MONO;
	402	return 0;
	403	}
	404
	405	case VIDIOC_S_STD:
	406	{
	407	v4l2_std_id *id = arg;
	408
391cd727	409	CHECK_ADDR(tv_tuner,"VIDIOC_S_STD");
1da177e4 LT	410	SWITCH_V4L2;
	411	t->mode = V4L2_TUNER_ANALOG_TV;
	412	t->std = *id;
	413	tuner_fixup_std(t);
	414	if (t->freq)
	415	set_freq(client,t->freq);
	416	break;
	417	}
	418	case VIDIOC_S_FREQUENCY:
	419	{
	420	struct v4l2_frequency *f = arg;
	421
391cd727	422	CHECK_MODE("VIDIOC_S_FREQUENCY");
1da177e4 LT	423	SWITCH_V4L2;
	424	if (V4L2_TUNER_RADIO == f->type &&
	425	V4L2_TUNER_RADIO != t->mode)
	426	set_tv_freq(client,400*16);
	427	t->mode = f->type;
e99d3438	428	set_freq(client,f->frequency);
1da177e4 LT	429	break;
1da177e4 LT	430	}
c184ca36 JB	431	case VIDIOC_G_FREQUENCY:
	432	{
	433	struct v4l2_frequency *f = arg;
	434
391cd727	435	CHECK_MODE("VIDIOC_G_FREQUENCY");
c184ca36 JB	436	SWITCH_V4L2;
	437	f->type = t->mode;
	438	f->frequency = t->freq;
	439	break;
	440	}
1da177e4 LT	441	case VIDIOC_G_TUNER:
	442	{
	443	struct v4l2_tuner *tuner = arg;
	444
391cd727	445	CHECK_MODE("VIDIOC_G_TUNER");
1da177e4 LT	446	SWITCH_V4L2;
	447	if (V4L2_TUNER_RADIO == t->mode && t->has_signal)
	448	tuner->signal = t->has_signal(client);
c184ca36 JB	449	tuner->rangelow = tv_range[0] * 16;
c184ca36 JB	450	tuner->rangehigh = tv_range[1] * 16;
1da177e4 LT	451	break;
	452	}
	453	default:
	454	/* nothing */
	455	break;
	456	}
	457
	458	return 0;
	459	}
	460
a2910689	461	static int tuner_suspend(struct device * dev, pm_message_t state, u32 level)
1da177e4 LT	462	{
	463	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	464	struct tuner *t = i2c_get_clientdata(c);
	465
	466	tuner_dbg("suspend\n");
	467	/* FIXME: power down ??? */
	468	return 0;
	469	}
	470
	471	static int tuner_resume(struct device * dev, u32 level)
	472	{
	473	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	474	struct tuner *t = i2c_get_clientdata(c);
	475
	476	tuner_dbg("resume\n");
	477	if (t->freq)
	478	set_freq(c,t->freq);
	479	return 0;
	480	}
	481
	482	/* ----------------------------------------------------------------------- */
	483
	484	static struct i2c_driver driver = {
	485	.owner = THIS_MODULE,
	486	.name = "tuner",
	487	.id = I2C_DRIVERID_TUNER,
	488	.flags = I2C_DF_NOTIFY,
	489	.attach_adapter = tuner_probe,
	490	.detach_client = tuner_detach,
	491	.command = tuner_command,
	492	.driver = {
	493	.suspend = tuner_suspend,
	494	.resume = tuner_resume,
	495	},
	496	};
	497	static struct i2c_client client_template =
	498	{
	499	I2C_DEVNAME("(tuner unset)"),
	500	.flags = I2C_CLIENT_ALLOW_USE,
	501	.driver = &driver,
	502	};
	503
	504	static int __init tuner_init_module(void)
	505	{
	506	return i2c_add_driver(&driver);
	507	}
	508
	509	static void __exit tuner_cleanup_module(void)
	510	{
	511	i2c_del_driver(&driver);
	512	}
	513
	514	module_init(tuner_init_module);
	515	module_exit(tuner_cleanup_module);
	516
	517	/*
	518	* Overrides for Emacs so that we follow Linus's tabbing style.
	519	* ---------------------------------------------------------------------------
	520	* Local variables:
	521	* c-basic-offset: 8
	522	* End:
	523	*/