Commit 6dc3eb5c 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: (66 commits)
  mfd: Fix ucb1x00 build failure for collie_defconfig
  mfd: Fix lpc_sch related depends/selects, fix build error
  gpio: Fix sch_gpio warning
  gpio: add Intel SCH GPIO controller driver
  i2c: convert i2c-isch to platform_device
  mfd: Use completion interrupt for WM831x AUXADC
  mfd: Use completion interrupt for WM835x AUXADC
  mfd: Introduce remove_script function for twl4030
  mfd/mmc: SDHI Kconfig update
  mfd: sh_mobile_sdhi MMC_CAP_MMC_HIGHSPEED support
  gpiolib: Force wm831x GPIOs into GPIO mode when requested
  mfd: Add WM831x revision B support
  gpiolib: Correct debugfs display of WM831x GPIO inversion
  gpiolib: Actually set output state in wm831x_gpio_direction_output()
  tmio_mmc: Balance cell enable()/disable() calls
  tmio_mmc: Remove const from platform data V3
  tmio_mmc: Use 100ms mmc_detect_change() delay
  tmio_mmc: Add MMC_CAP_MMC_HIGHSPEED support V2
  tmio_mmc: Keep card-detect interrupts enabled
  mfd: Add twl6030 base addr for ID0, ID1, ID2
  ...
parents 8fe900b8 2c08583c

drivers/gpio/Kconfig

+31 −0
Original line number Diff line number Diff line
@@ -94,6 +94,23 @@ config GPIO_VR41XX 
	help

	  Say yes here to support the NEC VR4100 series General-purpose I/O Uint



config GPIO_SCH

	tristate "Intel SCH GPIO"

	depends on GPIOLIB && PCI

	select MFD_CORE

	select LPC_SCH

	help

	  Say yes here to support GPIO interface on Intel Poulsbo SCH.

	  The Intel SCH contains a total of 14 GPIO pins. Ten GPIOs are

	  powered by the core power rail and are turned off during sleep

	  modes (S3 and higher). The remaining four GPIOs are powered by

	  the Intel SCH suspend power supply. These GPIOs remain

	  active during S3. The suspend powered GPIOs can be used to wake the

	  system from the Suspend-to-RAM state.



	  This driver can also be built as a module. If so, the module

	  will be called sch-gpio.



comment "I2C GPIO expanders:"



config GPIO_MAX7300
@@ -185,6 +202,20 @@ config GPIO_WM831X 
	  Say yes here to access the GPIO signals of WM831x power management

	  chips from Wolfson Microelectronics.



config GPIO_WM8350

	tristate "WM8350 GPIOs"

	depends on MFD_WM8350

	help

	  Say yes here to access the GPIO signals of WM8350 power management

	  chips from Wolfson Microelectronics.



config GPIO_WM8994

	tristate "WM8994 GPIOs"

	depends on MFD_WM8994

	help

	  Say yes here to access the GPIO signals of WM8994 audio hub

	  CODECs from Wolfson Microelectronics.



config GPIO_ADP5520

	tristate "GPIO Support for ADP5520 PMIC"

	depends on PMIC_ADP5520

drivers/gpio/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -25,3 +25,6 @@ obj-$(CONFIG_GPIO_BT8XX) += bt8xxgpio.o 
obj-$(CONFIG_GPIO_IT8761E)	+= it8761e_gpio.o

obj-$(CONFIG_GPIO_VR41XX)	+= vr41xx_giu.o

obj-$(CONFIG_GPIO_WM831X)	+= wm831x-gpio.o

obj-$(CONFIG_GPIO_WM8350)	+= wm8350-gpiolib.o

obj-$(CONFIG_GPIO_WM8994)	+= wm8994-gpio.o

obj-$(CONFIG_GPIO_SCH)		+= sch_gpio.o
 
 No newline at end of file

drivers/gpio/sch_gpio.c

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

 *  sch_gpio.c - GPIO interface for Intel Poulsbo SCH

 *

 *  Copyright (c) 2010 CompuLab Ltd

 *  Author: Denis Turischev <denis@compulab.co.il>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License 2 as published

 *  by the Free Software Foundation.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; see the file COPYING.  If not, write to

 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 */



