tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

coresight: Refactor runtime PM

The validation for driver data pointers and clock pointers are redundant
in the runtime PM callbacks. After a driver's probing, its driver data
and clocks have been initialized successfully, this ensures it is safe
to access driver data and clocks in the runtime PM callbacks. A corner
case is a clock pointer is NULL, in this case, the clock core layer can
handle it properly. So remove these redundant checking.

In runtime resume, respect values returned from clock function and add
error handling.

Reviewed-by: Anshuman Khandual <anshuman.khandual@arm.com>
Reviewed-by: Yeoreum Yun <yeoreum.yun@arm.com>
Tested-by: James Clark <james.clark@linaro.org>
Signed-off-by: Leo Yan <leo.yan@arm.com>
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Link: https://lore.kernel.org/r/20250731-arm_cs_fix_clock_v4-v6-10-1dfe10bb3f6f@arm.com

authored by

Leo Yan and committed by
Suzuki K Poulose dc783892 7b20a4fa

+53 -60
+3 -5
drivers/hwtracing/coresight/coresight-cpu-debug.c
··· 731 731 { 732 732 struct debug_drvdata *drvdata = dev_get_drvdata(dev); 733 733 734 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 735 - clk_disable_unprepare(drvdata->pclk); 734 + clk_disable_unprepare(drvdata->pclk); 735 + 736 736 return 0; 737 737 } 738 738 ··· 740 740 { 741 741 struct debug_drvdata *drvdata = dev_get_drvdata(dev); 742 742 743 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 744 - clk_prepare_enable(drvdata->pclk); 745 - return 0; 743 + return clk_prepare_enable(drvdata->pclk); 746 744 } 747 745 #endif 748 746
+2 -6
drivers/hwtracing/coresight/coresight-ctcu-core.c
··· 278 278 { 279 279 struct ctcu_drvdata *drvdata = dev_get_drvdata(dev); 280 280 281 - if (drvdata && !IS_ERR_OR_NULL(drvdata->apb_clk)) 282 - clk_disable_unprepare(drvdata->apb_clk); 281 + clk_disable_unprepare(drvdata->apb_clk); 283 282 284 283 return 0; 285 284 } ··· 287 288 { 288 289 struct ctcu_drvdata *drvdata = dev_get_drvdata(dev); 289 290 290 - if (drvdata && !IS_ERR_OR_NULL(drvdata->apb_clk)) 291 - clk_prepare_enable(drvdata->apb_clk); 292 - 293 - return 0; 291 + return clk_prepare_enable(drvdata->apb_clk); 294 292 } 295 293 #endif 296 294
+2 -6
drivers/hwtracing/coresight/coresight-etb10.c
··· 809 809 { 810 810 struct etb_drvdata *drvdata = dev_get_drvdata(dev); 811 811 812 - if (drvdata && !IS_ERR(drvdata->atclk)) 813 - clk_disable_unprepare(drvdata->atclk); 812 + clk_disable_unprepare(drvdata->atclk); 814 813 815 814 return 0; 816 815 } ··· 818 819 { 819 820 struct etb_drvdata *drvdata = dev_get_drvdata(dev); 820 821 821 - if (drvdata && !IS_ERR(drvdata->atclk)) 822 - clk_prepare_enable(drvdata->atclk); 823 - 824 - return 0; 822 + return clk_prepare_enable(drvdata->atclk); 825 823 } 826 824 #endif 827 825
+2 -6
drivers/hwtracing/coresight/coresight-etm3x-core.c
··· 925 925 { 926 926 struct etm_drvdata *drvdata = dev_get_drvdata(dev); 927 927 928 - if (drvdata && !IS_ERR(drvdata->atclk)) 929 - clk_disable_unprepare(drvdata->atclk); 928 + clk_disable_unprepare(drvdata->atclk); 930 929 931 930 return 0; 932 931 } ··· 934 935 { 935 936 struct etm_drvdata *drvdata = dev_get_drvdata(dev); 936 937 937 - if (drvdata && !IS_ERR(drvdata->atclk)) 938 - clk_prepare_enable(drvdata->atclk); 939 - 940 - return 0; 938 + return clk_prepare_enable(drvdata->atclk); 941 939 } 942 940 #endif 943 941
+11 -10
drivers/hwtracing/coresight/coresight-funnel.c
··· 284 284 { 285 285 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); 286 286 287 - if (drvdata && !IS_ERR(drvdata->atclk)) 288 - clk_disable_unprepare(drvdata->atclk); 289 - 290 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 291 - clk_disable_unprepare(drvdata->pclk); 287 + clk_disable_unprepare(drvdata->atclk); 288 + clk_disable_unprepare(drvdata->pclk); 292 289 293 290 return 0; 294 291 } ··· 293 296 static int funnel_runtime_resume(struct device *dev) 294 297 { 295 298 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); 299 + int ret; 296 300 297 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 298 - clk_prepare_enable(drvdata->pclk); 301 + ret = clk_prepare_enable(drvdata->pclk); 302 + if (ret) 303 + return ret; 299 304 300 - if (drvdata && !IS_ERR(drvdata->atclk)) 301 - clk_prepare_enable(drvdata->atclk); 302 - return 0; 305 + ret = clk_prepare_enable(drvdata->atclk); 306 + if (ret) 307 + clk_disable_unprepare(drvdata->pclk); 308 + 309 + return ret; 303 310 } 304 311 #endif 305 312
+11 -9
drivers/hwtracing/coresight/coresight-replicator.c
··· 323 323 { 324 324 struct replicator_drvdata *drvdata = dev_get_drvdata(dev); 325 325 326 - if (drvdata && !IS_ERR(drvdata->atclk)) 327 - clk_disable_unprepare(drvdata->atclk); 326 + clk_disable_unprepare(drvdata->atclk); 327 + clk_disable_unprepare(drvdata->pclk); 328 328 329 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 330 - clk_disable_unprepare(drvdata->pclk); 331 329 return 0; 332 330 } 333 331 334 332 static int replicator_runtime_resume(struct device *dev) 335 333 { 336 334 struct replicator_drvdata *drvdata = dev_get_drvdata(dev); 335 + int ret; 337 336 338 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 339 - clk_prepare_enable(drvdata->pclk); 337 + ret = clk_prepare_enable(drvdata->pclk); 338 + if (ret) 339 + return ret; 340 340 341 - if (drvdata && !IS_ERR(drvdata->atclk)) 342 - clk_prepare_enable(drvdata->atclk); 343 - return 0; 341 + ret = clk_prepare_enable(drvdata->atclk); 342 + if (ret) 343 + clk_disable_unprepare(drvdata->pclk); 344 + 345 + return ret; 344 346 } 345 347 #endif 346 348
+11 -9
drivers/hwtracing/coresight/coresight-stm.c
··· 957 957 { 958 958 struct stm_drvdata *drvdata = dev_get_drvdata(dev); 959 959 960 - if (drvdata && !IS_ERR(drvdata->atclk)) 961 - clk_disable_unprepare(drvdata->atclk); 960 + clk_disable_unprepare(drvdata->atclk); 961 + clk_disable_unprepare(drvdata->pclk); 962 962 963 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 964 - clk_disable_unprepare(drvdata->pclk); 965 963 return 0; 966 964 } 967 965 968 966 static int stm_runtime_resume(struct device *dev) 969 967 { 970 968 struct stm_drvdata *drvdata = dev_get_drvdata(dev); 969 + int ret; 971 970 972 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 973 - clk_prepare_enable(drvdata->pclk); 971 + ret = clk_prepare_enable(drvdata->pclk); 972 + if (ret) 973 + return ret; 974 974 975 - if (drvdata && !IS_ERR(drvdata->atclk)) 976 - clk_prepare_enable(drvdata->atclk); 977 - return 0; 975 + ret = clk_prepare_enable(drvdata->atclk); 976 + if (ret) 977 + clk_disable_unprepare(drvdata->pclk); 978 + 979 + return ret; 978 980 } 979 981 #endif 980 982
+11 -9
drivers/hwtracing/coresight/coresight-tpiu.c
··· 206 206 { 207 207 struct tpiu_drvdata *drvdata = dev_get_drvdata(dev); 208 208 209 - if (drvdata && !IS_ERR(drvdata->atclk)) 210 - clk_disable_unprepare(drvdata->atclk); 209 + clk_disable_unprepare(drvdata->atclk); 210 + clk_disable_unprepare(drvdata->pclk); 211 211 212 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 213 - clk_disable_unprepare(drvdata->pclk); 214 212 return 0; 215 213 } 216 214 217 215 static int tpiu_runtime_resume(struct device *dev) 218 216 { 219 217 struct tpiu_drvdata *drvdata = dev_get_drvdata(dev); 218 + int ret; 220 219 221 - if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk)) 222 - clk_prepare_enable(drvdata->pclk); 220 + ret = clk_prepare_enable(drvdata->pclk); 221 + if (ret) 222 + return ret; 223 223 224 - if (drvdata && !IS_ERR(drvdata->atclk)) 225 - clk_prepare_enable(drvdata->atclk); 226 - return 0; 224 + ret = clk_prepare_enable(drvdata->atclk); 225 + if (ret) 226 + clk_disable_unprepare(drvdata->pclk); 227 + 228 + return ret; 227 229 } 228 230 #endif 229 231