From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Pandruvada, Srinivas" Subject: Re: [PATCH v2] thermal: add sysfs_notify on some attributes Date: Tue, 15 Mar 2016 23:08:00 +0000 Message-ID: <1458079520.4486.39.camel@intel.com> References: <1457979156-10972-1-git-send-email-srikars@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1457979156-10972-1-git-send-email-srikars-DDmLM1+adcrQT0dZR+AlfA@public.gmane.org> Content-Language: en-US Content-ID: <3D6FB98C92254D4489335040A9D2C741-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org> Sender: linux-tegra-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: "Zhang, Rui" , "linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "edubezval-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org" , "srikars-DDmLM1+adcrQT0dZR+AlfA@public.gmane.org" , "linux-pm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "linux-tegra-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "mlongnecker-DDmLM1+adcrQT0dZR+AlfA@public.gmane.org" List-Id: linux-pm@vger.kernel.org T24gTW9uLCAyMDE2LTAzLTE0IGF0IDExOjEyIC0wNzAwLCBTcmlrYXIgU3JpbWF0aCBUaXJ1bWFs YSB3cm90ZToNCj4gQWRkIGEgc3lzZnNfbm90aWZ5IG9uIHRoZXJtYWxfem9uZSovdGVtcCBhbmQg Y29vbGluZ19kZXZpY2UqLw0KPiBjdXJfc3RhdGUgd2hlbmV2ZXIgYW55IHRyaXAgaXMgdHJpZ2dl cmVkIG9yIGN1ciBzdGF0ZSBpcyBjaGFuZ2VkLg0KPiANCj4gVGhpcyBjaGFuZ2UgYWxsb3dzIHVz ZXJtb2RlIGFwcHMgdG8gcmVnaXN0ZXIgdGhlbXNlbHZlcyB0byBnZXQNCj4gbm90aWZpZWQsIHdo ZW4gY2VydGFpbiB0aGVybWFsIGNvbmRpdGlvbnMgb2NjdXIgYW5kIHJlZHVjZSB0aGVpcg0KPiB3 b3JrbG9hZC4gVGhpcyB3b3JrbG9hZCB0aHJvdHRsaW5nIGFsbG93cyB1c2VybW9kZSB0byByZWFj dCBiZWZvcmUNCj4gaGFyZHdhcmUgY2xvY2tzIGFyZSB0aHJvdHRsZWQgYW5kIGtlZXAgc29tZSBj cml0aWNhbCBhcHBzIHJ1bm5pbmcNCj4gcmVsaWFibHkgbG9uZ2VyLg0KSSB0aGluayB3ZSBuZWVk IGEgY29tYmluYXRpb24gb2YgcHJvcG9zYWwgaW7CoA0KaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVs Lm9yZy9wYXRjaC83ODc2MzUxL8KgYW5kIHRoaXMuDQoNCkZvciBleGFtcGxlIHRoaXMgcGF0Y2gg bm90aWZpZXMgdGhhdCBzb21lIHRyaXAgaXMgdmlvbGF0ZWQsIGJ1dCB0aGF0IGlzDQpub3QgZW5v dWdoIGZvciB1c2VyIHNwYWNlIGFwcGxpY2F0aW9uIHRvIHRha2UgYW55IGFjdGlvbi4gU29tZSB0 cmlwcw0KdmlvbGF0aW9ucyB1c2VyIHNwYWNlIG1heSBub3QgY2FyZSBhcyB0aGlzIG1heSBiZSBh IHRyYW5zaWVudCBvbmUuIFRoZQ0KcGF0Y2ggZnJvbcKgRWR1YXJkbyBhZGRyZXNzIHRoYXQgYnkg cHJvdmlkaW5nIHRyaXAsIHRlbXBlcmF0dXJlIGFuZCBsYXN0DQp0ZW1wZXJhdHVyZSBpbmZvcm1h dGlvbi4gQnV0IHRoYXQgcGF0Y2ggb25seSBhZGRyZXNzIGhvdCB0cmlwcy4gSQ0KdW5kZXJzdGFu ZCB3aHkgRWR1YXJkbyBkb2Vzbid0IHdhbnQgdG8gYmUgbm90aWZpZWQgZm9yIHBhc3NpdmUgdHJp cHMgYXMNCnRoZXJlIHdpbGwgYmUgdG9vIG1hbnkuDQoNClNvIElNTyB3ZSBuZWVkIHNvbWUgbWVj aGFuaXNtIHRvIHR1cm4gb2ZmIG5vdGlmaWNhdGlvbiBhbmQgZGVjaWRlIHdoYXQNCm5vdGlmaWNh dGlvbiB3aWxsIHJlc3VsdCBpbiB1c2VyIHNwYWNlIG5vdGlmaWNhdGlvbnMuDQpPbiBzb21lIHg4 NiBzeXN0ZW1zIHdlIGhhdmUgMTArIHBhc3NpdmUvYWN0aXZlIHRyaXBzLCB0aGlzIHdpbGwgcmVz dWx0cw0KaW4gdG9vIG1hbnkgbm90aWZpY2F0aW9ucy4gV2UgbWF5IGJlIGluIHRoZXJtYWxseSBz ZW5zaXRpdmUgem9uZSwgd2hlcmUNCm1vcmUgY29kZSBleGNlY3V0aW9uIGlzIG1vcmUgaGVhdC4N Cg0KV2UgbWF5IGhhdmUgc29tZSBtYXNrIG9mIHRyaXBzIGZvciB3aGljaCB3aWxsIHJlc3VsdCBp biBub3RpZmljYXRpb25zLg0KQnkgZGVmYXVsdCBubyBub3RpZmljYXRpb25zLCB1bmxlc3Mgc29t ZSB1c2VyIHNwYWNlIHJlcXVlc3RzLg0KDQpEdXJpbmcgbGFzdCBMUEMgd2UgZGlzY3Vzc2VkIGFi b3V0IHVzaW5nIElJTyBmb3IgdGVtcGVyYXR1cmUgdGhyZXNob2xkDQpub3RpZmljYXRpb25zIGFu ZCBJIHN1Ym1pdHRlZCBtdWx0aXBsZSBjaGFuZ2VzIGZvciB0aGF0LiBMb29rcyBsaWtlIHdlDQph bHNvIGNhcmUgb2YgdHJpcCBwb2ludCBjaGFuZ2VzLiBTbyBJIHRoaW5rIHdlIG5lZWQgbW9yZSBj b21wcmVoZW5zaXZlDQptZWNoYW5pc20gdG8gYWRkcmVzcyB0aGlzLg0KDQpNYXkgYmUgd2Ugc2hv dWxkIGhhdmUgdGhlcm1hbCBtaW5pIHN1bW1pdCBkdXJpbmcgTFBDIGFnYWluIGFuZCBkZWNpZGUg YQ0KY29tcHJlaGVuc2l2ZSBwbGFuIHRvIGFkZHJlc3MgYWxsIGFzeW5jaHJvbm91cyB0aGVybWFs IG5vdGlmaWNhdGlvbnMuDQoNCg0KVGhhbmtzLA0KU3Jpbml2YXMNCg0KPiANCj4gU2lnbmVkLW9m Zi1ieTogU3Jpa2FyIFNyaW1hdGggVGlydW1hbGEgPHNyaWthcnNAbnZpZGlhLmNvbT4NCj4gLS0t DQo+IA0KPiBDaGFuZ2VzIGZyb20gdjE6DQo+IMKgLSBDYWxsaW5nIHN5c2ZzX25vdGlmeSBmb3Ig dGhlcm1hbF96b25lKi90ZW1wIG9ubHkgd2hlbiB0aGVyZSBpcyBhDQo+IMKgwqDCoHRyaXAgdmlv bGF0ZWQgb24gdGhlIHRoZXJtYWwgem9uZS4NCj4gwqAtIE1vZGlmaWVkIGNvbW1pdCBtZXNzYWdl Lg0KPiANCj4gwqBkcml2ZXJzL3RoZXJtYWwvdGhlcm1hbF9jb3JlLmMgfCAzNCArKysrKysrKysr KysrKysrKysrKysrKysrKy0tLS0NCj4gLS0tLQ0KPiDCoDEgZmlsZSBjaGFuZ2VkLCAyNiBpbnNl cnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQ0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGhl cm1hbC90aGVybWFsX2NvcmUuYw0KPiBiL2RyaXZlcnMvdGhlcm1hbC90aGVybWFsX2NvcmUuYw0K PiBpbmRleCBhMGE4ZmQxLi5mNTQ1MTllIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL3RoZXJtYWwv dGhlcm1hbF9jb3JlLmMNCj4gKysrIGIvZHJpdmVycy90aGVybWFsL3RoZXJtYWxfY29yZS5jDQo+ IEBAIC00MTksMTQgKzQxOSwyMyBAQCBzdGF0aWMgdm9pZCBtb25pdG9yX3RoZXJtYWxfem9uZShz dHJ1Y3QNCj4gdGhlcm1hbF96b25lX2RldmljZSAqdHopDQo+IMKgCW11dGV4X3VubG9jaygmdHot PmxvY2spOw0KPiDCoH0NCj4gwqANCj4gLXN0YXRpYyB2b2lkIGhhbmRsZV9ub25fY3JpdGljYWxf dHJpcHMoc3RydWN0IHRoZXJtYWxfem9uZV9kZXZpY2UNCj4gKnR6LA0KPiArc3RhdGljIGludCBo YW5kbGVfbm9uX2NyaXRpY2FsX3RyaXBzKHN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlICp0eiwN Cj4gwqAJCQlpbnQgdHJpcCwgZW51bSB0aGVybWFsX3RyaXBfdHlwZSB0cmlwX3R5cGUpDQo+IMKg ew0KPiArCWludCB0cmlwX3RlbXA7DQo+ICsJaW50IHJldCA9IDA7DQo+ICsNCj4gwqAJdHotPmdv dmVybm9yID8gdHotPmdvdmVybm9yLT50aHJvdHRsZSh0eiwgdHJpcCkgOg0KPiDCoAkJwqDCoMKg wqDCoMKgwqBkZWZfZ292ZXJub3ItPnRocm90dGxlKHR6LCB0cmlwKTsNCj4gKw0KPiArCXR6LT5v cHMtPmdldF90cmlwX3RlbXAodHosIHRyaXAsICZ0cmlwX3RlbXApOw0KPiArCWlmICh0ei0+dGVt cGVyYXR1cmUgPj0gdHJpcF90ZW1wKQ0KPiArCQlyZXQgPSAxOw0KPiArDQo+ICsJcmV0dXJuIHJl dDsNCj4gwqB9DQo+IMKgDQo+IC1zdGF0aWMgdm9pZCBoYW5kbGVfY3JpdGljYWxfdHJpcHMoc3Ry dWN0IHRoZXJtYWxfem9uZV9kZXZpY2UgKnR6LA0KPiArc3RhdGljIGludCBoYW5kbGVfY3JpdGlj YWxfdHJpcHMoc3RydWN0IHRoZXJtYWxfem9uZV9kZXZpY2UgKnR6LA0KPiDCoAkJCQlpbnQgdHJp cCwgZW51bSB0aGVybWFsX3RyaXBfdHlwZQ0KPiB0cmlwX3R5cGUpDQo+IMKgew0KPiDCoAlpbnQg dHJpcF90ZW1wOw0KPiBAQCAtNDM1LDcgKzQ0NCw3IEBAIHN0YXRpYyB2b2lkIGhhbmRsZV9jcml0 aWNhbF90cmlwcyhzdHJ1Y3QNCj4gdGhlcm1hbF96b25lX2RldmljZSAqdHosDQo+IMKgDQo+IMKg CS8qIElmIHdlIGhhdmUgbm90IGNyb3NzZWQgdGhlIHRyaXBfdGVtcCwgd2UgZG8gbm90IGNhcmUu ICovDQo+IMKgCWlmICh0cmlwX3RlbXAgPD0gMCB8fCB0ei0+dGVtcGVyYXR1cmUgPCB0cmlwX3Rl bXApDQo+IC0JCXJldHVybjsNCj4gKwkJcmV0dXJuIDA7DQo+IMKgDQo+IMKgCXRyYWNlX3RoZXJt YWxfem9uZV90cmlwKHR6LCB0cmlwLCB0cmlwX3R5cGUpOw0KPiDCoA0KPiBAQCAtNDQ4LDIzICs0 NTcsMjggQEAgc3RhdGljIHZvaWQgaGFuZGxlX2NyaXRpY2FsX3RyaXBzKHN0cnVjdA0KPiB0aGVy bWFsX3pvbmVfZGV2aWNlICp0eiwNCj4gwqAJCQnCoMKgdHotPnRlbXBlcmF0dXJlIC8gMTAwMCk7 DQo+IMKgCQlvcmRlcmx5X3Bvd2Vyb2ZmKHRydWUpOw0KPiDCoAl9DQo+ICsNCj4gKwlyZXR1cm4g MTsNCj4gwqB9DQo+IMKgDQo+IC1zdGF0aWMgdm9pZCBoYW5kbGVfdGhlcm1hbF90cmlwKHN0cnVj dCB0aGVybWFsX3pvbmVfZGV2aWNlICp0eiwgaW50DQo+IHRyaXApDQo+ICtzdGF0aWMgaW50IGhh bmRsZV90aGVybWFsX3RyaXAoc3RydWN0IHRoZXJtYWxfem9uZV9kZXZpY2UgKnR6LCBpbnQNCj4g dHJpcCkNCj4gwqB7DQo+ICsJaW50IHJldCA9IDA7DQo+IMKgCWVudW0gdGhlcm1hbF90cmlwX3R5 cGUgdHlwZTsNCj4gwqANCj4gwqAJdHotPm9wcy0+Z2V0X3RyaXBfdHlwZSh0eiwgdHJpcCwgJnR5 cGUpOw0KPiDCoA0KPiDCoAlpZiAodHlwZSA9PSBUSEVSTUFMX1RSSVBfQ1JJVElDQUwgfHwgdHlw ZSA9PQ0KPiBUSEVSTUFMX1RSSVBfSE9UKQ0KPiAtCQloYW5kbGVfY3JpdGljYWxfdHJpcHModHos IHRyaXAsIHR5cGUpOw0KPiArCQlyZXQgPSBoYW5kbGVfY3JpdGljYWxfdHJpcHModHosIHRyaXAs IHR5cGUpOw0KPiDCoAllbHNlDQo+IC0JCWhhbmRsZV9ub25fY3JpdGljYWxfdHJpcHModHosIHRy aXAsIHR5cGUpOw0KPiArCQlyZXQgPSBoYW5kbGVfbm9uX2NyaXRpY2FsX3RyaXBzKHR6LCB0cmlw LCB0eXBlKTsNCj4gwqAJLyoNCj4gwqAJwqAqIEFscmlnaHQsIHdlIGhhbmRsZWQgdGhpcyB0cmlw IHN1Y2Nlc3NmdWxseS4NCj4gwqAJwqAqIFNvLCBzdGFydCBtb25pdG9yaW5nIGFnYWluLg0KPiDC oAnCoCovDQo+IMKgCW1vbml0b3JfdGhlcm1hbF96b25lKHR6KTsNCj4gKw0KPiArCXJldHVybiBy ZXQ7DQo+IMKgfQ0KPiDCoA0KPiDCoC8qKg0KPiBAQCAtNTU2LDcgKzU3MCw3IEBAIHN0YXRpYyB2 b2lkIHRoZXJtYWxfem9uZV9kZXZpY2VfcmVzZXQoc3RydWN0DQo+IHRoZXJtYWxfem9uZV9kZXZp Y2UgKnR6KQ0KPiDCoHZvaWQgdGhlcm1hbF96b25lX2RldmljZV91cGRhdGUoc3RydWN0IHRoZXJt YWxfem9uZV9kZXZpY2UgKnR6KQ0KPiDCoHsNCj4gwqAJaW50IGNvdW50Ow0KPiAtDQo+ICsJaW50 IHRyaXBzID0gMDsNCj4gwqAJaWYgKGF0b21pY19yZWFkKCZpbl9zdXNwZW5kKSkNCj4gwqAJCXJl dHVybjsNCj4gwqANCj4gQEAgLTU2Niw3ICs1ODAsMTAgQEAgdm9pZCB0aGVybWFsX3pvbmVfZGV2 aWNlX3VwZGF0ZShzdHJ1Y3QNCj4gdGhlcm1hbF96b25lX2RldmljZSAqdHopDQo+IMKgCXVwZGF0 ZV90ZW1wZXJhdHVyZSh0eik7DQo+IMKgDQo+IMKgCWZvciAoY291bnQgPSAwOyBjb3VudCA8IHR6 LT50cmlwczsgY291bnQrKykNCj4gLQkJaGFuZGxlX3RoZXJtYWxfdHJpcCh0eiwgY291bnQpOw0K PiArCQl0cmlwcyArPSBoYW5kbGVfdGhlcm1hbF90cmlwKHR6LCBjb3VudCk7DQo+ICsNCj4gKwlp ZiAodHJpcHMpDQo+ICsJCXN5c2ZzX25vdGlmeSgmdHotPmRldmljZS5rb2JqLCBOVUxMLCAidGVt cCIpOw0KPiDCoH0NCj4gwqBFWFBPUlRfU1lNQk9MX0dQTCh0aGVybWFsX3pvbmVfZGV2aWNlX3Vw ZGF0ZSk7DQo+IMKgDQo+IEBAIC0xNjM4LDYgKzE2NTUsNyBAQCB2b2lkIHRoZXJtYWxfY2Rldl91 cGRhdGUoc3RydWN0DQo+IHRoZXJtYWxfY29vbGluZ19kZXZpY2UgKmNkZXYpDQo+IMKgCWNkZXYt PnVwZGF0ZWQgPSB0cnVlOw0KPiDCoAl0cmFjZV9jZGV2X3VwZGF0ZShjZGV2LCB0YXJnZXQpOw0K PiDCoAlkZXZfZGJnKCZjZGV2LT5kZXZpY2UsICJzZXQgdG8gc3RhdGUgJWx1XG4iLCB0YXJnZXQp Ow0KPiArCXN5c2ZzX25vdGlmeSgmY2Rldi0+ZGV2aWNlLmtvYmosIE5VTEwsICJjdXJfc3RhdGUi KTsNCj4gwqB9DQo+IMKgRVhQT1JUX1NZTUJPTCh0aGVybWFsX2NkZXZfdXBkYXRlKTsNCj4gwqA= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933802AbcCOXIE (ORCPT ); Tue, 15 Mar 2016 19:08:04 -0400 Received: from mga04.intel.com ([192.55.52.120]:57204 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753750AbcCOXIB (ORCPT ); Tue, 15 Mar 2016 19:08:01 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.24,341,1455004800"; d="scan'208";a="937938456" From: "Pandruvada, Srinivas" To: "Zhang, Rui" , "linux-kernel@vger.kernel.org" , "edubezval@gmail.com" , "srikars@nvidia.com" , "linux-pm@vger.kernel.org" , "linux-tegra@vger.kernel.org" , "mlongnecker@nvidia.com" Subject: Re: [PATCH v2] thermal: add sysfs_notify on some attributes Thread-Topic: [PATCH v2] thermal: add sysfs_notify on some attributes Thread-Index: AQHRfw+EtbHsrnt/jkqwyrCo77I33A== Date: Tue, 15 Mar 2016 23:08:00 +0000 Message-ID: <1458079520.4486.39.camel@intel.com> References: <1457979156-10972-1-git-send-email-srikars@nvidia.com> In-Reply-To: <1457979156-10972-1-git-send-email-srikars@nvidia.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.254.53.46] Content-Type: text/plain; charset="utf-8" Content-ID: <3D6FB98C92254D4489335040A9D2C741@intel.com> MIME-Version: 1.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id u2FN895B006173 On Mon, 2016-03-14 at 11:12 -0700, Srikar Srimath Tirumala wrote: > Add a sysfs_notify on thermal_zone*/temp and cooling_device*/ > cur_state whenever any trip is triggered or cur state is changed. > > This change allows usermode apps to register themselves to get > notified, when certain thermal conditions occur and reduce their > workload. This workload throttling allows usermode to react before > hardware clocks are throttled and keep some critical apps running > reliably longer. I think we need a combination of proposal in  https://patchwork.kernel.org/patch/7876351/ and this. For example this patch notifies that some trip is violated, but that is not enough for user space application to take any action. Some trips violations user space may not care as this may be a transient one. The patch from Eduardo address that by providing trip, temperature and last temperature information. But that patch only address hot trips. I understand why Eduardo doesn't want to be notified for passive trips as there will be too many. So IMO we need some mechanism to turn off notification and decide what notification will result in user space notifications. On some x86 systems we have 10+ passive/active trips, this will results in too many notifications. We may be in thermally sensitive zone, where more code excecution is more heat. We may have some mask of trips for which will result in notifications. By default no notifications, unless some user space requests. During last LPC we discussed about using IIO for temperature threshold notifications and I submitted multiple changes for that. Looks like we also care of trip point changes. So I think we need more comprehensive mechanism to address this. May be we should have thermal mini summit during LPC again and decide a comprehensive plan to address all asynchronous thermal notifications. Thanks, Srinivas > > Signed-off-by: Srikar Srimath Tirumala > --- > > Changes from v1: >  - Calling sysfs_notify for thermal_zone*/temp only when there is a >    trip violated on the thermal zone. >  - Modified commit message. > >  drivers/thermal/thermal_core.c | 34 ++++++++++++++++++++++++++---- > ---- >  1 file changed, 26 insertions(+), 8 deletions(-) > > diff --git a/drivers/thermal/thermal_core.c > b/drivers/thermal/thermal_core.c > index a0a8fd1..f54519e 100644 > --- a/drivers/thermal/thermal_core.c > +++ b/drivers/thermal/thermal_core.c > @@ -419,14 +419,23 @@ static void monitor_thermal_zone(struct > thermal_zone_device *tz) >   mutex_unlock(&tz->lock); >  } >   > -static void handle_non_critical_trips(struct thermal_zone_device > *tz, > +static int handle_non_critical_trips(struct thermal_zone_device *tz, >   int trip, enum thermal_trip_type trip_type) >  { > + int trip_temp; > + int ret = 0; > + >   tz->governor ? tz->governor->throttle(tz, trip) : >          def_governor->throttle(tz, trip); > + > + tz->ops->get_trip_temp(tz, trip, &trip_temp); > + if (tz->temperature >= trip_temp) > + ret = 1; > + > + return ret; >  } >   > -static void handle_critical_trips(struct thermal_zone_device *tz, > +static int handle_critical_trips(struct thermal_zone_device *tz, >   int trip, enum thermal_trip_type > trip_type) >  { >   int trip_temp; > @@ -435,7 +444,7 @@ static void handle_critical_trips(struct > thermal_zone_device *tz, >   >   /* If we have not crossed the trip_temp, we do not care. */ >   if (trip_temp <= 0 || tz->temperature < trip_temp) > - return; > + return 0; >   >   trace_thermal_zone_trip(tz, trip, trip_type); >   > @@ -448,23 +457,28 @@ static void handle_critical_trips(struct > thermal_zone_device *tz, >     tz->temperature / 1000); >   orderly_poweroff(true); >   } > + > + return 1; >  } >   > -static void handle_thermal_trip(struct thermal_zone_device *tz, int > trip) > +static int handle_thermal_trip(struct thermal_zone_device *tz, int > trip) >  { > + int ret = 0; >   enum thermal_trip_type type; >   >   tz->ops->get_trip_type(tz, trip, &type); >   >   if (type == THERMAL_TRIP_CRITICAL || type == > THERMAL_TRIP_HOT) > - handle_critical_trips(tz, trip, type); > + ret = handle_critical_trips(tz, trip, type); >   else > - handle_non_critical_trips(tz, trip, type); > + ret = handle_non_critical_trips(tz, trip, type); >   /* >    * Alright, we handled this trip successfully. >    * So, start monitoring again. >    */ >   monitor_thermal_zone(tz); > + > + return ret; >  } >   >  /** > @@ -556,7 +570,7 @@ static void thermal_zone_device_reset(struct > thermal_zone_device *tz) >  void thermal_zone_device_update(struct thermal_zone_device *tz) >  { >   int count; > - > + int trips = 0; >   if (atomic_read(&in_suspend)) >   return; >   > @@ -566,7 +580,10 @@ void thermal_zone_device_update(struct > thermal_zone_device *tz) >   update_temperature(tz); >   >   for (count = 0; count < tz->trips; count++) > - handle_thermal_trip(tz, count); > + trips += handle_thermal_trip(tz, count); > + > + if (trips) > + sysfs_notify(&tz->device.kobj, NULL, "temp"); >  } >  EXPORT_SYMBOL_GPL(thermal_zone_device_update); >   > @@ -1638,6 +1655,7 @@ void thermal_cdev_update(struct > thermal_cooling_device *cdev) >   cdev->updated = true; >   trace_cdev_update(cdev, target); >   dev_dbg(&cdev->device, "set to state %lu\n", target); > + sysfs_notify(&cdev->device.kobj, NULL, "cur_state"); >  } >  EXPORT_SYMBOL(thermal_cdev_update); >