drivers/thermal/ti-soc-thermal/ti-bandgap.h

   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
 120 struct 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  */
 185 struct 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
 199 struct 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  */
 213 struct 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  */
 239 struct 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: sensor gradient slope info for hotspot extrapolation equation
 258  * @constant: sensor gradient const info for hotspot extrapolation equation
 259  * @slope_pcb: sensor gradient slope info for hotspot extrapolation equation
 260  *             with no external influence
 261  * @constant_pcb: sensor gradient const info for hotspot extrapolation equation
 262  *             with no external influence
 263  * @register_cooling: function to describe how this sensor is going to be cooled
 264  * @unregister_cooling: function to release cooling data
 265  *
 266  * Data structure to describe a temperature sensor handled by a bandgap device.
 267  * It should provide configuration details on this sensor, such as how to
 268  * access the registers affecting this sensor, shadow register buffer, how to
 269  * assess the gradient from hotspot, how to cooldown the domain when sensor
 270  * reports too hot temperature.
 271  */
 272 struct ti_temp_sensor {
 273         struct temp_sensor_data         *ts_data;
 274         struct temp_sensor_registers    *registers;
 275         char                            *domain;
 276         /* for hotspot extrapolation */
 277         const int                       slope;
 278         const int                       constant;
 279         const int                       slope_pcb;
 280         const int                       constant_pcb;
 281         int (*register_cooling)(struct ti_bandgap *bgp, int id);
 282         int (*unregister_cooling)(struct ti_bandgap *bgp, int id);
 283 };
 284
 285 /**
 286  * DOC: ti bandgap feature types
 287  *
 288  * TI_BANDGAP_FEATURE_TSHUT - used when the thermal shutdown signal output
 289  *      of a bandgap device instance is routed to the processor. This means
 290  *      the system must react and perform the shutdown by itself (handle an
 291  *      IRQ, for instance).
 292  *
 293  * TI_BANDGAP_FEATURE_TSHUT_CONFIG - used when the bandgap device has control
 294  *      over the thermal shutdown configuration. This means that the thermal
 295  *      shutdown thresholds are programmable, for instance.
 296  *
 297  * TI_BANDGAP_FEATURE_TALERT - used when the bandgap device instance outputs
 298  *      a signal representing violation of programmable alert thresholds.
 299  *
 300  * TI_BANDGAP_FEATURE_MODE_CONFIG - used when it is possible to choose which
 301  *      mode, continuous or one shot, the bandgap device instance will operate.
 302  *
 303  * TI_BANDGAP_FEATURE_COUNTER - used when the bandgap device instance allows
 304  *      programming the update interval of its internal state machine.
 305  *
 306  * TI_BANDGAP_FEATURE_POWER_SWITCH - used when the bandgap device allows
 307  *      itself to be switched on/off.
 308  *
 309  * TI_BANDGAP_FEATURE_CLK_CTRL - used when the clocks feeding the bandgap
 310  *      device are gateable or not.
 311  *
 312  * TI_BANDGAP_FEATURE_FREEZE_BIT - used when the bandgap device features
 313  *      a history buffer that its update can be freezed/unfreezed.
 314  *
 315  * TI_BANDGAP_FEATURE_COUNTER_DELAY - used when the bandgap device features
 316  *      a delay programming based on distinct values.
 317  *
 318  * TI_BANDGAP_FEATURE_HISTORY_BUFFER - used when the bandgap device features
 319  *      a history buffer of temperatures.
 320  *
 321  * TI_BANDGAP_HAS(b, f) - macro to check if a bandgap device is capable of a
 322  *      specific feature (above) or not. Return non-zero, if yes.
 323  */
 324 #define TI_BANDGAP_FEATURE_TSHUT                BIT(0)
 325 #define TI_BANDGAP_FEATURE_TSHUT_CONFIG         BIT(1)
 326 #define TI_BANDGAP_FEATURE_TALERT               BIT(2)
 327 #define TI_BANDGAP_FEATURE_MODE_CONFIG          BIT(3)
 328 #define TI_BANDGAP_FEATURE_COUNTER              BIT(4)
 329 #define TI_BANDGAP_FEATURE_POWER_SWITCH         BIT(5)
 330 #define TI_BANDGAP_FEATURE_CLK_CTRL             BIT(6)
 331 #define TI_BANDGAP_FEATURE_FREEZE_BIT           BIT(7)
 332 #define TI_BANDGAP_FEATURE_COUNTER_DELAY        BIT(8)
 333 #define TI_BANDGAP_FEATURE_HISTORY_BUFFER       BIT(9)
 334 #define TI_BANDGAP_HAS(b, f)                    \
 335                         ((b)->conf->features & TI_BANDGAP_FEATURE_ ## f)
 336
 337 /**
 338  * struct ti_bandgap_data - ti bandgap data configuration structure
 339  * @features: a bitwise flag set to describe the device features
 340  * @conv_table: Pointer to ADC to temperature conversion table
 341  * @adc_start_val: ADC conversion table starting value
 342  * @adc_end_val: ADC conversion table ending value
 343  * @fclock_name: clock name of the functional clock
 344  * @div_ck_name: clock name of the clock divisor
 345  * @sensor_count: count of temperature sensor within this bandgap device
 346  * @report_temperature: callback to report thermal alert to thermal API
 347  * @expose_sensor: callback to export sensor to thermal API
 348  * @remove_sensor: callback to destroy sensor from thermal API
 349  * @sensors: array of sensors present in this bandgap instance
 350  *
 351  * This is a data structure which should hold most of the static configuration
 352  * of a bandgap device instance. It should describe which features this instance
 353  * is capable of, the clock names to feed this device, the amount of sensors and
 354  * their configuration representation, and how to export and unexport them to
 355  * a thermal API.
 356  */
 357 struct ti_bandgap_data {
 358         unsigned int                    features;
 359         const int                       *conv_table;
 360         u32                             adc_start_val;
 361         u32                             adc_end_val;
 362         char                            *fclock_name;
 363         char                            *div_ck_name;
 364         int                             sensor_count;
 365         int (*report_temperature)(struct ti_bandgap *bgp, int id);
 366         int (*expose_sensor)(struct ti_bandgap *bgp, int id, char *domain);
 367         int (*remove_sensor)(struct ti_bandgap *bgp, int id);
 368
 369         /* this needs to be at the end */
 370         struct ti_temp_sensor           sensors[];
 371 };
 372
 373 int ti_bandgap_read_thot(struct ti_bandgap *bgp, int id, int *thot);
 374 int ti_bandgap_write_thot(struct ti_bandgap *bgp, int id, int val);
 375 int ti_bandgap_read_tcold(struct ti_bandgap *bgp, int id, int *tcold);
 376 int ti_bandgap_write_tcold(struct ti_bandgap *bgp, int id, int val);
 377 int ti_bandgap_read_update_interval(struct ti_bandgap *bgp, int id,
 378                                     int *interval);
 379 int ti_bandgap_write_update_interval(struct ti_bandgap *bgp, int id,
 380                                      u32 interval);
 381 int ti_bandgap_read_temperature(struct ti_bandgap *bgp, int id,
 382                                   int *temperature);
 383 int ti_bandgap_set_sensor_data(struct ti_bandgap *bgp, int id, void *data);
 384 void *ti_bandgap_get_sensor_data(struct ti_bandgap *bgp, int id);
 385 int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend);
 386
 387 #ifdef CONFIG_OMAP4_THERMAL
 388 extern const struct ti_bandgap_data omap4430_data;
 389 extern const struct ti_bandgap_data omap4460_data;
 390 extern const struct ti_bandgap_data omap4470_data;
 391 #else
 392 #define omap4430_data                                   NULL
 393 #define omap4460_data                                   NULL
 394 #define omap4470_data                                   NULL
 395 #endif
 396
 397 #ifdef CONFIG_OMAP5_THERMAL
 398 extern const struct ti_bandgap_data omap5430_data;
 399 #else
 400 #define omap5430_data                                   NULL
 401 #endif
 402
 403 #ifdef CONFIG_DRA752_THERMAL
 404 extern const struct ti_bandgap_data dra752_data;
 405 #else
 406 #define dra752_data                                     NULL
 407 #endif
 408 #endif