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