Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 822e5215 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: (59 commits)
  mfd: ab8500-core chip version cut 2.0 support
  mfd: Flag WM831x /IRQ as a wake source
  mfd: Convert WM831x away from legacy I2C PM operations
  regulator: Support MAX8998/LP3974 DVS-GPIO
  mfd: Support LP3974 RTC
  i2c: Convert SCx200 driver from using raw PCI to platform device
  x86: OLPC: convert olpc-xo1 driver from pci device to platform device
  mfd: MAX8998/LP3974 hibernation support
  mfd/ab8500: remove spi support
  mfd: Remove ARCH_U8500 dependency from AB8500
  misc: Make AB8500_PWM driver depend on U8500 due to PWM breakage
  mfd: Add __devexit annotation for vx855_remove
  mfd: twl6030 irq_data conversion.
  gpio: Fix cs5535 printk warnings
  misc: Fix cs5535 printk warnings
  mfd: Convert Wolfson MFD drivers to use irq_data accessor function
  mfd: Convert TWL4030 to new irq_ APIs
  mfd: Convert tps6586x driver to new irq_ API
  mfd: Convert tc6393xb driver to new irq_ APIs
  mfd: Convert t7166xb driver to new irq_ API
  ...
parents c1e0d97d 92d50a41

arch/x86/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -2068,7 +2068,7 @@ config OLPC 


config OLPC_XO1

	tristate "OLPC XO-1 support"

	depends on OLPC && PCI

	depends on OLPC && MFD_CS5535

	---help---

	  Add support for non-essential features of the OLPC XO-1 laptop.

arch/x86/platform/olpc/olpc-xo1.c

+55 −46
Original line number Diff line number Diff line 
/*

 * Support for features of the OLPC XO-1 laptop

 *

 * Copyright (C) 2010 Andres Salomon <dilinger@queued.net>

 * Copyright (C) 2010 One Laptop per Child

 * Copyright (C) 2006 Red Hat, Inc.

 * Copyright (C) 2006 Advanced Micro Devices, Inc.
@@ -12,8 +13,6 @@ 
 */



#include <linux/module.h>

#include <linux/pci.h>

#include <linux/pci_ids.h>

#include <linux/platform_device.h>

#include <linux/pm.h>
@@ -22,9 +21,6 @@ 


#define DRV_NAME "olpc-xo1"



#define PMS_BAR		4

#define ACPI_BAR	5



/* PMC registers (PMS block) */

#define PM_SCLK		0x10

#define PM_IN_SLPCTL	0x20
@@ -57,65 +53,67 @@ static void xo1_power_off(void) 
	outl(0x00002000, acpi_base + PM1_CNT);

}



/* Read the base addresses from the PCI BAR info */

static int __devinit setup_bases(struct pci_dev *pdev)

static int __devinit olpc_xo1_probe(struct platform_device *pdev)

