[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/videodev2.h>
#include <media/v4l2-device.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-ctrls.h>
#include <media/wm8775.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
};

#define ALC_HOLD 0x85 /* R17: use zero cross detection, ALC hold time 42.6 ms */
#define ALC_EN 0x100  /* R17: ALC enable */

struct wm8775_state {
	struct v4l2_subdev sd;
	struct v4l2_ctrl_handler hdl;
	struct v4l2_ctrl *mute;
	struct v4l2_ctrl *vol;
	struct v4l2_ctrl *bal;
	struct v4l2_ctrl *loud;
	u8 input;		/* Last selected input (0-0xf) */
};

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

static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
{
	return &container_of(ctrl->handler, struct wm8775_state, hdl)->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 void wm8775_set_audio(struct v4l2_subdev *sd, int quietly)
{
	struct wm8775_state *state = to_state(sd);
	u8 vol_l, vol_r;
	int muted = 0 != state->mute->val;
	u16 volume = (u16)state->vol->val;
	u16 balance = (u16)state->bal->val;

	/* normalize ( 65535 to 0 -> 255 to 0 (+24dB to -103dB) ) */
	vol_l = (min(65536 - balance, 32768) * volume) >> 23;
	vol_r = (min(balance, (u16)32768) * volume) >> 23;

	/* Mute */
	if (muted || quietly)
		wm8775_write(sd, R21, 0x0c0 | state->input);

	wm8775_write(sd, R14, vol_l | 0x100); /* 0x100= Left channel ADC zero cross enable */
	wm8775_write(sd, R15, vol_r | 0x100); /* 0x100= Right channel ADC zero cross enable */

	/* Un-mute */
	if (!muted)
		wm8775_write(sd, R21, state->input);
}

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 (!v4l2_ctrl_g_ctrl(state->mute))
		return 0;
	if (!v4l2_ctrl_g_ctrl(state->vol))
		return 0;
	if (!v4l2_ctrl_g_ctrl(state->bal))
		return 0;
	wm8775_set_audio(sd, 1);
	return 0;
}

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

	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
	case V4L2_CID_AUDIO_VOLUME:
	case V4L2_CID_AUDIO_BALANCE:
		wm8775_set_audio(sd, 0);
		return 0;
	case V4L2_CID_AUDIO_LOUDNESS:
		wm8775_write(sd, R17, (ctrl->val ? ALC_EN : 0) | ALC_HOLD);
		return 0;
	}
	return -EINVAL;
}

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\n", state->input);
	v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
	return 0;
}

static int wm8775_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
{
	wm8775_set_audio(sd, 0);
	return 0;
}

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

static const struct v4l2_ctrl_ops wm8775_ctrl_ops = {
	.s_ctrl = wm8775_s_ctrl,
};

static const struct v4l2_subdev_core_ops wm8775_core_ops = {
	.log_status = wm8775_log_status,
	.g_chip_ident = wm8775_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_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;
	int err;

	/* 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 = kzalloc(sizeof(struct wm8775_state), GFP_KERNEL);
	if (state == NULL)
		return -ENOMEM;
	sd = &state->sd;
	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
	sd->grp_id = WM8775_GID; /* subdev group id */
	state->input = 2;

	v4l2_ctrl_handler_init(&state->hdl, 4);
	state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
			V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
	state->vol = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
			V4L2_CID_AUDIO_VOLUME, 0, 65535, (65535+99)/100, 0xCF00); /* 0dB*/
	state->bal = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
			V4L2_CID_AUDIO_BALANCE, 0, 65535, (65535+99)/100, 32768);
	state->loud = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
			V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 1);
	sd->ctrl_handler = &state->hdl;
	err = state->hdl.error;
	if (err) {
		v4l2_ctrl_handler_free(&state->hdl);
		kfree(state);
		return err;
	}

	/* Initialize wm8775 */

	/* RESET */
	wm8775_write(sd, R23, 0x000);
	/* Disable zero cross detect timeout */
	wm8775_write(sd, R7, 0x000);
	/* HPF enable, I2S mode, 24-bit */
	wm8775_write(sd, R11, 0x022);
	/* Master mode, clock ratio 256fs */
	wm8775_write(sd, R12, 0x102);
	/* Powered up */
	wm8775_write(sd, R13, 0x000);
	/* ALC stereo, ALC target level -5dB FS, ALC max gain +8dB */
	wm8775_write(sd, R16, 0x1bb);
	/* Set ALC mode and hold time */
	wm8775_write(sd, R17, (state->loud->val ? ALC_EN : 0) | ALC_HOLD);
	/* 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, ALC min gain -5dB  */
	wm8775_write(sd, R20, 0x0fb);

	wm8775_set_audio(sd, 1);      /* set volume/mute/mux */

	return 0;
}

