[mirror_ubuntu-hirsute-kernel.git] / drivers / mfd / wm8350-core.c

/*
 * wm8350-core.c  --  Device access for Wolfson WM8350
 *
 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
 *
 * Author: Liam Girdwood, Mark Brown
 *
 *  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/init.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/interrupt.h>

#include <linux/mfd/wm8350/core.h>
#include <linux/mfd/wm8350/audio.h>
#include <linux/mfd/wm8350/gpio.h>
#include <linux/mfd/wm8350/pmic.h>
#include <linux/mfd/wm8350/supply.h>

#define WM8350_UNLOCK_KEY		0x0013
#define WM8350_LOCK_KEY			0x0000

#define WM8350_CLOCK_CONTROL_1		0x28
#define WM8350_AIF_TEST			0x74

/* debug */
#define WM8350_BUS_DEBUG 0
#if WM8350_BUS_DEBUG
#define dump(regs, src) do { \
	int i_; \
	u16 *src_ = src; \
	printk(KERN_DEBUG); \
	for (i_ = 0; i_ < regs; i_++) \
		printk(" 0x%4.4x", *src_++); \
	printk("\n"); \
} while (0);
#else
#define dump(bytes, src)
#endif

#define WM8350_LOCK_DEBUG 0
#if WM8350_LOCK_DEBUG
#define ldbg(format, arg...) printk(format, ## arg)
#else
#define ldbg(format, arg...)
#endif

/*
 * WM8350 Device IO
 */
static DEFINE_MUTEX(io_mutex);
static DEFINE_MUTEX(reg_lock_mutex);
static DEFINE_MUTEX(auxadc_mutex);

/* Perform a physical read from the device.
 */
static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs,
			    u16 *dest)
{
	int i, ret;
	int bytes = num_regs * 2;

	dev_dbg(wm8350->dev, "volatile read\n");
	ret = wm8350->read_dev(wm8350, reg, bytes, (char *)dest);

	for (i = reg; i < reg + num_regs; i++) {
		/* Cache is CPU endian */
		dest[i - reg] = be16_to_cpu(dest[i - reg]);

		/* Satisfy non-volatile bits from cache */
		dest[i - reg] &= wm8350_reg_io_map[i].vol;
		dest[i - reg] |= wm8350->reg_cache[i];

		/* Mask out non-readable bits */
		dest[i - reg] &= wm8350_reg_io_map[i].readable;
	}

	dump(num_regs, dest);

	return ret;
}

static int wm8350_read(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *dest)
{
	int i;
	int end = reg + num_regs;
	int ret = 0;
	int bytes = num_regs * 2;

	if (wm8350->read_dev == NULL)
		return -ENODEV;

	if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
		dev_err(wm8350->dev, "invalid reg %x\n",
			reg + num_regs - 1);
		return -EINVAL;
	}

	dev_dbg(wm8350->dev,
		"%s R%d(0x%2.2x) %d regs\n", __func__, reg, reg, num_regs);

#if WM8350_BUS_DEBUG
	/* we can _safely_ read any register, but warn if read not supported */
	for (i = reg; i < end; i++) {
		if (!wm8350_reg_io_map[i].readable)
			dev_warn(wm8350->dev,
				"reg R%d is not readable\n", i);
	}
#endif

	/* if any volatile registers are required, then read back all */
	for (i = reg; i < end; i++)
		if (wm8350_reg_io_map[i].vol)
			return wm8350_phys_read(wm8350, reg, num_regs, dest);

	/* no volatiles, then cache is good */
	dev_dbg(wm8350->dev, "cache read\n");
	memcpy(dest, &wm8350->reg_cache[reg], bytes);
	dump(num_regs, dest);
	return ret;
}

static inline int is_reg_locked(struct wm8350 *wm8350, u8 reg)
{
	if (reg == WM8350_SECURITY ||
	    wm8350->reg_cache[WM8350_SECURITY] == WM8350_UNLOCK_KEY)
		return 0;

	if ((reg == WM8350_GPIO_CONFIGURATION_I_O) ||
	    (reg >= WM8350_GPIO_FUNCTION_SELECT_1 &&
	     reg <= WM8350_GPIO_FUNCTION_SELECT_4) ||
	    (reg >= WM8350_BATTERY_CHARGER_CONTROL_1 &&
	     reg <= WM8350_BATTERY_CHARGER_CONTROL_3))
		return 1;
	return 0;
}

