[deliverable/linux.git] / drivers / mfd / wm8994-core.c

/*
 * wm8994-core.c  --  Device access for Wolfson WM8994
 *
 * Copyright 2009 Wolfson Microelectronics PLC.
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 *  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.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/mfd/core.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/regulator/machine.h>

#include <linux/mfd/wm8994/core.h>
#include <linux/mfd/wm8994/pdata.h>
#include <linux/mfd/wm8994/registers.h>

static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
		       int bytes, void *dest)
{
	return regmap_raw_read(wm8994->regmap, reg, dest, bytes);
}

/**
 * wm8994_reg_read: Read a single WM8994 register.
 *
 * @wm8994: Device to read from.
 * @reg: Register to read.
 */
int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
{
	unsigned int val;
	int ret;

	ret = regmap_read(wm8994->regmap, reg, &val);

	if (ret < 0)
		return ret;
	else
		return val;
}
EXPORT_SYMBOL_GPL(wm8994_reg_read);

/**
 * wm8994_bulk_read: Read multiple WM8994 registers
 *
 * @wm8994: Device to read from
 * @reg: First register
 * @count: Number of registers
 * @buf: Buffer to fill.  The data will be returned big endian.
 */
int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
		     int count, u16 *buf)
{
	return regmap_bulk_read(wm8994->regmap, reg, buf, count);
}

static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
			int bytes, const void *src)
{
	return regmap_raw_write(wm8994->regmap, reg, src, bytes);
}

/**
 * wm8994_reg_write: Write a single WM8994 register.
 *
 * @wm8994: Device to write to.
 * @reg: Register to write to.
 * @val: Value to write.
 */
int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
		     unsigned short val)
{
	return regmap_write(wm8994->regmap, reg, val);
}
EXPORT_SYMBOL_GPL(wm8994_reg_write);

/**
 * wm8994_bulk_write: Write multiple WM8994 registers
 *
 * @wm8994: Device to write to
 * @reg: First register
 * @count: Number of registers
 * @buf: Buffer to write from.  Data must be big-endian formatted.
 */
int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
		      int count, const u16 *buf)
{
	return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
}
EXPORT_SYMBOL_GPL(wm8994_bulk_write);

/**
 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
 *
 * @wm8994: Device to write to.
 * @reg: Register to write to.
 * @mask: Mask of bits to set.
 * @val: Value to set (unshifted)
 */
int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
		    unsigned short mask, unsigned short val)
{
	return regmap_update_bits(wm8994->regmap, reg, mask, val);
}
EXPORT_SYMBOL_GPL(wm8994_set_bits);

static struct mfd_cell wm8994_regulator_devs[] = {
	{
		.name = "wm8994-ldo",
		.id = 1,
		.pm_runtime_no_callbacks = true,
	},
	{
		.name = "wm8994-ldo",
		.id = 2,
		.pm_runtime_no_callbacks = true,
	},
};

static struct resource wm8994_codec_resources[] = {
	{
		.start = WM8994_IRQ_TEMP_SHUT,
		.end   = WM8994_IRQ_TEMP_WARN,
		.flags = IORESOURCE_IRQ,
	},
};

static struct resource wm8994_gpio_resources[] = {
	{
		.start = WM8994_IRQ_GPIO(1),
		.end   = WM8994_IRQ_GPIO(11),
		.flags = IORESOURCE_IRQ,
	},
};

static struct mfd_cell wm8994_devs[] = {
	{
		.name = "wm8994-codec",
		.num_resources = ARRAY_SIZE(wm8994_codec_resources),
		.resources = wm8994_codec_resources,
	},

	{
		.name = "wm8994-gpio",
		.num_resources = ARRAY_SIZE(wm8994_gpio_resources),
		.resources = wm8994_gpio_resources,
		.pm_runtime_no_callbacks = true,
	},
};

/*
 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
 * and should be handled via the standard regulator API supply
 * management.
 */
static const char *wm1811_main_supplies[] = {
	"DBVDD1",
	"DBVDD2",
	"DBVDD3",
	"DCVDD",
	"AVDD1",
	"AVDD2",
	"CPVDD",
	"SPKVDD1",
	"SPKVDD2",
};

static const char *wm8994_main_supplies[] = {
	"DBVDD",
	"DCVDD",
	"AVDD1",
	"AVDD2",
	"CPVDD",
	"SPKVDD1",
	"SPKVDD2",
};

static const char *wm8958_main_supplies[] = {
	"DBVDD1",
	"DBVDD2",
	"DBVDD3",
	"DCVDD",
	"AVDD1",
	"AVDD2",
	"CPVDD",
	"SPKVDD1",
	"SPKVDD2",
};