static int wm8775_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);
	struct wm8775_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 wm8775_id[] = {
	{ "wm8775", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, wm8775_id);

static struct i2c_driver wm8775_driver = {
	.driver = {
		.owner	= THIS_MODULE,
		.name	= "wm8775",
	},
	.probe		= wm8775_probe,
	.remove		= wm8775_remove,
	.id_table	= wm8775_id,
};

static __init int init_wm8775(void)
{
	return i2c_add_driver(&wm8775_driver);
}

static __exit void exit_wm8775(void)
{
	i2c_del_driver(&wm8775_driver);
}

module_init(init_wm8775);
module_exit(exit_wm8775);
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>
33b687cf	34	#include <linux/videodev2.h>
ca085fb9	35	#include <media/v4l2-device.h>
74cab31c	36	#include <media/v4l2-chip-ident.h>
5aa9ae5e	37	#include <media/v4l2-ctrls.h>
fcb97573	38	#include <media/wm8775.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
fcb97573	54	#define ALC_HOLD 0x85 /* R17: use zero cross detection, ALC hold time 42.6 ms */
	55	#define ALC_EN 0x100 /* R17: ALC enable */
	56
0edeea4f	57	struct wm8775_state {
ca085fb9	58	struct v4l2_subdev sd;
5aa9ae5e HV	59	struct v4l2_ctrl_handler hdl;
5aa9ae5e HV	60	struct v4l2_ctrl *mute;
fcb97573	61	struct v4l2_ctrl *vol;
	62	struct v4l2_ctrl *bal;
	63	struct v4l2_ctrl *loud;
0edeea4f	64	u8 input; /* Last selected input (0-0xf) */
0edeea4f HV	65	};
0edeea4f HV	66
ca085fb9	67	static inline struct wm8775_state to_state(struct v4l2_subdev sd)
0edeea4f	68	{
ca085fb9 HV	69	return container_of(sd, struct wm8775_state, sd);
	70	}
	71
5aa9ae5e HV	72	static inline struct v4l2_subdev to_sd(struct v4l2_ctrl ctrl)
	73	{
	74	return &container_of(ctrl->handler, struct wm8775_state, hdl)->sd;
	75	}
	76
ca085fb9 HV	77	static int wm8775_write(struct v4l2_subdev *sd, int reg, u16 val)
	78	{
	79	struct i2c_client *client = v4l2_get_subdevdata(sd);
0edeea4f HV	80	int i;
	81
	82	if (reg < 0 \|\| reg >= TOT_REGS) {
ca085fb9	83	v4l2_err(sd, "Invalid register R%d\n", reg);
0edeea4f HV	84	return -1;
	85	}
	86
842441d4 HV	87	for (i = 0; i < 3; i++)
	88	if (i2c_smbus_write_byte_data(client,
	89	(reg << 1) \| (val >> 8), val & 0xff) == 0)
0edeea4f	90	return 0;
ca085fb9	91	v4l2_err(sd, "I2C: cannot write %03x to register R%d\n", val, reg);
0edeea4f HV	92	return -1;
	93	}
	94
fcb97573	95	static void wm8775_set_audio(struct v4l2_subdev *sd, int quietly)
	96	{
	97	struct wm8775_state *state = to_state(sd);
	98	u8 vol_l, vol_r;
	99	int muted = 0 != state->mute->val;
	100	u16 volume = (u16)state->vol->val;
	101	u16 balance = (u16)state->bal->val;
	102
	103	/* normalize ( 65535 to 0 -> 255 to 0 (+24dB to -103dB) ) */
	104	vol_l = (min(65536 - balance, 32768) * volume) >> 23;
	105	vol_r = (min(balance, (u16)32768) * volume) >> 23;
	106
	107	/* Mute */
	108	if (muted \|\| quietly)
	109	wm8775_write(sd, R21, 0x0c0 \| state->input);
	110
	111	wm8775_write(sd, R14, vol_l \| 0x100); /* 0x100= Left channel ADC zero cross enable */
	112	wm8775_write(sd, R15, vol_r \| 0x100); /* 0x100= Right channel ADC zero cross enable */
	113
	114	/* Un-mute */
	115	if (!muted)
	116	wm8775_write(sd, R21, state->input);
	117	}
	118
5325b427 HV	119	static int wm8775_s_routing(struct v4l2_subdev *sd,
5325b427 HV	120	u32 input, u32 output, u32 config)
0edeea4f	121	{
ca085fb9 HV	122	struct wm8775_state *state = to_state(sd);
	123
	124	/* There are 4 inputs and one output. Zero or more inputs
	125	are multiplexed together to the output. Hence there are
	126	16 combinations.
	127	If only one input is active (the normal case) then the
	128	input values 1, 2, 4 or 8 should be used. */
5325b427 HV	129	if (input > 15) {
5325b427 HV	130	v4l2_err(sd, "Invalid input %d.\n", input);
0edeea4f HV	131	return -EINVAL;
0edeea4f HV	132	}
5325b427	133	state->input = input;
5aa9ae5e	134	if (!v4l2_ctrl_g_ctrl(state->mute))
ca085fb9	135	return 0;
fcb97573	136	if (!v4l2_ctrl_g_ctrl(state->vol))
	137	return 0;
	138	if (!v4l2_ctrl_g_ctrl(state->bal))
	139	return 0;
	140	wm8775_set_audio(sd, 1);
ca085fb9 HV	141	return 0;
	142	}
	143
5aa9ae5e	144	static int wm8775_s_ctrl(struct v4l2_ctrl *ctrl)
ca085fb9	145	{
5aa9ae5e	146	struct v4l2_subdev *sd = to_sd(ctrl);
ca085fb9	147
5aa9ae5e HV	148	switch (ctrl->id) {
5aa9ae5e HV	149	case V4L2_CID_AUDIO_MUTE:
fcb97573	150	case V4L2_CID_AUDIO_VOLUME:
	151	case V4L2_CID_AUDIO_BALANCE:
	152	wm8775_set_audio(sd, 0);
	153	return 0;
	154	case V4L2_CID_AUDIO_LOUDNESS:
	155	wm8775_write(sd, R17, (ctrl->val ? ALC_EN : 0) \| ALC_HOLD);
5aa9ae5e HV	156	return 0;
	157	}
	158	return -EINVAL;
ca085fb9 HV	159	}
ca085fb9 HV	160
aecde8b5	161	static int wm8775_g_chip_ident(struct v4l2_subdev sd, struct v4l2_dbg_chip_ident chip)
ca085fb9 HV	162	{
	163	struct i2c_client *client = v4l2_get_subdevdata(sd);
	164
	165	return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_WM8775, 0);
	166	}
	167
	168	static int wm8775_log_status(struct v4l2_subdev *sd)
	169	{
	170	struct wm8775_state *state = to_state(sd);
	171
5aa9ae5e HV	172	v4l2_info(sd, "Input: %d\n", state->input);
5aa9ae5e HV	173	v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
0edeea4f HV	174	return 0;
	175	}
	176
