[net-next-2.6.git] / drivers / media / video / tvmixer.c

/*
 */

#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/i2c.h>
#include <linux/videodev.h>
#include <linux/init.h>
#include <linux/kdev_t.h>
#include <linux/sound.h>
#include <linux/soundcard.h>

#include <asm/semaphore.h>
#include <asm/uaccess.h>


#define DEV_MAX  4

static int devnr = -1;
module_param(devnr, int, 0644);

MODULE_AUTHOR("Gerd Knorr");
MODULE_LICENSE("GPL");

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

struct TVMIXER {
	struct i2c_client *dev;
	int minor;
	int count;
};

static struct TVMIXER devices[DEV_MAX];

static int tvmixer_adapters(struct i2c_adapter *adap);
static int tvmixer_clients(struct i2c_client *client);

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

static int mix_to_v4l(int i)
{
	int r;

	r = ((i & 0xff) * 65536 + 50) / 100;
	if (r > 65535) r = 65535;
	if (r <     0) r =     0;
	return r;
}

static int v4l_to_mix(int i)
{
	int r;

	r = (i * 100 + 32768) / 65536;
	if (r > 100) r = 100;
	if (r <   0) r =   0;
	return r | (r << 8);
}

static int v4l_to_mix2(int l, int r)
{
	r = (r * 100 + 32768) / 65536;
	if (r > 100) r = 100;
	if (r <   0) r =   0;
	l = (l * 100 + 32768) / 65536;
	if (l > 100) l = 100;
	if (l <   0) l =   0;
	return (r << 8) | l;
}

static int tvmixer_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	struct video_audio va;
	int left,right,ret,val = 0;
        struct TVMIXER *mix = file->private_data;
	struct i2c_client *client = mix->dev;
	void __user *argp = (void __user *)arg;
	int __user *p = argp;

	if (NULL == client)
		return -ENODEV;

        if (cmd == SOUND_MIXER_INFO) {
                mixer_info info;
                strlcpy(info.id, "tv card", sizeof(info.id));
                strlcpy(info.name, client->name, sizeof(info.name));
                info.modify_counter = 42 /* FIXME */;
                if (copy_to_user(argp, &info, sizeof(info)))
                        return -EFAULT;
                return 0;
        }
        if (cmd == SOUND_OLD_MIXER_INFO) {
                _old_mixer_info info;
                strlcpy(info.id, "tv card", sizeof(info.id));
                strlcpy(info.name, client->name, sizeof(info.name));
                if (copy_to_user(argp, &info, sizeof(info)))
                        return -EFAULT;
                return 0;
        }
        if (cmd == OSS_GETVERSION)
                return put_user(SOUND_VERSION, p);

	if (_SIOC_DIR(cmd) & _SIOC_WRITE)
		if (get_user(val, p))
			return -EFAULT;

	/* read state */
	memset(&va,0,sizeof(va));
	client->driver->command(client,VIDIOCGAUDIO,&va);

	switch (cmd) {
	case MIXER_READ(SOUND_MIXER_RECMASK):
	case MIXER_READ(SOUND_MIXER_CAPS):
	case MIXER_READ(SOUND_MIXER_RECSRC):
	case MIXER_WRITE(SOUND_MIXER_RECSRC):
		ret = 0;
		break;

	case MIXER_READ(SOUND_MIXER_STEREODEVS):
		ret = SOUND_MASK_VOLUME;
		break;
	case MIXER_READ(SOUND_MIXER_DEVMASK):
		ret = SOUND_MASK_VOLUME;
		if (va.flags & VIDEO_AUDIO_BASS)
			ret |= SOUND_MASK_BASS;
		if (va.flags & VIDEO_AUDIO_TREBLE)
			ret |= SOUND_MASK_TREBLE;
		break;

	case MIXER_WRITE(SOUND_MIXER_VOLUME):
		left  = mix_to_v4l(val);
		right = mix_to_v4l(val >> 8);
		va.volume  = max(left,right);
		va.balance = (32768*min(left,right)) / (va.volume ? va.volume : 1);
		va.balance = (left<right) ? (65535-va.balance) : va.balance;
		if (va.volume)
			va.flags &= ~VIDEO_AUDIO_MUTE;
		client->driver->command(client,VIDIOCSAUDIO,&va);
		client->driver->command(client,VIDIOCGAUDIO,&va);
		/* fall throuth */
	case MIXER_READ(SOUND_MIXER_VOLUME):
		left  = (min(65536 - va.balance,32768) *
			 va.volume) / 32768;
		right = (min(va.balance,(u16)32768) *
			 va.volume) / 32768;
		ret = v4l_to_mix2(left,right);
		break;

	case MIXER_WRITE(SOUND_MIXER_BASS):
		va.bass = mix_to_v4l(val);
		client->driver->command(client,VIDIOCSAUDIO,&va);
		client->driver->command(client,VIDIOCGAUDIO,&va);
		/* fall throuth  */
	case MIXER_READ(SOUND_MIXER_BASS):
		ret = v4l_to_mix(va.bass);
		break;

	case MIXER_WRITE(SOUND_MIXER_TREBLE):
		va.treble = mix_to_v4l(val);
		client->driver->command(client,VIDIOCSAUDIO,&va);
		client->driver->command(client,VIDIOCGAUDIO,&va);
		/* fall throuth */
	case MIXER_READ(SOUND_MIXER_TREBLE):
		ret = v4l_to_mix(va.treble);
		break;

	default:
		return -EINVAL;
	}
	if (put_user(ret, p))
		return -EFAULT;
	return 0;
}

