[deliverable/linux.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;
	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 = kzalloc(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;

	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, 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);
	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,
};

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>
74cab31c	36	#include <media/v4l2-chip-ident.h>
5aa9ae5e	37	#include <media/v4l2-ctrls.h>
6951803c	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
6951803c LR	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;
6951803c LR	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
6951803c LR	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;
6951803c LR	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:
6951803c LR	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	{
6951803c	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;
6951803c LR	229	int err;
	230	bool is_nova_s = false;
	231
	232	if (client->dev.platform_data) {
	233	struct wm8775_platform_data *data = client->dev.platform_data;
	234	is_nova_s = data->is_nova_s;
	235	}
0edeea4f HV	236
0edeea4f HV	237	/* Check if the adapter supports the needed features */
d9a53aa9 HV	238	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
d9a53aa9 HV	239	return -EIO;
0edeea4f	240
ca085fb9	241	v4l_info(client, "chip found @ 0x%02x (%s)\n",
842441d4	242	client->addr << 1, client->adapter->name);
0edeea4f	243
5aa9ae5e	244	state = kzalloc(sizeof(struct wm8775_state), GFP_KERNEL);
842441d4	245	if (state == NULL)
0edeea4f	246	return -ENOMEM;
ca085fb9 HV	247	sd = &state->sd;
ca085fb9 HV	248	v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
0edeea4f	249	state->input = 2;
5aa9ae5e	250
6951803c	251	v4l2_ctrl_handler_init(&state->hdl, 4);
5aa9ae5e HV	252	state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
5aa9ae5e HV	253	V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
6951803c LR	254	state->vol = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	255	V4L2_CID_AUDIO_VOLUME, 0, 65535, (65535+99)/100, 0xCF00); /* 0dB*/
	256	state->bal = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	257	V4L2_CID_AUDIO_BALANCE, 0, 65535, (65535+99)/100, 32768);
	258	state->loud = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
	259	V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 1);
5aa9ae5e	260	sd->ctrl_handler = &state->hdl;
6951803c LR	261	err = state->hdl.error;
6951803c LR	262	if (err) {
5aa9ae5e HV	263	v4l2_ctrl_handler_free(&state->hdl);
	264	kfree(state);
	265	return err;
	266	}
0edeea4f	267
842441d4 HV	268	/* Initialize wm8775 */
	269
	270	/* RESET */
ca085fb9	271	wm8775_write(sd, R23, 0x000);
842441d4	272	/* Disable zero cross detect timeout */
ca085fb9	273	wm8775_write(sd, R7, 0x000);
6951803c	274	/* HPF enable, left justified, 24-bit (Philips) mode */
46e67acd	275	wm8775_write(sd, R11, 0x021);
842441d4	276	/* Master mode, clock ratio 256fs */
ca085fb9	277	wm8775_write(sd, R12, 0x102);
842441d4	278	/* Powered up */
ca085fb9	279	wm8775_write(sd, R13, 0x000);
6951803c LR	280
	281	if (!is_nova_s) {
	282	/* ADC gain +2.5dB, enable zero cross */
	283	wm8775_write(sd, R14, 0x1d4);
	284	/* ADC gain +2.5dB, enable zero cross */
	285	wm8775_write(sd, R15, 0x1d4);
	286	/* ALC Stereo, ALC target level -1dB FS max gain +8dB */
	287	wm8775_write(sd, R16, 0x1bf);
	288	/* Enable gain control, use zero cross detection,
	289	ALC hold time 42.6 ms */
	290	wm8775_write(sd, R17, 0x185);
	291	} else {
	292	/* ALC stereo, ALC target level -5dB FS, ALC max gain +8dB */
	293	wm8775_write(sd, R16, 0x1bb);
	294	/* Set ALC mode and hold time */
	295	wm8775_write(sd, R17, (state->loud->val ? ALC_EN : 0) \| ALC_HOLD);
	296	}
842441d4	297	/* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */
ca085fb9	298	wm8775_write(sd, R18, 0x0a2);
842441d4	299	/* Enable noise gate, threshold -72dBfs */
ca085fb9	300	wm8775_write(sd, R19, 0x005);
6951803c LR	301	if (!is_nova_s) {
	302	/* Transient window 4ms, lower PGA gain limit -1dB */
	303	wm8775_write(sd, R20, 0x07a);
	304	/* LRBOTH = 1, use input 2. */
	305	wm8775_write(sd, R21, 0x102);
	306	} else {
	307	/* Transient window 4ms, ALC min gain -5dB */
	308	wm8775_write(sd, R20, 0x0fb);
	309
	310	wm8775_set_audio(sd, 1); /* set volume/mute/mux */
	311	}
0edeea4f HV	312	return 0;
	313	}
	314
d9a53aa9	315	static int wm8775_remove(struct i2c_client *client)
0edeea4f	316	{
ca085fb9	317	struct v4l2_subdev *sd = i2c_get_clientdata(client);
5aa9ae5e	318	struct wm8775_state *state = to_state(sd);
ca085fb9 HV	319
ca085fb9 HV	320	v4l2_device_unregister_subdev(sd);
5aa9ae5e HV	321	v4l2_ctrl_handler_free(&state->hdl);
5aa9ae5e HV	322	kfree(state);
0edeea4f HV	323	return 0;
	324	}
	325
af294867 JD	326	static const struct i2c_device_id wm8775_id[] = {
	327	{ "wm8775", 0 },
	328	{ }
	329	};
	330	MODULE_DEVICE_TABLE(i2c, wm8775_id);
	331
a5b2c493 HV	332	static struct i2c_driver wm8775_driver = {
	333	.driver = {
	334	.owner = THIS_MODULE,
	335	.name = "wm8775",
	336	},
	337	.probe = wm8775_probe,
	338	.remove = wm8775_remove,
	339	.id_table = wm8775_id,
0edeea4f	340	};
a5b2c493	341
c6e8d86f	342	module_i2c_driver(wm8775_driver);