{

	int r;

	struct resource *res;



	r = pci_enable_device_io(pdev);

	if (r) {

		dev_err(&pdev->dev, "can't enable device IO\n");

		return r;

	}

	/* don't run on non-XOs */

	if (!machine_is_olpc())

		return -ENODEV;



	r = pci_request_region(pdev, ACPI_BAR, DRV_NAME);

	if (r) {

		dev_err(&pdev->dev, "can't alloc PCI BAR #%d\n", ACPI_BAR);

		return r;

	res = platform_get_resource(pdev, IORESOURCE_IO, 0);

	if (!res) {

		dev_err(&pdev->dev, "can't fetch device resource info\n");

		return -EIO;

	}



	r = pci_request_region(pdev, PMS_BAR, DRV_NAME);

	if (r) {

		dev_err(&pdev->dev, "can't alloc PCI BAR #%d\n", PMS_BAR);

		pci_release_region(pdev, ACPI_BAR);

		return r;

	if (!request_region(res->start, resource_size(res), DRV_NAME)) {

		dev_err(&pdev->dev, "can't request region\n");

		return -EIO;

	}



	acpi_base = pci_resource_start(pdev, ACPI_BAR);

	pms_base = pci_resource_start(pdev, PMS_BAR);



	return 0;

}



static int __devinit olpc_xo1_probe(struct platform_device *pdev)

{

	struct pci_dev *pcidev;

	int r;



	pcidev = pci_get_device(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA,

				NULL);

	if (!pdev)

		return -ENODEV;



	r = setup_bases(pcidev);

	if (r)

		return r;

	if (strcmp(pdev->name, "cs5535-pms") == 0)

		pms_base = res->start;

	else if (strcmp(pdev->name, "cs5535-acpi") == 0)

		acpi_base = res->start;



	/* If we have both addresses, we can override the poweroff hook */

	if (pms_base && acpi_base) {

		pm_power_off = xo1_power_off;



		printk(KERN_INFO "OLPC XO-1 support registered\n");

	}



	return 0;

}



static int __devexit olpc_xo1_remove(struct platform_device *pdev)

{

	struct resource *r;



	r = platform_get_resource(pdev, IORESOURCE_IO, 0);

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



	if (strcmp(pdev->name, "cs5535-pms") == 0)

		pms_base = 0;

	else if (strcmp(pdev->name, "cs5535-acpi") == 0)

		acpi_base = 0;



	pm_power_off = NULL;

	return 0;

}



static struct platform_driver olpc_xo1_driver = {

static struct platform_driver cs5535_pms_drv = {

	.driver = {

		.name = "cs5535-pms",

		.owner = THIS_MODULE,

	},

	.probe = olpc_xo1_probe,

	.remove = __devexit_p(olpc_xo1_remove),

};



static struct platform_driver cs5535_acpi_drv = {

	.driver = {

		.name = DRV_NAME,

		.name = "cs5535-acpi",

		.owner = THIS_MODULE,

	},

	.probe = olpc_xo1_probe,
@@ -124,12 +122,23 @@ static struct platform_driver olpc_xo1_driver = { 


static int __init olpc_xo1_init(void)

{

	return platform_driver_register(&olpc_xo1_driver);

	int r;



	r = platform_driver_register(&cs5535_pms_drv);

	if (r)

		return r;



	r = platform_driver_register(&cs5535_acpi_drv);

	if (r)

		platform_driver_unregister(&cs5535_pms_drv);



	return r;

}



static void __exit olpc_xo1_exit(void)

{

	platform_driver_unregister(&olpc_xo1_driver);

	platform_driver_unregister(&cs5535_acpi_drv);

	platform_driver_unregister(&cs5535_pms_drv);

}



MODULE_AUTHOR("Daniel Drake <dsd@laptop.org>");

drivers/gpio/cs5535-gpio.c

+31 −62
Original line number Diff line number Diff line
@@ -11,14 +11,13 @@ 
#include <linux/kernel.h>

#include <linux/spinlock.h>

#include <linux/module.h>

#include <linux/pci.h>

#include <linux/platform_device.h>

#include <linux/gpio.h>

#include <linux/io.h>

#include <linux/cs5535.h>

#include <asm/msr.h>



#define DRV_NAME "cs5535-gpio"

#define GPIO_BAR 1



/*

 * Some GPIO pins
@@ -47,7 +46,7 @@ static struct cs5535_gpio_chip { 
	struct gpio_chip chip;

	resource_size_t base;



	struct pci_dev *pdev;

	struct platform_device *pdev;

	spinlock_t lock;

} cs5535_gpio_chip;
@@ -301,10 +300,10 @@ static struct cs5535_gpio_chip cs5535_gpio_chip = { 
	},

};



static int __init cs5535_gpio_probe(struct pci_dev *pdev,

		const struct pci_device_id *pci_id)

static int __devinit cs5535_gpio_probe(struct platform_device *pdev)

{

	int err;

	struct resource *res;

	int err = -EIO;

	ulong mask_orig = mask;



	/* There are two ways to get the GPIO base address; one is by
@@ -314,25 +313,23 @@ static int __init cs5535_gpio_probe(struct pci_dev *pdev, 
	 * it turns out to be unreliable in the face of crappy BIOSes, we

	 * can always go back to using MSRs.. */



	err = pci_enable_device_io(pdev);

	if (err) {

		dev_err(&pdev->dev, "can't enable device IO\n");

	res = platform_get_resource(pdev, IORESOURCE_IO, 0);

	if (!res) {

		dev_err(&pdev->dev, "can't fetch device resource info\n");

		goto done;

	}



	err = pci_request_region(pdev, GPIO_BAR, DRV_NAME);

	if (err) {

		dev_err(&pdev->dev, "can't alloc PCI BAR #%d\n", GPIO_BAR);

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

		dev_err(&pdev->dev, "can't request region\n");

		goto done;

	}



	/* set up the driver-specific struct */

	cs5535_gpio_chip.base = pci_resource_start(pdev, GPIO_BAR);

	cs5535_gpio_chip.base = res->start;

	cs5535_gpio_chip.pdev = pdev;

	spin_lock_init(&cs5535_gpio_chip.lock);



	dev_info(&pdev->dev, "allocated PCI BAR #%d: base 0x%llx\n", GPIO_BAR,

			(unsigned long long) cs5535_gpio_chip.base);

	dev_info(&pdev->dev, "reserved resource region %pR\n", res);



	/* mask out reserved pins */

	mask &= 0x1F7FFFFF;
@@ -350,78 +347,49 @@ static int __init cs5535_gpio_probe(struct pci_dev *pdev, 
	if (err)

		goto release_region;



	dev_info(&pdev->dev, DRV_NAME ": GPIO support successfully loaded.\n");

	dev_info(&pdev->dev, "GPIO support successfully loaded.\n");

	return 0;



release_region:

	pci_release_region(pdev, GPIO_BAR);

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

done:

	return err;

}



static void __exit cs5535_gpio_remove(struct pci_dev *pdev)

static int __devexit cs5535_gpio_remove(struct platform_device *pdev)

{

	struct resource *r;

	int err;



	err = gpiochip_remove(&cs5535_gpio_chip.chip);

	if (err) {

		/* uhh? */

		dev_err(&pdev->dev, "unable to remove gpio_chip?\n");

	}

	pci_release_region(pdev, GPIO_BAR);

}



static struct pci_device_id cs5535_gpio_pci_tbl[] = {

	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_ISA) },

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },

	{ 0, },

};

MODULE_DEVICE_TABLE(pci, cs5535_gpio_pci_tbl);



/*

 * We can't use the standard PCI driver registration stuff here, since

 * that allows only one driver to bind to each PCI device (and we want

 * multiple drivers to be able to bind to the device).  Instead, manually

 * scan for the PCI device, request a single region, and keep track of the

 * devices that we're using.

 */



static int __init cs5535_gpio_scan_pci(void)

{

	struct pci_dev *pdev;

	int err = -ENODEV;

	int i;



	for (i = 0; i < ARRAY_SIZE(cs5535_gpio_pci_tbl); i++) {

		pdev = pci_get_device(cs5535_gpio_pci_tbl[i].vendor,

				cs5535_gpio_pci_tbl[i].device, NULL);

		if (pdev) {

			err = cs5535_gpio_probe(pdev, &cs5535_gpio_pci_tbl[i]);

			if (err)

				pci_dev_put(pdev);



			/* we only support a single CS5535/6 southbridge */

			break;

		}

	}



		return err;

	}



static void __exit cs5535_gpio_free_pci(void)

{

	cs5535_gpio_remove(cs5535_gpio_chip.pdev);

	pci_dev_put(cs5535_gpio_chip.pdev);

	r = platform_get_resource(pdev, IORESOURCE_IO, 0);

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

	return 0;

}



static struct platform_driver cs5535_gpio_drv = {

	.driver = {

		.name = DRV_NAME,

		.owner = THIS_MODULE,

	},

	.probe = cs5535_gpio_probe,

	.remove = __devexit_p(cs5535_gpio_remove),

};



static int __init cs5535_gpio_init(void)

{

	return cs5535_gpio_scan_pci();

	return platform_driver_register(&cs5535_gpio_drv);

}



static void __exit cs5535_gpio_exit(void)

{

	cs5535_gpio_free_pci();

	platform_driver_unregister(&cs5535_gpio_drv);

}



module_init(cs5535_gpio_init);
@@ -430,3 +398,4 @@ module_exit(cs5535_gpio_exit); 
MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");

MODULE_DESCRIPTION("AMD CS5535/CS5536 GPIO driver");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:" DRV_NAME);

drivers/i2c/busses/scx200_acb.c

+80 −120
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 
#include <linux/init.h>

#include <linux/i2c.h>

#include <linux/pci.h>

#include <linux/platform_device.h>

#include <linux/delay.h>

#include <linux/mutex.h>

#include <linux/slab.h>
@@ -40,6 +41,7 @@ 


MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");

MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");

MODULE_ALIAS("platform:cs5535-smb");

MODULE_LICENSE("GPL");



#define MAX_DEVICES 4
@@ -84,10 +86,6 @@ struct scx200_acb_iface { 
	u8 *ptr;

	char needs_reset;

	unsigned len;



	/* PCI device info */

	struct pci_dev *pdev;

	int bar;

};



/* Register Definitions */
@@ -391,7 +389,7 @@ static const struct i2c_algorithm scx200_acb_algorithm = { 
static struct scx200_acb_iface *scx200_acb_list;

static DEFINE_MUTEX(scx200_acb_list_mutex);



static __init int scx200_acb_probe(struct scx200_acb_iface *iface)

static __devinit int scx200_acb_probe(struct scx200_acb_iface *iface)

{

	u8 val;
@@ -427,7 +425,7 @@ static __init int scx200_acb_probe(struct scx200_acb_iface *iface) 
	return 0;

}



static __init struct scx200_acb_iface *scx200_create_iface(const char *text,

static __devinit struct scx200_acb_iface *scx200_create_iface(const char *text,

		struct device *dev, int index)

{

	struct scx200_acb_iface *iface;
@@ -452,7 +450,7 @@ static __init struct scx200_acb_iface *scx200_create_iface(const char *text, 
	return iface;

}



static int __init scx200_acb_create(struct scx200_acb_iface *iface)

static int __devinit scx200_acb_create(struct scx200_acb_iface *iface)

{

	struct i2c_adapter *adapter;

	int rc;
@@ -472,183 +470,145 @@ static int __init scx200_acb_create(struct scx200_acb_iface *iface) 
		return -ENODEV;

	}



	if (!adapter->dev.parent) {

		/* If there's no dev, we're tracking (ISA) ifaces manually */

		mutex_lock(&scx200_acb_list_mutex);

		iface->next = scx200_acb_list;

		scx200_acb_list = iface;

		mutex_unlock(&scx200_acb_list_mutex);

	}



	return 0;

}



static __init int scx200_create_pci(const char *text, struct pci_dev *pdev,

		int bar)

static struct scx200_acb_iface * __devinit scx200_create_dev(const char *text,

		unsigned long base, int index, struct device *dev)

{

	struct scx200_acb_iface *iface;

	int rc;



	iface = scx200_create_iface(text, &pdev->dev, 0);

	iface = scx200_create_iface(text, dev, index);



	if (iface == NULL)

		return -ENOMEM;



	iface->pdev = pdev;

	iface->bar = bar;



	rc = pci_enable_device_io(iface->pdev);

	if (rc)

		goto errout_free;

		return NULL;



	rc = pci_request_region(iface->pdev, iface->bar, iface->adapter.name);

	if (rc) {

		printk(KERN_ERR NAME ": can't allocate PCI BAR %d\n",

				iface->bar);

	if (!request_region(base, 8, iface->adapter.name)) {

		printk(KERN_ERR NAME ": can't allocate io 0x%lx-0x%lx\n",

		       base, base + 8 - 1);

		goto errout_free;

	}



	iface->base = pci_resource_start(iface->pdev, iface->bar);

	iface->base = base;

	rc = scx200_acb_create(iface);



	if (rc == 0)

		return 0;

		return iface;



	pci_release_region(iface->pdev, iface->bar);

	pci_dev_put(iface->pdev);

	release_region(base, 8);

 errout_free:

	kfree(iface);

	return rc;

	return NULL;

}



static int __init scx200_create_isa(const char *text, unsigned long base,

		int index)

static int __devinit scx200_probe(struct platform_device *pdev)

{

	struct scx200_acb_iface *iface;

	int rc;



	iface = scx200_create_iface(text, NULL, index);

	struct resource *res;



	if (iface == NULL)

		return -ENOMEM;



	if (!request_region(base, 8, iface->adapter.name)) {

		printk(KERN_ERR NAME ": can't allocate io 0x%lx-0x%lx\n",

		       base, base + 8 - 1);

		rc = -EBUSY;

		goto errout_free;

	res = platform_get_resource(pdev, IORESOURCE_IO, 0);

	if (!res) {

		dev_err(&pdev->dev, "can't fetch device resource info\n");

		return -ENODEV;

	}



	iface->base = base;

	rc = scx200_acb_create(iface);

	iface = scx200_create_dev("CS5535", res->start, 0, &pdev->dev);

	if (!iface)

		return -EIO;



	dev_info(&pdev->dev, "SCx200 device '%s' registered\n",

			iface->adapter.name);

	platform_set_drvdata(pdev, iface);



	if (rc == 0)

	return 0;

}



	release_region(base, 8);

 errout_free:

static void __devexit scx200_cleanup_iface(struct scx200_acb_iface *iface)

{

	i2c_del_adapter(&iface->adapter);

	release_region(iface->base, 8);

	kfree(iface);

	return rc;

}



/* Driver data is an index into the scx200_data array that indicates

 * the name and the BAR where the I/O address resource is located.  ISA

 * devices are flagged with a bar value of -1 */



static const struct pci_device_id scx200_pci[] __initconst = {

	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE),

	  .driver_data = 0 },

	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE),

	  .driver_data = 0 },

	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_ISA),

	  .driver_data = 1 },

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA),

	  .driver_data = 2 },

	{ 0, }

};



