[linux.git] / drivers / thermal / intel_soc_dts_iosf.c

/*
 * intel_soc_dts_iosf.c
 * Copyright (c) 2015, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <asm/iosf_mbi.h>
#include "intel_soc_dts_iosf.h"

#define SOC_DTS_OFFSET_ENABLE		0xB0
#define SOC_DTS_OFFSET_TEMP		0xB1

#define SOC_DTS_OFFSET_PTPS		0xB2
#define SOC_DTS_OFFSET_PTTS		0xB3
#define SOC_DTS_OFFSET_PTTSS		0xB4
#define SOC_DTS_OFFSET_PTMC		0x80
#define SOC_DTS_TE_AUX0			0xB5
#define SOC_DTS_TE_AUX1			0xB6

#define SOC_DTS_AUX0_ENABLE_BIT		BIT(0)
#define SOC_DTS_AUX1_ENABLE_BIT		BIT(1)
#define SOC_DTS_CPU_MODULE0_ENABLE_BIT	BIT(16)
#define SOC_DTS_CPU_MODULE1_ENABLE_BIT	BIT(17)
#define SOC_DTS_TE_SCI_ENABLE		BIT(9)
#define SOC_DTS_TE_SMI_ENABLE		BIT(10)
#define SOC_DTS_TE_MSI_ENABLE		BIT(11)
#define SOC_DTS_TE_APICA_ENABLE		BIT(14)
#define SOC_DTS_PTMC_APIC_DEASSERT_BIT	BIT(4)

/* DTS encoding for TJ MAX temperature */
#define SOC_DTS_TJMAX_ENCODING		0x7F

/* Only 2 out of 4 is allowed for OSPM */
#define SOC_MAX_DTS_TRIPS		2

/* Mask for two trips in status bits */
#define SOC_DTS_TRIP_MASK		0x03

/* DTS0 and DTS 1 */
#define SOC_MAX_DTS_SENSORS		2

static int get_tj_max(u32 *tj_max)
{
	u32 eax, edx;
	u32 val;
	int err;

	err = rdmsr_safe(MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
	if (err)
		goto err_ret;
	else {
		val = (eax >> 16) & 0xff;
		if (val)
			*tj_max = val * 1000;
		else {
			err = -EINVAL;
			goto err_ret;
		}
	}

	return 0;
err_ret:
	*tj_max = 0;

	return err;
}

static int sys_get_trip_temp(struct thermal_zone_device *tzd, int trip,
			     int *temp)
{
	int status;
	u32 out;
	struct intel_soc_dts_sensor_entry *dts;
	struct intel_soc_dts_sensors *sensors;

	dts = tzd->devdata;
	sensors = dts->sensors;
	mutex_lock(&sensors->dts_update_lock);
	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_OFFSET_PTPS, &out);
	mutex_unlock(&sensors->dts_update_lock);
	if (status)
		return status;

	out = (out >> (trip * 8)) & SOC_DTS_TJMAX_ENCODING;
	if (!out)
		*temp = 0;
	else
		*temp = sensors->tj_max - out * 1000;

	return 0;
}

static int update_trip_temp(struct intel_soc_dts_sensor_entry *dts,
			    int thres_index, int temp,
			    enum thermal_trip_type trip_type)
{
	int status;
	u32 temp_out;
	u32 out;
	u32 store_ptps;
	u32 store_ptmc;
	u32 store_te_out;
	u32 te_out;
	u32 int_enable_bit = SOC_DTS_TE_APICA_ENABLE;
	struct intel_soc_dts_sensors *sensors = dts->sensors;

	if (sensors->intr_type == INTEL_SOC_DTS_INTERRUPT_MSI)
		int_enable_bit |= SOC_DTS_TE_MSI_ENABLE;

