9586c959bf
seeing a trickle of new features coming in they're getting much smaller than they were. It's also nice to have some features which support other subsystems building infrastructure on top of regmap. Highlights include: - Support for padding between the register and the value when interacting with the device, sometimes needed for fast interfaces. - Support for applying register updates to the device when restoring the register state. This is intended to be used to apply updates supplied by manufacturers for tuning the performance of the device (many of which are to undocumented registers which aren't otherwise covered). - Support for multi-register operations on cached registers. - Support for syncing only part of the register cache. - Stubs and parameter query functions intended to make it easier for other subsystems to build infrastructure on top of the regmap API. plus a few driver updates making use of the new features which it was easier to merge via this tree. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) iQIcBAABAgAGBQJPYJuOAAoJEBus8iNuMP3dauMP/1mYgILz0lpRHjGmUF86vQre AcualwUE4UY/WacyUkke72kxa9jcznwzbFjKKNSvL3rLnNy+QPY8Z9v6zBDL90or D9Ok8nRVRldIIDlDE708b10AP9sDSB25ra9IVVPzOEX/0NKoE+Y7ZkXcn0s3zGgI Y+bLwd1uufFopMpV3m5gXipi1/+PEK+jO7q6vgdUp3C1TcMzOqSyCg+uuHWffHGp iO/1XzdxNGx9BTDO/XDEqxUMRnjsQg/VS9JN3CMz8gXwxXD3zrWB/9+SMIfDb5Iy /iXqc58uJ6PTY87t5q9TEGyRKo0Xj7NEPnW4isXg/3r0UUb8kls3frXKigtLEUb7 wnwQD/GCRvXOTbC6TUkFDiZ3OX1qLmnk8YMQ6xhQlbNGM7jJfzj/fFiwBdre58BC iKPdF9gfL/gyH5yefySau/YeYqJUbVLzdOAfYVDkjApmQJv67CrPPd96xAsEsTFU YojkF9NcapBnk6Vs4adzjxD1YCTThaXnFtUSu/bBNZu1xNFD12TORl5fs0OedUe8 zvPMZEEKrE5CxHhQNB6j2Z0zajNOgsh183mNSr2VJK1vI4o4pY7MBENYYPzFiPB4 BfX8KFftxu8O50OVZnweZ80LKVZ9fAo57oWlgR8lfaEbetjY0WdRYOyDT8w5jrtW nU+mtlQLc5SmugTs+CiD =4Eo9 -----END PGP SIGNATURE----- Merge tag 'regmap-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap Pull regmap updates from Mark Brown: "Things are really quieting down with the regmap API, while we're still seeing a trickle of new features coming in they're getting much smaller than they were. It's also nice to have some features which support other subsystems building infrastructure on top of regmap. Highlights include: - Support for padding between the register and the value when interacting with the device, sometimes needed for fast interfaces. - Support for applying register updates to the device when restoring the register state. This is intended to be used to apply updates supplied by manufacturers for tuning the performance of the device (many of which are to undocumented registers which aren't otherwise covered). - Support for multi-register operations on cached registers. - Support for syncing only part of the register cache. - Stubs and parameter query functions intended to make it easier for other subsystems to build infrastructure on top of the regmap API. plus a few driver updates making use of the new features which it was easier to merge via this tree." * tag 'regmap-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap: (41 commits) regmap: Fix future missing prototype of devres_alloc() and friends regmap: Rejig struct declarations for stubbed API regmap: Fix rbtree block base in sync regcache: Make sure we sync register 0 in an rbtree cache regmap: delete unused module.h from drivers/base/regmap files regmap: Add stub for regcache_sync_region() mfd: Improve performance of later WM1811 revisions regmap: Fix x86_64 breakage regmap: Allow drivers to sync only part of the register cache regmap: Supply ranges to the sync operations regmap: Add tracepoints for cache only and cache bypass regmap: Mark the cache as clean after a successful sync regmap: Remove default cache sync implementation regmap: Skip hardware defaults for LZO caches regmap: Expose the driver name in debugfs mfd: wm8400: Convert to devm_regmap_init_i2c() mfd: wm831x: Convert to devm_regmap_init() mfd: wm8994: Convert to devm_regmap_init() mfd/ASoC: Convert WM8994 driver to use regmap patches mfd: Add __devinit and __devexit annotations in wm8994 ...
755 lines
17 KiB
C
755 lines
17 KiB
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>
|
|
|
|
#include "wm8994.h"
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
/**
|
|
* 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:
|
|
case WM1811:
|
|
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;
|
|
}
|
|
|
|
switch (wm8994->type) {
|
|
case WM1811:
|
|
ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
|
|
if (ret < 0) {
|
|
dev_err(dev, "Failed to read jackdet: %d\n", ret);
|
|
} else if (ret & WM1811_JACKDET_MODE_MASK) {
|
|
dev_dbg(dev, "CODEC still active, ignoring suspend\n");
|
|
return 0;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (wm8994->type) {
|
|
case WM1811:
|
|
ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
|
|
if (ret < 0) {
|
|
dev_err(dev, "Failed to read jackdet: %d\n", ret);
|
|
} else if (ret & WM1811_JACKDET_MODE_MASK) {
|
|
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);
|
|
|
|
/* 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,
|
|
wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
|
|
|
|
regcache_cache_only(wm8994->regmap, true);
|
|
regcache_mark_dirty(wm8994->regmap);
|
|
|
|
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;
|
|
|
|
/* 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;
|
|
}
|
|
|
|
regcache_cache_only(wm8994->regmap, false);
|
|
ret = regcache_sync(wm8994->regmap);
|
|
if (ret != 0) {
|
|
dev_err(dev, "Failed to restore register map: %d\n", ret);
|
|
goto err_enable;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
err_enable:
|
|
regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
|
|
|
|
return ret;
|
|
}
|
|
#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 const __devinitdata struct reg_default wm8994_revc_patch[] = {
|
|
{ 0x102, 0x3 },
|
|
{ 0x56, 0x3 },
|
|
{ 0x817, 0x0 },
|
|
{ 0x102, 0x0 },
|
|
};
|
|
|
|
static const __devinitdata struct reg_default wm8958_reva_patch[] = {
|
|
{ 0x102, 0x3 },
|
|
{ 0xcb, 0x81 },
|
|
{ 0x817, 0x0 },
|
|
{ 0x102, 0x0 },
|
|
};
|
|
|
|
static const __devinitdata struct reg_default wm1811_reva_patch[] = {
|
|
{ 0x102, 0x3 },
|
|
{ 0x56, 0x7 },
|
|
{ 0x5d, 0x7e },
|
|
{ 0x5e, 0x0 },
|
|
{ 0x102, 0x0 },
|
|
};
|
|
|
|
/*
|
|
* Instantiate the generic non-control parts of the device.
|
|
*/
|
|
static __devinit int wm8994_device_init(struct wm8994 *wm8994, int irq)
|
|
{
|
|
struct wm8994_pdata *pdata = wm8994->dev->platform_data;
|
|
struct regmap_config *regmap_config;
|
|
const struct reg_default *regmap_patch = NULL;
|
|
const char *devname;
|
|
int ret, i, patch_regs;
|
|
int pulls = 0;
|
|
|
|
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 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;
|
|
}
|
|
|
|
wm8994->supplies = devm_kzalloc(wm8994->dev,
|
|
sizeof(struct regulator_bulk_data) *
|
|
wm8994->num_supplies, GFP_KERNEL);
|
|
if (!wm8994->supplies) {
|
|
ret = -ENOMEM;
|
|
goto err;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
wm8994->revision = ret;
|
|
|
|
switch (wm8994->type) {
|
|
case WM8994:
|
|
switch (wm8994->revision) {
|
|
case 0:
|
|
case 1:
|
|
dev_warn(wm8994->dev,
|
|
"revision %c not fully supported\n",
|
|
'A' + wm8994->revision);
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
regmap_patch = wm8994_revc_patch;
|
|
patch_regs = ARRAY_SIZE(wm8994_revc_patch);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM8958:
|
|
switch (wm8994->revision) {
|
|
case 0:
|
|
regmap_patch = wm8958_reva_patch;
|
|
patch_regs = ARRAY_SIZE(wm8958_reva_patch);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM1811:
|
|
/* Revision C did not change the relevant layer */
|
|
if (wm8994->revision > 1)
|
|
wm8994->revision++;
|
|
switch (wm8994->revision) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
regmap_patch = wm1811_reva_patch;
|
|
patch_regs = ARRAY_SIZE(wm1811_reva_patch);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
dev_info(wm8994->dev, "%s revision %c\n", devname,
|
|
'A' + wm8994->revision);
|
|
|
|
switch (wm8994->type) {
|
|
case WM1811:
|
|
regmap_config = &wm1811_regmap_config;
|
|
break;
|
|
case WM8994:
|
|
regmap_config = &wm8994_regmap_config;
|
|
break;
|
|
case WM8958:
|
|
regmap_config = &wm8958_regmap_config;
|
|
break;
|
|
default:
|
|
dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
|
|
if (ret != 0) {
|
|
dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
|
|
ret);
|
|
return ret;
|
|
}
|
|
|
|
if (regmap_patch) {
|
|
ret = regmap_register_patch(wm8994->regmap, regmap_patch,
|
|
patch_regs);
|
|
if (ret != 0) {
|
|
dev_err(wm8994->dev, "Failed to register patch: %d\n",
|
|
ret);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
if (pdata->spkmode_pu)
|
|
pulls |= WM8994_SPKMODE_PU;
|
|
}
|
|
|
|
/* Disable unneeded pulls */
|
|
wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
|
|
WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
|
|
WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
|
|
pulls);
|
|
|
|
/* 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:
|
|
mfd_remove_devices(wm8994->dev);
|
|
return ret;
|
|
}
|
|
|
|
static __devexit 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);
|
|
}
|
|
|
|
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 __devinit int wm8994_i2c_probe(struct i2c_client *i2c,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct wm8994 *wm8994;
|
|
int ret;
|
|
|
|
wm8994 = devm_kzalloc(&i2c->dev, 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 = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
|
|
if (IS_ERR(wm8994->regmap)) {
|
|
ret = PTR_ERR(wm8994->regmap);
|
|
dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
|
|
ret);
|
|
return ret;
|
|
}
|
|
|
|
return wm8994_device_init(wm8994, i2c->irq);
|
|
}
|
|
|
|
static __devexit 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 },
|
|
{ "wm1811a", 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 = __devexit_p(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>");
|