path: root/arch/arm/mach-tegra/tegra3_thermal.c

/*
 * arch/arm/mach-tegra/tegra3_thermal.c
 *
 * Copyright (C) 2010-2012 NVIDIA Corporation.
 *
 * 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/kernel.h>
#include <linux/cpufreq.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/thermal.h>
#include <mach/thermal.h>
#include <mach/edp.h>
#include <linux/slab.h>

#include "clock.h"
#include "cpu-tegra.h"
#include "dvfs.h"

#define MAX_ZONES (16)

struct tegra_thermal {
	struct tegra_thermal_device *device;
	long temp_shutdown_tj;
#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	long temp_throttle_tj;
	int tc1;
	int tc2;
	long passive_delay;
#endif
#ifdef CONFIG_TEGRA_EDP_LIMITS
	int edp_thermal_zone_val;
	long edp_offset;
	long hysteresis_edp;
#endif
	struct mutex mutex;
};

static struct tegra_thermal thermal_state = {
	.device = NULL,
#ifdef CONFIG_TEGRA_EDP_LIMITS
	.edp_thermal_zone_val = -1,
#endif
};
#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
static struct throttle_table tj_bthrot_table[] = {
	{      0, 1000 },
	{ 640000, 1000 },
	{ 640000, 1000 },
	{ 640000, 1000 },
	{ 640000, 1000 },
	{ 640000, 1000 },
	{ 760000, 1000 },
	{ 760000, 1050 },
	{1000000, 1050 },
	{1000000, 1100 },
};

static struct balanced_throttle *tj_bthrot;

#define TJ_BALANCED_THROTTLE_ID		(0)
#endif

#ifdef CONFIG_TEGRA_EDP_LIMITS
static inline long edp2tj(struct tegra_thermal *thermal,
				long edp_temp)
{
	return edp_temp + thermal->edp_offset;
}

static inline long tj2edp(struct tegra_thermal *thermal,
				long temp_tj)
{
	return temp_tj - thermal->edp_offset;
}
#endif

static inline long dev2tj(struct tegra_thermal_device *dev,
				long dev_temp)
{
	return dev_temp + dev->offset;
}

static inline long tj2dev(struct tegra_thermal_device *dev,
				long tj_temp)
{
	return tj_temp - dev->offset;
}

static int tegra_thermal_get_tj_temp(long *tj_temp)
{
	long temp_dev;
	struct tegra_thermal *thermal = &thermal_state;

	if (!thermal->device)
		return -1;

	thermal->device->get_temp(thermal->device->data,
					&temp_dev);
	*tj_temp = dev2tj(thermal->device, temp_dev);

	return 0;
}

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE

static int tegra_thermal_zone_bind(struct thermal_zone_device *thz,
				struct thermal_cooling_device *cdevice) {

	struct balanced_throttle *bthrot = cdevice->devdata;
	struct tegra_thermal_device *device = thz->devdata;

	if ((bthrot->id == TJ_BALANCED_THROTTLE_ID) &&
		(device == thermal_state.device))
		return thermal_zone_bind_cooling_device(thz, 0, cdevice);

	return 0;
}

static int tegra_thermal_zone_unbind(struct thermal_zone_device *thz,
				struct thermal_cooling_device *cdevice) {
	struct balanced_throttle *bthrot = cdevice->devdata;
	struct tegra_thermal_device *device = thz->devdata;

	if ((bthrot->id == TJ_BALANCED_THROTTLE_ID) &&
		(device == thermal_state.device))
		return thermal_zone_unbind_cooling_device(thz, 0, cdevice);

	return 0;
}

static int tegra_thermal_zone_get_temp(struct thermal_zone_device *thz,
					unsigned long *temp)
{
	struct tegra_thermal_device *device = thz->devdata;

	device->get_temp(device->data, temp);

	return 0;
}

static int tegra_thermal_zone_get_trip_type(
			struct thermal_zone_device *thermal,
			int trip,
			enum thermal_trip_type *type) {
	if (trip != 0)
		return -EINVAL;

	*type = THERMAL_TRIP_PASSIVE;

	return 0;
}

static int tegra_thermal_zone_get_trip_temp(struct thermal_zone_device *thz,
					int trip,
					unsigned long *temp) {
	struct tegra_thermal_device *device = thz->devdata;

	if (trip != 0)
		return -EINVAL;

	*temp = tj2dev(device, thermal_state.temp_throttle_tj);

	return 0;
}

static struct thermal_zone_device_ops tegra_thermal_zone_ops = {
	.bind = tegra_thermal_zone_bind,
	.unbind = tegra_thermal_zone_unbind,
	.get_temp = tegra_thermal_zone_get_temp,
	.get_trip_type = tegra_thermal_zone_get_trip_type,
	.get_trip_temp = tegra_thermal_zone_get_trip_temp,
};
#endif

/* Make sure this function remains stateless */
void tegra_thermal_alert(void *data)
{
	struct tegra_thermal *thermal = data;
	long temp_tj;
	long lo_limit_throttle_tj, hi_limit_throttle_tj;
	long lo_limit_edp_tj = 0, hi_limit_edp_tj = 0;
	long temp_low_dev, temp_low_tj;
	int lo_limit_tj = 0, hi_limit_tj = 0;
#ifdef CONFIG_TEGRA_EDP_LIMITS
	const struct tegra_edp_limits *z;
	int zones_sz;
	int i;
#endif

	if (thermal != &thermal_state)
		BUG();

	mutex_lock(&thermal_state.mutex);

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	if (thermal->device->thz) {
		if (!thermal->device->thz->passive)
			thermal_zone_device_update(thermal->device->thz);
	}
#endif

	/* Convert all temps to tj and then do all work/logic in terms of
	   tj in order to avoid confusion */
	if (tegra_thermal_get_tj_temp(&temp_tj))
		goto done;
	thermal->device->get_temp_low(thermal->device, &temp_low_dev);
	temp_low_tj = dev2tj(thermal->device, temp_low_dev);

	lo_limit_throttle_tj = temp_low_tj;
	hi_limit_throttle_tj = thermal->temp_shutdown_tj;

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	hi_limit_throttle_tj = thermal->temp_throttle_tj;

	if (temp_tj > thermal->temp_throttle_tj) {
		lo_limit_throttle_tj = thermal->temp_throttle_tj;
		hi_limit_throttle_tj = thermal->temp_shutdown_tj;
	}
#endif

#ifdef CONFIG_TEGRA_EDP_LIMITS
	tegra_get_cpu_edp_limits(&z, &zones_sz);

/* edp table based off of tdiode measurements */
#define EDP_TEMP_TJ(_index)	edp2tj(thermal, z[_index].temperature * 1000)

	if (temp_tj < EDP_TEMP_TJ(0)) {
		lo_limit_edp_tj = temp_low_tj;
		hi_limit_edp_tj = EDP_TEMP_TJ(0);
	} else if (temp_tj >= EDP_TEMP_TJ(zones_sz-1)) {
		lo_limit_edp_tj = EDP_TEMP_TJ(zones_sz-1) -
					thermal->hysteresis_edp;
		hi_limit_edp_tj = thermal->temp_shutdown_tj;
	} else {
		for (i = 0; (i + 1) < zones_sz; i++) {
			if ((temp_tj >= EDP_TEMP_TJ(i)) &&
				(temp_tj < EDP_TEMP_TJ(i+1))) {
				lo_limit_edp_tj = EDP_TEMP_TJ(i) -
							thermal->hysteresis_edp;
				hi_limit_edp_tj = EDP_TEMP_TJ(i+1);
				break;
			}
		}
	}
#undef EDP_TEMP_TJ
#else
	lo_limit_edp_tj = temp_low_tj;
	hi_limit_edp_tj = thermal->temp_shutdown_tj;
#endif

	/* Get smallest window size */
	lo_limit_tj = max(lo_limit_throttle_tj, lo_limit_edp_tj);
	hi_limit_tj = min(hi_limit_throttle_tj, hi_limit_edp_tj);

	thermal->device->set_limits(thermal->device->data,
					tj2dev(thermal->device, lo_limit_tj),
					tj2dev(thermal->device, hi_limit_tj));

#ifdef CONFIG_TEGRA_EDP_LIMITS
	/* inform edp governor */
	if (thermal->edp_thermal_zone_val != temp_tj)
		tegra_edp_update_thermal_zone(tj2edp(thermal, temp_tj)/1000);

	thermal->edp_thermal_zone_val = temp_tj;
#endif

done:
	mutex_unlock(&thermal_state.mutex);
}



