1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * OMAP4 Bandgap temperature sensor driver 4 * 5 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ 6 * Contact: 7 * Eduardo Valentin <eduardo.valentin@ti.com> 8 */ 9 #ifndef __TI_BANDGAP_H 10 #define __TI_BANDGAP_H 11 12 #include <linux/spinlock.h> 13 #include <linux/types.h> 14 #include <linux/err.h> 15 #include <linux/cpu_pm.h> 16 #include <linux/device.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/pm.h> 19 20 struct gpio_desc; 21 22 /** 23 * DOC: bandgap driver data structure 24 * ================================== 25 * 26 * +----------+----------------+ 27 * | struct temp_sensor_regval | 28 * +---------------------------+ 29 * * (Array of) 30 * | 31 * | 32 * +-------------------+ +-----------------+ 33 * | struct ti_bandgap |-->| struct device * | 34 * +----------+--------+ +-----------------+ 35 * | 36 * | 37 * V 38 * +------------------------+ 39 * | struct ti_bandgap_data | 40 * +------------------------+ 41 * | 42 * | 43 * * (Array of) 44 * +------------+------------------------------------------------------+ 45 * | +----------+------------+ +-------------------------+ | 46 * | | struct ti_temp_sensor |-->| struct temp_sensor_data | | 47 * | +-----------------------+ +------------+------------+ | 48 * | | | 49 * | + | 50 * | V | 51 * | +----------+-------------------+ | 52 * | | struct temp_sensor_registers | | 53 * | +------------------------------+ | 54 * | | 55 * +-------------------------------------------------------------------+ 56 * 57 * Above is a simple diagram describing how the data structure below 58 * are organized. For each bandgap device there should be a ti_bandgap_data 59 * containing the device instance configuration, as well as, an array of 60 * sensors, representing every sensor instance present in this bandgap. 61 */ 62 63 /** 64 * struct temp_sensor_registers - descriptor to access registers and bitfields 65 * @temp_sensor_ctrl: TEMP_SENSOR_CTRL register offset 66 * @bgap_tempsoff_mask: mask to temp_sensor_ctrl.tempsoff 67 * @bgap_soc_mask: mask to temp_sensor_ctrl.soc 68 * @bgap_eocz_mask: mask to temp_sensor_ctrl.eocz 69 * @bgap_dtemp_mask: mask to temp_sensor_ctrl.dtemp 70 * @bgap_mask_ctrl: BANDGAP_MASK_CTRL register offset 71 * @mask_hot_mask: mask to bandgap_mask_ctrl.mask_hot 72 * @mask_cold_mask: mask to bandgap_mask_ctrl.mask_cold 73 * @mask_counter_delay_mask: mask to bandgap_mask_ctrl.mask_counter_delay 74 * @mask_freeze_mask: mask to bandgap_mask_ctrl.mask_free 75 * @bgap_mode_ctrl: BANDGAP_MODE_CTRL register offset 76 * @mode_ctrl_mask: mask to bandgap_mode_ctrl.mode_ctrl 77 * @bgap_counter: BANDGAP_COUNTER register offset 78 * @counter_mask: mask to bandgap_counter.counter 79 * @bgap_threshold: BANDGAP_THRESHOLD register offset (TALERT thresholds) 80 * @threshold_thot_mask: mask to bandgap_threhold.thot 81 * @threshold_tcold_mask: mask to bandgap_threhold.tcold 82 * @tshut_threshold: TSHUT_THRESHOLD register offset (TSHUT thresholds) 83 * @tshut_hot_mask: mask to tshut_threhold.thot 84 * @tshut_cold_mask: mask to tshut_threhold.thot 85 * @bgap_status: BANDGAP_STATUS register offset 86 * @status_hot_mask: mask to bandgap_status.hot 87 * @status_cold_mask: mask to bandgap_status.cold 88 * @ctrl_dtemp_1: CTRL_DTEMP1 register offset 89 * @ctrl_dtemp_2: CTRL_DTEMP2 register offset 90 * @bgap_efuse: BANDGAP_EFUSE register offset 91 * 92 * The register offsets and bitfields might change across 93 * OMAP and variants versions. Hence this struct serves as a 94 * descriptor map on how to access the registers and the bitfields. 95 * 96 * This descriptor contains registers of all versions of bandgap chips. 97 * Not all versions will use all registers, depending on the available 98 * features. Please read TRMs for descriptive explanation on each bitfield. 99 */ 100 101 struct temp_sensor_registers { 102 u32 temp_sensor_ctrl; 103 u32 bgap_tempsoff_mask; 104 u32 bgap_soc_mask; 105 u32 bgap_eocz_mask; 106 u32 bgap_dtemp_mask; 107 108 u32 bgap_mask_ctrl; 109 u32 mask_hot_mask; 110 u32 mask_cold_mask; 111 u32 mask_counter_delay_mask; 112 u32 mask_freeze_mask; 113 114 u32 bgap_mode_ctrl; 115 u32 mode_ctrl_mask; 116 117 u32 bgap_counter; 118 u32 counter_mask; 119 120 u32 bgap_threshold; 121 u32 threshold_thot_mask; 122 u32 threshold_tcold_mask; 123 124 u32 tshut_threshold; 125 u32 tshut_hot_mask; 126 u32 tshut_cold_mask; 127 128 u32 bgap_status; 129 u32 status_hot_mask; 130 u32 status_cold_mask; 131 132 u32 ctrl_dtemp_1; 133 u32 ctrl_dtemp_2; 134 u32 bgap_efuse; 135 }; 136 137 /** 138 * struct temp_sensor_data - The thresholds and limits for temperature sensors. 139 * @tshut_hot: temperature to trigger a thermal reset (initial value) 140 * @tshut_cold: temp to get the plat out of reset due to thermal (init val) 141 * @t_hot: temperature to trigger a thermal alert (high initial value) 142 * @t_cold: temperature to trigger a thermal alert (low initial value) 143 * @min_freq: sensor minimum clock rate 144 * @max_freq: sensor maximum clock rate 145 * 146 * This data structure will hold the required thresholds and temperature limits 147 * for a specific temperature sensor, like shutdown temperature, alert 148 * temperature, clock / rate used, ADC conversion limits and update intervals 149 */ 150 struct temp_sensor_data { 151 u32 tshut_hot; 152 u32 tshut_cold; 153 u32 t_hot; 154 u32 t_cold; 155 u32 min_freq; 156 u32 max_freq; 157 }; 158 159 struct ti_bandgap_data; 160 161 /** 162 * struct temp_sensor_regval - temperature sensor register values and priv data 163 * @bg_mode_ctrl: temp sensor control register value 164 * @bg_ctrl: bandgap ctrl register value 165 * @bg_counter: bandgap counter value 166 * @bg_threshold: bandgap threshold register value 167 * @tshut_threshold: bandgap tshut register value 168 * @data: private data 169 * 170 * Data structure to save and restore bandgap register set context. Only 171 * required registers are shadowed, when needed. 172 */ 173 struct temp_sensor_regval { 174 u32 bg_mode_ctrl; 175 u32 bg_ctrl; 176 u32 bg_counter; 177 u32 bg_threshold; 178 u32 tshut_threshold; 179 void *data; 180 }; 181 182 /** 183 * struct ti_bandgap - bandgap device structure 184 * @dev: struct device pointer 185 * @base: io memory base address 186 * @conf: struct with bandgap configuration set (# sensors, conv_table, etc) 187 * @regval: temperature sensor register values 188 * @fclock: pointer to functional clock of temperature sensor 189 * @div_clk: pointer to divider clock of temperature sensor fclk 190 * @lock: spinlock for ti_bandgap structure 191 * @irq: MPU IRQ number for thermal alert 192 * @tshut_gpio: GPIO where Tshut signal is routed 193 * @clk_rate: Holds current clock rate 194 * 195 * The bandgap device structure representing the bandgap device instance. 196 * It holds most of the dynamic stuff. Configurations and sensor specific 197 * entries are inside the @conf structure. 198 */ 199 struct ti_bandgap { 200 struct device *dev; 201 void __iomem *base; 202 const struct ti_bandgap_data *conf; 203 struct temp_sensor_regval *regval; 204 struct clk *fclock; 205 struct clk *div_clk; 206 spinlock_t lock; /* shields this struct */ 207 int irq; 208 struct gpio_desc *tshut_gpiod; 209 u32 clk_rate; 210 struct notifier_block nb; 211 unsigned int is_suspended:1; 212 }; 213 214 /** 215 * struct ti_temp_sensor - bandgap temperature sensor configuration data 216 * @ts_data: pointer to struct with thresholds, limits of temperature sensor 217 * @registers: pointer to the list of register offsets and bitfields 218 * @domain: the name of the domain where the sensor is located 219 * @slope_pcb: sensor gradient slope info for hotspot extrapolation equation 220 * with no external influence 221 * @constant_pcb: sensor gradient const info for hotspot extrapolation equation 222 * with no external influence 223 * @register_cooling: function to describe how this sensor is going to be cooled 224 * @unregister_cooling: function to release cooling data 225 * 226 * Data structure to describe a temperature sensor handled by a bandgap device. 227 * It should provide configuration details on this sensor, such as how to 228 * access the registers affecting this sensor, shadow register buffer, how to 229 * assess the gradient from hotspot, how to cooldown the domain when sensor 230 * reports too hot temperature. 231 */ 232 struct ti_temp_sensor { 233 struct temp_sensor_data *ts_data; 234 struct temp_sensor_registers *registers; 235 char *domain; 236 /* for hotspot extrapolation */ 237 const int slope_pcb; 238 const int constant_pcb; 239 int (*register_cooling)(struct ti_bandgap *bgp, int id); 240 int (*unregister_cooling)(struct ti_bandgap *bgp, int id); 241 }; 242 243 /** 244 * DOC: ti bandgap feature types 245 * 246 * TI_BANDGAP_FEATURE_TSHUT - used when the thermal shutdown signal output 247 * of a bandgap device instance is routed to the processor. This means 248 * the system must react and perform the shutdown by itself (handle an 249 * IRQ, for instance). 250 * 251 * TI_BANDGAP_FEATURE_TSHUT_CONFIG - used when the bandgap device has control 252 * over the thermal shutdown configuration. This means that the thermal 253 * shutdown thresholds are programmable, for instance. 254 * 255 * TI_BANDGAP_FEATURE_TALERT - used when the bandgap device instance outputs 256 * a signal representing violation of programmable alert thresholds. 257 * 258 * TI_BANDGAP_FEATURE_MODE_CONFIG - used when it is possible to choose which 259 * mode, continuous or one shot, the bandgap device instance will operate. 260 * 261 * TI_BANDGAP_FEATURE_COUNTER - used when the bandgap device instance allows 262 * programming the update interval of its internal state machine. 263 * 264 * TI_BANDGAP_FEATURE_POWER_SWITCH - used when the bandgap device allows 265 * itself to be switched on/off. 266 * 267 * TI_BANDGAP_FEATURE_CLK_CTRL - used when the clocks feeding the bandgap 268 * device are gateable or not. 269 * 270 * TI_BANDGAP_FEATURE_FREEZE_BIT - used when the bandgap device features 271 * a history buffer that its update can be freezed/unfreezed. 272 * 273 * TI_BANDGAP_FEATURE_COUNTER_DELAY - used when the bandgap device features 274 * a delay programming based on distinct values. 275 * 276 * TI_BANDGAP_FEATURE_HISTORY_BUFFER - used when the bandgap device features 277 * a history buffer of temperatures. 278 * 279 * TI_BANDGAP_FEATURE_ERRATA_814 - used to workaorund when the bandgap device 280 * has Errata 814 281 * TI_BANDGAP_FEATURE_UNRELIABLE - used when the sensor readings are too 282 * inaccurate. 283 * TI_BANDGAP_FEATURE_CONT_MODE_ONLY - used when single mode hangs the sensor 284 * TI_BANDGAP_HAS(b, f) - macro to check if a bandgap device is capable of a 285 * specific feature (above) or not. Return non-zero, if yes. 286 */ 287 #define TI_BANDGAP_FEATURE_TSHUT BIT(0) 288 #define TI_BANDGAP_FEATURE_TSHUT_CONFIG BIT(1) 289 #define TI_BANDGAP_FEATURE_TALERT BIT(2) 290 #define TI_BANDGAP_FEATURE_MODE_CONFIG BIT(3) 291 #define TI_BANDGAP_FEATURE_COUNTER BIT(4) 292 #define TI_BANDGAP_FEATURE_POWER_SWITCH BIT(5) 293 #define TI_BANDGAP_FEATURE_CLK_CTRL BIT(6) 294 #define TI_BANDGAP_FEATURE_FREEZE_BIT BIT(7) 295 #define TI_BANDGAP_FEATURE_COUNTER_DELAY BIT(8) 296 #define TI_BANDGAP_FEATURE_HISTORY_BUFFER BIT(9) 297 #define TI_BANDGAP_FEATURE_ERRATA_814 BIT(10) 298 #define TI_BANDGAP_FEATURE_UNRELIABLE BIT(11) 299 #define TI_BANDGAP_FEATURE_CONT_MODE_ONLY BIT(12) 300 #define TI_BANDGAP_HAS(b, f) \ 301 ((b)->conf->features & TI_BANDGAP_FEATURE_ ## f) 302 303 /** 304 * struct ti_bandgap_data - ti bandgap data configuration structure 305 * @features: a bitwise flag set to describe the device features 306 * @conv_table: Pointer to ADC to temperature conversion table 307 * @adc_start_val: ADC conversion table starting value 308 * @adc_end_val: ADC conversion table ending value 309 * @fclock_name: clock name of the functional clock 310 * @div_ck_name: clock name of the clock divisor 311 * @sensor_count: count of temperature sensor within this bandgap device 312 * @report_temperature: callback to report thermal alert to thermal API 313 * @expose_sensor: callback to export sensor to thermal API 314 * @remove_sensor: callback to destroy sensor from thermal API 315 * @sensors: array of sensors present in this bandgap instance 316 * 317 * This is a data structure which should hold most of the static configuration 318 * of a bandgap device instance. It should describe which features this instance 319 * is capable of, the clock names to feed this device, the amount of sensors and 320 * their configuration representation, and how to export and unexport them to 321 * a thermal API. 322 */ 323 struct ti_bandgap_data { 324 unsigned int features; 325 const int *conv_table; 326 u32 adc_start_val; 327 u32 adc_end_val; 328 char *fclock_name; 329 char *div_ck_name; 330 int sensor_count; 331 int (*report_temperature)(struct ti_bandgap *bgp, int id); 332 int (*expose_sensor)(struct ti_bandgap *bgp, int id, char *domain); 333 int (*remove_sensor)(struct ti_bandgap *bgp, int id); 334 335 /* this needs to be at the end */ 336 struct ti_temp_sensor sensors[]; 337 }; 338 339 int ti_bandgap_read_thot(struct ti_bandgap *bgp, int id, int *thot); 340 int ti_bandgap_write_thot(struct ti_bandgap *bgp, int id, int val); 341 int ti_bandgap_read_tcold(struct ti_bandgap *bgp, int id, int *tcold); 342 int ti_bandgap_write_tcold(struct ti_bandgap *bgp, int id, int val); 343 int ti_bandgap_read_update_interval(struct ti_bandgap *bgp, int id, 344 int *interval); 345 int ti_bandgap_write_update_interval(struct ti_bandgap *bgp, int id, 346 u32 interval); 347 int ti_bandgap_read_temperature(struct ti_bandgap *bgp, int id, 348 int *temperature); 349 int ti_bandgap_set_sensor_data(struct ti_bandgap *bgp, int id, void *data); 350 void *ti_bandgap_get_sensor_data(struct ti_bandgap *bgp, int id); 351 int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend); 352 353 #ifdef CONFIG_OMAP3_THERMAL 354 extern const struct ti_bandgap_data omap34xx_data; 355 extern const struct ti_bandgap_data omap36xx_data; 356 #else 357 #define omap34xx_data NULL 358 #define omap36xx_data NULL 359 #endif 360 361 #ifdef CONFIG_OMAP4_THERMAL 362 extern const struct ti_bandgap_data omap4430_data; 363 extern const struct ti_bandgap_data omap4460_data; 364 extern const struct ti_bandgap_data omap4470_data; 365 #else 366 #define omap4430_data NULL 367 #define omap4460_data NULL 368 #define omap4470_data NULL 369 #endif 370 371 #ifdef CONFIG_OMAP5_THERMAL 372 extern const struct ti_bandgap_data omap5430_data; 373 #else 374 #define omap5430_data NULL 375 #endif 376 377 #ifdef CONFIG_DRA752_THERMAL 378 extern const struct ti_bandgap_data dra752_data; 379 #else 380 #define dra752_data NULL 381 #endif 382 #endif 383