diff options
Diffstat (limited to 'drivers/mfd/tps65090.c')
-rw-r--r-- | drivers/mfd/tps65090.c | 385 |
1 files changed, 110 insertions, 275 deletions
diff --git a/drivers/mfd/tps65090.c b/drivers/mfd/tps65090.c index 080f97aa264b..25f463de1513 100644 --- a/drivers/mfd/tps65090.c +++ b/drivers/mfd/tps65090.c @@ -1,37 +1,33 @@ /* - * 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/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> +#include <linux/err.h> + +#define NUM_INT_REG 2 +#define TOTAL_NUM_REG 0x18 /* interrupt status registers */ #define TPS65090_INT_STS 0x0 @@ -41,95 +37,41 @@ #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), }; -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]; +static struct mfd_cell tps65090s[] = { + { + .name = "tps65910-pmic", + }, }; -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) { @@ -141,135 +83,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 = 0, mask = 0; + 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 +196,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) +static bool is_volatile_reg(struct device *dev, unsigned int reg) { - 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; + 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,50 +222,47 @@ 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); - if (tps65090 == NULL) + tps65090 = devm_kzalloc(&client->dev, sizeof(*tps65090), GFP_KERNEL); + if (!tps65090) { + dev_err(&client->dev, "mem alloc for tps65090 failed\n"); return -ENOMEM; + } - tps65090->client = client; tps65090->dev = &client->dev; i2c_set_clientdata(client, tps65090); - mutex_init(&tps65090->lock); + tps65090->rmap = devm_regmap_init_i2c(client, &tps65090_regmap_config); + if (IS_ERR(tps65090->rmap)) { + ret = PTR_ERR(tps65090->rmap); + dev_err(&client->dev, "regmap_init failed with err: %d\n", ret); + return ret; + } 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); + return ret; } } - ret = tps65090_add_subdevs(tps65090, pdata); + ret = mfd_add_devices(tps65090->dev, -1, tps65090s, + ARRAY_SIZE(tps65090s), NULL, 0); if (ret) { - dev_err(&client->dev, "add devices failed: %d\n", ret); - goto err_add_devs; + dev_err(&client->dev, "add mfd devices failed with err: %d\n", + ret); + goto err_irq_exit; } - 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: +err_irq_exit: if (client->irq) free_irq(client->irq, tps65090); -err_irq_init: - kfree(tps65090); return ret; } @@ -438,29 +270,34 @@ static int __devexit tps65090_i2c_remove(struct i2c_client *client) { struct tps65090 *tps65090 = i2c_get_clientdata(client); + mfd_remove_devices(tps65090->dev); 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) + +#ifdef CONFIG_PM_SLEEP +static int tps65090_suspend(struct device *dev) { + struct i2c_client *client = to_i2c_client(dev); if (client->irq) disable_irq(client->irq); return 0; } -static int tps65090_i2c_resume(struct i2c_client *client) +static int tps65090_resume(struct device *dev) { + struct i2c_client *client = to_i2c_client(dev); if (client->irq) enable_irq(client->irq); return 0; } #endif +static const struct dev_pm_ops tps65090_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(tps65090_suspend, tps65090_resume) +}; static const struct i2c_device_id tps65090_id_table[] = { { "tps65090", 0 }, @@ -472,13 +309,10 @@ static struct i2c_driver tps65090_driver = { .driver = { .name = "tps65090", .owner = THIS_MODULE, + .pm = &tps65090_pm_ops, }, .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, }; @@ -495,4 +329,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"); |