Commit e83ddb33 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6 

* 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6: (40 commits)
  mfd: Fix incorrect kfree(i2c) in wm8994-core i2c_driver probe
  mfd: Fix incorrect kfree(i2c) in wm831x-core i2c_driver probe
  mfd: Fix incorrect kfree(i2c) in tps6507x i2c_driver probe
  mfd: Add TPS6586x driver
  mfd: Use macros instead of some constant magic numbers for menelaus
  mfd: Fix menelaus mmc slot 2 misconfiguration
  mfd: Missing slab.h includes
  mfd: Fix wrong wm8350-core kfree in error path
  mfd: Fix wm8994_device_init() return value
  mfd: Avoid calling platform_device_put() twice in ucb1400 probe error path
  mfd: Annotate tc6387xb probe/remove routines with __devinit/__devexit
  mfd: Fix tc6387xb resource reclaim
  mfd: Fix wrong goto labels for tc6393xb error handling
  mfd: Get rid of now unused mc13783 private header
  hwmon: Don't access struct mc13783 directly from mc13783-adc
  mfd: New mc13783 function exposing flags
  mfd: Check jz4740-adc kmalloc() result
  mfd: Fix jz4740-adc resource reclaim in probe error path
  mfd: Add WM8321 support
  mfd: Add stmpe auto sleep feature
  ...
parents 14a4fa20 d0a11693

drivers/gpio/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -206,6 +206,13 @@ config GPIO_SX150X 
	  8 bits:  sx1508q

	  16 bits: sx1509q



config GPIO_STMPE

	bool "STMPE GPIOs"

	depends on MFD_STMPE

	help

	  This enables support for the GPIOs found on the STMPE I/O

	  Expanders.



config GPIO_TC35892

	bool "TC35892 GPIOs"

	depends on MFD_TC35892

drivers/gpio/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ obj-$(CONFIG_GPIO_MCP23S08) += mcp23s08.o 
obj-$(CONFIG_GPIO_PCA953X)	+= pca953x.o

obj-$(CONFIG_GPIO_PCF857X)	+= pcf857x.o

obj-$(CONFIG_GPIO_PL061)	+= pl061.o

obj-$(CONFIG_GPIO_STMPE)	+= stmpe-gpio.o

obj-$(CONFIG_GPIO_TC35892)	+= tc35892-gpio.o

obj-$(CONFIG_GPIO_TIMBERDALE)	+= timbgpio.o

obj-$(CONFIG_GPIO_TWL4030)	+= twl4030-gpio.o

drivers/gpio/stmpe-gpio.c

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

 * Copyright (C) ST-Ericsson SA 2010

 *

 * License Terms: GNU General Public License, version 2

 * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson

 */



#include <linux/module.h>

#include <linux/init.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/gpio.h>

#include <linux/irq.h>

#include <linux/interrupt.h>

#include <linux/mfd/stmpe.h>



/*

 * These registers are modified under the irq bus lock and cached to avoid

 * unnecessary writes in bus_sync_unlock.

 */

enum { REG_RE, REG_FE, REG_IE };



#define CACHE_NR_REGS	3

#define CACHE_NR_BANKS	(STMPE_NR_GPIOS / 8)



struct stmpe_gpio {

	struct gpio_chip chip;

	struct stmpe *stmpe;

	struct device *dev;

	struct mutex irq_lock;



	int irq_base;



	/* Caches of interrupt control registers for bus_lock */

	u8 regs[CACHE_NR_REGS][CACHE_NR_BANKS];

	u8 oldregs[CACHE_NR_REGS][CACHE_NR_BANKS];

};



static inline struct stmpe_gpio *to_stmpe_gpio(struct gpio_chip *chip)

{

	return container_of(chip, struct stmpe_gpio, chip);

}



static int stmpe_gpio_get(struct gpio_chip *chip, unsigned offset)

{

	struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	u8 reg = stmpe->regs[STMPE_IDX_GPMR_LSB] - (offset / 8);

	u8 mask = 1 << (offset % 8);

	int ret;



	ret = stmpe_reg_read(stmpe, reg);

	if (ret < 0)

		return ret;



	return ret & mask;

}



static void stmpe_gpio_set(struct gpio_chip *chip, unsigned offset, int val)

{

	struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	int which = val ? STMPE_IDX_GPSR_LSB : STMPE_IDX_GPCR_LSB;

	u8 reg = stmpe->regs[which] - (offset / 8);

	u8 mask = 1 << (offset % 8);



	stmpe_reg_write(stmpe, reg, mask);

}



static int stmpe_gpio_direction_output(struct gpio_chip *chip,

					 unsigned offset, int val)