static struct {

	const char *name;

	int bar;

} scx200_data[] = {

	{ "SCx200", -1 },

	{ "CS5535",  0 },

	{ "CS5536",  0 }

};



static __init int scx200_scan_pci(void)

static int __devexit scx200_remove(struct platform_device *pdev)

{

	int data, dev;

	int rc = -ENODEV;

	struct pci_dev *pdev;

	struct scx200_acb_iface *iface;



	for(dev = 0; dev < ARRAY_SIZE(scx200_pci); dev++) {

		pdev = pci_get_device(scx200_pci[dev].vendor,

				scx200_pci[dev].device, NULL);

	iface = platform_get_drvdata(pdev);

	platform_set_drvdata(pdev, NULL);

	scx200_cleanup_iface(iface);



		if (pdev == NULL)

			continue;

	return 0;

}



		data = scx200_pci[dev].driver_data;

static struct platform_driver scx200_pci_drv = {

	.driver = {

		.name = "cs5535-smb",

		.owner = THIS_MODULE,

	},

	.probe = scx200_probe,

	.remove = __devexit_p(scx200_remove),

};



		/* if .bar is greater or equal to zero, this is a

		 * PCI device - otherwise, we assume

		   that the ports are ISA based

		*/

static const struct pci_device_id scx200_isa[] __initconst = {

	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },

	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },

	{ 0, }

};



		if (scx200_data[data].bar >= 0)

			rc = scx200_create_pci(scx200_data[data].name, pdev,

					scx200_data[data].bar);

		else {

static __init void scx200_scan_isa(void)

{

	int i;



			pci_dev_put(pdev);

	if (!pci_dev_present(scx200_isa))

		return;



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

		if (base[i] == 0)

			continue;



				rc = scx200_create_isa(scx200_data[data].name,

						base[i],

						i);

		/* XXX: should we care about failures? */

		scx200_create_dev("SCx200", base[i], i, NULL);

	}

}



		break;

	}



	return rc;

}



