Skip to content

Commit

Permalink
staging: omap-thermal: introduce RMW_BITS macro
Browse files Browse the repository at this point in the history 
This patch introduce a macro to read, update, write bitfields.
It will be specific to bandgap data structures.

Signed-off-by: Eduardo Valentin <eduardo.valentin@ti.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
  • Loading branch information
Eduardo Valentin authored and Greg Kroah-Hartman committed Mar 15, 2013
1 parent 35b052a commit d3c291a
Showing 1 changed file with 46 additions and 132 deletions.
178 changes: 46 additions & 132 deletions drivers/staging/omap-thermal/omap-bandgap.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,41 +52,43 @@ static void omap_bandgap_writel(struct omap_bandgap *bg_ptr, u32 val, u32 reg)
writel(val, bg_ptr->base + reg);
}

/* update bits, value will be shifted */
#define RMW_BITS(bg_ptr, id, reg, mask, val) \
do { \
struct temp_sensor_registers *t; \
u32 r; \
\
t = bg_ptr->conf->sensors[(id)].registers; \
r = omap_bandgap_readl(bg_ptr, t->reg); \
r &= ~t->mask; \
r |= (val) << __ffs(t->mask); \
omap_bandgap_writel(bg_ptr, r, t->reg); \
} while (0)

static int omap_bandgap_power(struct omap_bandgap *bg_ptr, bool on)
{
struct temp_sensor_registers *tsr;
int i;
u32 ctrl;

if (!OMAP_BANDGAP_HAS(bg_ptr, POWER_SWITCH))
return 0;

for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
tsr = bg_ptr->conf->sensors[i].registers;
ctrl = omap_bandgap_readl(bg_ptr, tsr->temp_sensor_ctrl);
ctrl &= ~tsr->bgap_tempsoff_mask;
for (i = 0; i < bg_ptr->conf->sensor_count; i++)
/* active on 0 */
ctrl |= !on << __ffs(tsr->bgap_tempsoff_mask);

/* write BGAP_TEMPSOFF should be reset to 0 */
omap_bandgap_writel(bg_ptr, ctrl, tsr->temp_sensor_ctrl);
}
RMW_BITS(bg_ptr, i, temp_sensor_ctrl, bgap_tempsoff_mask, !on);

return 0;
}

static u32 omap_bandgap_read_temp(struct omap_bandgap *bg_ptr, int id)
{
struct temp_sensor_registers *tsr;
u32 temp, ctrl, reg;
u32 temp, reg;

tsr = bg_ptr->conf->sensors[id].registers;
reg = tsr->temp_sensor_ctrl;

if (OMAP_BANDGAP_HAS(bg_ptr, FREEZE_BIT)) {
ctrl = omap_bandgap_readl(bg_ptr, tsr->bgap_mask_ctrl);
ctrl |= tsr->mask_freeze_mask;
omap_bandgap_writel(bg_ptr, ctrl, tsr->bgap_mask_ctrl);
RMW_BITS(bg_ptr, 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
Expand All @@ -98,11 +100,8 @@ static u32 omap_bandgap_read_temp(struct omap_bandgap *bg_ptr, int id)
temp = omap_bandgap_readl(bg_ptr, reg);
temp &= tsr->bgap_dtemp_mask;

if (OMAP_BANDGAP_HAS(bg_ptr, FREEZE_BIT)) {
ctrl = omap_bandgap_readl(bg_ptr, tsr->bgap_mask_ctrl);
ctrl &= ~tsr->mask_freeze_mask;
omap_bandgap_writel(bg_ptr, ctrl, tsr->bgap_mask_ctrl);
}
if (OMAP_BANDGAP_HAS(bg_ptr, FREEZE_BIT))
RMW_BITS(bg_ptr, id, bgap_mask_ctrl, mask_freeze_mask, 0);

return temp;
}
Expand Down Expand Up @@ -290,37 +289,6 @@ int temp_sensor_configure_thot(struct omap_bandgap *bg_ptr, int id, int t_hot)
return temp_sensor_unmask_interrupts(bg_ptr, id, t_hot, cold);
}

/* Talert Thot and Tcold thresholds. Call it only if HAS(TALERT) is set */
static
int temp_sensor_init_talert_thresholds(struct omap_bandgap *bg_ptr, int id,
int t_hot, int t_cold)
{
struct temp_sensor_registers *tsr;
u32 reg_val, thresh_val;

tsr = bg_ptr->conf->sensors[id].registers;
thresh_val = omap_bandgap_readl(bg_ptr, tsr->bgap_threshold);

/* write the new t_cold value */
reg_val = thresh_val & ~tsr->threshold_tcold_mask;
reg_val |= (t_cold << __ffs(tsr->threshold_tcold_mask));
omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_threshold);

thresh_val = omap_bandgap_readl(bg_ptr, tsr->bgap_threshold);

/* write the new t_hot value */
reg_val = thresh_val & ~tsr->threshold_thot_mask;
reg_val |= (t_hot << __ffs(tsr->threshold_thot_mask));
omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_threshold);

