Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/mfd/max77686.c

  1 /*
  2  * max77686.c - mfd core driver for the Maxim 77686/802
  3  *
  4  * Copyright (C) 2012 Samsung Electronics
  5  * Chiwoong Byun <woong.byun@samsung.com>
  6  * Jonghwa Lee <jonghwa3.lee@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  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 21  *
 22  * This driver is based on max8997.c
 23  */
 24 
 25 #include <linux/export.h>
 26 #include <linux/slab.h>
 27 #include <linux/i2c.h>
 28 #include <linux/irq.h>
 29 #include <linux/interrupt.h>
 30 #include <linux/pm_runtime.h>
 31 #include <linux/module.h>
 32 #include <linux/mfd/core.h>
 33 #include <linux/mfd/max77686.h>
 34 #include <linux/mfd/max77686-private.h>
 35 #include <linux/err.h>
 36 #include <linux/of.h>
 37 
 38 static const struct mfd_cell max77686_devs[] = {
 39         { .name = "max77686-pmic", },
 40         { .name = "max77686-rtc", },
 41         { .name = "max77686-clk", },
 42 };
 43 
 44 static const struct mfd_cell max77802_devs[] = {
 45         { .name = "max77802-pmic", },
 46         { .name = "max77802-clk", },
 47         { .name = "max77802-rtc", },
 48 };
 49 
 50 static bool max77802_pmic_is_accessible_reg(struct device *dev,
 51                                             unsigned int reg)
 52 {
 53         return reg < MAX77802_REG_PMIC_END;
 54 }
 55 
 56 static bool max77802_rtc_is_accessible_reg(struct device *dev,
 57                                            unsigned int reg)
 58 {
 59         return (reg >= MAX77802_RTC_INT && reg < MAX77802_RTC_END);
 60 }
 61 
 62 static bool max77802_is_accessible_reg(struct device *dev, unsigned int reg)
 63 {
 64         return (max77802_pmic_is_accessible_reg(dev, reg) ||
 65                 max77802_rtc_is_accessible_reg(dev, reg));
 66 }
 67 
 68 static bool max77802_pmic_is_precious_reg(struct device *dev, unsigned int reg)
 69 {
 70         return (reg == MAX77802_REG_INTSRC || reg == MAX77802_REG_INT1 ||
 71                 reg == MAX77802_REG_INT2);
 72 }
 73 
 74 static bool max77802_rtc_is_precious_reg(struct device *dev, unsigned int reg)
 75 {
 76         return (reg == MAX77802_RTC_INT ||
 77                 reg == MAX77802_RTC_UPDATE0 ||
 78                 reg == MAX77802_RTC_UPDATE1);
 79 }
 80 
 81 static bool max77802_is_precious_reg(struct device *dev, unsigned int reg)
 82 {
 83         return (max77802_pmic_is_precious_reg(dev, reg) ||
 84                 max77802_rtc_is_precious_reg(dev, reg));
 85 }
 86 
 87 static bool max77802_pmic_is_volatile_reg(struct device *dev, unsigned int reg)
 88 {
 89         return (max77802_is_precious_reg(dev, reg) ||
 90                 reg == MAX77802_REG_STATUS1 || reg == MAX77802_REG_STATUS2 ||
 91                 reg == MAX77802_REG_PWRON);
 92 }
 93 
 94 static bool max77802_rtc_is_volatile_reg(struct device *dev, unsigned int reg)
 95 {
 96         return (max77802_rtc_is_precious_reg(dev, reg) ||
 97                 reg == MAX77802_RTC_SEC ||
 98                 reg == MAX77802_RTC_MIN ||
 99                 reg == MAX77802_RTC_HOUR ||
100                 reg == MAX77802_RTC_WEEKDAY ||
101                 reg == MAX77802_RTC_MONTH ||
102                 reg == MAX77802_RTC_YEAR ||
103                 reg == MAX77802_RTC_DATE);
104 }
105 
106 static bool max77802_is_volatile_reg(struct device *dev, unsigned int reg)
107 {
108         return (max77802_pmic_is_volatile_reg(dev, reg) ||
109                 max77802_rtc_is_volatile_reg(dev, reg));
110 }
111 
112 static const struct regmap_config max77686_regmap_config = {
113         .reg_bits = 8,
114         .val_bits = 8,
115 };
116 
117 static const struct regmap_config max77802_regmap_config = {
118         .reg_bits = 8,
119         .val_bits = 8,
120         .writeable_reg = max77802_is_accessible_reg,
121         .readable_reg = max77802_is_accessible_reg,
122         .precious_reg = max77802_is_precious_reg,
123         .volatile_reg = max77802_is_volatile_reg,
124         .name = "max77802-pmic",
125         .cache_type = REGCACHE_RBTREE,
126 };
127 
128 static const struct regmap_irq max77686_irqs[] = {
129         /* INT1 interrupts */
130         { .reg_offset = 0, .mask = MAX77686_INT1_PWRONF_MSK, },
131         { .reg_offset = 0, .mask = MAX77686_INT1_PWRONR_MSK, },
132         { .reg_offset = 0, .mask = MAX77686_INT1_JIGONBF_MSK, },
133         { .reg_offset = 0, .mask = MAX77686_INT1_JIGONBR_MSK, },
134         { .reg_offset = 0, .mask = MAX77686_INT1_ACOKBF_MSK, },
135         { .reg_offset = 0, .mask = MAX77686_INT1_ACOKBR_MSK, },
136         { .reg_offset = 0, .mask = MAX77686_INT1_ONKEY1S_MSK, },
137         { .reg_offset = 0, .mask = MAX77686_INT1_MRSTB_MSK, },
138         /* INT2 interrupts */
139         { .reg_offset = 1, .mask = MAX77686_INT2_140C_MSK, },
140         { .reg_offset = 1, .mask = MAX77686_INT2_120C_MSK, },
141 };
142 
143 static const struct regmap_irq_chip max77686_irq_chip = {
144         .name                   = "max77686-pmic",
145         .status_base            = MAX77686_REG_INT1,
146         .mask_base              = MAX77686_REG_INT1MSK,
147         .num_regs               = 2,
148         .irqs                   = max77686_irqs,
149         .num_irqs               = ARRAY_SIZE(max77686_irqs),
150 };
151 
152 static const struct regmap_irq_chip max77802_irq_chip = {
153         .name                   = "max77802-pmic",
154         .status_base            = MAX77802_REG_INT1,
155         .mask_base              = MAX77802_REG_INT1MSK,
156         .num_regs               = 2,
157         .irqs                   = max77686_irqs, /* same masks as 77686 */
158         .num_irqs               = ARRAY_SIZE(max77686_irqs),
159 };
160 
161 static const struct of_device_id max77686_pmic_dt_match[] = {
162         {
163                 .compatible = "maxim,max77686",
164                 .data = (void *)TYPE_MAX77686,
165         },
166         {
167                 .compatible = "maxim,max77802",
168                 .data = (void *)TYPE_MAX77802,
169         },
170         { },
171 };
172 MODULE_DEVICE_TABLE(of, max77686_pmic_dt_match);
173 
174 static int max77686_i2c_probe(struct i2c_client *i2c,
175                               const struct i2c_device_id *id)
176 {
177         struct max77686_dev *max77686 = NULL;
178         const struct of_device_id *match;
179         unsigned int data;
180         int ret = 0;
181         const struct regmap_config *config;
182         const struct regmap_irq_chip *irq_chip;
183         const struct mfd_cell *cells;
184         int n_devs;
185 
186         max77686 = devm_kzalloc(&i2c->dev,
187                                 sizeof(struct max77686_dev), GFP_KERNEL);
188         if (!max77686)
189                 return -ENOMEM;
190 
191         if (i2c->dev.of_node) {
192                 match = of_match_node(max77686_pmic_dt_match, i2c->dev.of_node);
193                 if (!match)
194                         return -EINVAL;
195 
196                 max77686->type = (unsigned long)match->data;
197         } else
198                 max77686->type = id->driver_data;
199 
200         i2c_set_clientdata(i2c, max77686);
201         max77686->dev = &i2c->dev;
202         max77686->i2c = i2c;
203 
204         max77686->irq = i2c->irq;
205 
206         if (max77686->type == TYPE_MAX77686) {
207                 config = &max77686_regmap_config;
208                 irq_chip = &max77686_irq_chip;
209                 cells =  max77686_devs;
210                 n_devs = ARRAY_SIZE(max77686_devs);
211         } else {
212                 config = &max77802_regmap_config;
213                 irq_chip = &max77802_irq_chip;
214                 cells =  max77802_devs;
215                 n_devs = ARRAY_SIZE(max77802_devs);
216         }
217 
218         max77686->regmap = devm_regmap_init_i2c(i2c, config);
219         if (IS_ERR(max77686->regmap)) {
220                 ret = PTR_ERR(max77686->regmap);
221                 dev_err(max77686->dev, "Failed to allocate register map: %d\n",
222                                 ret);
223                 return ret;
224         }
225 
226         ret = regmap_read(max77686->regmap, MAX77686_REG_DEVICE_ID, &data);
227         if (ret < 0) {
228                 dev_err(max77686->dev,
229                         "device not found on this channel (this is not an error)\n");
230                 return -ENODEV;
231         }
232 
233         ret = devm_regmap_add_irq_chip(&i2c->dev, max77686->regmap,
234                                        max77686->irq,
235                                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT |
236                                        IRQF_SHARED, 0, irq_chip,
237                                        &max77686->irq_data);
238         if (ret < 0) {
239                 dev_err(&i2c->dev, "failed to add PMIC irq chip: %d\n", ret);
240                 return ret;
241         }
242 
243         ret = devm_mfd_add_devices(max77686->dev, -1, cells, n_devs, NULL,
244                                    0, NULL);
245         if (ret < 0) {
246                 dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
247                 return ret;
248         }
249 
250         return 0;
251 }
252 
253 static const struct i2c_device_id max77686_i2c_id[] = {
254         { "max77686", TYPE_MAX77686 },
255         { "max77802", TYPE_MAX77802 },
256         { }
257 };
258 MODULE_DEVICE_TABLE(i2c, max77686_i2c_id);
259 
260 #ifdef CONFIG_PM_SLEEP
261 static int max77686_suspend(struct device *dev)
262 {
263         struct i2c_client *i2c = to_i2c_client(dev);
264         struct max77686_dev *max77686 = i2c_get_clientdata(i2c);
265 
266         if (device_may_wakeup(dev))
267                 enable_irq_wake(max77686->irq);
268 
269         /*
270          * IRQ must be disabled during suspend because if it happens
271          * while suspended it will be handled before resuming I2C.
272          *
273          * When device is woken up from suspend (e.g. by RTC wake alarm),
274          * an interrupt occurs before resuming I2C bus controller.
275          * Interrupt handler tries to read registers but this read
276          * will fail because I2C is still suspended.
277          */
278         disable_irq(max77686->irq);
279 
280         return 0;
281 }
282 
283 static int max77686_resume(struct device *dev)
284 {
285         struct i2c_client *i2c = to_i2c_client(dev);
286         struct max77686_dev *max77686 = i2c_get_clientdata(i2c);
287 
288         if (device_may_wakeup(dev))
289                 disable_irq_wake(max77686->irq);
290 
291         enable_irq(max77686->irq);
292 
293         return 0;
294 }
295 #endif /* CONFIG_PM_SLEEP */
296 
297 static SIMPLE_DEV_PM_OPS(max77686_pm, max77686_suspend, max77686_resume);
298 
299 static struct i2c_driver max77686_i2c_driver = {
300         .driver = {
301                    .name = "max77686",
302                    .pm = &max77686_pm,
303                    .of_match_table = of_match_ptr(max77686_pmic_dt_match),
304         },
305         .probe = max77686_i2c_probe,
306         .id_table = max77686_i2c_id,
307 };
308 
309 module_i2c_driver(max77686_i2c_driver);
310 
311 MODULE_DESCRIPTION("MAXIM 77686/802 multi-function core driver");
312 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
313 MODULE_LICENSE("GPL");
314 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us