[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/videodev.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\n\t\t\t0=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;

	snprintf(client->name, sizeof(client->name) - 1, "cs53l32a");

	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 struct v4l2_i2c_driver_data v4l2_i2c_data = {
	.name = "cs53l32a",
	.driverid = I2C_DRIVERID_CS53L32A,
	.command = cs53l32a_command,
	.probe = cs53l32a_probe,
};
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>
f4067fd4	29	#include <linux/videodev.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
	42	MODULE_PARM_DESC(debug, "Debugging messages\n\t\t\t0=Off (default), 1=On");
	43
f4067fd4 HV	44	static unsigned short normal_i2c[] = { 0x22 >> 1, I2C_CLIENT_END };
	45
	46
	47	I2C_CLIENT_INSMOD;
	48
	49	/* ----------------------------------------------------------------------- */
	50
	51	static int cs53l32a_write(struct i2c_client *client, u8 reg, u8 value)
	52	{
	53	return i2c_smbus_write_byte_data(client, reg, value);
	54	}
	55
	56	static int cs53l32a_read(struct i2c_client *client, u8 reg)
	57	{
	58	return i2c_smbus_read_byte_data(client, reg);
	59	}
	60
4c05de9c	61	static int cs53l32a_command(struct i2c_client client, unsigned cmd, void arg)
f4067fd4	62	{
7fa033b1	63	struct v4l2_routing *route = arg;
93605351	64	struct v4l2_control *ctrl = arg;
f4067fd4 HV	65
f4067fd4 HV	66	switch (cmd) {
7fa033b1 HV	67	case VIDIOC_INT_G_AUDIO_ROUTING:
	68	route->input = (cs53l32a_read(client, 0x01) >> 4) & 3;
	69	route->output = 0;
	70	break;
	71
	72	case VIDIOC_INT_S_AUDIO_ROUTING:
93605351 HV	73	/* There are 2 physical inputs, but the second input can be
	74	placed in two modes, the first mode bypasses the PGA (gain),
	75	the second goes through the PGA. Hence there are three
	76	possible inputs to choose from. */
7fa033b1 HV	77	if (route->input > 2) {
7fa033b1 HV	78	v4l_err(client, "Invalid input %d.\n", route->input);
f4067fd4 HV	79	return -EINVAL;
f4067fd4 HV	80	}
7fa033b1	81	cs53l32a_write(client, 0x01, 0x01 + (route->input << 4));
93605351 HV	82	break;
93605351 HV	83
93605351 HV	84	case VIDIOC_G_CTRL:
	85	if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
	86	ctrl->value = (cs53l32a_read(client, 0x03) & 0xc0) != 0;
	87	break;
	88	}
	89	if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
	90	return -EINVAL;
	91	ctrl->value = (s8)cs53l32a_read(client, 0x04);
f4067fd4 HV	92	break;
	93
	94	case VIDIOC_S_CTRL:
93605351 HV	95	if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
93605351 HV	96	cs53l32a_write(client, 0x03, ctrl->value ? 0xf0 : 0x30);
f4067fd4 HV	97	break;
f4067fd4 HV	98	}
93605351 HV	99	if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
	100	return -EINVAL;
	101	if (ctrl->value > 12 \|\| ctrl->value < -96)
	102	return -EINVAL;
	103	cs53l32a_write(client, 0x04, (u8) ctrl->value);
	104	cs53l32a_write(client, 0x05, (u8) ctrl->value);
	105	break;
f4067fd4	106
74cab31c	107	case VIDIOC_G_CHIP_IDENT:
4c05de9c HV	108	return v4l2_chip_ident_i2c_client(client,
4c05de9c HV	109	arg, V4L2_IDENT_CS53l32A, 0);
74cab31c	110
f4067fd4 HV	111	case VIDIOC_LOG_STATUS:
	112	{
	113	u8 v = cs53l32a_read(client, 0x01);
	114	u8 m = cs53l32a_read(client, 0x03);
93605351	115	s8 vol = cs53l32a_read(client, 0x04);
f4067fd4	116
fac9e899	117	v4l_info(client, "Input: %d%s\n", (v >> 4) & 3,
f4067fd4	118	(m & 0xC0) ? " (muted)" : "");
fac9e899	119	v4l_info(client, "Volume: %d dB\n", vol);
f4067fd4 HV	120	break;
	121	}
	122
	123	default:
	124	return -EINVAL;
	125	}
	126	return 0;
	127	}
	128
	129	/* ----------------------------------------------------------------------- */
	130
	131	/* i2c implementation */
	132
	133	/*
	134	* Generic i2c probe
	135	* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
	136	*/
	137
d2653e92 JD	138	static int cs53l32a_probe(struct i2c_client *client,
d2653e92 JD	139	const struct i2c_device_id *id)
f4067fd4	140	{
f4067fd4 HV	141	int i;
	142
	143	/* Check if the adapter supports the needed features */
e8e6b991	144	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
188f3457	145	return -EIO;
f4067fd4	146
f4067fd4 HV	147	snprintf(client->name, sizeof(client->name) - 1, "cs53l32a");
f4067fd4 HV	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
e8e6b991 HV	178	static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	179	.name = "cs53l32a",
	180	.driverid = I2C_DRIVERID_CS53L32A,
f4067fd4	181	.command = cs53l32a_command,
e8e6b991	182	.probe = cs53l32a_probe,
f4067fd4 HV	183	};
f4067fd4 HV	184