[deliverable/linux.git] / drivers / media / video / cs53l32a.c

/*
 * cs53l32a (Adaptec AVC-2010 and AVC-2410) i2c ivtv driver.
 * Copyright (C) 2005  Martin Vaughan
 *
 * Audio source switching for Adaptec AVC-2410 added by Trev Jackson
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


#include <linux/module.h>
#include <linux/types.h>
#include <linux/ioctl.h>
#include <asm/uaccess.h>
#include <linux/i2c.h>
#include <linux/i2c-id.h>
#include <linux/videodev2.h>
#include <media/v4l2-common.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-i2c-drv-legacy.h>

MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
MODULE_AUTHOR("Martin Vaughan");
MODULE_LICENSE("GPL");

static int debug;

module_param(debug, bool, 0644);

MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");

static unsigned short normal_i2c[] = { 0x22 >> 1, I2C_CLIENT_END };

I2C_CLIENT_INSMOD;

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

static int cs53l32a_write(struct i2c_client *client, u8 reg, u8 value)
{
	return i2c_smbus_write_byte_data(client, reg, value);
}

static int cs53l32a_read(struct i2c_client *client, u8 reg)
{
	return i2c_smbus_read_byte_data(client, reg);
}

static int cs53l32a_command(struct i2c_client *client, unsigned cmd, void *arg)
{
	struct v4l2_routing *route = arg;
	struct v4l2_control *ctrl = arg;

	switch (cmd) {
	case VIDIOC_INT_G_AUDIO_ROUTING:
		route->input = (cs53l32a_read(client, 0x01) >> 4) & 3;
		route->output = 0;
		break;

	case VIDIOC_INT_S_AUDIO_ROUTING:
		/* There are 2 physical inputs, but the second input can be
		   placed in two modes, the first mode bypasses the PGA (gain),
		   the second goes through the PGA. Hence there are three
		   possible inputs to choose from. */
		if (route->input > 2) {
			v4l_err(client, "Invalid input %d.\n", route->input);
			return -EINVAL;
		}
		cs53l32a_write(client, 0x01, 0x01 + (route->input << 4));
		break;

	case VIDIOC_G_CTRL:
		if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
			ctrl->value = (cs53l32a_read(client, 0x03) & 0xc0) != 0;
			break;
		}
		if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
			return -EINVAL;
		ctrl->value = (s8)cs53l32a_read(client, 0x04);
		break;

	case VIDIOC_S_CTRL:
		if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
			cs53l32a_write(client, 0x03, ctrl->value ? 0xf0 : 0x30);
			break;
		}
		if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
			return -EINVAL;
		if (ctrl->value > 12 || ctrl->value < -96)
			return -EINVAL;
		cs53l32a_write(client, 0x04, (u8) ctrl->value);
		cs53l32a_write(client, 0x05, (u8) ctrl->value);
		break;

	case VIDIOC_G_CHIP_IDENT:
		return v4l2_chip_ident_i2c_client(client,
				arg, V4L2_IDENT_CS53l32A, 0);

	case VIDIOC_LOG_STATUS:
		{
			u8 v = cs53l32a_read(client, 0x01);
			u8 m = cs53l32a_read(client, 0x03);
			s8 vol = cs53l32a_read(client, 0x04);

			v4l_info(client, "Input:  %d%s\n", (v >> 4) & 3,
				      (m & 0xC0) ? " (muted)" : "");
			v4l_info(client, "Volume: %d dB\n", vol);
			break;
		}

	default:
		return -EINVAL;
	}
	return 0;
}

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

/* i2c implementation */

/*
 * Generic i2c probe
 * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
 */

static int cs53l32a_probe(struct i2c_client *client,
			  const struct i2c_device_id *id)
{
	int i;

	/* Check if the adapter supports the needed features */
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -EIO;

	if (!id)
		strlcpy(client->name, "cs53l32a", sizeof(client->name));

	v4l_info(client, "chip found @ 0x%x (%s)\n",
			client->addr << 1, client->adapter->name);

	for (i = 1; i <= 7; i++) {
		u8 v = cs53l32a_read(client, i);

		v4l_dbg(1, debug, client, "Read Reg %d %02x\n", i, v);
	}

	/* Set cs53l32a internal register for Adaptec 2010/2410 setup */

	cs53l32a_write(client, 0x01, (u8) 0x21);
	cs53l32a_write(client, 0x02, (u8) 0x29);
	cs53l32a_write(client, 0x03, (u8) 0x30);
	cs53l32a_write(client, 0x04, (u8) 0x00);
	cs53l32a_write(client, 0x05, (u8) 0x00);
	cs53l32a_write(client, 0x06, (u8) 0x00);
	cs53l32a_write(client, 0x07, (u8) 0x00);

	/* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */

	for (i = 1; i <= 7; i++) {
		u8 v = cs53l32a_read(client, i);

		v4l_dbg(1, debug, client, "Read Reg %d %02x\n", i, v);
	}
	return 0;
}

