Commit 0620de59 authored by Samuel Ortiz's avatar Samuel Ortiz
Browse files

Merge tag 'mfd/wm5102' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/misc into for-next 

mfd: Initial support for Wolfson Arizona platform and WM5102 devices

The Wolfson Arizona platform is used to provide common register
interface to a series of low power audio hub CODECs, starting with the
WM5102. Since the features of these devices work over a range of
subsystems an MFD core driver is provided to instantiate the subdevices
and arbitrate access between them.

As the new regmap wake IRQ functionality is used as part of the driver
it is incorporated as a dependency.
parents 3a8e39c9 3afbac95

drivers/base/regmap/regmap-irq.c

+51 −0
Original line number Diff line number Diff line
@@ -29,9 +29,13 @@ struct regmap_irq_chip_data { 
	int irq_base;

	struct irq_domain *domain;



	int irq;

	int wake_count;



	unsigned int *status_buf;

	unsigned int *mask_buf;

	unsigned int *mask_buf_def;

	unsigned int *wake_buf;



	unsigned int irq_reg_stride;

};
@@ -71,6 +75,16 @@ static void regmap_irq_sync_unlock(struct irq_data *data) 
				d->chip->mask_base + (i * map->reg_stride));

	}



	/* If we've changed our wakeup count propagate it to the parent */

	if (d->wake_count < 0)

		for (i = d->wake_count; i < 0; i++)

			irq_set_irq_wake(d->irq, 0);

	else if (d->wake_count > 0)

		for (i = 0; i < d->wake_count; i++)

			irq_set_irq_wake(d->irq, 1);



	d->wake_count = 0;



	mutex_unlock(&d->lock);

}
@@ -92,12 +106,35 @@ static void regmap_irq_disable(struct irq_data *data) 
	d->mask_buf[irq_data->reg_offset / map->reg_stride] |= irq_data->mask;

}



static int regmap_irq_set_wake(struct irq_data *data, unsigned int on)

{

	struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data);

	struct regmap *map = d->map;

	const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq);



	if (!d->chip->wake_base)

		return -EINVAL;



	if (on) {

		d->wake_buf[irq_data->reg_offset / map->reg_stride]

			&= ~irq_data->mask;

		d->wake_count++;

	} else {

		d->wake_buf[irq_data->reg_offset / map->reg_stride]

			|= irq_data->mask;

		d->wake_count--;

	}



	return 0;

}



static struct irq_chip regmap_irq_chip = {

	.name			= "regmap",

	.irq_bus_lock		= regmap_irq_lock,

	.irq_bus_sync_unlock	= regmap_irq_sync_unlock,

	.irq_disable		= regmap_irq_disable,

	.irq_enable		= regmap_irq_enable,

	.irq_set_wake		= regmap_irq_set_wake,

};



static irqreturn_t regmap_irq_thread(int irq, void *d)
@@ -240,6 +277,14 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 
	if (!d->mask_buf_def)

		goto err_alloc;



	if (chip->wake_base) {

		d->wake_buf = kzalloc(sizeof(unsigned int) * chip->num_regs,

				      GFP_KERNEL);

		if (!d->wake_buf)

			goto err_alloc;

	}



	d->irq = irq;

	d->map = map;

	d->chip = chip;

	d->irq_base = irq_base;
@@ -294,6 +339,7 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 
err_domain:

	/* Should really dispose of the domain but... */

err_alloc:

	kfree(d->wake_buf);

	kfree(d->mask_buf_def);

	kfree(d->mask_buf);

	kfree(d->status_buf);
@@ -315,6 +361,7 @@ void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d) 


	free_irq(irq, d);

	/* We should unmap the domain but... */

	kfree(d->wake_buf);

	kfree(d->mask_buf_def);

	kfree(d->mask_buf);

	kfree(d->status_buf);
@@ -346,6 +393,10 @@ EXPORT_SYMBOL_GPL(regmap_irq_chip_get_base); 
 */

int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq)

{

	/* Handle holes in the IRQ list */

	if (!data->chip->irqs[irq].mask)

		return -EINVAL;



	return irq_create_mapping(data->domain, irq);

}

EXPORT_SYMBOL_GPL(regmap_irq_get_virq);

drivers/mfd/Kconfig

