Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7b5363cc authored by Ram Chandrasekar's avatar Ram Chandrasekar
Browse files

drivers: thermal: bcl_soc: Add Battery state of charge driver 



Add Battery state of charge driver, which will register the battery
state of charge as a sensor with thermal framework. This driver can take
a low threshold to monitor and will notify the thermal framework when
the state of charge goes below the threshold.

Change-Id: Ia553c49f7588dccf077d2b69e3061b609876f79c
Signed-off-by: default avatarRam Chandrasekar <rkumbako@codeaurora.org>
parent 05aa7f8f

Documentation/devicetree/bindings/thermal/qcom-bcl-soc.txt

0 → 100644
+14 −0
Original line number Diff line number Diff line 
===============================================================================

PMIC state of charge driver:

===============================================================================

Battery state of charge driver can monitor for change in battery charge and

notify thermal framework, when the value goes below a certain threshold.



Required Parameters:

- compatible: must be 'qcom,msm-bcl-soc' for battery state of charge driver.



Optional Parameters:



		bcl-soc {

			compatible = "qcom,msm-bcl-soc";

		};

drivers/thermal/qcom/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -72,3 +72,13 @@ config MSM_BCL_PERIPHERAL_CTL 
	  voltage sensors with the thermal core framework and can take

	  threshold input and notify the thermal core when the threshold is

	  reached.



config QTI_BCL_SOC_DRIVER

	bool "QTI Battery state of charge sensor driver"

	depends on THERMAL_OF

	help

	  This driver registers battery state of charge as a sensor with

	  thermal zone. This sensor can monitor for state of charge

	  threshold and notify the thermal framework.



	  If you want this support, you should say Y here.

drivers/thermal/qcom/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -6,3 +6,4 @@ obj-$(CONFIG_QTI_AOP_REG_COOLING_DEVICE) += regulator_aop_cdev.o 
obj-$(CONFIG_REGULATOR_COOLING_DEVICE) += regulator_cdev.o

obj-$(CONFIG_QTI_QMI_COOLING_DEVICE) += thermal_mitigation_device_service_v01.o qmi_cooling.o

obj-$(CONFIG_MSM_BCL_PERIPHERAL_CTL) += bcl_peripheral.o

obj-$(CONFIG_QTI_BCL_SOC_DRIVER) += bcl_soc.o

drivers/thermal/qcom/bcl_soc.c

0 → 100644
+191 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2018, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * 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.

 */



#define pr_fmt(fmt) "%s:%s " fmt, KBUILD_MODNAME, __func__



#include <linux/module.h>

#include <linux/workqueue.h>

#include <linux/kernel.h>

#include <linux/io.h>

#include <linux/err.h>

#include <linux/of.h>

#include <linux/platform_device.h>

#include <linux/mutex.h>

#include <linux/power_supply.h>

#include <linux/thermal.h>



#include "../thermal_core.h"



#define BCL_DRIVER_NAME       "bcl_soc_peripheral"



struct bcl_device {

	struct notifier_block			psy_nb;

	struct work_struct			soc_eval_work;

	long int				trip_temp;

	int					trip_val;

	struct mutex				state_trans_lock;

	bool					irq_enabled;

	struct thermal_zone_device		*tz_dev;

	struct thermal_zone_of_device_ops	ops;

};



static struct bcl_device *bcl_perph;



static int bcl_set_soc(void *data, int low, int high)

{

	if (low == bcl_perph->trip_temp)

		return 0;



	mutex_lock(&bcl_perph->state_trans_lock);

	pr_debug("low soc threshold:%d\n", low);

	bcl_perph->trip_temp = low;

	if (low == INT_MIN) {

		bcl_perph->irq_enabled = false;

		goto unlock_and_exit;

	}

	bcl_perph->irq_enabled = true;

	schedule_work(&bcl_perph->soc_eval_work);



unlock_and_exit:

	mutex_unlock(&bcl_perph->state_trans_lock);

	return 0;

}



static int bcl_read_soc(void *data, int *val)

