drivers/mfd/max8907.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * max8907.c - mfd driver for MAX8907
   4  *
   5  * Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
   6  * Copyright (C) 2010-2012, NVIDIA CORPORATION. All rights reserved.
   7  */
   8
   9 #include <linux/err.h>
  10 #include <linux/i2c.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/irq.h>
  14 #include <linux/mfd/core.h>
  15 #include <linux/mfd/max8907.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/regmap.h>
  19 #include <linux/slab.h>
  20
  21 static const struct mfd_cell max8907_cells[] = {
  22         { .name = "max8907-regulator", },
  23         { .name = "max8907-rtc", },
  24 };
  25
  26 static bool max8907_gen_is_volatile_reg(struct device *dev, unsigned int reg)
  27 {
  28         switch (reg) {
  29         case MAX8907_REG_ON_OFF_IRQ1:
  30         case MAX8907_REG_ON_OFF_STAT:
  31         case MAX8907_REG_ON_OFF_IRQ2:
  32         case MAX8907_REG_CHG_IRQ1:
  33         case MAX8907_REG_CHG_IRQ2:
  34         case MAX8907_REG_CHG_STAT:
  35                 return true;
  36         default:
  37                 return false;
  38         }
  39 }
  40
  41 static bool max8907_gen_is_precious_reg(struct device *dev, unsigned int reg)
  42 {
  43         switch (reg) {
  44         case MAX8907_REG_ON_OFF_IRQ1:
  45         case MAX8907_REG_ON_OFF_IRQ2:
  46         case MAX8907_REG_CHG_IRQ1:
  47         case MAX8907_REG_CHG_IRQ2:
  48                 return true;
  49         default:
  50                 return false;
  51         }
  52 }
  53
  54 static bool max8907_gen_is_writeable_reg(struct device *dev, unsigned int reg)
  55 {
  56         return !max8907_gen_is_volatile_reg(dev, reg);
  57 }
  58
  59 static const struct regmap_config max8907_regmap_gen_config = {
  60         .reg_bits = 8,
  61         .val_bits = 8,
  62         .volatile_reg = max8907_gen_is_volatile_reg,
  63         .precious_reg = max8907_gen_is_precious_reg,
  64         .writeable_reg = max8907_gen_is_writeable_reg,
  65         .max_register = MAX8907_REG_LDO20VOUT,
  66         .cache_type = REGCACHE_MAPLE,
  67 };
  68
  69 static bool max8907_rtc_is_volatile_reg(struct device *dev, unsigned int reg)
  70 {
  71         if (reg <= MAX8907_REG_RTC_YEAR2)
  72                 return true;
  73
  74         switch (reg) {
  75         case MAX8907_REG_RTC_STATUS:
  76         case MAX8907_REG_RTC_IRQ:
  77                 return true;
  78         default:
  79                 return false;
  80         }
  81 }
  82
  83 static bool max8907_rtc_is_precious_reg(struct device *dev, unsigned int reg)
  84 {
  85         switch (reg) {
  86         case MAX8907_REG_RTC_IRQ:
  87                 return true;
  88         default:
  89                 return false;
  90         }
  91 }
  92
  93 static bool max8907_rtc_is_writeable_reg(struct device *dev, unsigned int reg)
  94 {
  95         switch (reg) {
  96         case MAX8907_REG_RTC_STATUS:
  97         case MAX8907_REG_RTC_IRQ:
  98                 return false;
  99         default:
 100                 return true;
 101         }
 102 }
 103
 104 static const struct regmap_config max8907_regmap_rtc_config = {
 105         .reg_bits = 8,
 106         .val_bits = 8,
 107         .volatile_reg = max8907_rtc_is_volatile_reg,
 108         .precious_reg = max8907_rtc_is_precious_reg,
 109         .writeable_reg = max8907_rtc_is_writeable_reg,
 110         .max_register = MAX8907_REG_MPL_CNTL,
 111         .cache_type = REGCACHE_MAPLE,
 112 };
 113
 114 static const struct regmap_irq max8907_chg_irqs[] = {
 115         { .reg_offset = 0, .mask = 1 << 0, },
 116         { .reg_offset = 0, .mask = 1 << 1, },
 117         { .reg_offset = 0, .mask = 1 << 2, },
 118         { .reg_offset = 1, .mask = 1 << 0, },
 119         { .reg_offset = 1, .mask = 1 << 1, },
 120         { .reg_offset = 1, .mask = 1 << 2, },
 121         { .reg_offset = 1, .mask = 1 << 3, },
 122         { .reg_offset = 1, .mask = 1 << 4, },
 123         { .reg_offset = 1, .mask = 1 << 5, },
 124         { .reg_offset = 1, .mask = 1 << 6, },
 125         { .reg_offset = 1, .mask = 1 << 7, },
 126 };
 127
 128 static const struct regmap_irq_chip max8907_chg_irq_chip = {
 129         .name = "max8907 chg",
 130         .status_base = MAX8907_REG_CHG_IRQ1,
 131         .mask_base = MAX8907_REG_CHG_IRQ1_MASK,
 132         .wake_base = MAX8907_REG_CHG_IRQ1_MASK,
 133         .irq_reg_stride = MAX8907_REG_CHG_IRQ2 - MAX8907_REG_CHG_IRQ1,
 134         .num_regs = 2,
 135         .irqs = max8907_chg_irqs,
 136         .num_irqs = ARRAY_SIZE(max8907_chg_irqs),
 137 };
 138
 139 static const struct regmap_irq max8907_on_off_irqs[] = {
 140         { .reg_offset = 0, .mask = 1 << 0, },
 141         { .reg_offset = 0, .mask = 1 << 1, },
 142         { .reg_offset = 0, .mask = 1 << 2, },
 143         { .reg_offset = 0, .mask = 1 << 3, },
 144         { .reg_offset = 0, .mask = 1 << 4, },
 145         { .reg_offset = 0, .mask = 1 << 5, },
 146         { .reg_offset = 0, .mask = 1 << 6, },
 147         { .reg_offset = 0, .mask = 1 << 7, },
 148         { .reg_offset = 1, .mask = 1 << 0, },
 149         { .reg_offset = 1, .mask = 1 << 1, },
 150 };
 151
 152 static const struct regmap_irq_chip max8907_on_off_irq_chip = {
 153         .name = "max8907 on_off",
 154         .status_base = MAX8907_REG_ON_OFF_IRQ1,
 155         .mask_base = MAX8907_REG_ON_OFF_IRQ1_MASK,
 156         .irq_reg_stride = MAX8907_REG_ON_OFF_IRQ2 - MAX8907_REG_ON_OFF_IRQ1,
 157         .num_regs = 2,
 158         .irqs = max8907_on_off_irqs,
 159         .num_irqs = ARRAY_SIZE(max8907_on_off_irqs),
 160 };
 161
 162 static const struct regmap_irq max8907_rtc_irqs[] = {
 163         { .reg_offset = 0, .mask = 1 << 2, },
 164         { .reg_offset = 0, .mask = 1 << 3, },
 165 };
 166
 167 static const struct regmap_irq_chip max8907_rtc_irq_chip = {
 168         .name = "max8907 rtc",
 169         .status_base = MAX8907_REG_RTC_IRQ,
 170         .mask_base = MAX8907_REG_RTC_IRQ_MASK,
 171         .num_regs = 1,
 172         .irqs = max8907_rtc_irqs,
 173         .num_irqs = ARRAY_SIZE(max8907_rtc_irqs),
 174 };
 175
 176 static struct max8907 *max8907_pm_off;
 177 static void max8907_power_off(void)
 178 {
 179         regmap_update_bits(max8907_pm_off->regmap_gen, MAX8907_REG_RESET_CNFG,
 180                         MAX8907_MASK_POWER_OFF, MAX8907_MASK_POWER_OFF);
 181 }
 182
 183 static int max8907_i2c_probe(struct i2c_client *i2c)
 184 {
 185         struct max8907 *max8907;
 186         int ret;
 187         struct max8907_platform_data *pdata = dev_get_platdata(&i2c->dev);
 188         bool pm_off = false;
 189
 190         if (pdata)
 191                 pm_off = pdata->pm_off;
 192         else if (i2c->dev.of_node)
 193                 pm_off = of_property_read_bool(i2c->dev.of_node,
 194                                         "maxim,system-power-controller");
 195
 196         max8907 = devm_kzalloc(&i2c->dev, sizeof(struct max8907), GFP_KERNEL);
 197         if (!max8907) {
 198                 ret = -ENOMEM;
 199                 goto err_alloc_drvdata;
 200         }
 201
 202         max8907->dev = &i2c->dev;
 203         max8907->i2c_gen = i2c;
 204         i2c_set_clientdata(i2c, max8907);
 205         max8907->regmap_gen = devm_regmap_init_i2c(i2c,
 206                                                 &max8907_regmap_gen_config);
 207         if (IS_ERR(max8907->regmap_gen)) {
 208                 ret = PTR_ERR(max8907->regmap_gen);
 209                 dev_err(&i2c->dev, "gen regmap init failed: %d\n", ret);
 210                 goto err_regmap_gen;
 211         }
 212
 213         max8907->i2c_rtc = i2c_new_dummy_device(i2c->adapter, MAX8907_RTC_I2C_ADDR);
 214         if (IS_ERR(max8907->i2c_rtc)) {
 215                 ret = PTR_ERR(max8907->i2c_rtc);
 216                 goto err_dummy_rtc;
 217         }
 218         i2c_set_clientdata(max8907->i2c_rtc, max8907);
 219         max8907->regmap_rtc = devm_regmap_init_i2c(max8907->i2c_rtc,
 220                                                 &max8907_regmap_rtc_config);
 221         if (IS_ERR(max8907->regmap_rtc)) {
 222                 ret = PTR_ERR(max8907->regmap_rtc);
 223                 dev_err(&i2c->dev, "rtc regmap init failed: %d\n", ret);
 224                 goto err_regmap_rtc;
 225         }
 226
 227         ret = regmap_add_irq_chip(max8907->regmap_gen, max8907->i2c_gen->irq,
 228                                   IRQF_ONESHOT | IRQF_SHARED,
 229                                   -1, &max8907_chg_irq_chip,
 230                                   &max8907->irqc_chg);
 231         if (ret != 0) {
 232                 dev_err(&i2c->dev, "failed to add chg irq chip: %d\n", ret);
 233                 goto err_irqc_chg;
 234         }
 235         ret = regmap_add_irq_chip(max8907->regmap_gen, max8907->i2c_gen->irq,
 236                                   IRQF_ONESHOT | IRQF_SHARED, -1,
 237                                   &max8907_on_off_irq_chip,
 238                                   &max8907->irqc_on_off);
 239         if (ret != 0) {
 240                 dev_err(&i2c->dev, "failed to add on off irq chip: %d\n", ret);
 241                 goto err_irqc_on_off;
 242         }
 243         ret = regmap_add_irq_chip(max8907->regmap_rtc, max8907->i2c_gen->irq,
 244                                   IRQF_ONESHOT | IRQF_SHARED, -1,
 245                                   &max8907_rtc_irq_chip,
 246                                   &max8907->irqc_rtc);
 247         if (ret != 0) {
 248                 dev_err(&i2c->dev, "failed to add rtc irq chip: %d\n", ret);
 249                 goto err_irqc_rtc;
 250         }
 251
 252         ret = mfd_add_devices(max8907->dev, -1, max8907_cells,
 253                               ARRAY_SIZE(max8907_cells), NULL, 0, NULL);
 254         if (ret != 0) {
 255                 dev_err(&i2c->dev, "failed to add MFD devices %d\n", ret);
 256                 goto err_add_devices;
 257         }
 258
 259         if (pm_off && !pm_power_off) {
 260                 max8907_pm_off = max8907;
 261                 pm_power_off = max8907_power_off;
 262         }
 263
 264         return 0;
 265
 266 err_add_devices:
 267         regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_rtc);
 268 err_irqc_rtc:
 269         regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_on_off);
 270 err_irqc_on_off:
 271         regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_chg);
 272 err_irqc_chg:
 273 err_regmap_rtc:
 274         i2c_unregister_device(max8907->i2c_rtc);
 275 err_dummy_rtc:
 276 err_regmap_gen:
 277 err_alloc_drvdata:
 278         return ret;
 279 }
 280
 281 static void max8907_i2c_remove(struct i2c_client *i2c)
 282 {
 283         struct max8907 *max8907 = i2c_get_clientdata(i2c);
 284
 285         mfd_remove_devices(max8907->dev);
 286
 287         regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_rtc);
 288         regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_on_off);
 289         regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_chg);
 290
 291         i2c_unregister_device(max8907->i2c_rtc);
 292 }
 293
 294 #ifdef CONFIG_OF
 295 static const struct of_device_id max8907_of_match[] = {
 296         { .compatible = "maxim,max8907" },
 297         { },
 298 };
 299 MODULE_DEVICE_TABLE(of, max8907_of_match);
 300 #endif
 301
 302 static const struct i2c_device_id max8907_i2c_id[] = {
 303         { "max8907" },
 304         {}
 305 };
 306 MODULE_DEVICE_TABLE(i2c, max8907_i2c_id);
 307
 308 static struct i2c_driver max8907_i2c_driver = {
 309         .driver = {
 310                 .name = "max8907",
 311                 .of_match_table = of_match_ptr(max8907_of_match),
 312         },
 313         .probe = max8907_i2c_probe,
 314         .remove = max8907_i2c_remove,
 315         .id_table = max8907_i2c_id,
 316 };
 317
 318 static int __init max8907_i2c_init(void)
 319 {
 320         int ret = -ENODEV;
 321
 322         ret = i2c_add_driver(&max8907_i2c_driver);
 323         if (ret != 0)
 324                 pr_err("Failed to register I2C driver: %d\n", ret);
 325
 326         return ret;
 327 }
 328 subsys_initcall(max8907_i2c_init);
 329
 330 static void __exit max8907_i2c_exit(void)
 331 {
 332         i2c_del_driver(&max8907_i2c_driver);
 333 }
 334 module_exit(max8907_i2c_exit);
 335
 336 MODULE_DESCRIPTION("MAX8907 multi-function core driver");
 337 MODULE_AUTHOR("Gyungoh Yoo <jack.yoo@maxim-ic.com>");
 338 MODULE_LICENSE("GPL v2");