[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/slab.h>
#include <linux/ioctl.h>
#include <asm/uaccess.h>
#include <linux/i2c.h>
#include <linux/videodev2.h>
#include <media/v4l2-device.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-i2c-drv.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");


struct cs53l32a_state {
	struct v4l2_subdev sd;
	struct v4l2_ctrl_handler hdl;
};

static inline struct cs53l32a_state *to_state(struct v4l2_subdev *sd)
{
	return container_of(sd, struct cs53l32a_state, sd);
}

static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
{
	return &container_of(ctrl->handler, struct cs53l32a_state, hdl)->sd;
}

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

static int cs53l32a_write(struct v4l2_subdev *sd, u8 reg, u8 value)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	return i2c_smbus_write_byte_data(client, reg, value);
}

static int cs53l32a_read(struct v4l2_subdev *sd, u8 reg)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	return i2c_smbus_read_byte_data(client, reg);
}

static int cs53l32a_s_routing(struct v4l2_subdev *sd,
			      u32 input, u32 output, u32 config)
{
	/* 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 (input > 2) {
		v4l2_err(sd, "Invalid input %d.\n", input);
		return -EINVAL;
	}
	cs53l32a_write(sd, 0x01, 0x01 + (input << 4));
	return 0;
}

static int cs53l32a_s_ctrl(struct v4l2_ctrl *ctrl)
{
	struct v4l2_subdev *sd = to_sd(ctrl);

	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
		cs53l32a_write(sd, 0x03, ctrl->val ? 0xf0 : 0x30);
		return 0;
	case V4L2_CID_AUDIO_VOLUME:
		cs53l32a_write(sd, 0x04, (u8)ctrl->val);
		cs53l32a_write(sd, 0x05, (u8)ctrl->val);
		return 0;
	}
	return -EINVAL;
}

static int cs53l32a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	return v4l2_chip_ident_i2c_client(client,
			chip, V4L2_IDENT_CS53l32A, 0);
}

static int cs53l32a_log_status(struct v4l2_subdev *sd)
{
	struct cs53l32a_state *state = to_state(sd);
	u8 v = cs53l32a_read(sd, 0x01);

	v4l2_info(sd, "Input:  %d\n", (v >> 4) & 3);
	v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
	return 0;
}

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

static const struct v4l2_ctrl_ops cs53l32a_ctrl_ops = {
	.s_ctrl = cs53l32a_s_ctrl,
};

static const struct v4l2_subdev_core_ops cs53l32a_core_ops = {
	.log_status = cs53l32a_log_status,
	.g_chip_ident = cs53l32a_g_chip_ident,
	.g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
	.try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
	.s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
	.g_ctrl = v4l2_subdev_g_ctrl,
	.s_ctrl = v4l2_subdev_s_ctrl,
	.queryctrl = v4l2_subdev_queryctrl,
	.querymenu = v4l2_subdev_querymenu,
};

static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
	.s_routing = cs53l32a_s_routing,
};

static const struct v4l2_subdev_ops cs53l32a_ops = {
	.core = &cs53l32a_core_ops,
	.audio = &cs53l32a_audio_ops,
};

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

/* 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)
{
	struct cs53l32a_state *state;
	struct v4l2_subdev *sd;
	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);

	state = kzalloc(sizeof(struct cs53l32a_state), GFP_KERNEL);
	if (state == NULL)
		return -ENOMEM;
	sd = &state->sd;
	v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops);

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

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

	v4l2_ctrl_handler_init(&state->hdl, 2);
	v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
			V4L2_CID_AUDIO_VOLUME, -96, 12, 1, 0);
	v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
			V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
	sd->ctrl_handler = &state->hdl;
	if (state->hdl.error) {
		int err = state->hdl.error;

		v4l2_ctrl_handler_free(&state->hdl);
		kfree(state);
		return err;
	}

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

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

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

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

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

static int cs53l32a_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);
	struct cs53l32a_state *state = to_state(sd);

	v4l2_device_unregister_subdev(sd);
	v4l2_ctrl_handler_free(&state->hdl);
	kfree(state);
	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",
	.remove = cs53l32a_remove,
	.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>
5a0e3ad6	25	#include <linux/slab.h>
f4067fd4 HV	26	#include <linux/ioctl.h>
	27	#include <asm/uaccess.h>
	28	#include <linux/i2c.h>
33b687cf	29	#include <linux/videodev2.h>
825c6aa2	30	#include <media/v4l2-device.h>
74cab31c	31	#include <media/v4l2-chip-ident.h>
251190cf	32	#include <media/v4l2-ctrls.h>
5fed935c	33	#include <media/v4l2-i2c-drv.h>
f4067fd4 HV	34
	35	MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
	36	MODULE_AUTHOR("Martin Vaughan");
	37	MODULE_LICENSE("GPL");
	38
4c05de9c	39	static int debug;
f4067fd4 HV	40
	41	module_param(debug, bool, 0644);
	42
61a2d07d	43	MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");
f4067fd4	44
f4067fd4	45
251190cf HV	46	struct cs53l32a_state {
	47	struct v4l2_subdev sd;
	48	struct v4l2_ctrl_handler hdl;
	49	};
	50
	51	static inline struct cs53l32a_state to_state(struct v4l2_subdev sd)
	52	{
	53	return container_of(sd, struct cs53l32a_state, sd);
	54	}
	55
	56	static inline struct v4l2_subdev to_sd(struct v4l2_ctrl ctrl)
	57	{
	58	return &container_of(ctrl->handler, struct cs53l32a_state, hdl)->sd;
	59	}
	60
f4067fd4 HV	61	/* ----------------------------------------------------------------------- */
f4067fd4 HV	62
825c6aa2	63	static int cs53l32a_write(struct v4l2_subdev *sd, u8 reg, u8 value)
f4067fd4	64	{
825c6aa2 HV	65	struct i2c_client *client = v4l2_get_subdevdata(sd);
825c6aa2 HV	66
f4067fd4 HV	67	return i2c_smbus_write_byte_data(client, reg, value);
	68	}
	69
825c6aa2	70	static int cs53l32a_read(struct v4l2_subdev *sd, u8 reg)
f4067fd4	71	{
825c6aa2 HV	72	struct i2c_client *client = v4l2_get_subdevdata(sd);
825c6aa2 HV	73
f4067fd4 HV	74	return i2c_smbus_read_byte_data(client, reg);
	75	}
	76
5325b427 HV	77	static int cs53l32a_s_routing(struct v4l2_subdev *sd,
5325b427 HV	78	u32 input, u32 output, u32 config)
f4067fd4	79	{
825c6aa2 HV	80	/* There are 2 physical inputs, but the second input can be
	81	placed in two modes, the first mode bypasses the PGA (gain),
	82	the second goes through the PGA. Hence there are three
	83	possible inputs to choose from. */
5325b427 HV	84	if (input > 2) {
5325b427 HV	85	v4l2_err(sd, "Invalid input %d.\n", input);
f4067fd4 HV	86	return -EINVAL;
f4067fd4 HV	87	}
5325b427	88	cs53l32a_write(sd, 0x01, 0x01 + (input << 4));
825c6aa2 HV	89	return 0;
	90	}
	91
251190cf	92	static int cs53l32a_s_ctrl(struct v4l2_ctrl *ctrl)
825c6aa2	93	{
251190cf	94	struct v4l2_subdev *sd = to_sd(ctrl);
825c6aa2	95
251190cf HV	96	switch (ctrl->id) {
	97	case V4L2_CID_AUDIO_MUTE:
	98	cs53l32a_write(sd, 0x03, ctrl->val ? 0xf0 : 0x30);
	99	return 0;
	100	case V4L2_CID_AUDIO_VOLUME:
	101	cs53l32a_write(sd, 0x04, (u8)ctrl->val);
	102	cs53l32a_write(sd, 0x05, (u8)ctrl->val);
825c6aa2 HV	103	return 0;
825c6aa2 HV	104	}
251190cf	105	return -EINVAL;
f4067fd4 HV	106	}
f4067fd4 HV	107
aecde8b5	108	static int cs53l32a_g_chip_ident(struct v4l2_subdev sd, struct v4l2_dbg_chip_ident chip)
825c6aa2 HV	109	{
	110	struct i2c_client *client = v4l2_get_subdevdata(sd);
	111
	112	return v4l2_chip_ident_i2c_client(client,
	113	chip, V4L2_IDENT_CS53l32A, 0);
	114	}
	115
	116	static int cs53l32a_log_status(struct v4l2_subdev *sd)
	117	{
251190cf	118	struct cs53l32a_state *state = to_state(sd);
825c6aa2	119	u8 v = cs53l32a_read(sd, 0x01);
825c6aa2	120
251190cf HV	121	v4l2_info(sd, "Input: %d\n", (v >> 4) & 3);
251190cf HV	122	v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
825c6aa2 HV	123	return 0;
	124	}
	125
825c6aa2 HV	126	/* ----------------------------------------------------------------------- */
825c6aa2 HV	127
251190cf HV	128	static const struct v4l2_ctrl_ops cs53l32a_ctrl_ops = {
	129	.s_ctrl = cs53l32a_s_ctrl,
	130	};
	131
825c6aa2 HV	132	static const struct v4l2_subdev_core_ops cs53l32a_core_ops = {
	133	.log_status = cs53l32a_log_status,
	134	.g_chip_ident = cs53l32a_g_chip_ident,
251190cf HV	135	.g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
	136	.try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
	137	.s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
	138	.g_ctrl = v4l2_subdev_g_ctrl,
	139	.s_ctrl = v4l2_subdev_s_ctrl,
	140	.queryctrl = v4l2_subdev_queryctrl,
	141	.querymenu = v4l2_subdev_querymenu,
825c6aa2 HV	142	};
	143
	144	static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
	145	.s_routing = cs53l32a_s_routing,
	146	};
	147
	148	static const struct v4l2_subdev_ops cs53l32a_ops = {
	149	.core = &cs53l32a_core_ops,
	150	.audio = &cs53l32a_audio_ops,
	151	};
	152
