mfd: TPS65090: Add PMIC support
venu byravarasu [Tue, 10 Jan 2012 10:47:04 +0000 (15:47 +0530)]
This PMIC MFD driver provides-
PMIC register read/write access
support for interrupt handling.

bug 909648

Change-Id: I7f1a22e055b08b9cd31e987c94589c2a8c857d73
Signed-off-by: venu byravarasu <vbyravarasu@nvidia.com>
Reviewed-on: http://git-master/r/73135
Reviewed-by: Automatic_Commit_Validation_User
Reviewed-by: Laxman Dewangan <ldewangan@nvidia.com>
Reviewed-on: http://git-master/r/74894
Reviewed-by: Varun Colbert <vcolbert@nvidia.com>
Tested-by: Varun Colbert <vcolbert@nvidia.com>

drivers/mfd/Kconfig
drivers/mfd/Makefile
drivers/mfd/tps65090.c [new file with mode: 0644]
include/linux/mfd/tps65090.h [new file with mode: 0644]

index 55fd515..2cf0a06 100644 (file)
@@ -801,6 +801,25 @@ config MFD_TPS6591X
          additional drivers must be enabled in order to use the
          functionality of the device.
 
+config MFD_TPS65090
+       bool "TPS65090 Power Management chips"
+       depends on I2C && GENERIC_HARDIRQS
+       select MFD_CORE
+       select REGMAP_I2C
+       help
+         If you say yes here you get support for the TPS65090 series of
+         Power Management chips.
+         This driver provides common support for accessing the device,
+         additional drivers must be enabled in order to use the
+         functionality of the device.
+
+config MFD_AAT2870_CORE
+       bool "Support for the AnalogicTech AAT2870"
+       select MFD_CORE
+       depends on I2C=y && GPIOLIB
+       help
+         If you say yes here you get support for the AAT2870.
+
 config MFD_TPS80031
        bool "TI TPS80031 Power Management chips"
        depends on I2C && GPIOLIB && GENERIC_HARDIRQS
index f9f9d40..6abb3f3 100644 (file)
@@ -103,6 +103,7 @@ obj-$(CONFIG_MFD_PM8XXX_IRQ)        += pm8xxx-irq.o
 obj-$(CONFIG_TPS65911_COMPARATOR)      += tps65911-comparator.o
 obj-$(CONFIG_MFD_AAT2870_CORE) += aat2870-core.o
 obj-$(CONFIG_MFD_TPS6591X)     += tps6591x.o
+obj-$(CONFIG_MFD_TPS65090)     += tps65090.o
 obj-$(CONFIG_MFD_TPS80031)     += tps80031.o
 obj-$(CONFIG_GPADC_TPS80031)   += tps8003x-gpadc.o
 obj-$(CONFIG_MFD_MAX8907C)     += max8907c.o