static const struct i2c_device_id cs53l32a_id[] = {
	{ "cs53l32a", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, cs53l32a_id);

static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	.name = "cs53l32a",
	.driverid = I2C_DRIVERID_CS53L32A,
	.command = cs53l32a_command,
	.probe = cs53l32a_probe,
	.id_table = cs53l32a_id,
};
Commit	Line	Data
f4067fd4 HV	1	/*
	2	* cs53l32a (Adaptec AVC-2010 and AVC-2410) i2c ivtv driver.
	3	* Copyright (C) 2005 Martin Vaughan
	4	*
	5	* Audio source switching for Adaptec AVC-2410 added by Trev Jackson
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21
	22
	23	#include <linux/module.h>
	24	#include <linux/types.h>
	25	#include <linux/ioctl.h>
	26	#include <asm/uaccess.h>
	27	#include <linux/i2c.h>
e2998e10	28	#include <linux/i2c-id.h>
33b687cf	29	#include <linux/videodev2.h>
fac9e899	30	#include <media/v4l2-common.h>
74cab31c	31	#include <media/v4l2-chip-ident.h>
e8e6b991	32	#include <media/v4l2-i2c-drv-legacy.h>
f4067fd4 HV	33
	34	MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
	35	MODULE_AUTHOR("Martin Vaughan");
	36	MODULE_LICENSE("GPL");
	37
4c05de9c	38	static int debug;
f4067fd4 HV	39
	40	module_param(debug, bool, 0644);
	41
61a2d07d	42	MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");
f4067fd4	43
f4067fd4 HV	44	static unsigned short normal_i2c[] = { 0x22 >> 1, I2C_CLIENT_END };
f4067fd4 HV	45
f4067fd4 HV	46	I2C_CLIENT_INSMOD;
	47
	48	/* ----------------------------------------------------------------------- */
	49
	50	static int cs53l32a_write(struct i2c_client *client, u8 reg, u8 value)
	51	{
	52	return i2c_smbus_write_byte_data(client, reg, value);
	53	}
	54
	55	static int cs53l32a_read(struct i2c_client *client, u8 reg)
	56	{
	57	return i2c_smbus_read_byte_data(client, reg);
	58	}
	59
4c05de9c	60	static int cs53l32a_command(struct i2c_client client, unsigned cmd, void arg)
f4067fd4	61	{
7fa033b1	62	struct v4l2_routing *route = arg;
93605351	63	struct v4l2_control *ctrl = arg;
f4067fd4 HV	64
f4067fd4 HV	65	switch (cmd) {
7fa033b1 HV	66	case VIDIOC_INT_G_AUDIO_ROUTING:
	67	route->input = (cs53l32a_read(client, 0x01) >> 4) & 3;
	68	route->output = 0;
	69	break;
	70
	71	case VIDIOC_INT_S_AUDIO_ROUTING:
93605351 HV	72	/* There are 2 physical inputs, but the second input can be
	73	placed in two modes, the first mode bypasses the PGA (gain),
	74	the second goes through the PGA. Hence there are three
	75	possible inputs to choose from. */
7fa033b1 HV	76	if (route->input > 2) {
7fa033b1 HV	77	v4l_err(client, "Invalid input %d.\n", route->input);
f4067fd4 HV	78	return -EINVAL;
f4067fd4 HV	79	}
7fa033b1	80	cs53l32a_write(client, 0x01, 0x01 + (route->input << 4));
93605351 HV	81	break;
93605351 HV	82
93605351 HV	83	case VIDIOC_G_CTRL:
	84	if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
	85	ctrl->value = (cs53l32a_read(client, 0x03) & 0xc0) != 0;
	86	break;
	87	}
	88	if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
	89	return -EINVAL;
	90	ctrl->value = (s8)cs53l32a_read(client, 0x04);
f4067fd4 HV	91	break;
	92
	93	case VIDIOC_S_CTRL:
93605351 HV	94	if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
93605351 HV	95	cs53l32a_write(client, 0x03, ctrl->value ? 0xf0 : 0x30);
f4067fd4 HV	96	break;
f4067fd4 HV	97	}
93605351 HV	98	if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
	99	return -EINVAL;
	100	if (ctrl->value > 12 \|\| ctrl->value < -96)
	101	return -EINVAL;
	102	cs53l32a_write(client, 0x04, (u8) ctrl->value);
	103	cs53l32a_write(client, 0x05, (u8) ctrl->value);
	104	break;