f4067fd4 HV	153	/* ----------------------------------------------------------------------- */
	154
	155	/* i2c implementation */
	156
	157	/*
	158	* Generic i2c probe
	159	* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
	160	*/
	161
d2653e92 JD	162	static int cs53l32a_probe(struct i2c_client *client,
d2653e92 JD	163	const struct i2c_device_id *id)
f4067fd4	164	{
251190cf	165	struct cs53l32a_state *state;
825c6aa2	166	struct v4l2_subdev *sd;
f4067fd4 HV	167	int i;
	168
	169	/* Check if the adapter supports the needed features */
e8e6b991	170	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
188f3457	171	return -EIO;
f4067fd4	172
af294867 JD	173	if (!id)
af294867 JD	174	strlcpy(client->name, "cs53l32a", sizeof(client->name));
f4067fd4	175
4c05de9c HV	176	v4l_info(client, "chip found @ 0x%x (%s)\n",
4c05de9c HV	177	client->addr << 1, client->adapter->name);
f4067fd4	178
251190cf HV	179	state = kzalloc(sizeof(struct cs53l32a_state), GFP_KERNEL);
251190cf HV	180	if (state == NULL)
825c6aa2	181	return -ENOMEM;
251190cf	182	sd = &state->sd;
825c6aa2 HV	183	v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops);
825c6aa2 HV	184
f4067fd4	185	for (i = 1; i <= 7; i++) {
825c6aa2	186	u8 v = cs53l32a_read(sd, i);
f4067fd4	187
825c6aa2	188	v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
f4067fd4 HV	189	}
f4067fd4 HV	190
251190cf HV	191	v4l2_ctrl_handler_init(&state->hdl, 2);
	192	v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
	193	V4L2_CID_AUDIO_VOLUME, -96, 12, 1, 0);
	194	v4l2_ctrl_new_std(&state->hdl, &cs53l32a_ctrl_ops,
	195	V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
	196	sd->ctrl_handler = &state->hdl;
	197	if (state->hdl.error) {
	198	int err = state->hdl.error;
	199
	200	v4l2_ctrl_handler_free(&state->hdl);
	201	kfree(state);
	202	return err;
	203	}
	204
f4067fd4 HV	205	/* Set cs53l32a internal register for Adaptec 2010/2410 setup */
f4067fd4 HV	206
251190cf HV	207	cs53l32a_write(sd, 0x01, 0x21);
	208	cs53l32a_write(sd, 0x02, 0x29);
	209	cs53l32a_write(sd, 0x03, 0x30);
	210	cs53l32a_write(sd, 0x04, 0x00);
	211	cs53l32a_write(sd, 0x05, 0x00);
	212	cs53l32a_write(sd, 0x06, 0x00);
	213	cs53l32a_write(sd, 0x07, 0x00);
f4067fd4 HV	214
	215	/* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */
	216
	217	for (i = 1; i <= 7; i++) {
825c6aa2	218	u8 v = cs53l32a_read(sd, i);
f4067fd4	219
825c6aa2	220	v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
f4067fd4	221	}
f4067fd4 HV	222	return 0;
	223	}
	224
825c6aa2 HV	225	static int cs53l32a_remove(struct i2c_client *client)
	226	{
	227	struct v4l2_subdev *sd = i2c_get_clientdata(client);
251190cf	228	struct cs53l32a_state *state = to_state(sd);
825c6aa2 HV	229
825c6aa2 HV	230	v4l2_device_unregister_subdev(sd);
251190cf HV	231	v4l2_ctrl_handler_free(&state->hdl);
251190cf HV	232	kfree(state);
825c6aa2 HV	233	return 0;
	234	}
	235
af294867 JD	236	static const struct i2c_device_id cs53l32a_id[] = {
	237	{ "cs53l32a", 0 },
	238	{ }
	239	};
	240	MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
	241
e8e6b991 HV	242	static struct v4l2_i2c_driver_data v4l2_i2c_data = {
e8e6b991 HV	243	.name = "cs53l32a",
825c6aa2	244	.remove = cs53l32a_remove,
e8e6b991	245	.probe = cs53l32a_probe,
af294867	246	.id_table = cs53l32a_id,
f4067fd4	247	};