+29 −0
Original line number Diff line number Diff line
@@ -495,6 +495,35 @@ config MFD_S5M_CORE 
	 additional drivers must be enabled in order to use the functionality

	 of the device



config MFD_ARIZONA

	tristate



config MFD_ARIZONA_I2C

	tristate "Support Wolfson Microelectronics Arizona platform with I2C"

	select MFD_ARIZONA

	select MFD_CORE

	select REGMAP_I2C

	depends on I2C

	help

	  Support for the Wolfson Microelectronics Arizona platform audio SoC

	  core functionality controlled via I2C.



config MFD_ARIZONA_SPI

	tristate "Support Wolfson Microelectronics Arizona platform with SPI"

	select MFD_ARIZONA

	select MFD_CORE

	select REGMAP_SPI

	depends on SPI_MASTER

	help

	  Support for the Wolfson Microelectronics Arizona platform audio SoC

	  core functionality controlled via I2C.



config MFD_WM5102

	bool "Support Wolfson Microelectronics WM5102"

	depends on MFD_ARIZONA

	help

	  Support for Wolfson Microelectronics WM5102 low power audio SoC



config MFD_WM8400

	bool "Support Wolfson Microelectronics WM8400"

	select MFD_CORE

drivers/mfd/Makefile

+7 −0
Original line number Diff line number Diff line
@@ -24,6 +24,13 @@ obj-$(CONFIG_MFD_T7L66XB) += t7l66xb.o tmio_core.o 
obj-$(CONFIG_MFD_TC6387XB)	+= tc6387xb.o tmio_core.o

obj-$(CONFIG_MFD_TC6393XB)	+= tc6393xb.o tmio_core.o



obj-$(CONFIG_MFD_ARIZONA)	+= arizona-core.o

obj-$(CONFIG_MFD_ARIZONA)	+= arizona-irq.o

obj-$(CONFIG_MFD_ARIZONA_I2C)	+= arizona-i2c.o

obj-$(CONFIG_MFD_ARIZONA_SPI)	+= arizona-spi.o

ifneq ($(CONFIG_MFD_WM5102),n)

obj-$(CONFIG_MFD_ARIZONA)	+= wm5102-tables.o

endif

obj-$(CONFIG_MFD_WM8400)	+= wm8400-core.o

wm831x-objs			:= wm831x-core.o wm831x-irq.o wm831x-otp.o

wm831x-objs			+= wm831x-auxadc.o

drivers/mfd/arizona-core.c

