[deliverable/linux.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/slab.h>
#include <linux/bug.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/regmap.h>
#include <linux/workqueue.h>

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

#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(reg_lock_mutex);

/*
 * Safe read, modify, write methods
 */
int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
{
	return regmap_update_bits(wm8350->regmap, reg, mask, 0);
}
EXPORT_SYMBOL_GPL(wm8350_clear_bits);

int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
{
	return regmap_update_bits(wm8350->regmap, reg, mask, mask);
}
EXPORT_SYMBOL_GPL(wm8350_set_bits);

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

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

	return data;
}
EXPORT_SYMBOL_GPL(wm8350_reg_read);

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

	ret = regmap_write(wm8350->regmap, reg, val);

	if (ret)
		dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
	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;

	err = regmap_bulk_read(wm8350->regmap, start_reg, dest, regs);
	if (err)
		dev_err(wm8350->dev, "block read starting from R%d failed\n",
			start_reg);

	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;

	ret = regmap_bulk_write(wm8350->regmap, start_reg, src, regs);
	if (ret)
		dev_err(wm8350->dev, "block write starting at R%d failed\n",
			start_reg);

	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_block_write);

/**
 * wm8350_reg_lock()
 *
 * The WM8350 has a hardware lock which can be used to prevent writes to
 * some registers (generally those which can cause particularly serious
 * problems if misused).  This function enables that lock.
 */
int wm8350_reg_lock(struct wm8350 *wm8350)
{
	int ret;

	mutex_lock(&reg_lock_mutex);

	ldbg(__func__);

	ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_LOCK_KEY);
	if (ret)
		dev_err(wm8350->dev, "lock failed\n");

	wm8350->unlocked = false;

	mutex_unlock(&reg_lock_mutex);

	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_reg_lock);

/**
 * wm8350_reg_unlock()
 *
 * The WM8350 has a hardware lock which can be used to prevent writes to
 * some registers (generally those which can cause particularly serious
 * problems if misused).  This function disables that lock so updates
 * can be performed.  For maximum safety this should be done only when
 * required.
 */
int wm8350_reg_unlock(struct wm8350 *wm8350)
{
	int ret;

	mutex_lock(&reg_lock_mutex);

	ldbg(__func__);

	ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_UNLOCK_KEY);
	if (ret)
		dev_err(wm8350->dev, "unlock failed\n");

	wm8350->unlocked = true;

	mutex_unlock(&reg_lock_mutex);

	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_reg_unlock);

int wm8350_read_auxadc(struct wm8350 *wm8350, int channel, int scale, int vref)
{
	u16 reg, result = 0;

	if (channel < WM8350_AUXADC_AUX1 || channel > WM8350_AUXADC_TEMP)
		return -EINVAL;
	if (channel >= WM8350_AUXADC_USB && channel <= WM8350_AUXADC_TEMP
	    && (scale != 0 || vref != 0))
		return -EINVAL;

	mutex_lock(&wm8350->auxadc_mutex);

	/* Turn on the ADC */
	reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
	wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5, reg | WM8350_AUXADC_ENA);

	if (scale || vref) {
		reg = scale << 13;
		reg |= vref << 12;
		wm8350_reg_write(wm8350, WM8350_AUX1_READBACK + channel, reg);
	}

	reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
	reg |= 1 << channel | WM8350_AUXADC_POLL;
	wm8350_reg_write(wm8350, WM8350_DIGITISER_CONTROL_1, reg);

	/* If a late IRQ left the completion signalled then consume
	 * the completion. */
	try_wait_for_completion(&wm8350->auxadc_done);

	/* We ignore the result of the completion and just check for a
	 * conversion result, allowing us to soldier on if the IRQ
	 * infrastructure is not set up for the chip. */
	wait_for_completion_timeout(&wm8350->auxadc_done, msecs_to_jiffies(5));

	reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
	if (reg & WM8350_AUXADC_POLL)
		dev_err(wm8350->dev, "adc chn %d read timeout\n", channel);
	else
		result = wm8350_reg_read(wm8350,
					 WM8350_AUX1_READBACK + channel);

	/* Turn off the ADC */
	reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
	wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5,
			 reg & ~WM8350_AUXADC_ENA);

	mutex_unlock(&wm8350->auxadc_mutex);

	return result & WM8350_AUXADC_DATA1_MASK;
}
EXPORT_SYMBOL_GPL(wm8350_read_auxadc);

