Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6 (822e5215) · Commits · 戴 / test

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,

Admin message