#ifdef CONFIG_PM
static int wm8994_suspend(struct device *dev)
{
	struct wm8994 *wm8994 = dev_get_drvdata(dev);
	int ret;

	/* Don't actually go through with the suspend if the CODEC is
	 * still active (eg, for audio passthrough from CP. */
	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
	if (ret < 0) {
		dev_err(dev, "Failed to read power status: %d\n", ret);
	} else if (ret & WM8994_VMID_SEL_MASK) {
		dev_dbg(dev, "CODEC still active, ignoring suspend\n");
		return 0;
	}

	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
	if (ret < 0) {
		dev_err(dev, "Failed to read power status: %d\n", ret);
	} else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
			  WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
			  WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
		dev_dbg(dev, "CODEC still active, ignoring suspend\n");
		return 0;
	}

	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
	if (ret < 0) {
		dev_err(dev, "Failed to read power status: %d\n", ret);
	} else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
			  WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
			  WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
		dev_dbg(dev, "CODEC still active, ignoring suspend\n");
		return 0;
	}

	switch (wm8994->type) {
	case WM8958:
		ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
		if (ret < 0) {
			dev_err(dev, "Failed to read power status: %d\n", ret);
		} else if (ret & WM8958_MICD_ENA) {
			dev_dbg(dev, "CODEC still active, ignoring suspend\n");
			return 0;
		}
		break;
	default:
		break;
	}

	/* Disable LDO pulldowns while the device is suspended if we
	 * don't know that something will be driving them. */
	if (!wm8994->ldo_ena_always_driven)
		wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
				WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
				WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);

	/* GPIO configuration state is saved here since we may be configuring
	 * the GPIO alternate functions even if we're not using the gpiolib
	 * driver for them.
	 */
	ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
			  &wm8994->gpio_regs);
	if (ret < 0)
		dev_err(dev, "Failed to save GPIO registers: %d\n", ret);

	/* For similar reasons we also stash the regulator states */
	ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
			  &wm8994->ldo_regs);
	if (ret < 0)
		dev_err(dev, "Failed to save LDO registers: %d\n", ret);

	/* Explicitly put the device into reset in case regulators
	 * don't get disabled in order to ensure consistent restart.
	 */
	wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);

	wm8994->suspended = true;

	ret = regulator_bulk_disable(wm8994->num_supplies,
				     wm8994->supplies);
	if (ret != 0) {
		dev_err(dev, "Failed to disable supplies: %d\n", ret);
		return ret;
	}

	return 0;
}

static int wm8994_resume(struct device *dev)
{
	struct wm8994 *wm8994 = dev_get_drvdata(dev);
	int ret, i;

	/* We may have lied to the PM core about suspending */
	if (!wm8994->suspended)
		return 0;

	ret = regulator_bulk_enable(wm8994->num_supplies,
				    wm8994->supplies);
	if (ret != 0) {
		dev_err(dev, "Failed to enable supplies: %d\n", ret);
		return ret;
	}

	/* Write register at a time as we use the cache on the CPU so store
	 * it in native endian.
	 */
	for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
		ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
				       + i, wm8994->irq_masks_cur[i]);
		if (ret < 0)
			dev_err(dev, "Failed to restore interrupt masks: %d\n",
				ret);
	}

	ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
			   &wm8994->ldo_regs);
	if (ret < 0)
		dev_err(dev, "Failed to restore LDO registers: %d\n", ret);

	ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
			   &wm8994->gpio_regs);
	if (ret < 0)
		dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);

	/* Disable LDO pulldowns while the device is active */
	wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
			WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
			0);

	wm8994->suspended = false;

	return 0;
}
#endif

#ifdef CONFIG_REGULATOR
static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
{
	struct wm8994_ldo_pdata *ldo_pdata;

	if (!pdata)
		return 0;

	ldo_pdata = &pdata->ldo[ldo];

	if (!ldo_pdata->init_data)
		return 0;

	return ldo_pdata->init_data->num_consumer_supplies != 0;
}
#else
static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
{
	return 0;
}
#endif

static struct regmap_config wm8994_regmap_config = {
	.reg_bits = 16,
	.val_bits = 16,
};

/*
 * Instantiate the generic non-control parts of the device.
 */
