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

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

struct wm8775_state {
	struct v4l2_subdev sd;
	struct v4l2_ctrl_handler hdl;
	struct v4l2_ctrl *mute;
	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 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;
	wm8775_write(sd, R21, 0x0c0);
	wm8775_write(sd, R14, 0x1d4);
	wm8775_write(sd, R15, 0x1d4);
	wm8775_write(sd, R21, 0x100 + state->input);
	return 0;
}

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

	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
		wm8775_write(sd, R21, 0x0c0);
		wm8775_write(sd, R14, 0x1d4);
		wm8775_write(sd, R15, 0x1d4);
		if (!ctrl->val)
			wm8775_write(sd, R21, 0x100 + state->input);
		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)
{
	struct wm8775_state *state = to_state(sd);

	/* If I remove this, then it can happen that I have no
	   sound the first time I tune from static to a valid channel.
	   It's difficult to reproduce and is almost certainly related
	   to the zero cross detect circuit. */
	wm8775_write(sd, R21, 0x0c0);
	wm8775_write(sd, R14, 0x1d4);
	wm8775_write(sd, R15, 0x1d4);
	wm8775_write(sd, R21, 0x100 + state->input);
	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;

	/* 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, 1);
	state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
			V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
	sd->ctrl_handler = &state->hdl;
	if (state->hdl.error) {
		int err = state->hdl.error;

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