int tegra_thermal_set_device(struct tegra_thermal_device *device)
{
#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	struct thermal_zone_device *thz;
#endif

	/* only support one device */
	if (thermal_state.device)
		return -EINVAL;

	thermal_state.device = device;

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	thz = thermal_zone_device_register(device->name,
					1, /* trips */
					device,
					&tegra_thermal_zone_ops,
					thermal_state.tc1, /* dT/dt */
					thermal_state.tc2, /* throttle */
					thermal_state.passive_delay,
					0); /* polling delay */
	if (IS_ERR_OR_NULL(thz))
		return -ENODEV;

	device->thz = thz;

	tj_bthrot = balanced_throttle_register(
					TJ_BALANCED_THROTTLE_ID,
					tj_bthrot_table,
					ARRAY_SIZE(tj_bthrot_table));
	if (IS_ERR_OR_NULL(tj_bthrot))
		return -ENODEV;

#endif
	device->set_alert(device->data,
				tegra_thermal_alert,
				&thermal_state);

	device->set_shutdown_temp(device->data,
				tj2dev(device, thermal_state.temp_shutdown_tj));


	/* initialize limits */
	tegra_thermal_alert(&thermal_state);

	return 0;
}

int __init tegra_thermal_init(struct tegra_thermal_data *data)
{
#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	thermal_state.tc1 = data->tc1;
	thermal_state.tc2 = data->tc2;
	thermal_state.passive_delay = data->passive_delay;
	thermal_state.temp_throttle_tj = data->temp_throttle +
						data->temp_offset;
#endif
	mutex_init(&thermal_state.mutex);
#ifdef CONFIG_TEGRA_EDP_LIMITS
	thermal_state.edp_offset = data->edp_offset;
	thermal_state.hysteresis_edp = data->hysteresis_edp;
#endif
	thermal_state.temp_shutdown_tj = data->temp_shutdown +
						data->temp_offset;

	return 0;
}