#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/io.h>

#include <linux/errno.h>

#include <linux/acpi.h>

#include <linux/platform_device.h>



#include <linux/gpio.h>



static DEFINE_SPINLOCK(gpio_lock);



#define CGEN	(0x00)

#define CGIO	(0x04)

#define CGLV	(0x08)



#define RGEN	(0x20)

#define RGIO	(0x24)

#define RGLV	(0x28)



static unsigned short gpio_ba;



static int sch_gpio_core_direction_in(struct gpio_chip *gc, unsigned  gpio_num)

{

	u8 curr_dirs;

	unsigned short offset, bit;



	spin_lock(&gpio_lock);



	offset = CGIO + gpio_num / 8;

	bit = gpio_num % 8;



	curr_dirs = inb(gpio_ba + offset);



	if (!(curr_dirs & (1 << bit)))

		outb(curr_dirs | (1 << bit), gpio_ba + offset);



	spin_unlock(&gpio_lock);

	return 0;

}



static int sch_gpio_core_get(struct gpio_chip *gc, unsigned gpio_num)

{

	int res;

	unsigned short offset, bit;



	offset = CGLV + gpio_num / 8;

	bit = gpio_num % 8;



	res = !!(inb(gpio_ba + offset) & (1 << bit));

	return res;

}



static void sch_gpio_core_set(struct gpio_chip *gc, unsigned gpio_num, int val)

{

	u8 curr_vals;

	unsigned short offset, bit;



	spin_lock(&gpio_lock);



	offset = CGLV + gpio_num / 8;

	bit = gpio_num % 8;



	curr_vals = inb(gpio_ba + offset);



	if (val)

		outb(curr_vals | (1 << bit), gpio_ba + offset);

	else

		outb((curr_vals & ~(1 << bit)), gpio_ba + offset);

	spin_unlock(&gpio_lock);

}



static int sch_gpio_core_direction_out(struct gpio_chip *gc,

					unsigned gpio_num, int val)

{

	u8 curr_dirs;

	unsigned short offset, bit;



	sch_gpio_core_set(gc, gpio_num, val);



	spin_lock(&gpio_lock);



	offset = CGIO + gpio_num / 8;

	bit = gpio_num % 8;



	curr_dirs = inb(gpio_ba + offset);

	if (curr_dirs & (1 << bit))

		outb(curr_dirs & ~(1 << bit), gpio_ba + offset);



	spin_unlock(&gpio_lock);

	return 0;

}



static struct gpio_chip sch_gpio_core = {

	.label			= "sch_gpio_core",

	.owner			= THIS_MODULE,

	.direction_input	= sch_gpio_core_direction_in,

	.get			= sch_gpio_core_get,

	.direction_output	= sch_gpio_core_direction_out,

	.set			= sch_gpio_core_set,

};



static int sch_gpio_resume_direction_in(struct gpio_chip *gc,

					unsigned gpio_num)

{

	u8 curr_dirs;



	spin_lock(&gpio_lock);



	curr_dirs = inb(gpio_ba + RGIO);



	if (!(curr_dirs & (1 << gpio_num)))

		outb(curr_dirs | (1 << gpio_num) , gpio_ba + RGIO);



	spin_unlock(&gpio_lock);

	return 0;

}



static int sch_gpio_resume_get(struct gpio_chip *gc, unsigned gpio_num)

{

	return !!(inb(gpio_ba + RGLV) & (1 << gpio_num));

}



static void sch_gpio_resume_set(struct gpio_chip *gc,

				unsigned gpio_num, int val)

{

	u8 curr_vals;



	spin_lock(&gpio_lock);



	curr_vals = inb(gpio_ba + RGLV);



	if (val)

		outb(curr_vals | (1 << gpio_num), gpio_ba + RGLV);

	else

		outb((curr_vals & ~(1 << gpio_num)), gpio_ba + RGLV);



	spin_unlock(&gpio_lock);

}



static int sch_gpio_resume_direction_out(struct gpio_chip *gc,

					unsigned gpio_num, int val)

