mfd: tps65090: align driver with mainline
Venu Byravarasu [Fri, 16 Mar 2012 05:40:19 +0000 (10:40 +0530)]
Align the driver with mainline.

This is vbased on commit
3c33be06f9aa0949ad24e67dfcae1f2a3006f4e1
---------------
mfd: Add support for TPS65090

TPS65090 is a Texas Instrument PMIC. It contains 3 Step-Down converters, 2
always on LDO's and  7 current limited load switches.

Signed-off-by: Venu Byravarasu <vbyravarasu@nvidia.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
--------------

Change-Id: I26545520f2cc72100a927cb60b38693153a4afce
Signed-off-by: Laxman Dewangan <ldewangan@nvidia.com>
Reviewed-on: http://git-master/r/119320
Reviewed-by: Automatic_Commit_Validation_User
Reviewed-by: Venu Byravarasu <vbyravarasu@nvidia.com>

drivers/mfd/Kconfig
drivers/mfd/Makefile
drivers/mfd/tps65090.c
include/linux/mfd/tps65090.h

index f37d3ec..7040ae6 100644 (file)
@@ -783,6 +783,18 @@ config MFD_PM8XXX_IRQ
 config TPS65911_COMPARATOR
        tristate
 
+config MFD_TPS65090
+       bool "TPS65090 Power Management chips"
+       depends on I2C=y && 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
@@ -804,18 +816,6 @@ 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_RC5T583
        bool "Ricoh RC5T583 Power Management system device"
        depends on I2C=y && GENERIC_HARDIRQS
index 6634515..efd9f7f 100644 (file)
@@ -101,9 +101,9 @@ obj-$(CONFIG_MFD_OMAP_USB_HOST)     += omap-usb-host.o
 obj-$(CONFIG_MFD_PM8921_CORE)  += pm8921-core.o
 obj-$(CONFIG_MFD_PM8XXX_IRQ)   += pm8xxx-irq.o
 obj-$(CONFIG_TPS65911_COMPARATOR)      += tps65911-comparator.o
+obj-$(CONFIG_MFD_TPS65090)     += tps65090.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
index 080f97a..a66d4df 100644 (file)
@@ -1,24 +1,19 @@
 /*
- * 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
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+
+ * This program is distributed in the hope 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.
- *
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <linux/interrupt.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>
+#include <linux/err.h>
+
+#define NUM_INT_REG 2
+#define TOTAL_NUM_REG 0x18
 
 /* interrupt status registers */
 #define TPS65090_INT_STS       0x0
 #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)   \
+#define TPS65090_IRQ(_reg, _mask_pos)          \
        {                                       \
                .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),
+       [0]             = TPS65090_IRQ(0, 0),
+       [1]             = TPS65090_IRQ(0, 1),
+       [2]             = TPS65090_IRQ(0, 2),
+       [3]             = TPS65090_IRQ(0, 3),
+       [4]             = TPS65090_IRQ(0, 4),
+       [5]             = TPS65090_IRQ(0, 5),
+       [6]             = TPS65090_IRQ(0, 6),
+       [7]             = TPS65090_IRQ(0, 7),
+       [8]             = TPS65090_IRQ(1, 0),
+       [9]             = TPS65090_IRQ(1, 1),
+       [10]            = TPS65090_IRQ(1, 2),
+       [11]            = TPS65090_IRQ(1, 3),
+       [12]            = TPS65090_IRQ(1, 4),
+       [13]            = TPS65090_IRQ(1, 5),
+       [14]            = TPS65090_IRQ(1, 6),
+       [15]            = TPS65090_IRQ(1, 7),
+};
+
+static struct mfd_cell tps65090s[] = {
+       {
+               .name = "tps65910-pmic",
+       },
+       {
+               .name = "tps65910-regulator",
+       },
 };
 
 struct tps65090 {
@@ -86,51 +86,42 @@ struct tps65090 {
        struct irq_chip         irq_chip;
        struct mutex            irq_lock;
        int                     irq_base;
-       u32                     irq_en;
-       u8                      mask_cache[2];
-       u8                      mask_reg[2];
+       unsigned int            id;
 };
+
 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);
 }
+EXPORT_SYMBOL_GPL(tps65090_write);
+
 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;
+       unsigned int temp_val;
+       int ret;
+       ret = regmap_read(tps->rmap, reg, &temp_val);
+       if (!ret)
+               *val = temp_val;
+       return ret;
 }
 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);
-
+       return regmap_update_bits(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);
+       return regmap_update_bits(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);
@@ -141,135 +132,97 @@ static void tps65090_irq_lock(struct irq_data *data)
 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;
+       unsigned int __irq = irq_data->hwirq;
        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);
+       tps65090_set_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
+               data->mask_pos);
 }
 
 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);
-       }
+       tps65090_clr_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
+               data->mask_pos);
 }
 
 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;
+       u8 status, mask;
+       unsigned long int acks = 0;
        int i;
 
-       for (i = 0; i < 3; i++) {
-               ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + 2*i,
-                               &tmp[i]);
+       for (i = 0; i < NUM_INT_REG; i++) {
+               ret = tps65090_read(tps65090->dev, TPS65090_INT_MSK + i, &mask);
                if (ret < 0) {
                        dev_err(tps65090->dev,
-                               "failed to read interrupt status\n");
+                               "failed to read mask reg [addr:%d]\n",
+                               TPS65090_INT_MSK + i);
                        return IRQ_NONE;
                }
