![Bartlomiej Zolnierkiewicz](/assets/img/avatar_default.png)
Majority of this code (i.e. functions from ti-bandgap.c) has been
introduced in May 2013 by commit eb982001db
("thermal: introduce TI
SoC thermal driver"). Just remove it altogether (in case it is needed
it can be easily resurrected from git repo).
While at it fix incorrect "not used" comments.
Tested-by: Keerthy <j-keerthy@ti.com>
Acked-by: Keerthy <j-keerthy@ti.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
1268 lines
32 KiB
C
1268 lines
32 KiB
C
/*
|
|
* TI Bandgap temperature sensor driver
|
|
*
|
|
* Copyright (C) 2011-2012 Texas Instruments Incorporated - http://www.ti.com/
|
|
* Author: J Keerthy <j-keerthy@ti.com>
|
|
* Author: Moiz Sonasath <m-sonasath@ti.com>
|
|
* Couple of fixes, DT and MFD adaptation:
|
|
* Eduardo Valentin <eduardo.valentin@ti.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* version 2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/export.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/types.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/io.h>
|
|
|
|
#include "ti-bandgap.h"
|
|
|
|
static int ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id);
|
|
|
|
/*** Helper functions to access registers and their bitfields ***/
|
|
|
|
/**
|
|
* ti_bandgap_readl() - simple read helper function
|
|
* @bgp: pointer to ti_bandgap structure
|
|
* @reg: desired register (offset) to be read
|
|
*
|
|
* Helper function to read bandgap registers. It uses the io remapped area.
|
|
* Return: the register value.
|
|
*/
|
|
static u32 ti_bandgap_readl(struct ti_bandgap *bgp, u32 reg)
|
|
{
|
|
return readl(bgp->base + reg);
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_writel() - simple write helper function
|
|
* @bgp: pointer to ti_bandgap structure
|
|
* @val: desired register value to be written
|
|
* @reg: desired register (offset) to be written
|
|
*
|
|
* Helper function to write bandgap registers. It uses the io remapped area.
|
|
*/
|
|
static void ti_bandgap_writel(struct ti_bandgap *bgp, u32 val, u32 reg)
|
|
{
|
|
writel(val, bgp->base + reg);
|
|
}
|
|
|
|
/**
|
|
* DOC: macro to update bits.
|
|
*
|
|
* RMW_BITS() - used to read, modify and update bandgap bitfields.
|
|
* The value passed will be shifted.
|
|
*/
|
|
#define RMW_BITS(bgp, id, reg, mask, val) \
|
|
do { \
|
|
struct temp_sensor_registers *t; \
|
|
u32 r; \
|
|
\
|
|
t = bgp->conf->sensors[(id)].registers; \
|
|
r = ti_bandgap_readl(bgp, t->reg); \
|
|
r &= ~t->mask; \
|
|
r |= (val) << __ffs(t->mask); \
|
|
ti_bandgap_writel(bgp, r, t->reg); \
|
|
} while (0)
|
|
|
|
/*** Basic helper functions ***/
|
|
|
|
/**
|
|
* ti_bandgap_power() - controls the power state of a bandgap device
|
|
* @bgp: pointer to ti_bandgap structure
|
|
* @on: desired power state (1 - on, 0 - off)
|
|
*
|
|
* Used to power on/off a bandgap device instance. Only used on those
|
|
* that features tempsoff bit.
|
|
*
|
|
* Return: 0 on success, -ENOTSUPP if tempsoff is not supported.
|
|
*/
|
|
static int ti_bandgap_power(struct ti_bandgap *bgp, bool on)
|
|
{
|
|
int i;
|
|
|
|
if (!TI_BANDGAP_HAS(bgp, POWER_SWITCH))
|
|
return -ENOTSUPP;
|
|
|
|
for (i = 0; i < bgp->conf->sensor_count; i++)
|
|
/* active on 0 */
|
|
RMW_BITS(bgp, i, temp_sensor_ctrl, bgap_tempsoff_mask, !on);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_errata814_bandgap_read_temp() - helper function to read dra7 sensor temperature
|
|
* @bgp: pointer to ti_bandgap structure
|
|
* @reg: desired register (offset) to be read
|
|
*
|
|
* Function to read dra7 bandgap sensor temperature. This is done separately
|
|
* so as to workaround the errata "Bandgap Temperature read Dtemp can be
|
|
* corrupted" - Errata ID: i814".
|
|
* Read accesses to registers listed below can be corrupted due to incorrect
|
|
* resynchronization between clock domains.
|
|
* Read access to registers below can be corrupted :
|
|
* CTRL_CORE_DTEMP_MPU/GPU/CORE/DSPEVE/IVA_n (n = 0 to 4)
|
|
* CTRL_CORE_TEMP_SENSOR_MPU/GPU/CORE/DSPEVE/IVA_n
|
|
*
|
|
* Return: the register value.
|
|
*/
|
|
static u32 ti_errata814_bandgap_read_temp(struct ti_bandgap *bgp, u32 reg)
|
|
{
|
|
u32 val1, val2;
|
|
|
|
val1 = ti_bandgap_readl(bgp, reg);
|
|
val2 = ti_bandgap_readl(bgp, reg);
|
|
|
|
/* If both times we read the same value then that is right */
|
|
if (val1 == val2)
|
|
return val1;
|
|
|
|
/* if val1 and val2 are different read it third time */
|
|
return ti_bandgap_readl(bgp, reg);
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_read_temp() - helper function to read sensor temperature
|
|
* @bgp: pointer to ti_bandgap structure
|
|
* @id: bandgap sensor id
|
|
*
|
|
* Function to concentrate the steps to read sensor temperature register.
|
|
* This function is desired because, depending on bandgap device version,
|
|
* it might be needed to freeze the bandgap state machine, before fetching
|
|
* the register value.
|
|
*
|
|
* Return: temperature in ADC values.
|
|
*/
|
|
static u32 ti_bandgap_read_temp(struct ti_bandgap *bgp, int id)
|
|
{
|
|
struct temp_sensor_registers *tsr;
|
|
u32 temp, reg;
|
|
|
|
tsr = bgp->conf->sensors[id].registers;
|
|
reg = tsr->temp_sensor_ctrl;
|
|
|
|
if (TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
|
|
RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
|
|
/*
|
|
* In case we cannot read from cur_dtemp / dtemp_0,
|
|
* then we read from the last valid temp read
|
|
*/
|
|
reg = tsr->ctrl_dtemp_1;
|
|
}
|
|
|
|
/* read temperature */
|
|
if (TI_BANDGAP_HAS(bgp, ERRATA_814))
|
|
temp = ti_errata814_bandgap_read_temp(bgp, reg);
|
|
else
|
|
temp = ti_bandgap_readl(bgp, reg);
|
|
|
|
temp &= tsr->bgap_dtemp_mask;
|
|
|
|
if (TI_BANDGAP_HAS(bgp, FREEZE_BIT))
|
|
RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
|
|
|
|
return temp;
|
|
}
|
|
|
|
/*** IRQ handlers ***/
|
|
|
|
/**
|
|
* ti_bandgap_talert_irq_handler() - handles Temperature alert IRQs
|
|
* @irq: IRQ number
|
|
* @data: private data (struct ti_bandgap *)
|
|
*
|
|
* This is the Talert handler. Use it only if bandgap device features
|
|
* HAS(TALERT). This handler goes over all sensors and checks their
|
|
* conditions and acts accordingly. In case there are events pending,
|
|
* it will reset the event mask to wait for the opposite event (next event).
|
|
* Every time there is a new event, it will be reported to thermal layer.
|
|
*
|
|
* Return: IRQ_HANDLED
|
|
*/
|
|
static irqreturn_t ti_bandgap_talert_irq_handler(int irq, void *data)
|
|
{
|
|
struct ti_bandgap *bgp = data;
|
|
struct temp_sensor_registers *tsr;
|
|
u32 t_hot = 0, t_cold = 0, ctrl;
|
|
int i;
|
|
|
|
spin_lock(&bgp->lock);
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
tsr = bgp->conf->sensors[i].registers;
|
|
ctrl = ti_bandgap_readl(bgp, tsr->bgap_status);
|
|
|
|
/* Read the status of t_hot */
|
|
t_hot = ctrl & tsr->status_hot_mask;
|
|
|
|
/* Read the status of t_cold */
|
|
t_cold = ctrl & tsr->status_cold_mask;
|
|
|
|
if (!t_cold && !t_hot)
|
|
continue;
|
|
|
|
ctrl = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
|
|
/*
|
|
* One TALERT interrupt: Two sources
|
|
* If the interrupt is due to t_hot then mask t_hot and
|
|
* and unmask t_cold else mask t_cold and unmask t_hot
|
|
*/
|
|
if (t_hot) {
|
|
ctrl &= ~tsr->mask_hot_mask;
|
|
ctrl |= tsr->mask_cold_mask;
|
|
} else if (t_cold) {
|
|
ctrl &= ~tsr->mask_cold_mask;
|
|
ctrl |= tsr->mask_hot_mask;
|
|
}
|
|
|
|
ti_bandgap_writel(bgp, ctrl, tsr->bgap_mask_ctrl);
|
|
|
|
dev_dbg(bgp->dev,
|
|
"%s: IRQ from %s sensor: hotevent %d coldevent %d\n",
|
|
__func__, bgp->conf->sensors[i].domain,
|
|
t_hot, t_cold);
|
|
|
|
/* report temperature to whom may concern */
|
|
if (bgp->conf->report_temperature)
|
|
bgp->conf->report_temperature(bgp, i);
|
|
}
|
|
spin_unlock(&bgp->lock);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_tshut_irq_handler() - handles Temperature shutdown signal
|
|
* @irq: IRQ number
|
|
* @data: private data (unused)
|
|
*
|
|
* This is the Tshut handler. Use it only if bandgap device features
|
|
* HAS(TSHUT). If any sensor fires the Tshut signal, we simply shutdown
|
|
* the system.
|
|
*
|
|
* Return: IRQ_HANDLED
|
|
*/
|
|
static irqreturn_t ti_bandgap_tshut_irq_handler(int irq, void *data)
|
|
{
|
|
pr_emerg("%s: TSHUT temperature reached. Needs shut down...\n",
|
|
__func__);
|
|
|
|
orderly_poweroff(true);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/*** Helper functions which manipulate conversion ADC <-> mi Celsius ***/
|
|
|
|
/**
|
|
* ti_bandgap_adc_to_mcelsius() - converts an ADC value to mCelsius scale
|
|
* @bgp: struct ti_bandgap pointer
|
|
* @adc_val: value in ADC representation
|
|
* @t: address where to write the resulting temperature in mCelsius
|
|
*
|
|
* Simple conversion from ADC representation to mCelsius. In case the ADC value
|
|
* is out of the ADC conv table range, it returns -ERANGE, 0 on success.
|
|
* The conversion table is indexed by the ADC values.
|
|
*
|
|
* Return: 0 if conversion was successful, else -ERANGE in case the @adc_val
|
|
* argument is out of the ADC conv table range.
|
|
*/
|
|
static
|
|
int ti_bandgap_adc_to_mcelsius(struct ti_bandgap *bgp, int adc_val, int *t)
|
|
{
|
|
const struct ti_bandgap_data *conf = bgp->conf;
|
|
|
|
/* look up for temperature in the table and return the temperature */
|
|
if (adc_val < conf->adc_start_val || adc_val > conf->adc_end_val)
|
|
return -ERANGE;
|
|
|
|
*t = bgp->conf->conv_table[adc_val - conf->adc_start_val];
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_validate() - helper to check the sanity of a struct ti_bandgap
|
|
* @bgp: struct ti_bandgap pointer
|
|
* @id: bandgap sensor id
|
|
*
|
|
* Checks if the bandgap pointer is valid and if the sensor id is also
|
|
* applicable.
|
|
*
|
|
* Return: 0 if no errors, -EINVAL for invalid @bgp pointer or -ERANGE if
|
|
* @id cannot index @bgp sensors.
|
|
*/
|
|
static inline int ti_bandgap_validate(struct ti_bandgap *bgp, int id)
|
|
{
|
|
if (!bgp || IS_ERR(bgp)) {
|
|
pr_err("%s: invalid bandgap pointer\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ((id < 0) || (id >= bgp->conf->sensor_count)) {
|
|
dev_err(bgp->dev, "%s: sensor id out of range (%d)\n",
|
|
__func__, id);
|
|
return -ERANGE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_read_counter() - read the sensor counter
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @interval: resulting update interval in miliseconds
|
|
*/
|
|
static void ti_bandgap_read_counter(struct ti_bandgap *bgp, int id,
|
|
int *interval)
|
|
{
|
|
struct temp_sensor_registers *tsr;
|
|
int time;
|
|
|
|
tsr = bgp->conf->sensors[id].registers;
|
|
time = ti_bandgap_readl(bgp, tsr->bgap_counter);
|
|
time = (time & tsr->counter_mask) >>
|
|
__ffs(tsr->counter_mask);
|
|
time = time * 1000 / bgp->clk_rate;
|
|
*interval = time;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_read_counter_delay() - read the sensor counter delay
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @interval: resulting update interval in miliseconds
|
|
*/
|
|
static void ti_bandgap_read_counter_delay(struct ti_bandgap *bgp, int id,
|
|
int *interval)
|
|
{
|
|
struct temp_sensor_registers *tsr;
|
|
int reg_val;
|
|
|
|
tsr = bgp->conf->sensors[id].registers;
|
|
|
|
reg_val = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
|
|
reg_val = (reg_val & tsr->mask_counter_delay_mask) >>
|
|
__ffs(tsr->mask_counter_delay_mask);
|
|
switch (reg_val) {
|
|
case 0:
|
|
*interval = 0;
|
|
break;
|
|
case 1:
|
|
*interval = 1;
|
|
break;
|
|
case 2:
|
|
*interval = 10;
|
|
break;
|
|
case 3:
|
|
*interval = 100;
|
|
break;
|
|
case 4:
|
|
*interval = 250;
|
|
break;
|
|
case 5:
|
|
*interval = 500;
|
|
break;
|
|
default:
|
|
dev_warn(bgp->dev, "Wrong counter delay value read from register %X",
|
|
reg_val);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_read_update_interval() - read the sensor update interval
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @interval: resulting update interval in miliseconds
|
|
*
|
|
* Return: 0 on success or the proper error code
|
|
*/
|
|
int ti_bandgap_read_update_interval(struct ti_bandgap *bgp, int id,
|
|
int *interval)
|
|
{
|
|
int ret = 0;
|
|
|
|
ret = ti_bandgap_validate(bgp, id);
|
|
if (ret)
|
|
goto exit;
|
|
|
|
if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
|
|
!TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
|
|
ret = -ENOTSUPP;
|
|
goto exit;
|
|
}
|
|
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER)) {
|
|
ti_bandgap_read_counter(bgp, id, interval);
|
|
goto exit;
|
|
}
|
|
|
|
ti_bandgap_read_counter_delay(bgp, id, interval);
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_write_counter_delay() - set the counter_delay
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @interval: desired update interval in miliseconds
|
|
*
|
|
* Return: 0 on success or the proper error code
|
|
*/
|
|
static int ti_bandgap_write_counter_delay(struct ti_bandgap *bgp, int id,
|
|
u32 interval)
|
|
{
|
|
int rval;
|
|
|
|
switch (interval) {
|
|
case 0: /* Immediate conversion */
|
|
rval = 0x0;
|
|
break;
|
|
case 1: /* Conversion after ever 1ms */
|
|
rval = 0x1;
|
|
break;
|
|
case 10: /* Conversion after ever 10ms */
|
|
rval = 0x2;
|
|
break;
|
|
case 100: /* Conversion after ever 100ms */
|
|
rval = 0x3;
|
|
break;
|
|
case 250: /* Conversion after ever 250ms */
|
|
rval = 0x4;
|
|
break;
|
|
case 500: /* Conversion after ever 500ms */
|
|
rval = 0x5;
|
|
break;
|
|
default:
|
|
dev_warn(bgp->dev, "Delay %d ms is not supported\n", interval);
|
|
return -EINVAL;
|
|
}
|
|
|
|
spin_lock(&bgp->lock);
|
|
RMW_BITS(bgp, id, bgap_mask_ctrl, mask_counter_delay_mask, rval);
|
|
spin_unlock(&bgp->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_write_counter() - set the bandgap sensor counter
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @interval: desired update interval in miliseconds
|
|
*/
|
|
static void ti_bandgap_write_counter(struct ti_bandgap *bgp, int id,
|
|
u32 interval)
|
|
{
|
|
interval = interval * bgp->clk_rate / 1000;
|
|
spin_lock(&bgp->lock);
|
|
RMW_BITS(bgp, id, bgap_counter, counter_mask, interval);
|
|
spin_unlock(&bgp->lock);
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_write_update_interval() - set the update interval
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @interval: desired update interval in miliseconds
|
|
*
|
|
* Return: 0 on success or the proper error code
|
|
*/
|
|
int ti_bandgap_write_update_interval(struct ti_bandgap *bgp,
|
|
int id, u32 interval)
|
|
{
|
|
int ret = ti_bandgap_validate(bgp, id);
|
|
if (ret)
|
|
goto exit;
|
|
|
|
if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
|
|
!TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
|
|
ret = -ENOTSUPP;
|
|
goto exit;
|
|
}
|
|
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER)) {
|
|
ti_bandgap_write_counter(bgp, id, interval);
|
|
goto exit;
|
|
}
|
|
|
|
ret = ti_bandgap_write_counter_delay(bgp, id, interval);
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_read_temperature() - report current temperature
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @temperature: resulting temperature
|
|
*
|
|
* Return: 0 on success or the proper error code
|
|
*/
|
|
int ti_bandgap_read_temperature(struct ti_bandgap *bgp, int id,
|
|
int *temperature)
|
|
{
|
|
u32 temp;
|
|
int ret;
|
|
|
|
ret = ti_bandgap_validate(bgp, id);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!TI_BANDGAP_HAS(bgp, MODE_CONFIG)) {
|
|
ret = ti_bandgap_force_single_read(bgp, id);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
spin_lock(&bgp->lock);
|
|
temp = ti_bandgap_read_temp(bgp, id);
|
|
spin_unlock(&bgp->lock);
|
|
|
|
ret = ti_bandgap_adc_to_mcelsius(bgp, temp, &temp);
|
|
if (ret)
|
|
return -EIO;
|
|
|
|
*temperature = temp;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_set_sensor_data() - helper function to store thermal
|
|
* framework related data.
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
* @data: thermal framework related data to be stored
|
|
*
|
|
* Return: 0 on success or the proper error code
|
|
*/
|
|
int ti_bandgap_set_sensor_data(struct ti_bandgap *bgp, int id, void *data)
|
|
{
|
|
int ret = ti_bandgap_validate(bgp, id);
|
|
if (ret)
|
|
return ret;
|
|
|
|
bgp->regval[id].data = data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_get_sensor_data() - helper function to get thermal
|
|
* framework related data.
|
|
* @bgp: pointer to bandgap instance
|
|
* @id: sensor id
|
|
*
|
|
* Return: data stored by set function with sensor id on success or NULL
|
|
*/
|
|
void *ti_bandgap_get_sensor_data(struct ti_bandgap *bgp, int id)
|
|
{
|
|
int ret = ti_bandgap_validate(bgp, id);
|
|
if (ret)
|
|
return ERR_PTR(ret);
|
|
|
|
return bgp->regval[id].data;
|
|
}
|
|
|
|
/*** Helper functions used during device initialization ***/
|
|
|
|
/**
|
|
* ti_bandgap_force_single_read() - executes 1 single ADC conversion
|
|
* @bgp: pointer to struct ti_bandgap
|
|
* @id: sensor id which it is desired to read 1 temperature
|
|
*
|
|
* Used to initialize the conversion state machine and set it to a valid
|
|
* state. Called during device initialization and context restore events.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
static int
|
|
ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id)
|
|
{
|
|
u32 counter = 1000;
|
|
struct temp_sensor_registers *tsr;
|
|
|
|
/* Select single conversion mode */
|
|
if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
|
|
RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 0);
|
|
|
|
/* Start of Conversion = 1 */
|
|
RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 1);
|
|
|
|
/* Wait for EOCZ going up */
|
|
tsr = bgp->conf->sensors[id].registers;
|
|
|
|
while (--counter) {
|
|
if (ti_bandgap_readl(bgp, tsr->temp_sensor_ctrl) &
|
|
tsr->bgap_eocz_mask)
|
|
break;
|
|
}
|
|
|
|
/* Start of Conversion = 0 */
|
|
RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 0);
|
|
|
|
/* Wait for EOCZ going down */
|
|
counter = 1000;
|
|
while (--counter) {
|
|
if (!(ti_bandgap_readl(bgp, tsr->temp_sensor_ctrl) &
|
|
tsr->bgap_eocz_mask))
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_set_continuous_mode() - One time enabling of continuous mode
|
|
* @bgp: pointer to struct ti_bandgap
|
|
*
|
|
* Call this function only if HAS(MODE_CONFIG) is set. As this driver may
|
|
* be used for junction temperature monitoring, it is desirable that the
|
|
* sensors are operational all the time, so that alerts are generated
|
|
* properly.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
static int ti_bandgap_set_continuous_mode(struct ti_bandgap *bgp)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
/* Perform a single read just before enabling continuous */
|
|
ti_bandgap_force_single_read(bgp, i);
|
|
RMW_BITS(bgp, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_get_trend() - To fetch the temperature trend of a sensor
|
|
* @bgp: pointer to struct ti_bandgap
|
|
* @id: id of the individual sensor
|
|
* @trend: Pointer to trend.
|
|
*
|
|
* This function needs to be called to fetch the temperature trend of a
|
|
* Particular sensor. The function computes the difference in temperature
|
|
* w.r.t time. For the bandgaps with built in history buffer the temperatures
|
|
* are read from the buffer and for those without the Buffer -ENOTSUPP is
|
|
* returned.
|
|
*
|
|
* Return: 0 if no error, else return corresponding error. If no
|
|
* error then the trend value is passed on to trend parameter
|
|
*/
|
|
int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend)
|
|
{
|
|
struct temp_sensor_registers *tsr;
|
|
u32 temp1, temp2, reg1, reg2;
|
|
int t1, t2, interval, ret = 0;
|
|
|
|
ret = ti_bandgap_validate(bgp, id);
|
|
if (ret)
|
|
goto exit;
|
|
|
|
if (!TI_BANDGAP_HAS(bgp, HISTORY_BUFFER) ||
|
|
!TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
|
|
ret = -ENOTSUPP;
|
|
goto exit;
|
|
}
|
|
|
|
spin_lock(&bgp->lock);
|
|
|
|
tsr = bgp->conf->sensors[id].registers;
|
|
|
|
/* Freeze and read the last 2 valid readings */
|
|
RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
|
|
reg1 = tsr->ctrl_dtemp_1;
|
|
reg2 = tsr->ctrl_dtemp_2;
|
|
|
|
/* read temperature from history buffer */
|
|
temp1 = ti_bandgap_readl(bgp, reg1);
|
|
temp1 &= tsr->bgap_dtemp_mask;
|
|
|
|
temp2 = ti_bandgap_readl(bgp, reg2);
|
|
temp2 &= tsr->bgap_dtemp_mask;
|
|
|
|
/* Convert from adc values to mCelsius temperature */
|
|
ret = ti_bandgap_adc_to_mcelsius(bgp, temp1, &t1);
|
|
if (ret)
|
|
goto unfreeze;
|
|
|
|
ret = ti_bandgap_adc_to_mcelsius(bgp, temp2, &t2);
|
|
if (ret)
|
|
goto unfreeze;
|
|
|
|
/* Fetch the update interval */
|
|
ret = ti_bandgap_read_update_interval(bgp, id, &interval);
|
|
if (ret)
|
|
goto unfreeze;
|
|
|
|
/* Set the interval to 1 ms if bandgap counter delay is not set */
|
|
if (interval == 0)
|
|
interval = 1;
|
|
|
|
*trend = (t1 - t2) / interval;
|
|
|
|
dev_dbg(bgp->dev, "The temperatures are t1 = %d and t2 = %d and trend =%d\n",
|
|
t1, t2, *trend);
|
|
|
|
unfreeze:
|
|
RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
|
|
spin_unlock(&bgp->lock);
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_tshut_init() - setup and initialize tshut handling
|
|
* @bgp: pointer to struct ti_bandgap
|
|
* @pdev: pointer to device struct platform_device
|
|
*
|
|
* Call this function only in case the bandgap features HAS(TSHUT).
|
|
* In this case, the driver needs to handle the TSHUT signal as an IRQ.
|
|
* The IRQ is wired as a GPIO, and for this purpose, it is required
|
|
* to specify which GPIO line is used. TSHUT IRQ is fired anytime
|
|
* one of the bandgap sensors violates the TSHUT high/hot threshold.
|
|
* And in that case, the system must go off.
|
|
*
|
|
* Return: 0 if no error, else error status
|
|
*/
|
|
static int ti_bandgap_tshut_init(struct ti_bandgap *bgp,
|
|
struct platform_device *pdev)
|
|
{
|
|
int gpio_nr = bgp->tshut_gpio;
|
|
int status;
|
|
|
|
/* Request for gpio_86 line */
|
|
status = gpio_request(gpio_nr, "tshut");
|
|
if (status < 0) {
|
|
dev_err(bgp->dev, "Could not request for TSHUT GPIO:%i\n", 86);
|
|
return status;
|
|
}
|
|
status = gpio_direction_input(gpio_nr);
|
|
if (status) {
|
|
dev_err(bgp->dev, "Cannot set input TSHUT GPIO %d\n", gpio_nr);
|
|
return status;
|
|
}
|
|
|
|
status = request_irq(gpio_to_irq(gpio_nr), ti_bandgap_tshut_irq_handler,
|
|
IRQF_TRIGGER_RISING, "tshut", NULL);
|
|
if (status) {
|
|
gpio_free(gpio_nr);
|
|
dev_err(bgp->dev, "request irq failed for TSHUT");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ti_bandgap_alert_init() - setup and initialize talert handling
|
|
* @bgp: pointer to struct ti_bandgap
|
|
* @pdev: pointer to device struct platform_device
|
|
*
|
|
* Call this function only in case the bandgap features HAS(TALERT).
|
|
* In this case, the driver needs to handle the TALERT signals as an IRQs.
|
|
* TALERT is a normal IRQ and it is fired any time thresholds (hot or cold)
|
|
* are violated. In these situation, the driver must reprogram the thresholds,
|
|
* accordingly to specified policy.
|
|
*
|
|
* Return: 0 if no error, else return corresponding error.
|
|
*/
|
|
static int ti_bandgap_talert_init(struct ti_bandgap *bgp,
|
|
struct platform_device *pdev)
|
|
{
|
|
int ret;
|
|
|
|
bgp->irq = platform_get_irq(pdev, 0);
|
|
if (bgp->irq < 0) {
|
|
dev_err(&pdev->dev, "get_irq failed\n");
|
|
return bgp->irq;
|
|
}
|
|
ret = request_threaded_irq(bgp->irq, NULL,
|
|
ti_bandgap_talert_irq_handler,
|
|
IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
|
|
"talert", bgp);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "Request threaded irq failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id of_ti_bandgap_match[];
|
|
/**
|
|
* ti_bandgap_build() - parse DT and setup a struct ti_bandgap
|
|
* @pdev: pointer to device struct platform_device
|
|
*
|
|
* Used to read the device tree properties accordingly to the bandgap
|
|
* matching version. Based on bandgap version and its capabilities it
|
|
* will build a struct ti_bandgap out of the required DT entries.
|
|
*
|
|
* Return: valid bandgap structure if successful, else returns ERR_PTR
|
|
* return value must be verified with IS_ERR.
|
|
*/
|
|
static struct ti_bandgap *ti_bandgap_build(struct platform_device *pdev)
|
|
{
|
|
struct device_node *node = pdev->dev.of_node;
|
|
const struct of_device_id *of_id;
|
|
struct ti_bandgap *bgp;
|
|
struct resource *res;
|
|
int i;
|
|
|
|
/* just for the sake */
|
|
if (!node) {
|
|
dev_err(&pdev->dev, "no platform information available\n");
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
|
|
if (!bgp)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
of_id = of_match_device(of_ti_bandgap_match, &pdev->dev);
|
|
if (of_id)
|
|
bgp->conf = of_id->data;
|
|
|
|
/* register shadow for context save and restore */
|
|
bgp->regval = devm_kcalloc(&pdev->dev, bgp->conf->sensor_count,
|
|
sizeof(*bgp->regval), GFP_KERNEL);
|
|
if (!bgp->regval)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
i = 0;
|
|
do {
|
|
void __iomem *chunk;
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, i);
|
|
if (!res)
|
|
break;
|
|
chunk = devm_ioremap_resource(&pdev->dev, res);
|
|
if (i == 0)
|
|
bgp->base = chunk;
|
|
if (IS_ERR(chunk))
|
|
return ERR_CAST(chunk);
|
|
|
|
i++;
|
|
} while (res);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT)) {
|
|
bgp->tshut_gpio = of_get_gpio(node, 0);
|
|
if (!gpio_is_valid(bgp->tshut_gpio)) {
|
|
dev_err(&pdev->dev, "invalid gpio for tshut (%d)\n",
|
|
bgp->tshut_gpio);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
}
|
|
|
|
return bgp;
|
|
}
|
|
|
|
/*** Device driver call backs ***/
|
|
|
|
static
|
|
int ti_bandgap_probe(struct platform_device *pdev)
|
|
{
|
|
struct ti_bandgap *bgp;
|
|
int clk_rate, ret, i;
|
|
|
|
bgp = ti_bandgap_build(pdev);
|
|
if (IS_ERR(bgp)) {
|
|
dev_err(&pdev->dev, "failed to fetch platform data\n");
|
|
return PTR_ERR(bgp);
|
|
}
|
|
bgp->dev = &pdev->dev;
|
|
|
|
if (TI_BANDGAP_HAS(bgp, UNRELIABLE))
|
|
dev_warn(&pdev->dev,
|
|
"This OMAP thermal sensor is unreliable. You've been warned\n");
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT)) {
|
|
ret = ti_bandgap_tshut_init(bgp, pdev);
|
|
if (ret) {
|
|
dev_err(&pdev->dev,
|
|
"failed to initialize system tshut IRQ\n");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
bgp->fclock = clk_get(NULL, bgp->conf->fclock_name);
|
|
if (IS_ERR(bgp->fclock)) {
|
|
dev_err(&pdev->dev, "failed to request fclock reference\n");
|
|
ret = PTR_ERR(bgp->fclock);
|
|
goto free_irqs;
|
|
}
|
|
|
|
bgp->div_clk = clk_get(NULL, bgp->conf->div_ck_name);
|
|
if (IS_ERR(bgp->div_clk)) {
|
|
dev_err(&pdev->dev, "failed to request div_ts_ck clock ref\n");
|
|
ret = PTR_ERR(bgp->div_clk);
|
|
goto put_fclock;
|
|
}
|
|
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
struct temp_sensor_registers *tsr;
|
|
u32 val;
|
|
|
|
tsr = bgp->conf->sensors[i].registers;
|
|
/*
|
|
* check if the efuse has a non-zero value if not
|
|
* it is an untrimmed sample and the temperatures
|
|
* may not be accurate
|
|
*/
|
|
val = ti_bandgap_readl(bgp, tsr->bgap_efuse);
|
|
if (!val)
|
|
dev_info(&pdev->dev,
|
|
"Non-trimmed BGAP, Temp not accurate\n");
|
|
}
|
|
|
|
clk_rate = clk_round_rate(bgp->div_clk,
|
|
bgp->conf->sensors[0].ts_data->max_freq);
|
|
if (clk_rate < bgp->conf->sensors[0].ts_data->min_freq ||
|
|
clk_rate <= 0) {
|
|
ret = -ENODEV;
|
|
dev_err(&pdev->dev, "wrong clock rate (%d)\n", clk_rate);
|
|
goto put_clks;
|
|
}
|
|
|
|
ret = clk_set_rate(bgp->div_clk, clk_rate);
|
|
if (ret)
|
|
dev_err(&pdev->dev, "Cannot re-set clock rate. Continuing\n");
|
|
|
|
bgp->clk_rate = clk_rate;
|
|
if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
|
|
clk_prepare_enable(bgp->fclock);
|
|
|
|
|
|
spin_lock_init(&bgp->lock);
|
|
bgp->dev = &pdev->dev;
|
|
platform_set_drvdata(pdev, bgp);
|
|
|
|
ti_bandgap_power(bgp, true);
|
|
|
|
/* Set default counter to 1 for now */
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER))
|
|
for (i = 0; i < bgp->conf->sensor_count; i++)
|
|
RMW_BITS(bgp, i, bgap_counter, counter_mask, 1);
|
|
|
|
/* Set default thresholds for alert and shutdown */
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
struct temp_sensor_data *ts_data;
|
|
|
|
ts_data = bgp->conf->sensors[i].ts_data;
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TALERT)) {
|
|
/* Set initial Talert thresholds */
|
|
RMW_BITS(bgp, i, bgap_threshold,
|
|
threshold_tcold_mask, ts_data->t_cold);
|
|
RMW_BITS(bgp, i, bgap_threshold,
|
|
threshold_thot_mask, ts_data->t_hot);
|
|
/* Enable the alert events */
|
|
RMW_BITS(bgp, i, bgap_mask_ctrl, mask_hot_mask, 1);
|
|
RMW_BITS(bgp, i, bgap_mask_ctrl, mask_cold_mask, 1);
|
|
}
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG)) {
|
|
/* Set initial Tshut thresholds */
|
|
RMW_BITS(bgp, i, tshut_threshold,
|
|
tshut_hot_mask, ts_data->tshut_hot);
|
|
RMW_BITS(bgp, i, tshut_threshold,
|
|
tshut_cold_mask, ts_data->tshut_cold);
|
|
}
|
|
}
|
|
|
|
if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
|
|
ti_bandgap_set_continuous_mode(bgp);
|
|
|
|
/* Set .250 seconds time as default counter */
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER))
|
|
for (i = 0; i < bgp->conf->sensor_count; i++)
|
|
RMW_BITS(bgp, i, bgap_counter, counter_mask,
|
|
bgp->clk_rate / 4);
|
|
|
|
/* Every thing is good? Then expose the sensors */
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
char *domain;
|
|
|
|
if (bgp->conf->sensors[i].register_cooling) {
|
|
ret = bgp->conf->sensors[i].register_cooling(bgp, i);
|
|
if (ret)
|
|
goto remove_sensors;
|
|
}
|
|
|
|
if (bgp->conf->expose_sensor) {
|
|
domain = bgp->conf->sensors[i].domain;
|
|
ret = bgp->conf->expose_sensor(bgp, i, domain);
|
|
if (ret)
|
|
goto remove_last_cooling;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Enable the Interrupts once everything is set. Otherwise irq handler
|
|
* might be called as soon as it is enabled where as rest of framework
|
|
* is still getting initialised.
|
|
*/
|
|
if (TI_BANDGAP_HAS(bgp, TALERT)) {
|
|
ret = ti_bandgap_talert_init(bgp, pdev);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "failed to initialize Talert IRQ\n");
|
|
i = bgp->conf->sensor_count;
|
|
goto disable_clk;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
remove_last_cooling:
|
|
if (bgp->conf->sensors[i].unregister_cooling)
|
|
bgp->conf->sensors[i].unregister_cooling(bgp, i);
|
|
remove_sensors:
|
|
for (i--; i >= 0; i--) {
|
|
if (bgp->conf->sensors[i].unregister_cooling)
|
|
bgp->conf->sensors[i].unregister_cooling(bgp, i);
|
|
if (bgp->conf->remove_sensor)
|
|
bgp->conf->remove_sensor(bgp, i);
|
|
}
|
|
ti_bandgap_power(bgp, false);
|
|
disable_clk:
|
|
if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
|
|
clk_disable_unprepare(bgp->fclock);
|
|
put_clks:
|
|
clk_put(bgp->div_clk);
|
|
put_fclock:
|
|
clk_put(bgp->fclock);
|
|
free_irqs:
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT)) {
|
|
free_irq(gpio_to_irq(bgp->tshut_gpio), NULL);
|
|
gpio_free(bgp->tshut_gpio);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static
|
|
int ti_bandgap_remove(struct platform_device *pdev)
|
|
{
|
|
struct ti_bandgap *bgp = platform_get_drvdata(pdev);
|
|
int i;
|
|
|
|
/* First thing is to remove sensor interfaces */
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
if (bgp->conf->sensors[i].unregister_cooling)
|
|
bgp->conf->sensors[i].unregister_cooling(bgp, i);
|
|
|
|
if (bgp->conf->remove_sensor)
|
|
bgp->conf->remove_sensor(bgp, i);
|
|
}
|
|
|
|
ti_bandgap_power(bgp, false);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
|
|
clk_disable_unprepare(bgp->fclock);
|
|
clk_put(bgp->fclock);
|
|
clk_put(bgp->div_clk);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TALERT))
|
|
free_irq(bgp->irq, bgp);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT)) {
|
|
free_irq(gpio_to_irq(bgp->tshut_gpio), NULL);
|
|
gpio_free(bgp->tshut_gpio);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
struct temp_sensor_registers *tsr;
|
|
struct temp_sensor_regval *rval;
|
|
|
|
rval = &bgp->regval[i];
|
|
tsr = bgp->conf->sensors[i].registers;
|
|
|
|
if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
|
|
rval->bg_mode_ctrl = ti_bandgap_readl(bgp,
|
|
tsr->bgap_mode_ctrl);
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER))
|
|
rval->bg_counter = ti_bandgap_readl(bgp,
|
|
tsr->bgap_counter);
|
|
if (TI_BANDGAP_HAS(bgp, TALERT)) {
|
|
rval->bg_threshold = ti_bandgap_readl(bgp,
|
|
tsr->bgap_threshold);
|
|
rval->bg_ctrl = ti_bandgap_readl(bgp,
|
|
tsr->bgap_mask_ctrl);
|
|
}
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
|
|
rval->tshut_threshold = ti_bandgap_readl(bgp,
|
|
tsr->tshut_threshold);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ti_bandgap_restore_ctxt(struct ti_bandgap *bgp)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < bgp->conf->sensor_count; i++) {
|
|
struct temp_sensor_registers *tsr;
|
|
struct temp_sensor_regval *rval;
|
|
u32 val = 0;
|
|
|
|
rval = &bgp->regval[i];
|
|
tsr = bgp->conf->sensors[i].registers;
|
|
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER))
|
|
val = ti_bandgap_readl(bgp, tsr->bgap_counter);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
|
|
ti_bandgap_writel(bgp, rval->tshut_threshold,
|
|
tsr->tshut_threshold);
|
|
/* Force immediate temperature measurement and update
|
|
* of the DTEMP field
|
|
*/
|
|
ti_bandgap_force_single_read(bgp, i);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, COUNTER))
|
|
ti_bandgap_writel(bgp, rval->bg_counter,
|
|
tsr->bgap_counter);
|
|
if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
|
|
ti_bandgap_writel(bgp, rval->bg_mode_ctrl,
|
|
tsr->bgap_mode_ctrl);
|
|
if (TI_BANDGAP_HAS(bgp, TALERT)) {
|
|
ti_bandgap_writel(bgp, rval->bg_threshold,
|
|
tsr->bgap_threshold);
|
|
ti_bandgap_writel(bgp, rval->bg_ctrl,
|
|
tsr->bgap_mask_ctrl);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ti_bandgap_suspend(struct device *dev)
|
|
{
|
|
struct ti_bandgap *bgp = dev_get_drvdata(dev);
|
|
int err;
|
|
|
|
err = ti_bandgap_save_ctxt(bgp);
|
|
ti_bandgap_power(bgp, false);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
|
|
clk_disable_unprepare(bgp->fclock);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int ti_bandgap_resume(struct device *dev)
|
|
{
|
|
struct ti_bandgap *bgp = dev_get_drvdata(dev);
|
|
|
|
if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
|
|
clk_prepare_enable(bgp->fclock);
|
|
|
|
ti_bandgap_power(bgp, true);
|
|
|
|
return ti_bandgap_restore_ctxt(bgp);
|
|
}
|
|
static SIMPLE_DEV_PM_OPS(ti_bandgap_dev_pm_ops, ti_bandgap_suspend,
|
|
ti_bandgap_resume);
|
|
|
|
#define DEV_PM_OPS (&ti_bandgap_dev_pm_ops)
|
|
#else
|
|
#define DEV_PM_OPS NULL
|
|
#endif
|
|
|
|
static const struct of_device_id of_ti_bandgap_match[] = {
|
|
#ifdef CONFIG_OMAP3_THERMAL
|
|
{
|
|
.compatible = "ti,omap34xx-bandgap",
|
|
.data = (void *)&omap34xx_data,
|
|
},
|
|
{
|
|
.compatible = "ti,omap36xx-bandgap",
|
|
.data = (void *)&omap36xx_data,
|
|
},
|
|
#endif
|
|
#ifdef CONFIG_OMAP4_THERMAL
|
|
{
|
|
.compatible = "ti,omap4430-bandgap",
|
|
.data = (void *)&omap4430_data,
|
|
},
|
|
{
|
|
.compatible = "ti,omap4460-bandgap",
|
|
.data = (void *)&omap4460_data,
|
|
},
|
|
{
|
|
.compatible = "ti,omap4470-bandgap",
|
|
.data = (void *)&omap4470_data,
|
|
},
|
|
#endif
|
|
#ifdef CONFIG_OMAP5_THERMAL
|
|
{
|
|
.compatible = "ti,omap5430-bandgap",
|
|
.data = (void *)&omap5430_data,
|
|
},
|
|
#endif
|
|
#ifdef CONFIG_DRA752_THERMAL
|
|
{
|
|
.compatible = "ti,dra752-bandgap",
|
|
.data = (void *)&dra752_data,
|
|
},
|
|
#endif
|
|
/* Sentinel */
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(of, of_ti_bandgap_match);
|
|
|
|
static struct platform_driver ti_bandgap_sensor_driver = {
|
|
.probe = ti_bandgap_probe,
|
|
.remove = ti_bandgap_remove,
|
|
.driver = {
|
|
.name = "ti-soc-thermal",
|
|
.pm = DEV_PM_OPS,
|
|
.of_match_table = of_ti_bandgap_match,
|
|
},
|
|
};
|
|
|
|
module_platform_driver(ti_bandgap_sensor_driver);
|
|
|
|
MODULE_DESCRIPTION("OMAP4+ bandgap temperature sensor driver");
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_ALIAS("platform:ti-soc-thermal");
|
|
MODULE_AUTHOR("Texas Instrument Inc.");
|