Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'pm-runtime'
Merge updates related to runtime PM for 6.20-rc1/7.0-rc1:
- Make several drivers discard pm_runtime_put() return value in
preparation for converting that function to a void one (Rafael
Wysocki)
* pm-runtime:
drm: Discard pm_runtime_put() return value
genirq/chip: Change irq_chip_pm_put() return type to void
scsi: ufs: core: Discard pm_runtime_put() return values
platform/chrome: cros_hps_i2c: Discard pm_runtime_put() return value
coresight: Discard pm_runtime_put() return values
hwspinlock: omap: Discard pm_runtime_put() return value
watchdog: rzv2h_wdt: Discard pm_runtime_put() return value
watchdog: rz: Discard pm_runtime_put() return values
media: ccs: Discard pm_runtime_put() return value
drm/imagination: Discard pm_runtime_put() return value
USB: core: Discard pm_runtime_put() return value
+44
-85
+1
-5
drivers/gpu/drm/arm/malidp_crtc.c
+1
-5
drivers/gpu/drm/arm/malidp_crtc.c
···
77
77
crtc);
78
78
struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
79
79
struct malidp_hw_device *hwdev = malidp->dev;
80
-
int err;
81
80
82
81
/* always disable planes on the CRTC that is being turned off */
83
82
drm_atomic_helper_disable_planes_on_crtc(old_state, false);
···
86
87
87
88
clk_disable_unprepare(hwdev->pxlclk);
88
89
89
-
err = pm_runtime_put(crtc->dev->dev);
90
-
if (err < 0) {
91
-
DRM_DEBUG_DRIVER("Failed to disable runtime power management: %d\n", err);
92
-
}
90
+
pm_runtime_put(crtc->dev->dev);
93
91
}
94
92
95
93
static const struct gamma_curve_segment {
+1
-3
drivers/gpu/drm/bridge/imx/imx8qm-ldb.c
+1
-3
drivers/gpu/drm/bridge/imx/imx8qm-ldb.c
···
280
280
clk_disable_unprepare(imx8qm_ldb->clk_bypass);
281
281
clk_disable_unprepare(imx8qm_ldb->clk_pixel);
282
282
283
-
ret = pm_runtime_put(dev);
284
-
if (ret < 0)
285
-
DRM_DEV_ERROR(dev, "failed to put runtime PM: %d\n", ret);
283
+
pm_runtime_put(dev);
286
284
}
287
285
288
286
static const u32 imx8qm_ldb_bus_output_fmts[] = {
+1
-3
drivers/gpu/drm/bridge/imx/imx8qxp-ldb.c
+1
-3
drivers/gpu/drm/bridge/imx/imx8qxp-ldb.c
···
282
282
if (is_split && companion)
283
283
companion->funcs->atomic_disable(companion, state);
284
284
285
-
ret = pm_runtime_put(dev);
286
-
if (ret < 0)
287
-
DRM_DEV_ERROR(dev, "failed to put runtime PM: %d\n", ret);
285
+
pm_runtime_put(dev);
288
286
}
289
287
290
288
static const u32 imx8qxp_ldb_bus_output_fmts[] = {
+1
-4
drivers/gpu/drm/bridge/imx/imx8qxp-pixel-combiner.c
+1
-4
drivers/gpu/drm/bridge/imx/imx8qxp-pixel-combiner.c
···
181
181
{
182
182
struct imx8qxp_pc_channel *ch = bridge->driver_private;
183
183
struct imx8qxp_pc *pc = ch->pc;
184
-
int ret;
185
184
186
-
ret = pm_runtime_put(pc->dev);
187
-
if (ret < 0)
188
-
DRM_DEV_ERROR(pc->dev, "failed to put runtime PM: %d\n", ret);
185
+
pm_runtime_put(pc->dev);
189
186
}
190
187
191
188
static const u32 imx8qxp_pc_bus_output_fmts[] = {
+1
-4
drivers/gpu/drm/bridge/imx/imx8qxp-pxl2dpi.c
+1
-4
drivers/gpu/drm/bridge/imx/imx8qxp-pxl2dpi.c
···
127
127
struct drm_atomic_state *state)
128
128
{
129
129
struct imx8qxp_pxl2dpi *p2d = bridge->driver_private;
130
-
int ret;
131
130
132
-
ret = pm_runtime_put(p2d->dev);
133
-
if (ret < 0)
134
-
DRM_DEV_ERROR(p2d->dev, "failed to put runtime PM: %d\n", ret);
131
+
pm_runtime_put(p2d->dev);
135
132
136
133
if (p2d->companion)
137
134
p2d->companion->funcs->atomic_disable(p2d->companion, state);
+2
-2
drivers/gpu/drm/imagination/pvr_power.h
+2
-2
drivers/gpu/drm/imagination/pvr_power.h
···
30
30
return pm_runtime_resume_and_get(drm_dev->dev);
31
31
}
32
32
33
-
static __always_inline int
33
+
static __always_inline void
34
34
pvr_power_put(struct pvr_device *pvr_dev)
35
35
{
36
36
struct drm_device *drm_dev = from_pvr_device(pvr_dev);
37
37
38
-
return pm_runtime_put(drm_dev->dev);
38
+
pm_runtime_put(drm_dev->dev);
39
39
}
40
40
41
41
int pvr_power_domains_init(struct pvr_device *pvr_dev);
+3
-9
drivers/gpu/drm/imx/dc/dc-crtc.c
+3
-9
drivers/gpu/drm/imx/dc/dc-crtc.c
···
300
300
drm_atomic_get_new_crtc_state(state, crtc);
301
301
struct dc_drm_device *dc_drm = to_dc_drm_device(crtc->dev);
302
302
struct dc_crtc *dc_crtc = to_dc_crtc(crtc);
303
-
int idx, ret;
303
+
int idx;
304
304
305
305
if (!drm_dev_enter(crtc->dev, &idx))
306
306
goto out;
···
313
313
dc_fg_disable_clock(dc_crtc->fg);
314
314
315
315
/* request pixel engine power-off as plane is off too */
316
-
ret = pm_runtime_put(dc_drm->pe->dev);
317
-
if (ret)
318
-
dc_crtc_err(crtc, "failed to put DC pixel engine RPM: %d\n",
319
-
ret);
316
+
pm_runtime_put(dc_drm->pe->dev);
320
317
321
318
/* request display engine power-off when CRTC is disabled */
322
-
ret = pm_runtime_put(dc_crtc->de->dev);
323
-
if (ret < 0)
324
-
dc_crtc_err(crtc, "failed to put DC display engine RPM: %d\n",
325
-
ret);
319
+
pm_runtime_put(dc_crtc->de->dev);
326
320
327
321
drm_dev_exit(idx);
328
322
+1
-4
drivers/gpu/drm/vc4/vc4_hdmi.c
+1
-4
drivers/gpu/drm/vc4/vc4_hdmi.c
···
848
848
struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
849
849
struct drm_device *drm = vc4_hdmi->connector.dev;
850
850
unsigned long flags;
851
-
int ret;
852
851
int idx;
853
852
854
853
mutex_lock(&vc4_hdmi->mutex);
···
866
867
clk_disable_unprepare(vc4_hdmi->pixel_bvb_clock);
867
868
clk_disable_unprepare(vc4_hdmi->pixel_clock);
868
869
869
-
ret = pm_runtime_put(&vc4_hdmi->pdev->dev);
870
-
if (ret < 0)
871
-
drm_err(drm, "Failed to release power domain: %d\n", ret);
870
+
pm_runtime_put(&vc4_hdmi->pdev->dev);
872
871
873
872
drm_dev_exit(idx);
874
873
+2
-10
drivers/gpu/drm/vc4/vc4_vec.c
+2
-10
drivers/gpu/drm/vc4/vc4_vec.c
···
542
542
{
543
543
struct drm_device *drm = encoder->dev;
544
544
struct vc4_vec *vec = encoder_to_vc4_vec(encoder);
545
-
int idx, ret;
545
+
int idx;
546
546
547
547
if (!drm_dev_enter(drm, &idx))
548
548
return;
···
556
556
557
557
clk_disable_unprepare(vec->clock);
558
558
559
-
ret = pm_runtime_put(&vec->pdev->dev);
560
-
if (ret < 0) {
561
-
drm_err(drm, "Failed to release power domain: %d\n", ret);
562
-
goto err_dev_exit;
563
-
}
559
+
pm_runtime_put(&vec->pdev->dev);
564
560
565
-
drm_dev_exit(idx);
566
-
return;
567
-
568
-
err_dev_exit:
569
561
drm_dev_exit(idx);
570
562
}
571
563
+1
-3
drivers/hwspinlock/omap_hwspinlock.c
+1
-3
drivers/hwspinlock/omap_hwspinlock.c
···
101
101
* runtime PM will make sure the clock of this module is
102
102
* enabled again iff at least one lock is requested
103
103
*/
104
-
ret = pm_runtime_put(&pdev->dev);
105
-
if (ret < 0)
106
-
return ret;
104
+
pm_runtime_put(&pdev->dev);
107
105
108
106
/* one of the four lsb's must be set, and nothing else */
109
107
if (hweight_long(i & 0xf) != 1 || i > 8)
+4
-8
drivers/hwtracing/coresight/coresight-cpu-debug.c
+4
-8
drivers/hwtracing/coresight/coresight-cpu-debug.c
···
451
451
return ret;
452
452
}
453
453
454
-
static int debug_disable_func(void)
454
+
static void debug_disable_func(void)
455
455
{
456
456
struct debug_drvdata *drvdata;
457
-
int cpu, ret, err = 0;
457
+
int cpu;
458
458
459
459
/*
460
460
* Disable debug power domains, records the error and keep
···
466
466
if (!drvdata)
467
467
continue;
468
468
469
-
ret = pm_runtime_put(drvdata->dev);
470
-
if (ret < 0)
471
-
err = ret;
469
+
pm_runtime_put(drvdata->dev);
472
470
}
473
-
474
-
return err;
475
471
}
476
472
477
473
static ssize_t debug_func_knob_write(struct file *f,
···
488
492
if (val)
489
493
ret = debug_enable_func();
490
494
else
491
-
ret = debug_disable_func();
495
+
debug_disable_func();
492
496
493
497
if (ret) {
494
498
pr_err("%s: unable to %s debug function: %d\n",
+3
-1
drivers/media/i2c/ccs/ccs-core.c
+3
-1
drivers/media/i2c/ccs/ccs-core.c
···
1974
1974
struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1975
1975
struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1976
1976
1977
-
return pm_runtime_put(&client->dev);
1977
+
pm_runtime_put(&client->dev);
1978
+
1979
+
return 0;
1978
1980
}
1979
1981
1980
1982
static int ccs_enum_mbus_code(struct v4l2_subdev *subdev,
+3
-1
drivers/platform/chrome/cros_hps_i2c.c
+3
-1
drivers/platform/chrome/cros_hps_i2c.c
+2
-2
drivers/ufs/core/ufshcd-priv.h
+2
-2
drivers/ufs/core/ufshcd-priv.h
···
348
348
return pm_runtime_resume(&hba->ufs_device_wlun->sdev_gendev);
349
349
}
350
350
351
-
static inline int ufshcd_rpm_put(struct ufs_hba *hba)
351
+
static inline void ufshcd_rpm_put(struct ufs_hba *hba)
352
352
{
353
-
return pm_runtime_put(&hba->ufs_device_wlun->sdev_gendev);
353
+
pm_runtime_put(&hba->ufs_device_wlun->sdev_gendev);
354
354
}
355
355
356
356
/**
+3
-5
drivers/usb/core/driver.c
+3
-5
drivers/usb/core/driver.c
···
1810
1810
void usb_autopm_put_interface_async(struct usb_interface *intf)
1811
1811
{
1812
1812
struct usb_device *udev = interface_to_usbdev(intf);
1813
-
int status;
1814
1813
1815
1814
usb_mark_last_busy(udev);
1816
-
status = pm_runtime_put(&intf->dev);
1817
-
dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1818
-
__func__, atomic_read(&intf->dev.power.usage_count),
1819
-
status);
1815
+
pm_runtime_put(&intf->dev);
1816
+
dev_vdbg(&intf->dev, "%s: cnt %d\n",
1817
+
__func__, atomic_read(&intf->dev.power.usage_count));
1820
1818
}
1821
1819
EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1822
1820
+1
-3
drivers/watchdog/rzg2l_wdt.c
+1
-3
drivers/watchdog/rzg2l_wdt.c
+2
-6
drivers/watchdog/rzv2h_wdt.c
+2
-6
drivers/watchdog/rzv2h_wdt.c
···
174
174
if (priv->of_data->wdtdcr)
175
175
rzt2h_wdt_wdtdcr_count_stop(priv);
176
176
177
-
ret = pm_runtime_put(wdev->parent);
178
-
if (ret < 0)
179
-
return ret;
177
+
pm_runtime_put(wdev->parent);
180
178
181
179
return 0;
182
180
}
···
268
270
269
271
rzt2h_wdt_wdtdcr_count_stop(priv);
270
272
271
-
ret = pm_runtime_put(&pdev->dev);
272
-
if (ret < 0)
273
-
return ret;
273
+
pm_runtime_put(&pdev->dev);
274
274
275
275
return 0;
276
276
}
+1
-1
include/linux/irq.h
+1
-1
include/linux/irq.h
···
658
658
659
659
extern int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg);
660
660
extern int irq_chip_pm_get(struct irq_data *data);
661
-
extern int irq_chip_pm_put(struct irq_data *data);
661
+
extern void irq_chip_pm_put(struct irq_data *data);
662
662
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
663
663
extern void handle_fasteoi_ack_irq(struct irq_desc *desc);
664
664
extern void handle_fasteoi_mask_irq(struct irq_desc *desc);
+11
-11
kernel/irq/chip.c
+11
-11
kernel/irq/chip.c
···
974
974
irq_state_set_disabled(desc);
975
975
if (is_chained) {
976
976
desc->action = NULL;
977
-
WARN_ON(irq_chip_pm_put(irq_desc_get_irq_data(desc)));
977
+
irq_chip_pm_put(irq_desc_get_irq_data(desc));
978
978
}
979
979
desc->depth = 1;
980
980
}
···
1530
1530
}
1531
1531
1532
1532
/**
1533
-
* irq_chip_pm_put - Disable power for an IRQ chip
1533
+
* irq_chip_pm_put - Drop a PM reference on an IRQ chip
1534
1534
* @data: Pointer to interrupt specific data
1535
1535
*
1536
-
* Disable the power to the IRQ chip referenced by the interrupt data
1537
-
* structure, belongs. Note that power will only be disabled, once this
1538
-
* function has been called for all IRQs that have called irq_chip_pm_get().
1536
+
* Drop a power management reference, acquired via irq_chip_pm_get(), on the IRQ
1537
+
* chip represented by the interrupt data structure.
1538
+
*
1539
+
* Note that this will not disable power to the IRQ chip until this function
1540
+
* has been called for all IRQs that have called irq_chip_pm_get() and it may
1541
+
* not disable power at all (if user space prevents that, for example).
1539
1542
*/
1540
-
int irq_chip_pm_put(struct irq_data *data)
1543
+
void irq_chip_pm_put(struct irq_data *data)
1541
1544
{
1542
1545
struct device *dev = irq_get_pm_device(data);
1543
-
int retval = 0;
1544
1546
1545
-
if (IS_ENABLED(CONFIG_PM) && dev)
1546
-
retval = pm_runtime_put(dev);
1547
-
1548
-
return (retval < 0) ? retval : 0;
1547
+
if (dev)
1548
+
pm_runtime_put(dev);
1549
1549
}