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

/*
 * wm8775 - driver version 0.0.1
 *
 * Copyright (C) 2004 Ulf Eklund <ivtv at eklund.to>
 *
 * Based on saa7115 driver
 *
 * Copyright (C) 2005 Hans Verkuil <hverkuil@xs4all.nl>
 * - Cleanup
 * - V4L2 API update
 * - sound fixes
 *
 * 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/i2c-id.h>
#include <linux/videodev2.h>
#include <media/v4l2-device.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-i2c-drv.h>

MODULE_DESCRIPTION("wm8775 driver");
MODULE_AUTHOR("Ulf Eklund, Hans Verkuil");
MODULE_LICENSE("GPL");


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

enum {
	R7 = 7, R11 = 11,
	R12, R13, R14, R15, R16, R17, R18, R19, R20, R21, R23 = 23,
	TOT_REGS
};

struct wm8775_state {
	struct v4l2_subdev sd;
	u8 input;		/* Last selected input (0-0xf) */
	u8 muted;
};

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

static int wm8775_write(struct v4l2_subdev *sd, int reg, u16 val)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int i;

	if (reg < 0 || reg >= TOT_REGS) {
		v4l2_err(sd, "Invalid register R%d\n", reg);
		return -1;
	}

	for (i = 0; i < 3; i++)
		if (i2c_smbus_write_byte_data(client,
				(reg << 1) | (val >> 8), val & 0xff) == 0)
			return 0;
	v4l2_err(sd, "I2C: cannot write %03x to register R%d\n", val, reg);
	return -1;
}

static int wm8775_s_routing(struct v4l2_subdev *sd,
			    u32 input, u32 output, u32 config)
{
	struct wm8775_state *state = to_state(sd);

	/* There are 4 inputs and one output. Zero or more inputs
	   are multiplexed together to the output. Hence there are
	   16 combinations.
	   If only one input is active (the normal case) then the
	   input values 1, 2, 4 or 8 should be used. */
	if (input > 15) {
		v4l2_err(sd, "Invalid input %d.\n", input);
		return -EINVAL;
	}
	state->input = input;
	if (state->muted)
		return 0;
	wm8775_write(sd, R21, 0x0c0);
	wm8775_write(sd, R14, 0x1d4);
	wm8775_write(sd, R15, 0x1d4);
	wm8775_write(sd, R21, 0x100 + state->input);
	return 0;
}

static int wm8775_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	struct wm8775_state *state = to_state(sd);

	if (ctrl->id != V4L2_CID_AUDIO_MUTE)
		return -EINVAL;
	ctrl->value = state->muted;
	return 0;
}

static int wm8775_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	struct wm8775_state *state = to_state(sd);

	if (ctrl->id != V4L2_CID_AUDIO_MUTE)
		return -EINVAL;
	state->muted = ctrl->value;
	wm8775_write(sd, R21, 0x0c0);
	wm8775_write(sd, R14, 0x1d4);
	wm8775_write(sd, R15, 0x1d4);
	if (!state->muted)
		wm8775_write(sd, R21, 0x100 + state->input);
	return 0;
}

static int wm8775_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_WM8775, 0);
}

static int wm8775_log_status(struct v4l2_subdev *sd)
{
	struct wm8775_state *state = to_state(sd);

	v4l2_info(sd, "Input: %d%s\n", state->input,
			state->muted ? " (muted)" : "");
	return 0;
}

static int wm8775_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
{
	struct wm8775_state *state = to_state(sd);

	/* If I remove this, then it can happen that I have no
	   sound the first time I tune from static to a valid channel.
	   It's difficult to reproduce and is almost certainly related
	   to the zero cross detect circuit. */
	wm8775_write(sd, R21, 0x0c0);
	wm8775_write(sd, R14, 0x1d4);
	wm8775_write(sd, R15, 0x1d4);
	wm8775_write(sd, R21, 0x100 + state->input);
	return 0;
}

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

static const struct v4l2_subdev_core_ops wm8775_core_ops = {
	.log_status = wm8775_log_status,
	.g_chip_ident = wm8775_g_chip_ident,
	.g_ctrl = wm8775_g_ctrl,
	.s_ctrl = wm8775_s_ctrl,
};

static const struct v4l2_subdev_tuner_ops wm8775_tuner_ops = {
	.s_frequency = wm8775_s_frequency,
};

static const struct v4l2_subdev_audio_ops wm8775_audio_ops = {
	.s_routing = wm8775_s_routing,
};

static const struct v4l2_subdev_ops wm8775_ops = {
	.core = &wm8775_core_ops,
	.tuner = &wm8775_tuner_ops,
	.audio = &wm8775_audio_ops,
};

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