0 → 100644
+527 −0
Original line number Diff line number Diff line 
/*

 * Arizona core driver

 *

 * Copyright 2012 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 version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/delay.h>

#include <linux/gpio.h>

#include <linux/interrupt.h>

#include <linux/mfd/core.h>

#include <linux/module.h>

#include <linux/pm_runtime.h>

#include <linux/regmap.h>

#include <linux/regulator/consumer.h>

#include <linux/slab.h>



#include <linux/mfd/arizona/core.h>

#include <linux/mfd/arizona/registers.h>



#include "arizona.h"



static const char *wm5102_core_supplies[] = {

	"AVDD",

	"DBVDD1",

	"DCVDD",

};



int arizona_clk32k_enable(struct arizona *arizona)

{

	int ret = 0;



	mutex_lock(&arizona->clk_lock);



	arizona->clk32k_ref++;



	if (arizona->clk32k_ref == 1)

		ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,

					 ARIZONA_CLK_32K_ENA,

					 ARIZONA_CLK_32K_ENA);



	if (ret != 0)

		arizona->clk32k_ref--;



	mutex_unlock(&arizona->clk_lock);



	return ret;

}

EXPORT_SYMBOL_GPL(arizona_clk32k_enable);



int arizona_clk32k_disable(struct arizona *arizona)

{

	int ret = 0;



	mutex_lock(&arizona->clk_lock);



	BUG_ON(arizona->clk32k_ref <= 0);



	arizona->clk32k_ref--;



	if (arizona->clk32k_ref == 0)

		regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,

				   ARIZONA_CLK_32K_ENA, 0);



	mutex_unlock(&arizona->clk_lock);



	return ret;

}

EXPORT_SYMBOL_GPL(arizona_clk32k_disable);



static irqreturn_t arizona_clkgen_err(int irq, void *data)

{

	struct arizona *arizona = data;



	dev_err(arizona->dev, "CLKGEN error\n");



	return IRQ_HANDLED;

}



static irqreturn_t arizona_underclocked(int irq, void *data)

{

	struct arizona *arizona = data;

	unsigned int val;

	int ret;



	ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_8,

			  &val);

	if (ret != 0) {

		dev_err(arizona->dev, "Failed to read underclock status: %d\n",

			ret);

		return IRQ_NONE;

	}



	if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "AIF3 underclocked\n");

	if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "AIF3 underclocked\n");

	if (val & ARIZONA_AIF2_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "AIF1 underclocked\n");

	if (val & ARIZONA_ISRC2_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "ISRC2 underclocked\n");

	if (val & ARIZONA_ISRC1_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "ISRC1 underclocked\n");

	if (val & ARIZONA_FX_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "FX underclocked\n");

	if (val & ARIZONA_ASRC_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "ASRC underclocked\n");

	if (val & ARIZONA_DAC_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "DAC underclocked\n");

	if (val & ARIZONA_ADC_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "ADC underclocked\n");

	if (val & ARIZONA_MIXER_UNDERCLOCKED_STS)

		dev_err(arizona->dev, "Mixer underclocked\n");



	return IRQ_HANDLED;

}



static irqreturn_t arizona_overclocked(int irq, void *data)

{

	struct arizona *arizona = data;

	unsigned int val[2];

	int ret;

	

	ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6,

			       &val[0], 2);

	if (ret != 0) {

		dev_err(arizona->dev, "Failed to read overclock status: %d\n",

			ret);

		return IRQ_NONE;

	}



	if (val[0] & ARIZONA_PWM_OVERCLOCKED_STS)

		dev_err(arizona->dev, "PWM overclocked\n");

	if (val[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS)

		dev_err(arizona->dev, "FX core overclocked\n");

	if (val[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS)

		dev_err(arizona->dev, "DAC SYS overclocked\n");

	if (val[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS)

		dev_err(arizona->dev, "DAC WARP overclocked\n");

	if (val[0] & ARIZONA_ADC_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ADC overclocked\n");

	if (val[0] & ARIZONA_MIXER_OVERCLOCKED_STS)

		dev_err(arizona->dev, "Mixer overclocked\n");

	if (val[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS)

		dev_err(arizona->dev, "AIF3 overclocked\n");

	if (val[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS)

		dev_err(arizona->dev, "AIF2 overclocked\n");

	if (val[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS)

		dev_err(arizona->dev, "AIF1 overclocked\n");

	if (val[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS)

		dev_err(arizona->dev, "Pad control overclocked\n");



	if (val[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS)

		dev_err(arizona->dev, "Slimbus subsystem overclocked\n");

	if (val[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS)

		dev_err(arizona->dev, "Slimbus async overclocked\n");

	if (val[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS)

		dev_err(arizona->dev, "Slimbus sync overclocked\n");

	if (val[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ASRC async system overclocked\n");

	if (val[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ASRC async WARP overclocked\n");

	if (val[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ASRC sync system overclocked\n");

	if (val[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ASRC sync WARP overclocked\n");

	if (val[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS)

		dev_err(arizona->dev, "DSP1 overclocked\n");

	if (val[1] & ARIZONA_ISRC2_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ISRC2 overclocked\n");

	if (val[1] & ARIZONA_ISRC1_OVERCLOCKED_STS)

		dev_err(arizona->dev, "ISRC1 overclocked\n");



	return IRQ_HANDLED;

}



static int arizona_wait_for_boot(struct arizona *arizona)

{

	unsigned int reg;

	int ret, i;



	/*

	 * We can't use an interrupt as we need to runtime resume to do so,

	 * we won't race with the interrupt handler as it'll be blocked on

	 * runtime resume.

	 */

	for (i = 0; i < 5; i++) {

		msleep(1);



		ret = regmap_read(arizona->regmap,

				  ARIZONA_INTERRUPT_RAW_STATUS_5, &reg);

		if (ret != 0) {

			dev_err(arizona->dev, "Failed to read boot state: %d\n",

				ret);

			return ret;

		}



		if (reg & ARIZONA_BOOT_DONE_STS)

			break;

	}



	if (reg & ARIZONA_BOOT_DONE_STS) {

		regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5,

			     ARIZONA_BOOT_DONE_STS);

	} else {

		dev_err(arizona->dev, "Device boot timed out: %x\n", reg);

		return -ETIMEDOUT;

	}



	pm_runtime_mark_last_busy(arizona->dev);



	return 0;

}