static int wm8994_device_init(struct wm8994 *wm8994, int irq)
{
	struct wm8994_pdata *pdata = wm8994->dev->platform_data;
	const char *devname;
	int ret, i;

	dev_set_drvdata(wm8994->dev, wm8994);

	/* Add the on-chip regulators first for bootstrapping */
	ret = mfd_add_devices(wm8994->dev, -1,
			      wm8994_regulator_devs,
			      ARRAY_SIZE(wm8994_regulator_devs),
			      NULL, 0);
	if (ret != 0) {
		dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
		goto err_regmap;
	}

	switch (wm8994->type) {
	case WM1811:
		wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
		break;
	case WM8994:
		wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
		break;
	case WM8958:
		wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
		break;
	default:
		BUG();
		goto err_regmap;
	}

	wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
				   wm8994->num_supplies,
				   GFP_KERNEL);
	if (!wm8994->supplies) {
		ret = -ENOMEM;
		goto err_regmap;
	}

	switch (wm8994->type) {
	case WM1811:
		for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
			wm8994->supplies[i].supply = wm1811_main_supplies[i];
		break;
	case WM8994:
		for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
			wm8994->supplies[i].supply = wm8994_main_supplies[i];
		break;
	case WM8958:
		for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
			wm8994->supplies[i].supply = wm8958_main_supplies[i];
		break;
	default:
		BUG();
		goto err_regmap;
	}
		
	ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
				 wm8994->supplies);
	if (ret != 0) {
		dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
		goto err_supplies;
	}

	ret = regulator_bulk_enable(wm8994->num_supplies,
				    wm8994->supplies);
	if (ret != 0) {
		dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
		goto err_get;
	}

	ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
	if (ret < 0) {
		dev_err(wm8994->dev, "Failed to read ID register\n");
		goto err_enable;
	}
	switch (ret) {
	case 0x1811:
		devname = "WM1811";
		if (wm8994->type != WM1811)
			dev_warn(wm8994->dev, "Device registered as type %d\n",
				 wm8994->type);
		wm8994->type = WM1811;
		break;
	case 0x8994:
		devname = "WM8994";
		if (wm8994->type != WM8994)
			dev_warn(wm8994->dev, "Device registered as type %d\n",
				 wm8994->type);
		wm8994->type = WM8994;
		break;
	case 0x8958:
		devname = "WM8958";
		if (wm8994->type != WM8958)
			dev_warn(wm8994->dev, "Device registered as type %d\n",
				 wm8994->type);
		wm8994->type = WM8958;
		break;
	default:
		dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
			ret);
		ret = -EINVAL;
		goto err_enable;
	}

	ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
	if (ret < 0) {
		dev_err(wm8994->dev, "Failed to read revision register: %d\n",
			ret);
		goto err_enable;
	}

	switch (wm8994->type) {
	case WM8994:
		switch (ret) {
		case 0:
		case 1:
			dev_warn(wm8994->dev,
				 "revision %c not fully supported\n",
				 'A' + ret);
			break;
		default:
			break;
		}
		break;
	default:
		break;
	}

	dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);

	if (pdata) {
		wm8994->irq_base = pdata->irq_base;
		wm8994->gpio_base = pdata->gpio_base;

		/* GPIO configuration is only applied if it's non-zero */
		for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
			if (pdata->gpio_defaults[i]) {
				wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
						0xffff,
						pdata->gpio_defaults[i]);
			}
		}

		wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
	}

	/* Disable LDO pulldowns while the device is active */
	wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
			WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
			0);

	/* In some system designs where the regulators are not in use,
	 * we can achieve a small reduction in leakage currents by
	 * floating LDO outputs.  This bit makes no difference if the
	 * LDOs are enabled, it only affects cases where the LDOs were
	 * in operation and are then disabled.
	 */
	for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
		if (wm8994_ldo_in_use(pdata, i))
			wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
					WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
		else
			wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
					WM8994_LDO1_DISCH, 0);
	}

	wm8994_irq_init(wm8994);

	ret = mfd_add_devices(wm8994->dev, -1,
			      wm8994_devs, ARRAY_SIZE(wm8994_devs),
			      NULL, 0);
	if (ret != 0) {
		dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
		goto err_irq;
	}

	pm_runtime_enable(wm8994->dev);
	pm_runtime_resume(wm8994->dev);

	return 0;

err_irq:
	wm8994_irq_exit(wm8994);
err_enable:
	regulator_bulk_disable(wm8994->num_supplies,
			       wm8994->supplies);
err_get:
	regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
err_supplies:
	kfree(wm8994->supplies);
err_regmap:
	regmap_exit(wm8994->regmap);
	mfd_remove_devices(wm8994->dev);
	kfree(wm8994);
	return ret;
}

static void wm8994_device_exit(struct wm8994 *wm8994)
{
	pm_runtime_disable(wm8994->dev);
	mfd_remove_devices(wm8994->dev);
	wm8994_irq_exit(wm8994);
	regulator_bulk_disable(wm8994->num_supplies,
			       wm8994->supplies);
	regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
	kfree(wm8994->supplies);
	regmap_exit(wm8994->regmap);
	kfree(wm8994);
}

static const struct of_device_id wm8994_of_match[] = {
	{ .compatible = "wlf,wm1811", },
	{ .compatible = "wlf,wm8994", },
	{ .compatible = "wlf,wm8958", },
	{ }
};
MODULE_DEVICE_TABLE(of, wm8994_of_match);

static int wm8994_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct wm8994 *wm8994;
	int ret;

	wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
	if (wm8994 == NULL)
		return -ENOMEM;

	i2c_set_clientdata(i2c, wm8994);
	wm8994->dev = &i2c->dev;
	wm8994->irq = i2c->irq;
	wm8994->type = id->driver_data;

	wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
	if (IS_ERR(wm8994->regmap)) {
		ret = PTR_ERR(wm8994->regmap);
		dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
			ret);
		kfree(wm8994);
		return ret;
	}

	return wm8994_device_init(wm8994, i2c->irq);
}

static int wm8994_i2c_remove(struct i2c_client *i2c)
{
	struct wm8994 *wm8994 = i2c_get_clientdata(i2c);

	wm8994_device_exit(wm8994);

	return 0;
}

