[deliverable/linux.git] / drivers / media / i2c / 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-ctrls.h>
#include <media/i2c/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;
	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_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, const 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,
};

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;
	bool is_nova_s = false;

	if (client->dev.platform_data) {
		struct wm8775_platform_data *data = client->dev.platform_data;
		is_nova_s = data->is_nova_s;
	}

	/* 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 = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL);
	if (state == NULL)
		return -ENOMEM;
	sd = &state->sd;
	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
	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);
		return err;
	}

	/* Initialize wm8775 */

	/* RESET */
	wm8775_write(sd, R23, 0x000);
	/* Disable zero cross detect timeout */
	wm8775_write(sd, R7, 0x000);
	/* HPF enable, left justified, 24-bit (Philips) mode */
	wm8775_write(sd, R11, 0x021);
	/* Master mode, clock ratio 256fs */
	wm8775_write(sd, R12, 0x102);
	/* Powered up */
	wm8775_write(sd, R13, 0x000);

	if (!is_nova_s) {
		/* 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);
	} else {
		/* 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);
	if (!is_nova_s) {
		/* Transient window 4ms, lower PGA gain limit -1dB */
		wm8775_write(sd, R20, 0x07a);
		/* LRBOTH = 1, use input 2. */
		wm8775_write(sd, R21, 0x102);
	} else {
		/* 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);
	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 = {
		.name	= "wm8775",
	},
	.probe		= wm8775_probe,
	.remove		= wm8775_remove,
	.id_table	= wm8775_id,
};

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