#ifdef CONFIG_PM_RUNTIME

static int arizona_runtime_resume(struct device *dev)

{

	struct arizona *arizona = dev_get_drvdata(dev);

	int ret;



	if (arizona->pdata.ldoena)

		gpio_set_value_cansleep(arizona->pdata.ldoena, 1);



	regcache_cache_only(arizona->regmap, false);



	ret = arizona_wait_for_boot(arizona);

	if (ret != 0)

		return ret;



	regcache_sync(arizona->regmap);



	return 0;

}



static int arizona_runtime_suspend(struct device *dev)

{

	struct arizona *arizona = dev_get_drvdata(dev);



	if (arizona->pdata.ldoena) {

		gpio_set_value_cansleep(arizona->pdata.ldoena, 0);

		regcache_cache_only(arizona->regmap, true);

		regcache_mark_dirty(arizona->regmap);

	}



	return 0;

}

#endif



const struct dev_pm_ops arizona_pm_ops = {

	SET_RUNTIME_PM_OPS(arizona_runtime_suspend,

			   arizona_runtime_resume,

			   NULL)

};

EXPORT_SYMBOL_GPL(arizona_pm_ops);



static struct mfd_cell early_devs[] = {

	{ .name = "arizona-ldo1" },

};



static struct mfd_cell wm5102_devs[] = {

	{ .name = "arizona-extcon" },

	{ .name = "arizona-gpio" },

	{ .name = "arizona-micsupp" },

	{ .name = "arizona-pwm" },

	{ .name = "wm5102-codec" },

};



int __devinit arizona_dev_init(struct arizona *arizona)