{

	static struct power_supply *batt_psy;

	union power_supply_propval ret = {0,};

	int err = 0;



	*val = 100;

	if (!batt_psy)

		batt_psy = power_supply_get_by_name("battery");

	if (batt_psy) {

		err = power_supply_get_property(batt_psy,

				POWER_SUPPLY_PROP_CAPACITY, &ret);

		if (err) {

			pr_err("battery percentage read error:%d\n",

				err);

			return err;

		}

		*val = ret.intval;

	}

	pr_debug("soc:%d\n", *val);



	return err;

}



static void bcl_evaluate_soc(struct work_struct *work)

{

	int battery_percentage;



	if (bcl_read_soc(NULL, &battery_percentage))

		return;



	mutex_lock(&bcl_perph->state_trans_lock);

	if (!bcl_perph->irq_enabled)

		goto eval_exit;

	if (battery_percentage > bcl_perph->trip_temp)

		goto eval_exit;



	bcl_perph->trip_val = battery_percentage;

	mutex_unlock(&bcl_perph->state_trans_lock);

	of_thermal_handle_trip(bcl_perph->tz_dev);



	return;

eval_exit:

	mutex_unlock(&bcl_perph->state_trans_lock);

}



static int battery_supply_callback(struct notifier_block *nb,

			unsigned long event, void *data)

{

	struct power_supply *psy = data;



	if (strcmp(psy->desc->name, "battery"))

		return NOTIFY_OK;

	schedule_work(&bcl_perph->soc_eval_work);



	return NOTIFY_OK;

}



static int bcl_soc_remove(struct platform_device *pdev)

{

	power_supply_unreg_notifier(&bcl_perph->psy_nb);

	flush_work(&bcl_perph->soc_eval_work);

	if (bcl_perph->tz_dev)

		thermal_zone_of_sensor_unregister(&pdev->dev,

				bcl_perph->tz_dev);



	return 0;

}



static int bcl_soc_probe(struct platform_device *pdev)

{

	int ret = 0;



	bcl_perph = devm_kzalloc(&pdev->dev, sizeof(*bcl_perph), GFP_KERNEL);

	if (!bcl_perph)

		return -ENOMEM;



	mutex_init(&bcl_perph->state_trans_lock);

	bcl_perph->ops.get_temp = bcl_read_soc;

	bcl_perph->ops.set_trips = bcl_set_soc;

	INIT_WORK(&bcl_perph->soc_eval_work, bcl_evaluate_soc);

	bcl_perph->psy_nb.notifier_call = battery_supply_callback;

	ret = power_supply_reg_notifier(&bcl_perph->psy_nb);

	if (ret < 0) {

		pr_err("soc notifier registration error. defer. err:%d\n",

			ret);

		ret = -EPROBE_DEFER;

		goto bcl_soc_probe_exit;

	}

	bcl_perph->tz_dev = thermal_zone_of_sensor_register(&pdev->dev,

				0, bcl_perph, &bcl_perph->ops);

	if (IS_ERR(bcl_perph->tz_dev)) {

		pr_err("soc TZ register failed. err:%ld\n",

				PTR_ERR(bcl_perph->tz_dev));

		ret = PTR_ERR(bcl_perph->tz_dev);

		bcl_perph->tz_dev = NULL;

		goto bcl_soc_probe_exit;

	}

	thermal_zone_device_update(bcl_perph->tz_dev, THERMAL_DEVICE_UP);

	schedule_work(&bcl_perph->soc_eval_work);



	dev_set_drvdata(&pdev->dev, bcl_perph);



	return 0;



bcl_soc_probe_exit:

	bcl_soc_remove(pdev);

	return ret;

}



static const struct of_device_id bcl_match[] = {

	{

		.compatible = "qcom,msm-bcl-soc",

	},

	{},

};



static struct platform_driver bcl_driver = {

	.probe  = bcl_soc_probe,

	.remove = bcl_soc_remove,

	.driver = {

		.name           = BCL_DRIVER_NAME,

		.owner          = THIS_MODULE,

		.of_match_table = bcl_match,

	},

};



builtin_platform_driver(bcl_driver);