[linux-2.6-block.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.
 */

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