{

	struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB] - (offset / 8);

	u8 mask = 1 << (offset % 8);



	stmpe_gpio_set(chip, offset, val);



	return stmpe_set_bits(stmpe, reg, mask, mask);

}



static int stmpe_gpio_direction_input(struct gpio_chip *chip,

					unsigned offset)

{

	struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	u8 reg = stmpe->regs[STMPE_IDX_GPDR_LSB] - (offset / 8);

	u8 mask = 1 << (offset % 8);



	return stmpe_set_bits(stmpe, reg, mask, 0);

}



static int stmpe_gpio_to_irq(struct gpio_chip *chip, unsigned offset)

{

	struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);



	return stmpe_gpio->irq_base + offset;

}



static int stmpe_gpio_request(struct gpio_chip *chip, unsigned offset)

{

	struct stmpe_gpio *stmpe_gpio = to_stmpe_gpio(chip);

	struct stmpe *stmpe = stmpe_gpio->stmpe;



	return stmpe_set_altfunc(stmpe, 1 << offset, STMPE_BLOCK_GPIO);

}



static struct gpio_chip template_chip = {

	.label			= "stmpe",

	.owner			= THIS_MODULE,

	.direction_input	= stmpe_gpio_direction_input,

	.get			= stmpe_gpio_get,

	.direction_output	= stmpe_gpio_direction_output,

	.set			= stmpe_gpio_set,

	.to_irq			= stmpe_gpio_to_irq,

	.request		= stmpe_gpio_request,

	.can_sleep		= 1,

};



static int stmpe_gpio_irq_set_type(unsigned int irq, unsigned int type)

{

	struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);

	int offset = irq - stmpe_gpio->irq_base;

	int regoffset = offset / 8;

	int mask = 1 << (offset % 8);



	if (type == IRQ_TYPE_LEVEL_LOW || type == IRQ_TYPE_LEVEL_HIGH)

		return -EINVAL;



	if (type == IRQ_TYPE_EDGE_RISING)

		stmpe_gpio->regs[REG_RE][regoffset] |= mask;

	else

		stmpe_gpio->regs[REG_RE][regoffset] &= ~mask;



	if (type == IRQ_TYPE_EDGE_FALLING)

		stmpe_gpio->regs[REG_FE][regoffset] |= mask;

	else

		stmpe_gpio->regs[REG_FE][regoffset] &= ~mask;



	return 0;

}



static void stmpe_gpio_irq_lock(unsigned int irq)

{

	struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);



	mutex_lock(&stmpe_gpio->irq_lock);

}



static void stmpe_gpio_irq_sync_unlock(unsigned int irq)

{

	struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);

	static const u8 regmap[] = {

		[REG_RE]	= STMPE_IDX_GPRER_LSB,

		[REG_FE]	= STMPE_IDX_GPFER_LSB,

		[REG_IE]	= STMPE_IDX_IEGPIOR_LSB,

	};

	int i, j;



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

		for (j = 0; j < num_banks; j++) {

			u8 old = stmpe_gpio->oldregs[i][j];

			u8 new = stmpe_gpio->regs[i][j];



			if (new == old)

				continue;



			stmpe_gpio->oldregs[i][j] = new;

			stmpe_reg_write(stmpe, stmpe->regs[regmap[i]] - j, new);

		}

	}



	mutex_unlock(&stmpe_gpio->irq_lock);

}



static void stmpe_gpio_irq_mask(unsigned int irq)

{

	struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);

	int offset = irq - stmpe_gpio->irq_base;

	int regoffset = offset / 8;

	int mask = 1 << (offset % 8);



	stmpe_gpio->regs[REG_IE][regoffset] &= ~mask;

}



static void stmpe_gpio_irq_unmask(unsigned int irq)

{

	struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);

	int offset = irq - stmpe_gpio->irq_base;

	int regoffset = offset / 8;

	int mask = 1 << (offset % 8);



	stmpe_gpio->regs[REG_IE][regoffset] |= mask;

}



static struct irq_chip stmpe_gpio_irq_chip = {

	.name			= "stmpe-gpio",

	.bus_lock		= stmpe_gpio_irq_lock,

	.bus_sync_unlock	= stmpe_gpio_irq_sync_unlock,

	.mask			= stmpe_gpio_irq_mask,

	.unmask			= stmpe_gpio_irq_unmask,

	.set_type		= stmpe_gpio_irq_set_type,

};



static irqreturn_t stmpe_gpio_irq(int irq, void *dev)