/* i2c implementation */

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

static int wm8775_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct wm8775_state *state;
	struct v4l2_subdev *sd;

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

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

	state = kmalloc(sizeof(struct wm8775_state), GFP_KERNEL);
	if (state == NULL)
		return -ENOMEM;
	sd = &state->sd;
	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
	state->input = 2;
	state->muted = 0;

	/* Initialize wm8775 */

	/* RESET */
	wm8775_write(sd, R23, 0x000);
	/* Disable zero cross detect timeout */
	wm8775_write(sd, R7, 0x000);
	/* Left justified, 24-bit mode */
	wm8775_write(sd, R11, 0x021);
	/* Master mode, clock ratio 256fs */
	wm8775_write(sd, R12, 0x102);
	/* Powered up */
	wm8775_write(sd, R13, 0x000);
	/* ADC gain +2.5dB, enable zero cross */
	wm8775_write(sd, R14, 0x1d4);
	/* ADC gain +2.5dB, enable zero cross */
	wm8775_write(sd, R15, 0x1d4);
	/* ALC Stereo, ALC target level -1dB FS max gain +8dB */
	wm8775_write(sd, R16, 0x1bf);
	/* Enable gain control, use zero cross detection,
	   ALC hold time 42.6 ms */
	wm8775_write(sd, R17, 0x185);
	/* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */
	wm8775_write(sd, R18, 0x0a2);
	/* Enable noise gate, threshold -72dBfs */
	wm8775_write(sd, R19, 0x005);
	/* Transient window 4ms, lower PGA gain limit -1dB */
	wm8775_write(sd, R20, 0x07a);
	/* LRBOTH = 1, use input 2. */
	wm8775_write(sd, R21, 0x102);
	return 0;
}

static int wm8775_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);

	v4l2_device_unregister_subdev(sd);
	kfree(to_state(sd));
	return 0;
}

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

static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	.name = "wm8775",
	.probe = wm8775_probe,
	.remove = wm8775_remove,
	.id_table = wm8775_id,
};
Commit	Line	Data
0edeea4f HV	1	/*
	2	* wm8775 - driver version 0.0.1
	3	*
	4	* Copyright (C) 2004 Ulf Eklund <ivtv at eklund.to>
	5	*
	6	* Based on saa7115 driver
	7	*
1f4b3365 HV	8	* Copyright (C) 2005 Hans Verkuil <hverkuil@xs4all.nl>
	9	* - Cleanup
	10	* - V4L2 API update
	11	* - sound fixes
	12	*
0edeea4f HV	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	26	*/
	27
0edeea4f HV	28	#include <linux/module.h>
0edeea4f HV	29	#include <linux/types.h>
5a0e3ad6	30	#include <linux/slab.h>
0edeea4f HV	31	#include <linux/ioctl.h>
	32	#include <asm/uaccess.h>
	33	#include <linux/i2c.h>
e2998e10	34	#include <linux/i2c-id.h>
33b687cf	35	#include <linux/videodev2.h>
ca085fb9	36	#include <media/v4l2-device.h>
74cab31c	37	#include <media/v4l2-chip-ident.h>
4705e8c8	38	#include <media/v4l2-i2c-drv.h>
0edeea4f HV	39
0edeea4f HV	40	MODULE_DESCRIPTION("wm8775 driver");
1f4b3365	41	MODULE_AUTHOR("Ulf Eklund, Hans Verkuil");
0edeea4f HV	42	MODULE_LICENSE("GPL");
0edeea4f HV	43
0edeea4f	44
d9a53aa9	45
0edeea4f HV	46	/* ----------------------------------------------------------------------- */
	47
	48	enum {
	49	R7 = 7, R11 = 11,
	50	R12, R13, R14, R15, R16, R17, R18, R19, R20, R21, R23 = 23,
	51	TOT_REGS
	52	};
	53
	54	struct wm8775_state {
ca085fb9	55	struct v4l2_subdev sd;
0edeea4f HV	56	u8 input; /* Last selected input (0-0xf) */
	57	u8 muted;
	58	};
	59