static const struct i2c_device_id wm8994_i2c_id[] = {
	{ "wm1811", WM1811 },
	{ "wm8994", WM8994 },
	{ "wm8958", WM8958 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);

static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
			    NULL);

static struct i2c_driver wm8994_i2c_driver = {
	.driver = {
		.name = "wm8994",
		.owner = THIS_MODULE,
		.pm = &wm8994_pm_ops,
		.of_match_table = wm8994_of_match,
	},
	.probe = wm8994_i2c_probe,
	.remove = wm8994_i2c_remove,
	.id_table = wm8994_i2c_id,
};

static int __init wm8994_i2c_init(void)
{
	int ret;

	ret = i2c_add_driver(&wm8994_i2c_driver);
	if (ret != 0)
		pr_err("Failed to register wm8994 I2C driver: %d\n", ret);

	return ret;
}
module_init(wm8994_i2c_init);

static void __exit wm8994_i2c_exit(void)
{
	i2c_del_driver(&wm8994_i2c_driver);
}
module_exit(wm8994_i2c_exit);

MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
Commit	Line	Data
9e501086 MB	1	/*
	2	* wm8994-core.c -- Device access for Wolfson WM8994
	3	*
	4	* Copyright 2009 Wolfson Microelectronics PLC.
	5	*
	6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
5a0e3ad6	17	#include <linux/slab.h>
9e501086	18	#include <linux/i2c.h>
d6c645fc	19	#include <linux/err.h>
9e501086 MB	20	#include <linux/delay.h>
9e501086 MB	21	#include <linux/mfd/core.h>
d450f19e	22	#include <linux/pm_runtime.h>
d6c645fc	23	#include <linux/regmap.h>
9e501086 MB	24	#include <linux/regulator/consumer.h>
	25	#include <linux/regulator/machine.h>
	26
	27	#include <linux/mfd/wm8994/core.h>
	28	#include <linux/mfd/wm8994/pdata.h>
	29	#include <linux/mfd/wm8994/registers.h>
	30
	31	static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
	32	int bytes, void *dest)
	33	{
d6c645fc	34	return regmap_raw_read(wm8994->regmap, reg, dest, bytes);
9e501086 MB	35	}
	36
	37	/**
	38	* wm8994_reg_read: Read a single WM8994 register.
	39	*
	40	* @wm8994: Device to read from.
	41	* @reg: Register to read.
	42	*/
	43	int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
	44	{
d6c645fc	45	unsigned int val;
9e501086 MB	46	int ret;
9e501086 MB	47
d6c645fc	48	ret = regmap_read(wm8994->regmap, reg, &val);
9e501086 MB	49
	50	if (ret < 0)
	51	return ret;
	52	else
d6c645fc	53	return val;
9e501086 MB	54	}
	55	EXPORT_SYMBOL_GPL(wm8994_reg_read);
	56
	57	/**
	58	* wm8994_bulk_read: Read multiple WM8994 registers
	59	*
	60	* @wm8994: Device to read from
	61	* @reg: First register
	62	* @count: Number of registers
316b6cc0	63	* @buf: Buffer to fill. The data will be returned big endian.
9e501086 MB	64	*/
	65	int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
	66	int count, u16 *buf)
	67	{
d6c645fc	68	return regmap_bulk_read(wm8994->regmap, reg, buf, count);
9e501086	69	}
9e501086 MB	70
9e501086 MB	71	static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
07e73fbb	72	int bytes, const void *src)
9e501086	73	{
d6c645fc	74	return regmap_raw_write(wm8994->regmap, reg, src, bytes);
9e501086 MB	75	}
	76
	77	/**
	78	* wm8994_reg_write: Write a single WM8994 register.
	79	*
	80	* @wm8994: Device to write to.
	81	* @reg: Register to write to.
	82	* @val: Value to write.
	83	*/
	84	int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
	85	unsigned short val)
	86	{
d6c645fc	87	return regmap_write(wm8994->regmap, reg, val);
9e501086 MB	88	}
	89	EXPORT_SYMBOL_GPL(wm8994_reg_write);
	90
e93c5387 MB	91	/**
	92	* wm8994_bulk_write: Write multiple WM8994 registers
	93	*
	94	* @wm8994: Device to write to
	95	* @reg: First register
	96	* @count: Number of registers
4277163c	97	* @buf: Buffer to write from. Data must be big-endian formatted.
e93c5387 MB	98	*/
e93c5387 MB	99	int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
07e73fbb	100	int count, const u16 *buf)
e93c5387	101	{
d6c645fc	102	return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
e93c5387 MB	103	}
	104	EXPORT_SYMBOL_GPL(wm8994_bulk_write);
	105