static int wm8350_write(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *src)
{
	int i;
	int end = reg + num_regs;
	int bytes = num_regs * 2;

	if (wm8350->write_dev == NULL)
		return -ENODEV;

	if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
		dev_err(wm8350->dev, "invalid reg %x\n",
			reg + num_regs - 1);
		return -EINVAL;
	}

	/* it's generally not a good idea to write to RO or locked registers */
	for (i = reg; i < end; i++) {
		if (!wm8350_reg_io_map[i].writable) {
			dev_err(wm8350->dev,
				"attempted write to read only reg R%d\n", i);
			return -EINVAL;
		}

		if (is_reg_locked(wm8350, i)) {
			dev_err(wm8350->dev,
			       "attempted write to locked reg R%d\n", i);
			return -EINVAL;
		}

		src[i - reg] &= wm8350_reg_io_map[i].writable;

		wm8350->reg_cache[i] =
			(wm8350->reg_cache[i] & ~wm8350_reg_io_map[i].writable)
			| src[i - reg];

		src[i - reg] = cpu_to_be16(src[i - reg]);
	}

	/* Actually write it out */
	return wm8350->write_dev(wm8350, reg, bytes, (char *)src);
}

/*
 * Safe read, modify, write methods
 */
int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
{
	u16 data;
	int err;

	mutex_lock(&io_mutex);
	err = wm8350_read(wm8350, reg, 1, &data);
	if (err) {
		dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
		goto out;
	}

	data &= ~mask;
	err = wm8350_write(wm8350, reg, 1, &data);
	if (err)
		dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
out:
	mutex_unlock(&io_mutex);
	return err;
}
EXPORT_SYMBOL_GPL(wm8350_clear_bits);

int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
{
	u16 data;
	int err;

	mutex_lock(&io_mutex);
	err = wm8350_read(wm8350, reg, 1, &data);
	if (err) {
		dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
		goto out;
	}

	data |= mask;
	err = wm8350_write(wm8350, reg, 1, &data);
	if (err)
		dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
out:
	mutex_unlock(&io_mutex);
	return err;
}
EXPORT_SYMBOL_GPL(wm8350_set_bits);

u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
{
	u16 data;
	int err;

	mutex_lock(&io_mutex);
	err = wm8350_read(wm8350, reg, 1, &data);
	if (err)
		dev_err(wm8350->dev, "read from reg R%d failed\n", reg);

	mutex_unlock(&io_mutex);
	return data;
}
EXPORT_SYMBOL_GPL(wm8350_reg_read);

