Added missing tegra files.HEADmaster

1 files changed, 567 insertions, 0 deletions

diff --git a/drivers/regulator/fan53555-regulator.c b/drivers/regulator/fan53555-regulator.c
new file mode 100644
index 00000000000..13fa79c4ba3
--- /dev/null
+++ b/drivers/regulator/fan53555-regulator.c
@@ -0,0 +1,567 @@
+/*
+ * driver/regultor/fan53555-regulator.c
+ *
+ * Driver for FAN53555UC00X, FAN53555UC01X, FAN53555UC03X,
+ *            FAN53555UC04X, FAN53555UC05X
+ *
+ * Copyright (c) 2011, 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 version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
+ * whether express or implied; 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., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307, USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/fan53555-regulator.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+
+/* Register definitions */
+#define FAN53555_REG_VSEL0              0
+#define FAN53555_REG_VSEL1              1
+#define FAN53555_REG_CONTROL            2
+#define FAN53555_REG_ID1                3
+#define FAN53555_REG_ID2                4
+#define FAN53555_REG_MONITOR            5
+
+#define FAN53555_VSEL_BUCK_EN           BIT(7)
+#define FAN53555_VSEL_MODE              BIT(6)
+#define FAN53555_VSEL_NSEL_SHIFT        0
+#define FAN53555_VSEL_NSEL_MASK         0x3F
+
+#define FAN53555_CONTROL_DISCHARGE      BIT(7)
+#define FAN53555_CONTROL_SLEW_SHIFT     4
+#define FAN53555_CONTROL_SLEW_MASK      0x70
+#define FAN53555_CONTROL_RESET          BIT(2)
+
+#define FAN53555_ID1_VENDOR_SHIFT       4
+#define FAN53555_ID1_VENDOR_MASK        0xF0
+#define FAN53555_ID1_DIE_ID_SHIFT       0
+#define FAN53555_ID1_DIE_ID_MASK        0x0F
+
+#define FAN53555_ID2_REV_SHIFT          0
+#define FAN53555_ID2_REV_MASK           0x0F
+
+#define FAN53555_MONITOR_ILIM           BIT(7)
+#define FAN53555_MONITOR_UVLO           BIT(6)
+#define FAN53555_MONITOR_OVP            BIT(5)
+#define FAN53555_MONITOR_POS            BIT(4)
+#define FAN53555_MONITOR_NEG            BIT(3)
+#define FAN53555_MONITOR_RESET_STAT     BIT(2)
+#define FAN53555_MONITOR_OT             BIT(1)
+#define FAN53555_MONITOR_BUCK_STATUS    BIT(0)
+
+#define FAN53555_VSEL0_ID               0
+#define FAN53555_VSEL1_ID               1
+
+#define FAN53555UC00X_ID                0x80
+#define FAN53555UC01X_ID                0x81
+#define FAN53555UC03X_ID                0x83
+#define FAN53555UC04X_ID                0x84
+#define FAN53555UC05X_ID                0x85
+
+#define FAN53555_N_VOLTAGES             64
+
+/* FAN53555 chip information */
+struct fan53555_chip {
+        const char *name;
+        struct device *dev;
+        struct regulator_desc desc;
+        struct i2c_client *client;
+        struct regulator_dev *rdev;
+        struct mutex io_lock;
+        int chip_id;
+        int vsel_id;
+        u8 shadow[6];
+};
+
+#define FAN53555_VOLTAGE(chip_id, vsel)                         \
+        (((chip_id) == FAN53555UC04X_ID) ?                      \
+         ((vsel) * 12826 + 600000) : ((vsel) * 10000 + 600000))
+
+static int fan53555_read(struct fan53555_chip *fan, u8 reg)
+{
+        u8 data;
+        u8 val;
+        int ret;
+
+        data = reg;
+
+        ret = i2c_master_send(fan->client, &data, 1);
+        if (ret < 0)
+                goto out;
+
+        ret = i2c_master_recv(fan->client, &val, 1);
+        if (ret < 0)
+                goto out;
+
+        ret = val;
+out:
+        return ret;
+}
+
+static inline int fan53555_write(struct fan53555_chip *fan, u8 reg, u8 val)
+{
+        u8 msg[2];
+        int ret;
+
+        msg[0] = reg;
+        msg[1] = val;
+
+        ret = i2c_master_send(fan->client, msg, 2);
+        if (ret < 0)
+                return ret;
+        if (ret != 2)
+                return -EIO;
+        return 0;
+}
+
+static int fan53555_read_reg(struct fan53555_chip *fan, u8 reg)
+{
+        int data;
+
+        mutex_lock(&fan->io_lock);
+        data = fan53555_read(fan, reg);
+        if (data < 0)
+                dev_err(fan->dev, "Read from reg 0x%x failed\n", reg);
+        mutex_unlock(&fan->io_lock);
+
+        return data;
+}
+
+static int fan53555_set_bits(struct fan53555_chip *fan, u8 reg, u8 mask, u8 val)
+{
+        int err;
+        u8 data;
+
+        mutex_lock(&fan->io_lock);
+        data = fan->shadow[reg];
+        data &= ~mask;
+        val &= mask;
+        data |= val;
+        err = fan53555_write(fan, reg, data);
+        if (err)
+                dev_err(fan->dev, "write for reg 0x%x failed\n", reg);
+        else
+                fan->shadow[reg] = data;
+        mutex_unlock(&fan->io_lock);
+
+        return err;
+}
+
+static int __fan53555_dcdc_set_voltage(struct fan53555_chip *fan,
+                                       int vsel_id, int min_uV, int max_uV,
+                                       unsigned *selector)
+{
+        int nsel;
+        int uV;
+        int chip_id;
+        int n_voltages;
+
+        chip_id = fan->chip_id;
+        n_voltages = fan->desc.n_voltages;
+
+        if (max_uV < min_uV) {
+                dev_err(fan->dev, "max_uV(%d) < min_uV(%d)\n", max_uV, min_uV);
+                return -EINVAL;
+        }
+        if (min_uV > FAN53555_VOLTAGE(chip_id, n_voltages - 1)) {
+                dev_err(fan->dev, "min_uV(%d) > %d[uV]\n",
+                        min_uV, FAN53555_VOLTAGE(chip_id, n_voltages - 1));
+                return -EINVAL;
+        }
+        if (max_uV < FAN53555_VOLTAGE(chip_id, 0)) {
+                dev_err(fan->dev, "max_uV(%d) < %d[uV]\n",
+                        max_uV, FAN53555_VOLTAGE(chip_id, 0));
+                return -EINVAL;
+        }
+        if ((vsel_id != FAN53555_VSEL0_ID) && (vsel_id != FAN53555_VSEL1_ID)) {
+                dev_err(fan->dev,
+                        "%d is not valid VSEL register ID\n", vsel_id);
+                return -EINVAL;
+        }
+        for (nsel = 0; nsel < n_voltages; nsel++) {
+                uV = FAN53555_VOLTAGE(chip_id, nsel);
+                if (min_uV <= uV && uV <= max_uV) {
+                        if (selector)
+                                *selector = nsel;
+                        return fan53555_set_bits(fan,
+                                                 FAN53555_REG_VSEL0 + vsel_id,
+                                                 FAN53555_VSEL_NSEL_MASK,
+                                                 nsel <<
+                                                 FAN53555_VSEL_NSEL_SHIFT);
+                }
+        }
+
+        return -EINVAL;
+}
+
+#ifdef CONFIG_DEBUG_FS
+
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+static int dbg_fan_show(struct seq_file *s, void *unused)
+{
+        struct fan53555_chip *fan = s->private;
+        int val;
+
+        seq_printf(s, "FAN53555 Registers\n");
+        seq_printf(s, "------------------\n");
+
+        val = fan53555_read_reg(fan, FAN53555_REG_VSEL0);
+        if (val >= 0)
+                seq_printf(s, "Reg VSEL0   Value 0x%02x\n", val);
+
+        val = fan53555_read_reg(fan, FAN53555_REG_VSEL1);
+        if (val >= 0)
+                seq_printf(s, "Reg VSEL1   Value 0x%02x\n", val);
+
+        val = fan53555_read_reg(fan, FAN53555_REG_CONTROL);
+        if (val >= 0)
+                seq_printf(s, "Reg CONTROL Value 0x%02x\n", val);
+
+        val = fan53555_read_reg(fan, FAN53555_REG_ID1);
+        if (val >= 0)
+                seq_printf(s, "Reg ID1     Value 0x%02x\n", val);
+
+        val = fan53555_read_reg(fan, FAN53555_REG_ID2);
+        if (val >= 0)
+                seq_printf(s, "Reg ID2     Value 0x%02x\n", val);
+
+        val = fan53555_read_reg(fan, FAN53555_REG_MONITOR);
+        if (val >= 0)
+                seq_printf(s, "Reg MONITOR Value 0x%02x\n", val);
+
+        return 0;
+}
+
+static int dbg_fan_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, dbg_fan_show, inode->i_private);
+}
+
+static const struct file_operations debug_fops = {
+        .open = dbg_fan_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static void __init fan53555_debuginit(struct fan53555_chip *fan)
+{
+        (void)debugfs_create_file("fan53555", S_IRUGO, NULL, fan, &debug_fops);
+}
+#else
+static void __init fan53555_debuginit(struct fan53555_chip *fan)
+{
+}
+#endif
+
+static int fan53555_dcdc_init(struct fan53555_chip *fan,
+                              struct i2c_client *client,
+                              struct fan53555_regulator_platform_data *pdata)
+{
+        int err;
+        int val;
+
+        err = fan53555_read_reg(fan, FAN53555_REG_VSEL0);
+        if (err < 0)
+                return err;
+        fan->shadow[FAN53555_REG_VSEL0] = (u8)err;
+
+        err = fan53555_read_reg(fan, FAN53555_REG_VSEL1);
+        if (err < 0)
+                return err;
+        fan->shadow[FAN53555_REG_VSEL1] = (u8)err;
+
+        err = fan53555_read_reg(fan, FAN53555_REG_CONTROL);
+        if (err < 0)
+                return err;
+        fan->shadow[FAN53555_REG_CONTROL] = (u8)err;
+
+        err = __fan53555_dcdc_set_voltage(fan,
+                                          FAN53555_VSEL0_ID,
+                                          pdata->init_vsel0_min_uV,
+                                          pdata->init_vsel0_max_uV,
+                                          NULL);
+        if (err < 0)
+                return err;
+
+        val = pdata->vsel0_buck_en ? FAN53555_VSEL_BUCK_EN : 0;
+        val |= pdata->vsel0_mode ? FAN53555_VSEL_MODE : 0;
+        err = fan53555_set_bits(fan,
+                                FAN53555_REG_VSEL0,
+                                FAN53555_VSEL_BUCK_EN | FAN53555_VSEL_MODE,
+                                val);
+        if (err < 0)
+                return err;
+
+        err = __fan53555_dcdc_set_voltage(fan,
+                                          FAN53555_VSEL1_ID,
+                                          pdata->init_vsel1_min_uV,
+                                          pdata->init_vsel1_max_uV,
+                                          NULL);
+        if (err < 0)
+                return err;
+
+        val = pdata->vsel1_buck_en ? FAN53555_VSEL_BUCK_EN : 0;
+        val |= pdata->vsel1_mode ? FAN53555_VSEL_MODE : 0;
+        err = fan53555_set_bits(fan,
+                                FAN53555_REG_VSEL1,
+                                FAN53555_VSEL_BUCK_EN | FAN53555_VSEL_MODE,
+                                val);
+        if (err < 0)
+                return err;
+
+        val = pdata->slew_rate;
+        val <<= FAN53555_CONTROL_SLEW_SHIFT;
+        val |= pdata->output_discharge ? FAN53555_CONTROL_DISCHARGE : 0;
+        err = fan53555_set_bits(fan,
+                                FAN53555_REG_CONTROL,
+                                FAN53555_CONTROL_DISCHARGE |
+                                FAN53555_CONTROL_SLEW_MASK, val);
+        return err;
+}
+
+static int fan53555_dcdc_list_voltage(struct regulator_dev *dev,
+                                      unsigned selector)
+{
+        struct fan53555_chip *fan = rdev_get_drvdata(dev);
+
+        if ((selector < 0) || (selector >= fan->desc.n_voltages))
+                return -EINVAL;
+
+        return FAN53555_VOLTAGE(fan->chip_id, selector);
+}
+
+static int fan53555_dcdc_set_voltage(struct regulator_dev *dev,
+                                     int min_uV, int max_uV,
+                                     unsigned *selector)
+{
+        struct fan53555_chip *fan = rdev_get_drvdata(dev);
+
+        return __fan53555_dcdc_set_voltage(fan, fan->vsel_id, min_uV, max_uV,
+                                           selector);
+}
+
+static int fan53555_dcdc_get_voltage(struct regulator_dev *dev)
+{
+        struct fan53555_chip *fan = rdev_get_drvdata(dev);
+        u8 data;
+
+        if ((fan->vsel_id != FAN53555_VSEL0_ID) &&
+            (fan->vsel_id != FAN53555_VSEL1_ID)) {
+                dev_err(fan->dev,
+                        "%d is not valid VSEL register ID\n", fan->vsel_id);
+                return -EINVAL;
+        }
+        data = fan->shadow[FAN53555_REG_VSEL0 + fan->vsel_id];
+        data &= FAN53555_VSEL_NSEL_MASK;
+        data >>= FAN53555_VSEL_NSEL_SHIFT;
+
+        return FAN53555_VOLTAGE(fan->chip_id, data);
+}
+
+static int fan53555_dcdc_enable(struct regulator_dev *dev)
+{
+        struct fan53555_chip *fan = rdev_get_drvdata(dev);
+
+        if ((fan->vsel_id != FAN53555_VSEL0_ID) &&
+            (fan->vsel_id != FAN53555_VSEL1_ID)) {
+                dev_err(fan->dev,
+                        "%d is not valid VSEL register ID\n", fan->vsel_id);
+                return -EINVAL;
+        }
+
+        return fan53555_set_bits(fan,
+                                 FAN53555_REG_VSEL0 + fan->vsel_id,
+                                 FAN53555_VSEL_BUCK_EN, FAN53555_VSEL_BUCK_EN);
+}
+
+static int fan53555_dcdc_disable(struct regulator_dev *dev)
+{
+        struct fan53555_chip *fan = rdev_get_drvdata(dev);
+
+        if ((fan->vsel_id != FAN53555_VSEL0_ID) &&
+            (fan->vsel_id != FAN53555_VSEL1_ID)) {
+                dev_err(fan->dev,
+                        "%d is not valid VSEL register ID\n", fan->vsel_id);
+                return -EINVAL;
+        }
+
+        return fan53555_set_bits(fan,
+                                 FAN53555_REG_VSEL0 + fan->vsel_id,
+                                 FAN53555_VSEL_BUCK_EN, 0);
+}
+
+static int fan53555_dcdc_is_enabled(struct regulator_dev *dev)
+{
+        struct fan53555_chip *fan = rdev_get_drvdata(dev);
+        u8 data;
+
+        if ((fan->vsel_id != FAN53555_VSEL0_ID) &&
+            (fan->vsel_id != FAN53555_VSEL1_ID)) {
+                dev_err(fan->dev,
+                        "%d is not valid VSEL register ID\n", fan->vsel_id);
+                return -EINVAL;
+        }
+        data = fan->shadow[FAN53555_REG_VSEL0 + fan->vsel_id];
+
+        return (data & FAN53555_VSEL_BUCK_EN) ? 1 : 0;
+}
+
+static struct regulator_ops fan53555_dcdc_ops = {
+        .list_voltage = fan53555_dcdc_list_voltage,
+        .set_voltage = fan53555_dcdc_set_voltage,
+        .get_voltage = fan53555_dcdc_get_voltage,
+        .enable = fan53555_dcdc_enable,
+        .disable = fan53555_dcdc_disable,
+        .is_enabled = fan53555_dcdc_is_enabled,
+};
+
+static int __devinit fan53555_probe(struct i2c_client *client,
+                                    const struct i2c_device_id *id)
+{
+        struct fan53555_regulator_platform_data *pdata;
+        struct regulator_init_data *init_data;
+        struct regulator_dev *rdev;
+        struct fan53555_chip *fan;
+        int chip_id;
+        int err;
+
+        pdata = client->dev.platform_data;
+        if (!pdata) {
+                dev_err(&client->dev, "Err: Platform data not found\n");
+                return -EIO;
+        }
+        init_data = &pdata->reg_init_data;
+        fan = kzalloc(sizeof(*fan), GFP_KERNEL);
+        if (!fan) {
+                dev_err(&client->dev, "Err: Memory allocation fails\n");
+                return -ENOMEM;
+        }
+        mutex_init(&fan->io_lock);
+        fan->client = client;
+        fan->dev = &client->dev;
+        fan->vsel_id = pdata->vsel_id;
+        fan->name = id->name;
+        fan->desc.name = id->name;
+        fan->desc.id = 0;
+        fan->desc.irq = 0;
+        fan->desc.ops = &fan53555_dcdc_ops;
+        fan->desc.type = REGULATOR_VOLTAGE;
+        fan->desc.owner = THIS_MODULE;
+        fan->desc.n_voltages = FAN53555_N_VOLTAGES;
+        i2c_set_clientdata(client, fan);
+
+        chip_id = fan53555_read_reg(fan, FAN53555_REG_ID1);
+        if (chip_id < 0) {
+                err = chip_id;
+                dev_err(fan->dev, "Error in reading device %d\n", err);
+                goto fail;
+        }
+
+        switch (chip_id) {
+        case FAN53555UC00X_ID:
+        case FAN53555UC01X_ID:
+        case FAN53555UC03X_ID:
+        case FAN53555UC04X_ID:
+        case FAN53555UC05X_ID:
+                fan->chip_id = chip_id;
+                break;
+        default:
+                dev_err(fan->dev, "Err: not supported device chip id 0x%x",
+                        chip_id);
+                err = -ENODEV;
+                goto fail;
+        }
+
+        err = fan53555_dcdc_init(fan, client, pdata);
+        if (err < 0) {
+                dev_err(fan->dev, "FAN53555 init fails with %d\n", err);
+                goto fail;
+        }
+
+        rdev = regulator_register(&fan->desc, &client->dev, init_data, fan);
+        if (IS_ERR(rdev)) {
+                dev_err(fan->dev, "Failed to register %s\n", id->name);
+                err = PTR_ERR(rdev);
+                goto fail;
+        }
+        fan->rdev = rdev;
+
+        fan53555_debuginit(fan);
+        return 0;
+
+fail:
+        kfree(fan);
+        return err;
+}
+
+/**
+ * fan53555_remove - fan53555 driver i2c remove handler
+ * @client: i2c driver client device structure
+ *
+ * Unregister fan53555 driver as an i2c client device driver
+ */
+static int __devexit fan53555_remove(struct i2c_client *client)
+{
+        struct fan53555_chip *chip = i2c_get_clientdata(client);
+
+        regulator_unregister(chip->rdev);
+        kfree(chip);
+        return 0;
+}
+
+static const struct i2c_device_id fan53555_id[] = {
+        {.name = "fan53555", .driver_data = 0 },
+        {},
+};
+MODULE_DEVICE_TABLE(i2c, fan53555_id);
+
+static struct i2c_driver fan53555_i2c_driver = {
+        .driver = {
+                .name = "fan53555",
+                .owner = THIS_MODULE,
+        },
+        .probe = fan53555_probe,
+        .remove = __devexit_p(fan53555_remove),
+        .id_table = fan53555_id,
+};
+
+/* Module init function */
+static int __init fan53555_init(void)
+{
+        return i2c_add_driver(&fan53555_i2c_driver);
+}
+subsys_initcall_sync(fan53555_init);
+
+/* Module exit function */
+static void __exit fan53555_cleanup(void)
+{
+        i2c_del_driver(&fan53555_i2c_driver);
+}
+module_exit(fan53555_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jake Park<jakep@nvidia.com>");
+MODULE_DESCRIPTION("Regulator Driver for Fairchild FAN53555 Regulator");
+MODULE_ALIAS("platform:fan53555-regulator");