{

	struct device *dev = arizona->dev;

	const char *type_name;

	unsigned int reg, val;

	int ret, i;



	dev_set_drvdata(arizona->dev, arizona);

	mutex_init(&arizona->clk_lock);



	if (dev_get_platdata(arizona->dev))

		memcpy(&arizona->pdata, dev_get_platdata(arizona->dev),

		       sizeof(arizona->pdata));



	regcache_cache_only(arizona->regmap, true);



	switch (arizona->type) {

	case WM5102:

		for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++)

			arizona->core_supplies[i].supply

				= wm5102_core_supplies[i];

		arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies);

		break;

	default:

		dev_err(arizona->dev, "Unknown device type %d\n",

			arizona->type);

		return -EINVAL;

	}



	ret = mfd_add_devices(arizona->dev, -1, early_devs,

			      ARRAY_SIZE(early_devs), NULL, 0);

	if (ret != 0) {

		dev_err(dev, "Failed to add early children: %d\n", ret);

		return ret;

	}



	ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies,

				      arizona->core_supplies);

	if (ret != 0) {

		dev_err(dev, "Failed to request core supplies: %d\n",

			ret);

		goto err_early;

	}



	ret = regulator_bulk_enable(arizona->num_core_supplies,

				    arizona->core_supplies);

	if (ret != 0) {

		dev_err(dev, "Failed to enable core supplies: %d\n",

			ret);

		goto err_early;

	}



	if (arizona->pdata.reset) {

		/* Start out with /RESET low to put the chip into reset */

		ret = gpio_request_one(arizona->pdata.reset,

				       GPIOF_DIR_OUT | GPIOF_INIT_LOW,

				       "arizona /RESET");

		if (ret != 0) {

			dev_err(dev, "Failed to request /RESET: %d\n", ret);

			goto err_enable;

		}



		gpio_set_value_cansleep(arizona->pdata.reset, 1);

	}



	if (arizona->pdata.ldoena) {

		ret = gpio_request_one(arizona->pdata.ldoena,

				       GPIOF_DIR_OUT | GPIOF_INIT_HIGH,

				       "arizona LDOENA");

		if (ret != 0) {

			dev_err(dev, "Failed to request LDOENA: %d\n", ret);

			goto err_reset;

		}

	}



	regcache_cache_only(arizona->regmap, false);



	ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);

	if (ret != 0) {

		dev_err(dev, "Failed to read ID register: %d\n", ret);

		goto err_ldoena;

	}



	ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION,

			  &arizona->rev);

	if (ret != 0) {

		dev_err(dev, "Failed to read revision register: %d\n", ret);

		goto err_ldoena;

	}

	arizona->rev &= ARIZONA_DEVICE_REVISION_MASK;



	switch (reg) {

	case 0x5102:

		type_name = "WM5102";

		if (arizona->type != WM5102) {

			dev_err(arizona->dev, "WM5102 registered as %d\n",

				arizona->type);

			arizona->type = WM5102;

		}

		ret = wm5102_patch(arizona);

		break;



	default:

		dev_err(arizona->dev, "Unknown device ID %x\n", reg);

		goto err_ldoena;

	}



	dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A');



	if (ret != 0)

		dev_err(arizona->dev, "Failed to apply patch: %d\n", ret);



	/* If we have a /RESET GPIO we'll already be reset */

	if (!arizona->pdata.reset) {

		ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0);

		if (ret != 0) {

			dev_err(dev, "Failed to reset device: %d\n", ret);

			goto err_ldoena;

		}

	}



	arizona_wait_for_boot(arizona);



	for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) {

		if (!arizona->pdata.gpio_defaults[i])

			continue;



		regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i,

			     arizona->pdata.gpio_defaults[i]);

	}



	pm_runtime_set_autosuspend_delay(arizona->dev, 100);

	pm_runtime_use_autosuspend(arizona->dev);

	pm_runtime_enable(arizona->dev);



	/* Chip default */

	if (!arizona->pdata.clk32k_src)

		arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2;



	switch (arizona->pdata.clk32k_src) {

	case ARIZONA_32KZ_MCLK1:

	case ARIZONA_32KZ_MCLK2:

		regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,

				   ARIZONA_CLK_32K_SRC_MASK,

				   arizona->pdata.clk32k_src - 1);

		break;

	case ARIZONA_32KZ_NONE:

		regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,

				   ARIZONA_CLK_32K_SRC_MASK, 2);

		break;

	default:

		dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n",

			arizona->pdata.clk32k_src);

		ret = -EINVAL;

		goto err_ldoena;

	}



	for (i = 0; i < ARIZONA_MAX_INPUT; i++) {

		/* Default for both is 0 so noop with defaults */

		val = arizona->pdata.dmic_ref[i]

			<< ARIZONA_IN1_DMIC_SUP_SHIFT;

		val |= arizona->pdata.inmode[i] << ARIZONA_IN1_MODE_SHIFT;



		regmap_update_bits(arizona->regmap,

				   ARIZONA_IN1L_CONTROL + (i * 8),

				   ARIZONA_IN1_DMIC_SUP_MASK |

				   ARIZONA_IN1_MODE_MASK, val);

	}



	for (i = 0; i < ARIZONA_MAX_OUTPUT; i++) {

		/* Default is 0 so noop with defaults */

		if (arizona->pdata.out_mono[i])

			val = ARIZONA_OUT1_MONO;

		else

			val = 0;



		regmap_update_bits(arizona->regmap,

				   ARIZONA_OUTPUT_PATH_CONFIG_1L + (i * 8),

				   ARIZONA_OUT1_MONO, val);

	}



	BUILD_BUG_ON(ARIZONA_MAX_PDM_SPK > 1);

	for (i = 0; i < ARIZONA_MAX_PDM_SPK; i++) {

		if (arizona->pdata.spk_mute[i])

			regmap_update_bits(arizona->regmap,

					   ARIZONA_PDM_SPK1_CTRL_1,

					   ARIZONA_SPK1_MUTE_ENDIAN_MASK |

					   ARIZONA_SPK1_MUTE_SEQ1_MASK,

					   arizona->pdata.spk_mute[i]);



		if (arizona->pdata.spk_fmt[i])

			regmap_update_bits(arizona->regmap,

					   ARIZONA_PDM_SPK1_CTRL_2,

					   ARIZONA_SPK1_FMT_MASK,

					   arizona->pdata.spk_fmt[i]);

	}



	/* Set up for interrupts */

	ret = arizona_irq_init(arizona);

	if (ret != 0)

		goto err_ldoena;



	arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error",

			    arizona_clkgen_err, arizona);

	arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked",

			    arizona_overclocked, arizona);

	arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked",

			    arizona_underclocked, arizona);



	switch (arizona->type) {

	case WM5102:

		ret = mfd_add_devices(arizona->dev, -1, wm5102_devs,

				      ARRAY_SIZE(wm5102_devs), NULL, 0);

		break;

	}



	if (ret != 0) {

		dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret);

		goto err_irq;

	}



	return 0;