static int __init scx200_acb_init(void)

{

	int rc;



	pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");



	rc = scx200_scan_pci();

	/* First scan for ISA-based devices */

	scx200_scan_isa();	/* XXX: should we care about errors? */



	/* If at least one bus was created, init must succeed */

	if (scx200_acb_list)

		return 0;

	return rc;



	/* No ISA devices; register the platform driver for PCI-based devices */

	return platform_driver_register(&scx200_pci_drv);

}



static void __exit scx200_acb_cleanup(void)

{

	struct scx200_acb_iface *iface;



	platform_driver_unregister(&scx200_pci_drv);



	mutex_lock(&scx200_acb_list_mutex);

	while ((iface = scx200_acb_list) != NULL) {

		scx200_acb_list = iface->next;

		mutex_unlock(&scx200_acb_list_mutex);



		i2c_del_adapter(&iface->adapter);



		if (iface->pdev) {

			pci_release_region(iface->pdev, iface->bar);

			pci_dev_put(iface->pdev);

		}

		else

			release_region(iface->base, 8);

		scx200_cleanup_iface(iface);



		kfree(iface);

		mutex_lock(&scx200_acb_list_mutex);

	}

	mutex_unlock(&scx200_acb_list_mutex);

drivers/mfd/88pm860x-core.c

+15 −21
Original line number Diff line number Diff line
@@ -361,12 +361,6 @@ static struct pm860x_irq_data pm860x_irqs[] = { 
	},

};



