Merge tag 'media/v6.17-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

Merge tag 'media/v6.17-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Pull media fixes from Mauro Carvalho Chehab:

- drop the redundant pm_runtime_mark_last_busy() in rkvdec

- fix probing error handling in rkvdec

- fix an issue affecting lt6911uxe/lt6911uxc related to CSI-2 GPIO pins
in int3472

* tag 'media/v6.17-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media:
media: Remove redundant pm_runtime_mark_last_busy() calls
platform/x86: int3472: add hpd pin support
media: rkvdec: Remove redundant pm_runtime_mark_last_busy() calls
media: rkvdec: Fix an error handling path in rkvdec_probe()
media: rkvdec: Fix a NULL vs IS_ERR() bug in probe()

Linus Torvalds 7 months ago 518b21ba fab1beda

+19 -97

32 changed files

expand all collapse all

drivers

media

i2c

alvium-csi2.c

ccs

ccs-core.c

dw9768.c

gc0308.c

gc2145.c

imx219.c

imx283.c

imx290.c

imx296.c

imx415.c

mt9m114.c

ov4689.c

ov5640.c

ov5645.c

ov64a40.c

ov8858.c

st-mipid02.c

tc358746.c

thp7312.c

vd55g1.c

vd56g3.c

video-i2c.c

platform

chips-media

wave5

wave5-vpu-dec.c

wave5-vpu-enc.c

nvidia

tegra-vde

h264.c

qcom

iris

iris_hfi_queue.c

raspberrypi

pisp_be

pisp_be.c

rockchip

rkvdec

rkvdec.c

verisilicon

hantro_drv.c

gpio-ir-recv.c

platform

x86

intel

int3472

discrete.c

include

linux

platform_data

x86

int3472.h

-1

drivers/media/i2c/alvium-csi2.c

reviewed

··· 1841 1841 1842 1842 } else { 1843 1843 alvium_set_stream_mipi(alvium, enable); 1844 1844 - pm_runtime_mark_last_busy(&client->dev); 1845 1844 pm_runtime_put_autosuspend(&client->dev); 1846 1845 } 1847 1846

+1 -6

drivers/media/i2c/ccs/ccs-core.c

reviewed

