From 3843b9ef44df628f63d0189e427d6e73f6595b28 Mon Sep 17 00:00:00 2001 From: David Collins Date: Tue, 30 Jun 2015 11:31:08 -0700 Subject: [PATCH] Revert "regulator: rpm-smd-regulator: don't wait for ACK when lowering power state" This reverts commit d9556f3bce05fe346df5e31784ca288691e6cafd ("regulator: rpm-smd-regulator: don't wait for ACK when lowering power state") which conditionally avoids calling msm_rpm_wait_for_ack() after msm_rpm_send_request(). The lack of msm_rpm_wait_for_ack() calls can result in the device not being able to enter suspend due to dependencies within the rpm-smd driver. Change-Id: Ibd3f5c1877090e9101d42f07c473348a0e5c1a38 Signed-off-by: David Collins --- .../bindings/regulator/rpm-smd-regulator.txt | 4 - drivers/regulator/rpm-smd-regulator.c | 122 ++---------------- 2 files changed, 14 insertions(+), 112 deletions(-) diff --git a/Documentation/devicetree/bindings/regulator/rpm-smd-regulator.txt b/Documentation/devicetree/bindings/regulator/rpm-smd-regulator.txt index 8390235bb976..9b66a04de77d 100644 --- a/Documentation/devicetree/bindings/regulator/rpm-smd-regulator.txt +++ b/Documentation/devicetree/bindings/regulator/rpm-smd-regulator.txt @@ -36,10 +36,6 @@ Optional properties: consumers on the application processor. If this flag is specified, then voltage and current updates are only sent to the RPM if the regulator is enabled. -- qcom,always-wait-for-ack: Flag which indicates that the application - processor must wait for an ACK or a NACK from the RPM - for every request sent for this regulator including - those which are for a strictly lower power state. [Second Level Nodes] diff --git a/drivers/regulator/rpm-smd-regulator.c b/drivers/regulator/rpm-smd-regulator.c index d1dd223d91d9..fd7ab7f9f449 100644 --- a/drivers/regulator/rpm-smd-regulator.c +++ b/drivers/regulator/rpm-smd-regulator.c @@ -171,9 +171,6 @@ struct rpm_vreg { struct mutex mlock; unsigned long flags; bool sleep_request_sent; - bool wait_for_ack_active; - bool wait_for_ack_sleep; - bool always_wait_for_ack; bool apps_only; struct msm_rpm_request *handle_active; struct msm_rpm_request *handle_sleep; @@ -265,58 +262,6 @@ static inline bool rpm_vreg_shared_active_or_sleep_enabled_valid & BIT(RPM_REGULATOR_PARAM_ENABLE))); } -static const u32 power_level_params = - BIT(RPM_REGULATOR_PARAM_ENABLE) | - BIT(RPM_REGULATOR_PARAM_VOLTAGE) | - BIT(RPM_REGULATOR_PARAM_CURRENT) | - BIT(RPM_REGULATOR_PARAM_CORNER) | - BIT(RPM_REGULATOR_PARAM_BYPASS) | - BIT(RPM_REGULATOR_PARAM_FLOOR_CORNER) | - BIT(RPM_REGULATOR_PARAM_LEVEL) | - BIT(RPM_REGULATOR_PARAM_FLOOR_LEVEL); - -static bool rpm_vreg_ack_required(struct rpm_vreg *rpm_vreg, u32 set, - const u32 *prev_param, const u32 *param, - u32 prev_valid, u32 modified) -{ - u32 mask; - int i; - - if (rpm_vreg->always_wait_for_ack - || (set == RPM_SET_ACTIVE && rpm_vreg->wait_for_ack_active) - || (set == RPM_SET_SLEEP && rpm_vreg->wait_for_ack_sleep)) - return true; - - for (i = 0; i < RPM_REGULATOR_PARAM_MAX; i++) { - mask = BIT(i); - if (modified & mask) { - if ((prev_valid & mask) && (power_level_params & mask) - && (param[i] <= prev_param[i])) - continue; - else - return true; - } - } - - return false; -} - -static void rpm_vreg_check_param_max(struct rpm_regulator *regulator, int index, - u32 new_max) -{ - struct rpm_vreg *rpm_vreg = regulator->rpm_vreg; - - if (regulator->set_active - && (rpm_vreg->aggr_req_active.valid & BIT(index)) - && rpm_vreg->aggr_req_active.param[index] > new_max) - rpm_vreg->wait_for_ack_active = true; - - if (regulator->set_sleep - && (rpm_vreg->aggr_req_sleep.valid & BIT(index)) - && rpm_vreg->aggr_req_sleep.param[index] > new_max) - rpm_vreg->wait_for_ack_sleep = true; -} - /* * This is used when voting for LPM or HPM by subtracting or adding to the * hpm_min_load of a regulator. It has units of uA. @@ -472,37 +417,27 @@ static int rpm_vreg_add_modified_requests(struct rpm_regulator *regulator, return rc; } -static int rpm_vreg_send_request(struct rpm_regulator *regulator, u32 set, - bool wait_for_ack) +static int rpm_vreg_send_request(struct rpm_regulator *regulator, u32 set) { struct rpm_vreg *rpm_vreg = regulator->rpm_vreg; struct msm_rpm_request *handle = (set == RPM_SET_ACTIVE ? rpm_vreg->handle_active : rpm_vreg->handle_sleep); - u32 msg_id; int rc; - rc = unlikely(rpm_vreg->allow_atomic) ? - msm_rpm_send_request_noirq(handle) : msm_rpm_send_request(handle); - if (rc < 0) - goto fail; + if (rpm_vreg->allow_atomic) + rc = msm_rpm_wait_for_ack_noirq(msm_rpm_send_request_noirq( + handle)); + else + rc = msm_rpm_wait_for_ack(msm_rpm_send_request(handle)); - msg_id = rc; + if (rc) + vreg_err(regulator, + "msm rpm send failed: %s %u; set=%s, rc=%d\n", + rpm_vreg->resource_name, + rpm_vreg->resource_id, + (set == RPM_SET_ACTIVE ? "act" : "slp"), rc); - if (wait_for_ack) { - rc = unlikely(rpm_vreg->allow_atomic) ? - msm_rpm_wait_for_ack_noirq(msg_id) : - msm_rpm_wait_for_ack(msg_id); - if (rc < 0) - goto fail; - } - - return 0; - -fail: - vreg_err(regulator, "msm rpm send failed: %s %u; set=%s, rc=%d\n", - rpm_vreg->resource_name, rpm_vreg->resource_id, - (set == RPM_SET_ACTIVE ? "act" : "slp"), rc); return rc; } @@ -566,7 +501,6 @@ static int rpm_vreg_aggregate_requests(struct rpm_regulator *regulator) bool sleep_set_differs = false; bool send_active = false; bool send_sleep = false; - bool wait_for_ack; int rc = 0; int i; @@ -638,17 +572,10 @@ static int rpm_vreg_aggregate_requests(struct rpm_regulator *regulator) /* Send active set request to the RPM if it contains new KVPs. */ if (send_active) { - wait_for_ack = rpm_vreg_ack_required(rpm_vreg, RPM_SET_ACTIVE, - rpm_vreg->aggr_req_active.param, - param_active, - rpm_vreg->aggr_req_active.valid, - modified_active); - rc = rpm_vreg_send_request(regulator, RPM_SET_ACTIVE, - wait_for_ack); + rc = rpm_vreg_send_request(regulator, RPM_SET_ACTIVE); if (rc) return rc; rpm_vreg->aggr_req_active.valid |= modified_active; - rpm_vreg->wait_for_ack_active = false; } /* Store the results of the aggregation. */ rpm_vreg->aggr_req_active.modified = modified_active; @@ -662,19 +589,12 @@ static int rpm_vreg_aggregate_requests(struct rpm_regulator *regulator) /* Send sleep set request to the RPM if it contains new KVPs. */ if (send_sleep) { - wait_for_ack = rpm_vreg_ack_required(rpm_vreg, RPM_SET_SLEEP, - rpm_vreg->aggr_req_sleep.param, - param_sleep, - rpm_vreg->aggr_req_sleep.valid, - modified_sleep); - rc = rpm_vreg_send_request(regulator, RPM_SET_SLEEP, - wait_for_ack); + rc = rpm_vreg_send_request(regulator, RPM_SET_SLEEP); if (rc) return rc; else rpm_vreg->sleep_request_sent = true; rpm_vreg->aggr_req_sleep.valid |= modified_sleep; - rpm_vreg->wait_for_ack_sleep = false; } /* Store the results of the aggregation. */ rpm_vreg->aggr_req_sleep.modified = modified_sleep; @@ -791,8 +711,6 @@ static int rpm_vreg_set_voltage(struct regulator_dev *rdev, int min_uV, prev_voltage = reg->req.param[RPM_REGULATOR_PARAM_VOLTAGE]; RPM_VREG_SET_PARAM(reg, VOLTAGE, min_uV); - rpm_vreg_check_param_max(reg, RPM_REGULATOR_PARAM_VOLTAGE, max_uV); - /* * Only send a new voltage if the regulator is currently enabled or * if the regulator has been configured to always send voltage updates. @@ -852,9 +770,6 @@ static int rpm_vreg_set_voltage_corner(struct regulator_dev *rdev, int min_uV, prev_corner = reg->req.param[RPM_REGULATOR_PARAM_CORNER]; RPM_VREG_SET_PARAM(reg, CORNER, corner); - rpm_vreg_check_param_max(reg, RPM_REGULATOR_PARAM_CORNER, - max_uV - RPM_REGULATOR_CORNER_NONE); - /* * Only send a new voltage corner if the regulator is currently enabled * or if the regulator has been configured to always send voltage @@ -911,9 +826,6 @@ static int rpm_vreg_set_voltage_floor_corner(struct regulator_dev *rdev, prev_corner = reg->req.param[RPM_REGULATOR_PARAM_FLOOR_CORNER]; RPM_VREG_SET_PARAM(reg, FLOOR_CORNER, corner); - rpm_vreg_check_param_max(reg, RPM_REGULATOR_PARAM_FLOOR_CORNER, - max_uV - RPM_REGULATOR_CORNER_NONE); - /* * Only send a new voltage floor corner if the regulator is currently * enabled or if the regulator has been configured to always send @@ -964,8 +876,6 @@ static int rpm_vreg_set_voltage_level(struct regulator_dev *rdev, int min_uV, prev_level = reg->req.param[RPM_REGULATOR_PARAM_LEVEL]; RPM_VREG_SET_PARAM(reg, LEVEL, level); - rpm_vreg_check_param_max(reg, RPM_REGULATOR_PARAM_LEVEL, max_uV); - /* * Only send a new voltage level if the regulator is currently enabled * or if the regulator has been configured to always send voltage @@ -1015,8 +925,6 @@ static int rpm_vreg_set_voltage_floor_level(struct regulator_dev *rdev, prev_level = reg->req.param[RPM_REGULATOR_PARAM_FLOOR_LEVEL]; RPM_VREG_SET_PARAM(reg, FLOOR_LEVEL, level); - rpm_vreg_check_param_max(reg, RPM_REGULATOR_PARAM_FLOOR_LEVEL, max_uV); - /* * Only send a new voltage floor level if the regulator is currently * enabled or if the regulator has been configured to always send @@ -1987,8 +1895,6 @@ static int rpm_vreg_resource_probe(struct platform_device *pdev) of_property_read_u32(node, "qcom,hpm-min-load", &rpm_vreg->hpm_min_load); rpm_vreg->apps_only = of_property_read_bool(node, "qcom,apps-only"); - rpm_vreg->always_wait_for_ack - = of_property_read_bool(node, "qcom,always-wait-for-ack"); rpm_vreg->handle_active = msm_rpm_create_request(RPM_SET_ACTIVE, resource_type, rpm_vreg->resource_id, RPM_REGULATOR_PARAM_MAX);