-               if (tmp[i]) {
-                       /* Ack only those interrupts which are enabled */
-                       int_ack = tmp[i] & (~(tps65090->mask_cache[i]));
+               ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + i,
+                       &status);
+               if (ret < 0) {
+                       dev_err(tps65090->dev,
+                               "failed to read status reg [addr:%d]\n",
+                                TPS65090_INT_STS + i);
+                       return IRQ_NONE;
+               }
+               if (status) {
+                       /* Ack only those interrupts which are not masked */
+                       status &= (~mask);
                        ret = tps65090_write(tps65090->dev,
-                                       TPS65090_INT_STS + 2*i, int_ack);
+                                       TPS65090_INT_STS + i, status);
                        if (ret < 0) {
                                dev_err(tps65090->dev,
                                        "failed to write interrupt status\n");
                                return IRQ_NONE;
                        }
+                       acks |= (status << (i * 8));
                }
        }
 
-       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;
+       for_each_set_bit(i, &acks, ARRAY_SIZE(tps65090_irqs))
+               handle_nested_irq(tps65090->irq_base + i);
+       return acks ? IRQ_HANDLED : IRQ_NONE;
 }
 
 static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int irq,
-                               int irq_base)
+       int irq_base)
 {
        int i, ret;
 
        if (!irq_base) {
-               dev_warn(tps65090->dev, "No interrupt support on IRQ base\n");
+               dev_err(tps65090->dev, "IRQ base not set\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 < NUM_INT_REG; i++)
+               tps65090_write(tps65090->dev, TPS65090_INT_MSK + i, 0xFF);
 
-       for (i = 0; i < 2; i++)
+       for (i = 0; i < NUM_INT_REG; 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;
@@ -292,90 +245,21 @@ static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int 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)
+static bool is_volatile_reg(struct device *dev, unsigned int reg)
 {
-       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;
+       if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS))
+               return true;
+       else
+               return false;
 }
-#endif
 
 static const struct regmap_config tps65090_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
+       .max_register = TOTAL_NUM_REG,
+       .num_reg_defaults_raw = TOTAL_NUM_REG,
+       .cache_type = REGCACHE_RBTREE,
+       .volatile_reg = is_volatile_reg,
 };
 
 static int __devinit tps65090_i2c_probe(struct i2c_client *client,
@@ -387,10 +271,11 @@ static int __devinit tps65090_i2c_probe(struct i2c_client *client,
 
        if (!pdata) {
                dev_err(&client->dev, "tps65090 requires platform data\n");
-               return -ENOTSUPP;
+               return -EINVAL;
        }
 
-       tps65090 = kzalloc(sizeof(struct tps65090), GFP_KERNEL);
+       tps65090 = devm_kzalloc(&client->dev, sizeof(struct tps65090),
+               GFP_KERNEL);
        if (tps65090 == NULL)
                return -ENOMEM;
 
@@ -401,36 +286,39 @@ static int __devinit tps65090_i2c_probe(struct i2c_client *client,
        mutex_init(&tps65090->lock);
 
        if (client->irq) {
-               ret = tps65090_irq_init(tps65090, client->irq,
-                                       pdata->irq_base);
+               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;
+                       dev_err(&client->dev, "IRQ init failed with err: %d\n",
+                               ret);
+                       goto err_exit;
                }
        }
 
-       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",
+               dev_err(&client->dev, "regmap_init failed with err: %ld\n",
                        PTR_ERR(tps65090->rmap));
-               goto err_add_devs;
+               goto err_irq_exit;
        };
-       tps65090_debuginit(tps65090);
+
+       ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
+               ARRAY_SIZE(tps65090s), NULL, 0);
+       if (ret) {
+               dev_err(&client->dev, "add mfd devices failed with err: %d\n",
+                       ret);
+               goto err_regmap_exit;
+       }
 
        return 0;
 
-err_add_devs:
+err_regmap_exit:
+       regmap_exit(tps65090->rmap);
+
+err_irq_exit:
        if (client->irq)
                free_irq(client->irq, tps65090);
-err_irq_init:
-       kfree(tps65090);
+err_exit:
        return ret;
 }
 
@@ -438,13 +326,14 @@ static int __devexit tps65090_i2c_remove(struct i2c_client *client)
 {
        struct tps65090 *tps65090 = i2c_get_clientdata(client);
 
+       mfd_remove_devices(tps65090->dev);
+       regmap_exit(tps65090->rmap);
        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)
 {
@@ -461,7 +350,6 @@ static int tps65090_i2c_resume(struct i2c_client *client)
 }
 #endif
 
-
 static const struct i2c_device_id tps65090_id_table[] = {
        { "tps65090", 0 },
        { },
@@ -495,4 +383,5 @@ static void __exit tps65090_exit(void)
 module_exit(tps65090_exit);
 
 MODULE_DESCRIPTION("TPS65090 core driver");
-MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
+MODULE_LICENSE("GPL v2");
index 511ced5..38e31c5 100644 (file)
@@ -1,5 +1,4 @@
 /*
- * include/linux/mfd/tps65090.h
  * Core driver interface for TI TPS65090 PMIC family
  *
  * Copyright (C) 2012 NVIDIA Corporation
@@ -23,8 +22,6 @@
 #ifndef __LINUX_MFD_TPS65090_H
 #define __LINUX_MFD_TPS65090_H
 
-#include <linux/rtc.h>
-
 struct tps65090_subdev_info {
        int             id;
        const char      *name;
@@ -42,12 +39,8 @@ struct tps65090_platform_data {
  * 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 */