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