	temp_out = (sensors->tj_max - temp) / 1000;

	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_OFFSET_PTPS, &store_ptps);
	if (status)
		return status;

	out = (store_ptps & ~(0xFF << (thres_index * 8)));
	out |= (temp_out & 0xFF) << (thres_index * 8);
	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
				SOC_DTS_OFFSET_PTPS, out);
	if (status)
		return status;

	pr_debug("update_trip_temp PTPS = %x\n", out);
	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_OFFSET_PTMC, &out);
	if (status)
		goto err_restore_ptps;

	store_ptmc = out;

	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_TE_AUX0 + thres_index,
			       &te_out);
	if (status)
		goto err_restore_ptmc;

	store_te_out = te_out;
	/* Enable for CPU module 0 and module 1 */
	out |= (SOC_DTS_CPU_MODULE0_ENABLE_BIT |
					SOC_DTS_CPU_MODULE1_ENABLE_BIT);
	if (temp) {
		if (thres_index)
			out |= SOC_DTS_AUX1_ENABLE_BIT;
		else
			out |= SOC_DTS_AUX0_ENABLE_BIT;
		te_out |= int_enable_bit;
	} else {
		if (thres_index)
			out &= ~SOC_DTS_AUX1_ENABLE_BIT;
		else
			out &= ~SOC_DTS_AUX0_ENABLE_BIT;
		te_out &= ~int_enable_bit;
	}
	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
				SOC_DTS_OFFSET_PTMC, out);
	if (status)
		goto err_restore_te_out;

	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
				SOC_DTS_TE_AUX0 + thres_index,
				te_out);
	if (status)
		goto err_restore_te_out;

	dts->trip_types[thres_index] = trip_type;

	return 0;
err_restore_te_out:
	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
		       SOC_DTS_OFFSET_PTMC, store_te_out);
err_restore_ptmc:
	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
		       SOC_DTS_OFFSET_PTMC, store_ptmc);
err_restore_ptps:
	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
		       SOC_DTS_OFFSET_PTPS, store_ptps);
	/* Nothing we can do if restore fails */

	return status;
}

static int sys_set_trip_temp(struct thermal_zone_device *tzd, int trip,
			     int temp)
{
	struct intel_soc_dts_sensor_entry *dts = tzd->devdata;
	struct intel_soc_dts_sensors *sensors = dts->sensors;
	int status;

	if (temp > sensors->tj_max)
		return -EINVAL;

	mutex_lock(&sensors->dts_update_lock);
	status = update_trip_temp(tzd->devdata, trip, temp,
				  dts->trip_types[trip]);
	mutex_unlock(&sensors->dts_update_lock);

	return status;
}

static int sys_get_trip_type(struct thermal_zone_device *tzd,
			     int trip, enum thermal_trip_type *type)
{
	struct intel_soc_dts_sensor_entry *dts;

	dts = tzd->devdata;

	*type = dts->trip_types[trip];

	return 0;
}

static int sys_get_curr_temp(struct thermal_zone_device *tzd,
			     int *temp)
{
	int status;
	u32 out;
	struct intel_soc_dts_sensor_entry *dts;
	struct intel_soc_dts_sensors *sensors;

	dts = tzd->devdata;
	sensors = dts->sensors;
	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_OFFSET_TEMP, &out);
	if (status)
		return status;

	out = (out & dts->temp_mask) >> dts->temp_shift;
	out -= SOC_DTS_TJMAX_ENCODING;
	*temp = sensors->tj_max - out * 1000;

	return 0;
}

static struct thermal_zone_device_ops tzone_ops = {
	.get_temp = sys_get_curr_temp,
	.get_trip_temp = sys_get_trip_temp,
	.get_trip_type = sys_get_trip_type,
	.set_trip_temp = sys_set_trip_temp,
};

static int soc_dts_enable(int id)
{
	u32 out;
	int ret;

	ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			    SOC_DTS_OFFSET_ENABLE, &out);
	if (ret)
		return ret;

	if (!(out & BIT(id))) {
		out |= BIT(id);
		ret = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
				     SOC_DTS_OFFSET_ENABLE, out);
		if (ret)
			return ret;
	}

	return ret;
}

