1// SPDX-License-Identifier: GPL-2.0+
  2//
  3// max14577.c - mfd core driver for the Maxim 14577/77836
  4//
  5// Copyright (C) 2014 Samsung Electronics
  6// Chanwoo Choi <cw00.choi@samsung.com>
  7// Krzysztof Kozlowski <krzk@kernel.org>
  8//
  9// This driver is based on max8997.c
 10
 11#include <linux/err.h>
 12#include <linux/module.h>
 13#include <linux/interrupt.h>
 14#include <linux/of_device.h>
 15#include <linux/mfd/core.h>
 16#include <linux/mfd/max14577.h>
 17#include <linux/mfd/max14577-private.h>
 18
 19/*
 20 * Table of valid charger currents for different Maxim chipsets.
 21 * It is placed here because it is used by both charger and regulator driver.
 22 */
 23const struct maxim_charger_current maxim_charger_currents[] = {
 24	[MAXIM_DEVICE_TYPE_UNKNOWN] = { 0, 0, 0, 0 },
 25	[MAXIM_DEVICE_TYPE_MAX14577] = {
 26		.min		= MAX14577_CHARGER_CURRENT_LIMIT_MIN,
 27		.high_start	= MAX14577_CHARGER_CURRENT_LIMIT_HIGH_START,
 28		.high_step	= MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP,
 29		.max		= MAX14577_CHARGER_CURRENT_LIMIT_MAX,
 30	},
 31	[MAXIM_DEVICE_TYPE_MAX77836] = {
 32		.min		= MAX77836_CHARGER_CURRENT_LIMIT_MIN,
 33		.high_start	= MAX77836_CHARGER_CURRENT_LIMIT_HIGH_START,
 34		.high_step	= MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP,
 35		.max		= MAX77836_CHARGER_CURRENT_LIMIT_MAX,
 36	},
 37};
 38EXPORT_SYMBOL_GPL(maxim_charger_currents);
 39
 40/*
 41 * maxim_charger_calc_reg_current - Calculate register value for current
 42 * @limits:	constraints for charger, matching the MBCICHWRC register
 43 * @min_ua:	minimal requested current, micro Amps
 44 * @max_ua:	maximum requested current, micro Amps
 45 * @dst:	destination to store calculated register value
 46 *
 47 * Calculates the value of MBCICHWRC (Fast Battery Charge Current) register
 48 * for given current and stores it under pointed 'dst'. The stored value
 49 * combines low bit (MBCICHWRCL) and high bits (MBCICHWRCH). It is also
 50 * properly shifted.
 51 *
 52 * The calculated register value matches the current which:
 53 *  - is always between <limits.min, limits.max>;
 54 *  - is always less or equal to max_ua;
 55 *  - is the highest possible value;
 56 *  - may be lower than min_ua.
 57 *
 58 * On success returns 0. On error returns -EINVAL (requested min/max current
 59 * is outside of given charger limits) and 'dst' is not set.
 60 */
 61int maxim_charger_calc_reg_current(const struct maxim_charger_current *limits,
 62		unsigned int min_ua, unsigned int max_ua, u8 *dst)
 63{
 64	unsigned int current_bits;
 65
 66	if (min_ua > max_ua)
 67		return -EINVAL;
 68
 69	if (min_ua > limits->max || max_ua < limits->min)
 70		return -EINVAL;
 71
 72	if (max_ua < limits->high_start) {
 73		/*
 74		 * Less than high_start, so set the minimal current
 75		 * (turn Low Bit off, 0 as high bits).
 76		 */
 77		*dst = 0x0;
 78		return 0;
 79	}
 80
 81	/* max_ua is in range: <high_start, infinite>, cut it to limits.max */
 82	max_ua = min(limits->max, max_ua);
 83	max_ua -= limits->high_start;
 84	/*
 85	 * There is no risk of overflow 'max_ua' here because:
 86	 *  - max_ua >= limits.high_start
 87	 *  - BUILD_BUG checks that 'limits' are: max >= high_start + high_step
 88	 */
 89	current_bits = max_ua / limits->high_step;
 90
 91	/* Turn Low Bit on (use range <limits.high_start, limits.max>) ... */
 92	*dst = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;
 93	/* and set proper High Bits */
 94	*dst |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT;
 95
 96	return 0;
 97}
 98EXPORT_SYMBOL_GPL(maxim_charger_calc_reg_current);
 99