··· 787 787 rval = -EINVAL; 788 788 } 789 789 790 790 - if (pm_status > 0) { 791 791 - pm_runtime_mark_last_busy(&client->dev); 790 790 + if (pm_status > 0) 792 791 pm_runtime_put_autosuspend(&client->dev); 793 793 - } 794 792 795 793 return rval; 796 794 } ··· 1912 1914 if (!enable) { 1913 1915 ccs_stop_streaming(sensor); 1914 1916 sensor->streaming = false; 1915 1915 - pm_runtime_mark_last_busy(&client->dev); 1916 1917 pm_runtime_put_autosuspend(&client->dev); 1917 1918 1918 1919 return 0; ··· 1926 1929 rval = ccs_start_streaming(sensor); 1927 1930 if (rval < 0) { 1928 1931 sensor->streaming = false; 1929 1929 - pm_runtime_mark_last_busy(&client->dev); 1930 1932 pm_runtime_put_autosuspend(&client->dev); 1931 1933 } 1932 1934 ··· 2673 2677 return -ENODEV; 2674 2678 } 2675 2679 2676 2676 - pm_runtime_mark_last_busy(&client->dev); 2677 2680 pm_runtime_put_autosuspend(&client->dev); 2678 2681 2679 2682 /*

-1

drivers/media/i2c/dw9768.c

reviewed

··· 374 374 375 375 static int dw9768_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 376 376 { 377 377 - pm_runtime_mark_last_busy(sd->dev); 378 377 pm_runtime_put_autosuspend(sd->dev); 379 378 380 379 return 0;

-3

drivers/media/i2c/gc0308.c

reviewed

··· 974 974 if (ret) 975 975 dev_err(gc0308->dev, "failed to set control: %d\n", ret); 976 976 977 977 - pm_runtime_mark_last_busy(gc0308->dev); 978 977 pm_runtime_put_autosuspend(gc0308->dev); 979 978 980 979 return ret; ··· 1156 1157 return 0; 1157 1158 1158 1159 disable_pm: 1159 1159 - pm_runtime_mark_last_busy(gc0308->dev); 1160 1160 pm_runtime_put_autosuspend(gc0308->dev); 1161 1161 return ret; 1162 1162 } 1163 1163 1164 1164 static int gc0308_stop_stream(struct gc0308 *gc0308) 1165 1165 { 1166 1166 - pm_runtime_mark_last_busy(gc0308->dev); 1167 1166 pm_runtime_put_autosuspend(gc0308->dev); 1168 1167 return 0; 1169 1168 }

-3

drivers/media/i2c/gc2145.c

reviewed

··· 963 963 return 0; 964 964 965 965 err_rpm_put: 966 966 - pm_runtime_mark_last_busy(&client->dev); 967 966 pm_runtime_put_autosuspend(&client->dev); 968 967 return ret; 969 968 } ··· 984 985 if (ret) 985 986 dev_err(&client->dev, "%s failed to write regs\n", __func__); 986 987 987 987 - pm_runtime_mark_last_busy(&client->dev); 988 988 pm_runtime_put_autosuspend(&client->dev); 989 989 990 990 return ret; ··· 1191 1193 break; 1192 1194 } 1193 1195 1194 1194 - pm_runtime_mark_last_busy(&client->dev); 1195 1196 pm_runtime_put_autosuspend(&client->dev); 1196 1197 1197 1198 return ret;

-2

drivers/media/i2c/imx219.c

reviewed

··· 771 771 return 0; 772 772 773 773 err_rpm_put: 774 774 - pm_runtime_mark_last_busy(&client->dev); 775 774 pm_runtime_put_autosuspend(&client->dev); 776 775 return ret; 777 776 } ··· 792 793 __v4l2_ctrl_grab(imx219->vflip, false); 793 794 __v4l2_ctrl_grab(imx219->hflip, false); 794 795 795 795 - pm_runtime_mark_last_busy(&client->dev); 796 796 pm_runtime_put_autosuspend(&client->dev); 797 797 798 798 return ret;

-3

drivers/media/i2c/imx283.c

reviewed

··· 1143 1143 return 0; 1144 1144 1145 1145 err_rpm_put: 1146 1146 - pm_runtime_mark_last_busy(imx283->dev); 1147 1146 pm_runtime_put_autosuspend(imx283->dev); 1148 1147 1149 1148 return ret; ··· 1162 1163 if (ret) 1163 1164 dev_err(imx283->dev, "Failed to stop stream\n"); 1164 1165 1165 1165 - pm_runtime_mark_last_busy(imx283->dev); 1166 1166 pm_runtime_put_autosuspend(imx283->dev); 1167 1167 1168 1168 return ret; ··· 1556 1558 * Decrease the PM usage count. The device will get suspended after the 1557 1559 * autosuspend delay, turning the power off. 1558 1560 */ 1559 1559 - pm_runtime_mark_last_busy(imx283->dev); 1560 1561 pm_runtime_put_autosuspend(imx283->dev); 1561 1562 1562 1563 return 0;

-3

drivers/media/i2c/imx290.c

reviewed

··· 869 869 break; 870 870 } 871 871 872 872 - pm_runtime_mark_last_busy(imx290->dev); 873 872 pm_runtime_put_autosuspend(imx290->dev); 874 873 875 874 return ret; ··· 1098 1099 } 1099 1100 } else { 1100 1101 imx290_stop_streaming(imx290); 1101 1101 - pm_runtime_mark_last_busy(imx290->dev); 1102 1102 pm_runtime_put_autosuspend(imx290->dev); 1103 1103 } 1104 1104 ··· 1292 1294 * will already be prevented even before the delay. 1293 1295 */ 1294 1296 v4l2_i2c_subdev_init(&imx290->sd, client, &imx290_subdev_ops); 1295 1295 - pm_runtime_mark_last_busy(imx290->dev); 1296 1297 pm_runtime_put_autosuspend(imx290->dev); 1297 1298 1298 1299 imx290->sd.internal_ops = &imx290_internal_ops;

-1

drivers/media/i2c/imx296.c

reviewed