static irqreturn_t wm8350_auxadc_irq(int irq, void *irq_data)
{
	struct wm8350 *wm8350 = irq_data;

	complete(&wm8350->auxadc_done);

	return IRQ_HANDLED;
}

/*
 * Register a client device.  This is non-fatal since there is no need to
 * fail the entire device init due to a single platform device failing.
 */
static void wm8350_client_dev_register(struct wm8350 *wm8350,
				       const char *name,
				       struct platform_device **pdev)
{
	int ret;

	*pdev = platform_device_alloc(name, -1);
	if (*pdev == NULL) {
		dev_err(wm8350->dev, "Failed to allocate %s\n", name);
		return;
	}

	(*pdev)->dev.parent = wm8350->dev;
	platform_set_drvdata(*pdev, wm8350);
	ret = platform_device_add(*pdev);
	if (ret != 0) {
		dev_err(wm8350->dev, "Failed to register %s: %d\n", name, ret);
		platform_device_put(*pdev);
		*pdev = NULL;
	}
}

int wm8350_device_init(struct wm8350 *wm8350, int irq,
		       struct wm8350_platform_data *pdata)
{
	int ret;
	unsigned int id1, id2, mask_rev;
	unsigned int cust_id, mode, chip_rev;

	dev_set_drvdata(wm8350->dev, wm8350);

	/* get WM8350 revision and config mode */
	ret = regmap_read(wm8350->regmap, WM8350_RESET_ID, &id1);
	if (ret != 0) {
		dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
		goto err;
	}

	ret = regmap_read(wm8350->regmap, WM8350_ID, &id2);
	if (ret != 0) {
		dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
		goto err;
	}

	ret = regmap_read(wm8350->regmap, WM8350_REVISION, &mask_rev);
	if (ret != 0) {
		dev_err(wm8350->dev, "Failed to read revision: %d\n", ret);
		goto err;
	}

	if (id1 != 0x6143) {
		dev_err(wm8350->dev,
			"Device with ID %x is not a WM8350\n", id1);
		ret = -ENODEV;
		goto err;
	}

	mode = (id2 & WM8350_CONF_STS_MASK) >> 10;
	cust_id = id2 & WM8350_CUST_ID_MASK;
	chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12;
	dev_info(wm8350->dev,
		 "CONF_STS %d, CUST_ID %d, MASK_REV %d, CHIP_REV %d\n",
		 mode, cust_id, mask_rev, chip_rev);

	if (cust_id != 0) {
		dev_err(wm8350->dev, "Unsupported CUST_ID\n");
		ret = -ENODEV;
		goto err;
	}

