[mirror_ubuntu-bionic-kernel.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/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_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,
	.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;
	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 = {
		.owner	= THIS_MODULE,
		.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>
6951803c	37	#include <media/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;
5aa9ae5e	133	if (!v4l2_ctrl_g_ctrl(state->mute))
ca085fb9	134	return 0;
6951803c LR	135	if (!v4l2_ctrl_g_ctrl(state->vol))
	136	return 0;
	137	if (!v4l2_ctrl_g_ctrl(state->bal))
	138	return 0;
	139	wm8775_set_audio(sd, 1);
ca085fb9 HV	140	return 0;
	141	}
	142
5aa9ae5e	143	static int wm8775_s_ctrl(struct v4l2_ctrl *ctrl)
ca085fb9	144	{
5aa9ae5e	145	struct v4l2_subdev *sd = to_sd(ctrl);
ca085fb9	146
5aa9ae5e HV	147	switch (ctrl->id) {
5aa9ae5e HV	148	case V4L2_CID_AUDIO_MUTE:
6951803c LR	149	case V4L2_CID_AUDIO_VOLUME:
	150	case V4L2_CID_AUDIO_BALANCE:
	151	wm8775_set_audio(sd, 0);
	152	return 0;
	153	case V4L2_CID_AUDIO_LOUDNESS:
	154	wm8775_write(sd, R17, (ctrl->val ? ALC_EN : 0) \| ALC_HOLD);
5aa9ae5e HV	155	return 0;
	156	}
	157	return -EINVAL;
ca085fb9 HV	158	}
ca085fb9 HV	159
ca085fb9 HV	160	static int wm8775_log_status(struct v4l2_subdev *sd)
	161	{
	162	struct wm8775_state *state = to_state(sd);
	163
5aa9ae5e HV	164	v4l2_info(sd, "Input: %d\n", state->input);
5aa9ae5e HV	165	v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
0edeea4f HV	166	return 0;
	167	}
	168
b530a447	169	static int wm8775_s_frequency(struct v4l2_subdev sd, const struct v4l2_frequency freq)
ca085fb9	170	{
6951803c	171	wm8775_set_audio(sd, 0);
ca085fb9 HV	172	return 0;
	173	}
	174
ca085fb9 HV	175	/* ----------------------------------------------------------------------- */
ca085fb9 HV	176
5aa9ae5e HV	177	static const struct v4l2_ctrl_ops wm8775_ctrl_ops = {
	178	.s_ctrl = wm8775_s_ctrl,
	179	};
	180
ca085fb9 HV	181	static const struct v4l2_subdev_core_ops wm8775_core_ops = {
ca085fb9 HV	182	.log_status = wm8775_log_status,
5aa9ae5e HV	183	.g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
	184	.try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
	185	.s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
	186	.g_ctrl = v4l2_subdev_g_ctrl,
	187	.s_ctrl = v4l2_subdev_s_ctrl,
	188	.queryctrl = v4l2_subdev_queryctrl,
	189	.querymenu = v4l2_subdev_querymenu,
ca085fb9 HV	190	};
	191
	192	static const struct v4l2_subdev_tuner_ops wm8775_tuner_ops = {
	193	.s_frequency = wm8775_s_frequency,
	194	};
	195
	196	static const struct v4l2_subdev_audio_ops wm8775_audio_ops = {
	197	.s_routing = wm8775_s_routing,
	198	};
	199
	200	static const struct v4l2_subdev_ops wm8775_ops = {
	201	.core = &wm8775_core_ops,
	202	.tuner = &wm8775_tuner_ops,
	203	.audio = &wm8775_audio_ops,
	204	};
	205
0edeea4f HV	206	/* ----------------------------------------------------------------------- */
	207
	208	/* i2c implementation */
	209
	210	/*
	211	* Generic i2c probe
	212	* concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
	213	*/
	214
d2653e92 JD	215	static int wm8775_probe(struct i2c_client *client,
d2653e92 JD	216	const struct i2c_device_id *id)
0edeea4f	217	{
0edeea4f	218	struct wm8775_state *state;
ca085fb9	219	struct v4l2_subdev *sd;
6951803c LR	220	int err;
	221	bool is_nova_s = false;
	222
	223	if (client->dev.platform_data) {
	224	struct wm8775_platform_data *data = client->dev.platform_data;
	225	is_nova_s = data->is_nova_s;
	226	}
0edeea4f HV	227
0edeea4f HV	228	/* Check if the adapter supports the needed features */
d9a53aa9 HV	229	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
d9a53aa9 HV	230	return -EIO;
0edeea4f	231
ca085fb9	232	v4l_info(client, "chip found @ 0x%02x (%s)\n",
842441d4	233	client->addr << 1, client->adapter->name);
0edeea4f	234
c02b211d	235	state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL);
842441d4	236	if (state == NULL)
0edeea4f	237	return -ENOMEM;
ca085fb9 HV	238	sd = &state->sd;
ca085fb9 HV	239	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
0edeea4f	240	state->input = 2;
5aa9ae5e	241
6951803c	242	v4l2_ctrl_handler_init(&state->hdl, 4);
5aa9ae5e HV	243	state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
5aa9ae5e HV	244	V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
6951803c LR	245	state->vol = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	246	V4L2_CID_AUDIO_VOLUME, 0, 65535, (65535+99)/100, 0xCF00); /* 0dB*/
	247	state->bal = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	248	V4L2_CID_AUDIO_BALANCE, 0, 65535, (65535+99)/100, 32768);
	249	state->loud = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	250	V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 1);
