diff options
author | venu byravarasu <vbyravarasu@nvidia.com> | 2012-01-10 16:17:04 +0530 |
---|---|---|
committer | Varun Colbert <vcolbert@nvidia.com> | 2012-01-13 14:07:45 -0800 |
commit | c9b56e56386371e413d3473daa2c38b660c5e8b6 (patch) | |
tree | 4f4dfe5919e0bdb23040e6cadec5472be42d3257 /drivers/mfd | |
parent | 1d2f0974dbe7e7a9acfd79d204b49d9198d1830a (diff) |
mfd: TPS65090: Add PMIC support
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>
Diffstat (limited to 'drivers/mfd')
-rw-r--r-- | drivers/mfd/Kconfig | 19 | ||||
-rw-r--r-- | drivers/mfd/Makefile | 1 | ||||
-rw-r--r-- | drivers/mfd/tps65090.c | 498 |
3 files changed, 518 insertions, 0 deletions
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index 55fd5157b438..2cf0a06a9860 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -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 diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index f9f9d400b0ee..6abb3f3ca41a 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -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 index 000000000000..080f97aa264b --- /dev/null +++ b/drivers/mfd/tps65090.c @@ -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, ®_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"); |