static int tvmixer_open(struct inode *inode, struct file *file)
{
        int i, minor = iminor(inode);
        struct TVMIXER *mix = NULL;
	struct i2c_client *client = NULL;

	for (i = 0; i < DEV_MAX; i++) {
		if (devices[i].minor == minor) {
			mix = devices+i;
			client = mix->dev;
			break;
		}
	}

	if (NULL == client)
		return -ENODEV;

	/* lock bttv in memory while the mixer is in use  */
	file->private_data = mix;
#ifndef I2C_PEC
	if (client->adapter->inc_use)
		client->adapter->inc_use(client->adapter);
#endif
	if (client->adapter->owner)
		try_module_get(client->adapter->owner);
        return 0;
}

static int tvmixer_release(struct inode *inode, struct file *file)
{
	struct TVMIXER *mix = file->private_data;
	struct i2c_client *client;

	client = mix->dev;
	if (NULL == client) {
		return -ENODEV;
	}

#ifndef I2C_PEC
	if (client->adapter->dec_use)
		client->adapter->dec_use(client->adapter);
#endif
	if (client->adapter->owner)
		module_put(client->adapter->owner);
	return 0;
}

static struct i2c_driver driver = {
#ifdef I2C_PEC
	.owner           = THIS_MODULE,
#endif
	.name            = "tv card mixer driver",
        .id              = I2C_DRIVERID_TVMIXER,
#ifdef I2C_DF_DUMMY
	.flags           = I2C_DF_DUMMY,
#else
	.flags           = I2C_DF_NOTIFY,
        .detach_adapter  = tvmixer_adapters,
#endif
        .attach_adapter  = tvmixer_adapters,
        .detach_client   = tvmixer_clients,
};

static struct file_operations tvmixer_fops = {
	.owner		= THIS_MODULE,
	.llseek         = no_llseek,
	.ioctl          = tvmixer_ioctl,
	.open           = tvmixer_open,
	.release        = tvmixer_release,
};

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

static int tvmixer_adapters(struct i2c_adapter *adap)
{
	struct list_head  *item;
	struct i2c_client *client;

	list_for_each(item,&adap->clients) {
		client = list_entry(item, struct i2c_client, list);
		tvmixer_clients(client);
	}
	return 0;
}

