iMX/i2som-imx-linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
02228658df7d84d384ea622d848920da170281da
i2som-imx-linux/drivers/mfd/pf1550.c
Robin Gong 849c86ec97 MLK-12928-21 power: pf1550: fix charger interrupt never caught 
Charger interrupt can't be caught anymore after plug in DC 5V in/out dozens of
times, that caused by VBUS_I or CHG_I pending interrupt not cleared in time. The root
cause is VBUS_I and CHG_I will be triggered in very narrow window, and VBUS_I/CHG_I
act as the sub-interrupt of charger and share the same interrupt handler. Thus if CHG_I
interrupt status is coming while VBUS_I handler is running, CHG_I interrupt status will
never be cleared, since interrupt has been disabled in ISR. The unclear CHG_I interrupt
status make pf1550 never trigger next interrupt again. So clear all charger interrupt
status in ISR to workaround instead of ack for every sub-intterrupt.

Signed-off-by: Robin Gong <yibin.gong@nxp.com>
2019-02-12 10:25:04 +08:00

312 lines
8.2 KiB
C
Raw Blame History

/*
* pf1550.c - mfd core driver for the PF1550
*
* Copyright (C) 2016 Freescale Semiconductor, Inc.
* Robin Gong <yibin.gong@freescale.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* This driver is based on max77693.c
*/
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/mfd/core.h>
#include <linux/mfd/pf1550.h>
#include <linux/of.h>
#include <linux/regmap.h>
static const struct mfd_cell pf1550_devs[] = {
{
.name = "pf1550-regulator",
.of_compatible = "fsl,pf1550-regulator",
},
{
.name = "pf1550-onkey",
.of_compatible = "fsl,pf1550-onkey",
},
{
.name = "pf1550-charger",
.of_compatible = "fsl,pf1550-charger",
},
};
static const struct regmap_config pf1550_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = PF1550_PMIC_REG_END,
};
static const struct regmap_irq pf1550_regulator_irqs[] = {
{ .reg_offset = 0, .mask = PMIC_IRQ_SW1_LS, },
{ .reg_offset = 0, .mask = PMIC_IRQ_SW2_LS, },
{ .reg_offset = 0, .mask = PMIC_IRQ_SW3_LS, },
{ .reg_offset = 3, .mask = PMIC_IRQ_SW1_HS, },
{ .reg_offset = 3, .mask = PMIC_IRQ_SW2_HS, },
{ .reg_offset = 3, .mask = PMIC_IRQ_SW3_HS, },
{ .reg_offset = 16, .mask = PMIC_IRQ_LDO1_FAULT, },
{ .reg_offset = 16, .mask = PMIC_IRQ_LDO2_FAULT, },
{ .reg_offset = 16, .mask = PMIC_IRQ_LDO3_FAULT, },
{ .reg_offset = 22, .mask = PMIC_IRQ_TEMP_110, },
{ .reg_offset = 22, .mask = PMIC_IRQ_TEMP_125, },
};
static const struct regmap_irq_chip pf1550_regulator_irq_chip = {
.name = "pf1550-regulator",
.status_base = PF1550_PMIC_REG_SW_INT_STAT0,
.mask_base = PF1550_PMIC_REG_SW_INT_MASK0,
.mask_invert = false,
.num_regs = 23,
.irqs = pf1550_regulator_irqs,
.num_irqs = ARRAY_SIZE(pf1550_regulator_irqs),
};
static const struct regmap_irq pf1550_onkey_irqs[] = {
{ .reg_offset = 0, .mask = ONKEY_IRQ_PUSHI, },
{ .reg_offset = 0, .mask = ONKEY_IRQ_1SI, },
{ .reg_offset = 0, .mask = ONKEY_IRQ_2SI, },
{ .reg_offset = 0, .mask = ONKEY_IRQ_3SI, },
{ .reg_offset = 0, .mask = ONKEY_IRQ_4SI, },
{ .reg_offset = 0, .mask = ONKEY_IRQ_8SI, },
};
static const struct regmap_irq_chip pf1550_onkey_irq_chip = {
.name = "pf1550-onkey",
.status_base = PF1550_PMIC_REG_ONKEY_INT_STAT0,
.ack_base = PF1550_PMIC_REG_ONKEY_INT_STAT0,
.mask_base = PF1550_PMIC_REG_ONKEY_INT_MASK0,
.mask_invert = false,
.use_ack = 1,
.init_ack_masked = 1,
.num_regs = 1,
.irqs = pf1550_onkey_irqs,
.num_irqs = ARRAY_SIZE(pf1550_onkey_irqs),
};
static const struct regmap_irq pf1550_charger_irqs[] = {
{ .reg_offset = 0, .mask = CHARG_IRQ_BAT2SOCI, },
{ .reg_offset = 0, .mask = CHARG_IRQ_BATI, },
{ .reg_offset = 0, .mask = CHARG_IRQ_CHGI, },
{ .reg_offset = 0, .mask = CHARG_IRQ_VBUSI, },
{ .reg_offset = 0, .mask = CHARG_IRQ_THMI, },
};
static const struct regmap_irq_chip pf1550_charger_irq_chip = {
.name = "pf1550-charger",
.status_base = PF1550_CHARG_REG_CHG_INT,
.mask_base = PF1550_CHARG_REG_CHG_INT_MASK,
.mask_invert = false,
.num_regs = 1,
.irqs = pf1550_charger_irqs,
.num_irqs = ARRAY_SIZE(pf1550_charger_irqs),
};
int pf1550_read_otp(struct pf1550_dev *pf1550, unsigned int index,
unsigned int *val)
{
int ret = 0;
ret = regmap_write(pf1550->regmap, PF1550_PMIC_REG_KEY, 0x15);
if (ret)
goto read_err;
ret = regmap_write(pf1550->regmap, PF1550_CHARG_REG_CHGR_KEY2, 0x50);
if (ret)
goto read_err;
ret = regmap_write(pf1550->regmap, PF1550_TEST_REG_KEY3, 0xAB);
if (ret)
goto read_err;
ret = regmap_write(pf1550->regmap, PF1550_TEST_REG_FMRADDR, index);
if (ret)
goto read_err;
ret = regmap_read(pf1550->regmap, PF1550_TEST_REG_FMRDATA, val);
if (ret)
goto read_err;
return 0;
read_err:
dev_err(pf1550->dev, "read otp reg %x found!\n", index);
return ret;
}
static int pf1550_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct pf1550_dev *pf1550;
unsigned int reg_data = 0;
int ret = 0;
pf1550 = devm_kzalloc(&i2c->dev,
sizeof(struct pf1550_dev), GFP_KERNEL);
if (!pf1550)
return -ENOMEM;
i2c_set_clientdata(i2c, pf1550);
pf1550->dev = &i2c->dev;
pf1550->i2c = i2c;
pf1550->irq = i2c->irq;
pf1550->regmap = devm_regmap_init_i2c(i2c, &pf1550_regmap_config);
if (IS_ERR(pf1550->regmap)) {
ret = PTR_ERR(pf1550->regmap);
dev_err(pf1550->dev, "failed to allocate register map: %d\n",
ret);
return ret;
}
ret = regmap_read(pf1550->regmap, PF1550_PMIC_REG_DEVICE_ID, &reg_data);
if (ret < 0 || reg_data != 0x7c) {
dev_err(pf1550->dev, "device not found!\n");
return ret;
}
pf1550->type = PF1550;
dev_info(pf1550->dev, "pf1550 found.\n");
ret = regmap_add_irq_chip(pf1550->regmap, pf1550->irq,
IRQF_ONESHOT | IRQF_SHARED |
IRQF_TRIGGER_FALLING, 0,
&pf1550_regulator_irq_chip,
&pf1550->irq_data_regulator);
if (ret) {
dev_err(pf1550->dev, "failed to add irq1 chip: %d\n", ret);
goto err_regulator_irq;
}
ret = regmap_add_irq_chip(pf1550->regmap, pf1550->irq,
IRQF_ONESHOT | IRQF_SHARED |
IRQF_TRIGGER_FALLING, 0,
&pf1550_onkey_irq_chip,
&pf1550->irq_data_onkey);
if (ret) {
dev_err(pf1550->dev, "failed to add irq3 chip: %d\n", ret);
goto err_onkey_irq;
}
ret = regmap_add_irq_chip(pf1550->regmap, pf1550->irq,
IRQF_ONESHOT | IRQF_SHARED |
IRQF_TRIGGER_FALLING, 0,
&pf1550_charger_irq_chip,
&pf1550->irq_data_charger);
if (ret) {
dev_err(pf1550->dev, "failed to add irq4 chip: %d\n", ret);
goto err_charger_irq;
}
ret = mfd_add_devices(pf1550->dev, -1, pf1550_devs,
ARRAY_SIZE(pf1550_devs), NULL, 0, NULL);
if (ret < 0)
goto err_mfd;
return ret;
err_mfd:
mfd_remove_devices(pf1550->dev);
err_charger_irq:
regmap_del_irq_chip(pf1550->irq, pf1550->irq_data_charger);
err_onkey_irq:
regmap_del_irq_chip(pf1550->irq, pf1550->irq_data_regulator);
err_regulator_irq:
return ret;
}
static int pf1550_i2c_remove(struct i2c_client *i2c)
{
struct pf1550_dev *pf1550 = i2c_get_clientdata(i2c);
mfd_remove_devices(pf1550->dev);
regmap_del_irq_chip(pf1550->irq, pf1550->irq_data_regulator);
regmap_del_irq_chip(pf1550->irq, pf1550->irq_data_onkey);
regmap_del_irq_chip(pf1550->irq, pf1550->irq_data_charger);
return 0;
}
static const struct i2c_device_id pf1550_i2c_id[] = {
{ "pf1550", PF1550 },
{ }
};
MODULE_DEVICE_TABLE(i2c, pf1550_i2c_id);
static int pf1550_suspend(struct device *dev)
{
struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
struct pf1550_dev *pf1550 = i2c_get_clientdata(i2c);
if (device_may_wakeup(dev)) {
enable_irq_wake(pf1550->irq);
disable_irq(pf1550->irq);
}
return 0;
}
static int pf1550_resume(struct device *dev)
{
struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
struct pf1550_dev *pf1550 = i2c_get_clientdata(i2c);
if (device_may_wakeup(dev)) {
disable_irq_wake(pf1550->irq);
enable_irq(pf1550->irq);
}
return 0;
}
static const struct dev_pm_ops pf1550_pm = {
.suspend = pf1550_suspend,
.resume = pf1550_resume,
};
#ifdef CONFIG_OF
static const struct of_device_id pf1550_dt_match[] = {
{ .compatible = "fsl,pf1550" },
{},
};
#endif
static struct i2c_driver pf1550_i2c_driver = {
.driver = {
.name = "pf1550",
.owner = THIS_MODULE,
.pm = &pf1550_pm,
.of_match_table = of_match_ptr(pf1550_dt_match),
},
.probe = pf1550_i2c_probe,
.remove = pf1550_i2c_remove,
.id_table = pf1550_i2c_id,
};
static int __init pf1550_i2c_init(void)
{
return i2c_add_driver(&pf1550_i2c_driver);
}
/* init early so consumer devices can complete system boot */
subsys_initcall(pf1550_i2c_init);
static void __exit pf1550_i2c_exit(void)
{
i2c_del_driver(&pf1550_i2c_driver);
}
module_exit(pf1550_i2c_exit);
MODULE_DESCRIPTION("Freescale PF1550 multi-function core driver");
MODULE_AUTHOR("Robin Gong <yibin.gong@freescale.com>");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink