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