static int tvmixer_clients(struct i2c_client *client)
{
	struct video_audio va;
	int i,minor;

#ifdef I2C_CLASS_TV_ANALOG
	if (!(client->adapter->class & I2C_CLASS_TV_ANALOG))
		return -1;
#else
	/* TV card ??? */
	switch (client->adapter->id) {
	case I2C_HW_SMBUS_VOODOO3:
	case I2C_HW_B_BT848:
	case I2C_HW_B_RIVA:
		/* ok, have a look ... */
		break;
	default:
		/* ignore that one */
		return -1;
	}
#endif

	/* unregister ?? */
	for (i = 0; i < DEV_MAX; i++) {
		if (devices[i].dev == client) {
			/* unregister */
			unregister_sound_mixer(devices[i].minor);
			devices[i].dev = NULL;
			devices[i].minor = -1;
			printk("tvmixer: %s unregistered (#1)\n",
			       client->name);
			return 0;
		}
	}

	/* look for a free slot */
	for (i = 0; i < DEV_MAX; i++)
		if (NULL == devices[i].dev)
			break;
	if (i == DEV_MAX) {
		printk(KERN_WARNING "tvmixer: DEV_MAX too small\n");
		return -1;
	}

	/* audio chip with mixer ??? */
	if (NULL == client->driver->command)
		return -1;
	memset(&va,0,sizeof(va));
	if (0 != client->driver->command(client,VIDIOCGAUDIO,&va))
		return -1;
	if (0 == (va.flags & VIDEO_AUDIO_VOLUME))
		return -1;

	/* everything is fine, register */
	if ((minor = register_sound_mixer(&tvmixer_fops,devnr)) < 0) {
		printk(KERN_ERR "tvmixer: cannot allocate mixer device\n");
		return -1;
	}

	devices[i].minor = minor;
	devices[i].count = 0;
	devices[i].dev   = client;
	printk("tvmixer: %s (%s) registered with minor %d\n",
	       client->name,client->adapter->name,minor);

	return 0;
}

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

static int __init tvmixer_init_module(void)
{
	int i;

	for (i = 0; i < DEV_MAX; i++)
		devices[i].minor = -1;

	return i2c_add_driver(&driver);
}

static void __exit tvmixer_cleanup_module(void)
{
	int i;

	i2c_del_driver(&driver);
	for (i = 0; i < DEV_MAX; i++) {
		if (devices[i].minor != -1) {
			unregister_sound_mixer(devices[i].minor);
			printk("tvmixer: %s unregistered (#2)\n",
			       devices[i].dev->name);
		}
	}
}

module_init(tvmixer_init_module);
module_exit(tvmixer_cleanup_module);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
Commit	Line	Data
56fc08ca	1	/*
56fc08ca MCC	2	*/
56fc08ca MCC	3
1da177e4 LT	4	#include <linux/module.h>
	5	#include <linux/moduleparam.h>
	6	#include <linux/kernel.h>
	7	#include <linux/sched.h>
	8	#include <linux/string.h>
	9	#include <linux/timer.h>
	10	#include <linux/delay.h>
	11	#include <linux/errno.h>
	12	#include <linux/slab.h>
	13	#include <linux/i2c.h>
	14	#include <linux/videodev.h>
	15	#include <linux/init.h>
	16	#include <linux/kdev_t.h>
	17	#include <linux/sound.h>
	18	#include <linux/soundcard.h>
	19
	20	#include <asm/semaphore.h>
	21	#include <asm/uaccess.h>
	22
	23
	24	#define DEV_MAX 4
	25
	26	static int devnr = -1;
	27	module_param(devnr, int, 0644);
	28
	29	MODULE_AUTHOR("Gerd Knorr");
	30	MODULE_LICENSE("GPL");
	31
	32	/* ----------------------------------------------------------------------- */
	33
	34	struct TVMIXER {
	35	struct i2c_client *dev;
	36	int minor;
	37	int count;
	38	};
	39
	40	static struct TVMIXER devices[DEV_MAX];
	41
	42	static int tvmixer_adapters(struct i2c_adapter *adap);
	43	static int tvmixer_clients(struct i2c_client *client);
	44
	45	/* ----------------------------------------------------------------------- */
	46
	47	static int mix_to_v4l(int i)
	48	{
	49	int r;
	50
	51	r = ((i & 0xff) * 65536 + 50) / 100;
	52	if (r > 65535) r = 65535;
	53	if (r < 0) r = 0;
	54	return r;
	55	}
	56
	57	static int v4l_to_mix(int i)
	58	{
	59	int r;
	60
	61	r = (i * 100 + 32768) / 65536;
	62	if (r > 100) r = 100;
	63	if (r < 0) r = 0;
	64	return r \| (r << 8);
	65	}
	66
	67	static int v4l_to_mix2(int l, int r)