{

	struct stmpe_gpio *stmpe_gpio = dev;

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	u8 statmsbreg = stmpe->regs[STMPE_IDX_ISGPIOR_MSB];

	int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);

	u8 status[num_banks];

	int ret;

	int i;



	ret = stmpe_block_read(stmpe, statmsbreg, num_banks, status);

	if (ret < 0)

		return IRQ_NONE;



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

		int bank = num_banks - i - 1;

		unsigned int enabled = stmpe_gpio->regs[REG_IE][bank];

		unsigned int stat = status[i];



		stat &= enabled;

		if (!stat)

			continue;



		while (stat) {

			int bit = __ffs(stat);

			int line = bank * 8 + bit;



			handle_nested_irq(stmpe_gpio->irq_base + line);

			stat &= ~(1 << bit);

		}



		stmpe_reg_write(stmpe, statmsbreg + i, status[i]);

		stmpe_reg_write(stmpe, stmpe->regs[STMPE_IDX_GPEDR_MSB] + i,

				status[i]);

	}



	return IRQ_HANDLED;

}



static int __devinit stmpe_gpio_irq_init(struct stmpe_gpio *stmpe_gpio)

{

	int base = stmpe_gpio->irq_base;

	int irq;



	for (irq = base; irq < base + stmpe_gpio->chip.ngpio; irq++) {

		set_irq_chip_data(irq, stmpe_gpio);

		set_irq_chip_and_handler(irq, &stmpe_gpio_irq_chip,

					 handle_simple_irq);

		set_irq_nested_thread(irq, 1);

#ifdef CONFIG_ARM

		set_irq_flags(irq, IRQF_VALID);

#else

		set_irq_noprobe(irq);

#endif

	}



	return 0;

}



static void stmpe_gpio_irq_remove(struct stmpe_gpio *stmpe_gpio)

{

	int base = stmpe_gpio->irq_base;

	int irq;



	for (irq = base; irq < base + stmpe_gpio->chip.ngpio; irq++) {

#ifdef CONFIG_ARM

		set_irq_flags(irq, 0);

#endif

		set_irq_chip_and_handler(irq, NULL, NULL);

		set_irq_chip_data(irq, NULL);

	}

}



static int __devinit stmpe_gpio_probe(struct platform_device *pdev)

{

	struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);

	struct stmpe_gpio_platform_data *pdata;

	struct stmpe_gpio *stmpe_gpio;

	int ret;

	int irq;



	pdata = stmpe->pdata->gpio;

	if (!pdata)

		return -ENODEV;



	irq = platform_get_irq(pdev, 0);

	if (irq < 0)

		return irq;



	stmpe_gpio = kzalloc(sizeof(struct stmpe_gpio), GFP_KERNEL);

	if (!stmpe_gpio)

		return -ENOMEM;



	mutex_init(&stmpe_gpio->irq_lock);



	stmpe_gpio->dev = &pdev->dev;

	stmpe_gpio->stmpe = stmpe;



	stmpe_gpio->chip = template_chip;

	stmpe_gpio->chip.ngpio = stmpe->num_gpios;

	stmpe_gpio->chip.dev = &pdev->dev;

	stmpe_gpio->chip.base = pdata ? pdata->gpio_base : -1;



	stmpe_gpio->irq_base = stmpe->irq_base + STMPE_INT_GPIO(0);



	ret = stmpe_enable(stmpe, STMPE_BLOCK_GPIO);

	if (ret)

		return ret;



	ret = stmpe_gpio_irq_init(stmpe_gpio);

	if (ret)

		goto out_free;



	ret = request_threaded_irq(irq, NULL, stmpe_gpio_irq, IRQF_ONESHOT,

				   "stmpe-gpio", stmpe_gpio);

	if (ret) {

		dev_err(&pdev->dev, "unable to get irq: %d\n", ret);

		goto out_removeirq;

	}



	ret = gpiochip_add(&stmpe_gpio->chip);

	if (ret) {

		dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret);

		goto out_freeirq;

	}



	if (pdata && pdata->setup)

		pdata->setup(stmpe, stmpe_gpio->chip.base);



	platform_set_drvdata(pdev, stmpe_gpio);



	return 0;



out_freeirq:

	free_irq(irq, stmpe_gpio);

out_removeirq:

	stmpe_gpio_irq_remove(stmpe_gpio);

out_free:

	kfree(stmpe_gpio);

	return ret;

}



static int __devexit stmpe_gpio_remove(struct platform_device *pdev)