	switch (mask_rev) {
	case 0:
		wm8350->pmic.max_dcdc = WM8350_DCDC_6;
		wm8350->pmic.max_isink = WM8350_ISINK_B;

		switch (chip_rev) {
		case WM8350_REV_E:
			dev_info(wm8350->dev, "WM8350 Rev E\n");
			break;
		case WM8350_REV_F:
			dev_info(wm8350->dev, "WM8350 Rev F\n");
			break;
		case WM8350_REV_G:
			dev_info(wm8350->dev, "WM8350 Rev G\n");
			wm8350->power.rev_g_coeff = 1;
			break;
		case WM8350_REV_H:
			dev_info(wm8350->dev, "WM8350 Rev H\n");
			wm8350->power.rev_g_coeff = 1;
			break;
		default:
			/* For safety we refuse to run on unknown hardware */
			dev_err(wm8350->dev, "Unknown WM8350 CHIP_REV\n");
			ret = -ENODEV;
			goto err;
		}
		break;

	case 1:
		wm8350->pmic.max_dcdc = WM8350_DCDC_4;
		wm8350->pmic.max_isink = WM8350_ISINK_A;

		switch (chip_rev) {
		case 0:
			dev_info(wm8350->dev, "WM8351 Rev A\n");
			wm8350->power.rev_g_coeff = 1;
			break;

		case 1:
			dev_info(wm8350->dev, "WM8351 Rev B\n");
			wm8350->power.rev_g_coeff = 1;
			break;

		default:
			dev_err(wm8350->dev, "Unknown WM8351 CHIP_REV\n");
			ret = -ENODEV;
			goto err;
		}
		break;

	case 2:
		wm8350->pmic.max_dcdc = WM8350_DCDC_6;
		wm8350->pmic.max_isink = WM8350_ISINK_B;

		switch (chip_rev) {
		case 0:
			dev_info(wm8350->dev, "WM8352 Rev A\n");
			wm8350->power.rev_g_coeff = 1;
			break;

		default:
			dev_err(wm8350->dev, "Unknown WM8352 CHIP_REV\n");
			ret = -ENODEV;
			goto err;
		}
		break;

	default:
		dev_err(wm8350->dev, "Unknown MASK_REV\n");
		ret = -ENODEV;
		goto err;
	}

	mutex_init(&wm8350->auxadc_mutex);
	init_completion(&wm8350->auxadc_done);

	ret = wm8350_irq_init(wm8350, irq, pdata);
	if (ret < 0)
		goto err;

	if (wm8350->irq_base) {
		ret = request_threaded_irq(wm8350->irq_base +
					   WM8350_IRQ_AUXADC_DATARDY,
					   NULL, wm8350_auxadc_irq,
					   IRQF_ONESHOT,
					   "auxadc", wm8350);
		if (ret < 0)
			dev_warn(wm8350->dev,
				 "Failed to request AUXADC IRQ: %d\n", ret);
	}

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

	wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0x0);

	wm8350_client_dev_register(wm8350, "wm8350-codec",
				   &(wm8350->codec.pdev));
	wm8350_client_dev_register(wm8350, "wm8350-gpio",
				   &(wm8350->gpio.pdev));
	wm8350_client_dev_register(wm8350, "wm8350-hwmon",
				   &(wm8350->hwmon.pdev));
	wm8350_client_dev_register(wm8350, "wm8350-power",
				   &(wm8350->power.pdev));
	wm8350_client_dev_register(wm8350, "wm8350-rtc", &(wm8350->rtc.pdev));
	wm8350_client_dev_register(wm8350, "wm8350-wdt", &(wm8350->wdt.pdev));

	return 0;

err_irq:
	wm8350_irq_exit(wm8350);
err:
	return ret;
}
EXPORT_SYMBOL_GPL(wm8350_device_init);

void wm8350_device_exit(struct wm8350 *wm8350)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(wm8350->pmic.led); i++)
		platform_device_unregister(wm8350->pmic.led[i].pdev);

	for (i = 0; i < ARRAY_SIZE(wm8350->pmic.pdev); i++)
		platform_device_unregister(wm8350->pmic.pdev[i]);

	platform_device_unregister(wm8350->wdt.pdev);
	platform_device_unregister(wm8350->rtc.pdev);
	platform_device_unregister(wm8350->power.pdev);
	platform_device_unregister(wm8350->hwmon.pdev);
	platform_device_unregister(wm8350->gpio.pdev);
	platform_device_unregister(wm8350->codec.pdev);

	if (wm8350->irq_base)
		free_irq(wm8350->irq_base + WM8350_IRQ_AUXADC_DATARDY, wm8350);

	wm8350_irq_exit(wm8350);
}
EXPORT_SYMBOL_GPL(wm8350_device_exit);