static void remove_dts_thermal_zone(struct intel_soc_dts_sensor_entry *dts)
{
	if (dts) {
		iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
			       SOC_DTS_OFFSET_ENABLE, dts->store_status);
		thermal_zone_device_unregister(dts->tzone);
	}
}

static int add_dts_thermal_zone(int id, struct intel_soc_dts_sensor_entry *dts,
				bool notification_support, int trip_cnt,
				int read_only_trip_cnt)
{
	char name[10];
	int trip_count = 0;
	int trip_mask = 0;
	u32 store_ptps;
	int ret;
	int i;

	/* Store status to restor on exit */
	ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			    SOC_DTS_OFFSET_ENABLE,
			    &dts->store_status);
	if (ret)
		goto err_ret;

	dts->id = id;
	dts->temp_mask = 0x00FF << (id * 8);
	dts->temp_shift = id * 8;
	if (notification_support) {
		trip_count = min(SOC_MAX_DTS_TRIPS, trip_cnt);
		trip_mask = BIT(trip_count - read_only_trip_cnt) - 1;
	}

	/* Check if the writable trip we provide is not used by BIOS */
	ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			    SOC_DTS_OFFSET_PTPS, &store_ptps);
	if (ret)
		trip_mask = 0;
	else {
		for (i = 0; i < trip_count; ++i) {
			if (trip_mask & BIT(i))
				if (store_ptps & (0xff << (i * 8)))
					trip_mask &= ~BIT(i);
		}
	}
	dts->trip_mask = trip_mask;
	dts->trip_count = trip_count;
	snprintf(name, sizeof(name), "soc_dts%d", id);
	dts->tzone = thermal_zone_device_register(name,
						  trip_count,
						  trip_mask,
						  dts, &tzone_ops,
						  NULL, 0, 0);
	if (IS_ERR(dts->tzone)) {
		ret = PTR_ERR(dts->tzone);
		goto err_ret;
	}

	ret = soc_dts_enable(id);
	if (ret)
		goto err_enable;

	return 0;
err_enable:
	thermal_zone_device_unregister(dts->tzone);
err_ret:
	return ret;
}

int intel_soc_dts_iosf_add_read_only_critical_trip(
	struct intel_soc_dts_sensors *sensors, int critical_offset)
{
	int i, j;

	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
		for (j = 0; j < sensors->soc_dts[i].trip_count; ++j) {
			if (!(sensors->soc_dts[i].trip_mask & BIT(j))) {
				return update_trip_temp(&sensors->soc_dts[i], j,
					sensors->tj_max - critical_offset,
					THERMAL_TRIP_CRITICAL);
			}
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_add_read_only_critical_trip);

void intel_soc_dts_iosf_interrupt_handler(struct intel_soc_dts_sensors *sensors)
{
	u32 sticky_out;
	int status;
	u32 ptmc_out;
	unsigned long flags;

	spin_lock_irqsave(&sensors->intr_notify_lock, flags);

	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_OFFSET_PTMC, &ptmc_out);
	ptmc_out |= SOC_DTS_PTMC_APIC_DEASSERT_BIT;
	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
				SOC_DTS_OFFSET_PTMC, ptmc_out);

	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
			       SOC_DTS_OFFSET_PTTSS, &sticky_out);
	pr_debug("status %d PTTSS %x\n", status, sticky_out);
	if (sticky_out & SOC_DTS_TRIP_MASK) {
		int i;
		/* reset sticky bit */
		status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
					SOC_DTS_OFFSET_PTTSS, sticky_out);
		spin_unlock_irqrestore(&sensors->intr_notify_lock, flags);

		for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
			pr_debug("TZD update for zone %d\n", i);
			thermal_zone_device_update(sensors->soc_dts[i].tzone);
		}
	} else
		spin_unlock_irqrestore(&sensors->intr_notify_lock, flags);
}
EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_interrupt_handler);

