[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/delay.h>
#include <linux/mfd/core.h>
#include <linux/pm_runtime.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)
{
	int ret, i;
	u16 *buf = dest;

	BUG_ON(bytes % 2);
	BUG_ON(bytes <= 0);

	ret = wm8994->read_dev(wm8994, reg, bytes, dest);
	if (ret < 0)
		return ret;

	for (i = 0; i < bytes / 2; i++) {
		dev_vdbg(wm8994->dev, "Read %04x from R%d(0x%x)\n",
			 be16_to_cpu(buf[i]), reg + i, reg + i);
	}

	return 0;
}

/**
 * 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 short val;
	int ret;

	mutex_lock(&wm8994->io_lock);

	ret = wm8994_read(wm8994, reg, 2, &val);

	mutex_unlock(&wm8994->io_lock);

	if (ret < 0)
		return ret;
	else
		return be16_to_cpu(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)
{
	int ret;

	mutex_lock(&wm8994->io_lock);

	ret = wm8994_read(wm8994, reg, count * 2, buf);

	mutex_unlock(&wm8994->io_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(wm8994_bulk_read);

static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
			int bytes, const void *src)
{
	const u16 *buf = src;
	int i;

	BUG_ON(bytes % 2);
	BUG_ON(bytes <= 0);

	for (i = 0; i < bytes / 2; i++) {
		dev_vdbg(wm8994->dev, "Write %04x to R%d(0x%x)\n",
			 be16_to_cpu(buf[i]), reg + i, reg + i);
	}

	return wm8994->write_dev(wm8994, reg, bytes, src);
}

/**
 * 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)
{
	int ret;

	val = cpu_to_be16(val);

	mutex_lock(&wm8994->io_lock);

	ret = wm8994_write(wm8994, reg, 2, &val);

	mutex_unlock(&wm8994->io_lock);

	return ret;
}
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)
{
	int ret;

	mutex_lock(&wm8994->io_lock);

	ret = wm8994_write(wm8994, reg, count * 2, buf);

	mutex_unlock(&wm8994->io_lock);

	return ret;
}
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)
{
	int ret;
	u16 r;

	mutex_lock(&wm8994->io_lock);

	ret = wm8994_read(wm8994, reg, 2, &r);
	if (ret < 0)
		goto out;

	r = be16_to_cpu(r);

	r &= ~mask;
	r |= val;

	r = cpu_to_be16(r);

	ret = wm8994_write(wm8994, reg, 2, &r);

out:
	mutex_unlock(&wm8994->io_lock);

	return ret;
}
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 *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;
	}

	/* 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);

	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

/*
 * 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;

	mutex_init(&wm8994->io_lock);
	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;
	}

	switch (wm8994->type) {
	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;
	}

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

	switch (wm8994->type) {
	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;
	}
		
	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 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]);
			}
		}
	}

	/* 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:
	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);
	kfree(wm8994);
}

static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
				  int bytes, void *dest)
{
	struct i2c_client *i2c = wm8994->control_data;
	int ret;
	u16 r = cpu_to_be16(reg);

	ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
	if (ret < 0)
		return ret;
	if (ret != 2)
		return -EIO;

	ret = i2c_master_recv(i2c, dest, bytes);
	if (ret < 0)
		return ret;
	if (ret != bytes)
		return -EIO;
	return 0;
}

static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
				   int bytes, const void *src)
{
	struct i2c_client *i2c = wm8994->control_data;
	struct i2c_msg xfer[2];
	int ret;

	reg = cpu_to_be16(reg);

	xfer[0].addr = i2c->addr;
	xfer[0].flags = 0;
	xfer[0].len = 2;
	xfer[0].buf = (char *)&reg;

	xfer[1].addr = i2c->addr;
	xfer[1].flags = I2C_M_NOSTART;
	xfer[1].len = bytes;
	xfer[1].buf = (char *)src;

	ret = i2c_transfer(i2c->adapter, xfer, 2);
	if (ret < 0)
		return ret;
	if (ret != 2)
		return -EIO;

	return 0;
}

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

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

	i2c_set_clientdata(i2c, wm8994);
	wm8994->dev = &i2c->dev;
	wm8994->control_data = i2c;
	wm8994->read_dev = wm8994_i2c_read_device;
	wm8994->write_dev = wm8994_i2c_write_device;
	wm8994->irq = i2c->irq;
	wm8994->type = id->driver_data;

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