[mirror_ubuntu-artful-kernel.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>

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

static int debug = 0;

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 int 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 struct i2c_driver i2c_driver;

static int cs53l32a_attach(struct i2c_adapter *adapter, int address, int kind)
{
	struct i2c_client *client;
	int i;

	/* Check if the adapter supports the needed features */
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return 0;

	client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
	if (client == 0)
		return -ENOMEM;

	client->addr = address;
	client->adapter = adapter;
	client->driver = &i2c_driver;
	snprintf(client->name, sizeof(client->name) - 1, "cs53l32a");

	v4l_info(client, "chip found @ 0x%x (%s)\n", address << 1, 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);
	}

	i2c_attach_client(client);

	return 0;
}

static int cs53l32a_probe(struct i2c_adapter *adapter)
{
	if (adapter->class & I2C_CLASS_TV_ANALOG)
		return i2c_probe(adapter, &addr_data, cs53l32a_attach);
	return 0;
}

static int cs53l32a_detach(struct i2c_client *client)
{
	int err;

	err = i2c_detach_client(client);
	if (err) {
		return err;
	}
	kfree(client);

	return 0;
}

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

/* i2c implementation */
static struct i2c_driver i2c_driver = {
	.driver = {
		.name = "cs53l32a",
	},
	.id = I2C_DRIVERID_CS53L32A,
	.attach_adapter = cs53l32a_probe,
	.detach_client = cs53l32a_detach,
	.command = cs53l32a_command,
};


static int __init cs53l32a_init_module(void)
{
	return i2c_add_driver(&i2c_driver);
}

static void __exit cs53l32a_cleanup_module(void)
{
	i2c_del_driver(&i2c_driver);
}

module_init(cs53l32a_init_module);
module_exit(cs53l32a_cleanup_module);
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>
f4067fd4 HV	32
	33	MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
	34	MODULE_AUTHOR("Martin Vaughan");
	35	MODULE_LICENSE("GPL");
	36
	37	static int debug = 0;
	38
	39	module_param(debug, bool, 0644);
	40
	41	MODULE_PARM_DESC(debug, "Debugging messages\n\t\t\t0=Off (default), 1=On");
	42
f4067fd4 HV	43	static unsigned short normal_i2c[] = { 0x22 >> 1, I2C_CLIENT_END };
	44
	45
	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
	60	static int cs53l32a_command(struct i2c_client *client, unsigned int cmd,
	61	void *arg)
	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 HV	107	case VIDIOC_G_CHIP_IDENT:
	108	return v4l2_chip_ident_i2c_client(client, arg, V4L2_IDENT_CS53l32A, 0);
	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
	137	static struct i2c_driver i2c_driver;
	138
	139	static int cs53l32a_attach(struct i2c_adapter *adapter, int address, int kind)
	140	{
	141	struct i2c_client *client;
	142	int i;
	143
	144	/* Check if the adapter supports the needed features */
	145	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	146	return 0;
	147
7408187d	148	client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
f4067fd4 HV	149	if (client == 0)
	150	return -ENOMEM;
	151
f4067fd4 HV	152	client->addr = address;
	153	client->adapter = adapter;
	154	client->driver = &i2c_driver;
f4067fd4 HV	155	snprintf(client->name, sizeof(client->name) - 1, "cs53l32a");
f4067fd4 HV	156
fac9e899	157	v4l_info(client, "chip found @ 0x%x (%s)\n", address << 1, adapter->name);
f4067fd4 HV	158
	159	for (i = 1; i <= 7; i++) {
	160	u8 v = cs53l32a_read(client, i);
	161
f167cb4e	162	v4l_dbg(1, debug, client, "Read Reg %d %02x\n", i, v);
f4067fd4 HV	163	}
	164
	165	/* Set cs53l32a internal register for Adaptec 2010/2410 setup */
	166
	167	cs53l32a_write(client, 0x01, (u8) 0x21);
	168	cs53l32a_write(client, 0x02, (u8) 0x29);
	169	cs53l32a_write(client, 0x03, (u8) 0x30);
	170	cs53l32a_write(client, 0x04, (u8) 0x00);
	171	cs53l32a_write(client, 0x05, (u8) 0x00);
	172	cs53l32a_write(client, 0x06, (u8) 0x00);
	173	cs53l32a_write(client, 0x07, (u8) 0x00);
	174
	175	/* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */
	176
	177	for (i = 1; i <= 7; i++) {
	178	u8 v = cs53l32a_read(client, i);
	179
f167cb4e	180	v4l_dbg(1, debug, client, "Read Reg %d %02x\n", i, v);
f4067fd4 HV	181	}
	182
	183	i2c_attach_client(client);
	184
	185	return 0;
	186	}
	187
	188	static int cs53l32a_probe(struct i2c_adapter *adapter)
	189	{
e2998e10	190	if (adapter->class & I2C_CLASS_TV_ANALOG)
e2998e10 HV	191	return i2c_probe(adapter, &addr_data, cs53l32a_attach);
e2998e10 HV	192	return 0;
f4067fd4 HV	193	}
	194
	195	static int cs53l32a_detach(struct i2c_client *client)
	196	{
	197	int err;
	198
	199	err = i2c_detach_client(client);
	200	if (err) {
	201	return err;
	202	}
	203	kfree(client);
	204
	205	return 0;
	206	}
	207
	208	/* ----------------------------------------------------------------------- */
	209
	210	/* i2c implementation */
	211	static struct i2c_driver i2c_driver = {
604f28e2	212	.driver = {
604f28e2 LR	213	.name = "cs53l32a",
604f28e2 LR	214	},
f4067fd4	215	.id = I2C_DRIVERID_CS53L32A,
f4067fd4 HV	216	.attach_adapter = cs53l32a_probe,
	217	.detach_client = cs53l32a_detach,
	218	.command = cs53l32a_command,
f4067fd4 HV	219	};
	220
	221
	222	static int __init cs53l32a_init_module(void)
	223	{
	224	return i2c_add_driver(&i2c_driver);
	225	}
	226
	227	static void __exit cs53l32a_cleanup_module(void)
	228	{
	229	i2c_del_driver(&i2c_driver);
	230	}
	231
	232	module_init(cs53l32a_init_module);
	233	module_exit(cs53l32a_cleanup_module);