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 static const struct mfd_cell tps65218_cells[] = {
  37         {
  38                 .name = "tps65218-pwrbutton",
  39                 .of_compatible = "ti,tps65218-pwrbutton",
  40         },
  41         {
  42                 .name = "tps65218-gpio",
  43                 .of_compatible = "ti,tps65218-gpio",
  44         },
  45         { .name = "tps65218-regulator", },
  46 };
  47
  48 /**
  49  * tps65218_reg_write: Write a single tps65218 register.
  50  *
  51  * @tps65218: Device to write to.
  52  * @reg: Register to write to.
  53  * @val: Value to write.
  54  * @level: Password protected level
  55  */
  56 int tps65218_reg_write(struct tps65218 *tps, unsigned int reg,
  57                         unsigned int val, unsigned int level)
  58 {
  59         int ret;
  60         unsigned int xor_reg_val;
  61
  62         switch (level) {
  63         case TPS65218_PROTECT_NONE:
  64                 return regmap_write(tps->regmap, reg, val);
  65         case TPS65218_PROTECT_L1:
  66                 xor_reg_val = reg ^ TPS65218_PASSWORD_REGS_UNLOCK;
  67                 ret = regmap_write(tps->regmap, TPS65218_REG_PASSWORD,
  68                                                         xor_reg_val);
  69                 if (ret < 0)
  70                         return ret;
  71
  72                 return regmap_write(tps->regmap, reg, val);
  73         default:
  74                 return -EINVAL;
  75         }
  76 }
  77 EXPORT_SYMBOL_GPL(tps65218_reg_write);
  78
  79 /**
  80  * tps65218_update_bits: Modify bits w.r.t mask, val and level.
  81  *
  82  * @tps65218: Device to write to.
  83  * @reg: Register to read-write to.
  84  * @mask: Mask.
  85  * @val: Value to write.
  86  * @level: Password protected level
  87  */
  88 static int tps65218_update_bits(struct tps65218 *tps, unsigned int reg,
  89                 unsigned int mask, unsigned int val, unsigned int level)
  90 {
  91         int ret;
  92         unsigned int data;
  93
  94         ret = regmap_read(tps->regmap, reg, &data);
  95         if (ret) {
  96                 dev_err(tps->dev, "Read from reg 0x%x failed\n", reg);
  97                 return ret;
  98         }
  99
 100         data &= ~mask;
 101         data |= val & mask;
 102
 103         mutex_lock(&tps->tps_lock);
 104         ret = tps65218_reg_write(tps, reg, data, level);
 105         if (ret)
 106                 dev_err(tps->dev, "Write for reg 0x%x failed\n", reg);
 107         mutex_unlock(&tps->tps_lock);
 108
 109         return ret;
 110 }
 111
 112 int tps65218_set_bits(struct tps65218 *tps, unsigned int reg,
 113                 unsigned int mask, unsigned int val, unsigned int level)
 114 {
 115         return tps65218_update_bits(tps, reg, mask, val, level);
 116 }
 117 EXPORT_SYMBOL_GPL(tps65218_set_bits);
 118
 119 int tps65218_clear_bits(struct tps65218 *tps, unsigned int reg,
 120                 unsigned int mask, unsigned int level)
 121 {
 122         return tps65218_update_bits(tps, reg, mask, 0, level);
 123 }
 124 EXPORT_SYMBOL_GPL(tps65218_clear_bits);
 125
 126 static const struct regmap_range tps65218_yes_ranges[] = {
 127         regmap_reg_range(TPS65218_REG_INT1, TPS65218_REG_INT2),
 128         regmap_reg_range(TPS65218_REG_STATUS, TPS65218_REG_STATUS),
 129 };
 130
 131 static const struct regmap_access_table tps65218_volatile_table = {
 132         .yes_ranges = tps65218_yes_ranges,
 133         .n_yes_ranges = ARRAY_SIZE(tps65218_yes_ranges),
 134 };
 135
 136 static const struct regmap_config tps65218_regmap_config = {
 137         .reg_bits = 8,
 138         .val_bits = 8,
 139         .cache_type = REGCACHE_RBTREE,
 140         .volatile_table = &tps65218_volatile_table,
 141 };
 142
 143 static const struct regmap_irq tps65218_irqs[] = {
 144         /* INT1 IRQs */
 145         [TPS65218_PRGC_IRQ] = {
 146                 .mask = TPS65218_INT1_PRGC,
 147         },
 148         [TPS65218_CC_AQC_IRQ] = {
 149                 .mask = TPS65218_INT1_CC_AQC,
 150         },
 151         [TPS65218_HOT_IRQ] = {
 152                 .mask = TPS65218_INT1_HOT,
 153         },
 154         [TPS65218_PB_IRQ] = {
 155                 .mask = TPS65218_INT1_PB,
 156         },
 157         [TPS65218_AC_IRQ] = {
 158                 .mask = TPS65218_INT1_AC,
 159         },
 160         [TPS65218_VPRG_IRQ] = {
 161                 .mask = TPS65218_INT1_VPRG,
 162         },
 163         [TPS65218_INVALID1_IRQ] = {
 164         },
 165         [TPS65218_INVALID2_IRQ] = {
 166         },
 167         /* INT2 IRQs*/
 168         [TPS65218_LS1_I_IRQ] = {
 169                 .mask = TPS65218_INT2_LS1_I,
 170                 .reg_offset = 1,
 171         },
 172         [TPS65218_LS2_I_IRQ] = {
 173                 .mask = TPS65218_INT2_LS2_I,
 174                 .reg_offset = 1,
 175         },
 176         [TPS65218_LS3_I_IRQ] = {
 177                 .mask = TPS65218_INT2_LS3_I,
 178                 .reg_offset = 1,
 179         },
 180         [TPS65218_LS1_F_IRQ] = {
 181                 .mask = TPS65218_INT2_LS1_F,
 182                 .reg_offset = 1,
 183         },
 184         [TPS65218_LS2_F_IRQ] = {
 185                 .mask = TPS65218_INT2_LS2_F,
 186                 .reg_offset = 1,
 187         },
 188         [TPS65218_LS3_F_IRQ] = {
 189                 .mask = TPS65218_INT2_LS3_F,
 190                 .reg_offset = 1,
 191         },
 192         [TPS65218_INVALID3_IRQ] = {
 193         },
 194         [TPS65218_INVALID4_IRQ] = {
 195         },
 196 };
 197
 198 static struct regmap_irq_chip tps65218_irq_chip = {
 199         .name = "tps65218",
 200         .irqs = tps65218_irqs,
 201         .num_irqs = ARRAY_SIZE(tps65218_irqs),
 202
 203         .num_regs = 2,
 204         .mask_base = TPS65218_REG_INT_MASK1,
 205         .status_base = TPS65218_REG_INT1,
 206 };
 207
 208 static const struct of_device_id of_tps65218_match_table[] = {
 209         { .compatible = "ti,tps65218", },
 210         {}
 211 };
 212 MODULE_DEVICE_TABLE(of, of_tps65218_match_table);
 213
 214 static int tps65218_probe(struct i2c_client *client,
 215                                 const struct i2c_device_id *ids)
 216 {
 217         struct tps65218 *tps;
 218         int ret;
 219         unsigned int chipid;
 220
 221         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
 222         if (!tps)
 223                 return -ENOMEM;
 224
 225         i2c_set_clientdata(client, tps);
 226         tps->dev = &client->dev;
 227         tps->irq = client->irq;
 228         tps->regmap = devm_regmap_init_i2c(client, &tps65218_regmap_config);
 229         if (IS_ERR(tps->regmap)) {
 230                 ret = PTR_ERR(tps->regmap);
 231                 dev_err(tps->dev, "Failed to allocate register map: %d\n",
 232                         ret);
 233                 return ret;
 234         }
 235
 236         mutex_init(&tps->tps_lock);
 237
 238         ret = devm_regmap_add_irq_chip(&client->dev, tps->regmap, tps->irq,
 239                                        IRQF_ONESHOT, 0, &tps65218_irq_chip,
 240                                        &tps->irq_data);
 241         if (ret < 0)
 242                 return ret;
 243
 244         ret = regmap_read(tps->regmap, TPS65218_REG_CHIPID, &chipid);
 245         if (ret) {
 246                 dev_err(tps->dev, "Failed to read chipid: %d\n", ret);
 247                 return ret;
 248         }
 249
 250         tps->rev = chipid & TPS65218_CHIPID_REV_MASK;
 251
 252         ret = mfd_add_devices(tps->dev, PLATFORM_DEVID_AUTO, tps65218_cells,
 253                               ARRAY_SIZE(tps65218_cells), NULL, 0,
 254                               regmap_irq_get_domain(tps->irq_data));
 255
 256         return ret;
 257 }
 258
 259 static const struct i2c_device_id tps65218_id_table[] = {
 260         { "tps65218", TPS65218 },
 261         { },
 262 };
 263 MODULE_DEVICE_TABLE(i2c, tps65218_id_table);
 264
 265 static struct i2c_driver tps65218_driver = {
 266         .driver         = {
 267                 .name   = "tps65218",
 268                 .of_match_table = of_tps65218_match_table,
 269         },
 270         .probe          = tps65218_probe,
 271         .id_table       = tps65218_id_table,
 272 };
 273
 274 module_i2c_driver(tps65218_driver);
 275
 276 MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
 277 MODULE_DESCRIPTION("TPS65218 chip family multi-function driver");
 278 MODULE_LICENSE("GPL v2");