Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * max8907.c - mfd driver for MAX8907
0004  *
0005  * Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
0006  * Copyright (C) 2010-2012, NVIDIA CORPORATION. All rights reserved.
0007  */
0008 
0009 #include <linux/err.h>
0010 #include <linux/i2c.h>
0011 #include <linux/init.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/irq.h>
0014 #include <linux/mfd/core.h>
0015 #include <linux/mfd/max8907.h>
0016 #include <linux/module.h>
0017 #include <linux/of.h>
0018 #include <linux/of_device.h>
0019 #include <linux/regmap.h>
0020 #include <linux/slab.h>
0021 
0022 static const struct mfd_cell max8907_cells[] = {
0023     { .name = "max8907-regulator", },
0024     { .name = "max8907-rtc", },
0025 };
0026 
0027 static bool max8907_gen_is_volatile_reg(struct device *dev, unsigned int reg)
0028 {
0029     switch (reg) {
0030     case MAX8907_REG_ON_OFF_IRQ1:
0031     case MAX8907_REG_ON_OFF_STAT:
0032     case MAX8907_REG_ON_OFF_IRQ2:
0033     case MAX8907_REG_CHG_IRQ1:
0034     case MAX8907_REG_CHG_IRQ2:
0035     case MAX8907_REG_CHG_STAT:
0036         return true;
0037     default:
0038         return false;
0039     }
0040 }
0041 
0042 static bool max8907_gen_is_precious_reg(struct device *dev, unsigned int reg)
0043 {
0044     switch (reg) {
0045     case MAX8907_REG_ON_OFF_IRQ1:
0046     case MAX8907_REG_ON_OFF_IRQ2:
0047     case MAX8907_REG_CHG_IRQ1:
0048     case MAX8907_REG_CHG_IRQ2:
0049         return true;
0050     default:
0051         return false;
0052     }
0053 }
0054 
0055 static bool max8907_gen_is_writeable_reg(struct device *dev, unsigned int reg)
0056 {
0057     return !max8907_gen_is_volatile_reg(dev, reg);
0058 }
0059 
0060 static const struct regmap_config max8907_regmap_gen_config = {
0061     .reg_bits = 8,
0062     .val_bits = 8,
0063     .volatile_reg = max8907_gen_is_volatile_reg,
0064     .precious_reg = max8907_gen_is_precious_reg,
0065     .writeable_reg = max8907_gen_is_writeable_reg,
0066     .max_register = MAX8907_REG_LDO20VOUT,
0067     .cache_type = REGCACHE_RBTREE,
0068 };
0069 
0070 static bool max8907_rtc_is_volatile_reg(struct device *dev, unsigned int reg)
0071 {
0072     if (reg <= MAX8907_REG_RTC_YEAR2)
0073         return true;
0074 
0075     switch (reg) {
0076     case MAX8907_REG_RTC_STATUS:
0077     case MAX8907_REG_RTC_IRQ:
0078         return true;
0079     default:
0080         return false;
0081     }
0082 }
0083 
0084 static bool max8907_rtc_is_precious_reg(struct device *dev, unsigned int reg)
0085 {
0086     switch (reg) {
0087     case MAX8907_REG_RTC_IRQ:
0088         return true;
0089     default:
0090         return false;
0091     }
0092 }
0093 
0094 static bool max8907_rtc_is_writeable_reg(struct device *dev, unsigned int reg)
0095 {
0096     switch (reg) {
0097     case MAX8907_REG_RTC_STATUS:
0098     case MAX8907_REG_RTC_IRQ:
0099         return false;
0100     default:
0101         return true;
0102     }
0103 }
0104 
0105 static const struct regmap_config max8907_regmap_rtc_config = {
0106     .reg_bits = 8,
0107     .val_bits = 8,
0108     .volatile_reg = max8907_rtc_is_volatile_reg,
0109     .precious_reg = max8907_rtc_is_precious_reg,
0110     .writeable_reg = max8907_rtc_is_writeable_reg,
0111     .max_register = MAX8907_REG_MPL_CNTL,
0112     .cache_type = REGCACHE_RBTREE,
0113 };
0114 
0115 static const struct regmap_irq max8907_chg_irqs[] = {
0116     { .reg_offset = 0, .mask = 1 << 0, },
0117     { .reg_offset = 0, .mask = 1 << 1, },
0118     { .reg_offset = 0, .mask = 1 << 2, },
0119     { .reg_offset = 1, .mask = 1 << 0, },
0120     { .reg_offset = 1, .mask = 1 << 1, },
0121     { .reg_offset = 1, .mask = 1 << 2, },
0122     { .reg_offset = 1, .mask = 1 << 3, },
0123     { .reg_offset = 1, .mask = 1 << 4, },
0124     { .reg_offset = 1, .mask = 1 << 5, },
0125     { .reg_offset = 1, .mask = 1 << 6, },
0126     { .reg_offset = 1, .mask = 1 << 7, },
0127 };
0128 
0129 static const struct regmap_irq_chip max8907_chg_irq_chip = {
0130     .name = "max8907 chg",
0131     .status_base = MAX8907_REG_CHG_IRQ1,
0132     .mask_base = MAX8907_REG_CHG_IRQ1_MASK,
0133     .wake_base = MAX8907_REG_CHG_IRQ1_MASK,
0134     .irq_reg_stride = MAX8907_REG_CHG_IRQ2 - MAX8907_REG_CHG_IRQ1,
0135     .num_regs = 2,
0136     .irqs = max8907_chg_irqs,
0137     .num_irqs = ARRAY_SIZE(max8907_chg_irqs),
0138 };
0139 
0140 static const struct regmap_irq max8907_on_off_irqs[] = {
0141     { .reg_offset = 0, .mask = 1 << 0, },
0142     { .reg_offset = 0, .mask = 1 << 1, },
0143     { .reg_offset = 0, .mask = 1 << 2, },
0144     { .reg_offset = 0, .mask = 1 << 3, },
0145     { .reg_offset = 0, .mask = 1 << 4, },
0146     { .reg_offset = 0, .mask = 1 << 5, },
0147     { .reg_offset = 0, .mask = 1 << 6, },
0148     { .reg_offset = 0, .mask = 1 << 7, },
0149     { .reg_offset = 1, .mask = 1 << 0, },
0150     { .reg_offset = 1, .mask = 1 << 1, },
0151 };
0152 
0153 static const struct regmap_irq_chip max8907_on_off_irq_chip = {
0154     .name = "max8907 on_off",
0155     .status_base = MAX8907_REG_ON_OFF_IRQ1,
0156     .mask_base = MAX8907_REG_ON_OFF_IRQ1_MASK,
0157     .irq_reg_stride = MAX8907_REG_ON_OFF_IRQ2 - MAX8907_REG_ON_OFF_IRQ1,
0158     .num_regs = 2,
0159     .irqs = max8907_on_off_irqs,
0160     .num_irqs = ARRAY_SIZE(max8907_on_off_irqs),
0161 };
0162 
0163 static const struct regmap_irq max8907_rtc_irqs[] = {
0164     { .reg_offset = 0, .mask = 1 << 2, },
0165     { .reg_offset = 0, .mask = 1 << 3, },
0166 };
0167 
0168 static const struct regmap_irq_chip max8907_rtc_irq_chip = {
0169     .name = "max8907 rtc",
0170     .status_base = MAX8907_REG_RTC_IRQ,
0171     .mask_base = MAX8907_REG_RTC_IRQ_MASK,
0172     .num_regs = 1,
0173     .irqs = max8907_rtc_irqs,
0174     .num_irqs = ARRAY_SIZE(max8907_rtc_irqs),
0175 };
0176 
0177 static struct max8907 *max8907_pm_off;
0178 static void max8907_power_off(void)
0179 {
0180     regmap_update_bits(max8907_pm_off->regmap_gen, MAX8907_REG_RESET_CNFG,
0181             MAX8907_MASK_POWER_OFF, MAX8907_MASK_POWER_OFF);
0182 }
0183 
0184 static int max8907_i2c_probe(struct i2c_client *i2c,
0185                        const struct i2c_device_id *id)
0186 {
0187     struct max8907 *max8907;
0188     int ret;
0189     struct max8907_platform_data *pdata = dev_get_platdata(&i2c->dev);
0190     bool pm_off = false;
0191 
0192     if (pdata)
0193         pm_off = pdata->pm_off;
0194     else if (i2c->dev.of_node)
0195         pm_off = of_property_read_bool(i2c->dev.of_node,
0196                     "maxim,system-power-controller");
0197 
0198     max8907 = devm_kzalloc(&i2c->dev, sizeof(struct max8907), GFP_KERNEL);
0199     if (!max8907) {
0200         ret = -ENOMEM;
0201         goto err_alloc_drvdata;
0202     }
0203 
0204     max8907->dev = &i2c->dev;
0205     dev_set_drvdata(max8907->dev, max8907);
0206 
0207     max8907->i2c_gen = i2c;
0208     i2c_set_clientdata(i2c, max8907);
0209     max8907->regmap_gen = devm_regmap_init_i2c(i2c,
0210                         &max8907_regmap_gen_config);
0211     if (IS_ERR(max8907->regmap_gen)) {
0212         ret = PTR_ERR(max8907->regmap_gen);
0213         dev_err(&i2c->dev, "gen regmap init failed: %d\n", ret);
0214         goto err_regmap_gen;
0215     }
0216 
0217     max8907->i2c_rtc = i2c_new_dummy_device(i2c->adapter, MAX8907_RTC_I2C_ADDR);
0218     if (IS_ERR(max8907->i2c_rtc)) {
0219         ret = PTR_ERR(max8907->i2c_rtc);
0220         goto err_dummy_rtc;
0221     }
0222     i2c_set_clientdata(max8907->i2c_rtc, max8907);
0223     max8907->regmap_rtc = devm_regmap_init_i2c(max8907->i2c_rtc,
0224                         &max8907_regmap_rtc_config);
0225     if (IS_ERR(max8907->regmap_rtc)) {
0226         ret = PTR_ERR(max8907->regmap_rtc);
0227         dev_err(&i2c->dev, "rtc regmap init failed: %d\n", ret);
0228         goto err_regmap_rtc;
0229     }
0230 
0231     ret = regmap_add_irq_chip(max8907->regmap_gen, max8907->i2c_gen->irq,
0232                   IRQF_ONESHOT | IRQF_SHARED,
0233                   -1, &max8907_chg_irq_chip,
0234                   &max8907->irqc_chg);
0235     if (ret != 0) {
0236         dev_err(&i2c->dev, "failed to add chg irq chip: %d\n", ret);
0237         goto err_irqc_chg;
0238     }
0239     ret = regmap_add_irq_chip(max8907->regmap_gen, max8907->i2c_gen->irq,
0240                   IRQF_ONESHOT | IRQF_SHARED, -1,
0241                   &max8907_on_off_irq_chip,
0242                   &max8907->irqc_on_off);
0243     if (ret != 0) {
0244         dev_err(&i2c->dev, "failed to add on off irq chip: %d\n", ret);
0245         goto err_irqc_on_off;
0246     }
0247     ret = regmap_add_irq_chip(max8907->regmap_rtc, max8907->i2c_gen->irq,
0248                   IRQF_ONESHOT | IRQF_SHARED, -1,
0249                   &max8907_rtc_irq_chip,
0250                   &max8907->irqc_rtc);
0251     if (ret != 0) {
0252         dev_err(&i2c->dev, "failed to add rtc irq chip: %d\n", ret);
0253         goto err_irqc_rtc;
0254     }
0255 
0256     ret = mfd_add_devices(max8907->dev, -1, max8907_cells,
0257                   ARRAY_SIZE(max8907_cells), NULL, 0, NULL);
0258     if (ret != 0) {
0259         dev_err(&i2c->dev, "failed to add MFD devices %d\n", ret);
0260         goto err_add_devices;
0261     }
0262 
0263     if (pm_off && !pm_power_off) {
0264         max8907_pm_off = max8907;
0265         pm_power_off = max8907_power_off;
0266     }
0267 
0268     return 0;
0269 
0270 err_add_devices:
0271     regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_rtc);
0272 err_irqc_rtc:
0273     regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_on_off);
0274 err_irqc_on_off:
0275     regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_chg);
0276 err_irqc_chg:
0277 err_regmap_rtc:
0278     i2c_unregister_device(max8907->i2c_rtc);
0279 err_dummy_rtc:
0280 err_regmap_gen:
0281 err_alloc_drvdata:
0282     return ret;
0283 }
0284 
0285 static int max8907_i2c_remove(struct i2c_client *i2c)
0286 {
0287     struct max8907 *max8907 = i2c_get_clientdata(i2c);
0288 
0289     mfd_remove_devices(max8907->dev);
0290 
0291     regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_rtc);
0292     regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_on_off);
0293     regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_chg);
0294 
0295     i2c_unregister_device(max8907->i2c_rtc);
0296 
0297     return 0;
0298 }
0299 
0300 #ifdef CONFIG_OF
0301 static const struct of_device_id max8907_of_match[] = {
0302     { .compatible = "maxim,max8907" },
0303     { },
0304 };
0305 MODULE_DEVICE_TABLE(of, max8907_of_match);
0306 #endif
0307 
0308 static const struct i2c_device_id max8907_i2c_id[] = {
0309     {"max8907", 0},
0310     {}
0311 };
0312 MODULE_DEVICE_TABLE(i2c, max8907_i2c_id);
0313 
0314 static struct i2c_driver max8907_i2c_driver = {
0315     .driver = {
0316         .name = "max8907",
0317         .of_match_table = of_match_ptr(max8907_of_match),
0318     },
0319     .probe = max8907_i2c_probe,
0320     .remove = max8907_i2c_remove,
0321     .id_table = max8907_i2c_id,
0322 };
0323 
0324 static int __init max8907_i2c_init(void)
0325 {
0326     int ret = -ENODEV;
0327 
0328     ret = i2c_add_driver(&max8907_i2c_driver);
0329     if (ret != 0)
0330         pr_err("Failed to register I2C driver: %d\n", ret);
0331 
0332     return ret;
0333 }
0334 subsys_initcall(max8907_i2c_init);
0335 
0336 static void __exit max8907_i2c_exit(void)
0337 {
0338     i2c_del_driver(&max8907_i2c_driver);
0339 }
0340 module_exit(max8907_i2c_exit);
0341 
0342 MODULE_DESCRIPTION("MAX8907 multi-function core driver");
0343 MODULE_AUTHOR("Gyungoh Yoo <jack.yoo@maxim-ic.com>");
0344 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!