ca085fb9 HV	177	static int wm8775_s_frequency(struct v4l2_subdev sd, struct v4l2_frequency freq)
ca085fb9 HV	178	{
fcb97573	179	wm8775_set_audio(sd, 0);
ca085fb9 HV	180	return 0;
	181	}
	182
ca085fb9 HV	183	/* ----------------------------------------------------------------------- */
ca085fb9 HV	184
5aa9ae5e HV	185	static const struct v4l2_ctrl_ops wm8775_ctrl_ops = {
	186	.s_ctrl = wm8775_s_ctrl,
	187	};
	188
ca085fb9 HV	189	static const struct v4l2_subdev_core_ops wm8775_core_ops = {
	190	.log_status = wm8775_log_status,
	191	.g_chip_ident = wm8775_g_chip_ident,
5aa9ae5e HV	192	.g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
	193	.try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
	194	.s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
	195	.g_ctrl = v4l2_subdev_g_ctrl,
	196	.s_ctrl = v4l2_subdev_s_ctrl,
	197	.queryctrl = v4l2_subdev_queryctrl,
	198	.querymenu = v4l2_subdev_querymenu,
ca085fb9 HV	199	};
	200
	201	static const struct v4l2_subdev_tuner_ops wm8775_tuner_ops = {
	202	.s_frequency = wm8775_s_frequency,
	203	};
	204
	205	static const struct v4l2_subdev_audio_ops wm8775_audio_ops = {
	206	.s_routing = wm8775_s_routing,
	207	};
	208
	209	static const struct v4l2_subdev_ops wm8775_ops = {
	210	.core = &wm8775_core_ops,
	211	.tuner = &wm8775_tuner_ops,
	212	.audio = &wm8775_audio_ops,
	213	};
	214
0edeea4f HV	215	/* ----------------------------------------------------------------------- */
	216
	217	/* i2c implementation */
	218
	219	/*
	220	* Generic i2c probe
	221	* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
	222	*/
	223
