drivers/mfd/tps65218.c

   1 /*
   2  * Driver for TPS65218 Integrated power management chipsets
   3  *
   4  * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  11  * kind, whether expressed or implied; without even the implied warranty
  12  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License version 2 for more details.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/device.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/init.h>
  21 #include <linux/i2c.h>
  22 #include <linux/slab.h>
  23 #include <linux/regmap.h>
  24 #include <linux/err.h>
  25 #include <linux/of.h>
  26 #include <linux/of_device.h>
  27 #include <linux/irq.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/mutex.h>
  30
  31 #include <linux/mfd/core.h>
  32 #include <linux/mfd/tps65218.h>
  33
  34 #define TPS65218_PASSWORD_REGS_UNLOCK   0x7D
  35
  36 /**
  37  * tps65218_reg_read: Read a single tps65218 register.
  38  *
  39  * @tps: Device to read from.
  40  * @reg: Register to read.
  41  * @val: Contians the value
  42  */
  43 int tps65218_reg_read(struct tps65218 *tps, unsigned int reg,
  44                         unsigned int *val)
  45 {
  46         return regmap_read(tps->regmap, reg, val);
  47 }
  48 EXPORT_SYMBOL_GPL(tps65218_reg_read);
  49
  50 /**
  51  * tps65218_reg_write: Write a single tps65218 register.
  52  *
  53  * @tps65218: Device to write to.
  54  * @reg: Register to write to.
  55  * @val: Value to write.
  56  * @level: Password protected level
  57  */
  58 int tps65218_reg_write(struct tps65218 *tps, unsigned int reg,
  59                         unsigned int val, unsigned int level)
  60 {
  61         int ret;
  62         unsigned int xor_reg_val;
  63
  64         switch (level) {
  65         case TPS65218_PROTECT_NONE:
  66                 return regmap_write(tps->regmap, reg, val);
  67         case TPS65218_PROTECT_L1:
  68                 xor_reg_val = reg ^ TPS65218_PASSWORD_REGS_UNLOCK;
  69                 ret = regmap_write(tps->regmap, TPS65218_REG_PASSWORD,
  70                                                         xor_reg_val);
  71                 if (ret < 0)
  72                         return ret;
  73
  74                 return regmap_write(tps->regmap, reg, val);
  75         default:
  76                 return -EINVAL;
  77         }
  78 }
  79 EXPORT_SYMBOL_GPL(tps65218_reg_write);
  80
  81 /**
  82  * tps65218_update_bits: Modify bits w.r.t mask, val and level.
  83  *
  84  * @tps65218: Device to write to.
  85  * @reg: Register to read-write to.
  86  * @mask: Mask.
  87  * @val: Value to write.
  88  * @level: Password protected level
  89  */
  90 static int tps65218_update_bits(struct tps65218 *tps, unsigned int reg,
  91                 unsigned int mask, unsigned int val, unsigned int level)
  92 {
  93         int ret;
  94         unsigned int data;
  95
  96         ret = tps65218_reg_read(tps, reg, &data);
  97         if (ret) {
  98                 dev_err(tps->dev, "Read from reg 0x%x failed\n", reg);
  99                 return ret;
 100         }
 101
 102         data &= ~mask;
 103         data |= val & mask;
 104
 105         mutex_lock(&tps->tps_lock);
 106         ret = tps65218_reg_write(tps, reg, data, level);
 107         if (ret)
 108                 dev_err(tps->dev, "Write for reg 0x%x failed\n", reg);
 109         mutex_unlock(&tps->tps_lock);
 110
 111         return ret;
 112 }
 113
 114 int tps65218_set_bits(struct tps65218 *tps, unsigned int reg,
 115                 unsigned int mask, unsigned int val, unsigned int level)
 116 {
 117         return tps65218_update_bits(tps, reg, mask, val, level);
 118 }
 119 EXPORT_SYMBOL_GPL(tps65218_set_bits);
 120
 121 int tps65218_clear_bits(struct tps65218 *tps, unsigned int reg,
 122                 unsigned int mask, unsigned int level)
 123 {
 124         return tps65218_update_bits(tps, reg, mask, 0, level);
 125 }
 126 EXPORT_SYMBOL_GPL(tps65218_clear_bits);
 127
 128 static struct regmap_config tps65218_regmap_config = {
 129         .reg_bits = 8,
 130         .val_bits = 8,
 131         .cache_type = REGCACHE_RBTREE,
 132 };
 133
 134 static const struct regmap_irq tps65218_irqs[] = {
 135         /* INT1 IRQs */
 136         [TPS65218_PRGC_IRQ] = {
 137                 .mask = TPS65218_INT1_PRGC,
 138         },
 139         [TPS65218_CC_AQC_IRQ] = {
 140                 .mask = TPS65218_INT1_CC_AQC,
 141         },
 142         [TPS65218_HOT_IRQ] = {
 143                 .mask = TPS65218_INT1_HOT,
 144         },
 145         [TPS65218_PB_IRQ] = {
 146                 .mask = TPS65218_INT1_PB,
 147         },
 148         [TPS65218_AC_IRQ] = {
 149                 .mask = TPS65218_INT1_AC,
 150         },
 151         [TPS65218_VPRG_IRQ] = {
 152                 .mask = TPS65218_INT1_VPRG,
 153         },
 154         [TPS65218_INVALID1_IRQ] = {
 155         },
 156         [TPS65218_INVALID2_IRQ] = {
 157         },
 158         /* INT2 IRQs*/
 159         [TPS65218_LS1_I_IRQ] = {
 160                 .mask = TPS65218_INT2_LS1_I,
 161                 .reg_offset = 1,
 162         },
 163         [TPS65218_LS2_I_IRQ] = {
 164                 .mask = TPS65218_INT2_LS2_I,
 165                 .reg_offset = 1,
 166         },
 167         [TPS65218_LS3_I_IRQ] = {
 168                 .mask = TPS65218_INT2_LS3_I,
 169                 .reg_offset = 1,
 170         },
 171         [TPS65218_LS1_F_IRQ] = {
 172                 .mask = TPS65218_INT2_LS1_F,
 173                 .reg_offset = 1,
 174         },
 175         [TPS65218_LS2_F_IRQ] = {
 176                 .mask = TPS65218_INT2_LS2_F,
 177                 .reg_offset = 1,
 178         },
 179         [TPS65218_LS3_F_IRQ] = {
 180                 .mask = TPS65218_INT2_LS3_F,
 181                 .reg_offset = 1,
 182         },
 183         [TPS65218_INVALID3_IRQ] = {
 184         },
 185         [TPS65218_INVALID4_IRQ] = {
 186         },
 187 };
 188
 189 static struct regmap_irq_chip tps65218_irq_chip = {
 190         .name = "tps65218",
 191         .irqs = tps65218_irqs,
 192         .num_irqs = ARRAY_SIZE(tps65218_irqs),
 193
 194         .num_regs = 2,
 195         .mask_base = TPS65218_REG_INT_MASK1,
 196 };
 197
 198 static const struct of_device_id of_tps65218_match_table[] = {
 199         { .compatible = "ti,tps65218", },
 200         {}
 201 };
 202
 203 static int tps65218_probe(struct i2c_client *client,
 204                                 const struct i2c_device_id *ids)
 205 {
 206         struct tps65218 *tps;
 207         const struct of_device_id *match;
 208         int ret;
 209
 210         match = of_match_device(of_tps65218_match_table, &client->dev);
 211         if (!match) {
 212                 dev_err(&client->dev,
 213                         "Failed to find matching dt id\n");
 214                 return -EINVAL;
 215         }
 216
 217         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
 218         if (!tps)
 219                 return -ENOMEM;
 220
 221         i2c_set_clientdata(client, tps);
 222         tps->dev = &client->dev;
 223         tps->irq = client->irq;
 224         tps->regmap = devm_regmap_init_i2c(client, &tps65218_regmap_config);
 225         if (IS_ERR(tps->regmap)) {
 226                 ret = PTR_ERR(tps->regmap);
 227                 dev_err(tps->dev, "Failed to allocate register map: %d\n",
 228                         ret);
 229                 return ret;
 230         }
 231
 232         mutex_init(&tps->tps_lock);
 233
 234         ret = regmap_add_irq_chip(tps->regmap, tps->irq,
 235                         IRQF_ONESHOT, 0, &tps65218_irq_chip,
 236                         &tps->irq_data);
 237         if (ret < 0)
 238                 return ret;
 239
 240         ret = of_platform_populate(client->dev.of_node, NULL, NULL,
 241                                    &client->dev);
 242         if (ret < 0)
 243                 goto err_irq;
 244
 245         return 0;
 246
 247 err_irq:
 248         regmap_del_irq_chip(tps->irq, tps->irq_data);
 249
 250         return ret;
 251 }
 252
 253 static int tps65218_remove(struct i2c_client *client)
 254 {
 255         struct tps65218 *tps = i2c_get_clientdata(client);
 256
 257         regmap_del_irq_chip(tps->irq, tps->irq_data);
 258
 259         return 0;
 260 }
 261
 262 static const struct i2c_device_id tps65218_id_table[] = {
 263         { "tps65218", TPS65218 },
 264         { },
 265 };
 266 MODULE_DEVICE_TABLE(i2c, tps65218_id_table);
 267
 268 static struct i2c_driver tps65218_driver = {
 269         .driver         = {
 270                 .name   = "tps65218",
 271                 .owner  = THIS_MODULE,
 272                 .of_match_table = of_tps65218_match_table,
 273         },
 274         .probe          = tps65218_probe,
 275         .remove         = tps65218_remove,
 276         .id_table       = tps65218_id_table,
 277 };
 278
 279 module_i2c_driver(tps65218_driver);
 280
 281 MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
 282 MODULE_DESCRIPTION("TPS65218 chip family multi-function driver");
 283 MODULE_LICENSE("GPL v2");