err_irq:

	arizona_irq_exit(arizona);

err_ldoena:

	if (arizona->pdata.ldoena) {

		gpio_set_value_cansleep(arizona->pdata.ldoena, 0);

		gpio_free(arizona->pdata.ldoena);

	}

err_reset:

	if (arizona->pdata.reset) {

		gpio_set_value_cansleep(arizona->pdata.reset, 1);

		gpio_free(arizona->pdata.reset);

	}

err_enable:

	regulator_bulk_disable(ARRAY_SIZE(arizona->core_supplies),

			       arizona->core_supplies);

err_early:

	mfd_remove_devices(dev);

	return ret;

}

EXPORT_SYMBOL_GPL(arizona_dev_init);



int __devexit arizona_dev_exit(struct arizona *arizona)

{

	mfd_remove_devices(arizona->dev);

	arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona);

	arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona);

	arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona);

	pm_runtime_disable(arizona->dev);

	arizona_irq_exit(arizona);

	return 0;

}

EXPORT_SYMBOL_GPL(arizona_dev_exit);

drivers/mfd/arizona-i2c.c

0 → 100644
+89 −0
Original line number Diff line number Diff line 
/*

 * Arizona-i2c.c  --  Arizona I2C bus interface

 *

 * Copyright 2012 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 version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/err.h>

#include <linux/i2c.h>

#include <linux/module.h>

#include <linux/pm_runtime.h>

#include <linux/regmap.h>

#include <linux/regulator/consumer.h>

#include <linux/slab.h>



#include <linux/mfd/arizona/core.h>



#include "arizona.h"



static __devinit int arizona_i2c_probe(struct i2c_client *i2c,

					  const struct i2c_device_id *id)

{

	struct arizona *arizona;

	const struct regmap_config *regmap_config;

	int ret;



	switch (id->driver_data) {

	case WM5102:

		regmap_config = &wm5102_i2c_regmap;

		break;

	default:

		dev_err(&i2c->dev, "Unknown device type %ld\n",

			id->driver_data);

		return -EINVAL;

	}



	arizona = devm_kzalloc(&i2c->dev, sizeof(*arizona), GFP_KERNEL);

	if (arizona == NULL)

		return -ENOMEM;



	arizona->regmap = devm_regmap_init_i2c(i2c, regmap_config);

	if (IS_ERR(arizona->regmap)) {

		ret = PTR_ERR(arizona->regmap);

		dev_err(&i2c->dev, "Failed to allocate register map: %d\n",

			ret);

		return ret;

	}



	arizona->type = id->driver_data;

	arizona->dev = &i2c->dev;

	arizona->irq = i2c->irq;



	return arizona_dev_init(arizona);

}



static int __devexit arizona_i2c_remove(struct i2c_client *i2c)

{

	struct arizona *arizona = dev_get_drvdata(&i2c->dev);

	arizona_dev_exit(arizona);

	return 0;

}



static const struct i2c_device_id arizona_i2c_id[] = {

	{ "wm5102", WM5102 },

	{ }

};

MODULE_DEVICE_TABLE(i2c, arizona_i2c_id);



static struct i2c_driver arizona_i2c_driver = {

	.driver = {

		.name	= "arizona",

		.owner	= THIS_MODULE,

		.pm	= &arizona_pm_ops,

	},

	.probe		= arizona_i2c_probe,

	.remove		= __devexit_p(arizona_i2c_remove),

	.id_table	= arizona_i2c_id,

};



module_i2c_driver(arizona_i2c_driver);



MODULE_DESCRIPTION("Arizona I2C bus interface");

MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");

MODULE_LICENSE("GPL");

CRA Git | Maintained and supported by SUSTech CRA and CCSE