static inline struct pm860x_irq_data *irq_to_pm860x(struct pm860x_chip *chip,

						    int irq)

{

	return &pm860x_irqs[irq - chip->irq_base];

}



static irqreturn_t pm860x_irq(int irq, void *data)

{

	struct pm860x_chip *chip = data;
@@ -388,16 +382,16 @@ static irqreturn_t pm860x_irq(int irq, void *data) 
	return IRQ_HANDLED;

}



static void pm860x_irq_lock(unsigned int irq)

static void pm860x_irq_lock(struct irq_data *data)

{

	struct pm860x_chip *chip = get_irq_chip_data(irq);

	struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);



	mutex_lock(&chip->irq_lock);

}



static void pm860x_irq_sync_unlock(unsigned int irq)

static void pm860x_irq_sync_unlock(struct irq_data *data)

{

	struct pm860x_chip *chip = get_irq_chip_data(irq);

	struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);

	struct pm860x_irq_data *irq_data;

	struct i2c_client *i2c;

	static unsigned char cached[3] = {0x0, 0x0, 0x0};
@@ -439,25 +433,25 @@ static void pm860x_irq_sync_unlock(unsigned int irq) 
	mutex_unlock(&chip->irq_lock);

}



static void pm860x_irq_enable(unsigned int irq)