struct intel_soc_dts_sensors *intel_soc_dts_iosf_init(
	enum intel_soc_dts_interrupt_type intr_type, int trip_count,
	int read_only_trip_count)
{
	struct intel_soc_dts_sensors *sensors;
	bool notification;
	u32 tj_max;
	int ret;
	int i;

	if (!iosf_mbi_available())
		return ERR_PTR(-ENODEV);

	if (!trip_count || read_only_trip_count > trip_count)
		return ERR_PTR(-EINVAL);

	if (get_tj_max(&tj_max))
		return ERR_PTR(-EINVAL);

	sensors = kzalloc(sizeof(*sensors), GFP_KERNEL);
	if (!sensors)
		return ERR_PTR(-ENOMEM);

	spin_lock_init(&sensors->intr_notify_lock);
	mutex_init(&sensors->dts_update_lock);
	sensors->intr_type = intr_type;
	sensors->tj_max = tj_max;
	if (intr_type == INTEL_SOC_DTS_INTERRUPT_NONE)
		notification = false;
	else
		notification = true;
	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
		sensors->soc_dts[i].sensors = sensors;
		ret = add_dts_thermal_zone(i, &sensors->soc_dts[i],
					   notification, trip_count,
					   read_only_trip_count);
		if (ret)
			goto err_free;
	}

	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
		ret = update_trip_temp(&sensors->soc_dts[i], 0, 0,
				       THERMAL_TRIP_PASSIVE);
		if (ret)
			goto err_remove_zone;

		ret = update_trip_temp(&sensors->soc_dts[i], 1, 0,
				       THERMAL_TRIP_PASSIVE);
		if (ret)
			goto err_remove_zone;
	}

	return sensors;
err_remove_zone:
	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i)
		remove_dts_thermal_zone(&sensors->soc_dts[i]);

err_free:
	kfree(sensors);
	return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_init);

void intel_soc_dts_iosf_exit(struct intel_soc_dts_sensors *sensors)
{
	int i;

	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
		update_trip_temp(&sensors->soc_dts[i], 0, 0, 0);
		update_trip_temp(&sensors->soc_dts[i], 1, 0, 0);
		remove_dts_thermal_zone(&sensors->soc_dts[i]);
	}
	kfree(sensors);
}
EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_exit);