ca085fb9	60	static inline struct wm8775_state to_state(struct v4l2_subdev sd)
0edeea4f	61	{
ca085fb9 HV	62	return container_of(sd, struct wm8775_state, sd);
	63	}
	64
	65	static int wm8775_write(struct v4l2_subdev *sd, int reg, u16 val)
	66	{
	67	struct i2c_client *client = v4l2_get_subdevdata(sd);
0edeea4f HV	68	int i;
	69
	70	if (reg < 0 \|\| reg >= TOT_REGS) {
ca085fb9	71	v4l2_err(sd, "Invalid register R%d\n", reg);
0edeea4f HV	72	return -1;
	73	}
	74
842441d4 HV	75	for (i = 0; i < 3; i++)
	76	if (i2c_smbus_write_byte_data(client,
	77	(reg << 1) \| (val >> 8), val & 0xff) == 0)
0edeea4f	78	return 0;
ca085fb9	79	v4l2_err(sd, "I2C: cannot write %03x to register R%d\n", val, reg);
0edeea4f HV	80	return -1;
	81	}
	82
5325b427 HV	83	static int wm8775_s_routing(struct v4l2_subdev *sd,
5325b427 HV	84	u32 input, u32 output, u32 config)
0edeea4f	85	{
ca085fb9 HV	86	struct wm8775_state *state = to_state(sd);
	87
	88	/* There are 4 inputs and one output. Zero or more inputs
	89	are multiplexed together to the output. Hence there are
	90	16 combinations.
	91	If only one input is active (the normal case) then the
	92	input values 1, 2, 4 or 8 should be used. */
5325b427 HV	93	if (input > 15) {
5325b427 HV	94	v4l2_err(sd, "Invalid input %d.\n", input);
0edeea4f HV	95	return -EINVAL;
0edeea4f HV	96	}
5325b427	97	state->input = input;
ca085fb9 HV	98	if (state->muted)
	99	return 0;
	100	wm8775_write(sd, R21, 0x0c0);
	101	wm8775_write(sd, R14, 0x1d4);
	102	wm8775_write(sd, R15, 0x1d4);
	103	wm8775_write(sd, R21, 0x100 + state->input);
	104	return 0;
	105	}
	106
	107	static int wm8775_g_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)
	108	{
	109	struct wm8775_state *state = to_state(sd);
	110
	111	if (ctrl->id != V4L2_CID_AUDIO_MUTE)
	112	return -EINVAL;
	113	ctrl->value = state->muted;
	114	return 0;
	115	}
	116
	117	static int wm8775_s_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)
	118	{
	119	struct wm8775_state *state = to_state(sd);
	120
	121	if (ctrl->id != V4L2_CID_AUDIO_MUTE)
	122	return -EINVAL;
	123	state->muted = ctrl->value;
	124	wm8775_write(sd, R21, 0x0c0);
	125	wm8775_write(sd, R14, 0x1d4);
	126	wm8775_write(sd, R15, 0x1d4);
	127	if (!state->muted)
	128	wm8775_write(sd, R21, 0x100 + state->input);
	129	return 0;
	130	}
	131
aecde8b5	132	static int wm8775_g_chip_ident(struct v4l2_subdev sd, struct v4l2_dbg_chip_ident chip)
ca085fb9 HV	133	{
	134	struct i2c_client *client = v4l2_get_subdevdata(sd);
	135
	136	return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_WM8775, 0);
	137	}
	138
	139	static int wm8775_log_status(struct v4l2_subdev *sd)
	140	{
	141	struct wm8775_state *state = to_state(sd);
	142
	143	v4l2_info(sd, "Input: %d%s\n", state->input,
	144	state->muted ? " (muted)" : "");
0edeea4f HV	145	return 0;
	146	}
	147
ca085fb9 HV	148	static int wm8775_s_frequency(struct v4l2_subdev sd, struct v4l2_frequency freq)
	149	{
	150	struct wm8775_state *state = to_state(sd);
	151
	152	/* If I remove this, then it can happen that I have no
	153	sound the first time I tune from static to a valid channel.
	154	It's difficult to reproduce and is almost certainly related
	155	to the zero cross detect circuit. */
	156	wm8775_write(sd, R21, 0x0c0);
	157	wm8775_write(sd, R14, 0x1d4);
	158	wm8775_write(sd, R15, 0x1d4);
	159	wm8775_write(sd, R21, 0x100 + state->input);
	160	return 0;
	161	}
	162
ca085fb9 HV	163	/* ----------------------------------------------------------------------- */
	164
	165	static const struct v4l2_subdev_core_ops wm8775_core_ops = {
	166	.log_status = wm8775_log_status,
	167	.g_chip_ident = wm8775_g_chip_ident,
	168	.g_ctrl = wm8775_g_ctrl,
	169	.s_ctrl = wm8775_s_ctrl,
	170	};
	171
	172	static const struct v4l2_subdev_tuner_ops wm8775_tuner_ops = {
	173	.s_frequency = wm8775_s_frequency,
	174	};
	175
	176	static const struct v4l2_subdev_audio_ops wm8775_audio_ops = {
	177	.s_routing = wm8775_s_routing,
	178	};
	179
	180	static const struct v4l2_subdev_ops wm8775_ops = {
	181	.core = &wm8775_core_ops,
	182	.tuner = &wm8775_tuner_ops,
	183	.audio = &wm8775_audio_ops,
	184	};
	185