int tegra_thermal_exit(void)
{
#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	if (thermal_state.device->thz)
		thermal_zone_device_unregister(thermal_state.device->thz);
#endif

	return 0;
}

#ifdef CONFIG_DEBUG_FS

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
static int tegra_thermal_throttle_temp_tj_set(void *data, u64 val)
{
	mutex_lock(&thermal_state.mutex);
	thermal_state.temp_throttle_tj = val;
	mutex_unlock(&thermal_state.mutex);

	tegra_thermal_alert(&thermal_state);

	return 0;
}

static int tegra_thermal_throttle_temp_tj_get(void *data, u64 *val)
{
	*val = (u64)thermal_state.temp_throttle_tj;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(throttle_temp_tj_fops,
			tegra_thermal_throttle_temp_tj_get,
			tegra_thermal_throttle_temp_tj_set,
			"%llu\n");
#endif

static int tegra_thermal_shutdown_temp_tj_set(void *data, u64 val)
{
	thermal_state.temp_shutdown_tj = val;

	if (thermal_state.device)
		thermal_state.device->set_shutdown_temp(
				thermal_state.device->data,
				tj2dev(thermal_state.device,
					thermal_state.temp_shutdown_tj));

	tegra_thermal_alert(&thermal_state);

	return 0;
}

static int tegra_thermal_shutdown_temp_tj_get(void *data, u64 *val)
{
	*val = (u64)thermal_state.temp_shutdown_tj;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(shutdown_temp_tj_fops,
			tegra_thermal_shutdown_temp_tj_get,
			tegra_thermal_shutdown_temp_tj_set,
			"%llu\n");


static int tegra_thermal_temp_tj_get(void *data, u64 *val)
{
	long temp_tj;

	if (tegra_thermal_get_tj_temp(&temp_tj))
		temp_tj = -1;

	*val = (u64)temp_tj;

	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(temp_tj_fops,
			tegra_thermal_temp_tj_get,
			NULL,
			"%llu\n");

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
static int tegra_thermal_tc1_set(void *data, u64 val)
{
	thermal_state.device->thz->tc1 = val;
	return 0;
}

static int tegra_thermal_tc1_get(void *data, u64 *val)
{
	*val = (u64)thermal_state.device->thz->tc1;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(tc1_fops,
			tegra_thermal_tc1_get,
			tegra_thermal_tc1_set,
			"%llu\n");

static int tegra_thermal_tc2_set(void *data, u64 val)
{
	thermal_state.device->thz->tc2 = val;
	return 0;
}

static int tegra_thermal_tc2_get(void *data, u64 *val)
{
	*val = (u64)thermal_state.device->thz->tc2;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(tc2_fops,
			tegra_thermal_tc2_get,
			tegra_thermal_tc2_set,
			"%llu\n");

static int tegra_thermal_passive_delay_set(void *data, u64 val)
{
	thermal_state.device->thz->passive_delay = val;
	return 0;
}

static int tegra_thermal_passive_delay_get(void *data, u64 *val)
{
	*val = (u64)thermal_state.device->thz->passive_delay;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(passive_delay_fops,
			tegra_thermal_passive_delay_get,
			tegra_thermal_passive_delay_set,
			"%llu\n");
#endif


static struct dentry *thermal_debugfs_root;

static int __init tegra_thermal_debug_init(void)
{
	thermal_debugfs_root = debugfs_create_dir("tegra_thermal", 0);

	if (!debugfs_create_file("shutdown_temp_tj", 0644, thermal_debugfs_root,
				 NULL, &shutdown_temp_tj_fops))
		goto err_out;

	if (!debugfs_create_file("temp_tj", 0644, thermal_debugfs_root,
				 NULL, &temp_tj_fops))
		goto err_out;

#ifdef CONFIG_TEGRA_THERMAL_THROTTLE
	if (!debugfs_create_file("throttle_temp_tj", 0644, thermal_debugfs_root,
				 NULL, &throttle_temp_tj_fops))
		goto err_out;

	if (!debugfs_create_file("tc1", 0644, thermal_debugfs_root,
				 NULL, &tc1_fops))
		goto err_out;

	if (!debugfs_create_file("tc2", 0644, thermal_debugfs_root,
				 NULL, &tc2_fops))
		goto err_out;

	if (!debugfs_create_file("passive_delay", 0644, thermal_debugfs_root,
				 NULL, &passive_delay_fops))
		goto err_out;
#endif

	return 0;

err_out:
	debugfs_remove_recursive(thermal_debugfs_root);
	return -ENOMEM;
}

late_initcall(tegra_thermal_debug_init);
#endif