MODULE_DESCRIPTION("WM8350 AudioPlus PMIC core driver");
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>
5a0e3ad6	17	#include <linux/slab.h>
ebccec0f	18	#include <linux/bug.h>
89b4012b MB	19	#include <linux/device.h>
	20	#include <linux/delay.h>
	21	#include <linux/interrupt.h>
b7b142d9	22	#include <linux/regmap.h>
ebccec0f	23	#include <linux/workqueue.h>
89b4012b MB	24
	25	#include <linux/mfd/wm8350/core.h>
	26	#include <linux/mfd/wm8350/audio.h>
ebccec0f	27	#include <linux/mfd/wm8350/comparator.h>
89b4012b MB	28	#include <linux/mfd/wm8350/gpio.h>
89b4012b MB	29	#include <linux/mfd/wm8350/pmic.h>
ebccec0f	30	#include <linux/mfd/wm8350/rtc.h>
89b4012b	31	#include <linux/mfd/wm8350/supply.h>
ebccec0f	32	#include <linux/mfd/wm8350/wdt.h>
89b4012b	33
89b4012b MB	34	#define WM8350_CLOCK_CONTROL_1 0x28
	35	#define WM8350_AIF_TEST 0x74
	36
	37	/* debug */
	38	#define WM8350_BUS_DEBUG 0
	39	#if WM8350_BUS_DEBUG
	40	#define dump(regs, src) do { \
	41	int i_; \
	42	u16 *src_ = src; \
	43	printk(KERN_DEBUG); \
	44	for (i_ = 0; i_ < regs; i_++) \
	45	printk(" 0x%4.4x", *src_++); \
	46	printk("\n"); \
	47	} while (0);
	48	#else
	49	#define dump(bytes, src)
	50	#endif
	51
	52	#define WM8350_LOCK_DEBUG 0
	53	#if WM8350_LOCK_DEBUG
	54	#define ldbg(format, arg...) printk(format, ## arg)
	55	#else
	56	#define ldbg(format, arg...)
	57	#endif
	58
	59	/*
	60	* WM8350 Device IO
	61	*/
89b4012b	62	static DEFINE_MUTEX(reg_lock_mutex);
89b4012b	63
89b4012b MB	64	/*
	65	* Safe read, modify, write methods
	66	*/
	67	int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
	68	{
19d57ed5	69	return regmap_update_bits(wm8350->regmap, reg, mask, 0);
89b4012b MB	70	}
	71	EXPORT_SYMBOL_GPL(wm8350_clear_bits);
	72
	73	int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
	74	{
19d57ed5	75	return regmap_update_bits(wm8350->regmap, reg, mask, mask);
89b4012b MB	76	}
	77	EXPORT_SYMBOL_GPL(wm8350_set_bits);
	78
	79	u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
	80	{
19d57ed5	81	unsigned int data;
89b4012b MB	82	int err;
89b4012b MB	83
19d57ed5	84	err = regmap_read(wm8350->regmap, reg, &data);
89b4012b MB	85	if (err)
	86	dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
	87
89b4012b MB	88	return data;
	89	}
	90	EXPORT_SYMBOL_GPL(wm8350_reg_read);
	91
	92	int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val)
	93	{
	94	int ret;
89b4012b	95
19d57ed5 MB	96	ret = regmap_write(wm8350->regmap, reg, val);
19d57ed5 MB	97
89b4012b MB	98	if (ret)
89b4012b MB	99	dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
89b4012b MB	100	return ret;
	101	}
	102	EXPORT_SYMBOL_GPL(wm8350_reg_write);
	103
	104	int wm8350_block_read(struct wm8350 *wm8350, int start_reg, int regs,
	105	u16 *dest)
	106	{
	107	int err = 0;
	108
19d57ed5	109	err = regmap_bulk_read(wm8350->regmap, start_reg, dest, regs);
89b4012b MB	110	if (err)
	111	dev_err(wm8350->dev, "block read starting from R%d failed\n",
	112	start_reg);
19d57ed5	113
89b4012b MB	114	return err;
	115	}
	116	EXPORT_SYMBOL_GPL(wm8350_block_read);
	117
	118	int wm8350_block_write(struct wm8350 *wm8350, int start_reg, int regs,
	119	u16 *src)
	120	{
	121	int ret = 0;
	122
19d57ed5	123	ret = regmap_bulk_write(wm8350->regmap, start_reg, src, regs);
89b4012b MB	124	if (ret)
	125	dev_err(wm8350->dev, "block write starting at R%d failed\n",
	126	start_reg);
19d57ed5	127
89b4012b MB	128	return ret;
	129	}
	130	EXPORT_SYMBOL_GPL(wm8350_block_write);
	131