5aa9ae5e	251	sd->ctrl_handler = &state->hdl;
6951803c LR	252	err = state->hdl.error;
6951803c LR	253	if (err) {
5aa9ae5e	254	v4l2_ctrl_handler_free(&state->hdl);
5aa9ae5e HV	255	return err;
5aa9ae5e HV	256	}
0edeea4f	257
842441d4 HV	258	/* Initialize wm8775 */
	259
	260	/* RESET */
ca085fb9	261	wm8775_write(sd, R23, 0x000);
842441d4	262	/* Disable zero cross detect timeout */
ca085fb9	263	wm8775_write(sd, R7, 0x000);
6951803c	264	/* HPF enable, left justified, 24-bit (Philips) mode */
46e67acd	265	wm8775_write(sd, R11, 0x021);
842441d4	266	/* Master mode, clock ratio 256fs */
ca085fb9	267	wm8775_write(sd, R12, 0x102);
842441d4	268	/* Powered up */
ca085fb9	269	wm8775_write(sd, R13, 0x000);
6951803c LR	270
	271	if (!is_nova_s) {
	272	/* ADC gain +2.5dB, enable zero cross */
	273	wm8775_write(sd, R14, 0x1d4);
	274	/* ADC gain +2.5dB, enable zero cross */
	275	wm8775_write(sd, R15, 0x1d4);
	276	/* ALC Stereo, ALC target level -1dB FS max gain +8dB */
	277	wm8775_write(sd, R16, 0x1bf);
	278	/* Enable gain control, use zero cross detection,
	279	ALC hold time 42.6 ms */
	280	wm8775_write(sd, R17, 0x185);
	281	} else {
	282	/* ALC stereo, ALC target level -5dB FS, ALC max gain +8dB */
	283	wm8775_write(sd, R16, 0x1bb);
	284	/* Set ALC mode and hold time */
	285	wm8775_write(sd, R17, (state->loud->val ? ALC_EN : 0) \| ALC_HOLD);
	286	}
842441d4	287	/* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */
ca085fb9	288	wm8775_write(sd, R18, 0x0a2);
842441d4	289	/* Enable noise gate, threshold -72dBfs */
ca085fb9	290	wm8775_write(sd, R19, 0x005);
6951803c LR	291	if (!is_nova_s) {
	292	/* Transient window 4ms, lower PGA gain limit -1dB */
	293	wm8775_write(sd, R20, 0x07a);
	294	/* LRBOTH = 1, use input 2. */
	295	wm8775_write(sd, R21, 0x102);
	296	} else {
	297	/* Transient window 4ms, ALC min gain -5dB */
	298	wm8775_write(sd, R20, 0x0fb);
	299
	300	wm8775_set_audio(sd, 1); /* set volume/mute/mux */
	301	}
0edeea4f HV	302	return 0;
	303	}
	304
d9a53aa9	305	static int wm8775_remove(struct i2c_client *client)
0edeea4f	306	{
ca085fb9	307	struct v4l2_subdev *sd = i2c_get_clientdata(client);
5aa9ae5e	308	struct wm8775_state *state = to_state(sd);
ca085fb9 HV	309
ca085fb9 HV	310	v4l2_device_unregister_subdev(sd);
5aa9ae5e	311	v4l2_ctrl_handler_free(&state->hdl);
0edeea4f HV	312	return 0;
	313	}
	314
af294867 JD	315	static const struct i2c_device_id wm8775_id[] = {
	316	{ "wm8775", 0 },
	317	{ }
	318	};
	319	MODULE_DEVICE_TABLE(i2c, wm8775_id);
	320
a5b2c493 HV	321	static struct i2c_driver wm8775_driver = {
	322	.driver = {
	323	.owner = THIS_MODULE,
	324	.name = "wm8775",
	325	},
	326	.probe = wm8775_probe,
	327	.remove = wm8775_remove,
	328	.id_table = wm8775_id,
0edeea4f	329	};
a5b2c493	330
c6e8d86f	331	module_i2c_driver(wm8775_driver);