9e501086 MB	106	/**
	107	* wm8994_set_bits: Set the value of a bitfield in a WM8994 register
	108	*
	109	* @wm8994: Device to write to.
	110	* @reg: Register to write to.
	111	* @mask: Mask of bits to set.
	112	* @val: Value to set (unshifted)
	113	*/
	114	int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
	115	unsigned short mask, unsigned short val)
	116	{
d6c645fc	117	return regmap_update_bits(wm8994->regmap, reg, mask, val);
9e501086 MB	118	}
	119	EXPORT_SYMBOL_GPL(wm8994_set_bits);
	120
	121	static struct mfd_cell wm8994_regulator_devs[] = {
d450f19e MB	122	{
	123	.name = "wm8994-ldo",
	124	.id = 1,
	125	.pm_runtime_no_callbacks = true,
	126	},
	127	{
	128	.name = "wm8994-ldo",
	129	.id = 2,
	130	.pm_runtime_no_callbacks = true,
	131	},
9e501086 MB	132	};
9e501086 MB	133
c9fbf7e0 MB	134	static struct resource wm8994_codec_resources[] = {
	135	{
	136	.start = WM8994_IRQ_TEMP_SHUT,
	137	.end = WM8994_IRQ_TEMP_WARN,
	138	.flags = IORESOURCE_IRQ,
	139	},
	140	};
	141
	142	static struct resource wm8994_gpio_resources[] = {
	143	{
	144	.start = WM8994_IRQ_GPIO(1),
	145	.end = WM8994_IRQ_GPIO(11),
	146	.flags = IORESOURCE_IRQ,
	147	},
	148	};
	149
9e501086	150	static struct mfd_cell wm8994_devs[] = {
c9fbf7e0 MB	151	{
	152	.name = "wm8994-codec",
	153	.num_resources = ARRAY_SIZE(wm8994_codec_resources),
	154	.resources = wm8994_codec_resources,
	155	},
	156
	157	{
	158	.name = "wm8994-gpio",
	159	.num_resources = ARRAY_SIZE(wm8994_gpio_resources),
	160	.resources = wm8994_gpio_resources,
d450f19e	161	.pm_runtime_no_callbacks = true,
c9fbf7e0	162	},
9e501086 MB	163	};
	164
	165	/*
	166	* Supplies for the main bulk of CODEC; the LDO supplies are ignored
	167	* and should be handled via the standard regulator API supply
	168	* management.
	169	*/
b1f43bf3 MB	170	static const char *wm1811_main_supplies[] = {
	171	"DBVDD1",
	172	"DBVDD2",
	173	"DBVDD3",
	174	"DCVDD",
	175	"AVDD1",
	176	"AVDD2",
	177	"CPVDD",
	178	"SPKVDD1",
	179	"SPKVDD2",
	180	};
	181
9e501086 MB	182	static const char *wm8994_main_supplies[] = {
	183	"DBVDD",
	184	"DCVDD",
	185	"AVDD1",
	186	"AVDD2",
	187	"CPVDD",
	188	"SPKVDD1",
	189	"SPKVDD2",
	190	};
	191
559e0df6 MB	192	static const char *wm8958_main_supplies[] = {
	193	"DBVDD1",
	194	"DBVDD2",
	195	"DBVDD3",
	196	"DCVDD",
	197	"AVDD1",
	198	"AVDD2",
	199	"CPVDD",
	200	"SPKVDD1",
	201	"SPKVDD2",
	202	};
	203
9e501086	204	#ifdef CONFIG_PM
d450f19e	205	static int wm8994_suspend(struct device *dev)
9e501086 MB	206	{
	207	struct wm8994 *wm8994 = dev_get_drvdata(dev);
	208	int ret;
	209
77bd70e9 MB	210	/* Don't actually go through with the suspend if the CODEC is
	211	* still active (eg, for audio passthrough from CP. */
	212	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
	213	if (ret < 0) {
	214	dev_err(dev, "Failed to read power status: %d\n", ret);
	215	} else if (ret & WM8994_VMID_SEL_MASK) {
	216	dev_dbg(dev, "CODEC still active, ignoring suspend\n");
	217	return 0;
	218	}
	219
5f40c6b6 MB	220	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
	221	if (ret < 0) {
	222	dev_err(dev, "Failed to read power status: %d\n", ret);
	223	} else if (ret & (WM8994_AIF2ADCL_ENA \| WM8994_AIF2ADCR_ENA \|
	224	WM8994_AIF1ADC2L_ENA \| WM8994_AIF1ADC2R_ENA \|
	225	WM8994_AIF1ADC1L_ENA \| WM8994_AIF1ADC1R_ENA)) {
	226	dev_dbg(dev, "CODEC still active, ignoring suspend\n");
	227	return 0;
	228	}
	229
	230	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
	231	if (ret < 0) {
	232	dev_err(dev, "Failed to read power status: %d\n", ret);
	233	} else if (ret & (WM8994_AIF2DACL_ENA \| WM8994_AIF2DACR_ENA \|
	234	WM8994_AIF1DAC2L_ENA \| WM8994_AIF1DAC2R_ENA \|
	235	WM8994_AIF1DAC1L_ENA \| WM8994_AIF1DAC1R_ENA)) {
	236	dev_dbg(dev, "CODEC still active, ignoring suspend\n");
	237	return 0;
	238	}
	239
	240	switch (wm8994->type) {
	241	case WM8958:
	242	ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
	243	if (ret < 0) {
	244	dev_err(dev, "Failed to read power status: %d\n", ret);
	245	} else if (ret & WM8958_MICD_ENA) {
	246	dev_dbg(dev, "CODEC still active, ignoring suspend\n");
	247	return 0;
	248	}
	249	break;
	250	default:
	251	break;
	252	}
	253
881de670 MB	254	/* Disable LDO pulldowns while the device is suspended if we
	255	* don't know that something will be driving them. */
	256	if (!wm8994->ldo_ena_always_driven)
	257	wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
	258	WM8994_LDO1ENA_PD \| WM8994_LDO2ENA_PD,
	259	WM8994_LDO1ENA_PD \| WM8994_LDO2ENA_PD);
	260