858e6744 MB	132	/**
	133	* wm8350_reg_lock()
	134	*
	135	* The WM8350 has a hardware lock which can be used to prevent writes to
	136	* some registers (generally those which can cause particularly serious
	137	* problems if misused). This function enables that lock.
	138	*/
89b4012b MB	139	int wm8350_reg_lock(struct wm8350 *wm8350)
89b4012b MB	140	{
89b4012b MB	141	int ret;
89b4012b MB	142
52b461b8 MB	143	mutex_lock(&reg_lock_mutex);
52b461b8 MB	144
89b4012b	145	ldbg(__func__);
52b461b8 MB	146
52b461b8 MB	147	ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_LOCK_KEY);
89b4012b MB	148	if (ret)
89b4012b MB	149	dev_err(wm8350->dev, "lock failed\n");
52b461b8 MB	150
	151	wm8350->unlocked = false;
	152
	153	mutex_unlock(&reg_lock_mutex);
	154
89b4012b MB	155	return ret;
	156	}
	157	EXPORT_SYMBOL_GPL(wm8350_reg_lock);
	158
858e6744 MB	159	/**
	160	* wm8350_reg_unlock()
	161	*
	162	* The WM8350 has a hardware lock which can be used to prevent writes to
	163	* some registers (generally those which can cause particularly serious
	164	* problems if misused). This function disables that lock so updates
	165	* can be performed. For maximum safety this should be done only when
	166	* required.
	167	*/
89b4012b MB	168	int wm8350_reg_unlock(struct wm8350 *wm8350)
89b4012b MB	169	{
89b4012b MB	170	int ret;
89b4012b MB	171
52b461b8 MB	172	mutex_lock(&reg_lock_mutex);
52b461b8 MB	173
89b4012b	174	ldbg(__func__);
52b461b8 MB	175
52b461b8 MB	176	ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_UNLOCK_KEY);
89b4012b MB	177	if (ret)
89b4012b MB	178	dev_err(wm8350->dev, "unlock failed\n");
52b461b8 MB	179
	180	wm8350->unlocked = true;
	181
	182	mutex_unlock(&reg_lock_mutex);
	183
89b4012b MB	184	return ret;
	185	}
	186	EXPORT_SYMBOL_GPL(wm8350_reg_unlock);
	187
67488526 MB	188	int wm8350_read_auxadc(struct wm8350 *wm8350, int channel, int scale, int vref)
	189	{
	190	u16 reg, result = 0;
67488526 MB	191
	192	if (channel < WM8350_AUXADC_AUX1 \|\| channel > WM8350_AUXADC_TEMP)
	193	return -EINVAL;
	194	if (channel >= WM8350_AUXADC_USB && channel <= WM8350_AUXADC_TEMP
	195	&& (scale != 0 \|\| vref != 0))
	196	return -EINVAL;
	197
	198	mutex_lock(&wm8350->auxadc_mutex);
	199
	200	/* Turn on the ADC */
	201	reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
	202	wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5, reg \| WM8350_AUXADC_ENA);
	203
	204	if (scale \|\| vref) {
	205	reg = scale << 13;
	206	reg \|= vref << 12;
	207	wm8350_reg_write(wm8350, WM8350_AUX1_READBACK + channel, reg);
	208	}
	209
	210	reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
	211	reg \|= 1 << channel \| WM8350_AUXADC_POLL;
	212	wm8350_reg_write(wm8350, WM8350_DIGITISER_CONTROL_1, reg);
	213
