1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Amlogic Thermal Sensor Driver 4 * 5 * Copyright (C) 2017 Huan Biao <huan.biao@amlogic.com> 6 * Copyright (C) 2019 Guillaume La Roque <glaroque@baylibre.com> 7 * 8 * Register value to celsius temperature formulas: 9 * Read_Val m * U 10 * U = ---------, Uptat = --------- 11 * 2^16 1 + n * U 12 * 13 * Temperature = A * ( Uptat + u_efuse / 2^16 )- B 14 * 15 * A B m n : calibration parameters 16 * u_efuse : fused calibration value, it's a signed 16 bits value 17 */ 18 19 #include <linux/bitfield.h> 20 #include <linux/clk.h> 21 #include <linux/io.h> 22 #include <linux/mfd/syscon.h> 23 #include <linux/module.h> 24 #include <linux/of.h> 25 #include <linux/platform_device.h> 26 #include <linux/regmap.h> 27 #include <linux/thermal.h> 28 29 #include "thermal_hwmon.h" 30 31 #define TSENSOR_CFG_REG1 0x4 32 #define TSENSOR_CFG_REG1_RSET_VBG BIT(12) 33 #define TSENSOR_CFG_REG1_RSET_ADC BIT(11) 34 #define TSENSOR_CFG_REG1_VCM_EN BIT(10) 35 #define TSENSOR_CFG_REG1_VBG_EN BIT(9) 36 #define TSENSOR_CFG_REG1_OUT_CTL BIT(6) 37 #define TSENSOR_CFG_REG1_FILTER_EN BIT(5) 38 #define TSENSOR_CFG_REG1_DEM_EN BIT(3) 39 #define TSENSOR_CFG_REG1_CH_SEL GENMASK(1, 0) 40 #define TSENSOR_CFG_REG1_ENABLE \ 41 (TSENSOR_CFG_REG1_FILTER_EN | \ 42 TSENSOR_CFG_REG1_VCM_EN | \ 43 TSENSOR_CFG_REG1_VBG_EN | \ 44 TSENSOR_CFG_REG1_DEM_EN | \ 45 TSENSOR_CFG_REG1_CH_SEL) 46 47 #define TSENSOR_STAT0 0x40 48 49 #define TSENSOR_STAT9 0x64 50 51 #define TSENSOR_READ_TEMP_MASK GENMASK(15, 0) 52 #define TSENSOR_TEMP_MASK GENMASK(11, 0) 53 54 #define TSENSOR_TRIM_SIGN_MASK BIT(15) 55 #define TSENSOR_TRIM_TEMP_MASK GENMASK(14, 0) 56 #define TSENSOR_TRIM_VERSION_MASK GENMASK(31, 24) 57 58 #define TSENSOR_TRIM_VERSION(_version) \ 59 FIELD_GET(TSENSOR_TRIM_VERSION_MASK, _version) 60 61 #define TSENSOR_TRIM_CALIB_VALID_MASK (GENMASK(3, 2) | BIT(7)) 62 63 #define TSENSOR_CALIB_OFFSET 1 64 #define TSENSOR_CALIB_SHIFT 4 65 66 /** 67 * struct amlogic_thermal_soc_calib_data 68 * @A: calibration parameters 69 * @B: calibration parameters 70 * @m: calibration parameters 71 * @n: calibration parameters 72 * 73 * This structure is required for configuration of amlogic thermal driver. 74 */ 75 struct amlogic_thermal_soc_calib_data { 76 int A; 77 int B; 78 int m; 79 int n; 80 }; 81 82 /** 83 * struct amlogic_thermal_data 84 * @u_efuse_off: register offset to read fused calibration value 85 * @calibration_parameters: calibration parameters structure pointer 86 * @regmap_config: regmap config for the device 87 * This structure is required for configuration of amlogic thermal driver. 88 */ 89 struct amlogic_thermal_data { 90 int u_efuse_off; 91 const struct amlogic_thermal_soc_calib_data *calibration_parameters; 92 const struct regmap_config *regmap_config; 93 }; 94 95 struct amlogic_thermal { 96 struct platform_device *pdev; 97 const struct amlogic_thermal_data *data; 98 struct regmap *regmap; 99 struct regmap *sec_ao_map; 100 struct clk *clk; 101 struct thermal_zone_device *tzd; 102 u32 trim_info; 103 }; 104 105 /* 106 * Calculate a temperature value from a temperature code. 107 * The unit of the temperature is degree milliCelsius. 108 */ 109 static int amlogic_thermal_code_to_millicelsius(struct amlogic_thermal *pdata, 110 int temp_code) 111 { 112 const struct amlogic_thermal_soc_calib_data *param = 113 pdata->data->calibration_parameters; 114 int temp; 115 s64 factor, Uptat, uefuse; 116 117 uefuse = pdata->trim_info & TSENSOR_TRIM_SIGN_MASK ? 118 ~(pdata->trim_info & TSENSOR_TRIM_TEMP_MASK) + 1 : 119 (pdata->trim_info & TSENSOR_TRIM_TEMP_MASK); 120 121 factor = param->n * temp_code; 122 factor = div_s64(factor, 100); 123 124 Uptat = temp_code * param->m; 125 Uptat = div_s64(Uptat, 100); 126 Uptat = Uptat * BIT(16); 127 Uptat = div_s64(Uptat, BIT(16) + factor); 128 129 temp = (Uptat + uefuse) * param->A; 130 temp = div_s64(temp, BIT(16)); 131 temp = (temp - param->B) * 100; 132 133 return temp; 134 } 135 136 static int amlogic_thermal_initialize(struct amlogic_thermal *pdata) 137 { 138 int ret = 0; 139 int ver; 140 141 regmap_read(pdata->sec_ao_map, pdata->data->u_efuse_off, 142 &pdata->trim_info); 143 144 ver = TSENSOR_TRIM_VERSION(pdata->trim_info); 145 146 if ((ver & TSENSOR_TRIM_CALIB_VALID_MASK) == 0) { 147 ret = -EINVAL; 148 dev_err(&pdata->pdev->dev, 149 "tsensor thermal calibration not supported: 0x%x!\n", 150 ver); 151 } 152 153 return ret; 154 } 155 156 static int amlogic_thermal_enable(struct amlogic_thermal *data) 157 { 158 int ret; 159 160 ret = clk_prepare_enable(data->clk); 161 if (ret) 162 return ret; 163 164 regmap_update_bits(data->regmap, TSENSOR_CFG_REG1, 165 TSENSOR_CFG_REG1_ENABLE, TSENSOR_CFG_REG1_ENABLE); 166 167 return 0; 168 } 169 170 static int amlogic_thermal_disable(struct amlogic_thermal *data) 171 { 172 regmap_update_bits(data->regmap, TSENSOR_CFG_REG1, 173 TSENSOR_CFG_REG1_ENABLE, 0); 174 clk_disable_unprepare(data->clk); 175 176 return 0; 177 } 178 179 static int amlogic_thermal_get_temp(struct thermal_zone_device *tz, int *temp) 180 { 181 unsigned int tval; 182 struct amlogic_thermal *pdata = thermal_zone_device_priv(tz); 183 184 if (!pdata) 185 return -EINVAL; 186 187 regmap_read(pdata->regmap, TSENSOR_STAT0, &tval); 188 *temp = 189 amlogic_thermal_code_to_millicelsius(pdata, 190 tval & TSENSOR_READ_TEMP_MASK); 191 192 return 0; 193 } 194 195 static const struct thermal_zone_device_ops amlogic_thermal_ops = { 196 .get_temp = amlogic_thermal_get_temp, 197 }; 198 199 static const struct regmap_config amlogic_thermal_regmap_config_g12a = { 200 .reg_bits = 8, 201 .val_bits = 32, 202 .reg_stride = 4, 203 .max_register = TSENSOR_STAT9, 204 }; 205 206 static const struct amlogic_thermal_soc_calib_data amlogic_thermal_g12a = { 207 .A = 9411, 208 .B = 3159, 209 .m = 424, 210 .n = 324, 211 }; 212 213 static const struct amlogic_thermal_data amlogic_thermal_g12a_cpu_param = { 214 .u_efuse_off = 0x128, 215 .calibration_parameters = &amlogic_thermal_g12a, 216 .regmap_config = &amlogic_thermal_regmap_config_g12a, 217 }; 218 219 static const struct amlogic_thermal_data amlogic_thermal_g12a_ddr_param = { 220 .u_efuse_off = 0xf0, 221 .calibration_parameters = &amlogic_thermal_g12a, 222 .regmap_config = &amlogic_thermal_regmap_config_g12a, 223 }; 224 225 static const struct of_device_id of_amlogic_thermal_match[] = { 226 { 227 .compatible = "amlogic,g12a-ddr-thermal", 228 .data = &amlogic_thermal_g12a_ddr_param, 229 }, 230 { 231 .compatible = "amlogic,g12a-cpu-thermal", 232 .data = &amlogic_thermal_g12a_cpu_param, 233 }, 234 { /* sentinel */ } 235 }; 236 MODULE_DEVICE_TABLE(of, of_amlogic_thermal_match); 237 238 static int amlogic_thermal_probe(struct platform_device *pdev) 239 { 240 struct amlogic_thermal *pdata; 241 struct device *dev = &pdev->dev; 242 void __iomem *base; 243 int ret; 244 245 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 246 if (!pdata) 247 return -ENOMEM; 248 249 pdata->data = of_device_get_match_data(dev); 250 pdata->pdev = pdev; 251 platform_set_drvdata(pdev, pdata); 252 253 base = devm_platform_ioremap_resource(pdev, 0); 254 if (IS_ERR(base)) 255 return PTR_ERR(base); 256 257 pdata->regmap = devm_regmap_init_mmio(dev, base, 258 pdata->data->regmap_config); 259 if (IS_ERR(pdata->regmap)) 260 return PTR_ERR(pdata->regmap); 261 262 pdata->clk = devm_clk_get(dev, NULL); 263 if (IS_ERR(pdata->clk)) 264 return dev_err_probe(dev, PTR_ERR(pdata->clk), "failed to get clock\n"); 265 266 pdata->sec_ao_map = syscon_regmap_lookup_by_phandle 267 (pdev->dev.of_node, "amlogic,ao-secure"); 268 if (IS_ERR(pdata->sec_ao_map)) { 269 dev_err(dev, "syscon regmap lookup failed.\n"); 270 return PTR_ERR(pdata->sec_ao_map); 271 } 272 273 pdata->tzd = devm_thermal_of_zone_register(&pdev->dev, 274 0, 275 pdata, 276 &amlogic_thermal_ops); 277 if (IS_ERR(pdata->tzd)) { 278 ret = PTR_ERR(pdata->tzd); 279 dev_err(dev, "Failed to register tsensor: %d\n", ret); 280 return ret; 281 } 282 283 devm_thermal_add_hwmon_sysfs(&pdev->dev, pdata->tzd); 284 285 ret = amlogic_thermal_initialize(pdata); 286 if (ret) 287 return ret; 288 289 ret = amlogic_thermal_enable(pdata); 290 291 return ret; 292 } 293 294 static void amlogic_thermal_remove(struct platform_device *pdev) 295 { 296 struct amlogic_thermal *data = platform_get_drvdata(pdev); 297 298 amlogic_thermal_disable(data); 299 } 300 301 static int __maybe_unused amlogic_thermal_suspend(struct device *dev) 302 { 303 struct amlogic_thermal *data = dev_get_drvdata(dev); 304 305 return amlogic_thermal_disable(data); 306 } 307 308 static int __maybe_unused amlogic_thermal_resume(struct device *dev) 309 { 310 struct amlogic_thermal *data = dev_get_drvdata(dev); 311 312 return amlogic_thermal_enable(data); 313 } 314 315 static SIMPLE_DEV_PM_OPS(amlogic_thermal_pm_ops, 316 amlogic_thermal_suspend, amlogic_thermal_resume); 317 318 static struct platform_driver amlogic_thermal_driver = { 319 .driver = { 320 .name = "amlogic_thermal", 321 .pm = &amlogic_thermal_pm_ops, 322 .of_match_table = of_amlogic_thermal_match, 323 }, 324 .probe = amlogic_thermal_probe, 325 .remove_new = amlogic_thermal_remove, 326 }; 327 328 module_platform_driver(amlogic_thermal_driver); 329 330 MODULE_AUTHOR("Guillaume La Roque <glaroque@baylibre.com>"); 331 MODULE_DESCRIPTION("Amlogic thermal driver"); 332 MODULE_LICENSE("GPL v2"); 333