9e501086 MB	261	/* GPIO configuration state is saved here since we may be configuring
	262	* the GPIO alternate functions even if we're not using the gpiolib
	263	* driver for them.
	264	*/
	265	ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
	266	&wm8994->gpio_regs);
	267	if (ret < 0)
	268	dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
	269
	270	/* For similar reasons we also stash the regulator states */
	271	ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
	272	&wm8994->ldo_regs);
	273	if (ret < 0)
	274	dev_err(dev, "Failed to save LDO registers: %d\n", ret);
	275
f40dff9e MB	276	/* Explicitly put the device into reset in case regulators
	277	* don't get disabled in order to ensure consistent restart.
	278	*/
	279	wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
	280
77bd70e9 MB	281	wm8994->suspended = true;
77bd70e9 MB	282
559e0df6	283	ret = regulator_bulk_disable(wm8994->num_supplies,
9e501086 MB	284	wm8994->supplies);
	285	if (ret != 0) {
	286	dev_err(dev, "Failed to disable supplies: %d\n", ret);
	287	return ret;
	288	}
	289
	290	return 0;
	291	}
	292
d450f19e	293	static int wm8994_resume(struct device *dev)
9e501086 MB	294	{
9e501086 MB	295	struct wm8994 *wm8994 = dev_get_drvdata(dev);
98ae1cca	296	int ret, i;
9e501086	297
77bd70e9 MB	298	/* We may have lied to the PM core about suspending */
	299	if (!wm8994->suspended)
	300	return 0;
	301
559e0df6	302	ret = regulator_bulk_enable(wm8994->num_supplies,
9e501086 MB	303	wm8994->supplies);
	304	if (ret != 0) {
	305	dev_err(dev, "Failed to enable supplies: %d\n", ret);
	306	return ret;
	307	}
	308
98ae1cca MB	309	/* Write register at a time as we use the cache on the CPU so store
	310	* it in native endian.
	311	*/
	312	for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
	313	ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
	314	+ i, wm8994->irq_masks_cur[i]);
	315	if (ret < 0)
	316	dev_err(dev, "Failed to restore interrupt masks: %d\n",
	317	ret);
	318	}
c9fbf7e0	319
9e501086 MB	320	ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
	321	&wm8994->ldo_regs);
	322	if (ret < 0)
	323	dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
	324
	325	ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
	326	&wm8994->gpio_regs);
	327	if (ret < 0)
	328	dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
	329
881de670 MB	330	/* Disable LDO pulldowns while the device is active */
	331	wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
	332	WM8994_LDO1ENA_PD \| WM8994_LDO2ENA_PD,
	333	0);
	334
77bd70e9 MB	335	wm8994->suspended = false;
77bd70e9 MB	336
9e501086 MB	337	return 0;
	338	}
	339	#endif
	340
	341	#ifdef CONFIG_REGULATOR
	342	static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
	343	{
	344	struct wm8994_ldo_pdata *ldo_pdata;
	345
	346	if (!pdata)
	347	return 0;
	348
	349	ldo_pdata = &pdata->ldo[ldo];
	350
	351	if (!ldo_pdata->init_data)
	352	return 0;
	353
	354	return ldo_pdata->init_data->num_consumer_supplies != 0;
	355	}
	356	#else
	357	static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
	358	{
	359	return 0;
	360	}
	361	#endif
	362
d6c645fc MB	363	static struct regmap_config wm8994_regmap_config = {
	364	.reg_bits = 16,
	365	.val_bits = 16,
	366	};
	367
9e501086 MB	368	/*
	369	* Instantiate the generic non-control parts of the device.
	370	*/