100static const struct mfd_cell max14577_devs[] = {
101	{
102		.name = "max14577-muic",
103		.of_compatible = "maxim,max14577-muic",
104	},
105	{
106		.name = "max14577-regulator",
107		.of_compatible = "maxim,max14577-regulator",
108	},
109	{
110		.name = "max14577-charger",
111		.of_compatible = "maxim,max14577-charger",
112	},
113};
114
115static const struct mfd_cell max77836_devs[] = {
116	{
117		.name = "max77836-muic",
118		.of_compatible = "maxim,max77836-muic",
119	},
120	{
121		.name = "max77836-regulator",
122		.of_compatible = "maxim,max77836-regulator",
123	},
124	{
125		.name = "max77836-charger",
126		.of_compatible = "maxim,max77836-charger",
127	},
128	{
129		.name = "max77836-battery",
130		.of_compatible = "maxim,max77836-battery",
131	},
132};
133
134static const struct of_device_id max14577_dt_match[] = {
135	{
136		.compatible = "maxim,max14577",
137		.data = (void *)MAXIM_DEVICE_TYPE_MAX14577,
138	},
139	{
140		.compatible = "maxim,max77836",
141		.data = (void *)MAXIM_DEVICE_TYPE_MAX77836,
142	},
143	{},
144};
145
146static bool max14577_muic_volatile_reg(struct device *dev, unsigned int reg)
147{
148	switch (reg) {
149	case MAX14577_REG_INT1 ... MAX14577_REG_STATUS3:
150		return true;
151	default:
152		break;
153	}
154	return false;
155}
156
157static bool max77836_muic_volatile_reg(struct device *dev, unsigned int reg)
158{
159	/* Any max14577 volatile registers are also max77836 volatile. */
160	if (max14577_muic_volatile_reg(dev, reg))
161		return true;
162
163	switch (reg) {
164	case MAX77836_FG_REG_VCELL_MSB ... MAX77836_FG_REG_SOC_LSB:
165	case MAX77836_FG_REG_CRATE_MSB ... MAX77836_FG_REG_CRATE_LSB:
166	case MAX77836_FG_REG_STATUS_H ... MAX77836_FG_REG_STATUS_L:
167	case MAX77836_PMIC_REG_INTSRC:
168	case MAX77836_PMIC_REG_TOPSYS_INT:
169	case MAX77836_PMIC_REG_TOPSYS_STAT:
170		return true;
171	default:
172		break;
173	}
174	return false;
175}
176
177static const struct regmap_config max14577_muic_regmap_config = {
178	.reg_bits	= 8,
179	.val_bits	= 8,
180	.volatile_reg	= max14577_muic_volatile_reg,
181	.max_register	= MAX14577_REG_END,
182};
183
184static const struct regmap_config max77836_pmic_regmap_config = {
185	.reg_bits	= 8,
186	.val_bits	= 8,
187	.volatile_reg	= max77836_muic_volatile_reg,
188	.max_register	= MAX77836_PMIC_REG_END,
189};
190
191static const struct regmap_irq max14577_irqs[] = {
192	/* INT1 interrupts */
193	{ .reg_offset = 0, .mask = MAX14577_INT1_ADC_MASK, },
194	{ .reg_offset = 0, .mask = MAX14577_INT1_ADCLOW_MASK, },
195	{ .reg_offset = 0, .mask = MAX14577_INT1_ADCERR_MASK, },
196	/* INT2 interrupts */
197	{ .reg_offset = 1, .mask = MAX14577_INT2_CHGTYP_MASK, },
198	{ .reg_offset = 1, .mask = MAX14577_INT2_CHGDETRUN_MASK, },
199	{ .reg_offset = 1, .mask = MAX14577_INT2_DCDTMR_MASK, },
200	{ .reg_offset = 1, .mask = MAX14577_INT2_DBCHG_MASK, },
201	{ .reg_offset = 1, .mask = MAX14577_INT2_VBVOLT_MASK, },
202	/* INT3 interrupts */
203	{ .reg_offset = 2, .mask = MAX14577_INT3_EOC_MASK, },
204	{ .reg_offset = 2, .mask = MAX14577_INT3_CGMBC_MASK, },
205	{ .reg_offset = 2, .mask = MAX14577_INT3_OVP_MASK, },
206	{ .reg_offset = 2, .mask = MAX14577_INT3_MBCCHGERR_MASK, },
207};
208
209static const struct regmap_irq_chip max14577_irq_chip = {
210	.name			= "max14577",
211	.status_base		= MAX14577_REG_INT1,
212	.unmask_base		= MAX14577_REG_INTMASK1,
213	.num_regs		= 3,
214	.irqs			= max14577_irqs,
215	.num_irqs		= ARRAY_SIZE(max14577_irqs),
216};
217
218static const struct regmap_irq max77836_muic_irqs[] = {
219	/* INT1 interrupts */
220	{ .reg_offset = 0, .mask = MAX14577_INT1_ADC_MASK, },
221	{ .reg_offset = 0, .mask = MAX14577_INT1_ADCLOW_MASK, },
222	{ .reg_offset = 0, .mask = MAX14577_INT1_ADCERR_MASK, },
223	{ .reg_offset = 0, .mask = MAX77836_INT1_ADC1K_MASK, },
224	/* INT2 interrupts */
225	{ .reg_offset = 1, .mask = MAX14577_INT2_CHGTYP_MASK, },
226	{ .reg_offset = 1, .mask = MAX14577_INT2_CHGDETRUN_MASK, },
227	{ .reg_offset = 1, .mask = MAX14577_INT2_DCDTMR_MASK, },
228	{ .reg_offset = 1, .mask = MAX14577_INT2_DBCHG_MASK, },
229	{ .reg_offset = 1, .mask = MAX14577_INT2_VBVOLT_MASK, },
230	{ .reg_offset = 1, .mask = MAX77836_INT2_VIDRM_MASK, },
231	/* INT3 interrupts */
232	{ .reg_offset = 2, .mask = MAX14577_INT3_EOC_MASK, },
233	{ .reg_offset = 2, .mask = MAX14577_INT3_CGMBC_MASK, },
234	{ .reg_offset = 2, .mask = MAX14577_INT3_OVP_MASK, },
235	{ .reg_offset = 2, .mask = MAX14577_INT3_MBCCHGERR_MASK, },
236};
237
238static const struct regmap_irq_chip max77836_muic_irq_chip = {
239	.name			= "max77836-muic",
240	.status_base		= MAX14577_REG_INT1,
241	.unmask_base		= MAX14577_REG_INTMASK1,
242	.num_regs		= 3,
243	.irqs			= max77836_muic_irqs,
244	.num_irqs		= ARRAY_SIZE(max77836_muic_irqs),
245};
246
247static const struct regmap_irq max77836_pmic_irqs[] = {
248	{ .reg_offset = 0, .mask = MAX77836_TOPSYS_INT_T120C_MASK, },
249	{ .reg_offset = 0, .mask = MAX77836_TOPSYS_INT_T140C_MASK, },
250};
251
252static const struct regmap_irq_chip max77836_pmic_irq_chip = {
253	.name			= "max77836-pmic",
254	.status_base		= MAX77836_PMIC_REG_TOPSYS_INT,
255	.mask_base		= MAX77836_PMIC_REG_TOPSYS_INT_MASK,
256	.num_regs		= 1,
257	.irqs			= max77836_pmic_irqs,
258	.num_irqs		= ARRAY_SIZE(max77836_pmic_irqs),
259};
260
261static void max14577_print_dev_type(struct max14577 *max14577)
262{
263	u8 reg_data, vendor_id, device_id;
264	int ret;
265
266	ret = max14577_read_reg(max14577->regmap, MAX14577_REG_DEVICEID,
267			&reg_data);
268	if (ret) {
269		dev_err(max14577->dev,
270			"Failed to read DEVICEID register: %d\n", ret);
271		return;
272	}
273
274	vendor_id = ((reg_data & DEVID_VENDORID_MASK) >>
275				DEVID_VENDORID_SHIFT);
276	device_id = ((reg_data & DEVID_DEVICEID_MASK) >>
277				DEVID_DEVICEID_SHIFT);
278
279	dev_info(max14577->dev, "Device type: %u (ID: 0x%x, vendor: 0x%x)\n",
280			max14577->dev_type, device_id, vendor_id);
281}
282
283/*
284 * Max77836 specific initialization code for driver probe.
285 * Adds new I2C dummy device, regmap and regmap IRQ chip.
286 * Unmasks Interrupt Source register.
287 *
288 * On success returns 0.
289 * On failure returns errno and reverts any changes done so far (e.g. remove
290 * I2C dummy device), except masking the INT SRC register.
291 */
292static int max77836_init(struct max14577 *max14577)
293{
294	int ret;
295	u8 intsrc_mask;
296
297	max14577->i2c_pmic = i2c_new_dummy_device(max14577->i2c->adapter,
298			I2C_ADDR_PMIC);
299	if (IS_ERR(max14577->i2c_pmic)) {
300		dev_err(max14577->dev, "Failed to register PMIC I2C device\n");
301		return PTR_ERR(max14577->i2c_pmic);
302	}
303	i2c_set_clientdata(max14577->i2c_pmic, max14577);
304
305	max14577->regmap_pmic = devm_regmap_init_i2c(max14577->i2c_pmic,
306			&max77836_pmic_regmap_config);
307	if (IS_ERR(max14577->regmap_pmic)) {
308		ret = PTR_ERR(max14577->regmap_pmic);
309		dev_err(max14577->dev, "Failed to allocate PMIC register map: %d\n",
310				ret);
311		goto err;
312	}
313
314	/* Un-mask MAX77836 Interrupt Source register */
315	ret = max14577_read_reg(max14577->regmap_pmic,
316			MAX77836_PMIC_REG_INTSRC_MASK, &intsrc_mask);
317	if (ret < 0) {
318		dev_err(max14577->dev, "Failed to read PMIC register\n");
319		goto err;
320	}
321
322	intsrc_mask &= ~(MAX77836_INTSRC_MASK_TOP_INT_MASK);
323	intsrc_mask &= ~(MAX77836_INTSRC_MASK_MUIC_CHG_INT_MASK);
324	ret = max14577_write_reg(max14577->regmap_pmic,
325			MAX77836_PMIC_REG_INTSRC_MASK, intsrc_mask);
326	if (ret < 0) {
327		dev_err(max14577->dev, "Failed to write PMIC register\n");
328		goto err;
329	}
330
331	ret = regmap_add_irq_chip(max14577->regmap_pmic, max14577->irq,
332			IRQF_ONESHOT | IRQF_SHARED,
333			0, &max77836_pmic_irq_chip,
334			&max14577->irq_data_pmic);
335	if (ret != 0) {
336		dev_err(max14577->dev, "Failed to request PMIC IRQ %d: %d\n",
337				max14577->irq, ret);
338		goto err;
339	}
340
341	return 0;
342
343err:
344	i2c_unregister_device(max14577->i2c_pmic);
345
346	return ret;
347}
348
349/*
350 * Max77836 specific de-initialization code for driver remove.
351 */
352static void max77836_remove(struct max14577 *max14577)
353{
354	regmap_del_irq_chip(max14577->irq, max14577->irq_data_pmic);
355	i2c_unregister_device(max14577->i2c_pmic);
356}
357
358static int max14577_i2c_probe(struct i2c_client *i2c)
359{
360	const struct i2c_device_id *id = i2c_client_get_device_id(i2c);
361	struct max14577 *max14577;
362	struct max14577_platform_data *pdata = dev_get_platdata(&i2c->dev);
363	struct device_node *np = i2c->dev.of_node;
364	int ret = 0;
365	const struct regmap_irq_chip *irq_chip;
366	const struct mfd_cell *mfd_devs;
367	unsigned int mfd_devs_size;
368	int irq_flags;
369
370	if (np) {
371		pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL);
372		if (!pdata)
373			return -ENOMEM;
374		i2c->dev.platform_data = pdata;
375	}
376
377	if (!pdata) {
378		dev_err(&i2c->dev, "No platform data found.\n");
379		return -EINVAL;
380	}
381
382	max14577 = devm_kzalloc(&i2c->dev, sizeof(*max14577), GFP_KERNEL);
383	if (!max14577)
384		return -ENOMEM;
385
386	i2c_set_clientdata(i2c, max14577);
387	max14577->dev = &i2c->dev;
388	max14577->i2c = i2c;
389	max14577->irq = i2c->irq;
390
391	max14577->regmap = devm_regmap_init_i2c(i2c,
392			&max14577_muic_regmap_config);
393	if (IS_ERR(max14577->regmap)) {
394		ret = PTR_ERR(max14577->regmap);
395		dev_err(max14577->dev, "Failed to allocate register map: %d\n",
396				ret);
397		return ret;
398	}
399
400	if (np) {
401		const struct of_device_id *of_id;
402
403		of_id = of_match_device(max14577_dt_match, &i2c->dev);
404		if (of_id)
405			max14577->dev_type =
406				(enum maxim_device_type)of_id->data;
407	} else {
408		max14577->dev_type = id->driver_data;
409	}
410
411	max14577_print_dev_type(max14577);
412
413	switch (max14577->dev_type) {
414	case MAXIM_DEVICE_TYPE_MAX77836:
415		irq_chip = &max77836_muic_irq_chip;
416		mfd_devs = max77836_devs;
417		mfd_devs_size = ARRAY_SIZE(max77836_devs);
418		irq_flags = IRQF_ONESHOT | IRQF_SHARED;
419		break;
420	case MAXIM_DEVICE_TYPE_MAX14577:
421	default:
422		irq_chip = &max14577_irq_chip;
423		mfd_devs = max14577_devs;
424		mfd_devs_size = ARRAY_SIZE(max14577_devs);
425		irq_flags = IRQF_ONESHOT;
426		break;
427	}
428
429	ret = regmap_add_irq_chip(max14577->regmap, max14577->irq,
430				  irq_flags, 0, irq_chip,
431				  &max14577->irq_data);
432	if (ret != 0) {
433		dev_err(&i2c->dev, "Failed to request IRQ %d: %d\n",
434				max14577->irq, ret);
435		return ret;
436	}
437
438	/* Max77836 specific initialization code (additional regmap) */
439	if (max14577->dev_type == MAXIM_DEVICE_TYPE_MAX77836) {
440		ret = max77836_init(max14577);
441		if (ret < 0)
442			goto err_max77836;
443	}
444
445	ret = mfd_add_devices(max14577->dev, -1, mfd_devs,
446			mfd_devs_size, NULL, 0, NULL);
447	if (ret < 0)
448		goto err_mfd;
449
450	device_init_wakeup(max14577->dev, 1);
451
452	return 0;
453
454err_mfd:
455	if (max14577->dev_type == MAXIM_DEVICE_TYPE_MAX77836)
456		max77836_remove(max14577);
457err_max77836:
458	regmap_del_irq_chip(max14577->irq, max14577->irq_data);
459
460	return ret;
461}
462
463static void max14577_i2c_remove(struct i2c_client *i2c)
464{
465	struct max14577 *max14577 = i2c_get_clientdata(i2c);
466
467	mfd_remove_devices(max14577->dev);
468	regmap_del_irq_chip(max14577->irq, max14577->irq_data);
469	if (max14577->dev_type == MAXIM_DEVICE_TYPE_MAX77836)
470		max77836_remove(max14577);
471}
472
473static const struct i2c_device_id max14577_i2c_id[] = {
474	{ "max14577", MAXIM_DEVICE_TYPE_MAX14577, },
475	{ "max77836", MAXIM_DEVICE_TYPE_MAX77836, },
476	{ }
477};
478MODULE_DEVICE_TABLE(i2c, max14577_i2c_id);
479
480static int max14577_suspend(struct device *dev)
481{
482	struct i2c_client *i2c = to_i2c_client(dev);
483	struct max14577 *max14577 = i2c_get_clientdata(i2c);
484
485	if (device_may_wakeup(dev))
486		enable_irq_wake(max14577->irq);
487	/*
488	 * MUIC IRQ must be disabled during suspend because if it happens
489	 * while suspended it will be handled before resuming I2C.
490	 *
491	 * When device is woken up from suspend (e.g. by ADC change),
492	 * an interrupt occurs before resuming I2C bus controller.
493	 * Interrupt handler tries to read registers but this read
494	 * will fail because I2C is still suspended.
495	 */
496	disable_irq(max14577->irq);
497
498	return 0;
499}
500
501static int max14577_resume(struct device *dev)
502{
503	struct i2c_client *i2c = to_i2c_client(dev);
504	struct max14577 *max14577 = i2c_get_clientdata(i2c);
505
506	if (device_may_wakeup(dev))
507		disable_irq_wake(max14577->irq);
508	enable_irq(max14577->irq);
509
510	return 0;
511}
512
513static DEFINE_SIMPLE_DEV_PM_OPS(max14577_pm, max14577_suspend, max14577_resume);
514
515static struct i2c_driver max14577_i2c_driver = {
516	.driver = {
517		.name = "max14577",
518		.pm = pm_sleep_ptr(&max14577_pm),
519		.of_match_table = max14577_dt_match,
520	},
521	.probe_new = max14577_i2c_probe,
522	.remove = max14577_i2c_remove,
523	.id_table = max14577_i2c_id,
524};
525
526static int __init max14577_i2c_init(void)
527{
528	BUILD_BUG_ON(ARRAY_SIZE(max14577_i2c_id) != MAXIM_DEVICE_TYPE_NUM);
529	BUILD_BUG_ON(ARRAY_SIZE(max14577_dt_match) != MAXIM_DEVICE_TYPE_NUM);
530
531	/* Valid charger current values must be provided for each chipset */
532	BUILD_BUG_ON(ARRAY_SIZE(maxim_charger_currents) != MAXIM_DEVICE_TYPE_NUM);
533
534	/* Check for valid values for charger */
535	BUILD_BUG_ON(MAX14577_CHARGER_CURRENT_LIMIT_HIGH_START +
536			MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP * 0xf !=
537			MAX14577_CHARGER_CURRENT_LIMIT_MAX);
538	BUILD_BUG_ON(MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP == 0);
539
540	BUILD_BUG_ON(MAX77836_CHARGER_CURRENT_LIMIT_HIGH_START +
541			MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP * 0xf !=
542			MAX77836_CHARGER_CURRENT_LIMIT_MAX);
543	BUILD_BUG_ON(MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP == 0);
544
545	return i2c_add_driver(&max14577_i2c_driver);
546}
547module_init(max14577_i2c_init);
548
549static void __exit max14577_i2c_exit(void)
550{
551	i2c_del_driver(&max14577_i2c_driver);
552}
553module_exit(max14577_i2c_exit);
554
555MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <krzk@kernel.org>");
556MODULE_DESCRIPTION("Maxim 14577/77836 multi-function core driver");
557MODULE_LICENSE("GPL");