| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * intel_soc_dts_iosf.c | |
| * Copyright (c) 2015, Intel Corporation. | |
| */ | |
| #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
| #include <linux/bitops.h> | |
| #include <linux/intel_tcc.h> | |
| #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 | |
| /* Mask for two trips in status bits */ | |
| #define SOC_DTS_TRIP_MASK 0x03 | |
| static int update_trip_temp(struct intel_soc_dts_sensors *sensors, | |
| int thres_index, int temp) | |
| { | |
| int status; | |
| u32 temp_out; | |
| u32 out; | |
| unsigned long update_ptps; | |
| u32 store_ptps; | |
| u32 store_ptmc; | |
| u32 store_te_out; | |
| u32 te_out; | |
| u32 int_enable_bit = SOC_DTS_TE_APICA_ENABLE; | |
| 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, MBI_REG_READ, | |
| SOC_DTS_OFFSET_PTPS, &store_ptps); | |
| if (status) | |
| return status; | |
| update_ptps = store_ptps; | |
| bitmap_set_value8(&update_ptps, temp_out & 0xFF, thres_index * 8); | |
| out = update_ptps; | |
| status = iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_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, MBI_REG_READ, | |
| SOC_DTS_OFFSET_PTMC, &out); | |
| if (status) | |
| goto err_restore_ptps; | |
| store_ptmc = out; | |
| status = iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_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, MBI_REG_WRITE, | |
| SOC_DTS_OFFSET_PTMC, out); | |
| if (status) | |
| goto err_restore_te_out; | |
| status = iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, | |
| SOC_DTS_TE_AUX0 + thres_index, | |
| te_out); | |
| if (status) | |
| goto err_restore_te_out; | |
| return 0; | |
| err_restore_te_out: | |
| iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, | |
| SOC_DTS_OFFSET_PTMC, store_te_out); | |
| err_restore_ptmc: | |
| iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, | |
| SOC_DTS_OFFSET_PTMC, store_ptmc); | |
| err_restore_ptps: | |
| iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_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, | |
| const struct thermal_trip *trip, | |
| int temp) | |
| { | |
| struct intel_soc_dts_sensor_entry *dts = thermal_zone_device_priv(tzd); | |
| struct intel_soc_dts_sensors *sensors = dts->sensors; | |
| unsigned int trip_index = THERMAL_TRIP_PRIV_TO_INT(trip->priv); | |
| int status; | |
| if (temp > sensors->tj_max) | |
| return -EINVAL; | |
| mutex_lock(&sensors->dts_update_lock); | |
| status = update_trip_temp(sensors, trip_index, temp); | |
| mutex_unlock(&sensors->dts_update_lock); | |
| return status; | |
| } | |
| static int sys_get_curr_temp(struct thermal_zone_device *tzd, | |
| int *temp) | |
| { | |
| int status; | |
| u32 out; | |
| struct intel_soc_dts_sensor_entry *dts = thermal_zone_device_priv(tzd); | |
| struct intel_soc_dts_sensors *sensors; | |
| unsigned long raw; | |
| sensors = dts->sensors; | |
| status = iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, | |
| SOC_DTS_OFFSET_TEMP, &out); | |
| if (status) | |
| return status; | |
| raw = out; | |
| out = bitmap_get_value8(&raw, dts->id * 8) - SOC_DTS_TJMAX_ENCODING; | |
| *temp = sensors->tj_max - out * 1000; | |
| return 0; | |
| } | |
| static const struct thermal_zone_device_ops tzone_ops = { | |
| .get_temp = sys_get_curr_temp, | |
| .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, MBI_REG_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, MBI_REG_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) | |
| { | |
| iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_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, | |
| struct thermal_trip *trips) | |
| { | |
| char name[10]; | |
| u32 store_ptps; | |
| int ret; | |
| /* Store status to restor on exit */ | |
| ret = iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, | |
| SOC_DTS_OFFSET_ENABLE, &dts->store_status); | |
| if (ret) | |
| goto err_ret; | |
| dts->id = id; | |
| /* Check if the writable trip we provide is not used by BIOS */ | |
| ret = iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, | |
| SOC_DTS_OFFSET_PTPS, &store_ptps); | |
| if (!ret) { | |
| int i; | |
| for (i = 0; i <= 1; i++) { | |
| if (store_ptps & (0xFFU << i * 8)) | |
| trips[i].flags &= ~THERMAL_TRIP_FLAG_RW_TEMP; | |
| } | |
| } | |
| snprintf(name, sizeof(name), "soc_dts%d", id); | |
| dts->tzone = thermal_zone_device_register_with_trips(name, trips, | |
| SOC_MAX_DTS_TRIPS, | |
| dts, &tzone_ops, | |
| NULL, 0, 0); | |
| if (IS_ERR(dts->tzone)) { | |
| ret = PTR_ERR(dts->tzone); | |
| goto err_ret; | |
| } | |
| ret = thermal_zone_device_enable(dts->tzone); | |
| if (ret) | |
| goto err_enable; | |
| ret = soc_dts_enable(id); | |
| if (ret) | |
| goto err_enable; | |
| return 0; | |
| err_enable: | |
| thermal_zone_device_unregister(dts->tzone); | |
| err_ret: | |
| return ret; | |
| } | |
| 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, MBI_REG_READ, | |
| SOC_DTS_OFFSET_PTMC, &ptmc_out); | |
| ptmc_out |= SOC_DTS_PTMC_APIC_DEASSERT_BIT; | |
| status = iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, | |
| SOC_DTS_OFFSET_PTMC, ptmc_out); | |
| status = iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_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, MBI_REG_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, | |
| THERMAL_EVENT_UNSPECIFIED); | |
| } | |
| } else | |
| spin_unlock_irqrestore(&sensors->intr_notify_lock, flags); | |
| } | |
| EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_interrupt_handler); | |
| static void dts_trips_reset(struct intel_soc_dts_sensors *sensors, int dts_index) | |
| { | |
| update_trip_temp(sensors, 0, 0); | |
| update_trip_temp(sensors, 1, 0); | |
| } | |
| static void set_trip(struct thermal_trip *trip, enum thermal_trip_type type, | |
| u8 flags, int temp, unsigned int index) | |
| { | |
| trip->type = type; | |
| trip->flags = flags; | |
| trip->temperature = temp; | |
| trip->priv = THERMAL_INT_TO_TRIP_PRIV(index); | |
| } | |
| struct intel_soc_dts_sensors * | |
| intel_soc_dts_iosf_init(enum intel_soc_dts_interrupt_type intr_type, | |
| bool critical_trip, int crit_offset) | |
| { | |
| struct thermal_trip trips[SOC_MAX_DTS_SENSORS][SOC_MAX_DTS_TRIPS] = { 0 }; | |
| struct intel_soc_dts_sensors *sensors; | |
| int tj_max; | |
| int ret; | |
| int i; | |
| if (!iosf_mbi_available()) | |
| return ERR_PTR(-ENODEV); | |
| tj_max = intel_tcc_get_tjmax(-1); | |
| if (tj_max < 0) | |
| return ERR_PTR(tj_max); | |
| 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 * 1000; | |
| for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) { | |
| int temp; | |
| sensors->soc_dts[i].sensors = sensors; | |
| set_trip(&trips[i][0], THERMAL_TRIP_PASSIVE, | |
| THERMAL_TRIP_FLAG_RW_TEMP, 0, 0); | |
| ret = update_trip_temp(sensors, 0, 0); | |
| if (ret) | |
| goto err_reset_trips; | |
| if (critical_trip) { | |
| temp = sensors->tj_max - crit_offset; | |
| set_trip(&trips[i][1], THERMAL_TRIP_CRITICAL, 0, temp, 1); | |
| } else { | |
| set_trip(&trips[i][1], THERMAL_TRIP_PASSIVE, | |
| THERMAL_TRIP_FLAG_RW_TEMP, 0, 1); | |
| temp = 0; | |
| } | |
| ret = update_trip_temp(sensors, 1, temp); | |
| if (ret) | |
| goto err_reset_trips; | |
| } | |
| for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) { | |
| ret = add_dts_thermal_zone(i, &sensors->soc_dts[i], trips[i]); | |
| 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_reset_trips: | |
| for (i = 0; i < SOC_MAX_DTS_SENSORS; i++) | |
| dts_trips_reset(sensors, i); | |
| 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) { | |
| remove_dts_thermal_zone(&sensors->soc_dts[i]); | |
| dts_trips_reset(sensors, i); | |
| } | |
| kfree(sensors); | |
| } | |
| EXPORT_SYMBOL_GPL(intel_soc_dts_iosf_exit); | |
| MODULE_IMPORT_NS(INTEL_TCC); | |
| MODULE_LICENSE("GPL v2"); | |
| MODULE_DESCRIPTION("SoC DTS driver using side band interface"); |