559e0df6	371	static int wm8994_device_init(struct wm8994 *wm8994, int irq)
9e501086 MB	372	{
9e501086 MB	373	struct wm8994_pdata *pdata = wm8994->dev->platform_data;
559e0df6	374	const char *devname;
9e501086 MB	375	int ret, i;
9e501086 MB	376
9e501086 MB	377	dev_set_drvdata(wm8994->dev, wm8994);
	378
	379	/* Add the on-chip regulators first for bootstrapping */
	380	ret = mfd_add_devices(wm8994->dev, -1,
	381	wm8994_regulator_devs,
	382	ARRAY_SIZE(wm8994_regulator_devs),
	383	NULL, 0);
	384	if (ret != 0) {
	385	dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
d6c645fc	386	goto err_regmap;
9e501086 MB	387	}
9e501086 MB	388
559e0df6	389	switch (wm8994->type) {
b1f43bf3 MB	390	case WM1811:
	391	wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
	392	break;
559e0df6 MB	393	case WM8994:
	394	wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
	395	break;
	396	case WM8958:
	397	wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
	398	break;
	399	default:
	400	BUG();
d6c645fc	401	goto err_regmap;
559e0df6 MB	402	}
559e0df6 MB	403
9e501086	404	wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
559e0df6	405	wm8994->num_supplies,
9e501086	406	GFP_KERNEL);
fccbd21f AL	407	if (!wm8994->supplies) {
fccbd21f AL	408	ret = -ENOMEM;
d6c645fc	409	goto err_regmap;
fccbd21f	410	}
9e501086	411
559e0df6	412	switch (wm8994->type) {
b1f43bf3 MB	413	case WM1811:
	414	for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
	415	wm8994->supplies[i].supply = wm1811_main_supplies[i];
	416	break;
559e0df6 MB	417	case WM8994:
	418	for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
	419	wm8994->supplies[i].supply = wm8994_main_supplies[i];
	420	break;
	421	case WM8958:
	422	for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
	423	wm8994->supplies[i].supply = wm8958_main_supplies[i];
	424	break;
	425	default:
	426	BUG();
d6c645fc	427	goto err_regmap;
559e0df6 MB	428	}
	429
	430	ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
9e501086 MB	431	wm8994->supplies);
	432	if (ret != 0) {
	433	dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
7731074a	434	goto err_supplies;
9e501086 MB	435	}
9e501086 MB	436
559e0df6	437	ret = regulator_bulk_enable(wm8994->num_supplies,
9e501086 MB	438	wm8994->supplies);
	439	if (ret != 0) {
	440	dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
7731074a	441	goto err_get;
9e501086 MB	442	}
	443
	444	ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
	445	if (ret < 0) {
	446	dev_err(wm8994->dev, "Failed to read ID register\n");
	447	goto err_enable;
	448	}
559e0df6	449	switch (ret) {
b1f43bf3 MB	450	case 0x1811:
	451	devname = "WM1811";
	452	if (wm8994->type != WM1811)
	453	dev_warn(wm8994->dev, "Device registered as type %d\n",
	454	wm8994->type);
	455	wm8994->type = WM1811;
	456	break;
559e0df6 MB	457	case 0x8994:
	458	devname = "WM8994";
	459	if (wm8994->type != WM8994)
	460	dev_warn(wm8994->dev, "Device registered as type %d\n",
	461	wm8994->type);
	462	wm8994->type = WM8994;
	463	break;
	464	case 0x8958:
	465	devname = "WM8958";
	466	if (wm8994->type != WM8958)
	467	dev_warn(wm8994->dev, "Device registered as type %d\n",
	468	wm8994->type);
	469	wm8994->type = WM8958;
	470	break;
	471	default:
9e501086 MB	472	dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
	473	ret);
	474	ret = -EINVAL;
	475	goto err_enable;
	476	}
	477
	478	ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
	479	if (ret < 0) {
	480	dev_err(wm8994->dev, "Failed to read revision register: %d\n",
	481	ret);
	482	goto err_enable;
	483	}
	484
a2495bc7 MB	485	switch (wm8994->type) {
	486	case WM8994:
	487	switch (ret) {
	488	case 0:
	489	case 1:
559e0df6 MB	490	dev_warn(wm8994->dev,
	491	"revision %c not fully supported\n",
	492	'A' + ret);
a2495bc7 MB	493	break;
	494	default:
	495	break;
	496	}
9e501086 MB	497	break;
9e501086 MB	498	default:
9e501086 MB	499	break;
	500	}
	501
559e0df6	502	dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
9e501086 MB	503
9e501086 MB	504	if (pdata) {
c9fbf7e0	505	wm8994->irq_base = pdata->irq_base;
9e501086 MB	506	wm8994->gpio_base = pdata->gpio_base;
	507
	508	/* GPIO configuration is only applied if it's non-zero */
	509	for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
	510	if (pdata->gpio_defaults[i]) {
	511	wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
	512	0xffff,
	513	pdata->gpio_defaults[i]);
	514	}
	515	}
881de670 MB	516
881de670 MB	517	wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
9e501086 MB	518	}
9e501086 MB	519
881de670 MB	520	/* Disable LDO pulldowns while the device is active */
	521	wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
	522	WM8994_LDO1ENA_PD \| WM8994_LDO2ENA_PD,
	523	0);
	524
9e501086 MB	525	/* In some system designs where the regulators are not in use,
	526	* we can achieve a small reduction in leakage currents by
	527	* floating LDO outputs. This bit makes no difference if the
	528	* LDOs are enabled, it only affects cases where the LDOs were
	529	* in operation and are then disabled.
	530	*/
	531	for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
	532	if (wm8994_ldo_in_use(pdata, i))
	533	wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
	534	WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
	535	else
	536	wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
	537	WM8994_LDO1_DISCH, 0);
	538	}
	539