··· 604 604 if (!enable) { 605 605 ret = imx296_stream_off(sensor); 606 606 607 607 - pm_runtime_mark_last_busy(sensor->dev); 608 607 pm_runtime_put_autosuspend(sensor->dev); 609 608 610 609 goto unlock;

-1

drivers/media/i2c/imx415.c

reviewed

··· 952 952 if (!enable) { 953 953 ret = imx415_stream_off(sensor); 954 954 955 955 - pm_runtime_mark_last_busy(sensor->dev); 956 955 pm_runtime_put_autosuspend(sensor->dev); 957 956 958 957 goto unlock;

-6

drivers/media/i2c/mt9m114.c

reviewed

··· 974 974 return 0; 975 975 976 976 error: 977 977 - pm_runtime_mark_last_busy(&sensor->client->dev); 978 977 pm_runtime_put_autosuspend(&sensor->client->dev); 979 978 980 979 return ret; ··· 987 988 988 989 ret = mt9m114_set_state(sensor, MT9M114_SYS_STATE_ENTER_SUSPEND); 989 990 990 990 - pm_runtime_mark_last_busy(&sensor->client->dev); 991 991 pm_runtime_put_autosuspend(&sensor->client->dev); 992 992 993 993 return ret; ··· 1044 1046 break; 1045 1047 } 1046 1048 1047 1047 - pm_runtime_mark_last_busy(&sensor->client->dev); 1048 1049 pm_runtime_put_autosuspend(&sensor->client->dev); 1049 1050 1050 1051 return ret; ··· 1110 1113 break; 1111 1114 } 1112 1115 1113 1113 - pm_runtime_mark_last_busy(&sensor->client->dev); 1114 1116 pm_runtime_put_autosuspend(&sensor->client->dev); 1115 1117 1116 1118 return ret; ··· 1561 1565 break; 1562 1566 } 1563 1567 1564 1564 - pm_runtime_mark_last_busy(&sensor->client->dev); 1565 1568 pm_runtime_put_autosuspend(&sensor->client->dev); 1566 1569 1567 1570 return ret; ··· 2467 2472 * Decrease the PM usage count. The device will get suspended after the 2468 2473 * autosuspend delay, turning the power off. 2469 2474 */ 2470 2470 - pm_runtime_mark_last_busy(dev); 2471 2475 pm_runtime_put_autosuspend(dev); 2472 2476 2473 2477 return 0;

-3

drivers/media/i2c/ov4689.c

reviewed

··· 497 497 } else { 498 498 cci_write(ov4689->regmap, OV4689_REG_CTRL_MODE, 499 499 OV4689_MODE_SW_STANDBY, NULL); 500 500 - pm_runtime_mark_last_busy(dev); 501 500 pm_runtime_put_autosuspend(dev); 502 501 } 503 502 ··· 701 702 break; 702 703 } 703 704 704 704 - pm_runtime_mark_last_busy(dev); 705 705 pm_runtime_put_autosuspend(dev); 706 706 707 707 return ret; ··· 997 999 goto err_clean_subdev_pm; 998 1000 } 999 1001 1000 1000 - pm_runtime_mark_last_busy(dev); 1001 1002 pm_runtime_put_autosuspend(dev); 1002 1003 1003 1004 return 0;

-4

drivers/media/i2c/ov5640.c

reviewed

··· 3341 3341 break; 3342 3342 } 3343 3343 3344 3344 - pm_runtime_mark_last_busy(&sensor->i2c_client->dev); 3345 3344 pm_runtime_put_autosuspend(&sensor->i2c_client->dev); 3346 3345 3347 3346 return 0; ··· 3416 3417 break; 3417 3418 } 3418 3419 3419 3419 - pm_runtime_mark_last_busy(&sensor->i2c_client->dev); 3420 3420 pm_runtime_put_autosuspend(&sensor->i2c_client->dev); 3421 3421 3422 3422 return ret; ··· 3752 3754 mutex_unlock(&sensor->lock); 3753 3755 3754 3756 if (!enable || ret) { 3755 3755 - pm_runtime_mark_last_busy(&sensor->i2c_client->dev); 3756 3757 pm_runtime_put_autosuspend(&sensor->i2c_client->dev); 3757 3758 } 3758 3759 ··· 3962 3965 3963 3966 pm_runtime_set_autosuspend_delay(dev, 1000); 3964 3967 pm_runtime_use_autosuspend(dev); 3965 3965 - pm_runtime_mark_last_busy(dev); 3966 3968 pm_runtime_put_autosuspend(dev); 3967 3969 3968 3970 return 0;