int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val)
{
	int ret;
	u16 data = val;

	mutex_lock(&io_mutex);
	ret = wm8350_write(wm8350, reg, 1, &data);
	if (ret)
		dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
	mutex_unlock(&io_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_reg_write);

int wm8350_block_read(struct wm8350 *wm8350, int start_reg, int regs,
		      u16 *dest)
{
	int err = 0;

	mutex_lock(&io_mutex);
	err = wm8350_read(wm8350, start_reg, regs, dest);
	if (err)
		dev_err(wm8350->dev, "block read starting from R%d failed\n",
			start_reg);
	mutex_unlock(&io_mutex);
	return err;
}
EXPORT_SYMBOL_GPL(wm8350_block_read);

int wm8350_block_write(struct wm8350 *wm8350, int start_reg, int regs,
		       u16 *src)
{
	int ret = 0;

	mutex_lock(&io_mutex);
	ret = wm8350_write(wm8350, start_reg, regs, src);
	if (ret)
		dev_err(wm8350->dev, "block write starting at R%d failed\n",
			start_reg);
	mutex_unlock(&io_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_block_write);

int wm8350_reg_lock(struct wm8350 *wm8350)
{
	u16 key = WM8350_LOCK_KEY;
	int ret;

	ldbg(__func__);
	mutex_lock(&io_mutex);
	ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
	if (ret)
		dev_err(wm8350->dev, "lock failed\n");
	mutex_unlock(&io_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_reg_lock);

int wm8350_reg_unlock(struct wm8350 *wm8350)
{
	u16 key = WM8350_UNLOCK_KEY;
	int ret;

	ldbg(__func__);
	mutex_lock(&io_mutex);
	ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
	if (ret)
		dev_err(wm8350->dev, "unlock failed\n");
	mutex_unlock(&io_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_reg_unlock);

/*
 * Cache is always host endian.
 */
static int wm8350_create_cache(struct wm8350 *wm8350, int mode)
{
	int i, ret = 0;
	u16 value;
	const u16 *reg_map;

	switch (mode) {
#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_0
	case 0:
		reg_map = wm8350_mode0_defaults;
		break;
#endif
#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_1
	case 1:
		reg_map = wm8350_mode1_defaults;
		break;
#endif
#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_2
	case 2:
		reg_map = wm8350_mode2_defaults;
		break;
#endif
#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_3
	case 3:
		reg_map = wm8350_mode3_defaults;
		break;
#endif
	default:
		dev_err(wm8350->dev, "Configuration mode %d not supported\n",
			mode);
		return -EINVAL;
	}

	wm8350->reg_cache =
	    kzalloc(sizeof(u16) * (WM8350_MAX_REGISTER + 1), GFP_KERNEL);
	if (wm8350->reg_cache == NULL)
		return -ENOMEM;

	/* Read the initial cache state back from the device - this is
	 * a PMIC so the device many not be in a virgin state and we
	 * can't rely on the silicon values.
	 */
	for (i = 0; i < WM8350_MAX_REGISTER; i++) {
		/* audio register range */
		if (wm8350_reg_io_map[i].readable &&
		    (i < WM8350_CLOCK_CONTROL_1 || i > WM8350_AIF_TEST)) {
			ret = wm8350->read_dev(wm8350, i, 2, (char *)&value);
			if (ret < 0) {
				dev_err(wm8350->dev,
				       "failed to read initial cache value\n");
				goto out;
			}
			value = be16_to_cpu(value);
			value &= wm8350_reg_io_map[i].readable;
			wm8350->reg_cache[i] = value;
		} else
			wm8350->reg_cache[i] = reg_map[i];
	}

out:
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_create_cache);

int wm8350_device_init(struct wm8350 *wm8350,
		       struct wm8350_platform_data *pdata)
{
	int ret = -EINVAL;
	u16 id1, id2, mask, mode;

	/* get WM8350 revision and config mode */
	wm8350->read_dev(wm8350, WM8350_RESET_ID, sizeof(id1), &id1);
	wm8350->read_dev(wm8350, WM8350_ID, sizeof(id2), &id2);

	id1 = be16_to_cpu(id1);
	id2 = be16_to_cpu(id2);

	if (id1 == 0x0)
		dev_info(wm8350->dev, "Found Rev C device\n");
	else if (id1 == 0x6143) {
		switch ((id2 & WM8350_CHIP_REV_MASK) >> 12) {
		case WM8350_REV_E:
			dev_info(wm8350->dev, "Found Rev E device\n");
			wm8350->rev = WM8350_REV_E;
			break;
		case WM8350_REV_F:
			dev_info(wm8350->dev, "Found Rev F device\n");
			wm8350->rev = WM8350_REV_F;
			break;
		case WM8350_REV_G:
			dev_info(wm8350->dev, "Found Rev G device\n");
			wm8350->rev = WM8350_REV_G;
			break;
		default:
			/* For safety we refuse to run on unknown hardware */
			dev_info(wm8350->dev, "Found unknown rev\n");
			ret = -ENODEV;
			goto err;
		}
	} else {
		dev_info(wm8350->dev, "Device with ID %x is not a WM8350\n",
			 id1);
		ret = -ENODEV;
		goto err;
	}

	mode = id2 & WM8350_CONF_STS_MASK >> 10;
	mask = id2 & WM8350_CUST_ID_MASK;
	dev_info(wm8350->dev, "Config mode %d, ROM mask %d\n", mode, mask);

	ret = wm8350_create_cache(wm8350, mode);
	if (ret < 0) {
		printk(KERN_ERR "wm8350: failed to create register cache\n");
		return ret;
	}

	if (pdata->init) {
		ret = pdata->init(wm8350);
		if (ret != 0) {
			dev_err(wm8350->dev, "Platform init() failed: %d\n",
				ret);
			goto err;
		}
	}

	return 0;

err:
	kfree(wm8350->reg_cache);
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_device_init);

void wm8350_device_exit(struct wm8350 *wm8350)
{
	kfree(wm8350->reg_cache);
}
EXPORT_SYMBOL_GPL(wm8350_device_exit);

MODULE_LICENSE("GPL");
Commit	Line	Data
89b4012b MB	1	/*
	2	* wm8350-core.c -- Device access for Wolfson WM8350
	3	*
	4	* Copyright 2007, 2008 Wolfson Microelectronics PLC.
	5	*
	6	* Author: Liam Girdwood, Mark Brown
	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>
	17	#include <linux/init.h>
	18	#include <linux/device.h>
	19	#include <linux/delay.h>
	20	#include <linux/interrupt.h>
	21
	22	#include <linux/mfd/wm8350/core.h>
	23	#include <linux/mfd/wm8350/audio.h>
	24	#include <linux/mfd/wm8350/gpio.h>
	25	#include <linux/mfd/wm8350/pmic.h>
	26	#include <linux/mfd/wm8350/supply.h>
	27
	28	#define WM8350_UNLOCK_KEY 0x0013
	29	#define WM8350_LOCK_KEY 0x0000
	30
	31	#define WM8350_CLOCK_CONTROL_1 0x28
	32	#define WM8350_AIF_TEST 0x74
	33
	34	/* debug */
	35	#define WM8350_BUS_DEBUG 0
	36	#if WM8350_BUS_DEBUG
	37	#define dump(regs, src) do { \
	38	int i_; \
	39	u16 *src_ = src; \
	40	printk(KERN_DEBUG); \
	41	for (i_ = 0; i_ < regs; i_++) \
	42	printk(" 0x%4.4x", *src_++); \
	43	printk("\n"); \
	44	} while (0);
	45	#else
	46	#define dump(bytes, src)
	47	#endif
	48
	49	#define WM8350_LOCK_DEBUG 0
	50	#if WM8350_LOCK_DEBUG
	51	#define ldbg(format, arg...) printk(format, ## arg)
	52	#else
	53	#define ldbg(format, arg...)
	54	#endif
	55
	56	/*
	57	* WM8350 Device IO
	58	*/
	59	static DEFINE_MUTEX(io_mutex);
	60	static DEFINE_MUTEX(reg_lock_mutex);
	61	static DEFINE_MUTEX(auxadc_mutex);
	62
	63	/* Perform a physical read from the device.
	64	*/
65	static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs,
66	u16 *dest)
67	{
68	int i, ret;
69	int bytes = num_regs * 2;
70
71	dev_dbg(wm8350->dev, "volatile read\n");
72	ret = wm8350->read_dev(wm8350, reg, bytes, (char *)dest);
73
74	for (i = reg; i < reg + num_regs; i++) {
75	/* Cache is CPU endian */
76	dest[i - reg] = be16_to_cpu(dest[i - reg]);
77
78	/* Satisfy non-volatile bits from cache */
79	dest[i - reg] &= wm8350_reg_io_map[i].vol;
80	dest[i - reg] \|= wm8350->reg_cache[i];
81
82	/* Mask out non-readable bits */
83	dest[i - reg] &= wm8350_reg_io_map[i].readable;
84	}
85
86	dump(num_regs, dest);
87
88	return ret;
89	}
90
91	static int wm8350_read(struct wm8350 wm8350, u8 reg, int num_regs, u16 dest)
92	{
93	int i;
94	int end = reg + num_regs;
95	int ret = 0;
96	int bytes = num_regs * 2;
97
98	if (wm8350->read_dev == NULL)
99	return -ENODEV;
100
101	if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
102	dev_err(wm8350->dev, "invalid reg %x\n",
103	reg + num_regs - 1);
104	return -EINVAL;
105	}
106
107	dev_dbg(wm8350->dev,
108	"%s R%d(0x%2.2x) %d regs\n", __func__, reg, reg, num_regs);
109
110	#if WM8350_BUS_DEBUG
111	/* we can _safely_ read any register, but warn if read not supported */
112	for (i = reg; i < end; i++) {
113	if (!wm8350_reg_io_map[i].readable)
114	dev_warn(wm8350->dev,
115	"reg R%d is not readable\n", i);
116	}
117	#endif
118
119	/* if any volatile registers are required, then read back all */
120	for (i = reg; i < end; i++)
121	if (wm8350_reg_io_map[i].vol)
122	return wm8350_phys_read(wm8350, reg, num_regs, dest);
123
124	/* no volatiles, then cache is good */
125	dev_dbg(wm8350->dev, "cache read\n");
126	memcpy(dest, &wm8350->reg_cache[reg], bytes);
127	dump(num_regs, dest);
128	return ret;
129	}
130
131	static inline int is_reg_locked(struct wm8350 *wm8350, u8 reg)
132	{
133	if (reg == WM8350_SECURITY \|\|
134	wm8350->reg_cache[WM8350_SECURITY] == WM8350_UNLOCK_KEY)
135	return 0;
136
137	if ((reg == WM8350_GPIO_CONFIGURATION_I_O) \|\|
138	(reg >= WM8350_GPIO_FUNCTION_SELECT_1 &&
139	reg <= WM8350_GPIO_FUNCTION_SELECT_4) \|\|
140	(reg >= WM8350_BATTERY_CHARGER_CONTROL_1 &&
141	reg <= WM8350_BATTERY_CHARGER_CONTROL_3))
142	return 1;
143	return 0;
144	}
145
146	static int wm8350_write(struct wm8350 wm8350, u8 reg, int num_regs, u16 src)
147	{
148	int i;
149	int end = reg + num_regs;
150	int bytes = num_regs * 2;
151
152	if (wm8350->write_dev == NULL)
153	return -ENODEV;
154
155	if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
156	dev_err(wm8350->dev, "invalid reg %x\n",
157	reg + num_regs - 1);
158	return -EINVAL;
159	}
160
161	/* it's generally not a good idea to write to RO or locked registers */
162	for (i = reg; i < end; i++) {
163	if (!wm8350_reg_io_map[i].writable) {
164	dev_err(wm8350->dev,
165	"attempted write to read only reg R%d\n", i);
166	return -EINVAL;
167	}
168
169	if (is_reg_locked(wm8350, i)) {
170	dev_err(wm8350->dev,
171	"attempted write to locked reg R%d\n", i);
172	return -EINVAL;
173	}
174
175	src[i - reg] &= wm8350_reg_io_map[i].writable;
176
177	wm8350->reg_cache[i] =
178	(wm8350->reg_cache[i] & ~wm8350_reg_io_map[i].writable)
179	\| src[i - reg];
180
181	src[i - reg] = cpu_to_be16(src[i - reg]);
182	}
183
184	/* Actually write it out */
185	return wm8350->write_dev(wm8350, reg, bytes, (char *)src);
186	}
187
188	/*
189	* Safe read, modify, write methods
190	*/
191	int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
192	{
193	u16 data;
194	int err;
195
196	mutex_lock(&io_mutex);
197	err = wm8350_read(wm8350, reg, 1, &data);
198	if (err) {
199	dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
200	goto out;
201	}
202
203	data &= ~mask;
204	err = wm8350_write(wm8350, reg, 1, &data);
205	if (err)
206	dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
207	out:
208	mutex_unlock(&io_mutex);
209	return err;
210	}
211	EXPORT_SYMBOL_GPL(wm8350_clear_bits);
212
213	int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
214	{
215	u16 data;
216	int err;
217
218	mutex_lock(&io_mutex);
219	err = wm8350_read(wm8350, reg, 1, &data);
220	if (err) {
221	dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
222	goto out;
223	}
224
225	data \|= mask;
226	err = wm8350_write(wm8350, reg, 1, &data);
227	if (err)
228	dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
229	out:
230	mutex_unlock(&io_mutex);
231	return err;
232	}
233	EXPORT_SYMBOL_GPL(wm8350_set_bits);
234
235	u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
236	{
237	u16 data;
238	int err;
239
240	mutex_lock(&io_mutex);
241	err = wm8350_read(wm8350, reg, 1, &data);
242	if (err)
243	dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
244
245	mutex_unlock(&io_mutex);
246	return data;
247	}
248	EXPORT_SYMBOL_GPL(wm8350_reg_read);
249
250	int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val)
251	{
252	int ret;
253	u16 data = val;
254
255	mutex_lock(&io_mutex);
256	ret = wm8350_write(wm8350, reg, 1, &data);
257	if (ret)
258	dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
259	mutex_unlock(&io_mutex);
260	return ret;
261	}
262	EXPORT_SYMBOL_GPL(wm8350_reg_write);
263
264	int wm8350_block_read(struct wm8350 *wm8350, int start_reg, int regs,
265	u16 *dest)
266	{
267	int err = 0;
268
269	mutex_lock(&io_mutex);
270	err = wm8350_read(wm8350, start_reg, regs, dest);
271	if (err)
272	dev_err(wm8350->dev, "block read starting from R%d failed\n",
273	start_reg);
274	mutex_unlock(&io_mutex);
275	return err;
276	}
277	EXPORT_SYMBOL_GPL(wm8350_block_read);
278
279	int wm8350_block_write(struct wm8350 *wm8350, int start_reg, int regs,
280	u16 *src)
281	{
282	int ret = 0;
283
284	mutex_lock(&io_mutex);
285	ret = wm8350_write(wm8350, start_reg, regs, src);
286	if (ret)
287	dev_err(wm8350->dev, "block write starting at R%d failed\n",
288	start_reg);
289	mutex_unlock(&io_mutex);
290	return ret;
291	}
292	EXPORT_SYMBOL_GPL(wm8350_block_write);
293
294	int wm8350_reg_lock(struct wm8350 *wm8350)
295	{
296	u16 key = WM8350_LOCK_KEY;
297	int ret;
298
299	ldbg(__func__);
300	mutex_lock(&io_mutex);
301	ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
302	if (ret)
303	dev_err(wm8350->dev, "lock failed\n");
304	mutex_unlock(&io_mutex);
305	return ret;
306	}
307	EXPORT_SYMBOL_GPL(wm8350_reg_lock);
308
309	int wm8350_reg_unlock(struct wm8350 *wm8350)
310	{
311	u16 key = WM8350_UNLOCK_KEY;
312	int ret;
313
314	ldbg(__func__);
315	mutex_lock(&io_mutex);
316	ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
317	if (ret)
318	dev_err(wm8350->dev, "unlock failed\n");
319	mutex_unlock(&io_mutex);
320	return ret;
321	}
322	EXPORT_SYMBOL_GPL(wm8350_reg_unlock);
323
324	/*
325	* Cache is always host endian.
326	*/
327	static int wm8350_create_cache(struct wm8350 *wm8350, int mode)
328	{
329	int i, ret = 0;
330	u16 value;
331	const u16 *reg_map;
332
333	switch (mode) {
334	#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_0
335	case 0:
336	reg_map = wm8350_mode0_defaults;
337	break;
338	#endif
339	#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_1
340	case 1:
341	reg_map = wm8350_mode1_defaults;
342	break;
343	#endif
344	#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_2
345	case 2:
346	reg_map = wm8350_mode2_defaults;
347	break;
348	#endif
349	#ifdef CONFIG_MFD_WM8350_CONFIG_MODE_3
350	case 3:
351	reg_map = wm8350_mode3_defaults;
352	break;
353	#endif
354	default:
355	dev_err(wm8350->dev, "Configuration mode %d not supported\n",
356	mode);
357	return -EINVAL;
358	}
359
360	wm8350->reg_cache =
361	kzalloc(sizeof(u16) * (WM8350_MAX_REGISTER + 1), GFP_KERNEL);
362	if (wm8350->reg_cache == NULL)
363	return -ENOMEM;
364
365	/* Read the initial cache state back from the device - this is
366	* a PMIC so the device many not be in a virgin state and we
367	* can't rely on the silicon values.
368	*/
369	for (i = 0; i < WM8350_MAX_REGISTER; i++) {
370	/* audio register range */
371	if (wm8350_reg_io_map[i].readable &&
372	(i < WM8350_CLOCK_CONTROL_1 \|\| i > WM8350_AIF_TEST)) {
373	ret = wm8350->read_dev(wm8350, i, 2, (char *)&value);
374	if (ret < 0) {
375	dev_err(wm8350->dev,
376	"failed to read initial cache value\n");
377	goto out;
378	}
379	value = be16_to_cpu(value);
380	value &= wm8350_reg_io_map[i].readable;
381	wm8350->reg_cache[i] = value;
382	} else
383	wm8350->reg_cache[i] = reg_map[i];
384	}
385
386	out:
387	return ret;
388	}
389	EXPORT_SYMBOL_GPL(wm8350_create_cache);
390
bcdd4efc MB	391	int wm8350_device_init(struct wm8350 *wm8350,
bcdd4efc MB	392	struct wm8350_platform_data *pdata)
89b4012b MB	393	{
	394	int ret = -EINVAL;
	395	u16 id1, id2, mask, mode;
	396
	397	/* get WM8350 revision and config mode */
	398	wm8350->read_dev(wm8350, WM8350_RESET_ID, sizeof(id1), &id1);
	399	wm8350->read_dev(wm8350, WM8350_ID, sizeof(id2), &id2);
	400
	401	id1 = be16_to_cpu(id1);
	402	id2 = be16_to_cpu(id2);
	403
	404	if (id1 == 0x0)
	405	dev_info(wm8350->dev, "Found Rev C device\n");
	406	else if (id1 == 0x6143) {
	407	switch ((id2 & WM8350_CHIP_REV_MASK) >> 12) {
	408	case WM8350_REV_E:
	409	dev_info(wm8350->dev, "Found Rev E device\n");
	410	wm8350->rev = WM8350_REV_E;
	411	break;
	412	case WM8350_REV_F:
	413	dev_info(wm8350->dev, "Found Rev F device\n");
	414	wm8350->rev = WM8350_REV_F;
	415	break;
	416	case WM8350_REV_G:
	417	dev_info(wm8350->dev, "Found Rev G device\n");
	418	wm8350->rev = WM8350_REV_G;
	419	break;
	420	default:
	421	/* For safety we refuse to run on unknown hardware */
	422	dev_info(wm8350->dev, "Found unknown rev\n");
	423	ret = -ENODEV;
	424	goto err;
	425	}
	426	} else {
	427	dev_info(wm8350->dev, "Device with ID %x is not a WM8350\n",
	428	id1);
	429	ret = -ENODEV;
	430	goto err;
	431	}
	432
	433	mode = id2 & WM8350_CONF_STS_MASK >> 10;
	434	mask = id2 & WM8350_CUST_ID_MASK;
	435	dev_info(wm8350->dev, "Config mode %d, ROM mask %d\n", mode, mask);
	436
	437	ret = wm8350_create_cache(wm8350, mode);
	438	if (ret < 0) {
	439	printk(KERN_ERR "wm8350: failed to create register cache\n");
	440	return ret;
	441	}
	442
bcdd4efc MB	443	if (pdata->init) {
	444	ret = pdata->init(wm8350);
	445	if (ret != 0) {
	446	dev_err(wm8350->dev, "Platform init() failed: %d\n",
	447	ret);
	448	goto err;
	449	}
	450	}
	451
89b4012b MB	452	return 0;
	453
	454	err:
	455	kfree(wm8350->reg_cache);
	456	return ret;
	457	}
	458	EXPORT_SYMBOL_GPL(wm8350_device_init);
	459
	460	void wm8350_device_exit(struct wm8350 *wm8350)
	461	{
	462	kfree(wm8350->reg_cache);
	463	}
	464	EXPORT_SYMBOL_GPL(wm8350_device_exit);
	465
	466	MODULE_LICENSE("GPL");