5051d411 MB	214	/* If a late IRQ left the completion signalled then consume
	215	* the completion. */
	216	try_wait_for_completion(&wm8350->auxadc_done);
	217
d19663ac MB	218	/* We ignore the result of the completion and just check for a
	219	* conversion result, allowing us to soldier on if the IRQ
	220	* infrastructure is not set up for the chip. */
	221	wait_for_completion_timeout(&wm8350->auxadc_done, msecs_to_jiffies(5));
67488526	222
d19663ac MB	223	reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
d19663ac MB	224	if (reg & WM8350_AUXADC_POLL)
67488526 MB	225	dev_err(wm8350->dev, "adc chn %d read timeout\n", channel);
	226	else
	227	result = wm8350_reg_read(wm8350,
	228	WM8350_AUX1_READBACK + channel);
	229
	230	/* Turn off the ADC */
	231	reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
	232	wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5,
	233	reg & ~WM8350_AUXADC_ENA);
	234
	235	mutex_unlock(&wm8350->auxadc_mutex);
	236
	237	return result & WM8350_AUXADC_DATA1_MASK;
	238	}
	239	EXPORT_SYMBOL_GPL(wm8350_read_auxadc);
	240
d19663ac MB	241	static irqreturn_t wm8350_auxadc_irq(int irq, void *irq_data)
	242	{
	243	struct wm8350 *wm8350 = irq_data;
	244
	245	complete(&wm8350->auxadc_done);
	246
	247	return IRQ_HANDLED;
	248	}
	249
9201d38b MB	250	/*
	251	* Register a client device. This is non-fatal since there is no need to
	252	* fail the entire device init due to a single platform device failing.
	253	*/
	254	static void wm8350_client_dev_register(struct wm8350 *wm8350,
	255	const char *name,
	256	struct platform_device **pdev)
	257	{
	258	int ret;
	259
	260	*pdev = platform_device_alloc(name, -1);
cb9b2245	261	if (*pdev == NULL) {
9201d38b MB	262	dev_err(wm8350->dev, "Failed to allocate %s\n", name);
	263	return;
	264	}
	265
	266	(*pdev)->dev.parent = wm8350->dev;
	267	platform_set_drvdata(*pdev, wm8350);
	268	ret = platform_device_add(*pdev);
	269	if (ret != 0) {
	270	dev_err(wm8350->dev, "Failed to register %s: %d\n", name, ret);
	271	platform_device_put(*pdev);
	272	*pdev = NULL;
	273	}
	274	}
	275
