drivers/mfd/tps65090.c

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