static void pm860x_irq_enable(struct irq_data *data)

{

	struct pm860x_chip *chip = get_irq_chip_data(irq);

	pm860x_irqs[irq - chip->irq_base].enable

		= pm860x_irqs[irq - chip->irq_base].offs;

	struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);

	pm860x_irqs[data->irq - chip->irq_base].enable

		= pm860x_irqs[data->irq - chip->irq_base].offs;

}



static void pm860x_irq_disable(unsigned int irq)

static void pm860x_irq_disable(struct irq_data *data)

{

	struct pm860x_chip *chip = get_irq_chip_data(irq);

	pm860x_irqs[irq - chip->irq_base].enable = 0;

	struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);

	pm860x_irqs[data->irq - chip->irq_base].enable = 0;

}



static struct irq_chip pm860x_irq_chip = {

	.name		= "88pm860x",

	.bus_lock	= pm860x_irq_lock,

	.bus_sync_unlock = pm860x_irq_sync_unlock,

	.enable		= pm860x_irq_enable,

	.disable	= pm860x_irq_disable,

	.irq_bus_lock	= pm860x_irq_lock,

	.irq_bus_sync_unlock = pm860x_irq_sync_unlock,

	.irq_enable	= pm860x_irq_enable,

	.irq_disable	= pm860x_irq_disable,

};



static int __devinit device_gpadc_init(struct pm860x_chip *chip,