MODULE_LICENSE("GPL v2");
Commit	Line	Data
ee073604 SP	1	/*
	2	* intel_soc_dts_iosf.c
	3	* Copyright (c) 2015, Intel Corporation.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	*/
	15
	16	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	17
	18	#include <linux/module.h>
	19	#include <linux/slab.h>
	20	#include <linux/interrupt.h>
	21	#include <asm/iosf_mbi.h>
	22	#include "intel_soc_dts_iosf.h"
	23
	24	#define SOC_DTS_OFFSET_ENABLE 0xB0
	25	#define SOC_DTS_OFFSET_TEMP 0xB1
	26
	27	#define SOC_DTS_OFFSET_PTPS 0xB2
	28	#define SOC_DTS_OFFSET_PTTS 0xB3
	29	#define SOC_DTS_OFFSET_PTTSS 0xB4
	30	#define SOC_DTS_OFFSET_PTMC 0x80
	31	#define SOC_DTS_TE_AUX0 0xB5
	32	#define SOC_DTS_TE_AUX1 0xB6
	33
	34	#define SOC_DTS_AUX0_ENABLE_BIT BIT(0)
	35	#define SOC_DTS_AUX1_ENABLE_BIT BIT(1)
	36	#define SOC_DTS_CPU_MODULE0_ENABLE_BIT BIT(16)
	37	#define SOC_DTS_CPU_MODULE1_ENABLE_BIT BIT(17)
	38	#define SOC_DTS_TE_SCI_ENABLE BIT(9)
	39	#define SOC_DTS_TE_SMI_ENABLE BIT(10)
	40	#define SOC_DTS_TE_MSI_ENABLE BIT(11)
	41	#define SOC_DTS_TE_APICA_ENABLE BIT(14)
	42	#define SOC_DTS_PTMC_APIC_DEASSERT_BIT BIT(4)
	43
	44	/* DTS encoding for TJ MAX temperature */
	45	#define SOC_DTS_TJMAX_ENCODING 0x7F
	46
	47	/* Only 2 out of 4 is allowed for OSPM */
	48	#define SOC_MAX_DTS_TRIPS 2
	49
	50	/* Mask for two trips in status bits */
	51	#define SOC_DTS_TRIP_MASK 0x03
	52
	53	/* DTS0 and DTS 1 */
	54	#define SOC_MAX_DTS_SENSORS 2
	55
	56	static int get_tj_max(u32 *tj_max)
	57	{
	58	u32 eax, edx;
	59	u32 val;
	60	int err;
	61
	62	err = rdmsr_safe(MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
	63	if (err)
	64	goto err_ret;
65	else {
66	val = (eax >> 16) & 0xff;
67	if (val)
68	tj_max = val 1000;
69	else {
70	err = -EINVAL;
71	goto err_ret;
72	}
73	}
74
75	return 0;
76	err_ret:
77	*tj_max = 0;
78
79	return err;
80	}
81
82	static int sys_get_trip_temp(struct thermal_zone_device *tzd, int trip,
17e8351a	83	int *temp)
ee073604 SP	84	{
	85	int status;
	86	u32 out;
	87	struct intel_soc_dts_sensor_entry *dts;
	88	struct intel_soc_dts_sensors *sensors;
	89
	90	dts = tzd->devdata;
	91	sensors = dts->sensors;
	92	mutex_lock(&sensors->dts_update_lock);
	93	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	94	SOC_DTS_OFFSET_PTPS, &out);
	95	mutex_unlock(&sensors->dts_update_lock);
	96	if (status)
	97	return status;
	98
	99	out = (out >> (trip * 8)) & SOC_DTS_TJMAX_ENCODING;
	100	if (!out)
	101	*temp = 0;
	102	else
	103	temp = sensors->tj_max - out 1000;
	104
	105	return 0;
	106	}
	107
	108	static int update_trip_temp(struct intel_soc_dts_sensor_entry *dts,
17e8351a	109	int thres_index, int temp,
ee073604 SP	110	enum thermal_trip_type trip_type)
	111	{
	112	int status;
	113	u32 temp_out;
	114	u32 out;
	115	u32 store_ptps;
	116	u32 store_ptmc;
	117	u32 store_te_out;
	118	u32 te_out;
	119	u32 int_enable_bit = SOC_DTS_TE_APICA_ENABLE;
	120	struct intel_soc_dts_sensors *sensors = dts->sensors;
	121
	122	if (sensors->intr_type == INTEL_SOC_DTS_INTERRUPT_MSI)
	123	int_enable_bit \|= SOC_DTS_TE_MSI_ENABLE;
	124
	125	temp_out = (sensors->tj_max - temp) / 1000;
	126
	127	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	128	SOC_DTS_OFFSET_PTPS, &store_ptps);
	129	if (status)
	130	return status;
	131
	132	out = (store_ptps & ~(0xFF << (thres_index * 8)));
	133	out \|= (temp_out & 0xFF) << (thres_index * 8);
	134	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
	135	SOC_DTS_OFFSET_PTPS, out);
	136	if (status)
	137	return status;
	138
	139	pr_debug("update_trip_temp PTPS = %x\n", out);
	140	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	141	SOC_DTS_OFFSET_PTMC, &out);
	142	if (status)
	143	goto err_restore_ptps;
	144
	145	store_ptmc = out;
	146
	147	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	148	SOC_DTS_TE_AUX0 + thres_index,
	149	&te_out);
	150	if (status)
	151	goto err_restore_ptmc;
	152
	153	store_te_out = te_out;
	154	/* Enable for CPU module 0 and module 1 */
	155	out \|= (SOC_DTS_CPU_MODULE0_ENABLE_BIT \|
	156	SOC_DTS_CPU_MODULE1_ENABLE_BIT);
	157	if (temp) {
	158	if (thres_index)
	159	out \|= SOC_DTS_AUX1_ENABLE_BIT;
	160	else
	161	out \|= SOC_DTS_AUX0_ENABLE_BIT;
	162	te_out \|= int_enable_bit;
	163	} else {
	164	if (thres_index)
	165	out &= ~SOC_DTS_AUX1_ENABLE_BIT;
	166	else
	167	out &= ~SOC_DTS_AUX0_ENABLE_BIT;
	168	te_out &= ~int_enable_bit;
	169	}
	170	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
	171	SOC_DTS_OFFSET_PTMC, out);
	172	if (status)
	173	goto err_restore_te_out;
