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  * 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/regmap.h>
  29 #include <linux/err.h>
  30
  31 #define NUM_INT_REG 2
  32 #define TOTAL_NUM_REG 0x18
  33
  34 /* interrupt status registers */
  35 #define TPS65090_INT_STS        0x0
  36 #define TPS65090_INT_STS2       0x1
  37
  38 /* interrupt mask registers */
  39 #define TPS65090_INT_MSK        0x2
  40 #define TPS65090_INT_MSK2       0x3
  41
  42 struct tps65090_irq_data {
  43         u8              mask_reg;
  44         u8              mask_pos;
  45 };
  46
  47 #define TPS65090_IRQ(_reg, _mask_pos)           \
  48         {                                       \
  49                 .mask_reg       = (_reg),       \
  50                 .mask_pos       = (_mask_pos),  \
  51         }
  52
  53 static const struct tps65090_irq_data tps65090_irqs[] = {
  54         [0]             = TPS65090_IRQ(0, 0),
  55         [1]             = TPS65090_IRQ(0, 1),
  56         [2]             = TPS65090_IRQ(0, 2),
  57         [3]             = TPS65090_IRQ(0, 3),
  58         [4]             = TPS65090_IRQ(0, 4),
  59         [5]             = TPS65090_IRQ(0, 5),
  60         [6]             = TPS65090_IRQ(0, 6),
  61         [7]             = TPS65090_IRQ(0, 7),
  62         [8]             = TPS65090_IRQ(1, 0),
  63         [9]             = TPS65090_IRQ(1, 1),
  64         [10]            = TPS65090_IRQ(1, 2),
  65         [11]            = TPS65090_IRQ(1, 3),
  66         [12]            = TPS65090_IRQ(1, 4),
  67         [13]            = TPS65090_IRQ(1, 5),
  68         [14]            = TPS65090_IRQ(1, 6),
  69         [15]            = TPS65090_IRQ(1, 7),
  70 };
  71
  72 static struct mfd_cell tps65090s[] = {
  73         {
  74                 .name = "tps65910-pmic",
  75         },
  76         {
  77                 .name = "tps65910-regulator",
  78         },
  79 };
  80
  81 struct tps65090 {
  82         struct mutex            lock;
  83         struct device           *dev;
  84         struct i2c_client       *client;
  85         struct regmap           *rmap;
  86         struct irq_chip         irq_chip;
  87         struct mutex            irq_lock;
  88         int                     irq_base;
  89         unsigned int            id;
  90 };
  91
  92 int tps65090_write(struct device *dev, int reg, uint8_t val)
  93 {
  94         struct tps65090 *tps = dev_get_drvdata(dev);
  95         return regmap_write(tps->rmap, reg, val);
  96 }
  97 EXPORT_SYMBOL_GPL(tps65090_write);
  98
  99 int tps65090_read(struct device *dev, int reg, uint8_t *val)
 100 {
 101         struct tps65090 *tps = dev_get_drvdata(dev);
 102         unsigned int temp_val;
 103         int ret;
 104         ret = regmap_read(tps->rmap, reg, &temp_val);
 105         if (!ret)
 106                 *val = temp_val;
 107         return ret;
 108 }
 109 EXPORT_SYMBOL_GPL(tps65090_read);
 110
 111 int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num)
 112 {
 113         struct tps65090 *tps = dev_get_drvdata(dev);
 114         return regmap_update_bits(tps->rmap, reg, BIT(bit_num), ~0u);
 115 }
 116 EXPORT_SYMBOL_GPL(tps65090_set_bits);
 117
 118 int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num)
 119 {
 120         struct tps65090 *tps = dev_get_drvdata(dev);
 121         return regmap_update_bits(tps->rmap, reg, BIT(bit_num), 0u);
 122 }
 123 EXPORT_SYMBOL_GPL(tps65090_clr_bits);
 124
 125 static void tps65090_irq_lock(struct irq_data *data)
 126 {
 127         struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);
 128
 129         mutex_lock(&tps65090->irq_lock);
 130 }
 131
 132 static void tps65090_irq_mask(struct irq_data *irq_data)
 133 {
 134         struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
 135         unsigned int __irq = irq_data->hwirq;
 136         const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
 137
 138         tps65090_set_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
 139                 data->mask_pos);
 140 }
 141
 142 static void tps65090_irq_unmask(struct irq_data *irq_data)
 143 {
 144         struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
 145         unsigned int __irq = irq_data->irq - tps65090->irq_base;
 146         const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
 147
 148         tps65090_clr_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
 149                 data->mask_pos);
 150 }
 151
 152 static void tps65090_irq_sync_unlock(struct irq_data *data)
 153 {
 154         struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);
 155
 156         mutex_unlock(&tps65090->irq_lock);
 157 }
 158
 159 static irqreturn_t tps65090_irq(int irq, void *data)
 160 {
 161         struct tps65090 *tps65090 = data;
 162         int ret = 0;
 163         u8 status, mask;
 164         unsigned long int acks = 0;
 165         int i;
 166
 167         for (i = 0; i < NUM_INT_REG; i++) {
 168                 ret = tps65090_read(tps65090->dev, TPS65090_INT_MSK + i, &mask);
 169                 if (ret < 0) {
 170                         dev_err(tps65090->dev,
 171                                 "failed to read mask reg [addr:%d]\n",
 172                                 TPS65090_INT_MSK + i);
 173                         return IRQ_NONE;
 174                 }
 175                 ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + i,
 176                         &status);
 177                 if (ret < 0) {
 178                         dev_err(tps65090->dev,
 179                                 "failed to read status reg [addr:%d]\n",
 180                                  TPS65090_INT_STS + i);
 181                         return IRQ_NONE;
 182                 }
 183                 if (status) {
 184                         /* Ack only those interrupts which are not masked */
 185                         status &= (~mask);
 186                         ret = tps65090_write(tps65090->dev,
 187                                         TPS65090_INT_STS + i, status);
 188                         if (ret < 0) {
 189                                 dev_err(tps65090->dev,
 190                                         "failed to write interrupt status\n");
 191                                 return IRQ_NONE;
 192                         }
 193                         acks |= (status << (i * 8));
 194                 }
 195         }
 196
 197         for_each_set_bit(i, &acks, ARRAY_SIZE(tps65090_irqs))
 198                 handle_nested_irq(tps65090->irq_base + i);
 199         return acks ? IRQ_HANDLED : IRQ_NONE;
 200 }
 201
 202 static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int irq,
 203         int irq_base)
 204 {
 205         int i, ret;
 206
 207         if (!irq_base) {
 208                 dev_err(tps65090->dev, "IRQ base not set\n");
 209                 return -EINVAL;
 210         }
 211
 212         mutex_init(&tps65090->irq_lock);
 213
 214         for (i = 0; i < NUM_INT_REG; i++)
 215                 tps65090_write(tps65090->dev, TPS65090_INT_MSK + i, 0xFF);
 216
 217         for (i = 0; i < NUM_INT_REG; i++)
 218                 tps65090_write(tps65090->dev, TPS65090_INT_STS + i, 0xff);
 219
 220         tps65090->irq_base = irq_base;
 221         tps65090->irq_chip.name = "tps65090";
 222         tps65090->irq_chip.irq_mask = tps65090_irq_mask;
 223         tps65090->irq_chip.irq_unmask = tps65090_irq_unmask;
 224         tps65090->irq_chip.irq_bus_lock = tps65090_irq_lock;
 225         tps65090->irq_chip.irq_bus_sync_unlock = tps65090_irq_sync_unlock;
 226
 227         for (i = 0; i < ARRAY_SIZE(tps65090_irqs); i++) {
 228                 int __irq = i + tps65090->irq_base;
 229                 irq_set_chip_data(__irq, tps65090);
 230                 irq_set_chip_and_handler(__irq, &tps65090->irq_chip,
 231                                          handle_simple_irq);
 232                 irq_set_nested_thread(__irq, 1);
 233 #ifdef CONFIG_ARM
 234                 set_irq_flags(__irq, IRQF_VALID);
 235 #endif
 236         }
 237
 238         ret = request_threaded_irq(irq, NULL, tps65090_irq, IRQF_ONESHOT,
 239                                 "tps65090", tps65090);
 240         if (!ret) {
 241                 device_init_wakeup(tps65090->dev, 1);
 242                 enable_irq_wake(irq);
 243         }
 244
 245         return ret;
 246 }
 247
 248 static bool is_volatile_reg(struct device *dev, unsigned int reg)
 249 {
 250         if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS))
 251                 return true;
 252         else
 253                 return false;
 254 }
 255
 256 static const struct regmap_config tps65090_regmap_config = {
 257         .reg_bits = 8,
 258         .val_bits = 8,
 259         .max_register = TOTAL_NUM_REG,
 260         .num_reg_defaults_raw = TOTAL_NUM_REG,
 261         .cache_type = REGCACHE_RBTREE,
 262         .volatile_reg = is_volatile_reg,
 263 };
 264
 265 static int __devinit tps65090_i2c_probe(struct i2c_client *client,
 266                                         const struct i2c_device_id *id)
 267 {
 268         struct tps65090_platform_data *pdata = client->dev.platform_data;
 269         struct tps65090 *tps65090;
 270         int ret;
 271
 272         if (!pdata) {
 273                 dev_err(&client->dev, "tps65090 requires platform data\n");
 274                 return -EINVAL;
 275         }
 276
 277         tps65090 = devm_kzalloc(&client->dev, sizeof(struct tps65090),
 278                 GFP_KERNEL);
 279         if (tps65090 == NULL)
 280                 return -ENOMEM;
 281
 282         tps65090->client = client;
 283         tps65090->dev = &client->dev;
 284         i2c_set_clientdata(client, tps65090);
 285
 286         mutex_init(&tps65090->lock);
 287
 288         if (client->irq) {
 289                 ret = tps65090_irq_init(tps65090, client->irq, pdata->irq_base);
 290                 if (ret) {
 291                         dev_err(&client->dev, "IRQ init failed with err: %d\n",
 292                                 ret);
 293                         goto err_exit;
 294                 }
 295         }
 296
 297         tps65090->rmap = regmap_init_i2c(tps65090->client,
 298                 &tps65090_regmap_config);
 299         if (IS_ERR(tps65090->rmap)) {
 300                 dev_err(&client->dev, "regmap_init failed with err: %ld\n",
 301                         PTR_ERR(tps65090->rmap));
 302                 goto err_irq_exit;
 303         };
 304
 305         ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
 306                 ARRAY_SIZE(tps65090s), NULL, 0);
 307         if (ret) {
 308                 dev_err(&client->dev, "add mfd devices failed with err: %d\n",
 309                         ret);
 310                 goto err_regmap_exit;
 311         }
 312
 313         return 0;
 314
 315 err_regmap_exit:
 316         regmap_exit(tps65090->rmap);
 317
 318 err_irq_exit:
 319         if (client->irq)
 320                 free_irq(client->irq, tps65090);
 321 err_exit:
 322         return ret;
 323 }
 324
 325 static int __devexit tps65090_i2c_remove(struct i2c_client *client)
 326 {
 327         struct tps65090 *tps65090 = i2c_get_clientdata(client);
 328
 329         mfd_remove_devices(tps65090->dev);
 330         regmap_exit(tps65090->rmap);
 331         if (client->irq)
 332                 free_irq(client->irq, tps65090);
 333
 334         return 0;
 335 }
 336
 337 #ifdef CONFIG_PM
 338 static int tps65090_i2c_suspend(struct i2c_client *client, pm_message_t state)
 339 {
 340         if (client->irq)
 341                 disable_irq(client->irq);
 342         return 0;
 343 }
 344
 345 static int tps65090_i2c_resume(struct i2c_client *client)
 346 {
 347         if (client->irq)
 348                 enable_irq(client->irq);
 349         return 0;
 350 }
 351 #endif
 352
 353 static const struct i2c_device_id tps65090_id_table[] = {
 354         { "tps65090", 0 },
 355         { },
 356 };
 357 MODULE_DEVICE_TABLE(i2c, tps65090_id_table);
 358
 359 static struct i2c_driver tps65090_driver = {
 360         .driver = {
 361                 .name   = "tps65090",
 362                 .owner  = THIS_MODULE,
 363         },
 364         .probe          = tps65090_i2c_probe,
 365         .remove         = __devexit_p(tps65090_i2c_remove),
 366 #ifdef CONFIG_PM
 367         .suspend        = tps65090_i2c_suspend,
 368         .resume         = tps65090_i2c_resume,
 369 #endif
 370         .id_table       = tps65090_id_table,
 371 };
 372
 373 static int __init tps65090_init(void)
 374 {
 375         return i2c_add_driver(&tps65090_driver);
 376 }
 377 subsys_initcall(tps65090_init);
 378
 379 static void __exit tps65090_exit(void)
 380 {
 381         i2c_del_driver(&tps65090_driver);
 382 }
 383 module_exit(tps65090_exit);
 384
 385 MODULE_DESCRIPTION("TPS65090 core driver");
 386 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
 387 MODULE_LICENSE("GPL v2");