1 /* 2 * max14577.c - mfd core driver for the Maxim 14577 3 * 4 * Copyright (C) 2013 Samsung Electrnoics 5 * Chanwoo Choi <cw00.choi@samsung.com> 6 * Krzysztof Kozlowski <k.kozlowski@samsung.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * This driver is based on max8997.c 19 */ 20 21 #include <linux/err.h> 22 #include <linux/module.h> 23 #include <linux/interrupt.h> 24 #include <linux/mfd/core.h> 25 #include <linux/mfd/max14577.h> 26 #include <linux/mfd/max14577-private.h> 27 28 static struct mfd_cell max14577_devs[] = { 29 { 30 .name = "max14577-muic", 31 .of_compatible = "maxim,max14577-muic", 32 }, 33 { 34 .name = "max14577-regulator", 35 .of_compatible = "maxim,max14577-regulator", 36 }, 37 { .name = "max14577-charger", }, 38 }; 39 40 static bool max14577_muic_volatile_reg(struct device *dev, unsigned int reg) 41 { 42 switch (reg) { 43 case MAX14577_REG_INT1 ... MAX14577_REG_STATUS3: 44 return true; 45 default: 46 break; 47 } 48 return false; 49 } 50 51 static const struct regmap_config max14577_muic_regmap_config = { 52 .reg_bits = 8, 53 .val_bits = 8, 54 .volatile_reg = max14577_muic_volatile_reg, 55 .max_register = MAX14577_REG_END, 56 }; 57 58 static const struct regmap_irq max14577_irqs[] = { 59 /* INT1 interrupts */ 60 { .reg_offset = 0, .mask = INT1_ADC_MASK, }, 61 { .reg_offset = 0, .mask = INT1_ADCLOW_MASK, }, 62 { .reg_offset = 0, .mask = INT1_ADCERR_MASK, }, 63 /* INT2 interrupts */ 64 { .reg_offset = 1, .mask = INT2_CHGTYP_MASK, }, 65 { .reg_offset = 1, .mask = INT2_CHGDETRUN_MASK, }, 66 { .reg_offset = 1, .mask = INT2_DCDTMR_MASK, }, 67 { .reg_offset = 1, .mask = INT2_DBCHG_MASK, }, 68 { .reg_offset = 1, .mask = INT2_VBVOLT_MASK, }, 69 /* INT3 interrupts */ 70 { .reg_offset = 2, .mask = INT3_EOC_MASK, }, 71 { .reg_offset = 2, .mask = INT3_CGMBC_MASK, }, 72 { .reg_offset = 2, .mask = INT3_OVP_MASK, }, 73 { .reg_offset = 2, .mask = INT3_MBCCHGERR_MASK, }, 74 }; 75 76 static const struct regmap_irq_chip max14577_irq_chip = { 77 .name = "max14577", 78 .status_base = MAX14577_REG_INT1, 79 .mask_base = MAX14577_REG_INTMASK1, 80 .mask_invert = 1, 81 .num_regs = 3, 82 .irqs = max14577_irqs, 83 .num_irqs = ARRAY_SIZE(max14577_irqs), 84 }; 85 86 static int max14577_i2c_probe(struct i2c_client *i2c, 87 const struct i2c_device_id *id) 88 { 89 struct max14577 *max14577; 90 struct max14577_platform_data *pdata = dev_get_platdata(&i2c->dev); 91 struct device_node *np = i2c->dev.of_node; 92 u8 reg_data; 93 int ret = 0; 94 95 if (np) { 96 pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL); 97 if (!pdata) 98 return -ENOMEM; 99 i2c->dev.platform_data = pdata; 100 } 101 102 if (!pdata) { 103 dev_err(&i2c->dev, "No platform data found.\n"); 104 return -EINVAL; 105 } 106 107 max14577 = devm_kzalloc(&i2c->dev, sizeof(*max14577), GFP_KERNEL); 108 if (!max14577) 109 return -ENOMEM; 110 111 i2c_set_clientdata(i2c, max14577); 112 max14577->dev = &i2c->dev; 113 max14577->i2c = i2c; 114 max14577->irq = i2c->irq; 115 116 max14577->regmap = devm_regmap_init_i2c(i2c, 117 &max14577_muic_regmap_config); 118 if (IS_ERR(max14577->regmap)) { 119 ret = PTR_ERR(max14577->regmap); 120 dev_err(max14577->dev, "Failed to allocate register map: %d\n", 121 ret); 122 return ret; 123 } 124 125 ret = max14577_read_reg(max14577->regmap, MAX14577_REG_DEVICEID, 126 ®_data); 127 if (ret) { 128 dev_err(max14577->dev, "Device not found on this channel: %d\n", 129 ret); 130 return ret; 131 } 132 max14577->vendor_id = ((reg_data & DEVID_VENDORID_MASK) >> 133 DEVID_VENDORID_SHIFT); 134 max14577->device_id = ((reg_data & DEVID_DEVICEID_MASK) >> 135 DEVID_DEVICEID_SHIFT); 136 dev_info(max14577->dev, "Device ID: 0x%x, vendor: 0x%x\n", 137 max14577->device_id, max14577->vendor_id); 138 139 ret = regmap_add_irq_chip(max14577->regmap, max14577->irq, 140 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 0, 141 &max14577_irq_chip, 142 &max14577->irq_data); 143 if (ret != 0) { 144 dev_err(&i2c->dev, "Failed to request IRQ %d: %d\n", 145 max14577->irq, ret); 146 return ret; 147 } 148 149 ret = mfd_add_devices(max14577->dev, -1, max14577_devs, 150 ARRAY_SIZE(max14577_devs), NULL, 0, 151 regmap_irq_get_domain(max14577->irq_data)); 152 if (ret < 0) 153 goto err_mfd; 154 155 device_init_wakeup(max14577->dev, 1); 156 157 return 0; 158 159 err_mfd: 160 regmap_del_irq_chip(max14577->irq, max14577->irq_data); 161 162 return ret; 163 } 164 165 static int max14577_i2c_remove(struct i2c_client *i2c) 166 { 167 struct max14577 *max14577 = i2c_get_clientdata(i2c); 168 169 mfd_remove_devices(max14577->dev); 170 regmap_del_irq_chip(max14577->irq, max14577->irq_data); 171 172 return 0; 173 } 174 175 static const struct i2c_device_id max14577_i2c_id[] = { 176 { "max14577", 0 }, 177 { } 178 }; 179 MODULE_DEVICE_TABLE(i2c, max14577_i2c_id); 180 181 #ifdef CONFIG_PM_SLEEP 182 static int max14577_suspend(struct device *dev) 183 { 184 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); 185 struct max14577 *max14577 = i2c_get_clientdata(i2c); 186 187 if (device_may_wakeup(dev)) { 188 enable_irq_wake(max14577->irq); 189 /* 190 * MUIC IRQ must be disabled during suspend if this is 191 * a wake up source because it will be handled before 192 * resuming I2C. 193 * 194 * When device is woken up from suspend (e.g. by ADC change), 195 * an interrupt occurs before resuming I2C bus controller. 196 * Interrupt handler tries to read registers but this read 197 * will fail because I2C is still suspended. 198 */ 199 disable_irq(max14577->irq); 200 } 201 202 return 0; 203 } 204 205 static int max14577_resume(struct device *dev) 206 { 207 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); 208 struct max14577 *max14577 = i2c_get_clientdata(i2c); 209 210 if (device_may_wakeup(dev)) { 211 disable_irq_wake(max14577->irq); 212 enable_irq(max14577->irq); 213 } 214 215 return 0; 216 } 217 #endif /* CONFIG_PM_SLEEP */ 218 219 static struct of_device_id max14577_dt_match[] = { 220 { .compatible = "maxim,max14577", }, 221 {}, 222 }; 223 224 static SIMPLE_DEV_PM_OPS(max14577_pm, max14577_suspend, max14577_resume); 225 226 static struct i2c_driver max14577_i2c_driver = { 227 .driver = { 228 .name = "max14577", 229 .owner = THIS_MODULE, 230 .pm = &max14577_pm, 231 .of_match_table = max14577_dt_match, 232 }, 233 .probe = max14577_i2c_probe, 234 .remove = max14577_i2c_remove, 235 .id_table = max14577_i2c_id, 236 }; 237 238 static int __init max14577_i2c_init(void) 239 { 240 return i2c_add_driver(&max14577_i2c_driver); 241 } 242 subsys_initcall(max14577_i2c_init); 243 244 static void __exit max14577_i2c_exit(void) 245 { 246 i2c_del_driver(&max14577_i2c_driver); 247 } 248 module_exit(max14577_i2c_exit); 249 250 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <k.kozlowski@samsung.com>"); 251 MODULE_DESCRIPTION("MAXIM 14577 multi-function core driver"); 252 MODULE_LICENSE("GPL"); 253