ebccec0f	276	int wm8350_device_init(struct wm8350 *wm8350, int irq,
bcdd4efc	277	struct wm8350_platform_data *pdata)
89b4012b	278	{
85c93ea7	279	int ret;
b7b142d9 MB	280	unsigned int id1, id2, mask_rev;
b7b142d9 MB	281	unsigned int cust_id, mode, chip_rev;
89b4012b	282
18bf50a3 MB	283	dev_set_drvdata(wm8350->dev, wm8350);
18bf50a3 MB	284
89b4012b	285	/* get WM8350 revision and config mode */
b7b142d9	286	ret = regmap_read(wm8350->regmap, WM8350_RESET_ID, &id1);
85c93ea7 MB	287	if (ret != 0) {
	288	dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
	289	goto err;
	290	}
	291
b7b142d9	292	ret = regmap_read(wm8350->regmap, WM8350_ID, &id2);
85c93ea7 MB	293	if (ret != 0) {
	294	dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
	295	goto err;
	296	}
	297
b7b142d9	298	ret = regmap_read(wm8350->regmap, WM8350_REVISION, &mask_rev);
85c93ea7 MB	299	if (ret != 0) {
	300	dev_err(wm8350->dev, "Failed to read revision: %d\n", ret);
	301	goto err;
	302	}
89b4012b	303
b797a555 MB	304	if (id1 != 0x6143) {
	305	dev_err(wm8350->dev,
	306	"Device with ID %x is not a WM8350\n", id1);
	307	ret = -ENODEV;
	308	goto err;
	309	}
	310
1753b40f	311	mode = (id2 & WM8350_CONF_STS_MASK) >> 10;
b797a555 MB	312	cust_id = id2 & WM8350_CUST_ID_MASK;
	313	chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12;
	314	dev_info(wm8350->dev,
	315	"CONF_STS %d, CUST_ID %d, MASK_REV %d, CHIP_REV %d\n",
	316	mode, cust_id, mask_rev, chip_rev);
	317
	318	if (cust_id != 0) {
	319	dev_err(wm8350->dev, "Unsupported CUST_ID\n");
	320	ret = -ENODEV;
	321	goto err;
	322	}
	323
	324	switch (mask_rev) {
	325	case 0:
645524a9 MB	326	wm8350->pmic.max_dcdc = WM8350_DCDC_6;
	327	wm8350->pmic.max_isink = WM8350_ISINK_B;
	328
b797a555	329	switch (chip_rev) {
89b4012b	330	case WM8350_REV_E:
b797a555	331	dev_info(wm8350->dev, "WM8350 Rev E\n");
89b4012b MB	332	break;
89b4012b MB	333	case WM8350_REV_F:
b797a555	334	dev_info(wm8350->dev, "WM8350 Rev F\n");
89b4012b MB	335	break;
89b4012b MB	336	case WM8350_REV_G:
b797a555	337	dev_info(wm8350->dev, "WM8350 Rev G\n");
d756f4a4	338	wm8350->power.rev_g_coeff = 1;
89b4012b	339	break;
0c8a6016	340	case WM8350_REV_H:
b797a555	341	dev_info(wm8350->dev, "WM8350 Rev H\n");
d756f4a4	342	wm8350->power.rev_g_coeff = 1;
0c8a6016	343	break;
89b4012b MB	344	default:
89b4012b MB	345	/* For safety we refuse to run on unknown hardware */
b797a555	346	dev_err(wm8350->dev, "Unknown WM8350 CHIP_REV\n");
89b4012b MB	347	ret = -ENODEV;
	348	goto err;
	349	}
b797a555 MB	350	break;
b797a555 MB	351
ca23f8c1 MB	352	case 1:
	353	wm8350->pmic.max_dcdc = WM8350_DCDC_4;
	354	wm8350->pmic.max_isink = WM8350_ISINK_A;
	355
	356	switch (chip_rev) {
	357	case 0:
	358	dev_info(wm8350->dev, "WM8351 Rev A\n");
	359	wm8350->power.rev_g_coeff = 1;
	360	break;
	361
02d46e07 MB	362	case 1:
	363	dev_info(wm8350->dev, "WM8351 Rev B\n");
	364	wm8350->power.rev_g_coeff = 1;
	365	break;
	366
ca23f8c1 MB	367	default:
	368	dev_err(wm8350->dev, "Unknown WM8351 CHIP_REV\n");
	369	ret = -ENODEV;
	370	goto err;
	371	}
	372	break;
	373
96920630	374	case 2:
645524a9 MB	375	wm8350->pmic.max_dcdc = WM8350_DCDC_6;
	376	wm8350->pmic.max_isink = WM8350_ISINK_B;
	377
96920630 MB	378	switch (chip_rev) {
	379	case 0:
	380	dev_info(wm8350->dev, "WM8352 Rev A\n");
	381	wm8350->power.rev_g_coeff = 1;
	382	break;
	383
	384	default:
	385	dev_err(wm8350->dev, "Unknown WM8352 CHIP_REV\n");
	386	ret = -ENODEV;
	387	goto err;
	388	}
	389	break;
	390
b797a555 MB	391	default:
b797a555 MB	392	dev_err(wm8350->dev, "Unknown MASK_REV\n");
89b4012b MB	393	ret = -ENODEV;
	394	goto err;
	395	}
	396
67488526	397	mutex_init(&wm8350->auxadc_mutex);
d19663ac	398	init_completion(&wm8350->auxadc_done);
32064503	399
e0a3389a MB	400	ret = wm8350_irq_init(wm8350, irq, pdata);
e0a3389a MB	401	if (ret < 0)
19d57ed5	402	goto err;
ebccec0f	403
d19663ac MB	404	if (wm8350->irq_base) {
	405	ret = request_threaded_irq(wm8350->irq_base +
	406	WM8350_IRQ_AUXADC_DATARDY,
b3c8c82b FE	407	NULL, wm8350_auxadc_irq,
b3c8c82b FE	408	IRQF_ONESHOT,
d19663ac MB	409	"auxadc", wm8350);
	410	if (ret < 0)
	411	dev_warn(wm8350->dev,
	412	"Failed to request AUXADC IRQ: %d\n", ret);
	413	}
	414
62571c29 MB	415	if (pdata && pdata->init) {
	416	ret = pdata->init(wm8350);
	417	if (ret != 0) {
	418	dev_err(wm8350->dev, "Platform init() failed: %d\n",
	419	ret);
e0a3389a	420	goto err_irq;
62571c29 MB	421	}
	422	}
	423
ebccec0f MB	424	wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0x0);
ebccec0f MB	425
add41cb4 MB	426	wm8350_client_dev_register(wm8350, "wm8350-codec",
	427	&(wm8350->codec.pdev));
	428	wm8350_client_dev_register(wm8350, "wm8350-gpio",
	429	&(wm8350->gpio.pdev));