d2653e92 JD	224	static int wm8775_probe(struct i2c_client *client,
d2653e92 JD	225	const struct i2c_device_id *id)
0edeea4f	226	{
0edeea4f	227	struct wm8775_state *state;
ca085fb9	228	struct v4l2_subdev *sd;
fcb97573	229	int err;
0edeea4f HV	230
0edeea4f HV	231	/* Check if the adapter supports the needed features */
d9a53aa9 HV	232	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
d9a53aa9 HV	233	return -EIO;
0edeea4f	234
ca085fb9	235	v4l_info(client, "chip found @ 0x%02x (%s)\n",
842441d4	236	client->addr << 1, client->adapter->name);
0edeea4f	237
5aa9ae5e	238	state = kzalloc(sizeof(struct wm8775_state), GFP_KERNEL);
842441d4	239	if (state == NULL)
0edeea4f	240	return -ENOMEM;
ca085fb9 HV	241	sd = &state->sd;
ca085fb9 HV	242	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
fcb97573	243	sd->grp_id = WM8775_GID; /* subdev group id */
0edeea4f	244	state->input = 2;
5aa9ae5e	245
fcb97573	246	v4l2_ctrl_handler_init(&state->hdl, 4);
5aa9ae5e HV	247	state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
5aa9ae5e HV	248	V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
fcb97573	249	state->vol = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	250	V4L2_CID_AUDIO_VOLUME, 0, 65535, (65535+99)/100, 0xCF00); /* 0dB*/
	251	state->bal = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	252	V4L2_CID_AUDIO_BALANCE, 0, 65535, (65535+99)/100, 32768);
	253	state->loud = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	254	V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 1);
5aa9ae5e	255	sd->ctrl_handler = &state->hdl;
fcb97573	256	err = state->hdl.error;
fcb97573	257	if (err) {
5aa9ae5e HV	258	v4l2_ctrl_handler_free(&state->hdl);
	259	kfree(state);
	260	return err;
	261	}
0edeea4f	262
842441d4 HV	263	/* Initialize wm8775 */
	264
	265	/* RESET */
ca085fb9	266	wm8775_write(sd, R23, 0x000);
842441d4	267	/* Disable zero cross detect timeout */
ca085fb9	268	wm8775_write(sd, R7, 0x000);
fcb97573	269	/* HPF enable, I2S mode, 24-bit */
fcb97573	270	wm8775_write(sd, R11, 0x022);
842441d4	271	/* Master mode, clock ratio 256fs */
ca085fb9	272	wm8775_write(sd, R12, 0x102);
842441d4	273	/* Powered up */
ca085fb9	274	wm8775_write(sd, R13, 0x000);
fcb97573	275	/* ALC stereo, ALC target level -5dB FS, ALC max gain +8dB */
	276	wm8775_write(sd, R16, 0x1bb);
	277	/* Set ALC mode and hold time */
	278	wm8775_write(sd, R17, (state->loud->val ? ALC_EN : 0) \| ALC_HOLD);
842441d4	279	/* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */
ca085fb9	280	wm8775_write(sd, R18, 0x0a2);
842441d4	281	/* Enable noise gate, threshold -72dBfs */
ca085fb9	282	wm8775_write(sd, R19, 0x005);
fcb97573	283	/* Transient window 4ms, ALC min gain -5dB */
	284	wm8775_write(sd, R20, 0x0fb);
	285
	286	wm8775_set_audio(sd, 1); /* set volume/mute/mux */
	287
0edeea4f HV	288	return 0;
	289	}
	290
d9a53aa9	291	static int wm8775_remove(struct i2c_client *client)
0edeea4f	292	{
ca085fb9	293	struct v4l2_subdev *sd = i2c_get_clientdata(client);
5aa9ae5e	294	struct wm8775_state *state = to_state(sd);
ca085fb9 HV	295
ca085fb9 HV	296	v4l2_device_unregister_subdev(sd);
5aa9ae5e HV	297	v4l2_ctrl_handler_free(&state->hdl);
5aa9ae5e HV	298	kfree(state);
0edeea4f HV	299	return 0;
	300	}
	301
af294867 JD	302	static const struct i2c_device_id wm8775_id[] = {
	303	{ "wm8775", 0 },
	304	{ }
	305	};
	306	MODULE_DEVICE_TABLE(i2c, wm8775_id);
	307
a5b2c493 HV	308	static struct i2c_driver wm8775_driver = {
	309	.driver = {
	310	.owner = THIS_MODULE,
	311	.name = "wm8775",
	312	},
	313	.probe = wm8775_probe,
	314	.remove = wm8775_remove,
	315	.id_table = wm8775_id,
0edeea4f	316	};
a5b2c493 HV	317
	318	static __init int init_wm8775(void)
	319	{
	320	return i2c_add_driver(&wm8775_driver);
	321	}
	322
	323	static __exit void exit_wm8775(void)
	324	{
	325	i2c_del_driver(&wm8775_driver);
	326	}
	327
	328	module_init(init_wm8775);
	329	module_exit(exit_wm8775);