-3

drivers/media/i2c/ov5645.c

reviewed

··· 808 808 break; 809 809 } 810 810 811 811 - pm_runtime_mark_last_busy(ov5645->dev); 812 811 pm_runtime_put_autosuspend(ov5645->dev); 813 812 814 813 return ret; ··· 978 979 OV5645_SYSTEM_CTRL0_STOP); 979 980 980 981 rpm_put: 981 981 - pm_runtime_mark_last_busy(ov5645->dev); 982 982 pm_runtime_put_autosuspend(ov5645->dev); 983 983 984 984 return ret; ··· 1194 1196 1195 1197 pm_runtime_set_autosuspend_delay(dev, 1000); 1196 1198 pm_runtime_use_autosuspend(dev); 1197 1197 - pm_runtime_mark_last_busy(dev); 1198 1199 pm_runtime_put_autosuspend(dev); 1199 1200 1200 1201 return 0;

+1 -6

drivers/media/i2c/ov64a40.c

reviewed

··· 2990 2990 return 0; 2991 2991 2992 2992 error_power_off: 2993 2993 - pm_runtime_mark_last_busy(ov64a40->dev); 2994 2993 pm_runtime_put_autosuspend(ov64a40->dev); 2995 2994 2996 2995 return ret; ··· 2999 3000 struct v4l2_subdev_state *state) 3000 3001 { 3001 3002 cci_update_bits(ov64a40->cci, OV64A40_REG_SMIA, BIT(0), 0, NULL); 3002 3002 - pm_runtime_mark_last_busy(ov64a40->dev); 3003 3003 pm_runtime_put_autosuspend(ov64a40->dev); 3004 3004 3005 3005 __v4l2_ctrl_grab(ov64a40->link_freq, false); ··· 3327 3329 break; 3328 3330 } 3329 3331 3330 3330 - if (pm_status > 0) { 3331 3331 - pm_runtime_mark_last_busy(ov64a40->dev); 3332 3332 + if (pm_status > 0) 3332 3333 pm_runtime_put_autosuspend(ov64a40->dev); 3333 3333 - } 3334 3334 3335 3335 return ret; 3336 3336 } ··· 3618 3622 goto error_subdev_cleanup; 3619 3623 } 3620 3624 3621 3621 - pm_runtime_mark_last_busy(&client->dev); 3622 3625 pm_runtime_put_autosuspend(&client->dev); 3623 3626 3624 3627 return 0;

-2

drivers/media/i2c/ov8858.c

reviewed

··· 1391 1391 } 1392 1392 } else { 1393 1393 ov8858_stop_stream(ov8858); 1394 1394 - pm_runtime_mark_last_busy(&client->dev); 1395 1394 pm_runtime_put_autosuspend(&client->dev); 1396 1395 } 1397 1396 ··· 1944 1945 goto err_power_off; 1945 1946 } 1946 1947 1947 1947 - pm_runtime_mark_last_busy(dev); 1948 1948 pm_runtime_put_autosuspend(dev); 1949 1949 1950 1950 return 0;

-2

drivers/media/i2c/st-mipid02.c

reviewed

··· 465 465 if (ret) 466 466 goto error; 467 467 468 468 - pm_runtime_mark_last_busy(&client->dev); 469 468 pm_runtime_put_autosuspend(&client->dev); 470 469 471 470 error: ··· 541 542 cci_write(bridge->regmap, MIPID02_DATA_LANE0_REG1, 0, &ret); 542 543 cci_write(bridge->regmap, MIPID02_DATA_LANE1_REG1, 0, &ret); 543 544 544 544 - pm_runtime_mark_last_busy(&client->dev); 545 545 pm_runtime_put_autosuspend(&client->dev); 546 546 return ret; 547 547 }

-5