fb6c023a MB	430	wm8350_client_dev_register(wm8350, "wm8350-hwmon",
fb6c023a MB	431	&(wm8350->hwmon.pdev));
add41cb4 MB	432	wm8350_client_dev_register(wm8350, "wm8350-power",
	433	&(wm8350->power.pdev));
	434	wm8350_client_dev_register(wm8350, "wm8350-rtc", &(wm8350->rtc.pdev));
	435	wm8350_client_dev_register(wm8350, "wm8350-wdt", &(wm8350->wdt.pdev));
	436
89b4012b MB	437	return 0;
89b4012b MB	438
e0a3389a MB	439	err_irq:
e0a3389a MB	440	wm8350_irq_exit(wm8350);
8c46cf30	441	err:
89b4012b MB	442	return ret;
	443	}
	444	EXPORT_SYMBOL_GPL(wm8350_device_init);
	445
	446	void wm8350_device_exit(struct wm8350 *wm8350)
	447	{
da09155a MB	448	int i;
da09155a MB	449
0081e802 MB	450	for (i = 0; i < ARRAY_SIZE(wm8350->pmic.led); i++)
	451	platform_device_unregister(wm8350->pmic.led[i].pdev);
	452
da09155a	453	for (i = 0; i < ARRAY_SIZE(wm8350->pmic.pdev); i++)
add41cb4 MB	454	platform_device_unregister(wm8350->pmic.pdev[i]);
	455
	456	platform_device_unregister(wm8350->wdt.pdev);
	457	platform_device_unregister(wm8350->rtc.pdev);
	458	platform_device_unregister(wm8350->power.pdev);
fb6c023a	459	platform_device_unregister(wm8350->hwmon.pdev);
add41cb4 MB	460	platform_device_unregister(wm8350->gpio.pdev);
add41cb4 MB	461	platform_device_unregister(wm8350->codec.pdev);
da09155a	462
d19663ac MB	463	if (wm8350->irq_base)
	464	free_irq(wm8350->irq_base + WM8350_IRQ_AUXADC_DATARDY, wm8350);
	465
e0a3389a	466	wm8350_irq_exit(wm8350);
89b4012b MB	467	}
	468	EXPORT_SYMBOL_GPL(wm8350_device_exit);
	469
ebccec0f	470	MODULE_DESCRIPTION("WM8350 AudioPlus PMIC core driver");
89b4012b	471	MODULE_LICENSE("GPL");