// SPDX-License-Identifier: GPL-2.0-or-later /* * db8500_thermal.c - DB8500 Thermal Management Implementation * * Copyright (C) 2012 ST-Ericsson * Copyright (C) 2012-2019 Linaro Ltd. * * Authors: Hongbo Zhang, Linus Walleij */ #include #include #include #include #include #include #include #include #define PRCMU_DEFAULT_MEASURE_TIME 0xFFF #define PRCMU_DEFAULT_LOW_TEMP 0 /** * db8500_thermal_points - the interpolation points that trigger * interrupts */ static const unsigned long db8500_thermal_points[] = { 15000, 20000, 25000, 30000, 35000, 40000, 45000, 50000, 55000, 60000, 65000, 70000, 75000, 80000, /* * This is where things start to get really bad for the * SoC and the thermal zones should be set up to trigger * critical temperature at 85000 mC so we don't get above * this point. */ 85000, 90000, 95000, 100000, }; struct db8500_thermal_zone { struct thermal_zone_device *tz; struct device *dev; unsigned long interpolated_temp; unsigned int cur_index; }; /* Callback to get current temperature */ static int db8500_thermal_get_temp(struct thermal_zone_device *tz, int *temp) { struct db8500_thermal_zone *th = thermal_zone_device_priv(tz); /* * TODO: There is no PRCMU interface to get temperature data currently, * so a pseudo temperature is returned , it works for thermal framework * and this will be fixed when the PRCMU interface is available. */ *temp = th->interpolated_temp; return 0; } static const struct thermal_zone_device_ops thdev_ops = { .get_temp = db8500_thermal_get_temp, }; static void db8500_thermal_update_config(struct db8500_thermal_zone *th, unsigned int idx, unsigned long next_low, unsigned long next_high) { prcmu_stop_temp_sense(); th->cur_index = idx; th->interpolated_temp = (next_low + next_high)/2; /* * The PRCMU accept absolute temperatures in celsius so divide * down the millicelsius with 1000 */ prcmu_config_hotmon((u8)(next_low/1000), (u8)(next_high/1000)); prcmu_start_temp_sense(PRCMU_DEFAULT_MEASURE_TIME); } static irqreturn_t prcmu_low_irq_handler(int irq, void *irq_data) { struct db8500_thermal_zone *th = irq_data; unsigned int idx = th->cur_index; unsigned long next_low, next_high; if (idx == 0) /* Meaningless for thermal management, ignoring it */ return IRQ_HANDLED; if (idx == 1) { next_high = db8500_thermal_points[0]; next_low = PRCMU_DEFAULT_LOW_TEMP; } else { next_high = db8500_thermal_points[idx - 1]; next_low = db8500_thermal_points[idx - 2]; } idx -= 1; db8500_thermal_update_config(th, idx, next_low, next_high); dev_dbg(th->dev, "PRCMU set max %ld, min %ld\n", next_high, next_low); thermal_zone_device_update(th->tz, THERMAL_EVENT_UNSPECIFIED); return IRQ_HANDLED; } static irqreturn_t prcmu_high_irq_handler(int irq, void *irq_data) { struct db8500_thermal_zone *th = irq_data; unsigned int idx = th->cur_index; unsigned long next_low, next_high; int num_points = ARRAY_SIZE(db8500_thermal_points); if (idx < num_points - 1) { next_high = db8500_thermal_points[idx+1]; next_low = db8500_thermal_points[idx]; idx += 1; db8500_thermal_update_config(th, idx, next_low, next_high); dev_dbg(th->dev, "PRCMU set max %ld, min %ld\n", next_high, next_low); } else if (idx == num_points - 1) /* So we roof out 1 degree over the max point */ th->interpolated_temp = db8500_thermal_points[idx] + 1; thermal_zone_device_update(th->tz, THERMAL_EVENT_UNSPECIFIED); return IRQ_HANDLED; } static int db8500_thermal_probe(struct platform_device *pdev) { struct db8500_thermal_zone *th = NULL; struct device *dev = &pdev->dev; int low_irq, high_irq, ret = 0; th = devm_kzalloc(dev, sizeof(*th), GFP_KERNEL); if (!th) return -ENOMEM; th->dev = dev; low_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW"); if (low_irq < 0) return low_irq; ret = devm_request_threaded_irq(dev, low_irq, NULL, prcmu_low_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, "dbx500_temp_low", th); if (ret < 0) { dev_err(dev, "failed to allocate temp low irq\n"); return ret; } high_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH"); if (high_irq < 0) return high_irq; ret = devm_request_threaded_irq(dev, high_irq, NULL, prcmu_high_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, "dbx500_temp_high", th); if (ret < 0) { dev_err(dev, "failed to allocate temp high irq\n"); return ret; } /* register of thermal sensor and get info from DT */ th->tz = devm_thermal_of_zone_register(dev, 0, th, &thdev_ops); if (IS_ERR(th->tz)) { dev_err(dev, "register thermal zone sensor failed\n"); return PTR_ERR(th->tz); } dev_info(dev, "thermal zone sensor registered\n"); /* Start measuring at the lowest point */ db8500_thermal_update_config(th, 0, PRCMU_DEFAULT_LOW_TEMP, db8500_thermal_points[0]); platform_set_drvdata(pdev, th); return 0; } static int db8500_thermal_suspend(struct platform_device *pdev, pm_message_t state) { prcmu_stop_temp_sense(); return 0; } static int db8500_thermal_resume(struct platform_device *pdev) { struct db8500_thermal_zone *th = platform_get_drvdata(pdev); /* Resume and start measuring at the lowest point */ db8500_thermal_update_config(th, 0, PRCMU_DEFAULT_LOW_TEMP, db8500_thermal_points[0]); return 0; } static const struct of_device_id db8500_thermal_match[] = { { .compatible = "stericsson,db8500-thermal" }, {}, }; MODULE_DEVICE_TABLE(of, db8500_thermal_match); static struct platform_driver db8500_thermal_driver = { .driver = { .name = "db8500-thermal", .of_match_table = db8500_thermal_match, }, .probe = db8500_thermal_probe, .suspend = db8500_thermal_suspend, .resume = db8500_thermal_resume, }; module_platform_driver(db8500_thermal_driver); MODULE_AUTHOR("Hongbo Zhang "); MODULE_DESCRIPTION("DB8500 thermal driver"); MODULE_LICENSE("GPL");