c9fbf7e0 MB	540	wm8994_irq_init(wm8994);
c9fbf7e0 MB	541
9e501086 MB	542	ret = mfd_add_devices(wm8994->dev, -1,
	543	wm8994_devs, ARRAY_SIZE(wm8994_devs),
	544	NULL, 0);
	545	if (ret != 0) {
	546	dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
c9fbf7e0	547	goto err_irq;
9e501086 MB	548	}
9e501086 MB	549
d450f19e MB	550	pm_runtime_enable(wm8994->dev);
	551	pm_runtime_resume(wm8994->dev);
	552
9e501086 MB	553	return 0;
9e501086 MB	554
c9fbf7e0 MB	555	err_irq:
c9fbf7e0 MB	556	wm8994_irq_exit(wm8994);
9e501086	557	err_enable:
559e0df6	558	regulator_bulk_disable(wm8994->num_supplies,
9e501086 MB	559	wm8994->supplies);
9e501086 MB	560	err_get:
559e0df6	561	regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
9e501086 MB	562	err_supplies:
9e501086 MB	563	kfree(wm8994->supplies);
d6c645fc MB	564	err_regmap:
d6c645fc MB	565	regmap_exit(wm8994->regmap);
9e501086 MB	566	mfd_remove_devices(wm8994->dev);
	567	kfree(wm8994);
	568	return ret;
	569	}
	570
	571	static void wm8994_device_exit(struct wm8994 *wm8994)
	572	{
d450f19e	573	pm_runtime_disable(wm8994->dev);
9e501086	574	mfd_remove_devices(wm8994->dev);
c9fbf7e0	575	wm8994_irq_exit(wm8994);
559e0df6	576	regulator_bulk_disable(wm8994->num_supplies,
9e501086	577	wm8994->supplies);
559e0df6	578	regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
9e501086	579	kfree(wm8994->supplies);
d6c645fc	580	regmap_exit(wm8994->regmap);
9e501086 MB	581	kfree(wm8994);
	582	}
	583
cf763c2e MB	584	static const struct of_device_id wm8994_of_match[] = {
	585	{ .compatible = "wlf,wm1811", },
	586	{ .compatible = "wlf,wm8994", },
	587	{ .compatible = "wlf,wm8958", },
	588	{ }
	589	};
	590	MODULE_DEVICE_TABLE(of, wm8994_of_match);
	591
9e501086 MB	592	static int wm8994_i2c_probe(struct i2c_client *i2c,
	593	const struct i2c_device_id *id)
	594	{
	595	struct wm8994 *wm8994;
d6c645fc	596	int ret;
9e501086 MB	597
9e501086 MB	598	wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
d0a11693	599	if (wm8994 == NULL)
9e501086	600	return -ENOMEM;
9e501086 MB	601
	602	i2c_set_clientdata(i2c, wm8994);
	603	wm8994->dev = &i2c->dev;
c9fbf7e0	604	wm8994->irq = i2c->irq;
559e0df6	605	wm8994->type = id->driver_data;
9e501086	606
d6c645fc MB	607	wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
	608	if (IS_ERR(wm8994->regmap)) {
	609	ret = PTR_ERR(wm8994->regmap);
	610	dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
	611	ret);
	612	kfree(wm8994);
	613	return ret;
	614	}
	615
559e0df6	616	return wm8994_device_init(wm8994, i2c->irq);
9e501086 MB	617	}
	618
	619	static int wm8994_i2c_remove(struct i2c_client *i2c)
	620	{
	621	struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
	622
	623	wm8994_device_exit(wm8994);
	624
	625	return 0;
	626	}
	627
9e501086	628	static const struct i2c_device_id wm8994_i2c_id[] = {
b1f43bf3	629	{ "wm1811", WM1811 },
559e0df6 MB	630	{ "wm8994", WM8994 },
559e0df6 MB	631	{ "wm8958", WM8958 },
9e501086 MB	632	{ }
	633	};
	634	MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
	635
aad34310 MB	636	static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
aad34310 MB	637	NULL);
d450f19e	638
9e501086 MB	639	static struct i2c_driver wm8994_i2c_driver = {
9e501086 MB	640	.driver = {
d450f19e MB	641	.name = "wm8994",
	642	.owner = THIS_MODULE,
	643	.pm = &wm8994_pm_ops,
cf763c2e	644	.of_match_table = wm8994_of_match,
9e501086 MB	645	},
	646	.probe = wm8994_i2c_probe,
	647	.remove = wm8994_i2c_remove,
9e501086 MB	648	.id_table = wm8994_i2c_id,
	649	};
	650
	651	static int __init wm8994_i2c_init(void)
	652	{
	653	int ret;
	654
	655	ret = i2c_add_driver(&wm8994_i2c_driver);
	656	if (ret != 0)
	657	pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
	658
	659	return ret;
	660	}
	661	module_init(wm8994_i2c_init);
	662
	663	static void __exit wm8994_i2c_exit(void)
	664	{
	665	i2c_del_driver(&wm8994_i2c_driver);
	666	}
	667	module_exit(wm8994_i2c_exit);
	668
	669	MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
	670	MODULE_LICENSE("GPL");
	671	MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");