174
175	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
176	SOC_DTS_TE_AUX0 + thres_index,
177	te_out);
178	if (status)
179	goto err_restore_te_out;
180
181	dts->trip_types[thres_index] = trip_type;
182
183	return 0;
184	err_restore_te_out:
185	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
186	SOC_DTS_OFFSET_PTMC, store_te_out);
187	err_restore_ptmc:
188	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
189	SOC_DTS_OFFSET_PTMC, store_ptmc);
190	err_restore_ptps:
191	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
192	SOC_DTS_OFFSET_PTPS, store_ptps);
193	/* Nothing we can do if restore fails */
194
195	return status;
196	}
197
198	static int sys_set_trip_temp(struct thermal_zone_device *tzd, int trip,
17e8351a	199	int temp)
ee073604 SP	200	{
	201	struct intel_soc_dts_sensor_entry *dts = tzd->devdata;
	202	struct intel_soc_dts_sensors *sensors = dts->sensors;
	203	int status;
	204
	205	if (temp > sensors->tj_max)
	206	return -EINVAL;
	207
	208	mutex_lock(&sensors->dts_update_lock);
	209	status = update_trip_temp(tzd->devdata, trip, temp,
	210	dts->trip_types[trip]);
	211	mutex_unlock(&sensors->dts_update_lock);
	212
	213	return status;
	214	}
	215
	216	static int sys_get_trip_type(struct thermal_zone_device *tzd,
	217	int trip, enum thermal_trip_type *type)
	218	{
	219	struct intel_soc_dts_sensor_entry *dts;
	220
	221	dts = tzd->devdata;
	222
	223	*type = dts->trip_types[trip];
	224
	225	return 0;
	226	}
	227
	228	static int sys_get_curr_temp(struct thermal_zone_device *tzd,
17e8351a	229	int *temp)
ee073604 SP	230	{
	231	int status;
	232	u32 out;
	233	struct intel_soc_dts_sensor_entry *dts;
	234	struct intel_soc_dts_sensors *sensors;
	235
	236	dts = tzd->devdata;
	237	sensors = dts->sensors;
	238	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	239	SOC_DTS_OFFSET_TEMP, &out);
	240	if (status)
	241	return status;
	242
	243	out = (out & dts->temp_mask) >> dts->temp_shift;
	244	out -= SOC_DTS_TJMAX_ENCODING;
	245	temp = sensors->tj_max - out 1000;
	246
	247	return 0;
	248	}
	249
	250	static struct thermal_zone_device_ops tzone_ops = {
	251	.get_temp = sys_get_curr_temp,
	252	.get_trip_temp = sys_get_trip_temp,
	253	.get_trip_type = sys_get_trip_type,
	254	.set_trip_temp = sys_set_trip_temp,
	255	};
	256
	257	static int soc_dts_enable(int id)
	258	{
	259	u32 out;
	260	int ret;
	261
	262	ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	263	SOC_DTS_OFFSET_ENABLE, &out);
	264	if (ret)
	265	return ret;
	266
	267	if (!(out & BIT(id))) {
	268	out \|= BIT(id);
	269	ret = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
	270	SOC_DTS_OFFSET_ENABLE, out);
	271	if (ret)
	272	return ret;
	273	}
	274
	275	return ret;
	276	}
	277
	278	static void remove_dts_thermal_zone(struct intel_soc_dts_sensor_entry *dts)
	279	{
	280	if (dts) {
	281	iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
	282	SOC_DTS_OFFSET_ENABLE, dts->store_status);
	283	thermal_zone_device_unregister(dts->tzone);
	284	}
	285	}
	286
	287	static int add_dts_thermal_zone(int id, struct intel_soc_dts_sensor_entry *dts,
	288	bool notification_support, int trip_cnt,
	289	int read_only_trip_cnt)
	290	{
	291	char name[10];
	292	int trip_count = 0;
	293	int trip_mask = 0;
294	u32 store_ptps;
295	int ret;
296	int i;
297
298	/* Store status to restor on exit */
299	ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
300	SOC_DTS_OFFSET_ENABLE,
301	&dts->store_status);
302	if (ret)
303	goto err_ret;
304
305	dts->id = id;
306	dts->temp_mask = 0x00FF << (id * 8);
307	dts->temp_shift = id * 8;
308	if (notification_support) {
309	trip_count = min(SOC_MAX_DTS_TRIPS, trip_cnt);
310	trip_mask = BIT(trip_count - read_only_trip_cnt) - 1;
311	}
312
313	/* Check if the writable trip we provide is not used by BIOS */
314	ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
315	SOC_DTS_OFFSET_PTPS, &store_ptps);
316	if (ret)
317	trip_mask = 0;
318	else {
319	for (i = 0; i < trip_count; ++i) {
320	if (trip_mask & BIT(i))
321	if (store_ptps & (0xff << (i * 8)))
322	trip_mask &= ~BIT(i);
323	}
324	}
325	dts->trip_mask = trip_mask;
326	dts->trip_count = trip_count;
327	snprintf(name, sizeof(name), "soc_dts%d", id);
328	dts->tzone = thermal_zone_device_register(name,
329	trip_count,
330	trip_mask,
331	dts, &tzone_ops,
332	NULL, 0, 0);
333	if (IS_ERR(dts->tzone)) {
334	ret = PTR_ERR(dts->tzone);
335	goto err_ret;
336	}
337
338	ret = soc_dts_enable(id);
339	if (ret)
340	goto err_enable;
341
342	return 0;
343	err_enable:
344	thermal_zone_device_unregister(dts->tzone);
345	err_ret:
346	return ret;
347	}
348
349	int intel_soc_dts_iosf_add_read_only_critical_trip(
350	struct intel_soc_dts_sensors *sensors, int critical_offset)
351	{
352	int i, j;
ee073604 SP	353
	354	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
	355	for (j = 0; j < sensors->soc_dts[i].trip_count; ++j) {
	356	if (!(sensors->soc_dts[i].trip_mask & BIT(j))) {
bd7081ae	357	return update_trip_temp(&sensors->soc_dts[i], j,
ee073604 SP	358	sensors->tj_max - critical_offset,
ee073604 SP	359	THERMAL_TRIP_CRITICAL);
ee073604 SP	360	}
	361	}
	362	}
	363
	364	return -EINVAL;
	365	}
	366	EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_add_read_only_critical_trip);
	367
	368	void intel_soc_dts_iosf_interrupt_handler(struct intel_soc_dts_sensors *sensors)
	369	{
	370	u32 sticky_out;
	371	int status;
	372	u32 ptmc_out;
	373	unsigned long flags;
	374
	375	spin_lock_irqsave(&sensors->intr_notify_lock, flags);
	376
	377	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	378	SOC_DTS_OFFSET_PTMC, &ptmc_out);
	379	ptmc_out \|= SOC_DTS_PTMC_APIC_DEASSERT_BIT;
	380	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
	381	SOC_DTS_OFFSET_PTMC, ptmc_out);
	382
	383	status = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
	384	SOC_DTS_OFFSET_PTTSS, &sticky_out);
	385	pr_debug("status %d PTTSS %x\n", status, sticky_out);
	386	if (sticky_out & SOC_DTS_TRIP_MASK) {
	387	int i;
	388	/* reset sticky bit */
	389	status = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
	390	SOC_DTS_OFFSET_PTTSS, sticky_out);
	391	spin_unlock_irqrestore(&sensors->intr_notify_lock, flags);
	392
	393	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
	394	pr_debug("TZD update for zone %d\n", i);
	395	thermal_zone_device_update(sensors->soc_dts[i].tzone);
	396	}
	397	} else
	398	spin_unlock_irqrestore(&sensors->intr_notify_lock, flags);
	399	}
	400	EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_interrupt_handler);
	401
	402	struct intel_soc_dts_sensors *intel_soc_dts_iosf_init(
	403	enum intel_soc_dts_interrupt_type intr_type, int trip_count,
	404	int read_only_trip_count)
	405	{
	406	struct intel_soc_dts_sensors *sensors;
	407	bool notification;
	408	u32 tj_max;
	409	int ret;
	410	int i;
	411
	412	if (!iosf_mbi_available())
	413	return ERR_PTR(-ENODEV);
	414
	415	if (!trip_count \|\| read_only_trip_count > trip_count)
	416	return ERR_PTR(-EINVAL);
	417
	418	if (get_tj_max(&tj_max))
	419	return ERR_PTR(-EINVAL);
	420
	421	sensors = kzalloc(sizeof(*sensors), GFP_KERNEL);
	422	if (!sensors)
	423	return ERR_PTR(-ENOMEM);
424
425	spin_lock_init(&sensors->intr_notify_lock);
426	mutex_init(&sensors->dts_update_lock);
427	sensors->intr_type = intr_type;
428	sensors->tj_max = tj_max;
429	if (intr_type == INTEL_SOC_DTS_INTERRUPT_NONE)
430	notification = false;
431	else
432	notification = true;
433	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
434	sensors->soc_dts[i].sensors = sensors;
435	ret = add_dts_thermal_zone(i, &sensors->soc_dts[i],
436	notification, trip_count,
437	read_only_trip_count);
438	if (ret)
439	goto err_free;
440	}
441
442	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
443	ret = update_trip_temp(&sensors->soc_dts[i], 0, 0,
444	THERMAL_TRIP_PASSIVE);
445	if (ret)
446	goto err_remove_zone;
447
448	ret = update_trip_temp(&sensors->soc_dts[i], 1, 0,
449	THERMAL_TRIP_PASSIVE);
450	if (ret)
451	goto err_remove_zone;
452	}
453
454	return sensors;
455	err_remove_zone:
456	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i)
457	remove_dts_thermal_zone(&sensors->soc_dts[i]);
458
459	err_free:
460	kfree(sensors);
461	return ERR_PTR(ret);
462	}
463	EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_init);
464
465	void intel_soc_dts_iosf_exit(struct intel_soc_dts_sensors *sensors)
466	{
467	int i;
468
469	for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
470	update_trip_temp(&sensors->soc_dts[i], 0, 0, 0);
471	update_trip_temp(&sensors->soc_dts[i], 1, 0, 0);
472	remove_dts_thermal_zone(&sensors->soc_dts[i]);
473	}
474	kfree(sensors);
475	}
476	EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_exit);
477
478	MODULE_LICENSE("GPL v2");