From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tony Lindgren Subject: Re: power management problems in ehci-omap Date: Tue, 6 Feb 2018 09:17:37 -0800 Message-ID: <20180206171737.GB21573@atomide.com> References: <20180204000335.29812776@kemnade.info> <20180204093831.44322452@kemnade.info> <20180206074201.479405e7@aktux> <20180206160452.GA21573@atomide.com> <20180206175509.4d80e930@aktux> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 8BIT Return-path: Content-Disposition: inline In-Reply-To: <20180206175509.4d80e930@aktux> Sender: linux-usb-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: Andreas Kemnade Cc: Michael Nazzareno Trimarchi , USB list , Linux OMAP Mailing List , Discussions about the Letux Kernel , Roger Quadros List-Id: linux-omap@vger.kernel.org * Andreas Kemnade [180206 16:56]: > On Tue, 6 Feb 2018 08:04:52 -0800 > Tony Lindgren wrote: > > > * Andreas Kemnade [180206 06:42]: > > > rechecked with a board with really nothing connected there > > > Same behaviour > > > > I've just verified that my test board power consumption goes > > back to normal after rmmod ehci-omap with v4.15. > > > yes, for me too, I initially used a test script which does an > echo rmmod ehci-omap > > without a real > rmmod ehci-omap Ah OK :) > It just seems to be consistent with my observations in a fully booted > system (where many things can play a role). Sorry for that confusion. Try with a minimal set of modules first, then modprobe and rmmod one at a time until you find the module breaking PM? You probably know this already, but just in case it helps.. First idle the UARTs and enable off mode with something like: uarts=$(find /sys/class/tty/tty[SO]*/device/power/ -type d) for uart in $uarts; do echo 3000 > $uart/autosuspend_delay_ms 2>&1 done uarts=$(find /sys/class/tty/tty[SO]*/power/ -type d 2>/dev/null) for uart in $uarts; do echo enabled > $uart/wakeup 2>&1 echo auto > $uart/control 2>&1 done echo -n 1 > /sys/kernel/debug/pm_debug/enable_off_mode Then if using omap3, the attached debug hack patch can be used to see which devices are not idling: > But suspend current is a problem. I have repeated the measurement with > another board, so it is not a board problem. I also verified v4.15 behaves for suspend current even with echi-omap loaded just in case. Regards, Tony 8< ------------------- >>From tony Mon Sep 17 00:00:00 2001 From: Tony Lindgren Date: Wed, 13 Dec 2017 16:36:45 -0800 Subject: [PATCH] NOT FOR MERGING: Test patch for dumping omap3 off idle blocking bits Allows seeing the deeper idle state blockers in /sys/kernel/debug/pm_debug/count. For example, when off idle is working on beaglboard xm, this is what i see: # sleep 5; cat /sys/kernel/debug/pm_debug/count ... 0006ffff 48005020 (fa005020) cm_idlest_per blocking bits: 00010000 e7ffffbd 48004a20 (fa004a20) cm_idlest1_core blocking bits: 00000042 0000000d 48004a28 (fa004a28) cm_idlest3_core --- arch/arm/mach-omap2/pm-debug.c | 68 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/arch/arm/mach-omap2/pm-debug.c b/arch/arm/mach-omap2/pm-debug.c --- a/arch/arm/mach-omap2/pm-debug.c +++ b/arch/arm/mach-omap2/pm-debug.c @@ -142,10 +142,78 @@ static int pwrdm_dbg_show_timer(struct powerdomain *pwrdm, void *user) return 0; } +#include "iomap.h" + +struct dregs { + const char *desc; + u32 phys; + void __iomem *virt; + u32 mask; +}; + +#define PER_CM_BASE 0x48005000 +#define PER_CM_REG(name, offset, mask) \ + { name, PER_CM_BASE + offset, \ + OMAP2_L4_IO_ADDRESS(PER_CM_BASE + offset), mask, } + +static struct dregs cm_per[] = { + PER_CM_REG("cm_idlest_per", 0x20, 0xfff80000), /* p 513 */ + { NULL, }, +}; + +#define CORE_CM_BASE 0x48004a00 +#define CORE_CM_REG(name, offset, mask) \ + { name, CORE_CM_BASE + offset, \ + OMAP2_L4_IO_ADDRESS(CORE_CM_BASE + offset), mask, } + +static struct dregs cm_core[] = { + CORE_CM_REG("cm_idlest1_core", 0x20, 0x9c800109), /* p 467 */ + CORE_CM_REG("cm_idlest3_core", 0x28, 0xfffffffb), + { NULL, }, +}; + +void __dregs_dump(struct dregs *dregs, struct seq_file *s) +{ + for (; dregs->desc; dregs++) { + u32 val, blockers; + + val = __raw_readl(dregs->virt); + + seq_printf(s, "%08x %08x (%p) %s", + val, dregs->phys, dregs->virt, + dregs->desc); + + if (dregs->mask) { + blockers = ~val; + blockers &= ~dregs->mask; + + if (blockers) + seq_printf(s, " blocking bits: %08x", + blockers); + } + + seq_printf(s, "\n"); + } +} + +void cm_per_dump(struct seq_file *s) +{ + __dregs_dump(cm_per, s); +} + +void cm_core_dump(struct seq_file *s) +{ + __dregs_dump(cm_core, s); +} + static int pm_dbg_show_counters(struct seq_file *s, void *unused) { pwrdm_for_each(pwrdm_dbg_show_counter, s); clkdm_for_each(clkdm_dbg_show_counter, s); + if (cpu_is_omap34xx()) { + cm_per_dump(s); + cm_core_dump(s); + } return 0; } -- 2.16.1 -- To unsubscribe from this list: send the line "unsubscribe linux-usb" in the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org More majordomo info at http://vger.kernel.org/majordomo-info.html 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: power management problems in ehci-omap From: Tony Lindgren Message-Id: <20180206171737.GB21573@atomide.com> Date: Tue, 6 Feb 2018 09:17:37 -0800 To: Andreas Kemnade Cc: Michael Nazzareno Trimarchi , USB list , Linux OMAP Mailing List , Discussions about the Letux Kernel , Roger Quadros List-ID: KiBBbmRyZWFzIEtlbW5hZGUgPGFuZHJlYXNAa2VtbmFkZS5pbmZvPiBbMTgwMjA2IDE2OjU2XToK PiBPbiBUdWUsIDYgRmViIDIwMTggMDg6MDQ6NTIgLTA4MDAKPiBUb255IExpbmRncmVuIDx0b255 QGF0b21pZGUuY29tPiB3cm90ZToKPiAKPiA+ICogQW5kcmVhcyBLZW1uYWRlIDxhbmRyZWFzQGtl bW5hZGUuaW5mbz4gWzE4MDIwNiAwNjo0Ml06Cj4gPiA+IHJlY2hlY2tlZCB3aXRoIGEgYm9hcmQg d2l0aCByZWFsbHkgbm90aGluZyBjb25uZWN0ZWQgdGhlcmUKPiA+ID4gU2FtZSBiZWhhdmlvdXIg IAo+ID4gCj4gPiBJJ3ZlIGp1c3QgdmVyaWZpZWQgdGhhdCBteSB0ZXN0IGJvYXJkIHBvd2VyIGNv bnN1bXB0aW9uIGdvZXMKPiA+IGJhY2sgdG8gbm9ybWFsIGFmdGVyIHJtbW9kIGVoY2ktb21hcCB3 aXRoIHY0LjE1Lgo+ID4gCj4geWVzLCBmb3IgbWUgdG9vLCBJIGluaXRpYWxseSB1c2VkIGEgdGVz dCBzY3JpcHQgd2hpY2ggZG9lcyBhbgo+IGVjaG8gcm1tb2QgZWhjaS1vbWFwCj4gCj4gd2l0aG91 dCBhIHJlYWwKPiBybW1vZCBlaGNpLW9tYXAKCkFoIE9LIDopCgo+IEl0IGp1c3Qgc2VlbXMgdG8g YmUgY29uc2lzdGVudCB3aXRoIG15IG9ic2VydmF0aW9ucyBpbiBhIGZ1bGx5IGJvb3RlZAo+IHN5 c3RlbSAod2hlcmUgbWFueSB0aGluZ3MgY2FuIHBsYXkgYSByb2xlKS4gU29ycnkgZm9yIHRoYXQg Y29uZnVzaW9uLgoKVHJ5IHdpdGggYSBtaW5pbWFsIHNldCBvZiBtb2R1bGVzIGZpcnN0LCB0aGVu IG1vZHByb2JlIGFuZCBybW1vZCBvbmUKYXQgYSB0aW1lIHVudGlsIHlvdSBmaW5kIHRoZSBtb2R1 bGUgYnJlYWtpbmcgUE0/CgpZb3UgcHJvYmFibHkga25vdyB0aGlzIGFscmVhZHksIGJ1dCBqdXN0 IGluIGNhc2UgaXQgaGVscHMuLgoKRmlyc3QgaWRsZSB0aGUgVUFSVHMgYW5kIGVuYWJsZSBvZmYg bW9kZSB3aXRoIHNvbWV0aGluZyBsaWtlOgoKdWFydHM9JChmaW5kIC9zeXMvY2xhc3MvdHR5L3R0 eVtTT10qL2RldmljZS9wb3dlci8gLXR5cGUgZCkKZm9yIHVhcnQgaW4gJHVhcnRzOyBkbwoJZWNo byAzMDAwID4gJHVhcnQvYXV0b3N1c3BlbmRfZGVsYXlfbXMgMj4mMQpkb25lCgp1YXJ0cz0kKGZp bmQgL3N5cy9jbGFzcy90dHkvdHR5W1NPXSovcG93ZXIvIC10eXBlIGQgMj4vZGV2L251bGwpCmZv ciB1YXJ0IGluICR1YXJ0czsgZG8KCWVjaG8gZW5hYmxlZCA+ICR1YXJ0L3dha2V1cCAyPiYxCgll Y2hvIGF1dG8gPiAkdWFydC9jb250cm9sIDI+JjEKZG9uZQoKZWNobyAtbiAxID4gL3N5cy9rZXJu ZWwvZGVidWcvcG1fZGVidWcvZW5hYmxlX29mZl9tb2RlCgpUaGVuIGlmIHVzaW5nIG9tYXAzLCB0 aGUgYXR0YWNoZWQgZGVidWcgaGFjayBwYXRjaCBjYW4gYmUgdXNlZCB0bwpzZWUgd2hpY2ggZGV2 aWNlcyBhcmUgbm90IGlkbGluZzoKCj4gQnV0IHN1c3BlbmQgY3VycmVudCBpcyBhIHByb2JsZW0u IEkgaGF2ZSByZXBlYXRlZCB0aGUgbWVhc3VyZW1lbnQgd2l0aAo+IGFub3RoZXIgYm9hcmQsIHNv IGl0IGlzIG5vdCBhIGJvYXJkIHByb2JsZW0uIAoKSSBhbHNvIHZlcmlmaWVkIHY0LjE1IGJlaGF2 ZXMgZm9yIHN1c3BlbmQgY3VycmVudCBldmVuIHdpdGgKZWNoaS1vbWFwIGxvYWRlZCBqdXN0IGlu IGNhc2UuCgpSZWdhcmRzLAoKVG9ueQoKODwgLS0tLS0tLS0tLS0tLS0tLS0tLQpGcm9tIHRvbnkg TW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206IFRvbnkgTGluZGdyZW4gPHRvbnlAYXRvbWlk ZS5jb20+CkRhdGU6IFdlZCwgMTMgRGVjIDIwMTcgMTY6MzY6NDUgLTA4MDAKU3ViamVjdDogW1BB VENIXSBOT1QgRk9SIE1FUkdJTkc6IFRlc3QgcGF0Y2ggZm9yIGR1bXBpbmcgb21hcDMgb2ZmIGlk bGUKIGJsb2NraW5nIGJpdHMKCkFsbG93cyBzZWVpbmcgdGhlIGRlZXBlciBpZGxlIHN0YXRlIGJs b2NrZXJzIGluCi9zeXMva2VybmVsL2RlYnVnL3BtX2RlYnVnL2NvdW50LiBGb3IgZXhhbXBsZSwg d2hlbgpvZmYgaWRsZSBpcyB3b3JraW5nIG9uIGJlYWdsYm9hcmQgeG0sIHRoaXMgaXMgd2hhdApp IHNlZToKCiMgc2xlZXAgNTsgY2F0IC9zeXMva2VybmVsL2RlYnVnL3BtX2RlYnVnL2NvdW50Ci4u LgowMDA2ZmZmZiA0ODAwNTAyMCAoZmEwMDUwMjApIGNtX2lkbGVzdF9wZXIgYmxvY2tpbmcgYml0 czogMDAwMTAwMDAKZTdmZmZmYmQgNDgwMDRhMjAgKGZhMDA0YTIwKSBjbV9pZGxlc3QxX2NvcmUg YmxvY2tpbmcgYml0czogMDAwMDAwNDIKMDAwMDAwMGQgNDgwMDRhMjggKGZhMDA0YTI4KSBjbV9p ZGxlc3QzX2NvcmUKLS0tCiBhcmNoL2FybS9tYWNoLW9tYXAyL3BtLWRlYnVnLmMgfCA2OCArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA2 OCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wbS1kZWJ1 Zy5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wbS1kZWJ1Zy5jCi0tLSBhL2FyY2gvYXJtL21hY2gt b21hcDIvcG0tZGVidWcuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3BtLWRlYnVnLmMKQEAg LTE0MiwxMCArMTQyLDc4IEBAIHN0YXRpYyBpbnQgcHdyZG1fZGJnX3Nob3dfdGltZXIoc3RydWN0 IHBvd2VyZG9tYWluICpwd3JkbSwgdm9pZCAqdXNlcikKIAlyZXR1cm4gMDsKIH0KIAorI2luY2x1 ZGUgImlvbWFwLmgiCisKK3N0cnVjdCBkcmVncyB7CisJY29uc3QgY2hhcgkqZGVzYzsKKwl1MzIJ CXBoeXM7CisJdm9pZCBfX2lvbWVtCSp2aXJ0OworCXUzMgkJbWFzazsKK307CisKKyNkZWZpbmUg UEVSX0NNX0JBU0UJMHg0ODAwNTAwMAorI2RlZmluZSBQRVJfQ01fUkVHKG5hbWUsIG9mZnNldCwg bWFzaykJCQkJXAorCXsgbmFtZSwgUEVSX0NNX0JBU0UgKyBvZmZzZXQsCQkJCVwKKwlPTUFQMl9M NF9JT19BRERSRVNTKFBFUl9DTV9CQVNFICsgb2Zmc2V0KSwgbWFzaywgfQorCitzdGF0aWMgc3Ry dWN0IGRyZWdzIGNtX3BlcltdID0geworCVBFUl9DTV9SRUcoImNtX2lkbGVzdF9wZXIiLCAweDIw LCAweGZmZjgwMDAwKSwgLyogcCA1MTMgKi8KKwl7IE5VTEwsIH0sCit9OworCisjZGVmaW5lIENP UkVfQ01fQkFTRQkweDQ4MDA0YTAwCisjZGVmaW5lIENPUkVfQ01fUkVHKG5hbWUsIG9mZnNldCwg bWFzaykJCQkJXAorCXsgbmFtZSwgQ09SRV9DTV9CQVNFICsgb2Zmc2V0LAkJCQlcCisJT01BUDJf TDRfSU9fQUREUkVTUyhDT1JFX0NNX0JBU0UgKyBvZmZzZXQpLCBtYXNrLCB9CisKK3N0YXRpYyBz dHJ1Y3QgZHJlZ3MgY21fY29yZVtdID0geworCUNPUkVfQ01fUkVHKCJjbV9pZGxlc3QxX2NvcmUi LCAweDIwLCAweDljODAwMTA5KSwgLyogcCA0NjcgKi8KKwlDT1JFX0NNX1JFRygiY21faWRsZXN0 M19jb3JlIiwgMHgyOCwgMHhmZmZmZmZmYiksCisJeyBOVUxMLCB9LAorfTsKKwordm9pZCBfX2Ry ZWdzX2R1bXAoc3RydWN0IGRyZWdzICpkcmVncywgc3RydWN0IHNlcV9maWxlICpzKQoreworCWZv ciAoOyBkcmVncy0+ZGVzYzsgZHJlZ3MrKykgeworCQl1MzIgdmFsLCBibG9ja2VyczsKKworCQl2 YWwgPSBfX3Jhd19yZWFkbChkcmVncy0+dmlydCk7CisKKwkJc2VxX3ByaW50ZihzLCAiJTA4eCAl MDh4ICglcCkgJXMiLAorCQkJICAgdmFsLCBkcmVncy0+cGh5cywgZHJlZ3MtPnZpcnQsCisJCQkg ICBkcmVncy0+ZGVzYyk7CisKKwkJaWYgKGRyZWdzLT5tYXNrKSB7CisJCQlibG9ja2VycyA9IH52 YWw7CisJCQlibG9ja2VycyAmPSB+ZHJlZ3MtPm1hc2s7CisKKwkJCWlmIChibG9ja2VycykKKwkJ CQlzZXFfcHJpbnRmKHMsICIgYmxvY2tpbmcgYml0czogJTA4eCIsCisJCQkJCSAgIGJsb2NrZXJz KTsKKwkJfQorCisJCXNlcV9wcmludGYocywgIlxuIik7CisJfQorfQorCit2b2lkIGNtX3Blcl9k dW1wKHN0cnVjdCBzZXFfZmlsZSAqcykKK3sKKwlfX2RyZWdzX2R1bXAoY21fcGVyLCBzKTsKK30K Kwordm9pZCBjbV9jb3JlX2R1bXAoc3RydWN0IHNlcV9maWxlICpzKQoreworCV9fZHJlZ3NfZHVt cChjbV9jb3JlLCBzKTsKK30KKwogc3RhdGljIGludCBwbV9kYmdfc2hvd19jb3VudGVycyhzdHJ1 Y3Qgc2VxX2ZpbGUgKnMsIHZvaWQgKnVudXNlZCkKIHsKIAlwd3JkbV9mb3JfZWFjaChwd3JkbV9k Ymdfc2hvd19jb3VudGVyLCBzKTsKIAljbGtkbV9mb3JfZWFjaChjbGtkbV9kYmdfc2hvd19jb3Vu dGVyLCBzKTsKKwlpZiAoY3B1X2lzX29tYXAzNHh4KCkpIHsKKwkJY21fcGVyX2R1bXAocyk7CisJ CWNtX2NvcmVfZHVtcChzKTsKKwl9CiAKIAlyZXR1cm4gMDsKIH0K