drivers/media/i2c/tc358746.c

reviewed

··· 816 816 return 0; 817 817 818 818 err_out: 819 819 - pm_runtime_mark_last_busy(sd->dev); 820 819 pm_runtime_put_sync_autosuspend(sd->dev); 821 820 822 821 return err; ··· 837 838 if (err) 838 839 return err; 839 840 840 840 - pm_runtime_mark_last_busy(sd->dev); 841 841 pm_runtime_put_sync_autosuspend(sd->dev); 842 842 843 843 return v4l2_subdev_call(src, video, s_stream, 0); ··· 1014 1016 err = tc358746_read(tc358746, reg->reg, &val); 1015 1017 reg->val = val; 1016 1018 1017 1017 - pm_runtime_mark_last_busy(sd->dev); 1018 1019 pm_runtime_put_sync_autosuspend(sd->dev); 1019 1020 1020 1021 return err; ··· 1029 1032 1030 1033 tc358746_write(tc358746, (u32)reg->reg, (u32)reg->val); 1031 1034 1032 1032 - pm_runtime_mark_last_busy(sd->dev); 1033 1035 pm_runtime_put_sync_autosuspend(sd->dev); 1034 1036 1035 1037 return 0; ··· 1391 1395 } 1392 1396 1393 1397 err = tc358746_read(tc358746, CHIPID_REG, &val); 1394 1394 - pm_runtime_mark_last_busy(dev); 1395 1398 pm_runtime_put_sync_autosuspend(dev); 1396 1399 if (err) 1397 1400 return -ENODEV;

-4

drivers/media/i2c/thp7312.c

reviewed

··· 808 808 if (!enable) { 809 809 thp7312_stream_enable(thp7312, false); 810 810 811 811 - pm_runtime_mark_last_busy(thp7312->dev); 812 811 pm_runtime_put_autosuspend(thp7312->dev); 813 812 814 813 v4l2_subdev_unlock_state(sd_state); ··· 838 839 goto finish_unlock; 839 840 840 841 finish_pm: 841 841 - pm_runtime_mark_last_busy(thp7312->dev); 842 842 pm_runtime_put_autosuspend(thp7312->dev); 843 843 finish_unlock: 844 844 v4l2_subdev_unlock_state(sd_state); ··· 1145 1147 break; 1146 1148 } 1147 1149 1148 1148 - pm_runtime_mark_last_busy(thp7312->dev); 1149 1150 pm_runtime_put_autosuspend(thp7312->dev); 1150 1151 1151 1152 return ret; ··· 2180 2183 * Decrease the PM usage count. The device will get suspended after the 2181 2184 * autosuspend delay, turning the power off. 2182 2185 */ 2183 2183 - pm_runtime_mark_last_busy(dev); 2184 2186 pm_runtime_put_autosuspend(dev); 2185 2187 2186 2188 dev_info(dev, "THP7312 firmware version %02u.%02u\n",

-4

drivers/media/i2c/vd55g1.c

reviewed

··· 1104 1104 1105 1105 vd55g1_grab_ctrls(sensor, false); 1106 1106 1107 1107 - pm_runtime_mark_last_busy(sensor->dev); 1108 1107 pm_runtime_put_autosuspend(sensor->dev); 1109 1108 1110 1109 return ret; ··· 1337 1338 break; 1338 1339 } 1339 1340 1340 1340 - pm_runtime_mark_last_busy(sensor->dev); 1341 1341 pm_runtime_put_autosuspend(sensor->dev); 1342 1342 1343 1343 return ret; ··· 1431 1433 break; 1432 1434 } 1433 1435 1434 1434 - pm_runtime_mark_last_busy(sensor->dev); 1435 1436 pm_runtime_put_autosuspend(sensor->dev); 1436 1437 1437 1438 return ret; ··· 1892 1895 pm_runtime_enable(dev); 1893 1896 pm_runtime_set_autosuspend_delay(dev, 4000); 1894 1897 pm_runtime_use_autosuspend(dev); 1895 1895 - pm_runtime_mark_last_busy(dev); 1896 1898 pm_runtime_put_autosuspend(dev); 1897 1899 1898 1900 ret = vd55g1_subdev_init(sensor);