diff --git a/drivers/mfd/tps65090.c b/drivers/mfd/tps65090.c
new file mode 100644 (file)
index 0000000..080f97a
--- /dev/null
@@ -0,0 +1,498 @@
+/*
+ * driver/mfd/tps65090.c
+ *
+ * Core driver for TI TPS65090 PMIC family
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+ *
+ * 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.
+ *
+ * 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; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+
+#include <linux/mfd/core.h>
+#include <linux/mfd/tps65090.h>
+#include <linux/regmap.h>
+
+/* interrupt status registers */
+#define TPS65090_INT_STS       0x0
+#define TPS65090_INT_STS2      0x1
+
+/* interrupt mask registers */
+#define TPS65090_INT_MSK       0x2
+#define TPS65090_INT_MSK2      0x3
+
+
+enum irq_type {
+       EVENT,
+};
+
+struct tps65090_irq_data {
+       u8              mask_reg;
+       u8              mask_pos;
+       enum irq_type   type;
+};
+
+#define TPS65090_IRQ(_reg, _mask_pos, _type)   \
+       {                                       \
+               .mask_reg       = (_reg),       \
+               .mask_pos       = (_mask_pos),  \
+               .type           = (_type),      \
+       }
+
+static const struct tps65090_irq_data tps65090_irqs[] = {
+       [0]             = TPS65090_IRQ(0, 0, EVENT),
+       [1]             = TPS65090_IRQ(0, 1, EVENT),
+       [2]             = TPS65090_IRQ(0, 2, EVENT),
+       [3]             = TPS65090_IRQ(0, 3, EVENT),
+       [4]             = TPS65090_IRQ(0, 4, EVENT),
+       [5]             = TPS65090_IRQ(0, 5, EVENT),
+       [6]             = TPS65090_IRQ(0, 6, EVENT),
+       [7]             = TPS65090_IRQ(0, 7, EVENT),
+       [8]             = TPS65090_IRQ(1, 0, EVENT),
+       [9]             = TPS65090_IRQ(1, 1, EVENT),
+       [10]            = TPS65090_IRQ(1, 2, EVENT),
+       [11]            = TPS65090_IRQ(1, 3, EVENT),
+       [12]            = TPS65090_IRQ(1, 4, EVENT),
+       [13]            = TPS65090_IRQ(1, 5, EVENT),
+       [14]            = TPS65090_IRQ(1, 6, EVENT),
+       [15]            = TPS65090_IRQ(1, 7, EVENT),
+};
+
+struct tps65090 {
+       struct mutex            lock;
+       struct device           *dev;
+       struct i2c_client       *client;
+       struct regmap           *rmap;
+       struct irq_chip         irq_chip;
+       struct mutex            irq_lock;
+       int                     irq_base;
+       u32                     irq_en;
+       u8                      mask_cache[2];
+       u8                      mask_reg[2];
+};
+int tps65090_write(struct device *dev, int reg, uint8_t val)
+{
+       struct tps65090 *tps = dev_get_drvdata(dev);
+       return regmap_write(tps->rmap, reg, val);
+}
+int tps65090_read(struct device *dev, int reg, uint8_t *val)
+{
+       int rval, ret = 0;
+       struct tps65090 *tps = dev_get_drvdata(dev);
+       ret = regmap_read(tps->rmap, reg, &rval);
+       *val = rval;
+       return 0;
+}
+EXPORT_SYMBOL_GPL(tps65090_read);
+
+int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num)
+{
+       struct tps65090 *tps = dev_get_drvdata(dev);
+       return regmap_update_bits_lazy(tps->rmap, reg, BIT(bit_num), ~0u);
+
+}
+EXPORT_SYMBOL_GPL(tps65090_set_bits);
+
+int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num)
+{
+       struct tps65090 *tps = dev_get_drvdata(dev);
+       return regmap_update_bits_lazy(tps->rmap, reg, BIT(bit_num), 0u);
+}
+EXPORT_SYMBOL_GPL(tps65090_clr_bits);
+
+static int __remove_subdev(struct device *dev, void *unused)
+{
+       platform_device_unregister(to_platform_device(dev));
+       return 0;
+}
+
+static int tps65090_remove_subdevs(struct tps65090 *tps65090)
+{
+       return device_for_each_child(tps65090->dev, NULL, __remove_subdev);
+}
+
+static void tps65090_irq_lock(struct irq_data *data)
+{
+       struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);
+
+       mutex_lock(&tps65090->irq_lock);
+}
+
+static void tps65090_irq_mask(struct irq_data *irq_data)
+{
+       struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
+       unsigned int __irq = irq_data->irq - tps65090->irq_base;
+       const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
+
+       if (data->type == EVENT)
+               tps65090->mask_reg[data->mask_reg] |= (1 << data->mask_pos);
+       else
+               tps65090->mask_reg[data->mask_reg] |= (3 << data->mask_pos);
+
+       tps65090->irq_en &= ~(1 << __irq);
+}
+
+static void tps65090_irq_unmask(struct irq_data *irq_data)
+{
+       struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
+
+       unsigned int __irq = irq_data->irq - tps65090->irq_base;
+       const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
+
+       if (data->type == EVENT) {
+               tps65090->mask_reg[data->mask_reg] &= ~(1 << data->mask_pos);
+               tps65090->irq_en |= (1 << __irq);
+       }
+}
+
+static void tps65090_irq_sync_unlock(struct irq_data *data)
+{
+       struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(tps65090->mask_reg); i++) {
+               if (tps65090->mask_reg[i] != tps65090->mask_cache[i]) {
+                       if (!WARN_ON(tps65090_write(tps65090->dev,
+                                               TPS65090_INT_MSK + 2*i,
+                                               tps65090->mask_reg[i])))
+                               tps65090->mask_cache[i] = tps65090->mask_reg[i];
+               }
+       }
+
+       mutex_unlock(&tps65090->irq_lock);
+}
+
+static int tps65090_irq_set_type(struct irq_data *irq_data, unsigned int type)
+{
+       struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
+
+       unsigned int __irq = irq_data->irq - tps65090->irq_base;
+       const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
+
+       if (data->type != EVENT) /* add support for GPIO, if needed */
+               return -EINVAL;
+
+       return 0;
+}
+
+static irqreturn_t tps65090_irq(int irq, void *data)
+{
+       struct tps65090 *tps65090 = data;
+       int ret = 0;
+       u8 tmp[3];
+       u8 int_ack;
+       u32 acks, mask = 0;
+       int i;
+
+       for (i = 0; i < 3; i++) {
+               ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + 2*i,
+                               &tmp[i]);
+               if (ret < 0) {
+                       dev_err(tps65090->dev,
+                               "failed to read interrupt status\n");
+                       return IRQ_NONE;
+               }
+               if (tmp[i]) {
+                       /* Ack only those interrupts which are enabled */
+                       int_ack = tmp[i] & (~(tps65090->mask_cache[i]));
+                       ret = tps65090_write(tps65090->dev,
+                                       TPS65090_INT_STS + 2*i, int_ack);
+                       if (ret < 0) {
+                               dev_err(tps65090->dev,
+                                       "failed to write interrupt status\n");
+                               return IRQ_NONE;
+                       }
+               }
+       }
+
+       acks = (tmp[2] << 16) | (tmp[1] << 8) | tmp[0];
+
+       for (i = 0; i < ARRAY_SIZE(tps65090_irqs); i++) {
+               if (tps65090_irqs[i].type == EVENT)
+                       mask = (1 << (tps65090_irqs[i].mask_pos
+                                       + tps65090_irqs[i].mask_reg*8));
+               else
+                       return -EINVAL;
+               if ((acks & mask) && (tps65090->irq_en & (1 << i)))
+                       handle_nested_irq(tps65090->irq_base + i);
+       }
+       return IRQ_HANDLED;
+}
+
+static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int irq,
+                               int irq_base)
+{
+       int i, ret;
+
+       if (!irq_base) {
+               dev_warn(tps65090->dev, "No interrupt support on IRQ base\n");
+               return -EINVAL;
+       }
+
+       mutex_init(&tps65090->irq_lock);
+
+       tps65090->mask_reg[0] = 0xFF;
+       tps65090->mask_reg[1] = 0xFF;
+       for (i = 0; i < 2; i++) {
+               tps65090->mask_cache[i] = tps65090->mask_reg[i];
+               tps65090_write(tps65090->dev, TPS65090_INT_MSK + i,
+                                tps65090->mask_cache[i]);
+       }
+
+       for (i = 0; i < 2; i++)
+               tps65090_write(tps65090->dev, TPS65090_INT_STS + i, 0xff);
+
+       tps65090->irq_base = irq_base;
+
+       tps65090->irq_chip.name = "tps65090";
+       tps65090->irq_chip.irq_mask = tps65090_irq_mask;
+       tps65090->irq_chip.irq_unmask = tps65090_irq_unmask;
+       tps65090->irq_chip.irq_bus_lock = tps65090_irq_lock;
+       tps65090->irq_chip.irq_bus_sync_unlock = tps65090_irq_sync_unlock;
+       tps65090->irq_chip.irq_set_type = tps65090_irq_set_type;
+
+       for (i = 0; i < ARRAY_SIZE(tps65090_irqs); i++) {
+               int __irq = i + tps65090->irq_base;
+               irq_set_chip_data(__irq, tps65090);
+               irq_set_chip_and_handler(__irq, &tps65090->irq_chip,
+                                        handle_simple_irq);
+               irq_set_nested_thread(__irq, 1);
+#ifdef CONFIG_ARM
+               set_irq_flags(__irq, IRQF_VALID);
+#endif
+       }
+
+       ret = request_threaded_irq(irq, NULL, tps65090_irq, IRQF_ONESHOT,
+                               "tps65090", tps65090);
+       if (!ret) {
+               device_init_wakeup(tps65090->dev, 1);
+               enable_irq_wake(irq);
+       }
+
+       return ret;
+}
+
+static int __devinit tps65090_add_subdevs(struct tps65090 *tps65090,
+                                         struct tps65090_platform_data *pdata)
+{
+       struct tps65090_subdev_info *subdev;
+       struct platform_device *pdev;
+       int i, ret = 0;
+
+       for (i = 0; i < pdata->num_subdevs; i++) {
+               subdev = &pdata->subdevs[i];
+
+               pdev = platform_device_alloc(subdev->name, subdev->id);
+
+               pdev->dev.parent = tps65090->dev;
+               pdev->dev.platform_data = subdev->platform_data;
+
+               ret = platform_device_add(pdev);
+               if (ret)
+                       goto failed;
+       }
+       return 0;
+
+failed:
+       tps65090_remove_subdevs(tps65090);
+       return ret;
+}
+#ifdef CONFIG_DEBUG_FS
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+static void print_regs(const char *header, struct seq_file *s,
+               struct i2c_client *client, int start_offset,
+               int end_offset)
+{
+       int reg_val;
+       int i;
+       int ret;
+       struct tps65090 *tps = s->private;
+       seq_printf(s, "%s\n", header);
+       for (i = start_offset; i <= end_offset; ++i) {
+               ret = regmap_read(tps->rmap, i, &reg_val);
+               if (ret >= 0)
+                       seq_printf(s, "Reg 0x%02x Value 0x%02x\n", i, reg_val);
+       }
+       seq_printf(s, "------------------\n");
+}
+
+static int dbg_tps_show(struct seq_file *s, void *unused)
+{
+       struct tps65090 *tps = s->private;
+       struct i2c_client *client = tps->client;
+
+       seq_printf(s, "TPS65090 Registers\n");
+       seq_printf(s, "------------------\n");
+
+       print_regs("All Regs",    s, client, 0x0, 24);
+       return 0;
+}
+
+static int dbg_tps_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, dbg_tps_show, inode->i_private);
+}
+
+static const struct file_operations debug_fops = {
+       .open           = dbg_tps_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static void __init tps65090_debuginit(struct tps65090 *tps)
+{
+       (void)debugfs_create_file("tps65090", S_IRUGO, NULL,
+                       tps, &debug_fops);
+}
+#else
+static void __init tps65090_debuginit(struct tps65090 *tpsi)
+{
+       return;
+}
+#endif
+
+static const struct regmap_config tps65090_regmap_config = {
+       .reg_bits = 8,
+       .val_bits = 8,
+};
+
+static int __devinit tps65090_i2c_probe(struct i2c_client *client,
+                                       const struct i2c_device_id *id)
+{
+       struct tps65090_platform_data *pdata = client->dev.platform_data;
+       struct tps65090 *tps65090;
+       int ret;
+
+       if (!pdata) {
+               dev_err(&client->dev, "tps65090 requires platform data\n");
+               return -ENOTSUPP;
+       }
+
+       tps65090 = kzalloc(sizeof(struct tps65090), GFP_KERNEL);
+       if (tps65090 == NULL)
+               return -ENOMEM;
+
+       tps65090->client = client;
+       tps65090->dev = &client->dev;
+       i2c_set_clientdata(client, tps65090);
+
+       mutex_init(&tps65090->lock);
+
+       if (client->irq) {
+               ret = tps65090_irq_init(tps65090, client->irq,
+                                       pdata->irq_base);
+               if (ret) {
+                       dev_err(&client->dev, "IRQ init failed: %d\n", ret);
+                       goto err_irq_init;
+               }
+       }
+
+       ret = tps65090_add_subdevs(tps65090, pdata);
+       if (ret) {
+               dev_err(&client->dev, "add devices failed: %d\n", ret);
+               goto err_add_devs;
+       }
+
+       tps65090->rmap = regmap_init_i2c(tps65090->client,
+               &tps65090_regmap_config);
+       if (IS_ERR(tps65090->rmap)) {
+               dev_err(&client->dev, "regmap_init failed: %ld\n",
+                       PTR_ERR(tps65090->rmap));
+               goto err_add_devs;
+       };
+       tps65090_debuginit(tps65090);
+
+       return 0;
+
+err_add_devs:
+       if (client->irq)
+               free_irq(client->irq, tps65090);
+err_irq_init:
+       kfree(tps65090);
+       return ret;
+}
+
+static int __devexit tps65090_i2c_remove(struct i2c_client *client)
+{
+       struct tps65090 *tps65090 = i2c_get_clientdata(client);
+
+       if (client->irq)
+               free_irq(client->irq, tps65090);
+
+       regmap_exit(tps65090->rmap);
+       kfree(tps65090);
+       return 0;
+}
+#ifdef CONFIG_PM
+static int tps65090_i2c_suspend(struct i2c_client *client, pm_message_t state)
+{
+       if (client->irq)
+               disable_irq(client->irq);
+       return 0;
+}
+
+static int tps65090_i2c_resume(struct i2c_client *client)
+{
+       if (client->irq)
+               enable_irq(client->irq);
+       return 0;
+}
+#endif
+
+
+static const struct i2c_device_id tps65090_id_table[] = {
+       { "tps65090", 0 },
+       { },
+};
+MODULE_DEVICE_TABLE(i2c, tps65090_id_table);
+
+static struct i2c_driver tps65090_driver = {
+       .driver = {
+               .name   = "tps65090",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = tps65090_i2c_probe,
+       .remove         = __devexit_p(tps65090_i2c_remove),
+#ifdef CONFIG_PM
+       .suspend        = tps65090_i2c_suspend,
+       .resume         = tps65090_i2c_resume,
+#endif
+       .id_table       = tps65090_id_table,
+};
+
+static int __init tps65090_init(void)
+{
+       return i2c_add_driver(&tps65090_driver);
+}
+subsys_initcall(tps65090_init);
+
+static void __exit tps65090_exit(void)
+{
+       i2c_del_driver(&tps65090_driver);
+}
+module_exit(tps65090_exit);
+
+MODULE_DESCRIPTION("TPS65090 core driver");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/mfd/tps65090.h b/include/linux/mfd/tps65090.h
new file mode 100644 (file)
index 0000000..511ced5
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * include/linux/mfd/tps65090.h
+ * Core driver interface for TI TPS65090 PMIC family
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+ *
+ * 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.
+ *
+ * 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; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_TPS65090_H
+#define __LINUX_MFD_TPS65090_H
+
+#include <linux/rtc.h>
+
+struct tps65090_subdev_info {
+       int             id;
+       const char      *name;
+       void            *platform_data;
+};
+
+struct tps65090_platform_data {
+       int irq_base;
+       int num_subdevs;
+       struct tps65090_subdev_info *subdevs;
+};
+
+/*
+ * NOTE: the functions below are not intended for use outside
+ * of the TPS65090 sub-device drivers
+ */
+extern int tps65090_write(struct device *dev, int reg, uint8_t val);
+extern int tps65090_writes(struct device *dev, int reg, int len, uint8_t *val);
+extern int tps65090_read(struct device *dev, int reg, uint8_t *val);
+extern int tps65090_reads(struct device *dev, int reg, int len, uint8_t *val);
+extern int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num);
+extern int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num);
+extern int tps65090_update(struct device *dev, int reg, uint8_t val,
+                          uint8_t bit_num);
+
+#endif /*__LINUX_MFD_TPS65090_H */