diff options
author | Ulf Hansson <ulf.hansson@linaro.org> | 2016-05-30 05:43:08 -0400 |
---|---|---|
committer | Rafael J. Wysocki <rafael.j.wysocki@intel.com> | 2016-06-16 09:01:43 -0400 |
commit | 800188538965d90759cea13bcb4f87a214cf5c53 (patch) | |
tree | 1340e440b072d132fe2dd86258699b0cb2e1c3b9 /drivers/base | |
parent | 39dd0f234fc37da071dadbd9b49fe800d62139b4 (diff) |
PM / Domains: Remove redundant wrapper functions for system PM
Due to the previous changes in genpd, which removed the suspend_power_off
flag, several of the system PM callbacks no longer do any additional
checks but only invoke corresponding pm_generic_* helper functions.
To clean up the code, drop these wrapper functions as they have
become redundant. Instead, assign the system PM callbacks directly
to the pm_generic_*() helper functions.
While changing this, it has bocame clear that some of the current
system PM callbacks in genpd invoke wrong driver callbacks. For
example, the genpd's ->restore() callback invokes pm_generic_resume(),
while that should be pm_generic_restore(). Fix that as well.
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
Reviewed-by: Kevin Hilman <khilman@baylibre.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Diffstat (limited to 'drivers/base')
-rw-r--r-- | drivers/base/power/domain.c | 203 |
1 files changed, 12 insertions, 191 deletions
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c index a608f521e6fc..658eb1b229f8 100644 --- a/drivers/base/power/domain.c +++ b/drivers/base/power/domain.c | |||
@@ -768,48 +768,6 @@ static int pm_genpd_prepare(struct device *dev) | |||
768 | } | 768 | } |
769 | 769 | ||
770 | /** | 770 | /** |
771 | * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain. | ||
772 | * @dev: Device to suspend. | ||
773 | * | ||
774 | * Suspend a device under the assumption that its pm_domain field points to the | ||
775 | * domain member of an object of type struct generic_pm_domain representing | ||
776 | * a PM domain consisting of I/O devices. | ||
777 | */ | ||
778 | static int pm_genpd_suspend(struct device *dev) | ||
779 | { | ||
780 | struct generic_pm_domain *genpd; | ||
781 | |||
782 | dev_dbg(dev, "%s()\n", __func__); | ||
783 | |||
784 | genpd = dev_to_genpd(dev); | ||
785 | if (IS_ERR(genpd)) | ||
786 | return -EINVAL; | ||
787 | |||
788 | return pm_generic_suspend(dev); | ||
789 | } | ||
790 | |||
791 | /** | ||
792 | * pm_genpd_suspend_late - Late suspend of a device from an I/O PM domain. | ||
793 | * @dev: Device to suspend. | ||
794 | * | ||
795 | * Carry out a late suspend of a device under the assumption that its | ||
796 | * pm_domain field points to the domain member of an object of type | ||
797 | * struct generic_pm_domain representing a PM domain consisting of I/O devices. | ||
798 | */ | ||
799 | static int pm_genpd_suspend_late(struct device *dev) | ||
800 | { | ||
801 | struct generic_pm_domain *genpd; | ||
802 | |||
803 | dev_dbg(dev, "%s()\n", __func__); | ||
804 | |||
805 | genpd = dev_to_genpd(dev); | ||
806 | if (IS_ERR(genpd)) | ||
807 | return -EINVAL; | ||
808 | |||
809 | return pm_generic_suspend_late(dev); | ||
810 | } | ||
811 | |||
812 | /** | ||
813 | * pm_genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain. | 771 | * pm_genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain. |
814 | * @dev: Device to suspend. | 772 | * @dev: Device to suspend. |
815 | * | 773 | * |
@@ -873,92 +831,6 @@ static int pm_genpd_resume_noirq(struct device *dev) | |||
873 | } | 831 | } |
874 | 832 | ||
875 | /** | 833 | /** |
876 | * pm_genpd_resume_early - Early resume of a device in an I/O PM domain. | ||
877 | * @dev: Device to resume. | ||
878 | * | ||
879 | * Carry out an early resume of a device under the assumption that its | ||
880 | * pm_domain field points to the domain member of an object of type | ||
881 | * struct generic_pm_domain representing a power domain consisting of I/O | ||
882 | * devices. | ||
883 | */ | ||
884 | static int pm_genpd_resume_early(struct device *dev) | ||
885 | { | ||
886 | struct generic_pm_domain *genpd; | ||
887 | |||
888 | dev_dbg(dev, "%s()\n", __func__); | ||
889 | |||
890 | genpd = dev_to_genpd(dev); | ||
891 | if (IS_ERR(genpd)) | ||
892 | return -EINVAL; | ||
893 | |||
894 | return pm_generic_resume_early(dev); | ||
895 | } | ||
896 | |||
897 | /** | ||
898 | * pm_genpd_resume - Resume of device in an I/O PM domain. | ||
899 | * @dev: Device to resume. | ||
900 | * | ||
901 | * Resume a device under the assumption that its pm_domain field points to the | ||
902 | * domain member of an object of type struct generic_pm_domain representing | ||
903 | * a power domain consisting of I/O devices. | ||
904 | */ | ||
905 | static int pm_genpd_resume(struct device *dev) | ||
906 | { | ||
907 | struct generic_pm_domain *genpd; | ||
908 | |||
909 | dev_dbg(dev, "%s()\n", __func__); | ||
910 | |||
911 | genpd = dev_to_genpd(dev); | ||
912 | if (IS_ERR(genpd)) | ||
913 | return -EINVAL; | ||
914 | |||
915 | return pm_generic_resume(dev); | ||
916 | } | ||
917 | |||
918 | /** | ||
919 | * pm_genpd_freeze - Freezing a device in an I/O PM domain. | ||
920 | * @dev: Device to freeze. | ||
921 | * | ||
922 | * Freeze a device under the assumption that its pm_domain field points to the | ||
923 | * domain member of an object of type struct generic_pm_domain representing | ||
924 | * a power domain consisting of I/O devices. | ||
925 | */ | ||
926 | static int pm_genpd_freeze(struct device *dev) | ||
927 | { | ||
928 | struct generic_pm_domain *genpd; | ||
929 | |||
930 | dev_dbg(dev, "%s()\n", __func__); | ||
931 | |||
932 | genpd = dev_to_genpd(dev); | ||
933 | if (IS_ERR(genpd)) | ||
934 | return -EINVAL; | ||
935 | |||
936 | return pm_generic_freeze(dev); | ||
937 | } | ||
938 | |||
939 | /** | ||
940 | * pm_genpd_freeze_late - Late freeze of a device in an I/O PM domain. | ||
941 | * @dev: Device to freeze. | ||
942 | * | ||
943 | * Carry out a late freeze of a device under the assumption that its | ||
944 | * pm_domain field points to the domain member of an object of type | ||
945 | * struct generic_pm_domain representing a power domain consisting of I/O | ||
946 | * devices. | ||
947 | */ | ||
948 | static int pm_genpd_freeze_late(struct device *dev) | ||
949 | { | ||
950 | struct generic_pm_domain *genpd; | ||
951 | |||
952 | dev_dbg(dev, "%s()\n", __func__); | ||
953 | |||
954 | genpd = dev_to_genpd(dev); | ||
955 | if (IS_ERR(genpd)) | ||
956 | return -EINVAL; | ||
957 | |||
958 | return pm_generic_freeze_late(dev); | ||
959 | } | ||
960 | |||
961 | /** | ||
962 | * pm_genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain. | 834 | * pm_genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain. |
963 | * @dev: Device to freeze. | 835 | * @dev: Device to freeze. |
964 | * | 836 | * |
@@ -1001,49 +873,6 @@ static int pm_genpd_thaw_noirq(struct device *dev) | |||
1001 | } | 873 | } |
1002 | 874 | ||
1003 | /** | 875 | /** |
1004 | * pm_genpd_thaw_early - Early thaw of device in an I/O PM domain. | ||
1005 | * @dev: Device to thaw. | ||
1006 | * | ||
1007 | * Carry out an early thaw of a device under the assumption that its | ||
1008 | * pm_domain field points to the domain member of an object of type | ||
1009 | * struct generic_pm_domain representing a power domain consisting of I/O | ||
1010 | * devices. | ||
1011 | */ | ||
1012 | static int pm_genpd_thaw_early(struct device *dev) | ||
1013 | { | ||
1014 | struct generic_pm_domain *genpd; | ||
1015 | |||
1016 | dev_dbg(dev, "%s()\n", __func__); | ||
1017 | |||
1018 | genpd = dev_to_genpd(dev); | ||
1019 | if (IS_ERR(genpd)) | ||
1020 | return -EINVAL; | ||
1021 | |||
1022 | return pm_generic_thaw_early(dev); | ||
1023 | } | ||
1024 | |||
1025 | /** | ||
1026 | * pm_genpd_thaw - Thaw a device belonging to an I/O power domain. | ||
1027 | * @dev: Device to thaw. | ||
1028 | * | ||
1029 | * Thaw a device under the assumption that its pm_domain field points to the | ||
1030 | * domain member of an object of type struct generic_pm_domain representing | ||
1031 | * a power domain consisting of I/O devices. | ||
1032 | */ | ||
1033 | static int pm_genpd_thaw(struct device *dev) | ||
1034 | { | ||
1035 | struct generic_pm_domain *genpd; | ||
1036 | |||
1037 | dev_dbg(dev, "%s()\n", __func__); | ||
1038 | |||
1039 | genpd = dev_to_genpd(dev); | ||
1040 | if (IS_ERR(genpd)) | ||
1041 | return -EINVAL; | ||
1042 | |||
1043 | return pm_generic_thaw(dev); | ||
1044 | } | ||
1045 | |||
1046 | /** | ||
1047 | * pm_genpd_restore_noirq - Start of restore of device in an I/O PM domain. | 876 | * pm_genpd_restore_noirq - Start of restore of device in an I/O PM domain. |
1048 | * @dev: Device to resume. | 877 | * @dev: Device to resume. |
1049 | * | 878 | * |
@@ -1151,18 +980,10 @@ EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron); | |||
1151 | #else /* !CONFIG_PM_SLEEP */ | 980 | #else /* !CONFIG_PM_SLEEP */ |
1152 | 981 | ||
1153 | #define pm_genpd_prepare NULL | 982 | #define pm_genpd_prepare NULL |
1154 | #define pm_genpd_suspend NULL | ||
1155 | #define pm_genpd_suspend_late NULL | ||
1156 | #define pm_genpd_suspend_noirq NULL | 983 | #define pm_genpd_suspend_noirq NULL |
1157 | #define pm_genpd_resume_early NULL | ||
1158 | #define pm_genpd_resume_noirq NULL | 984 | #define pm_genpd_resume_noirq NULL |
1159 | #define pm_genpd_resume NULL | ||
1160 | #define pm_genpd_freeze NULL | ||
1161 | #define pm_genpd_freeze_late NULL | ||
1162 | #define pm_genpd_freeze_noirq NULL | 985 | #define pm_genpd_freeze_noirq NULL |
1163 | #define pm_genpd_thaw_early NULL | ||
1164 | #define pm_genpd_thaw_noirq NULL | 986 | #define pm_genpd_thaw_noirq NULL |
1165 | #define pm_genpd_thaw NULL | ||
1166 | #define pm_genpd_restore_noirq NULL | 987 | #define pm_genpd_restore_noirq NULL |
1167 | #define pm_genpd_complete NULL | 988 | #define pm_genpd_complete NULL |
1168 | 989 | ||
@@ -1454,24 +1275,24 @@ void pm_genpd_init(struct generic_pm_domain *genpd, | |||
1454 | genpd->domain.ops.runtime_suspend = genpd_runtime_suspend; | 1275 | genpd->domain.ops.runtime_suspend = genpd_runtime_suspend; |
1455 | genpd->domain.ops.runtime_resume = genpd_runtime_resume; | 1276 | genpd->domain.ops.runtime_resume = genpd_runtime_resume; |
1456 | genpd->domain.ops.prepare = pm_genpd_prepare; | 1277 | genpd->domain.ops.prepare = pm_genpd_prepare; |
1457 | genpd->domain.ops.suspend = pm_genpd_suspend; | 1278 | genpd->domain.ops.suspend = pm_generic_suspend; |
1458 | genpd->domain.ops.suspend_late = pm_genpd_suspend_late; | 1279 | genpd->domain.ops.suspend_late = pm_generic_suspend_late; |
1459 | genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq; | 1280 | genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq; |
1460 | genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq; | 1281 | genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq; |
1461 | genpd->domain.ops.resume_early = pm_genpd_resume_early; | 1282 | genpd->domain.ops.resume_early = pm_generic_resume_early; |
1462 | genpd->domain.ops.resume = pm_genpd_resume; | 1283 | genpd->domain.ops.resume = pm_generic_resume; |
1463 | genpd->domain.ops.freeze = pm_genpd_freeze; | 1284 | genpd->domain.ops.freeze = pm_generic_freeze; |
1464 | genpd->domain.ops.freeze_late = pm_genpd_freeze_late; | 1285 | genpd->domain.ops.freeze_late = pm_generic_freeze_late; |
1465 | genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq; | 1286 | genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq; |
1466 | genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq; | 1287 | genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq; |
1467 | genpd->domain.ops.thaw_early = pm_genpd_thaw_early; | 1288 | genpd->domain.ops.thaw_early = pm_generic_thaw_early; |
1468 | genpd->domain.ops.thaw = pm_genpd_thaw; | 1289 | genpd->domain.ops.thaw = pm_generic_thaw; |
1469 | genpd->domain.ops.poweroff = pm_genpd_suspend; | 1290 | genpd->domain.ops.poweroff = pm_generic_poweroff; |
1470 | genpd->domain.ops.poweroff_late = pm_genpd_suspend_late; | 1291 | genpd->domain.ops.poweroff_late = pm_generic_poweroff_late; |
1471 | genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq; | 1292 | genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq; |
1472 | genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq; | 1293 | genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq; |
1473 | genpd->domain.ops.restore_early = pm_genpd_resume_early; | 1294 | genpd->domain.ops.restore_early = pm_generic_restore_early; |
1474 | genpd->domain.ops.restore = pm_genpd_resume; | 1295 | genpd->domain.ops.restore = pm_generic_restore; |
1475 | genpd->domain.ops.complete = pm_genpd_complete; | 1296 | genpd->domain.ops.complete = pm_genpd_complete; |
1476 | 1297 | ||
1477 | if (genpd->flags & GENPD_FLAG_PM_CLK) { | 1298 | if (genpd->flags & GENPD_FLAG_PM_CLK) { |