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.

iio: magnetometer: bmc150_magn: use automated cleanup for mutex

Use guard() and scoped_guard() to replace manual mutex lock/unlock
calls. This simplifies error handling and ensures RAII-style cleanup.

guard() is used in read_raw, write_raw, trig_reen, and
trigger_set_state. Case blocks using guard() in read_raw and write_raw
are wrapped in braces at the case label level to ensure clear scope for
the cleanup guards.

A bmc150_magn_set_power_mode_locked() helper is added to deduplicate
the lock-call-unlock pattern used by remove, runtime_suspend, suspend,
and resume.

The trigger_handler function is left unchanged as mixing guard() with
goto error paths can be fragile.

Signed-off-by: Neel Bullywon <neelb2403@gmail.com>
Acked-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

authored by

Neel Bullywon and committed by
Jonathan Cameron 7031ee94 cd04646c

+44 -68
+44 -68
drivers/iio/magnetometer/bmc150_magn.c
··· 12 12 #include <linux/module.h> 13 13 #include <linux/i2c.h> 14 14 #include <linux/interrupt.h> 15 + #include <linux/cleanup.h> 15 16 #include <linux/delay.h> 16 17 #include <linux/slab.h> 17 18 #include <linux/pm.h> ··· 258 257 return -EINVAL; 259 258 } 260 259 260 + static int bmc150_magn_set_power_mode_locked(struct bmc150_magn_data *data, 261 + enum bmc150_magn_power_modes mode) 262 + { 263 + guard(mutex)(&data->mutex); 264 + return bmc150_magn_set_power_mode(data, mode, true); 265 + } 266 + 261 267 static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on) 262 268 { 263 269 int ret = 0; ··· 463 455 s32 values[AXIS_XYZ_MAX]; 464 456 465 457 switch (mask) { 466 - case IIO_CHAN_INFO_RAW: 458 + case IIO_CHAN_INFO_RAW: { 467 459 if (iio_buffer_enabled(indio_dev)) 468 460 return -EBUSY; 469 - mutex_lock(&data->mutex); 461 + 462 + guard(mutex)(&data->mutex); 470 463 471 464 ret = bmc150_magn_set_power_state(data, true); 472 - if (ret < 0) { 473 - mutex_unlock(&data->mutex); 465 + if (ret < 0) 474 466 return ret; 475 - } 476 467 477 468 ret = bmc150_magn_read_xyz(data, values); 478 469 if (ret < 0) { 479 470 bmc150_magn_set_power_state(data, false); 480 - mutex_unlock(&data->mutex); 481 471 return ret; 482 472 } 483 473 *val = values[chan->scan_index]; 484 474 485 475 ret = bmc150_magn_set_power_state(data, false); 486 - if (ret < 0) { 487 - mutex_unlock(&data->mutex); 476 + if (ret < 0) 488 477 return ret; 489 - } 490 478 491 - mutex_unlock(&data->mutex); 492 479 return IIO_VAL_INT; 480 + } 493 481 case IIO_CHAN_INFO_SCALE: 494 482 /* 495 483 * The API/driver performs an off-chip temperature ··· 533 529 int ret; 534 530 535 531 switch (mask) { 536 - case IIO_CHAN_INFO_SAMP_FREQ: 532 + case IIO_CHAN_INFO_SAMP_FREQ: { 537 533 if (val > data->max_odr) 538 534 return -EINVAL; 539 - mutex_lock(&data->mutex); 540 - ret = bmc150_magn_set_odr(data, val); 541 - mutex_unlock(&data->mutex); 542 - return ret; 535 + guard(mutex)(&data->mutex); 536 + return bmc150_magn_set_odr(data, val); 537 + } 543 538 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 544 539 switch (chan->channel2) { 545 540 case IIO_MOD_X: 546 - case IIO_MOD_Y: 541 + case IIO_MOD_Y: { 547 542 if (val < 1 || val > 511) 548 543 return -EINVAL; 549 - mutex_lock(&data->mutex); 544 + guard(mutex)(&data->mutex); 550 545 ret = bmc150_magn_set_max_odr(data, val, 0, 0); 551 - if (ret < 0) { 552 - mutex_unlock(&data->mutex); 546 + if (ret < 0) 553 547 return ret; 554 - } 555 - ret = regmap_update_bits(data->regmap, 548 + return regmap_update_bits(data->regmap, 556 549 BMC150_MAGN_REG_REP_XY, 557 550 BMC150_MAGN_REG_REP_DATAMASK, 558 - BMC150_MAGN_REPXY_TO_REGVAL 559 - (val)); 560 - mutex_unlock(&data->mutex); 561 - return ret; 562 - case IIO_MOD_Z: 551 + BMC150_MAGN_REPXY_TO_REGVAL(val)); 552 + } 553 + case IIO_MOD_Z: { 563 554 if (val < 1 || val > 256) 564 555 return -EINVAL; 565 - mutex_lock(&data->mutex); 556 + guard(mutex)(&data->mutex); 566 557 ret = bmc150_magn_set_max_odr(data, 0, val, 0); 567 - if (ret < 0) { 568 - mutex_unlock(&data->mutex); 558 + if (ret < 0) 569 559 return ret; 570 - } 571 - ret = regmap_update_bits(data->regmap, 560 + return regmap_update_bits(data->regmap, 572 561 BMC150_MAGN_REG_REP_Z, 573 562 BMC150_MAGN_REG_REP_DATAMASK, 574 - BMC150_MAGN_REPZ_TO_REGVAL 575 - (val)); 576 - mutex_unlock(&data->mutex); 577 - return ret; 563 + BMC150_MAGN_REPZ_TO_REGVAL(val)); 564 + } 578 565 default: 579 566 return -EINVAL; 580 567 } ··· 780 785 if (!data->dready_trigger_on) 781 786 return; 782 787 783 - mutex_lock(&data->mutex); 788 + guard(mutex)(&data->mutex); 784 789 ret = bmc150_magn_reset_intr(data); 785 - mutex_unlock(&data->mutex); 786 790 if (ret) 787 791 dev_err(data->dev, "Failed to reset interrupt\n"); 788 792 } ··· 791 797 { 792 798 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 793 799 struct bmc150_magn_data *data = iio_priv(indio_dev); 794 - int ret = 0; 800 + int ret; 795 801 796 - mutex_lock(&data->mutex); 802 + guard(mutex)(&data->mutex); 803 + 797 804 if (state == data->dready_trigger_on) 798 - goto err_unlock; 805 + return 0; 799 806 800 807 ret = regmap_update_bits(data->regmap, BMC150_MAGN_REG_INT_DRDY, 801 808 BMC150_MAGN_MASK_DRDY_EN, 802 809 state << BMC150_MAGN_SHIFT_DRDY_EN); 803 810 if (ret < 0) 804 - goto err_unlock; 811 + return ret; 805 812 806 813 data->dready_trigger_on = state; 807 814 808 815 if (state) { 809 816 ret = bmc150_magn_reset_intr(data); 810 817 if (ret < 0) 811 - goto err_unlock; 818 + return ret; 812 819 } 813 - mutex_unlock(&data->mutex); 814 820 815 821 return 0; 816 - 817 - err_unlock: 818 - mutex_unlock(&data->mutex); 819 - return ret; 820 822 } 821 823 822 824 static const struct iio_trigger_ops bmc150_magn_trigger_ops = { ··· 970 980 if (data->dready_trig) 971 981 iio_trigger_unregister(data->dready_trig); 972 982 973 - mutex_lock(&data->mutex); 974 - bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SUSPEND, true); 975 - mutex_unlock(&data->mutex); 983 + bmc150_magn_set_power_mode_locked(data, BMC150_MAGN_POWER_MODE_SUSPEND); 976 984 977 985 regulator_bulk_disable(ARRAY_SIZE(data->regulators), data->regulators); 978 986 } ··· 983 995 struct bmc150_magn_data *data = iio_priv(indio_dev); 984 996 int ret; 985 997 986 - mutex_lock(&data->mutex); 987 - ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SLEEP, 988 - true); 989 - mutex_unlock(&data->mutex); 998 + ret = bmc150_magn_set_power_mode_locked(data, 999 + BMC150_MAGN_POWER_MODE_SLEEP); 990 1000 if (ret < 0) { 991 1001 dev_err(dev, "powering off device failed\n"); 992 1002 return ret; ··· 1010 1024 { 1011 1025 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1012 1026 struct bmc150_magn_data *data = iio_priv(indio_dev); 1013 - int ret; 1014 1027 1015 - mutex_lock(&data->mutex); 1016 - ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SLEEP, 1017 - true); 1018 - mutex_unlock(&data->mutex); 1019 - 1020 - return ret; 1028 + return bmc150_magn_set_power_mode_locked(data, 1029 + BMC150_MAGN_POWER_MODE_SLEEP); 1021 1030 } 1022 1031 1023 1032 static int bmc150_magn_resume(struct device *dev) 1024 1033 { 1025 1034 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1026 1035 struct bmc150_magn_data *data = iio_priv(indio_dev); 1027 - int ret; 1028 1036 1029 - mutex_lock(&data->mutex); 1030 - ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_NORMAL, 1031 - true); 1032 - mutex_unlock(&data->mutex); 1033 - 1034 - return ret; 1037 + return bmc150_magn_set_power_mode_locked(data, 1038 + BMC150_MAGN_POWER_MODE_NORMAL); 1035 1039 } 1036 1040 #endif 1037 1041