reg_val = omap_bandgap_readl(bg_ptr, tsr->bgap_mask_ctrl);
reg_val |= tsr->mask_hot_mask;
reg_val |= tsr->mask_cold_mask;
omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_mask_ctrl);

return 0;
}

/* Talert Tcold threshold. Call it only if HAS(TALERT) is set */
static
int temp_sensor_configure_tcold(struct omap_bandgap *bg_ptr, int id,
Expand Down Expand Up @@ -359,54 +327,6 @@ int temp_sensor_configure_tcold(struct omap_bandgap *bg_ptr, int id,
return temp_sensor_unmask_interrupts(bg_ptr, id, hot, t_cold);
}

/* This is Tshut Thot config. Call it only if HAS(TSHUT_CONFIG) is set */
static int temp_sensor_configure_tshut_hot(struct omap_bandgap *bg_ptr,
int id, int tshut_hot)
{
struct temp_sensor_registers *tsr;
u32 reg_val;

tsr = bg_ptr->conf->sensors[id].registers;
reg_val = omap_bandgap_readl(bg_ptr, tsr->tshut_threshold);
reg_val &= ~tsr->tshut_hot_mask;
reg_val |= tshut_hot << __ffs(tsr->tshut_hot_mask);
omap_bandgap_writel(bg_ptr, reg_val, tsr->tshut_threshold);

return 0;
}

/* This is Tshut Tcold config. Call it only if HAS(TSHUT_CONFIG) is set */
static int temp_sensor_configure_tshut_cold(struct omap_bandgap *bg_ptr,
int id, int tshut_cold)
{
struct temp_sensor_registers *tsr;
u32 reg_val;

tsr = bg_ptr->conf->sensors[id].registers;
reg_val = omap_bandgap_readl(bg_ptr, tsr->tshut_threshold);
reg_val &= ~tsr->tshut_cold_mask;
reg_val |= tshut_cold << __ffs(tsr->tshut_cold_mask);
omap_bandgap_writel(bg_ptr, reg_val, tsr->tshut_threshold);

return 0;
}

/* This is counter config. Call it only if HAS(COUNTER) is set */
static int configure_temp_sensor_counter(struct omap_bandgap *bg_ptr, int id,
u32 counter)
{
struct temp_sensor_registers *tsr;
u32 val;

tsr = bg_ptr->conf->sensors[id].registers;
val = omap_bandgap_readl(bg_ptr, tsr->bgap_counter);
val &= ~tsr->counter_mask;
val |= counter << __ffs(tsr->counter_mask);
omap_bandgap_writel(bg_ptr, val, tsr->bgap_counter);

return 0;
}

#define bandgap_is_valid(b) \
(!IS_ERR_OR_NULL(b))
#define bandgap_is_valid_sensor_id(b, i) \
Expand Down Expand Up @@ -628,7 +548,7 @@ int omap_bandgap_write_update_interval(struct omap_bandgap *bg_ptr,

interval = interval * bg_ptr->clk_rate / 1000;
mutex_lock(&bg_ptr->bg_mutex);
configure_temp_sensor_counter(bg_ptr, id, interval);
RMW_BITS(bg_ptr, id, bgap_counter, counter_mask, interval);
mutex_unlock(&bg_ptr->bg_mutex);

return 0;
Expand All @@ -645,15 +565,13 @@ int omap_bandgap_write_update_interval(struct omap_bandgap *bg_ptr,
int omap_bandgap_read_temperature(struct omap_bandgap *bg_ptr, int id,
int *temperature)
{
struct temp_sensor_registers *tsr;
u32 temp;
int ret;

ret = omap_bandgap_validate(bg_ptr, id);
if (ret)
return ret;

tsr = bg_ptr->conf->sensors[id].registers;
mutex_lock(&bg_ptr->bg_mutex);
temp = omap_bandgap_read_temp(bg_ptr, id);
mutex_unlock(&bg_ptr->bg_mutex);
Expand Down Expand Up @@ -708,31 +626,23 @@ void *omap_bandgap_get_sensor_data(struct omap_bandgap *bg_ptr, int id)
static int
omap_bandgap_force_single_read(struct omap_bandgap *bg_ptr, int id)
{
struct temp_sensor_registers *tsr;
u32 temp = 0, counter = 1000;

tsr = bg_ptr->conf->sensors[id].registers;
/* Select single conversion mode */
if (OMAP_BANDGAP_HAS(bg_ptr, MODE_CONFIG)) {
temp = omap_bandgap_readl(bg_ptr, tsr->bgap_mode_ctrl);
temp &= ~(1 << __ffs(tsr->mode_ctrl_mask));
omap_bandgap_writel(bg_ptr, temp, tsr->bgap_mode_ctrl);
}
if (OMAP_BANDGAP_HAS(bg_ptr, MODE_CONFIG))
RMW_BITS(bg_ptr, id, bgap_mode_ctrl, mode_ctrl_mask, 0);

/* Start of Conversion = 1 */
temp = omap_bandgap_readl(bg_ptr, tsr->temp_sensor_ctrl);
temp |= 1 << __ffs(tsr->bgap_soc_mask);
omap_bandgap_writel(bg_ptr, temp, tsr->temp_sensor_ctrl);
RMW_BITS(bg_ptr, id, temp_sensor_ctrl, bgap_soc_mask, 1);
/* Wait until DTEMP is updated */
temp = omap_bandgap_read_temp(bg_ptr, id);

while ((temp == 0) && --counter)
temp = omap_bandgap_read_temp(bg_ptr, id);
/* REVISIT: Check correct condition for end of conversion */

/* Start of Conversion = 0 */
temp = omap_bandgap_readl(bg_ptr, tsr->temp_sensor_ctrl);
temp &= ~(1 << __ffs(tsr->bgap_soc_mask));
omap_bandgap_writel(bg_ptr, temp, tsr->temp_sensor_ctrl);
RMW_BITS(bg_ptr, id, temp_sensor_ctrl, bgap_soc_mask, 0);

return 0;
}
Expand All @@ -745,17 +655,12 @@ omap_bandgap_force_single_read(struct omap_bandgap *bg_ptr, int id)
*/
static int enable_continuous_mode(struct omap_bandgap *bg_ptr)
{
struct temp_sensor_registers *tsr;
int i;
u32 val;

for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
/* Perform a single read just before enabling continuous */
omap_bandgap_force_single_read(bg_ptr, i);
tsr = bg_ptr->conf->sensors[i].registers;
val = omap_bandgap_readl(bg_ptr, tsr->bgap_mode_ctrl);
val |= 1 << __ffs(tsr->mode_ctrl_mask);
omap_bandgap_writel(bg_ptr, val, tsr->bgap_mode_ctrl);
RMW_BITS(bg_ptr, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
}

return 0;
Expand Down Expand Up @@ -955,22 +860,31 @@ int omap_bandgap_probe(struct platform_device *pdev)
/* Set default counter to 1 for now */
if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
for (i = 0; i < bg_ptr->conf->sensor_count; i++)
configure_temp_sensor_counter(bg_ptr, i, 1);
RMW_BITS(bg_ptr, i, bgap_counter, counter_mask, 1);

/* Set default thresholds for alert and shutdown */
for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
struct temp_sensor_data *ts_data;

ts_data = bg_ptr->conf->sensors[i].ts_data;

if (OMAP_BANDGAP_HAS(bg_ptr, TALERT))
temp_sensor_init_talert_thresholds(bg_ptr, i,
ts_data->t_hot,
ts_data->t_cold);
if (OMAP_BANDGAP_HAS(bg_ptr, TALERT)) {
/* Set initial Talert thresholds */
RMW_BITS(bg_ptr, i, bgap_threshold,
threshold_tcold_mask, ts_data->t_cold);
RMW_BITS(bg_ptr, i, bgap_threshold,
threshold_thot_mask, ts_data->t_hot);
/* Enable the alert events */
RMW_BITS(bg_ptr, i, bgap_mask_ctrl, mask_hot_mask, 1);
RMW_BITS(bg_ptr, i, bgap_mask_ctrl, mask_cold_mask, 1);
}

if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT_CONFIG)) {
temp_sensor_configure_tshut_hot(bg_ptr, i,
ts_data->tshut_hot);
temp_sensor_configure_tshut_cold(bg_ptr, i,
ts_data->tshut_cold);
/* Set initial Tshut thresholds */
RMW_BITS(bg_ptr, i, tshut_threshold,
tshut_hot_mask, ts_data->tshut_hot);
RMW_BITS(bg_ptr, i, tshut_threshold,
tshut_cold_mask, ts_data->tshut_cold);
}
}

Expand All @@ -980,8 +894,8 @@ int omap_bandgap_probe(struct platform_device *pdev)
/* Set .250 seconds time as default counter */
if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
for (i = 0; i < bg_ptr->conf->sensor_count; i++)
configure_temp_sensor_counter(bg_ptr, i,
bg_ptr->clk_rate / 4);
RMW_BITS(bg_ptr, i, bgap_counter, counter_mask,
bg_ptr->clk_rate / 4);

/* Every thing is good? Then expose the sensors */
for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
Expand Down

0 comments on commit d3c291a

Please sign in to comment.