linux/drivers/mfd/tps65090.c
<<
>>
Prefs
   1/*
   2 * Core driver for TI TPS65090 PMIC family
   3 *
   4 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   5
   6 * This program is free software; you can redistribute it and/or modify it
   7 * under the terms and conditions of the GNU General Public License,
   8 * version 2, as published by the Free Software Foundation.
   9
  10 * This program is distributed in the hope it will be useful, but WITHOUT
  11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13 * more details.
  14
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19#include <linux/interrupt.h>
  20#include <linux/irq.h>
  21#include <linux/kernel.h>
  22#include <linux/module.h>
  23#include <linux/mutex.h>
  24#include <linux/slab.h>
  25#include <linux/i2c.h>
  26#include <linux/mfd/core.h>
  27#include <linux/mfd/tps65090.h>
  28#include <linux/of.h>
  29#include <linux/of_device.h>
  30#include <linux/err.h>
  31
  32#define NUM_INT_REG 2
  33#define TOTAL_NUM_REG 0x18
  34
  35/* interrupt status registers */
  36#define TPS65090_INT_STS        0x0
  37#define TPS65090_INT_STS2       0x1
  38
  39/* interrupt mask registers */
  40#define TPS65090_INT_MSK        0x2
  41#define TPS65090_INT_MSK2       0x3
  42
  43#define TPS65090_INT1_MASK_VAC_STATUS_CHANGE            1
  44#define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE           2
  45#define TPS65090_INT1_MASK_BAT_STATUS_CHANGE            3
  46#define TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE       4
  47#define TPS65090_INT1_MASK_CHARGING_COMPLETE            5
  48#define TPS65090_INT1_MASK_OVERLOAD_DCDC1               6
  49#define TPS65090_INT1_MASK_OVERLOAD_DCDC2               7
  50#define TPS65090_INT2_MASK_OVERLOAD_DCDC3               0
  51#define TPS65090_INT2_MASK_OVERLOAD_FET1                1
  52#define TPS65090_INT2_MASK_OVERLOAD_FET2                2
  53#define TPS65090_INT2_MASK_OVERLOAD_FET3                3
  54#define TPS65090_INT2_MASK_OVERLOAD_FET4                4
  55#define TPS65090_INT2_MASK_OVERLOAD_FET5                5
  56#define TPS65090_INT2_MASK_OVERLOAD_FET6                6
  57#define TPS65090_INT2_MASK_OVERLOAD_FET7                7
  58
  59static struct resource charger_resources[] = {
  60        {
  61                .start  = TPS65090_IRQ_VAC_STATUS_CHANGE,
  62                .end    = TPS65090_IRQ_VAC_STATUS_CHANGE,
  63                .flags  = IORESOURCE_IRQ,
  64        }
  65};
  66
  67static struct mfd_cell tps65090s[] = {
  68        {
  69                .name = "tps65090-pmic",
  70        },
  71        {
  72                .name = "tps65090-charger",
  73                .num_resources = ARRAY_SIZE(charger_resources),
  74                .resources = &charger_resources[0],
  75                .of_compatible = "ti,tps65090-charger",
  76        },
  77};
  78
  79static const struct regmap_irq tps65090_irqs[] = {
  80        /* INT1 IRQs*/
  81        [TPS65090_IRQ_VAC_STATUS_CHANGE] = {
  82                        .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE,
  83        },
  84        [TPS65090_IRQ_VSYS_STATUS_CHANGE] = {
  85                        .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE,
  86        },
  87        [TPS65090_IRQ_BAT_STATUS_CHANGE] = {
  88                        .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE,
  89        },
  90        [TPS65090_IRQ_CHARGING_STATUS_CHANGE] = {
  91                        .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE,
  92        },
  93        [TPS65090_IRQ_CHARGING_COMPLETE] = {
  94                        .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE,
  95        },
  96        [TPS65090_IRQ_OVERLOAD_DCDC1] = {
  97                        .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1,
  98        },
  99        [TPS65090_IRQ_OVERLOAD_DCDC2] = {
 100                        .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2,
 101        },
 102        /* INT2 IRQs*/
 103        [TPS65090_IRQ_OVERLOAD_DCDC3] = {
 104                        .reg_offset = 1,
 105                        .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3,
 106        },
 107        [TPS65090_IRQ_OVERLOAD_FET1] = {
 108                        .reg_offset = 1,
 109                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET1,
 110        },
 111        [TPS65090_IRQ_OVERLOAD_FET2] = {
 112                        .reg_offset = 1,
 113                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET2,
 114        },
 115        [TPS65090_IRQ_OVERLOAD_FET3] = {
 116                        .reg_offset = 1,
 117                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET3,
 118        },
 119        [TPS65090_IRQ_OVERLOAD_FET4] = {
 120                        .reg_offset = 1,
 121                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET4,
 122        },
 123        [TPS65090_IRQ_OVERLOAD_FET5] = {
 124                        .reg_offset = 1,
 125                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET5,
 126        },
 127        [TPS65090_IRQ_OVERLOAD_FET6] = {
 128                        .reg_offset = 1,
 129                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET6,
 130        },
 131        [TPS65090_IRQ_OVERLOAD_FET7] = {
 132                        .reg_offset = 1,
 133                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET7,
 134        },
 135};
 136
 137static struct regmap_irq_chip tps65090_irq_chip = {
 138        .name = "tps65090",
 139        .irqs = tps65090_irqs,
 140        .num_irqs = ARRAY_SIZE(tps65090_irqs),
 141        .num_regs = NUM_INT_REG,
 142        .status_base = TPS65090_INT_STS,
 143        .mask_base = TPS65090_INT_MSK,
 144        .mask_invert = true,
 145};
 146
 147static bool is_volatile_reg(struct device *dev, unsigned int reg)
 148{
 149        if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS2))
 150                return true;
 151        else
 152                return false;
 153}
 154
 155static const struct regmap_config tps65090_regmap_config = {
 156        .reg_bits = 8,
 157        .val_bits = 8,
 158        .max_register = TOTAL_NUM_REG,
 159        .num_reg_defaults_raw = TOTAL_NUM_REG,
 160        .cache_type = REGCACHE_RBTREE,
 161        .volatile_reg = is_volatile_reg,
 162};
 163
 164#ifdef CONFIG_OF
 165static const struct of_device_id tps65090_of_match[] = {
 166        { .compatible = "ti,tps65090",},
 167        {},
 168};
 169MODULE_DEVICE_TABLE(of, tps65090_of_match);
 170#endif
 171
 172static int tps65090_i2c_probe(struct i2c_client *client,
 173                                        const struct i2c_device_id *id)
 174{
 175        struct tps65090_platform_data *pdata = client->dev.platform_data;
 176        int irq_base = 0;
 177        struct tps65090 *tps65090;
 178        int ret;
 179
 180        if (!pdata && !client->dev.of_node) {
 181                dev_err(&client->dev,
 182                        "tps65090 requires platform data or of_node\n");
 183                return -EINVAL;
 184        }
 185
 186        if (pdata)
 187                irq_base = pdata->irq_base;
 188
 189        tps65090 = devm_kzalloc(&client->dev, sizeof(*tps65090), GFP_KERNEL);
 190        if (!tps65090) {
 191                dev_err(&client->dev, "mem alloc for tps65090 failed\n");
 192                return -ENOMEM;
 193        }
 194
 195        tps65090->dev = &client->dev;
 196        i2c_set_clientdata(client, tps65090);
 197
 198        tps65090->rmap = devm_regmap_init_i2c(client, &tps65090_regmap_config);
 199        if (IS_ERR(tps65090->rmap)) {
 200                ret = PTR_ERR(tps65090->rmap);
 201                dev_err(&client->dev, "regmap_init failed with err: %d\n", ret);
 202                return ret;
 203        }
 204
 205        if (client->irq) {
 206                ret = regmap_add_irq_chip(tps65090->rmap, client->irq,
 207                        IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base,
 208                        &tps65090_irq_chip, &tps65090->irq_data);
 209                        if (ret) {
 210                                dev_err(&client->dev,
 211                                        "IRQ init failed with err: %d\n", ret);
 212                        return ret;
 213                }
 214        }
 215
 216        ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
 217                ARRAY_SIZE(tps65090s), NULL,
 218                0, regmap_irq_get_domain(tps65090->irq_data));
 219        if (ret) {
 220                dev_err(&client->dev, "add mfd devices failed with err: %d\n",
 221                        ret);
 222                goto err_irq_exit;
 223        }
 224
 225        return 0;
 226
 227err_irq_exit:
 228        if (client->irq)
 229                regmap_del_irq_chip(client->irq, tps65090->irq_data);
 230        return ret;
 231}
 232
 233static int tps65090_i2c_remove(struct i2c_client *client)
 234{
 235        struct tps65090 *tps65090 = i2c_get_clientdata(client);
 236
 237        mfd_remove_devices(tps65090->dev);
 238        if (client->irq)
 239                regmap_del_irq_chip(client->irq, tps65090->irq_data);
 240
 241        return 0;
 242}
 243
 244static const struct i2c_device_id tps65090_id_table[] = {
 245        { "tps65090", 0 },
 246        { },
 247};
 248MODULE_DEVICE_TABLE(i2c, tps65090_id_table);
 249
 250static struct i2c_driver tps65090_driver = {
 251        .driver = {
 252                .name   = "tps65090",
 253                .owner  = THIS_MODULE,
 254                .of_match_table = of_match_ptr(tps65090_of_match),
 255        },
 256        .probe          = tps65090_i2c_probe,
 257        .remove         = tps65090_i2c_remove,
 258        .id_table       = tps65090_id_table,
 259};
 260
 261static int __init tps65090_init(void)
 262{
 263        return i2c_add_driver(&tps65090_driver);
 264}
 265subsys_initcall(tps65090_init);
 266
 267static void __exit tps65090_exit(void)
 268{
 269        i2c_del_driver(&tps65090_driver);
 270}
 271module_exit(tps65090_exit);
 272
 273MODULE_DESCRIPTION("TPS65090 core driver");
 274MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
 275MODULE_LICENSE("GPL v2");
 276
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.