68	{
69	r = (r * 100 + 32768) / 65536;
70	if (r > 100) r = 100;
71	if (r < 0) r = 0;
72	l = (l * 100 + 32768) / 65536;
73	if (l > 100) l = 100;
74	if (l < 0) l = 0;
75	return (r << 8) \| l;
76	}
77
78	static int tvmixer_ioctl(struct inode inode, struct file file, unsigned int cmd, unsigned long arg)
79	{
80	struct video_audio va;
81	int left,right,ret,val = 0;
82	struct TVMIXER *mix = file->private_data;
83	struct i2c_client *client = mix->dev;
84	void __user argp = (void __user )arg;
85	int __user *p = argp;
86
87	if (NULL == client)
88	return -ENODEV;
89
90	if (cmd == SOUND_MIXER_INFO) {
91	mixer_info info;
92	strlcpy(info.id, "tv card", sizeof(info.id));
fae91e72	93	strlcpy(info.name, client->name, sizeof(info.name));
1da177e4 LT	94	info.modify_counter = 42 /* FIXME */;
	95	if (copy_to_user(argp, &info, sizeof(info)))
	96	return -EFAULT;
	97	return 0;
	98	}
	99	if (cmd == SOUND_OLD_MIXER_INFO) {
	100	_old_mixer_info info;
	101	strlcpy(info.id, "tv card", sizeof(info.id));
fae91e72	102	strlcpy(info.name, client->name, sizeof(info.name));
1da177e4 LT	103	if (copy_to_user(argp, &info, sizeof(info)))
	104	return -EFAULT;
	105	return 0;
	106	}
	107	if (cmd == OSS_GETVERSION)
	108	return put_user(SOUND_VERSION, p);
	109
	110	if (_SIOC_DIR(cmd) & _SIOC_WRITE)
	111	if (get_user(val, p))
	112	return -EFAULT;
	113
	114	/* read state */
	115	memset(&va,0,sizeof(va));
	116	client->driver->command(client,VIDIOCGAUDIO,&va);
	117
	118	switch (cmd) {
	119	case MIXER_READ(SOUND_MIXER_RECMASK):
	120	case MIXER_READ(SOUND_MIXER_CAPS):
	121	case MIXER_READ(SOUND_MIXER_RECSRC):
	122	case MIXER_WRITE(SOUND_MIXER_RECSRC):
	123	ret = 0;
	124	break;
	125
	126	case MIXER_READ(SOUND_MIXER_STEREODEVS):
	127	ret = SOUND_MASK_VOLUME;
	128	break;
	129	case MIXER_READ(SOUND_MIXER_DEVMASK):
	130	ret = SOUND_MASK_VOLUME;
	131	if (va.flags & VIDEO_AUDIO_BASS)
	132	ret \|= SOUND_MASK_BASS;
	133	if (va.flags & VIDEO_AUDIO_TREBLE)
	134	ret \|= SOUND_MASK_TREBLE;
	135	break;
	136
	137	case MIXER_WRITE(SOUND_MIXER_VOLUME):
	138	left = mix_to_v4l(val);
	139	right = mix_to_v4l(val >> 8);
	140	va.volume = max(left,right);
	141	va.balance = (32768*min(left,right)) / (va.volume ? va.volume : 1);
	142	va.balance = (left<right) ? (65535-va.balance) : va.balance;
	143	if (va.volume)
	144	va.flags &= ~VIDEO_AUDIO_MUTE;
	145	client->driver->command(client,VIDIOCSAUDIO,&va);
	146	client->driver->command(client,VIDIOCGAUDIO,&va);
	147	/* fall throuth */
	148	case MIXER_READ(SOUND_MIXER_VOLUME):
	149	left = (min(65536 - va.balance,32768) *
	150	va.volume) / 32768;
	151	right = (min(va.balance,(u16)32768) *
	152	va.volume) / 32768;
	153	ret = v4l_to_mix2(left,right);
	154	break;
	155
	156	case MIXER_WRITE(SOUND_MIXER_BASS):
	157	va.bass = mix_to_v4l(val);
	158	client->driver->command(client,VIDIOCSAUDIO,&va);
	159	client->driver->command(client,VIDIOCGAUDIO,&va);
	160	/* fall throuth */
	161	case MIXER_READ(SOUND_MIXER_BASS):
	162	ret = v4l_to_mix(va.bass);
	163	break;
	164
	165	case MIXER_WRITE(SOUND_MIXER_TREBLE):
	166	va.treble = mix_to_v4l(val);
167	client->driver->command(client,VIDIOCSAUDIO,&va);
168	client->driver->command(client,VIDIOCGAUDIO,&va);
169	/* fall throuth */
170	case MIXER_READ(SOUND_MIXER_TREBLE):
171	ret = v4l_to_mix(va.treble);
172	break;
173
174	default:
175	return -EINVAL;
176	}
177	if (put_user(ret, p))
178	return -EFAULT;
179	return 0;
180	}
181
182	static int tvmixer_open(struct inode inode, struct file file)
183	{
184	int i, minor = iminor(inode);
185	struct TVMIXER *mix = NULL;
186	struct i2c_client *client = NULL;
187
188	for (i = 0; i < DEV_MAX; i++) {
189	if (devices[i].minor == minor) {
190	mix = devices+i;
191	client = mix->dev;
192	break;
193	}
194	}
195
196	if (NULL == client)
197	return -ENODEV;
198
199	/* lock bttv in memory while the mixer is in use */
200	file->private_data = mix;
201	#ifndef I2C_PEC
202	if (client->adapter->inc_use)
203	client->adapter->inc_use(client->adapter);
204	#endif
205	if (client->adapter->owner)
206	try_module_get(client->adapter->owner);
207	return 0;
208	}
209
210	static int tvmixer_release(struct inode inode, struct file file)
211	{
212	struct TVMIXER *mix = file->private_data;
213	struct i2c_client *client;
214
215	client = mix->dev;
216	if (NULL == client) {
217	return -ENODEV;
218	}
219
220	#ifndef I2C_PEC
221	if (client->adapter->dec_use)
222	client->adapter->dec_use(client->adapter);
223	#endif
224	if (client->adapter->owner)
225	module_put(client->adapter->owner);
226	return 0;
227	}
228
229	static struct i2c_driver driver = {
230	#ifdef I2C_PEC
231	.owner = THIS_MODULE,
232	#endif
233	.name = "tv card mixer driver",
234	.id = I2C_DRIVERID_TVMIXER,
235	#ifdef I2C_DF_DUMMY
236	.flags = I2C_DF_DUMMY,
237	#else
238	.flags = I2C_DF_NOTIFY,
239	.detach_adapter = tvmixer_adapters,
240	#endif
241	.attach_adapter = tvmixer_adapters,
242	.detach_client = tvmixer_clients,
243	};
244
245	static struct file_operations tvmixer_fops = {
246	.owner = THIS_MODULE,
247	.llseek = no_llseek,
248	.ioctl = tvmixer_ioctl,
249	.open = tvmixer_open,
250	.release = tvmixer_release,
251	};
252
253	/* ----------------------------------------------------------------------- */
254
255	static int tvmixer_adapters(struct i2c_adapter *adap)
256	{
257	struct list_head *item;
258	struct i2c_client *client;
259
260	list_for_each(item,&adap->clients) {
261	client = list_entry(item, struct i2c_client, list);
262	tvmixer_clients(client);
263	}
264	return 0;
265	}
266
267	static int tvmixer_clients(struct i2c_client *client)
268	{
269	struct video_audio va;
270	int i,minor;
271
272	#ifdef I2C_CLASS_TV_ANALOG
273	if (!(client->adapter->class & I2C_CLASS_TV_ANALOG))
274	return -1;
275	#else
276	/* TV card ??? */
277	switch (client->adapter->id) {
c7a46533 JD	278	case I2C_HW_SMBUS_VOODOO3:
	279	case I2C_HW_B_BT848:
	280	case I2C_HW_B_RIVA:
1da177e4 LT	281	/* ok, have a look ... */
	282	break;
	283	default:
	284	/* ignore that one */
	285	return -1;
	286	}
	287	#endif
	288
	289	/* unregister ?? */
	290	for (i = 0; i < DEV_MAX; i++) {
	291	if (devices[i].dev == client) {
	292	/* unregister */
	293	unregister_sound_mixer(devices[i].minor);
	294	devices[i].dev = NULL;
	295	devices[i].minor = -1;
	296	printk("tvmixer: %s unregistered (#1)\n",
fae91e72	297	client->name);
1da177e4 LT	298	return 0;
	299	}
	300	}
	301
	302	/* look for a free slot */
	303	for (i = 0; i < DEV_MAX; i++)
	304	if (NULL == devices[i].dev)
	305	break;
	306	if (i == DEV_MAX) {
	307	printk(KERN_WARNING "tvmixer: DEV_MAX too small\n");
	308	return -1;
	309	}
	310
	311	/* audio chip with mixer ??? */
	312	if (NULL == client->driver->command)
	313	return -1;
	314	memset(&va,0,sizeof(va));
	315	if (0 != client->driver->command(client,VIDIOCGAUDIO,&va))
	316	return -1;
	317	if (0 == (va.flags & VIDEO_AUDIO_VOLUME))
	318	return -1;
	319
	320	/* everything is fine, register */
	321	if ((minor = register_sound_mixer(&tvmixer_fops,devnr)) < 0) {
	322	printk(KERN_ERR "tvmixer: cannot allocate mixer device\n");
	323	return -1;
	324	}
	325
	326	devices[i].minor = minor;
	327	devices[i].count = 0;
	328	devices[i].dev = client;
	329	printk("tvmixer: %s (%s) registered with minor %d\n",
	330	client->name,client->adapter->name,minor);
	331
	332	return 0;
	333	}
	334
	335	/* ----------------------------------------------------------------------- */
	336
	337	static int __init tvmixer_init_module(void)
	338	{
	339	int i;
	340
	341	for (i = 0; i < DEV_MAX; i++)
	342	devices[i].minor = -1;
	343
	344	return i2c_add_driver(&driver);
	345	}
	346
	347	static void __exit tvmixer_cleanup_module(void)
	348	{
	349	int i;
	350
	351	i2c_del_driver(&driver);
	352	for (i = 0; i < DEV_MAX; i++) {
	353	if (devices[i].minor != -1) {
	354	unregister_sound_mixer(devices[i].minor);
	355	printk("tvmixer: %s unregistered (#2)\n",
fae91e72	356	devices[i].dev->name);
1da177e4 LT	357	}
	358	}
	359	}
	360
	361	module_init(tvmixer_init_module);
	362	module_exit(tvmixer_cleanup_module);
	363
	364	/*
	365	* Overrides for Emacs so that we follow Linus's tabbing style.
	366	* ---------------------------------------------------------------------------
	367	* Local variables:
	368	* c-basic-offset: 8
	369	* End:
	370	*/