f4067fd4	105
74cab31c	106	case VIDIOC_G_CHIP_IDENT:
4c05de9c HV	107	return v4l2_chip_ident_i2c_client(client,
4c05de9c HV	108	arg, V4L2_IDENT_CS53l32A, 0);
74cab31c	109
f4067fd4 HV	110	case VIDIOC_LOG_STATUS:
	111	{
	112	u8 v = cs53l32a_read(client, 0x01);
	113	u8 m = cs53l32a_read(client, 0x03);
93605351	114	s8 vol = cs53l32a_read(client, 0x04);
f4067fd4	115
fac9e899	116	v4l_info(client, "Input: %d%s\n", (v >> 4) & 3,
f4067fd4	117	(m & 0xC0) ? " (muted)" : "");
fac9e899	118	v4l_info(client, "Volume: %d dB\n", vol);
f4067fd4 HV	119	break;
	120	}
	121
	122	default:
	123	return -EINVAL;
	124	}
	125	return 0;
	126	}
	127
	128	/* ----------------------------------------------------------------------- */
	129
	130	/* i2c implementation */
	131
	132	/*
	133	* Generic i2c probe
	134	* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
	135	*/
	136
d2653e92 JD	137	static int cs53l32a_probe(struct i2c_client *client,
d2653e92 JD	138	const struct i2c_device_id *id)
f4067fd4	139	{
f4067fd4 HV	140	int i;
	141
	142	/* Check if the adapter supports the needed features */
e8e6b991	143	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
188f3457	144	return -EIO;
f4067fd4	145
af294867 JD	146	if (!id)
af294867 JD	147	strlcpy(client->name, "cs53l32a", sizeof(client->name));
f4067fd4	148
4c05de9c HV	149	v4l_info(client, "chip found @ 0x%x (%s)\n",
4c05de9c HV	150	client->addr << 1, client->adapter->name);
f4067fd4 HV	151
	152	for (i = 1; i <= 7; i++) {
	153	u8 v = cs53l32a_read(client, i);
	154
f167cb4e	155	v4l_dbg(1, debug, client, "Read Reg %d %02x\n", i, v);
f4067fd4 HV	156	}
	157
	158	/* Set cs53l32a internal register for Adaptec 2010/2410 setup */
	159
	160	cs53l32a_write(client, 0x01, (u8) 0x21);
	161	cs53l32a_write(client, 0x02, (u8) 0x29);
	162	cs53l32a_write(client, 0x03, (u8) 0x30);
	163	cs53l32a_write(client, 0x04, (u8) 0x00);
	164	cs53l32a_write(client, 0x05, (u8) 0x00);
	165	cs53l32a_write(client, 0x06, (u8) 0x00);
	166	cs53l32a_write(client, 0x07, (u8) 0x00);
	167
	168	/* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */
	169
	170	for (i = 1; i <= 7; i++) {
	171	u8 v = cs53l32a_read(client, i);
	172
f167cb4e	173	v4l_dbg(1, debug, client, "Read Reg %d %02x\n", i, v);
f4067fd4	174	}
f4067fd4 HV	175	return 0;
	176	}
	177
af294867 JD	178	static const struct i2c_device_id cs53l32a_id[] = {
	179	{ "cs53l32a", 0 },
	180	{ }
	181	};
	182	MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
	183
e8e6b991 HV	184	static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	185	.name = "cs53l32a",
	186	.driverid = I2C_DRIVERID_CS53L32A,
f4067fd4	187	.command = cs53l32a_command,
e8e6b991	188	.probe = cs53l32a_probe,
af294867	189	.id_table = cs53l32a_id,
f4067fd4	190	};