[PATCH 02/10] thermal: tegra: Use driver-private data consistently

Thierry Reding
2023-04-14T12:57:54Z

Instead of passing around platform and plain devices and figuring out
the driver-private data within each helper, directly pass around the
driver-private data when it's available.

Also store a pointer to the parent device in the main driver-private
data structure for easier access.

Signed-off-by: Thierry Reding <treding@nvidia.com>
---
drivers/thermal/tegra/soctherm.c | 213 ++++++++++++++-----------------
1 file changed, 95 insertions(+), 118 deletions(-)

diff --git a/drivers/thermal/tegra/soctherm.c b/drivers/thermal/tegra/soctherm.c
index ea66cba09e56..ca39340cd93f 100644
--- a/drivers/thermal/tegra/soctherm.c
+++ b/drivers/thermal/tegra/soctherm.c
@@ -299,7 +299,6 @@ static const char *const throt_names[] = {
struct tegra_soctherm;
struct tegra_thermctl_zone {
void __iomem *reg;
- struct device *dev;
struct tegra_soctherm *ts;
struct thermal_zone_device *tz;
const struct tegra_tsensor_group *sg;
@@ -327,6 +326,7 @@ struct soctherm_throt_cfg {
};

struct tegra_soctherm {
+ struct device *dev;
struct reset_control *reset;
struct clk *clock_tsensor;
struct clk *clock_soctherm;
@@ -444,14 +444,15 @@ static int tegra_thermctl_get_temp(struct thermal_zone_device *tz, int *out_temp
*
* Return: The precision adjusted capped temperature in millicelsius.
*/
-static int enforce_temp_range(struct device *dev, int trip_temp)
+static int enforce_temp_range(struct tegra_soctherm *ts, int trip_temp)
{
int temp;

temp = clamp_val(trip_temp, min_low_temp, max_high_temp);
if (temp != trip_temp)
- dev_dbg(dev, "soctherm: trip temperature %d forced to %d\n",
+ dev_dbg(ts->dev, "trip temperature %d forced to %d\n",
trip_temp, temp);
+
return temp;
}

@@ -471,18 +472,17 @@ static int enforce_temp_range(struct device *dev, int trip_temp)
*
* Return: 0 upon success, or %-EINVAL upon failure.
*/
-static int thermtrip_program(struct device *dev,
+static int thermtrip_program(struct tegra_soctherm *ts,
const struct tegra_tsensor_group *sg,
int trip_temp)
{
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
int temp;
u32 r;

if (!sg || !sg->thermtrip_threshold_mask)
return -EINVAL;

- temp = enforce_temp_range(dev, trip_temp) / ts->soc->thresh_grain;
+ temp = enforce_temp_range(ts, trip_temp) / ts->soc->thresh_grain;

r = readl(ts->regs + THERMCTL_THERMTRIP_CTL);
r = REG_SET_MASK(r, sg->thermtrip_threshold_mask, temp);
@@ -496,7 +496,7 @@ static int thermtrip_program(struct device *dev,
/**
* throttrip_program() - Configures the hardware to throttle the
* pulse if a given sensor group reaches a given temperature
- * @dev: ptr to the struct device for the SOC_THERM IP block
+ * @ts: pointer to a struct tegra_soctherm
* @sg: pointer to the sensor group to set the thermtrip temperature for
* @stc: pointer to the throttle need to be triggered
* @trip_temp: the temperature in millicelsius to trigger the thermal trip at
@@ -510,12 +510,11 @@ static int thermtrip_program(struct device *dev,
*
* Return: 0 upon success, or %-EINVAL upon failure.
*/
-static int throttrip_program(struct device *dev,
+static int throttrip_program(struct tegra_soctherm *ts,
const struct tegra_tsensor_group *sg,
struct soctherm_throt_cfg *stc,
int trip_temp)
{
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
int temp, cpu_throt, gpu_throt;
unsigned int throt;
u32 r, reg_off;
@@ -523,7 +522,7 @@ static int throttrip_program(struct device *dev,
if (!sg || !stc || !stc->init)
return -EINVAL;

- temp = enforce_temp_range(dev, trip_temp) / ts->soc->thresh_grain;
+ temp = enforce_temp_range(ts, trip_temp) / ts->soc->thresh_grain;

/* Hardcode LIGHT on LEVEL1 and HEAVY on LEVEL2 */
throt = stc->id;
@@ -536,7 +535,7 @@ static int throttrip_program(struct device *dev,
cpu_throt = THERMCTL_LVL0_CPU0_CPU_THROT_HEAVY;
gpu_throt = THERMCTL_LVL0_CPU0_GPU_THROT_HEAVY;
if (throt != THROTTLE_HEAVY)
- dev_warn(dev,
+ dev_warn(ts->dev,
"invalid throt id %d - assuming HEAVY",
throt);
}
@@ -588,7 +587,6 @@ static int tegra_thermctl_set_trip_temp(struct thermal_zone_device *tz, int trip
struct tegra_soctherm *ts = zone->ts;
struct thermal_trip trip;
const struct tegra_tsensor_group *sg = zone->sg;
- struct device *dev = zone->dev;
int ret;

if (!tz)
@@ -605,7 +603,7 @@ static int tegra_thermctl_set_trip_temp(struct thermal_zone_device *tz, int trip
* if not, program critical trip to HW.
*/
if (min_low_temp == tsensor_group_thermtrip_get(ts, sg->id))
- return thermtrip_program(dev, sg, temp);
+ return thermtrip_program(ts, sg, temp);
else
return 0;

@@ -625,7 +623,7 @@ static int tegra_thermctl_set_trip_temp(struct thermal_zone_device *tz, int trip
else
continue;

- return throttrip_program(dev, sg, stc, temp);
+ return throttrip_program(ts, sg, stc, temp);
}
}

@@ -667,9 +665,9 @@ static int tegra_thermctl_set_trips(struct thermal_zone_device *tz, int lo, int
r = REG_SET_MASK(r, THERMCTL_LVL0_CPU0_EN_MASK, 0);
writel(r, zone->ts->regs + zone->sg->thermctl_lvl0_offset);

- lo = enforce_temp_range(zone->dev, lo) / zone->ts->soc->thresh_grain;
- hi = enforce_temp_range(zone->dev, hi) / zone->ts->soc->thresh_grain;
- dev_dbg(zone->dev, "%s hi:%d, lo:%d\n", __func__, hi, lo);
+ lo = enforce_temp_range(zone->ts, lo) / zone->ts->soc->thresh_grain;
+ hi = enforce_temp_range(zone->ts, hi) / zone->ts->soc->thresh_grain;
+ dev_dbg(zone->ts->dev, "%s hi:%d, lo:%d\n", __func__, hi, lo);

r = REG_SET_MASK(r, zone->sg->thermctl_lvl0_up_thresh_mask, hi);
r = REG_SET_MASK(r, zone->sg->thermctl_lvl0_dn_thresh_mask, lo);
@@ -731,11 +729,10 @@ static int get_hot_temp(struct thermal_zone_device *tz, int *trip_id, int *temp)
* this one appears on the serial console:
* ""throttrip: will throttle when sensor group XXX reaches YYYYYY mC"
*/
-static int tegra_soctherm_set_hwtrips(struct device *dev,
+static int tegra_soctherm_set_hwtrips(struct tegra_soctherm *ts,
const struct tegra_tsensor_group *sg,
struct thermal_zone_device *tz)
{
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
struct soctherm_throt_cfg *stc;
int i, trip, temperature, ret;

@@ -745,18 +742,19 @@ static int tegra_soctherm_set_hwtrips(struct device *dev,
if (thermal_zone_get_crit_temp(tz, &temperature))
temperature = max_high_temp;

- ret = thermtrip_program(dev, sg, temperature);
+ ret = thermtrip_program(ts, sg, temperature);
if (ret) {
- dev_err(dev, "thermtrip: %s: error during enable\n", sg->name);
+ dev_err(ts->dev, "thermtrip: %s: error during enable\n",
+ sg->name);
return ret;
}

- dev_info(dev, "thermtrip: will shut down when %s reaches %d mC\n",
+ dev_info(ts->dev, "thermtrip: will shut down when %s reaches %d mC\n",
sg->name, temperature);

ret = get_hot_temp(tz, &trip, &temperature);
if (ret) {
- dev_info(dev, "throttrip: %s: missing hot temperature\n",
+ dev_info(ts->dev, "throttrip: %s: missing hot temperature\n",
sg->name);
return 0;
}
@@ -773,21 +771,21 @@ static int tegra_soctherm_set_hwtrips(struct device *dev,
else
continue;

- ret = throttrip_program(dev, sg, stc, temperature);
+ ret = throttrip_program(ts, sg, stc, temperature);
if (ret) {
- dev_err(dev, "throttrip: %s: error during enable\n",
+ dev_err(ts->dev, "throttrip: %s: error during enable\n",
sg->name);
return ret;
}

- dev_info(dev,
+ dev_info(ts->dev,
"throttrip: will throttle when %s reaches %d mC\n",
sg->name, temperature);
break;
}

if (i == THROTTLE_SIZE)
- dev_info(dev, "throttrip: %s: missing throttle cdev\n",
+ dev_info(ts->dev, "throttrip: %s: missing throttle cdev\n",
sg->name);

return 0;
@@ -1253,8 +1251,7 @@ static int soctherm_oc_int_init(struct device_node *np, int num_irqs)
#ifdef CONFIG_DEBUG_FS
static int regs_show(struct seq_file *s, void *data)
{
- struct platform_device *pdev = s->private;
- struct tegra_soctherm *ts = platform_get_drvdata(pdev);
+ struct tegra_soctherm *ts = s->private;
const struct tegra_tsensor *tsensors = ts->soc->tsensors;
const struct tegra_tsensor_group **ttgs = ts->soc->ttgs;
u32 r, state;
@@ -1449,24 +1446,24 @@ static int regs_show(struct seq_file *s, void *data)

DEFINE_SHOW_ATTRIBUTE(regs);

-static void soctherm_debug_init(struct platform_device *pdev)
+static void soctherm_debug_init(struct tegra_soctherm *tegra)
{
- struct tegra_soctherm *tegra = platform_get_drvdata(pdev);
struct dentry *root;

root = debugfs_create_dir("soctherm", NULL);

tegra->debugfs_dir = root;

- debugfs_create_file("reg_contents", 0644, root, pdev, &regs_fops);
+ debugfs_create_file("reg_contents", 0644, root, tegra, &regs_fops);
}
#else
-static inline void soctherm_debug_init(struct platform_device *pdev) {}
+static inline void soctherm_debug_init(struct tegra_soctherm *ts)
+{
+}
#endif

-static int soctherm_clk_enable(struct platform_device *pdev, bool enable)
+static int soctherm_clk_enable(struct tegra_soctherm *tegra, bool enable)
{
- struct tegra_soctherm *tegra = platform_get_drvdata(pdev);
int err;

if (!tegra->clock_soctherm || !tegra->clock_tsensor)
@@ -1531,10 +1528,8 @@ static const struct thermal_cooling_device_ops throt_cooling_ops = {
.set_cur_state = throt_set_cdev_state,
};

-static int soctherm_thermtrips_parse(struct platform_device *pdev)
+static int soctherm_thermtrips_parse(struct tegra_soctherm *ts)
{
- struct device *dev = &pdev->dev;
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
struct tsensor_group_thermtrips *tt = ts->soc->thermtrips;
const int max_num_prop = ts->soc->num_ttgs * 2;
u32 *tlb;
@@ -1543,22 +1538,22 @@ static int soctherm_thermtrips_parse(struct platform_device *pdev)
if (!tt)
return -ENOMEM;

- n = of_property_count_u32_elems(dev->of_node, "nvidia,thermtrips");
+ n = of_property_count_u32_elems(ts->dev->of_node, "nvidia,thermtrips");
if (n <= 0) {
- dev_info(dev,
+ dev_info(ts->dev,
"missing thermtrips, will use critical trips as shut down temp\n");
return n;
}

n = min(max_num_prop, n);

- tlb = devm_kcalloc(&pdev->dev, max_num_prop, sizeof(u32), GFP_KERNEL);
+ tlb = devm_kcalloc(ts->dev, max_num_prop, sizeof(u32), GFP_KERNEL);
if (!tlb)
return -ENOMEM;
- ret = of_property_read_u32_array(dev->of_node, "nvidia,thermtrips",
+ ret = of_property_read_u32_array(ts->dev->of_node, "nvidia,thermtrips",
tlb, n);
if (ret) {
- dev_err(dev, "invalid num ele: thermtrips:%d\n", ret);
+ dev_err(ts->dev, "invalid num ele: thermtrips:%d\n", ret);
return ret;
}

@@ -1575,9 +1570,9 @@ static int soctherm_thermtrips_parse(struct platform_device *pdev)
return 0;
}

-static void soctherm_oc_cfg_parse(struct device *dev,
- struct device_node *np_oc,
- struct soctherm_throt_cfg *stc)
+static void soctherm_oc_cfg_parse(struct tegra_soctherm *tegra,
+ struct device_node *np_oc,
+ struct soctherm_throt_cfg *stc)
{
u32 val;

@@ -1601,19 +1596,20 @@ static void soctherm_oc_cfg_parse(struct device *dev,
stc->oc_cfg.mode = OC_THROTTLE_MODE_BRIEF;
}

-static int soctherm_throt_cfg_parse(struct device *dev,
+static int soctherm_throt_cfg_parse(struct tegra_soctherm *ts,
struct device_node *np,
struct soctherm_throt_cfg *stc)
{
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
int ret;
u32 val;

ret = of_property_read_u32(np, "nvidia,priority", &val);
if (ret) {
- dev_err(dev, "throttle-cfg: %s: invalid priority\n", stc->name);
+ dev_err(ts->dev, "throttle-cfg: %s: invalid priority\n",
+ stc->name);
return -EINVAL;
}
+
stc->priority = val;

ret = of_property_read_u32(np, ts->soc->use_ccroc ?
@@ -1640,7 +1636,7 @@ static int soctherm_throt_cfg_parse(struct device *dev,
return 0;

err:
- dev_err(dev, "throttle-cfg: %s: no throt prop or invalid prop\n",
+ dev_err(ts->dev, "throttle-cfg: %s: no throt prop or invalid prop\n",
stc->name);
return -EINVAL;
}
@@ -1648,25 +1644,23 @@ static int soctherm_throt_cfg_parse(struct device *dev,
/**
* soctherm_init_hw_throt_cdev() - Parse the HW throttle configurations
* and register them as cooling devices.
- * @pdev: Pointer to platform_device struct
+ * @tegra: pointer to Tegra soctherm structure
*/
-static void soctherm_init_hw_throt_cdev(struct platform_device *pdev)
+static void soctherm_init_hw_throt_cdev(struct tegra_soctherm *tegra)
{
- struct device *dev = &pdev->dev;
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
struct device_node *np_stc, *np_stcc;
const char *name;
int i;

for (i = 0; i < THROTTLE_SIZE; i++) {
- ts->throt_cfgs[i].name = throt_names[i];
- ts->throt_cfgs[i].id = i;
- ts->throt_cfgs[i].init = false;
+ tegra->throt_cfgs[i].name = throt_names[i];
+ tegra->throt_cfgs[i].id = i;
+ tegra->throt_cfgs[i].init = false;
}

- np_stc = of_get_child_by_name(dev->of_node, "throttle-cfgs");
+ np_stc = of_get_child_by_name(tegra->dev->of_node, "throttle-cfgs");
if (!np_stc) {
- dev_info(dev,
+ dev_info(tegra->dev,
"throttle-cfg: no throttle-cfgs - not enabling\n");
return;
}
@@ -1677,33 +1671,34 @@ static void soctherm_init_hw_throt_cdev(struct platform_device *pdev)
int err;

name = np_stcc->name;
- stc = find_throttle_cfg_by_name(ts, name);
+ stc = find_throttle_cfg_by_name(tegra, name);
if (!stc) {
- dev_err(dev,
- "throttle-cfg: could not find %s\n", name);
+ dev_err(tegra->dev, "throttle-cfg: could not find %s\n",
+ name);
continue;
}

if (stc->init) {
- dev_err(dev, "throttle-cfg: %s: redefined!\n", name);
+ dev_err(tegra->dev, "throttle-cfg: %s: redefined!\n",
+ name);
of_node_put(np_stcc);
break;
}

- err = soctherm_throt_cfg_parse(dev, np_stcc, stc);
+ err = soctherm_throt_cfg_parse(tegra, np_stcc, stc);
if (err)
continue;

if (stc->id >= THROTTLE_OC1) {
- soctherm_oc_cfg_parse(dev, np_stcc, stc);
+ soctherm_oc_cfg_parse(tegra, np_stcc, stc);
stc->init = true;
} else {

tcd = thermal_of_cooling_device_register(np_stcc,
- (char *)name, ts,
+ (char *)name, tegra,
&throt_cooling_ops);
if (IS_ERR_OR_NULL(tcd)) {
- dev_err(dev,
+ dev_err(tegra->dev,
"throttle-cfg: %s: failed to register cooling device\n",
name);
continue;
@@ -1711,7 +1706,6 @@ static void soctherm_init_hw_throt_cdev(struct platform_device *pdev)
stc->cdev = tcd;
stc->init = true;
}
-
}

of_node_put(np_stc);
@@ -1931,9 +1925,8 @@ static void soctherm_throttle_program(struct tegra_soctherm *ts,
writel(r, ts->regs + THROT_PRIORITY_LOCK);
}

-static void tegra_soctherm_throttle(struct device *dev)
+static void tegra_soctherm_throttle(struct tegra_soctherm *ts)
{
- struct tegra_soctherm *ts = dev_get_drvdata(dev);
u32 v;
int i;

@@ -1969,43 +1962,29 @@ static void tegra_soctherm_throttle(struct device *dev)
writel(v, ts->regs + THERMCTL_STATS_CTL);
}

-static int soctherm_interrupts_init(struct platform_device *pdev,
- struct tegra_soctherm *tegra)
+static int soctherm_interrupts_init(struct tegra_soctherm *tegra)
{
- struct device_node *np = pdev->dev.of_node;
int ret;

- ret = soctherm_oc_int_init(np, TEGRA_SOC_OC_IRQ_MAX);
+ ret = soctherm_oc_int_init(tegra->dev->of_node, TEGRA_SOC_OC_IRQ_MAX);
if (ret < 0) {
- dev_err(&pdev->dev, "soctherm_oc_int_init failed\n");
+ dev_err(tegra->dev, "soctherm_oc_int_init failed\n");
return ret;
}

- tegra->thermal_irq = platform_get_irq(pdev, 0);
- if (tegra->thermal_irq < 0) {
- dev_dbg(&pdev->dev, "get 'thermal_irq' failed.\n");
- return 0;
- }
-
- tegra->edp_irq = platform_get_irq(pdev, 1);
- if (tegra->edp_irq < 0) {
- dev_dbg(&pdev->dev, "get 'edp_irq' failed.\n");
- return 0;
- }
-
- ret = devm_request_threaded_irq(&pdev->dev,
+ ret = devm_request_threaded_irq(tegra->dev,
tegra->thermal_irq,
soctherm_thermal_isr,
soctherm_thermal_isr_thread,
IRQF_ONESHOT,
- dev_name(&pdev->dev),
+ dev_name(tegra->dev),
tegra);
if (ret < 0) {
- dev_err(&pdev->dev, "request_irq 'thermal_irq' failed.\n");
+ dev_err(tegra->dev, "failed to request thermal IRQ: %d\n", ret);
return ret;
}

- ret = devm_request_threaded_irq(&pdev->dev,
+ ret = devm_request_threaded_irq(tegra->dev,
tegra->edp_irq,
soctherm_edp_isr,
soctherm_edp_isr_thread,
@@ -2013,16 +1992,15 @@ static int soctherm_interrupts_init(struct platform_device *pdev,
"soctherm_edp",
tegra);
if (ret < 0) {
- dev_err(&pdev->dev, "request_irq 'edp_irq' failed.\n");
+ dev_err(tegra->dev, "failed to request EDP IRQ: %d\n", ret);
return ret;
}

return 0;
}

-static void soctherm_init(struct platform_device *pdev)
+static void soctherm_init(struct tegra_soctherm *tegra)
{
- struct tegra_soctherm *tegra = platform_get_drvdata(pdev);
const struct tegra_tsensor_group **ttgs = tegra->soc->ttgs;
int i;
u32 pdiv, hotspot;
@@ -2048,7 +2026,7 @@ static void soctherm_init(struct platform_device *pdev)
writel(hotspot, tegra->regs + SENSOR_HOTSPOT_OFF);

/* Configure hw throttle */
- tegra_soctherm_throttle(&pdev->dev);
+ tegra_soctherm_throttle(tegra);
}

static const struct of_device_id tegra_soctherm_of_match[] = {
@@ -2096,9 +2074,9 @@ static int tegra_soctherm_probe(struct platform_device *pdev)
if (!tegra)
return -ENOMEM;

- mutex_init(&tegra->thermctl_lock);
dev_set_drvdata(&pdev->dev, tegra);
-
+ mutex_init(&tegra->thermctl_lock);
+ tegra->dev = &pdev->dev;
tegra->soc = soc;

tegra->regs = devm_platform_ioremap_resource_byname(pdev, "soctherm-reg");
@@ -2121,6 +2099,9 @@ static int tegra_soctherm_probe(struct platform_device *pdev)
}
}

+ tegra->thermal_irq = platform_get_irq(pdev, 0);
+ tegra->edp_irq = platform_get_irq(pdev, 1);
+
tegra->reset = devm_reset_control_get(&pdev->dev, "soctherm");
if (IS_ERR(tegra->reset)) {
dev_err(&pdev->dev, "can't get soctherm reset\n");
@@ -2165,15 +2146,15 @@ static int tegra_soctherm_probe(struct platform_device *pdev)
if (!tegra->thermctl_tzs)
return -ENOMEM;

- err = soctherm_clk_enable(pdev, true);
+ err = soctherm_clk_enable(tegra, true);
if (err)
return err;

- soctherm_thermtrips_parse(pdev);
+ soctherm_thermtrips_parse(tegra);

- soctherm_init_hw_throt_cdev(pdev);
+ soctherm_init_hw_throt_cdev(tegra);

- soctherm_init(pdev);
+ soctherm_init(tegra);

for (i = 0; i < soc->num_ttgs; ++i) {
struct tegra_thermctl_zone *zone =
@@ -2184,7 +2165,6 @@ static int tegra_soctherm_probe(struct platform_device *pdev)
}

zone->reg = tegra->regs + soc->ttgs[i]->sensor_temp_offset;
- zone->dev = &pdev->dev;
zone->sg = soc->ttgs[i];
zone->ts = tegra;

@@ -2202,19 +2182,19 @@ static int tegra_soctherm_probe(struct platform_device *pdev)
tegra->thermctl_tzs[soc->ttgs[i]->id] = z;

/* Configure hw trip points */
- err = tegra_soctherm_set_hwtrips(&pdev->dev, soc->ttgs[i], z);
+ err = tegra_soctherm_set_hwtrips(tegra, soc->ttgs[i], z);
if (err)
goto disable_clocks;
}

- err = soctherm_interrupts_init(pdev, tegra);
+ err = soctherm_interrupts_init(tegra);

- soctherm_debug_init(pdev);
+ soctherm_debug_init(tegra);

return 0;

disable_clocks:
- soctherm_clk_enable(pdev, false);
+ soctherm_clk_enable(tegra, false);

return err;
}
@@ -2225,44 +2205,41 @@ static int tegra_soctherm_remove(struct platform_device *pdev)

debugfs_remove_recursive(tegra->debugfs_dir);

- soctherm_clk_enable(pdev, false);
+ soctherm_clk_enable(tegra, false);

return 0;
}

static int __maybe_unused soctherm_suspend(struct device *dev)
{
- struct platform_device *pdev = to_platform_device(dev);
+ struct tegra_soctherm *tegra = dev_get_drvdata(dev);

- soctherm_clk_enable(pdev, false);
+ soctherm_clk_enable(tegra, false);

return 0;
}

static int __maybe_unused soctherm_resume(struct device *dev)
{
- struct platform_device *pdev = to_platform_device(dev);
- struct tegra_soctherm *tegra = platform_get_drvdata(pdev);
+ struct tegra_soctherm *tegra = dev_get_drvdata(dev);
struct tegra_soctherm_soc *soc = tegra->soc;
int err, i;

- err = soctherm_clk_enable(pdev, true);
+ err = soctherm_clk_enable(tegra, true);
if (err) {
- dev_err(&pdev->dev,
- "Resume failed: enable clocks failed\n");
+ dev_err(dev, "Resume failed: enable clocks failed\n");
return err;
}

- soctherm_init(pdev);
+ soctherm_init(tegra);

for (i = 0; i < soc->num_ttgs; ++i) {
struct thermal_zone_device *tz;

tz = tegra->thermctl_tzs[soc->ttgs[i]->id];
- err = tegra_soctherm_set_hwtrips(dev, soc->ttgs[i], tz);
+ err = tegra_soctherm_set_hwtrips(tegra, soc->ttgs[i], tz);
if (err) {
- dev_err(&pdev->dev,
- "Resume failed: set hwtrips failed\n");
+ dev_err(dev, "Resume failed: set hwtrips failed\n");
return err;
}
}
--
2.40.0