0edeea4f HV	186	/* ----------------------------------------------------------------------- */
	187
	188	/* i2c implementation */
	189
	190	/*
	191	* Generic i2c probe
	192	* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
	193	*/
	194
d2653e92 JD	195	static int wm8775_probe(struct i2c_client *client,
d2653e92 JD	196	const struct i2c_device_id *id)
0edeea4f	197	{
0edeea4f	198	struct wm8775_state *state;
ca085fb9	199	struct v4l2_subdev *sd;
0edeea4f HV	200
0edeea4f HV	201	/* Check if the adapter supports the needed features */
d9a53aa9 HV	202	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
d9a53aa9 HV	203	return -EIO;
0edeea4f	204
ca085fb9	205	v4l_info(client, "chip found @ 0x%02x (%s)\n",
842441d4	206	client->addr << 1, client->adapter->name);
0edeea4f HV	207
0edeea4f HV	208	state = kmalloc(sizeof(struct wm8775_state), GFP_KERNEL);
842441d4	209	if (state == NULL)
0edeea4f	210	return -ENOMEM;
ca085fb9 HV	211	sd = &state->sd;
ca085fb9 HV	212	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
0edeea4f HV	213	state->input = 2;
0edeea4f HV	214	state->muted = 0;
0edeea4f	215
842441d4 HV	216	/* Initialize wm8775 */
	217
	218	/* RESET */
ca085fb9	219	wm8775_write(sd, R23, 0x000);
842441d4	220	/* Disable zero cross detect timeout */
ca085fb9	221	wm8775_write(sd, R7, 0x000);
842441d4	222	/* Left justified, 24-bit mode */
ca085fb9	223	wm8775_write(sd, R11, 0x021);
842441d4	224	/* Master mode, clock ratio 256fs */
ca085fb9	225	wm8775_write(sd, R12, 0x102);
842441d4	226	/* Powered up */
ca085fb9	227	wm8775_write(sd, R13, 0x000);
842441d4	228	/* ADC gain +2.5dB, enable zero cross */
ca085fb9	229	wm8775_write(sd, R14, 0x1d4);
842441d4	230	/* ADC gain +2.5dB, enable zero cross */
ca085fb9	231	wm8775_write(sd, R15, 0x1d4);
842441d4	232	/* ALC Stereo, ALC target level -1dB FS max gain +8dB */
ca085fb9	233	wm8775_write(sd, R16, 0x1bf);
842441d4 HV	234	/* Enable gain control, use zero cross detection,
842441d4 HV	235	ALC hold time 42.6 ms */
ca085fb9	236	wm8775_write(sd, R17, 0x185);
842441d4	237	/* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */
ca085fb9	238	wm8775_write(sd, R18, 0x0a2);
842441d4	239	/* Enable noise gate, threshold -72dBfs */
ca085fb9	240	wm8775_write(sd, R19, 0x005);
842441d4	241	/* Transient window 4ms, lower PGA gain limit -1dB */
ca085fb9	242	wm8775_write(sd, R20, 0x07a);
842441d4	243	/* LRBOTH = 1, use input 2. */
ca085fb9	244	wm8775_write(sd, R21, 0x102);
0edeea4f HV	245	return 0;
	246	}
	247
d9a53aa9	248	static int wm8775_remove(struct i2c_client *client)
0edeea4f	249	{
ca085fb9 HV	250	struct v4l2_subdev *sd = i2c_get_clientdata(client);
	251
	252	v4l2_device_unregister_subdev(sd);
	253	kfree(to_state(sd));
0edeea4f HV	254	return 0;
	255	}
	256
af294867 JD	257	static const struct i2c_device_id wm8775_id[] = {
	258	{ "wm8775", 0 },
	259	{ }
	260	};
	261	MODULE_DEVICE_TABLE(i2c, wm8775_id);
	262
d9a53aa9 HV	263	static struct v4l2_i2c_driver_data v4l2_i2c_data = {
d9a53aa9 HV	264	.name = "wm8775",
d9a53aa9 HV	265	.probe = wm8775_probe,
d9a53aa9 HV	266	.remove = wm8775_remove,
af294867	267	.id_table = wm8775_id,
0edeea4f	268	};