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

iio: Reconcile operation order between iio_register/unregister and pm functions

At probe, runtime pm should be setup before registering the sysfs interface so
that all the power attributes are accurate and functional when registering.
Also, when removing the device we should unregister first to make sure
that the interfaces that may result in wakeups are no longer available.

Fix this behaviour for the following drivers: bmc150, bmg160, kmx61,
kxcj-1013, mma9551, mma9553, rpr0521.

Signed-off-by: Adriana Reus <adriana.reus@intel.com>
Signed-off-by: Jonathan Cameron <jic23@kernel.org>

authored by

Adriana Reus and committed by
Jonathan Cameron 7d0ead5c 536bbca7

+70 -88
+10 -12
drivers/iio/accel/bmc150-accel-core.c
··· 1623 1623 } 1624 1624 } 1625 1625 1626 + ret = pm_runtime_set_active(dev); 1627 + if (ret) 1628 + goto err_trigger_unregister; 1629 + 1630 + pm_runtime_enable(dev); 1631 + pm_runtime_set_autosuspend_delay(dev, BMC150_AUTO_SUSPEND_DELAY_MS); 1632 + pm_runtime_use_autosuspend(dev); 1633 + 1626 1634 ret = iio_device_register(indio_dev); 1627 1635 if (ret < 0) { 1628 1636 dev_err(dev, "Unable to register iio device\n"); 1629 1637 goto err_trigger_unregister; 1630 1638 } 1631 1639 1632 - ret = pm_runtime_set_active(dev); 1633 - if (ret) 1634 - goto err_iio_unregister; 1635 - 1636 - pm_runtime_enable(dev); 1637 - pm_runtime_set_autosuspend_delay(dev, BMC150_AUTO_SUSPEND_DELAY_MS); 1638 - pm_runtime_use_autosuspend(dev); 1639 - 1640 1640 return 0; 1641 1641 1642 - err_iio_unregister: 1643 - iio_device_unregister(indio_dev); 1644 1642 err_trigger_unregister: 1645 1643 bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1); 1646 1644 err_buffer_cleanup: ··· 1653 1655 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1654 1656 struct bmc150_accel_data *data = iio_priv(indio_dev); 1655 1657 1658 + iio_device_unregister(indio_dev); 1659 + 1656 1660 pm_runtime_disable(data->dev); 1657 1661 pm_runtime_set_suspended(data->dev); 1658 1662 pm_runtime_put_noidle(data->dev); 1659 - 1660 - iio_device_unregister(indio_dev); 1661 1663 1662 1664 bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1); 1663 1665
+9 -11
drivers/iio/accel/kxcjk-1013.c
··· 1264 1264 goto err_trigger_unregister; 1265 1265 } 1266 1266 1267 - ret = iio_device_register(indio_dev); 1268 - if (ret < 0) { 1269 - dev_err(&client->dev, "unable to register iio device\n"); 1270 - goto err_buffer_cleanup; 1271 - } 1272 - 1273 1267 ret = pm_runtime_set_active(&client->dev); 1274 1268 if (ret) 1275 - goto err_iio_unregister; 1269 + goto err_buffer_cleanup; 1276 1270 1277 1271 pm_runtime_enable(&client->dev); 1278 1272 pm_runtime_set_autosuspend_delay(&client->dev, 1279 1273 KXCJK1013_SLEEP_DELAY_MS); 1280 1274 pm_runtime_use_autosuspend(&client->dev); 1281 1275 1276 + ret = iio_device_register(indio_dev); 1277 + if (ret < 0) { 1278 + dev_err(&client->dev, "unable to register iio device\n"); 1279 + goto err_buffer_cleanup; 1280 + } 1281 + 1282 1282 return 0; 1283 1283 1284 - err_iio_unregister: 1285 - iio_device_unregister(indio_dev); 1286 1284 err_buffer_cleanup: 1287 1285 if (data->dready_trig) 1288 1286 iio_triggered_buffer_cleanup(indio_dev); ··· 1300 1302 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1301 1303 struct kxcjk1013_data *data = iio_priv(indio_dev); 1302 1304 1305 + iio_device_unregister(indio_dev); 1306 + 1303 1307 pm_runtime_disable(&client->dev); 1304 1308 pm_runtime_set_suspended(&client->dev); 1305 1309 pm_runtime_put_noidle(&client->dev); 1306 - 1307 - iio_device_unregister(indio_dev); 1308 1310 1309 1311 if (data->dready_trig) { 1310 1312 iio_triggered_buffer_cleanup(indio_dev);
+9 -10
drivers/iio/accel/mma9551.c
··· 495 495 if (ret < 0) 496 496 goto out_poweroff; 497 497 498 - ret = iio_device_register(indio_dev); 499 - if (ret < 0) { 500 - dev_err(&client->dev, "unable to register iio device\n"); 501 - goto out_poweroff; 502 - } 503 - 504 498 ret = pm_runtime_set_active(&client->dev); 505 499 if (ret < 0) 506 - goto out_iio_unregister; 500 + goto out_poweroff; 507 501 508 502 pm_runtime_enable(&client->dev); 509 503 pm_runtime_set_autosuspend_delay(&client->dev, 510 504 MMA9551_AUTO_SUSPEND_DELAY_MS); 511 505 pm_runtime_use_autosuspend(&client->dev); 512 506 507 + ret = iio_device_register(indio_dev); 508 + if (ret < 0) { 509 + dev_err(&client->dev, "unable to register iio device\n"); 510 + goto out_poweroff; 511 + } 512 + 513 513 return 0; 514 514 515 - out_iio_unregister: 516 - iio_device_unregister(indio_dev); 517 515 out_poweroff: 518 516 mma9551_set_device_state(client, false); 519 517 ··· 523 525 struct iio_dev *indio_dev = i2c_get_clientdata(client); 524 526 struct mma9551_data *data = iio_priv(indio_dev); 525 527 528 + iio_device_unregister(indio_dev); 529 + 526 530 pm_runtime_disable(&client->dev); 527 531 pm_runtime_set_suspended(&client->dev); 528 532 pm_runtime_put_noidle(&client->dev); 529 533 530 - iio_device_unregister(indio_dev); 531 534 mutex_lock(&data->mutex); 532 535 mma9551_set_device_state(data->client, false); 533 536 mutex_unlock(&data->mutex);
+9 -11
drivers/iio/accel/mma9553.c
··· 1133 1133 } 1134 1134 } 1135 1135 1136 - ret = iio_device_register(indio_dev); 1137 - if (ret < 0) { 1138 - dev_err(&client->dev, "unable to register iio device\n"); 1139 - goto out_poweroff; 1140 - } 1141 - 1142 1136 ret = pm_runtime_set_active(&client->dev); 1143 1137 if (ret < 0) 1144 - goto out_iio_unregister; 1138 + goto out_poweroff; 1145 1139 1146 1140 pm_runtime_enable(&client->dev); 1147 1141 pm_runtime_set_autosuspend_delay(&client->dev, 1148 1142 MMA9551_AUTO_SUSPEND_DELAY_MS); 1149 1143 pm_runtime_use_autosuspend(&client->dev); 1150 1144 1151 - dev_dbg(&indio_dev->dev, "Registered device %s\n", name); 1145 + ret = iio_device_register(indio_dev); 1146 + if (ret < 0) { 1147 + dev_err(&client->dev, "unable to register iio device\n"); 1148 + goto out_poweroff; 1149 + } 1152 1150 1151 + dev_dbg(&indio_dev->dev, "Registered device %s\n", name); 1153 1152 return 0; 1154 1153 1155 - out_iio_unregister: 1156 - iio_device_unregister(indio_dev); 1157 1154 out_poweroff: 1158 1155 mma9551_set_device_state(client, false); 1159 1156 return ret; ··· 1161 1164 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1162 1165 struct mma9553_data *data = iio_priv(indio_dev); 1163 1166 1167 + iio_device_unregister(indio_dev); 1168 + 1164 1169 pm_runtime_disable(&client->dev); 1165 1170 pm_runtime_set_suspended(&client->dev); 1166 1171 pm_runtime_put_noidle(&client->dev); 1167 1172 1168 - iio_device_unregister(indio_dev); 1169 1173 mutex_lock(&data->mutex); 1170 1174 mma9551_set_device_state(data->client, false); 1171 1175 mutex_unlock(&data->mutex);
+9 -10
drivers/iio/gyro/bmg160_core.c
··· 1077 1077 goto err_trigger_unregister; 1078 1078 } 1079 1079 1080 - ret = iio_device_register(indio_dev); 1081 - if (ret < 0) { 1082 - dev_err(dev, "unable to register iio device\n"); 1083 - goto err_buffer_cleanup; 1084 - } 1085 - 1086 1080 ret = pm_runtime_set_active(dev); 1087 1081 if (ret) 1088 - goto err_iio_unregister; 1082 + goto err_buffer_cleanup; 1089 1083 1090 1084 pm_runtime_enable(dev); 1091 1085 pm_runtime_set_autosuspend_delay(dev, 1092 1086 BMG160_AUTO_SUSPEND_DELAY_MS); 1093 1087 pm_runtime_use_autosuspend(dev); 1094 1088 1089 + ret = iio_device_register(indio_dev); 1090 + if (ret < 0) { 1091 + dev_err(dev, "unable to register iio device\n"); 1092 + goto err_buffer_cleanup; 1093 + } 1094 + 1095 1095 return 0; 1096 1096 1097 - err_iio_unregister: 1098 - iio_device_unregister(indio_dev); 1099 1097 err_buffer_cleanup: 1100 1098 iio_triggered_buffer_cleanup(indio_dev); 1101 1099 err_trigger_unregister: ··· 1111 1113 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1112 1114 struct bmg160_data *data = iio_priv(indio_dev); 1113 1115 1116 + iio_device_unregister(indio_dev); 1117 + 1114 1118 pm_runtime_disable(dev); 1115 1119 pm_runtime_set_suspended(dev); 1116 1120 pm_runtime_put_noidle(dev); 1117 1121 1118 - iio_device_unregister(indio_dev); 1119 1122 iio_triggered_buffer_cleanup(indio_dev); 1120 1123 1121 1124 if (data->dready_trig) {
+11 -13
drivers/iio/imu/kmx61.c
··· 1390 1390 } 1391 1391 } 1392 1392 1393 + ret = pm_runtime_set_active(&client->dev); 1394 + if (ret < 0) 1395 + goto err_buffer_cleanup_mag; 1396 + 1397 + pm_runtime_enable(&client->dev); 1398 + pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS); 1399 + pm_runtime_use_autosuspend(&client->dev); 1400 + 1393 1401 ret = iio_device_register(data->acc_indio_dev); 1394 1402 if (ret < 0) { 1395 1403 dev_err(&client->dev, "Failed to register acc iio device\n"); ··· 1410 1402 goto err_iio_unregister_acc; 1411 1403 } 1412 1404 1413 - ret = pm_runtime_set_active(&client->dev); 1414 - if (ret < 0) 1415 - goto err_iio_unregister_mag; 1416 - 1417 - pm_runtime_enable(&client->dev); 1418 - pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS); 1419 - pm_runtime_use_autosuspend(&client->dev); 1420 - 1421 1405 return 0; 1422 1406 1423 - err_iio_unregister_mag: 1424 - iio_device_unregister(data->mag_indio_dev); 1425 1407 err_iio_unregister_acc: 1426 1408 iio_device_unregister(data->acc_indio_dev); 1427 1409 err_buffer_cleanup_mag: ··· 1435 1437 { 1436 1438 struct kmx61_data *data = i2c_get_clientdata(client); 1437 1439 1440 + iio_device_unregister(data->acc_indio_dev); 1441 + iio_device_unregister(data->mag_indio_dev); 1442 + 1438 1443 pm_runtime_disable(&client->dev); 1439 1444 pm_runtime_set_suspended(&client->dev); 1440 1445 pm_runtime_put_noidle(&client->dev); 1441 - 1442 - iio_device_unregister(data->acc_indio_dev); 1443 - iio_device_unregister(data->mag_indio_dev); 1444 1446 1445 1447 if (client->irq > 0) { 1446 1448 iio_triggered_buffer_cleanup(data->acc_indio_dev);
+4 -10
drivers/iio/light/rpr0521.c
··· 507 507 dev_err(&client->dev, "rpr0521 chip init failed\n"); 508 508 return ret; 509 509 } 510 - ret = iio_device_register(indio_dev); 511 - if (ret < 0) 512 - return ret; 513 510 514 511 ret = pm_runtime_set_active(&client->dev); 515 512 if (ret < 0) 516 - goto err_iio_unregister; 513 + return ret; 517 514 518 515 pm_runtime_enable(&client->dev); 519 516 pm_runtime_set_autosuspend_delay(&client->dev, RPR0521_SLEEP_DELAY_MS); 520 517 pm_runtime_use_autosuspend(&client->dev); 521 518 522 - return 0; 523 - 524 - err_iio_unregister: 525 - iio_device_unregister(indio_dev); 526 - return ret; 519 + return iio_device_register(indio_dev); 527 520 } 528 521 529 522 static int rpr0521_remove(struct i2c_client *client) 530 523 { 531 524 struct iio_dev *indio_dev = i2c_get_clientdata(client); 532 525 526 + iio_device_unregister(indio_dev); 527 + 533 528 pm_runtime_disable(&client->dev); 534 529 pm_runtime_set_suspended(&client->dev); 535 530 pm_runtime_put_noidle(&client->dev); 536 531 537 - iio_device_unregister(indio_dev); 538 532 rpr0521_poweroff(iio_priv(indio_dev)); 539 533 540 534 return 0;
+9 -11
drivers/iio/magnetometer/bmc150_magn.c
··· 928 928 goto err_free_irq; 929 929 } 930 930 931 - ret = iio_device_register(indio_dev); 932 - if (ret < 0) { 933 - dev_err(&client->dev, "unable to register iio device\n"); 934 - goto err_buffer_cleanup; 935 - } 936 - 937 931 ret = pm_runtime_set_active(&client->dev); 938 932 if (ret) 939 - goto err_iio_unregister; 933 + goto err_buffer_cleanup; 940 934 941 935 pm_runtime_enable(&client->dev); 942 936 pm_runtime_set_autosuspend_delay(&client->dev, 943 937 BMC150_MAGN_AUTO_SUSPEND_DELAY_MS); 944 938 pm_runtime_use_autosuspend(&client->dev); 945 939 946 - dev_dbg(&indio_dev->dev, "Registered device %s\n", name); 940 + ret = iio_device_register(indio_dev); 941 + if (ret < 0) { 942 + dev_err(&client->dev, "unable to register iio device\n"); 943 + goto err_buffer_cleanup; 944 + } 947 945 946 + dev_dbg(&indio_dev->dev, "Registered device %s\n", name); 948 947 return 0; 949 948 950 - err_iio_unregister: 951 - iio_device_unregister(indio_dev); 952 949 err_buffer_cleanup: 953 950 iio_triggered_buffer_cleanup(indio_dev); 954 951 err_free_irq: ··· 964 967 struct iio_dev *indio_dev = i2c_get_clientdata(client); 965 968 struct bmc150_magn_data *data = iio_priv(indio_dev); 966 969 970 + iio_device_unregister(indio_dev); 971 + 967 972 pm_runtime_disable(&client->dev); 968 973 pm_runtime_set_suspended(&client->dev); 969 974 pm_runtime_put_noidle(&client->dev); 970 975 971 - iio_device_unregister(indio_dev); 972 976 iio_triggered_buffer_cleanup(indio_dev); 973 977 974 978 if (client->irq > 0)