-4

drivers/media/i2c/vd56g3.c

reviewed

··· 493 493 break; 494 494 } 495 495 496 496 - pm_runtime_mark_last_busy(sensor->dev); 497 496 pm_runtime_put_autosuspend(sensor->dev); 498 497 499 498 return ret; ··· 576 577 break; 577 578 } 578 579 579 579 - pm_runtime_mark_last_busy(sensor->dev); 580 580 pm_runtime_put_autosuspend(sensor->dev); 581 581 582 582 return ret; ··· 1019 1021 __v4l2_ctrl_grab(sensor->vflip_ctrl, false); 1020 1022 __v4l2_ctrl_grab(sensor->patgen_ctrl, false); 1021 1023 1022 1022 - pm_runtime_mark_last_busy(sensor->dev); 1023 1024 pm_runtime_put_autosuspend(sensor->dev); 1024 1025 1025 1026 return ret; ··· 1524 1527 } 1525 1528 1526 1529 /* Sensor could now be powered off (after the autosuspend delay) */ 1527 1527 - pm_runtime_mark_last_busy(dev); 1528 1530 pm_runtime_put_autosuspend(dev); 1529 1531 1530 1532 dev_dbg(dev, "Successfully probe %s sensor\n",

-4

drivers/media/i2c/video-i2c.c

reviewed

··· 288 288 return tmp; 289 289 290 290 tmp = regmap_bulk_read(data->regmap, AMG88XX_REG_TTHL, &buf, 2); 291 291 - pm_runtime_mark_last_busy(regmap_get_device(data->regmap)); 292 291 pm_runtime_put_autosuspend(regmap_get_device(data->regmap)); 293 292 if (tmp) 294 293 return tmp; ··· 526 527 return 0; 527 528 528 529 error_rpm_put: 529 529 - pm_runtime_mark_last_busy(dev); 530 530 pm_runtime_put_autosuspend(dev); 531 531 error_del_list: 532 532 video_i2c_del_list(vq, VB2_BUF_STATE_QUEUED); ··· 542 544 543 545 kthread_stop(data->kthread_vid_cap); 544 546 data->kthread_vid_cap = NULL; 545 545 - pm_runtime_mark_last_busy(regmap_get_device(data->regmap)); 546 547 pm_runtime_put_autosuspend(regmap_get_device(data->regmap)); 547 548 548 549 video_i2c_del_list(vq, VB2_BUF_STATE_ERROR); ··· 850 853 if (ret < 0) 851 854 goto error_pm_disable; 852 855 853 853 - pm_runtime_mark_last_busy(&client->dev); 854 856 pm_runtime_put_autosuspend(&client->dev); 855 857 856 858 return 0;

-4

drivers/media/platform/chips-media/wave5/wave5-vpu-dec.c

reviewed

··· 451 451 if (q_status.report_queue_count == 0 && 452 452 (q_status.instance_queue_count == 0 || dec_info.sequence_changed)) { 453 453 dev_dbg(inst->dev->dev, "%s: finishing job.\n", __func__); 454 454 - pm_runtime_mark_last_busy(inst->dev->dev); 455 454 pm_runtime_put_autosuspend(inst->dev->dev); 456 455 v4l2_m2m_job_finish(inst->v4l2_m2m_dev, m2m_ctx); 457 456 } ··· 1363 1364 } 1364 1365 1365 1366 } 1366 1366 - pm_runtime_mark_last_busy(inst->dev->dev); 1367 1367 pm_runtime_put_autosuspend(inst->dev->dev); 1368 1368 return ret; 1369 1369 ··· 1496 1498 else 1497 1499 streamoff_capture(q); 1498 1500 1499 1499 - pm_runtime_mark_last_busy(inst->dev->dev); 1500 1501 pm_runtime_put_autosuspend(inst->dev->dev); 1501 1502 } 1502 1503 ··· 1659 1662 1660 1663 finish_job_and_return: 1661 1664 dev_dbg(inst->dev->dev, "%s: leave and finish job", __func__); 1662 1662 - pm_runtime_mark_last_busy(inst->dev->dev); 1663 1665 pm_runtime_put_autosuspend(inst->dev->dev); 1664 1666 v4l2_m2m_job_finish(inst->v4l2_m2m_dev, m2m_ctx); 1665 1667 }