{

	struct stmpe_gpio *stmpe_gpio = platform_get_drvdata(pdev);

	struct stmpe *stmpe = stmpe_gpio->stmpe;

	struct stmpe_gpio_platform_data *pdata = stmpe->pdata->gpio;

	int irq = platform_get_irq(pdev, 0);

	int ret;



	if (pdata && pdata->remove)

		pdata->remove(stmpe, stmpe_gpio->chip.base);



	ret = gpiochip_remove(&stmpe_gpio->chip);

	if (ret < 0) {

		dev_err(stmpe_gpio->dev,

			"unable to remove gpiochip: %d\n", ret);

		return ret;

	}



	stmpe_disable(stmpe, STMPE_BLOCK_GPIO);



	free_irq(irq, stmpe_gpio);

	stmpe_gpio_irq_remove(stmpe_gpio);

	platform_set_drvdata(pdev, NULL);

	kfree(stmpe_gpio);



	return 0;

}



static struct platform_driver stmpe_gpio_driver = {

	.driver.name	= "stmpe-gpio",

	.driver.owner	= THIS_MODULE,

	.probe		= stmpe_gpio_probe,

	.remove		= __devexit_p(stmpe_gpio_remove),

};



static int __init stmpe_gpio_init(void)

{

	return platform_driver_register(&stmpe_gpio_driver);

}

subsys_initcall(stmpe_gpio_init);



static void __exit stmpe_gpio_exit(void)

{

	platform_driver_unregister(&stmpe_gpio_driver);

}

module_exit(stmpe_gpio_exit);



MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("STMPExxxx GPIO driver");

MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>");

drivers/gpio/wm831x-gpio.c

+32 −0
Original line number Diff line number Diff line
@@ -108,6 +108,37 @@ static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset) 
	return wm831x->irq_base + WM831X_IRQ_GPIO_1 + offset;

}



static int wm831x_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,

				    unsigned debounce)

{

	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);

	struct wm831x *wm831x = wm831x_gpio->wm831x;

	int reg = WM831X_GPIO1_CONTROL + offset;

	int ret, fn;



	ret = wm831x_reg_read(wm831x, reg);

	if (ret < 0)

		return ret;



	switch (ret & WM831X_GPN_FN_MASK) {

	case 0:

	case 1:

		break;

	default:

		/* Not in GPIO mode */

		return -EBUSY;

	}



	if (debounce >= 32 && debounce <= 64)

		fn = 0;

	else if (debounce >= 4000 && debounce <= 8000)

		fn = 1;

	else

		return -EINVAL;



	return wm831x_set_bits(wm831x, reg, WM831X_GPN_FN_MASK, fn);

}



#ifdef CONFIG_DEBUG_FS

static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)

{
@@ -208,6 +239,7 @@ static struct gpio_chip template_chip = { 
	.direction_output	= wm831x_gpio_direction_out,

	.set			= wm831x_gpio_set,

	.to_irq			= wm831x_gpio_to_irq,

	.set_debounce		= wm831x_gpio_set_debounce,

	.dbg_show		= wm831x_gpio_dbg_show,

	.can_sleep		= 1,

};

drivers/hwmon/mc13783-adc.c

+13 −4
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

 */



#include <linux/mfd/mc13783-private.h>

#include <linux/mfd/mc13783.h>

#include <linux/platform_device.h>

#include <linux/hwmon-sysfs.h>

#include <linux/kernel.h>
@@ -144,6 +144,14 @@ static const struct attribute_group mc13783_group_ts = { 
	.attrs = mc13783_attr_ts,

};



static int mc13783_adc_use_touchscreen(struct platform_device *pdev)

{

	struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);

	unsigned flags = mc13783_get_flags(priv->mc13783);



	return flags & MC13783_USE_TOUCHSCREEN;

}



static int __init mc13783_adc_probe(struct platform_device *pdev)

{

	struct mc13783_adc_priv *priv;
@@ -162,10 +170,11 @@ static int __init mc13783_adc_probe(struct platform_device *pdev) 
	if (ret)

		goto out_err_create1;



	if (!(priv->mc13783->flags & MC13783_USE_TOUCHSCREEN))

	if (!mc13783_adc_use_touchscreen(pdev)) {

		ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_ts);

		if (ret)

			goto out_err_create2;

	}



	priv->hwmon_dev = hwmon_device_register(&pdev->dev);

	if (IS_ERR(priv->hwmon_dev)) {
@@ -180,7 +189,7 @@ static int __init mc13783_adc_probe(struct platform_device *pdev) 


out_err_register:



	if (!(priv->mc13783->flags & MC13783_USE_TOUCHSCREEN))

	if (!mc13783_adc_use_touchscreen(pdev))

		sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);

out_err_create2:
@@ -199,7 +208,7 @@ static int __devexit mc13783_adc_remove(struct platform_device *pdev) 


	hwmon_device_unregister(priv->hwmon_dev);



	if (!(priv->mc13783->flags & MC13783_USE_TOUCHSCREEN))

	if (!mc13783_adc_use_touchscreen(pdev))

		sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);



	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group);

CRA Git | Maintained and supported by SUSTech CRA and CCSE