From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tony Lindgren Subject: [PATCH 2/2] phy: mapphone-mdm6600: Improve phy related runtime PM calls Date: Sat, 17 Nov 2018 05:37:55 -0800 Message-ID: <20181117133755.9129-3-tony@atomide.com> References: <20181117133755.9129-1-tony@atomide.com> Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <20181117133755.9129-1-tony@atomide.com> Sender: linux-kernel-owner@vger.kernel.org To: Kishon Vijay Abraham I Cc: linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, linux-omap@vger.kernel.org, Pavel Machek , Sebastian Reichel List-Id: linux-omap@vger.kernel.org I noticed that phy_pm_runtime_get_sync() and phy_pm_runtime_put() are not currently doing anything for phy-mapphone-mdm6600, only the sysfs interface for works for "auto" and "on". This is because of the shared GPIO pins between mdm6600 USB port and n_gsm port. We have not enabled runtime PM for the phy driver until after we've booted up mdm6600 properly to the USB mode. Otherwise phy_create() would have called pm_runtime_enable() and pm_runtime_no_callbacks() automatically on init. Let's fix this by registering the phy a bit later after we've powered up the mdm6600 USB port. And as the PM runtime support is only needed for the n_gsm mode and not for USB, we can allow the device to idle between phy_mdm6600_power_on() and phy_mdm6600_power_off(). Note that for suspend, runtime_pm is already disabled for the phy so we need to check for phy_pm_runtime_enabled(). Cc: Pavel Machek Cc: Sebastian Reichel Signed-off-by: Tony Lindgren --- drivers/phy/motorola/phy-mapphone-mdm6600.c | 71 +++++++++++++++------ 1 file changed, 51 insertions(+), 20 deletions(-) diff --git a/drivers/phy/motorola/phy-mapphone-mdm6600.c b/drivers/phy/motorola/phy-mapphone-mdm6600.c --- a/drivers/phy/motorola/phy-mapphone-mdm6600.c +++ b/drivers/phy/motorola/phy-mapphone-mdm6600.c @@ -16,6 +16,7 @@ #include #include #include +#include #define PHY_MDM6600_PHY_DELAY_MS 4000 /* PHY enable 2.2s to 3.5s */ #define PHY_MDM6600_ENABLED_DELAY_MS 8000 /* 8s more total for MDM6600 */ @@ -124,12 +125,22 @@ static int phy_mdm6600_power_on(struct phy *x) { struct phy_mdm6600 *ddata = phy_get_drvdata(x); struct gpio_desc *enable_gpio = ddata->ctrl_gpios[PHY_MDM6600_ENABLE]; + int error; if (!ddata->enabled) return -ENODEV; + error = pinctrl_pm_select_default_state(ddata->dev); + if (error) + dev_warn(ddata->dev, "%s: error with default_state: %i\n", + __func__, error); + gpiod_set_value_cansleep(enable_gpio, 1); + /* Allow aggressive PM for USB, it's only needed for n_gsm port */ + if (phy_pm_runtime_enabled(ddata->generic_phy)) + phy_pm_runtime_put(ddata->generic_phy); + return 0; } @@ -137,12 +148,26 @@ static int phy_mdm6600_power_off(struct phy *x) { struct phy_mdm6600 *ddata = phy_get_drvdata(x); struct gpio_desc *enable_gpio = ddata->ctrl_gpios[PHY_MDM6600_ENABLE]; + int error; if (!ddata->enabled) return -ENODEV; + /* Paired with phy_pm_runtime_put() in phy_mdm6600_power_on() */ + if (phy_pm_runtime_enabled(ddata->generic_phy)) { + error = phy_pm_runtime_get(ddata->generic_phy); + if (error < 0 && error != -EINPROGRESS) + dev_warn(ddata->dev, "%s: phy_pm_runtime_get: %i\n", + __func__, error); + } + gpiod_set_value_cansleep(enable_gpio, 0); + error = pinctrl_pm_select_sleep_state(ddata->dev); + if (error) + dev_warn(ddata->dev, "%s: error with sleep_state: %i\n", + __func__, error); + return 0; } @@ -555,28 +580,17 @@ static int phy_mdm6600_probe(struct platform_device *pdev) ddata->dev = &pdev->dev; platform_set_drvdata(pdev, ddata); + /* Active state selected in phy_mdm6600_power_on() */ + error = pinctrl_pm_select_sleep_state(ddata->dev); + if (error) + dev_warn(ddata->dev, "%s: error with sleep_state: %i\n", + __func__, error); + error = phy_mdm6600_init_lines(ddata); if (error) return error; phy_mdm6600_init_irq(ddata); - - ddata->generic_phy = devm_phy_create(ddata->dev, NULL, &gpio_usb_ops); - if (IS_ERR(ddata->generic_phy)) { - error = PTR_ERR(ddata->generic_phy); - goto cleanup; - } - - phy_set_drvdata(ddata->generic_phy, ddata); - - ddata->phy_provider = - devm_of_phy_provider_register(ddata->dev, - of_phy_simple_xlate); - if (IS_ERR(ddata->phy_provider)) { - error = PTR_ERR(ddata->phy_provider); - goto cleanup; - } - schedule_delayed_work(&ddata->bootup_work, 0); /* @@ -600,14 +614,31 @@ static int phy_mdm6600_probe(struct platform_device *pdev) if (error < 0) { dev_warn(ddata->dev, "failed to wake modem: %i\n", error); pm_runtime_put_noidle(ddata->dev); + goto cleanup; } + + ddata->generic_phy = devm_phy_create(ddata->dev, NULL, &gpio_usb_ops); + if (IS_ERR(ddata->generic_phy)) { + error = PTR_ERR(ddata->generic_phy); + goto idle; + } + + phy_set_drvdata(ddata->generic_phy, ddata); + + ddata->phy_provider = + devm_of_phy_provider_register(ddata->dev, + of_phy_simple_xlate); + if (IS_ERR(ddata->phy_provider)) + error = PTR_ERR(ddata->phy_provider); + +idle: pm_runtime_mark_last_busy(ddata->dev); pm_runtime_put_autosuspend(ddata->dev); - return 0; - cleanup: - phy_mdm6600_device_power_off(ddata); + if (error < 0) + phy_mdm6600_device_power_off(ddata); + return error; } -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [2/2] phy: mapphone-mdm6600: Improve phy related runtime PM calls From: Tony Lindgren Message-Id: <20181117133755.9129-3-tony@atomide.com> Date: Sat, 17 Nov 2018 05:37:55 -0800 To: Kishon Vijay Abraham I Cc: linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, linux-omap@vger.kernel.org, Pavel Machek , Sebastian Reichel List-ID: SSBub3RpY2VkIHRoYXQgcGh5X3BtX3J1bnRpbWVfZ2V0X3N5bmMoKSBhbmQgcGh5X3BtX3J1bnRp bWVfcHV0KCkgYXJlIG5vdApjdXJyZW50bHkgZG9pbmcgYW55dGhpbmcgZm9yIHBoeS1tYXBwaG9u ZS1tZG02NjAwLCBvbmx5IHRoZSBzeXNmcyBpbnRlcmZhY2UKZm9yIHdvcmtzIGZvciAiYXV0byIg YW5kICJvbiIuCgpUaGlzIGlzIGJlY2F1c2Ugb2YgdGhlIHNoYXJlZCBHUElPIHBpbnMgYmV0d2Vl biBtZG02NjAwIFVTQiBwb3J0IGFuZCBuX2dzbQpwb3J0LiBXZSBoYXZlIG5vdCBlbmFibGVkIHJ1 bnRpbWUgUE0gZm9yIHRoZSBwaHkgZHJpdmVyIHVudGlsIGFmdGVyIHdlJ3ZlCmJvb3RlZCB1cCBt ZG02NjAwIHByb3Blcmx5IHRvIHRoZSBVU0IgbW9kZS4gT3RoZXJ3aXNlIHBoeV9jcmVhdGUoKSB3 b3VsZApoYXZlIGNhbGxlZCBwbV9ydW50aW1lX2VuYWJsZSgpIGFuZCBwbV9ydW50aW1lX25vX2Nh bGxiYWNrcygpIGF1dG9tYXRpY2FsbHkKb24gaW5pdC4KCkxldCdzIGZpeCB0aGlzIGJ5IHJlZ2lz dGVyaW5nIHRoZSBwaHkgYSBiaXQgbGF0ZXIgYWZ0ZXIgd2UndmUgcG93ZXJlZCB1cCB0aGUKbWRt NjYwMCBVU0IgcG9ydC4KCkFuZCBhcyB0aGUgUE0gcnVudGltZSBzdXBwb3J0IGlzIG9ubHkgbmVl ZGVkIGZvciB0aGUgbl9nc20gbW9kZSBhbmQgbm90IGZvcgpVU0IsIHdlIGNhbiBhbGxvdyB0aGUg ZGV2aWNlIHRvIGlkbGUgYmV0d2VlbiBwaHlfbWRtNjYwMF9wb3dlcl9vbigpIGFuZApwaHlfbWRt NjYwMF9wb3dlcl9vZmYoKS4gTm90ZSB0aGF0IGZvciBzdXNwZW5kLCBydW50aW1lX3BtIGlzIGFs cmVhZHkKZGlzYWJsZWQgZm9yIHRoZSBwaHkgc28gd2UgbmVlZCB0byBjaGVjayBmb3IgcGh5X3Bt X3J1bnRpbWVfZW5hYmxlZCgpLgoKQ2M6IFBhdmVsIE1hY2hlayA8cGF2ZWxAdWN3LmN6PgpDYzog U2ViYXN0aWFuIFJlaWNoZWwgPHNyZUBrZXJuZWwub3JnPgpTaWduZWQtb2ZmLWJ5OiBUb255IExp bmRncmVuIDx0b255QGF0b21pZGUuY29tPgotLS0KIGRyaXZlcnMvcGh5L21vdG9yb2xhL3BoeS1t YXBwaG9uZS1tZG02NjAwLmMgfCA3MSArKysrKysrKysrKysrKystLS0tLS0KIDEgZmlsZSBjaGFu Z2VkLCA1MSBpbnNlcnRpb25zKCspLCAyMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2 ZXJzL3BoeS9tb3Rvcm9sYS9waHktbWFwcGhvbmUtbWRtNjYwMC5jIGIvZHJpdmVycy9waHkvbW90 b3JvbGEvcGh5LW1hcHBob25lLW1kbTY2MDAuYwotLS0gYS9kcml2ZXJzL3BoeS9tb3Rvcm9sYS9w aHktbWFwcGhvbmUtbWRtNjYwMC5jCisrKyBiL2RyaXZlcnMvcGh5L21vdG9yb2xhL3BoeS1tYXBw aG9uZS1tZG02NjAwLmMKQEAgLTE2LDYgKzE2LDcgQEAKICNpbmNsdWRlIDxsaW51eC9ncGlvL2Nv bnN1bWVyLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfcGxhdGZvcm0uaD4KICNpbmNsdWRlIDxsaW51 eC9waHkvcGh5Lmg+CisjaW5jbHVkZSA8bGludXgvcGluY3RybC9jb25zdW1lci5oPgogCiAjZGVm aW5lIFBIWV9NRE02NjAwX1BIWV9ERUxBWV9NUwk0MDAwCS8qIFBIWSBlbmFibGUgMi4ycyB0byAz LjVzICovCiAjZGVmaW5lIFBIWV9NRE02NjAwX0VOQUJMRURfREVMQVlfTVMJODAwMAkvKiA4cyBt b3JlIHRvdGFsIGZvciBNRE02NjAwICovCkBAIC0xMjQsMTIgKzEyNSwyMiBAQCBzdGF0aWMgaW50 IHBoeV9tZG02NjAwX3Bvd2VyX29uKHN0cnVjdCBwaHkgKngpCiB7CiAJc3RydWN0IHBoeV9tZG02 NjAwICpkZGF0YSA9IHBoeV9nZXRfZHJ2ZGF0YSh4KTsKIAlzdHJ1Y3QgZ3Bpb19kZXNjICplbmFi bGVfZ3BpbyA9IGRkYXRhLT5jdHJsX2dwaW9zW1BIWV9NRE02NjAwX0VOQUJMRV07CisJaW50IGVy cm9yOwogCiAJaWYgKCFkZGF0YS0+ZW5hYmxlZCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKKwllcnJv ciA9IHBpbmN0cmxfcG1fc2VsZWN0X2RlZmF1bHRfc3RhdGUoZGRhdGEtPmRldik7CisJaWYgKGVy cm9yKQorCQlkZXZfd2FybihkZGF0YS0+ZGV2LCAiJXM6IGVycm9yIHdpdGggZGVmYXVsdF9zdGF0 ZTogJWlcbiIsCisJCQkgX19mdW5jX18sIGVycm9yKTsKKwogCWdwaW9kX3NldF92YWx1ZV9jYW5z bGVlcChlbmFibGVfZ3BpbywgMSk7CiAKKwkvKiBBbGxvdyBhZ2dyZXNzaXZlIFBNIGZvciBVU0Is IGl0J3Mgb25seSBuZWVkZWQgZm9yIG5fZ3NtIHBvcnQgKi8KKwlpZiAocGh5X3BtX3J1bnRpbWVf ZW5hYmxlZChkZGF0YS0+Z2VuZXJpY19waHkpKQorCQlwaHlfcG1fcnVudGltZV9wdXQoZGRhdGEt PmdlbmVyaWNfcGh5KTsKKwogCXJldHVybiAwOwogfQogCkBAIC0xMzcsMTIgKzE0OCwyNiBAQCBz dGF0aWMgaW50IHBoeV9tZG02NjAwX3Bvd2VyX29mZihzdHJ1Y3QgcGh5ICp4KQogewogCXN0cnVj dCBwaHlfbWRtNjYwMCAqZGRhdGEgPSBwaHlfZ2V0X2RydmRhdGEoeCk7CiAJc3RydWN0IGdwaW9f ZGVzYyAqZW5hYmxlX2dwaW8gPSBkZGF0YS0+Y3RybF9ncGlvc1tQSFlfTURNNjYwMF9FTkFCTEVd OworCWludCBlcnJvcjsKIAogCWlmICghZGRhdGEtPmVuYWJsZWQpCiAJCXJldHVybiAtRU5PREVW OwogCisJLyogUGFpcmVkIHdpdGggcGh5X3BtX3J1bnRpbWVfcHV0KCkgaW4gcGh5X21kbTY2MDBf cG93ZXJfb24oKSAqLworCWlmIChwaHlfcG1fcnVudGltZV9lbmFibGVkKGRkYXRhLT5nZW5lcmlj X3BoeSkpIHsKKwkJZXJyb3IgPSBwaHlfcG1fcnVudGltZV9nZXQoZGRhdGEtPmdlbmVyaWNfcGh5 KTsKKwkJaWYgKGVycm9yIDwgMCAmJiBlcnJvciAhPSAtRUlOUFJPR1JFU1MpCisJCQlkZXZfd2Fy bihkZGF0YS0+ZGV2LCAiJXM6IHBoeV9wbV9ydW50aW1lX2dldDogJWlcbiIsCisJCQkJIF9fZnVu Y19fLCBlcnJvcik7CisJfQorCiAJZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKGVuYWJsZV9ncGlv LCAwKTsKIAorCWVycm9yID0gcGluY3RybF9wbV9zZWxlY3Rfc2xlZXBfc3RhdGUoZGRhdGEtPmRl dik7CisJaWYgKGVycm9yKQorCQlkZXZfd2FybihkZGF0YS0+ZGV2LCAiJXM6IGVycm9yIHdpdGgg c2xlZXBfc3RhdGU6ICVpXG4iLAorCQkJIF9fZnVuY19fLCBlcnJvcik7CisKIAlyZXR1cm4gMDsK IH0KIApAQCAtNTU1LDI4ICs1ODAsMTcgQEAgc3RhdGljIGludCBwaHlfbWRtNjYwMF9wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWRkYXRhLT5kZXYgPSAmcGRldi0+ZGV2Owog CXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGRkYXRhKTsKIAorCS8qIEFjdGl2ZSBzdGF0ZSBz ZWxlY3RlZCBpbiBwaHlfbWRtNjYwMF9wb3dlcl9vbigpICovCisJZXJyb3IgPSBwaW5jdHJsX3Bt X3NlbGVjdF9zbGVlcF9zdGF0ZShkZGF0YS0+ZGV2KTsKKwlpZiAoZXJyb3IpCisJCWRldl93YXJu KGRkYXRhLT5kZXYsICIlczogZXJyb3Igd2l0aCBzbGVlcF9zdGF0ZTogJWlcbiIsCisJCQkgX19m dW5jX18sIGVycm9yKTsKKwogCWVycm9yID0gcGh5X21kbTY2MDBfaW5pdF9saW5lcyhkZGF0YSk7 CiAJaWYgKGVycm9yKQogCQlyZXR1cm4gZXJyb3I7CiAKIAlwaHlfbWRtNjYwMF9pbml0X2lycShk ZGF0YSk7Ci0KLQlkZGF0YS0+Z2VuZXJpY19waHkgPSBkZXZtX3BoeV9jcmVhdGUoZGRhdGEtPmRl diwgTlVMTCwgJmdwaW9fdXNiX29wcyk7Ci0JaWYgKElTX0VSUihkZGF0YS0+Z2VuZXJpY19waHkp KSB7Ci0JCWVycm9yID0gUFRSX0VSUihkZGF0YS0+Z2VuZXJpY19waHkpOwotCQlnb3RvIGNsZWFu dXA7Ci0JfQotCi0JcGh5X3NldF9kcnZkYXRhKGRkYXRhLT5nZW5lcmljX3BoeSwgZGRhdGEpOwot Ci0JZGRhdGEtPnBoeV9wcm92aWRlciA9Ci0JCWRldm1fb2ZfcGh5X3Byb3ZpZGVyX3JlZ2lzdGVy KGRkYXRhLT5kZXYsCi0JCQkJCSAgICAgIG9mX3BoeV9zaW1wbGVfeGxhdGUpOwotCWlmIChJU19F UlIoZGRhdGEtPnBoeV9wcm92aWRlcikpIHsKLQkJZXJyb3IgPSBQVFJfRVJSKGRkYXRhLT5waHlf cHJvdmlkZXIpOwotCQlnb3RvIGNsZWFudXA7Ci0JfQotCiAJc2NoZWR1bGVfZGVsYXllZF93b3Jr KCZkZGF0YS0+Ym9vdHVwX3dvcmssIDApOwogCiAJLyoKQEAgLTYwMCwxNCArNjE0LDMxIEBAIHN0 YXRpYyBpbnQgcGh5X21kbTY2MDBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK IAlpZiAoZXJyb3IgPCAwKSB7CiAJCWRldl93YXJuKGRkYXRhLT5kZXYsICJmYWlsZWQgdG8gd2Fr ZSBtb2RlbTogJWlcbiIsIGVycm9yKTsKIAkJcG1fcnVudGltZV9wdXRfbm9pZGxlKGRkYXRhLT5k ZXYpOworCQlnb3RvIGNsZWFudXA7CiAJfQorCisJZGRhdGEtPmdlbmVyaWNfcGh5ID0gZGV2bV9w aHlfY3JlYXRlKGRkYXRhLT5kZXYsIE5VTEwsICZncGlvX3VzYl9vcHMpOworCWlmIChJU19FUlIo ZGRhdGEtPmdlbmVyaWNfcGh5KSkgeworCQllcnJvciA9IFBUUl9FUlIoZGRhdGEtPmdlbmVyaWNf cGh5KTsKKwkJZ290byBpZGxlOworCX0KKworCXBoeV9zZXRfZHJ2ZGF0YShkZGF0YS0+Z2VuZXJp Y19waHksIGRkYXRhKTsKKworCWRkYXRhLT5waHlfcHJvdmlkZXIgPQorCQlkZXZtX29mX3BoeV9w cm92aWRlcl9yZWdpc3RlcihkZGF0YS0+ZGV2LAorCQkJCQkgICAgICBvZl9waHlfc2ltcGxlX3hs YXRlKTsKKwlpZiAoSVNfRVJSKGRkYXRhLT5waHlfcHJvdmlkZXIpKQorCQllcnJvciA9IFBUUl9F UlIoZGRhdGEtPnBoeV9wcm92aWRlcik7CisKK2lkbGU6CiAJcG1fcnVudGltZV9tYXJrX2xhc3Rf YnVzeShkZGF0YS0+ZGV2KTsKIAlwbV9ydW50aW1lX3B1dF9hdXRvc3VzcGVuZChkZGF0YS0+ZGV2 KTsKIAotCXJldHVybiAwOwotCiBjbGVhbnVwOgotCXBoeV9tZG02NjAwX2RldmljZV9wb3dlcl9v ZmYoZGRhdGEpOworCWlmIChlcnJvciA8IDApCisJCXBoeV9tZG02NjAwX2RldmljZV9wb3dlcl9v ZmYoZGRhdGEpOworCiAJcmV0dXJuIGVycm9yOwogfQogCg==