-5

drivers/media/platform/chips-media/wave5/wave5-vpu-enc.c

reviewed

··· 1391 1391 if (ret) 1392 1392 goto return_buffers; 1393 1393 1394 1394 - pm_runtime_mark_last_busy(inst->dev->dev); 1395 1394 pm_runtime_put_autosuspend(inst->dev->dev); 1396 1395 return 0; 1397 1396 return_buffers: 1398 1397 wave5_return_bufs(q, VB2_BUF_STATE_QUEUED); 1399 1399 - pm_runtime_mark_last_busy(inst->dev->dev); 1400 1398 pm_runtime_put_autosuspend(inst->dev->dev); 1401 1399 return ret; 1402 1400 } ··· 1463 1465 else 1464 1466 streamoff_capture(inst, q); 1465 1467 1466 1466 - pm_runtime_mark_last_busy(inst->dev->dev); 1467 1468 pm_runtime_put_autosuspend(inst->dev->dev); 1468 1469 } 1469 1470 ··· 1517 1520 break; 1518 1521 } 1519 1522 dev_dbg(inst->dev->dev, "%s: leave with active job", __func__); 1520 1520 - pm_runtime_mark_last_busy(inst->dev->dev); 1521 1523 pm_runtime_put_autosuspend(inst->dev->dev); 1522 1524 return; 1523 1525 default: ··· 1525 1529 break; 1526 1530 } 1527 1531 dev_dbg(inst->dev->dev, "%s: leave and finish job", __func__); 1528 1528 - pm_runtime_mark_last_busy(inst->dev->dev); 1529 1532 pm_runtime_put_autosuspend(inst->dev->dev); 1530 1533 v4l2_m2m_job_finish(inst->v4l2_m2m_dev, m2m_ctx); 1531 1534 }

-2

drivers/media/platform/nvidia/tegra-vde/h264.c

reviewed

··· 585 585 return 0; 586 586 587 587 put_runtime_pm: 588 588 - pm_runtime_mark_last_busy(dev); 589 588 pm_runtime_put_autosuspend(dev); 590 589 591 590 unlock: ··· 611 612 if (err) 612 613 dev_err(dev, "DEC end: Failed to assert HW reset: %d\n", err); 613 614 614 614 - pm_runtime_mark_last_busy(dev); 615 615 pm_runtime_put_autosuspend(dev); 616 616 617 617 mutex_unlock(&vde->lock);

-1

drivers/media/platform/qcom/iris/iris_hfi_queue.c

reviewed

··· 142 142 } 143 143 mutex_unlock(&core->lock); 144 144 145 145 - pm_runtime_mark_last_busy(core->dev); 146 145 pm_runtime_put_autosuspend(core->dev); 147 146 148 147 return 0;

-2

drivers/media/platform/raspberrypi/pisp_be/pisp_be.c

reviewed

