drivers/power/pm8058-charger.c - kernel/msm.git - Git at Google

 /*
  * Copyright (c) 2010 Google, Inc.
  *
  * Author: Dima Zavin <dima@android.com>
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * 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.
  *
  */

 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/kernel.h>
 #include <linux/mfd/pm8058.h>
 #include <linux/platform_device.h>
 #include <linux/power_supply.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>


 struct pm8058_charger {
 	struct device				*pmic_dev;
 	int					chgval_irq;
 	int					fastchg_irq;

 	struct power_supply			ac_supply;
 	struct power_supply			usb_supply;

 	struct pm8058_charger_platform_data	*pdata;

 	spinlock_t				lock;
 	bool					can_charge;
 	bool					is_ac;
 	bool					is_online;
 	bool					vbus_present;
 	int					charge_type;
 	u32					max_current;
 };

 static struct pm8058_charger *the_pm8058_charger;

 /* TODO: the usb core driver should provide the maximum current draw value to us
  * for charging */

 void pm8058_notify_charger_connected(int status)
 {
 	struct pm8058_charger *charger = the_pm8058_charger;
 	u32 max_current = 0;
 	bool is_ac;
 	bool is_online;
 	bool change = false;
 	unsigned long flags;

 	if (!charger)
 		return;

 	printk("### %s(%d) ###\n", __func__, status);
 	if (status && !charger->vbus_present)
 		pr_warning("%s: cable status mismatch %d %d\n", __func__,
 			   status, charger->vbus_present);

 	switch (status) {
 	case 1:
 		/* usb (pc) charging */
 		max_current = 500;
 		is_ac = false;
 		is_online = true;
 		break;
 	case 2:
 		/* wall charger */
 		max_current = 1500;
 		is_ac = true;
 		is_online = true;
 		break;
 	case 0:
 	default:
 		/* disable charging */
 		max_current = 0;
 		is_ac = false;
 		is_online = false;
 		break;
 	}
 	spin_lock_irqsave(&charger->lock, flags);
 	if (max_current != charger->max_current ||
 	    is_ac != charger->is_ac || is_online != charger->is_online) {
 		charger->max_current = max_current;
 		charger->is_ac = is_ac;
 		charger->is_online = is_online;
 		change = true;
 	}
 	spin_unlock_irqrestore(&charger->lock, flags);
 	/* for now, charge control is done on the modem side, so we have to
 	 * delegate to the board file. Eventually, all charge control will
 	 * be done in this driver */
 	if (change && charger->pdata->charge)
 		charger->pdata->charge(max_current, is_ac);

 	power_supply_changed(&charger->ac_supply);
 	power_supply_changed(&charger->usb_supply);
 }
 EXPORT_SYMBOL_GPL(pm8058_notify_charger_connected);

 static void check_chgval(struct pm8058_charger *charger)
 {
 	int ret;
 	unsigned long flags;

 	ret = pm8058_irq_get_status(charger->pmic_dev, PM8058_CHGVAL_IRQ);
 	if (ret >= 0) {
 		spin_lock_irqsave(&charger->lock, flags);
 		charger->vbus_present = !!ret;
 		spin_unlock_irqrestore(&charger->lock, flags);
 		charger->pdata->vbus_present(ret);
 	} else {
 		pr_err("%s: can't read status!! ignoring event?!\n", __func__);
 	}
 }

 static irqreturn_t chgval_irq_handler(int irq, void *dev_id)
 {
 	struct pm8058_charger *charger = dev_id;

 	check_chgval(charger);
 	return IRQ_HANDLED;
 }

 /* should only get this irq when we are plugged in */
 static irqreturn_t fastchg_irq_handler(int irq, void *dev_id)
 {
 	struct pm8058_charger *charger = dev_id;
 	int ret;
 	bool fast_charging;
 	unsigned long flags;

 	ret = pm8058_irq_get_status(charger->pmic_dev, PM8058_FASTCHG_IRQ);
 	if (ret < 0)
 		return IRQ_HANDLED;
 	fast_charging = !!ret;

 	spin_lock_irqsave(&charger->lock, flags);
 	if (fast_charging) {
 		if (!charger->vbus_present) {
 			pr_err("%s: charging without vbus?!\n", __func__);
 			goto done;
 		}
 		charger->charge_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
 	} else {
 		/* charging is either stopped (done/overtemp/etc.), or we
 		 * are trickle charging. */
 		/* TODO: detect trickle charging mode */
 		if (charger->is_online)
 			charger->charge_type = POWER_SUPPLY_CHARGE_TYPE_NONE;
 		else
 			charger->charge_type = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
 	}

 done:
 	spin_unlock_irqrestore(&charger->lock, flags);

 	power_supply_changed(&charger->ac_supply);
 	power_supply_changed(&charger->usb_supply);
 	return IRQ_HANDLED;
 }

 static int power_get_property(struct power_supply *psy,
 			      enum power_supply_property psp,
 			      union power_supply_propval *val)
 {
 	struct pm8058_charger *charger;

 	if (psy->type == POWER_SUPPLY_TYPE_MAINS)
 		charger = container_of(psy, struct pm8058_charger, ac_supply);
 	else
 		charger = container_of(psy, struct pm8058_charger, usb_supply);

 	switch (psp) {
 	case POWER_SUPPLY_PROP_ONLINE:
 		if (psy->type == POWER_SUPPLY_TYPE_MAINS)
 			val->intval = charger->is_online && charger->is_ac;
 		else
 			val->intval = charger->is_online && !charger->is_ac;
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
 		/* for now, fake fast charge all the time if we're on */
 		if (psy->type == POWER_SUPPLY_TYPE_MAINS)
 			val->intval = charger->is_ac ? charger->charge_type :
 				POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
 		else
 			val->intval = charger->is_online && !charger->is_ac ?
 				charger->charge_type :
 				POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
 		break;
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static enum power_supply_property power_properties[] = {
 	POWER_SUPPLY_PROP_ONLINE,
 	POWER_SUPPLY_PROP_CHARGE_TYPE,
 };

 static int __init pm8058_charger_probe(struct platform_device *pdev)
 {
 	struct pm8058_charger_platform_data *pdata = pdev->dev.platform_data;
 	struct pm8058_charger *charger;
 	int chgval_irq;
 	int fastchg_irq;
 	int ret;

 	chgval_irq = platform_get_irq_byname(pdev, "chgval_irq");
 	fastchg_irq = platform_get_irq_byname(pdev, "fastchg_irq");

 	if (!pdata || chgval_irq < 0 || fastchg_irq < 0) {
 		pr_err("%s: missing platform data/resources\n", __func__);
 		return -EINVAL;
 	}

 	charger = kzalloc(sizeof(struct pm8058_charger), GFP_KERNEL);
 	if (!charger) {
 		pr_err("%s: can't alloc mem for charger struct\n", __func__);
 		return -ENOMEM;
 	}

 	charger->pmic_dev = pdev->dev.parent;
 	charger->pdata = pdata;
 	platform_set_drvdata(pdev, charger);
 	spin_lock_init(&charger->lock);

 	the_pm8058_charger = charger;

 	charger->ac_supply.name = "ac";
 	charger->ac_supply.type = POWER_SUPPLY_TYPE_MAINS;
 	charger->ac_supply.supplied_to = pdata->supplied_to;
 	charger->ac_supply.num_supplicants = pdata->num_supplicants;
 	charger->ac_supply.properties = power_properties;
 	charger->ac_supply.num_properties = ARRAY_SIZE(power_properties);
 	charger->ac_supply.get_property = power_get_property;

 	charger->usb_supply.name = "usb";
 	charger->usb_supply.type = POWER_SUPPLY_TYPE_USB;
 	charger->usb_supply.supplied_to = pdata->supplied_to;
 	charger->usb_supply.num_supplicants = pdata->num_supplicants;
 	charger->usb_supply.properties = power_properties;
 	charger->usb_supply.num_properties = ARRAY_SIZE(power_properties);
 	charger->usb_supply.get_property = power_get_property;

 	ret = power_supply_register(&pdev->dev, &charger->ac_supply);
 	if (ret)
 		goto err_reg_ac_supply;
 	ret = power_supply_register(&pdev->dev, &charger->usb_supply);
 	if (ret)
 		goto err_reg_usb_supply;

 	ret = request_threaded_irq(chgval_irq, NULL, chgval_irq_handler,
 				   IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
 				   "pm8058-charger-valid", charger);
 	if (ret) {
 		pr_err("%s: can't request chgval_irq\n", __func__);
 		goto err_req_chgval_irq;
 	}
 	charger->chgval_irq = chgval_irq;

 	ret = request_threaded_irq(fastchg_irq, NULL, fastchg_irq_handler,
 				   IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
 				   "pm8058-charger-fastchg", charger);
 	if (ret) {
 		pr_err("%s: can't request stuck\n", __func__);
 		goto err_req_fastchg_irq;
 	}
 	charger->fastchg_irq = fastchg_irq;
 	enable_irq_wake(charger->chgval_irq);

 	pr_info("%s: driver initialized\n", __func__);
 	check_chgval(charger);

 	return 0;

 err_req_fastchg_irq:
 	free_irq(chgval_irq, charger);
 err_req_chgval_irq:
 	power_supply_unregister(&charger->usb_supply);
 err_reg_usb_supply:
 	power_supply_unregister(&charger->ac_supply);
 err_reg_ac_supply:
 	platform_set_drvdata(pdev, NULL);
 	the_pm8058_charger = NULL;
 	kfree(charger);
 	return ret;
 }

 static struct platform_driver pm8058_charger_driver = {
 	.probe	= pm8058_charger_probe,
 	.driver	= {
 		.name	= "pm8058-charger",
 		.owner	= THIS_MODULE,
 	},
 };

 static int __init pm8058_charger_init(void)
 {
 	return platform_driver_register(&pm8058_charger_driver);
 }

 module_init(pm8058_charger_init);
 MODULE_DESCRIPTION("PM8058 Charger Driver");
 MODULE_AUTHOR("Dima Zavin <dima@android.com>");
 MODULE_LICENSE("GPL");
	/*
	* Copyright (c) 2010 Google, Inc.
	*
	* Author: Dima Zavin <dima@android.com>
	*
	* This software is licensed under the terms of the GNU General Public
	* License version 2, as published by the Free Software Foundation, and
	* may be copied, distributed, and modified under those terms.
	*
	* 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.
	*
	*/

	#include <linux/delay.h>
	#include <linux/err.h>
	#include <linux/interrupt.h>
	#include <linux/irq.h>
	#include <linux/kernel.h>
	#include <linux/mfd/pm8058.h>
	#include <linux/platform_device.h>
	#include <linux/power_supply.h>
	#include <linux/slab.h>
	#include <linux/spinlock.h>
	#include <linux/wait.h>


	struct pm8058_charger {
	struct device *pmic_dev;
	int chgval_irq;
	int fastchg_irq;

	struct power_supply ac_supply;
	struct power_supply usb_supply;

	struct pm8058_charger_platform_data *pdata;

	spinlock_t lock;
	bool can_charge;
	bool is_ac;
	bool is_online;
	bool vbus_present;
	int charge_type;
	u32 max_current;
	};

	static struct pm8058_charger *the_pm8058_charger;

	/* TODO: the usb core driver should provide the maximum current draw value to us
	* for charging */

	void pm8058_notify_charger_connected(int status)
	{
	struct pm8058_charger *charger = the_pm8058_charger;
	u32 max_current = 0;
	bool is_ac;
	bool is_online;
	bool change = false;
	unsigned long flags;

	if (!charger)
	return;

	printk("### %s(%d) ###\n", __func__, status);
	if (status && !charger->vbus_present)
	pr_warning("%s: cable status mismatch %d %d\n", __func__,
	status, charger->vbus_present);

	switch (status) {
	case 1:
	/* usb (pc) charging */
	max_current = 500;
	is_ac = false;
	is_online = true;
	break;
	case 2:
	/* wall charger */
	max_current = 1500;
	is_ac = true;
	is_online = true;
	break;
	case 0:
	default:
	/* disable charging */
	max_current = 0;
	is_ac = false;
	is_online = false;
	break;
	}
	spin_lock_irqsave(&charger->lock, flags);
	if (max_current != charger->max_current \|\|
	is_ac != charger->is_ac \|\| is_online != charger->is_online) {
	charger->max_current = max_current;
	charger->is_ac = is_ac;
	charger->is_online = is_online;
	change = true;
	}
	spin_unlock_irqrestore(&charger->lock, flags);
	/* for now, charge control is done on the modem side, so we have to
	* delegate to the board file. Eventually, all charge control will
	* be done in this driver */
	if (change && charger->pdata->charge)
	charger->pdata->charge(max_current, is_ac);

	power_supply_changed(&charger->ac_supply);
	power_supply_changed(&charger->usb_supply);
	}
	EXPORT_SYMBOL_GPL(pm8058_notify_charger_connected);

	static void check_chgval(struct pm8058_charger *charger)
	{
	int ret;
	unsigned long flags;

	ret = pm8058_irq_get_status(charger->pmic_dev, PM8058_CHGVAL_IRQ);
	if (ret >= 0) {
	spin_lock_irqsave(&charger->lock, flags);
	charger->vbus_present = !!ret;
	spin_unlock_irqrestore(&charger->lock, flags);
	charger->pdata->vbus_present(ret);
	} else {
	pr_err("%s: can't read status!! ignoring event?!\n", __func__);
	}
	}

	static irqreturn_t chgval_irq_handler(int irq, void *dev_id)
	{
	struct pm8058_charger *charger = dev_id;

	check_chgval(charger);
	return IRQ_HANDLED;
	}

	/* should only get this irq when we are plugged in */
	static irqreturn_t fastchg_irq_handler(int irq, void *dev_id)
	{
	struct pm8058_charger *charger = dev_id;
	int ret;
	bool fast_charging;
	unsigned long flags;

	ret = pm8058_irq_get_status(charger->pmic_dev, PM8058_FASTCHG_IRQ);
	if (ret < 0)
	return IRQ_HANDLED;
	fast_charging = !!ret;

	spin_lock_irqsave(&charger->lock, flags);
	if (fast_charging) {
	if (!charger->vbus_present) {
	pr_err("%s: charging without vbus?!\n", __func__);
	goto done;
	}
	charger->charge_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
	} else {
	/* charging is either stopped (done/overtemp/etc.), or we
	* are trickle charging. */
	/* TODO: detect trickle charging mode */
	if (charger->is_online)
	charger->charge_type = POWER_SUPPLY_CHARGE_TYPE_NONE;
	else
	charger->charge_type = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
	}

	done:
	spin_unlock_irqrestore(&charger->lock, flags);

	power_supply_changed(&charger->ac_supply);
	power_supply_changed(&charger->usb_supply);
	return IRQ_HANDLED;
	}

	static int power_get_property(struct power_supply *psy,
	enum power_supply_property psp,
	union power_supply_propval *val)
	{
	struct pm8058_charger *charger;

	if (psy->type == POWER_SUPPLY_TYPE_MAINS)
	charger = container_of(psy, struct pm8058_charger, ac_supply);
	else
	charger = container_of(psy, struct pm8058_charger, usb_supply);

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
	if (psy->type == POWER_SUPPLY_TYPE_MAINS)
	val->intval = charger->is_online && charger->is_ac;
	else
	val->intval = charger->is_online && !charger->is_ac;
	break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	/* for now, fake fast charge all the time if we're on */
	if (psy->type == POWER_SUPPLY_TYPE_MAINS)
	val->intval = charger->is_ac ? charger->charge_type :
	POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
	else
	val->intval = charger->is_online && !charger->is_ac ?
	charger->charge_type :
	POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
	break;
	default:
	return -EINVAL;
	}

	return 0;
	}

	static enum power_supply_property power_properties[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_CHARGE_TYPE,
	};

	static int __init pm8058_charger_probe(struct platform_device *pdev)
	{
	struct pm8058_charger_platform_data *pdata = pdev->dev.platform_data;
	struct pm8058_charger *charger;
	int chgval_irq;
	int fastchg_irq;
	int ret;

	chgval_irq = platform_get_irq_byname(pdev, "chgval_irq");
	fastchg_irq = platform_get_irq_byname(pdev, "fastchg_irq");

	if (!pdata \|\| chgval_irq < 0 \|\| fastchg_irq < 0) {
	pr_err("%s: missing platform data/resources\n", __func__);
	return -EINVAL;
	}

	charger = kzalloc(sizeof(struct pm8058_charger), GFP_KERNEL);
	if (!charger) {
	pr_err("%s: can't alloc mem for charger struct\n", __func__);
	return -ENOMEM;
	}

	charger->pmic_dev = pdev->dev.parent;
	charger->pdata = pdata;
	platform_set_drvdata(pdev, charger);
	spin_lock_init(&charger->lock);

	the_pm8058_charger = charger;

	charger->ac_supply.name = "ac";
	charger->ac_supply.type = POWER_SUPPLY_TYPE_MAINS;
	charger->ac_supply.supplied_to = pdata->supplied_to;
	charger->ac_supply.num_supplicants = pdata->num_supplicants;
	charger->ac_supply.properties = power_properties;
	charger->ac_supply.num_properties = ARRAY_SIZE(power_properties);
	charger->ac_supply.get_property = power_get_property;

	charger->usb_supply.name = "usb";
	charger->usb_supply.type = POWER_SUPPLY_TYPE_USB;
	charger->usb_supply.supplied_to = pdata->supplied_to;
	charger->usb_supply.num_supplicants = pdata->num_supplicants;
	charger->usb_supply.properties = power_properties;
	charger->usb_supply.num_properties = ARRAY_SIZE(power_properties);
	charger->usb_supply.get_property = power_get_property;

	ret = power_supply_register(&pdev->dev, &charger->ac_supply);
	if (ret)
	goto err_reg_ac_supply;
	ret = power_supply_register(&pdev->dev, &charger->usb_supply);
	if (ret)
	goto err_reg_usb_supply;

	ret = request_threaded_irq(chgval_irq, NULL, chgval_irq_handler,
	IRQF_TRIGGER_FALLING \| IRQF_TRIGGER_RISING,
	"pm8058-charger-valid", charger);
	if (ret) {
	pr_err("%s: can't request chgval_irq\n", __func__);
	goto err_req_chgval_irq;
	}
	charger->chgval_irq = chgval_irq;

	ret = request_threaded_irq(fastchg_irq, NULL, fastchg_irq_handler,
	IRQF_TRIGGER_FALLING \| IRQF_TRIGGER_RISING,
	"pm8058-charger-fastchg", charger);
	if (ret) {
	pr_err("%s: can't request stuck\n", __func__);
	goto err_req_fastchg_irq;
	}
	charger->fastchg_irq = fastchg_irq;
	enable_irq_wake(charger->chgval_irq);

	pr_info("%s: driver initialized\n", __func__);
	check_chgval(charger);

	return 0;

	err_req_fastchg_irq:
	free_irq(chgval_irq, charger);
	err_req_chgval_irq:
	power_supply_unregister(&charger->usb_supply);
	err_reg_usb_supply:
	power_supply_unregister(&charger->ac_supply);
	err_reg_ac_supply:
	platform_set_drvdata(pdev, NULL);
	the_pm8058_charger = NULL;
	kfree(charger);
	return ret;
	}

	static struct platform_driver pm8058_charger_driver = {
	.probe = pm8058_charger_probe,
	.driver = {
	.name = "pm8058-charger",
	.owner = THIS_MODULE,
	},
	};

	static int __init pm8058_charger_init(void)
	{
	return platform_driver_register(&pm8058_charger_driver);
	}

	module_init(pm8058_charger_init);
	MODULE_DESCRIPTION("PM8058 Charger Driver");
	MODULE_AUTHOR("Dima Zavin <dima@android.com>");
	MODULE_LICENSE("GPL");