{

	u8 curr_dirs;



	sch_gpio_resume_set(gc, gpio_num, val);



	spin_lock(&gpio_lock);



	curr_dirs = inb(gpio_ba + RGIO);

	if (curr_dirs & (1 << gpio_num))

		outb(curr_dirs & ~(1 << gpio_num), gpio_ba + RGIO);



	spin_unlock(&gpio_lock);

	return 0;

}



static struct gpio_chip sch_gpio_resume = {

	.label			= "sch_gpio_resume",

	.owner			= THIS_MODULE,

	.direction_input	= sch_gpio_resume_direction_in,

	.get			= sch_gpio_resume_get,

	.direction_output	= sch_gpio_resume_direction_out,

	.set			= sch_gpio_resume_set,

};



static int __devinit sch_gpio_probe(struct platform_device *pdev)

{

	struct resource *res;

	int err;



	res = platform_get_resource(pdev, IORESOURCE_IO, 0);

	if (!res)

		return -EBUSY;



	if (!request_region(res->start, resource_size(res), pdev->name))

		return -EBUSY;



	gpio_ba = res->start;



	sch_gpio_core.base = 0;

	sch_gpio_core.ngpio = 10;

	sch_gpio_core.dev = &pdev->dev;



	sch_gpio_resume.base = 10;

	sch_gpio_resume.ngpio = 4;

	sch_gpio_resume.dev = &pdev->dev;



	err = gpiochip_add(&sch_gpio_core);

	if (err < 0)

		goto err_sch_gpio_core;



	err = gpiochip_add(&sch_gpio_resume);

	if (err < 0)

		goto err_sch_gpio_resume;



	/*

	 * GPIO[6:0] enabled by default

	 * GPIO7 is configured by the CMC as SLPIOVR

	 * Enable GPIO[9:8] core powered gpios explicitly

	 */

	outb(0x3, gpio_ba + CGEN + 1);

	/*

	 * SUS_GPIO[2:0] enabled by default

	 * Enable SUS_GPIO3 resume powered gpio explicitly

	 */

	outb(0x8, gpio_ba + RGEN);



	return 0;



err_sch_gpio_resume:

	err = gpiochip_remove(&sch_gpio_core);

	if (err)

		dev_err(&pdev->dev, "%s failed, %d\n",

				"gpiochip_remove()", err);



err_sch_gpio_core:

	release_region(res->start, resource_size(res));

	gpio_ba = 0;



	return err;

}



static int __devexit sch_gpio_remove(struct platform_device *pdev)

{

	struct resource *res;

	if (gpio_ba) {

		int err;



		err  = gpiochip_remove(&sch_gpio_core);

		if (err)

			dev_err(&pdev->dev, "%s failed, %d\n",

				"gpiochip_remove()", err);

		err = gpiochip_remove(&sch_gpio_resume);

		if (err)

			dev_err(&pdev->dev, "%s failed, %d\n",

				"gpiochip_remove()", err);



		res = platform_get_resource(pdev, IORESOURCE_IO, 0);



		release_region(res->start, resource_size(res));

		gpio_ba = 0;



		return err;

	}



	return 0;

}



static struct platform_driver sch_gpio_driver = {

	.driver = {

		.name = "sch_gpio",

		.owner = THIS_MODULE,

	},

	.probe		= sch_gpio_probe,

	.remove		= __devexit_p(sch_gpio_remove),

};



static int __init sch_gpio_init(void)

{

	return platform_driver_register(&sch_gpio_driver);

}



static void __exit sch_gpio_exit(void)

{

	platform_driver_unregister(&sch_gpio_driver);

}



module_init(sch_gpio_init);

module_exit(sch_gpio_exit);



MODULE_AUTHOR("Denis Turischev <denis@compulab.co.il>");

MODULE_DESCRIPTION("GPIO interface for Intel Poulsbo SCH");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:sch_gpio");

drivers/gpio/wm831x-gpio.c