··· 950 950 kfree(job); 951 951 } 952 952 953 953 - pm_runtime_mark_last_busy(pispbe->dev); 954 953 pm_runtime_put_autosuspend(pispbe->dev); 955 954 956 955 dev_dbg(pispbe->dev, "Nodes streaming now 0x%x\n", ··· 1741 1742 if (ret) 1742 1743 goto disable_devs_err; 1743 1744 1744 1744 - pm_runtime_mark_last_busy(pispbe->dev); 1745 1745 pm_runtime_put_autosuspend(pispbe->dev); 1746 1746 1747 1747 return 0;

+9 -8

drivers/media/platform/rockchip/rkvdec/rkvdec.c

reviewed

··· 765 765 { 766 766 struct rkvdec_dev *rkvdec = ctx->dev; 767 767 768 768 - pm_runtime_mark_last_busy(rkvdec->dev); 769 768 pm_runtime_put_autosuspend(rkvdec->dev); 770 769 rkvdec_job_finish_no_pm(ctx, result); 771 770 } ··· 1158 1159 return ret; 1159 1160 } 1160 1161 1161 1161 - if (iommu_get_domain_for_dev(&pdev->dev)) { 1162 1162 - rkvdec->empty_domain = iommu_paging_domain_alloc(rkvdec->dev); 1163 1163 - 1164 1164 - if (!rkvdec->empty_domain) 1165 1165 - dev_warn(rkvdec->dev, "cannot alloc new empty domain\n"); 1166 1166 - } 1167 1167 - 1168 1162 vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32)); 1169 1163 1170 1164 irq = platform_get_irq(pdev, 0); ··· 1179 1187 ret = rkvdec_v4l2_init(rkvdec); 1180 1188 if (ret) 1181 1189 goto err_disable_runtime_pm; 1190 1190 + 1191 1191 + if (iommu_get_domain_for_dev(&pdev->dev)) { 1192 1192 + rkvdec->empty_domain = iommu_paging_domain_alloc(rkvdec->dev); 1193 1193 + 1194 1194 + if (IS_ERR(rkvdec->empty_domain)) { 1195 1195 + rkvdec->empty_domain = NULL; 1196 1196 + dev_warn(rkvdec->dev, "cannot alloc new empty domain\n"); 1197 1197 + } 1198 1198 + } 1182 1199 1183 1200 return 0; 1184 1201

-1

drivers/media/platform/verisilicon/hantro_drv.c

reviewed

··· 89 89 struct hantro_ctx *ctx, 90 90 enum vb2_buffer_state result) 91 91 { 92 92 - pm_runtime_mark_last_busy(vpu->dev); 93 92 pm_runtime_put_autosuspend(vpu->dev); 94 93 95 94 clk_bulk_disable(vpu->variant->num_clocks, vpu->clocks);

+1 -3

drivers/media/rc/gpio-ir-recv.c

reviewed

··· 48 48 if (val >= 0) 49 49 ir_raw_event_store_edge(gpio_dev->rcdev, val == 1); 50 50 51 51 - if (pmdev) { 52 52 - pm_runtime_mark_last_busy(pmdev); 51 51 + if (pmdev) 53 52 pm_runtime_put_autosuspend(pmdev); 54 54 - } 55 53 56 54 return IRQ_HANDLED; 57 55 }

drivers/platform/x86/intel/int3472/discrete.c

reviewed

··· 193 193 *con_id = "privacy-led"; 194 194 *gpio_flags = GPIO_ACTIVE_HIGH; 195 195 break; 196 196 + case INT3472_GPIO_TYPE_HOTPLUG_DETECT: 197 197 + *con_id = "hpd"; 198 198 + *gpio_flags = GPIO_ACTIVE_HIGH; 199 199 + break; 196 200 case INT3472_GPIO_TYPE_POWER_ENABLE: 197 201 *con_id = "avdd"; 198 202 *gpio_flags = GPIO_ACTIVE_HIGH; ··· 227 223 * 0x0b Power enable 228 224 * 0x0c Clock enable 229 225 * 0x0d Privacy LED 226 226 + * 0x13 Hotplug detect 230 227 * 231 228 * There are some known platform specific quirks where that does not quite 232 229 * hold up; for example where a pin with type 0x01 (Power down) is mapped to ··· 297 292 switch (type) { 298 293 case INT3472_GPIO_TYPE_RESET: 299 294 case INT3472_GPIO_TYPE_POWERDOWN: 295 295 + case INT3472_GPIO_TYPE_HOTPLUG_DETECT: 300 296 ret = skl_int3472_map_gpio_to_sensor(int3472, agpio, con_id, gpio_flags); 301 297 if (ret) 302 298 err_msg = "Failed to map GPIO pin to sensor\n";

include/linux/platform_data/x86/int3472.h

reviewed

··· 27 27 #define INT3472_GPIO_TYPE_CLK_ENABLE 0x0c 28 28 #define INT3472_GPIO_TYPE_PRIVACY_LED 0x0d 29 29 #define INT3472_GPIO_TYPE_HANDSHAKE 0x12 30 30 + #define INT3472_GPIO_TYPE_HOTPLUG_DETECT 0x13 30 31 31 32 #define INT3472_PDEV_MAX_NAME_LEN 23 32 33 #define INT3472_MAX_SENSOR_GPIOS 3