+33 −12
Original line number Diff line number Diff line
@@ -38,10 +38,14 @@ static int wm831x_gpio_direction_in(struct gpio_chip *chip, unsigned offset) 
{

	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);

	struct wm831x *wm831x = wm831x_gpio->wm831x;

	int val = WM831X_GPN_DIR;



	if (wm831x->has_gpio_ena)

		val |= WM831X_GPN_TRI;



	return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,

			       WM831X_GPN_DIR | WM831X_GPN_TRI,

			       WM831X_GPN_DIR);

			       WM831X_GPN_DIR | WM831X_GPN_TRI |

			       WM831X_GPN_FN_MASK, val);

}



static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset)
@@ -60,23 +64,36 @@ static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset) 
		return 0;

}



static int wm831x_gpio_direction_out(struct gpio_chip *chip,

				     unsigned offset, int value)

static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)

{

	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);

	struct wm831x *wm831x = wm831x_gpio->wm831x;



	return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,

			       WM831X_GPN_DIR | WM831X_GPN_TRI, 0);

	wm831x_set_bits(wm831x, WM831X_GPIO_LEVEL, 1 << offset,

			value << offset);

}



static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)

static int wm831x_gpio_direction_out(struct gpio_chip *chip,

				     unsigned offset, int value)

{

	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);

	struct wm831x *wm831x = wm831x_gpio->wm831x;

	int val = 0;

	int ret;



	wm831x_set_bits(wm831x, WM831X_GPIO_LEVEL, 1 << offset,

			value << offset);

	if (wm831x->has_gpio_ena)

		val |= WM831X_GPN_TRI;



	ret = wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,

			      WM831X_GPN_DIR | WM831X_GPN_TRI |

			      WM831X_GPN_FN_MASK, val);

	if (ret < 0)

		return ret;



	/* Can only set GPIO state once it's in output mode */

	wm831x_gpio_set(chip, offset, value);



	return 0;

}



static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
@@ -95,7 +112,7 @@ static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip) 
{

	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);

	struct wm831x *wm831x = wm831x_gpio->wm831x;

	int i;

	int i, tristated;



	for (i = 0; i < chip->ngpio; i++) {

		int gpio = i + chip->base;
@@ -162,15 +179,19 @@ static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip) 
			break;

		}



		tristated = reg & WM831X_GPN_TRI;

		if (wm831x->has_gpio_ena)

			tristated = !tristated;



		seq_printf(s, " %s %s %s %s%s\n"

			   "                                  %s%s (0x%4x)\n",

			   reg & WM831X_GPN_DIR ? "in" : "out",

			   wm831x_gpio_get(chip, i) ? "high" : "low",

			   pull,

			   powerdomain,

			   reg & WM831X_GPN_POL ? " inverted" : "",

			   reg & WM831X_GPN_POL ? "" : " inverted",

			   reg & WM831X_GPN_OD ? "open-drain" : "CMOS",

			   reg & WM831X_GPN_TRI ? " tristated" : "",

			   tristated ? " tristated" : "",

			   reg);

	}

}

drivers/gpio/wm8350-gpiolib.c

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

 * wm835x-gpiolib.c  --  gpiolib support for Wolfson WM835x PMICs

 *

 * 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/gpio.h>

#include <linux/mfd/core.h>

#include <linux/platform_device.h>

#include <linux/seq_file.h>



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

#include <linux/mfd/wm8350/gpio.h>



struct wm8350_gpio_data {

	struct wm8350 *wm8350;

	struct gpio_chip gpio_chip;

};



static inline struct wm8350_gpio_data *to_wm8350_gpio(struct gpio_chip *chip)

{

	return container_of(chip, struct wm8350_gpio_data, gpio_chip);

}



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

{

	struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);

	struct wm8350 *wm8350 = wm8350_gpio->wm8350;



	return wm8350_set_bits(wm8350, WM8350_GPIO_CONFIGURATION_I_O,

			       1 << offset);

}



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

{

	struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);

	struct wm8350 *wm8350 = wm8350_gpio->wm8350;

	int ret;



	ret = wm8350_reg_read(wm8350, WM8350_GPIO_LEVEL);

	if (ret < 0)

		return ret;



	if (ret & (1 << offset))

		return 1;

	else

		return 0;

}



static void wm8350_gpio_set(struct gpio_chip *chip, unsigned offset, int value)

{

	struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);

	struct wm8350 *wm8350 = wm8350_gpio->wm8350;



	if (value)

		wm8350_set_bits(wm8350, WM8350_GPIO_LEVEL, 1 << offset);

	else

		wm8350_clear_bits(wm8350, WM8350_GPIO_LEVEL, 1 << offset);

}



static int wm8350_gpio_direction_out(struct gpio_chip *chip,

				     unsigned offset, int value)

{

	struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);

	struct wm8350 *wm8350 = wm8350_gpio->wm8350;

	int ret;



	ret = wm8350_clear_bits(wm8350, WM8350_GPIO_CONFIGURATION_I_O,

				1 << offset);

	if (ret < 0)

		return ret;



	/* Don't have an atomic direction/value setup */

	wm8350_gpio_set(chip, offset, value);



	return 0;

}



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

{

	struct wm8350_gpio_data *wm8350_gpio = to_wm8350_gpio(chip);

	struct wm8350 *wm8350 = wm8350_gpio->wm8350;



	if (!wm8350->irq_base)

		return -EINVAL;



	return wm8350->irq_base + WM8350_IRQ_GPIO(offset);

}



static struct gpio_chip template_chip = {

	.label			= "wm8350",

	.owner			= THIS_MODULE,

	.direction_input	= wm8350_gpio_direction_in,

	.get			= wm8350_gpio_get,

	.direction_output	= wm8350_gpio_direction_out,

	.set			= wm8350_gpio_set,

	.to_irq			= wm8350_gpio_to_irq,

	.can_sleep		= 1,

};



static int __devinit wm8350_gpio_probe(struct platform_device *pdev)

{

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

	struct wm8350_platform_data *pdata = wm8350->dev->platform_data;

	struct wm8350_gpio_data *wm8350_gpio;

	int ret;



	wm8350_gpio = kzalloc(sizeof(*wm8350_gpio), GFP_KERNEL);

	if (wm8350_gpio == NULL)

		return -ENOMEM;



	wm8350_gpio->wm8350 = wm8350;

	wm8350_gpio->gpio_chip = template_chip;

	wm8350_gpio->gpio_chip.ngpio = 13;

	wm8350_gpio->gpio_chip.dev = &pdev->dev;

	if (pdata && pdata->gpio_base)

		wm8350_gpio->gpio_chip.base = pdata->gpio_base;

	else

		wm8350_gpio->gpio_chip.base = -1;



	ret = gpiochip_add(&wm8350_gpio->gpio_chip);

	if (ret < 0) {

		dev_err(&pdev->dev, "Could not register gpiochip, %d\n",

			ret);

		goto err;

	}



	platform_set_drvdata(pdev, wm8350_gpio);



	return ret;



err:

	kfree(wm8350_gpio);

	return ret;

}



static int __devexit wm8350_gpio_remove(struct platform_device *pdev)

{

	struct wm8350_gpio_data *wm8350_gpio = platform_get_drvdata(pdev);

	int ret;



	ret = gpiochip_remove(&wm8350_gpio->gpio_chip);

	if (ret == 0)

		kfree(wm8350_gpio);



	return ret;

}



static struct platform_driver wm8350_gpio_driver = {

	.driver.name	= "wm8350-gpio",

	.driver.owner	= THIS_MODULE,

	.probe		= wm8350_gpio_probe,

	.remove		= __devexit_p(wm8350_gpio_remove),

};



static int __init wm8350_gpio_init(void)

{

	return platform_driver_register(&wm8350_gpio_driver);

}

subsys_initcall(wm8350_gpio_init);



static void __exit wm8350_gpio_exit(void)

{

	platform_driver_unregister(&wm8350_gpio_driver);

}

module_exit(wm8350_gpio_exit);



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

MODULE_DESCRIPTION("GPIO interface for WM8350 PMICs");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:wm8350-gpio");

CRA Git | Maintained and supported by SUSTech CRA and CCSE