From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [RFC v2 1/4] drm/nouveau: Add support for basic clockgating on Kepler1 Date: Thu, 25 Jan 2018 22:35:03 -0500 Message-ID: <20180126033607.7682-2-lyude@redhat.com> References: <20180126033607.7682-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180126033607.7682-1-lyude-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: nouveau-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Nouveau" To: nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Cc: David Airlie , Greg Kroah-Hartman , dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Alexandre Courbot , Ben Skeggs List-Id: nouveau.vger.kernel.org VGhpcyBhZGRzIHN1cHBvcnQgZm9yIGVuYWJsaW5nIGF1dG9tYXRpYyBjbG9ja2dhdGluZyBvbiBu dmlkaWEgR1BVcyBmb3IKS2VwbGVyMS4gV2hpbGUgdGhpcyBpcyBub3QgdGVjaG5pY2FsbHkgYSBj bG9ja2dhdGluZyBsZXZlbCwgaXQgZG9lcwplbmFibGUgY2xvY2tnYXRpbmcgdXNpbmcgdGhlIGNs b2NrZ2F0aW5nIHZhbHVlcyBpbml0aWFsbHkgc2V0IGJ5IHRoZQp2YmlvcyAod2hpY2ggc2hvdWxk IGJlIHNhZmUgdG8gdXNlKS4KClRoaXMgaW50cm9kdWNlcyB0d28gdGhlcm0gaGVscGVycyBmb3Ig Y29udHJvbGxpbmcgYmFzaWMgY2xvY2tnYXRpbmc6CgludmttX3RoZXJtX2Nsa2dhdGVfZW5hYmxl KCkgLSBlbmFibGVzIGNsb2NrZ2F0aW5nIHRocm91Z2gKCUNHX0NUUkwsIGRvbmUgYWZ0ZXIgaW5p dGlhbGl6aW5nIHRoZSBHUFUgZnVsbHkKCW52a21fdGhlcm1fY2xrZ2F0ZV9maW5pKCkgLSBwcmVw YXJlcyBjbG9ja2dhdGluZyBmb3Igc3VzcGVuZCBvcgoJZHJpdmVyIHVubG9hZAoKQXMgd2VsbCwg d2UgYWRkIHRoZSBub3V2ZWF1IGtlcm5lbCBjb25maWcgcGFyYW1ldGVyIE52UG1FbmFibGVHYXRp bmcsCndoaWNoIGNhbiBiZSB0b2dnbGVkIG9uIG9yIG9mZiBpbiBvcmRlciB0byBlbmFibGUvZGlz YWJsZSBjbG9ja2dhdGluZy4KU2luY2Ugd2UndmUgb25seSBoYWQgbGltaXRlZCB0ZXN0aW5nIG9u IHRoaXMgdGh1cyBmYXIsIHdlIGRpc2FibGUgdGhpcwpieSBkZWZhdWx0LgoKQSBsb3Qgb2YgdGhp cyBjb2RlIHdhcyBvcmlnaW5hbGx5IGdvaW5nIHRvIGJlIGJhc2VkIG9mZiBvZiBmZXJtaTsKaG93 ZXZlciBpdCB0dXJucyBvdXQgdGhhdCB3aGlsZSBGZXJtaSdzIHRoZSBmaXJzdCBsaW5lIG9mIEdQ VXMgdGhhdAppbnRyb2R1Y2VkIHRoaXMga2luZCBvZiBwb3dlciBzYXZpbmcsIEZlcm1pIHJlcXVp cmVzIG1vcmUgZmluZSB0dW5lZApjb250cm9sIG9mIHRoZSBDR19DVFJMIHJlZ2lzdGVycyBmcm9t IHRoZSBkcml2ZXIgd2hpbGUgcmVjbG9ja2luZyB0aGF0CndlIGRvbid0IGVudGlyZWx5IHVuZGVy c3RhbmQgeWV0LgoKRm9yIHRoZSBzaW1wbGUgcGFydHMgd2Ugd2lsbCBiZSBzaGFyaW5nIHdpdGgg RmVybWkgZm9yIGNlcnRhaW4gaG93ZXZlciwKd2UgYXQgbGVhc3QgYWRkIHRob3NlIGludG8gYSBu ZXcgc3ViZGV2L3RoZXJtL2dmMTAwLmggaGVhZGVyLgoKU2lnbmVkLW9mZi1ieTogTHl1ZGUgUGF1 bCA8bHl1ZGVAcmVkaGF0LmNvbT4KLS0tCiAuLi4vZ3B1L2RybS9ub3V2ZWF1L2luY2x1ZGUvbnZr bS9zdWJkZXYvdGhlcm0uaCAgICB8ICAgNSArCiBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmtt L2VuZ2luZS9kZXZpY2UvYmFzZS5jICB8ICAxNyArLS0KIGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1 L252a20vc3ViZGV2L3RoZXJtL0tidWlsZCAgIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS9ub3V2 ZWF1L252a20vc3ViZGV2L3RoZXJtL2Jhc2UuYyAgIHwgIDYwICsrKysrKystLQogZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2YxMDAuaCAgfCAgMzUgKysrKysrCiBk cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9nZjExOS5jICB8ICAgOCAr LQogZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2sxMDQuYyAgfCAx MzUgKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1 YmRldi90aGVybS9nazEwNC5oICB8ICA0OCArKysrKysrKwogZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbnZrbS9zdWJkZXYvdGhlcm0vcHJpdi5oICAgfCAgMTUgKystCiA5IGZpbGVzIGNoYW5nZWQs IDMwMyBpbnNlcnRpb25zKCspLCAyMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9nZjEwMC5oCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2sx MDQuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3Vi ZGV2L3RoZXJtL2drMTA0LmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9p bmNsdWRlL252a20vc3ViZGV2L3RoZXJtLmggYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9pbmNs dWRlL252a20vc3ViZGV2L3RoZXJtLmgKaW5kZXggYjFhYzQ3ZWI3ODZlLi4yNDBiMTliYjQ2Njcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2luY2x1ZGUvbnZrbS9zdWJkZXYv dGhlcm0uaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9pbmNsdWRlL252a20vc3ViZGV2 L3RoZXJtLmgKQEAgLTg1LDE3ICs4NSwyMiBAQCBzdHJ1Y3QgbnZrbV90aGVybSB7CiAKIAlpbnQg KCphdHRyX2dldCkoc3RydWN0IG52a21fdGhlcm0gKiwgZW51bSBudmttX3RoZXJtX2F0dHJfdHlw ZSk7CiAJaW50ICgqYXR0cl9zZXQpKHN0cnVjdCBudmttX3RoZXJtICosIGVudW0gbnZrbV90aGVy bV9hdHRyX3R5cGUsIGludCk7CisKKwlib29sIGNsa2dhdGluZ19lbmFibGVkOwogfTsKIAogaW50 IG52a21fdGhlcm1fdGVtcF9nZXQoc3RydWN0IG52a21fdGhlcm0gKik7CiBpbnQgbnZrbV90aGVy bV9mYW5fc2Vuc2Uoc3RydWN0IG52a21fdGhlcm0gKik7CiBpbnQgbnZrbV90aGVybV9jc3RhdGUo c3RydWN0IG52a21fdGhlcm0gKiwgaW50LCBpbnQpOwordm9pZCBudmttX3RoZXJtX2Nsa2dhdGVf ZW5hYmxlKHN0cnVjdCBudmttX3RoZXJtICopOwordm9pZCBudmttX3RoZXJtX2Nsa2dhdGVfZmlu aShzdHJ1Y3QgbnZrbV90aGVybSAqLCBib29sKTsKIAogaW50IG52NDBfdGhlcm1fbmV3KHN0cnVj dCBudmttX2RldmljZSAqLCBpbnQsIHN0cnVjdCBudmttX3RoZXJtICoqKTsKIGludCBudjUwX3Ro ZXJtX25ldyhzdHJ1Y3QgbnZrbV9kZXZpY2UgKiwgaW50LCBzdHJ1Y3QgbnZrbV90aGVybSAqKik7 CiBpbnQgZzg0X3RoZXJtX25ldyhzdHJ1Y3QgbnZrbV9kZXZpY2UgKiwgaW50LCBzdHJ1Y3QgbnZr bV90aGVybSAqKik7CiBpbnQgZ3QyMTVfdGhlcm1fbmV3KHN0cnVjdCBudmttX2RldmljZSAqLCBp bnQsIHN0cnVjdCBudmttX3RoZXJtICoqKTsKIGludCBnZjExOV90aGVybV9uZXcoc3RydWN0IG52 a21fZGV2aWNlICosIGludCwgc3RydWN0IG52a21fdGhlcm0gKiopOworaW50IGdrMTA0X3RoZXJt X25ldyhzdHJ1Y3QgbnZrbV9kZXZpY2UgKiwgaW50LCBzdHJ1Y3QgbnZrbV90aGVybSAqKik7CiBp bnQgZ20xMDdfdGhlcm1fbmV3KHN0cnVjdCBudmttX2RldmljZSAqLCBpbnQsIHN0cnVjdCBudmtt X3RoZXJtICoqKTsKIGludCBnbTIwMF90aGVybV9uZXcoc3RydWN0IG52a21fZGV2aWNlICosIGlu dCwgc3RydWN0IG52a21fdGhlcm0gKiopOwogaW50IGdwMTAwX3RoZXJtX25ldyhzdHJ1Y3QgbnZr bV9kZXZpY2UgKiwgaW50LCBzdHJ1Y3QgbnZrbV90aGVybSAqKik7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL2VuZ2luZS9kZXZpY2UvYmFzZS5jIGIvZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvbnZrbS9lbmdpbmUvZGV2aWNlL2Jhc2UuYwppbmRleCAwOGU3N2NkNTVl NmUuLjc0YmQwOWIxYzg5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZr bS9lbmdpbmUvZGV2aWNlL2Jhc2UuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmtt L2VuZ2luZS9kZXZpY2UvYmFzZS5jCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5jbHVkZSA8Y29yZS9v cHRpb24uaD4KIAogI2luY2x1ZGUgPHN1YmRldi9iaW9zLmg+CisjaW5jbHVkZSA8c3ViZGV2L3Ro ZXJtLmg+CiAKIHN0YXRpYyBERUZJTkVfTVVURVgobnZfZGV2aWNlc19tdXRleCk7CiBzdGF0aWMg TElTVF9IRUFEKG52X2RldmljZXMpOwpAQCAtMTY4Miw3ICsxNjgzLDcgQEAgbnZlNF9jaGlwc2V0 ID0gewogCS5teG0gPSBudjUwX214bV9uZXcsCiAJLnBjaSA9IGdrMTA0X3BjaV9uZXcsCiAJLnBt dSA9IGdrMTA0X3BtdV9uZXcsCi0JLnRoZXJtID0gZ2YxMTlfdGhlcm1fbmV3LAorCS50aGVybSA9 IGdrMTA0X3RoZXJtX25ldywKIAkudGltZXIgPSBudjQxX3RpbWVyX25ldywKIAkudG9wID0gZ2sx MDRfdG9wX25ldywKIAkudm9sdCA9IGdrMTA0X3ZvbHRfbmV3LApAQCAtMTcyMSw3ICsxNzIyLDcg QEAgbnZlNl9jaGlwc2V0ID0gewogCS5teG0gPSBudjUwX214bV9uZXcsCiAJLnBjaSA9IGdrMTA0 X3BjaV9uZXcsCiAJLnBtdSA9IGdrMTA0X3BtdV9uZXcsCi0JLnRoZXJtID0gZ2YxMTlfdGhlcm1f bmV3LAorCS50aGVybSA9IGdrMTA0X3RoZXJtX25ldywKIAkudGltZXIgPSBudjQxX3RpbWVyX25l dywKIAkudG9wID0gZ2sxMDRfdG9wX25ldywKIAkudm9sdCA9IGdrMTA0X3ZvbHRfbmV3LApAQCAt MTc2MCw3ICsxNzYxLDcgQEAgbnZlN19jaGlwc2V0ID0gewogCS5teG0gPSBudjUwX214bV9uZXcs CiAJLnBjaSA9IGdrMTA0X3BjaV9uZXcsCiAJLnBtdSA9IGdrMTA0X3BtdV9uZXcsCi0JLnRoZXJt ID0gZ2YxMTlfdGhlcm1fbmV3LAorCS50aGVybSA9IGdrMTA0X3RoZXJtX25ldywKIAkudGltZXIg PSBudjQxX3RpbWVyX25ldywKIAkudG9wID0gZ2sxMDRfdG9wX25ldywKIAkudm9sdCA9IGdrMTA0 X3ZvbHRfbmV3LApAQCAtMTgyNCw3ICsxODI1LDcgQEAgbnZmMF9jaGlwc2V0ID0gewogCS5teG0g PSBudjUwX214bV9uZXcsCiAJLnBjaSA9IGdrMTA0X3BjaV9uZXcsCiAJLnBtdSA9IGdrMTEwX3Bt dV9uZXcsCi0JLnRoZXJtID0gZ2YxMTlfdGhlcm1fbmV3LAorCS50aGVybSA9IGdrMTA0X3RoZXJt X25ldywKIAkudGltZXIgPSBudjQxX3RpbWVyX25ldywKIAkudG9wID0gZ2sxMDRfdG9wX25ldywK IAkudm9sdCA9IGdrMTA0X3ZvbHRfbmV3LApAQCAtMTg2Miw3ICsxODYzLDcgQEAgbnZmMV9jaGlw c2V0ID0gewogCS5teG0gPSBudjUwX214bV9uZXcsCiAJLnBjaSA9IGdrMTA0X3BjaV9uZXcsCiAJ LnBtdSA9IGdrMTEwX3BtdV9uZXcsCi0JLnRoZXJtID0gZ2YxMTlfdGhlcm1fbmV3LAorCS50aGVy bSA9IGdrMTA0X3RoZXJtX25ldywKIAkudGltZXIgPSBudjQxX3RpbWVyX25ldywKIAkudG9wID0g Z2sxMDRfdG9wX25ldywKIAkudm9sdCA9IGdrMTA0X3ZvbHRfbmV3LApAQCAtMTkwMCw3ICsxOTAx LDcgQEAgbnYxMDZfY2hpcHNldCA9IHsKIAkubXhtID0gbnY1MF9teG1fbmV3LAogCS5wY2kgPSBn azEwNF9wY2lfbmV3LAogCS5wbXUgPSBnazIwOF9wbXVfbmV3LAotCS50aGVybSA9IGdmMTE5X3Ro ZXJtX25ldywKKwkudGhlcm0gPSBnazEwNF90aGVybV9uZXcsCiAJLnRpbWVyID0gbnY0MV90aW1l cl9uZXcsCiAJLnRvcCA9IGdrMTA0X3RvcF9uZXcsCiAJLnZvbHQgPSBnazEwNF92b2x0X25ldywK QEAgLTE5MzgsNyArMTkzOSw3IEBAIG52MTA4X2NoaXBzZXQgPSB7CiAJLm14bSA9IG52NTBfbXht X25ldywKIAkucGNpID0gZ2sxMDRfcGNpX25ldywKIAkucG11ID0gZ2syMDhfcG11X25ldywKLQku dGhlcm0gPSBnZjExOV90aGVybV9uZXcsCisJLnRoZXJtID0gZ2sxMDRfdGhlcm1fbmV3LAogCS50 aW1lciA9IG52NDFfdGltZXJfbmV3LAogCS50b3AgPSBnazEwNF90b3BfbmV3LAogCS52b2x0ID0g Z2sxMDRfdm9sdF9uZXcsCkBAIC0yNTA4LDYgKzI1MDksNyBAQCBudmttX2RldmljZV9maW5pKHN0 cnVjdCBudmttX2RldmljZSAqZGV2aWNlLCBib29sIHN1c3BlbmQpCiAJCX0KIAl9CiAKKwludmtt X3RoZXJtX2Nsa2dhdGVfZmluaShkZXZpY2UtPnRoZXJtLCBzdXNwZW5kKTsKIAogCWlmIChkZXZp Y2UtPmZ1bmMtPmZpbmkpCiAJCWRldmljZS0+ZnVuYy0+ZmluaShkZXZpY2UsIHN1c3BlbmQpOwpA QCAtMjU5Nyw2ICsyNTk5LDcgQEAgbnZrbV9kZXZpY2VfaW5pdChzdHJ1Y3QgbnZrbV9kZXZpY2Ug KmRldmljZSkKIAl9CiAKIAludmttX2FjcGlfaW5pdChkZXZpY2UpOworCW52a21fdGhlcm1fY2xr Z2F0ZV9lbmFibGUoZGV2aWNlLT50aGVybSk7CiAKIAl0aW1lID0ga3RpbWVfdG9fdXMoa3RpbWVf Z2V0KCkpIC0gdGltZTsKIAludmRldl90cmFjZShkZXZpY2UsICJpbml0IGNvbXBsZXRlZCBpbiAl bGxkdXNcbiIsIHRpbWUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZr bS9zdWJkZXYvdGhlcm0vS2J1aWxkIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJk ZXYvdGhlcm0vS2J1aWxkCmluZGV4IDdiYTU2YjEyYmFkZC4uNGJhYzQ3NzJkOGVkIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9LYnVpbGQKKysr IGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vS2J1aWxkCkBAIC0x MCw2ICsxMCw3IEBAIG52a20teSArPSBudmttL3N1YmRldi90aGVybS9udjUwLm8KIG52a20teSAr PSBudmttL3N1YmRldi90aGVybS9nODQubwogbnZrbS15ICs9IG52a20vc3ViZGV2L3RoZXJtL2d0 MjE1Lm8KIG52a20teSArPSBudmttL3N1YmRldi90aGVybS9nZjExOS5vCitudmttLXkgKz0gbnZr bS9zdWJkZXYvdGhlcm0vZ2sxMDQubwogbnZrbS15ICs9IG52a20vc3ViZGV2L3RoZXJtL2dtMTA3 Lm8KIG52a20teSArPSBudmttL3N1YmRldi90aGVybS9nbTIwMC5vCiBudmttLXkgKz0gbnZrbS9z dWJkZXYvdGhlcm0vZ3AxMDAubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUv bnZrbS9zdWJkZXYvdGhlcm0vYmFzZS5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9z dWJkZXYvdGhlcm0vYmFzZS5jCmluZGV4IGYyN2ZjNmQwZDRjNi4uZTRjOTZlNDZkYjhmIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9iYXNlLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vYmFzZS5jCkBA IC0yMSw2ICsyMSw3IEBACiAgKgogICogQXV0aG9yczogTWFydGluIFBlcmVzCiAgKi8KKyNpbmNs dWRlIDxudmttL2NvcmUvb3B0aW9uLmg+CiAjaW5jbHVkZSAicHJpdi5oIgogCiBpbnQKQEAgLTI5 Nyw2ICsyOTgsMzggQEAgbnZrbV90aGVybV9hdHRyX3NldChzdHJ1Y3QgbnZrbV90aGVybSAqdGhl cm0sCiAJcmV0dXJuIC1FSU5WQUw7CiB9CiAKK3ZvaWQKK252a21fdGhlcm1fY2xrZ2F0ZV9lbmFi bGUoc3RydWN0IG52a21fdGhlcm0gKnRoZXJtKQoreworCWlmICghdGhlcm0tPmZ1bmMtPmNsa2dh dGVfZW5hYmxlIHx8ICF0aGVybS0+Y2xrZ2F0aW5nX2VuYWJsZWQpCisJCXJldHVybjsKKworCW52 a21fZGVidWcoJnRoZXJtLT5zdWJkZXYsCisJCSAgICJFbmFibGluZyBjbG9ja2dhdGluZ1xuIik7 CisJdGhlcm0tPmZ1bmMtPmNsa2dhdGVfZW5hYmxlKHRoZXJtKTsKK30KKwordm9pZAorbnZrbV90 aGVybV9jbGtnYXRlX2Zpbmkoc3RydWN0IG52a21fdGhlcm0gKnRoZXJtLCBib29sIHN1c3BlbmQp Cit7CisJaWYgKCF0aGVybS0+ZnVuYy0+Y2xrZ2F0ZV9maW5pIHx8ICF0aGVybS0+Y2xrZ2F0aW5n X2VuYWJsZWQpCisJCXJldHVybjsKKworCW52a21fZGVidWcoJnRoZXJtLT5zdWJkZXYsCisJCSAg ICJQcmVwYXJpbmcgY2xvY2tnYXRpbmcgZm9yICVzXG4iLAorCQkgICBzdXNwZW5kID8gInN1c3Bl bmQiIDogImZpbmkiKTsKKwl0aGVybS0+ZnVuYy0+Y2xrZ2F0ZV9maW5pKHRoZXJtLCBzdXNwZW5k KTsKK30KKworc3RhdGljIHZvaWQKK252a21fdGhlcm1fY2xrZ2F0ZV9vbmVpbml0KHN0cnVjdCBu dmttX3RoZXJtICp0aGVybSkKK3sKKwlpZiAoIXRoZXJtLT5mdW5jLT5jbGtnYXRlX2VuYWJsZSB8 fCAhdGhlcm0tPmNsa2dhdGluZ19lbmFibGVkKQorCQlyZXR1cm47CisKKwludmttX2luZm8oJnRo ZXJtLT5zdWJkZXYsICJDbG9ja2dhdGluZyBlbmFibGVkXG4iKTsKK30KKwogc3RhdGljIHZvaWQK IG52a21fdGhlcm1faW50cihzdHJ1Y3QgbnZrbV9zdWJkZXYgKnN1YmRldikKIHsKQEAgLTMzMyw2 ICszNjYsNyBAQCBudmttX3RoZXJtX29uZWluaXQoc3RydWN0IG52a21fc3ViZGV2ICpzdWJkZXYp CiAJbnZrbV90aGVybV9mYW5fY3Rvcih0aGVybSk7CiAJbnZrbV90aGVybV9mYW5fbW9kZSh0aGVy bSwgTlZLTV9USEVSTV9DVFJMX0FVVE8pOwogCW52a21fdGhlcm1fc2Vuc29yX3ByZWluaXQodGhl cm0pOworCW52a21fdGhlcm1fY2xrZ2F0ZV9vbmVpbml0KHRoZXJtKTsKIAlyZXR1cm4gMDsKIH0K IApAQCAtMzc0LDE1ICs0MDgsMTAgQEAgbnZrbV90aGVybSA9IHsKIAkuaW50ciA9IG52a21fdGhl cm1faW50ciwKIH07CiAKLWludAotbnZrbV90aGVybV9uZXdfKGNvbnN0IHN0cnVjdCBudmttX3Ro ZXJtX2Z1bmMgKmZ1bmMsIHN0cnVjdCBudmttX2RldmljZSAqZGV2aWNlLAotCQlpbnQgaW5kZXgs IHN0cnVjdCBudmttX3RoZXJtICoqcHRoZXJtKQordm9pZAorbnZrbV90aGVybV9jdG9yKHN0cnVj dCBudmttX3RoZXJtICp0aGVybSwgc3RydWN0IG52a21fZGV2aWNlICpkZXZpY2UsCisJCWludCBp bmRleCwgY29uc3Qgc3RydWN0IG52a21fdGhlcm1fZnVuYyAqZnVuYykKIHsKLQlzdHJ1Y3QgbnZr bV90aGVybSAqdGhlcm07Ci0KLQlpZiAoISh0aGVybSA9ICpwdGhlcm0gPSBremFsbG9jKHNpemVv ZigqdGhlcm0pLCBHRlBfS0VSTkVMKSkpCi0JCXJldHVybiAtRU5PTUVNOwotCiAJbnZrbV9zdWJk ZXZfY3RvcigmbnZrbV90aGVybSwgZGV2aWNlLCBpbmRleCwgJnRoZXJtLT5zdWJkZXYpOwogCXRo ZXJtLT5mdW5jID0gZnVuYzsKIApAQCAtMzk1LDUgKzQyNCwyMCBAQCBudmttX3RoZXJtX25ld18o Y29uc3Qgc3RydWN0IG52a21fdGhlcm1fZnVuYyAqZnVuYywgc3RydWN0IG52a21fZGV2aWNlICpk ZXZpY2UsCiAJdGhlcm0tPmF0dHJfZ2V0ID0gbnZrbV90aGVybV9hdHRyX2dldDsKIAl0aGVybS0+ YXR0cl9zZXQgPSBudmttX3RoZXJtX2F0dHJfc2V0OwogCXRoZXJtLT5tb2RlID0gdGhlcm0tPnN1 c3BlbmQgPSAtMTsgLyogdW5kZWZpbmVkICovCisKKwl0aGVybS0+Y2xrZ2F0aW5nX2VuYWJsZWQg PSBudmttX2Jvb2xvcHQoZGV2aWNlLT5jZmdvcHQsCisJCQkJCQkiTnZQbUVuYWJsZUdhdGluZyIs IGZhbHNlKTsKK30KKworaW50CitudmttX3RoZXJtX25ld18oY29uc3Qgc3RydWN0IG52a21fdGhl cm1fZnVuYyAqZnVuYywgc3RydWN0IG52a21fZGV2aWNlICpkZXZpY2UsCisJCWludCBpbmRleCwg c3RydWN0IG52a21fdGhlcm0gKipwdGhlcm0pCit7CisJc3RydWN0IG52a21fdGhlcm0gKnRoZXJt OworCisJaWYgKCEodGhlcm0gPSAqcHRoZXJtID0ga3phbGxvYyhzaXplb2YoKnRoZXJtKSwgR0ZQ X0tFUk5FTCkpKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW52a21fdGhlcm1fY3Rvcih0aGVybSwg ZGV2aWNlLCBpbmRleCwgZnVuYyk7CiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9nZjEwMC5oIGIvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2YxMDAuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAuLmNmYjI1YWY3N2M2MAotLS0gL2Rldi9udWxsCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2dmMTAwLmgKQEAgLTAsMCAr MSwzNSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDE4IFJlZCBIYXQgSW5jLgorICoKKyAqIFBlcm1p c3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9i dGFpbmluZyBhCisgKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1l bnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdh cmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICog dGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1 dGUsIHN1YmxpY2Vuc2UsCisgKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBh bmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hl ZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKgorICog VGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hh bGwgYmUgaW5jbHVkZWQgaW4KKyAqIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMg b2YgdGhlIFNvZnR3YXJlLgorICoKKyAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMi LCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCisgKiBJTVBMSUVELCBJ TkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSwKKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5H RU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAorICogVEhFIENPUFlSSUdIVCBIT0xERVIoUykgT1Ig QVVUSE9SKFMpIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SCisgKiBPVEhFUiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVS V0lTRSwKKyAqIEFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUg U09GVFdBUkUgT1IgVEhFIFVTRSBPUgorICogT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJF LgorICoKKyAqIEF1dGhvcnM6IEx5dWRlIFBhdWwKKyAqLworCisjaWZuZGVmIF9fR0YxMDBfVEhF Uk1fSF9fCisjZGVmaW5lIF9fR0YxMDBfVEhFUk1fSF9fCisKKyNpbmNsdWRlIDxjb3JlL2Rldmlj ZS5oPgorCitzdHJ1Y3QgZ2YxMDBfaWRsZV9maWx0ZXIgeworCXUzMiBmZWNzOworCXUzMiBodWJt bXU7Cit9OworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252 a20vc3ViZGV2L3RoZXJtL2dmMTE5LmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1 YmRldi90aGVybS9nZjExOS5jCmluZGV4IDA2ZGNmZDZlZTk2Ni4uMDk4MWIwMjc5MGUyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9nZjExOS5j CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2dmMTE5LmMK QEAgLTQ5LDcgKzQ5LDcgQEAgcHdtX2luZm8oc3RydWN0IG52a21fdGhlcm0gKnRoZXJtLCBpbnQg bGluZSkKIAlyZXR1cm4gLUVOT0RFVjsKIH0KIAotc3RhdGljIGludAoraW50CiBnZjExOV9mYW5f cHdtX2N0cmwoc3RydWN0IG52a21fdGhlcm0gKnRoZXJtLCBpbnQgbGluZSwgYm9vbCBlbmFibGUp CiB7CiAJc3RydWN0IG52a21fZGV2aWNlICpkZXZpY2UgPSB0aGVybS0+c3ViZGV2LmRldmljZTsK QEAgLTYzLDcgKzYzLDcgQEAgZ2YxMTlfZmFuX3B3bV9jdHJsKHN0cnVjdCBudmttX3RoZXJtICp0 aGVybSwgaW50IGxpbmUsIGJvb2wgZW5hYmxlKQogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50 CitpbnQKIGdmMTE5X2Zhbl9wd21fZ2V0KHN0cnVjdCBudmttX3RoZXJtICp0aGVybSwgaW50IGxp bmUsIHUzMiAqZGl2cywgdTMyICpkdXR5KQogewogCXN0cnVjdCBudmttX2RldmljZSAqZGV2aWNl ID0gdGhlcm0tPnN1YmRldi5kZXZpY2U7CkBAIC04NSw3ICs4NSw3IEBAIGdmMTE5X2Zhbl9wd21f Z2V0KHN0cnVjdCBudmttX3RoZXJtICp0aGVybSwgaW50IGxpbmUsIHUzMiAqZGl2cywgdTMyICpk dXR5KQogCXJldHVybiAtRUlOVkFMOwogfQogCi1zdGF0aWMgaW50CitpbnQKIGdmMTE5X2Zhbl9w d21fc2V0KHN0cnVjdCBudmttX3RoZXJtICp0aGVybSwgaW50IGxpbmUsIHUzMiBkaXZzLCB1MzIg ZHV0eSkKIHsKIAlzdHJ1Y3QgbnZrbV9kZXZpY2UgKmRldmljZSA9IHRoZXJtLT5zdWJkZXYuZGV2 aWNlOwpAQCAtMTAyLDcgKzEwMiw3IEBAIGdmMTE5X2Zhbl9wd21fc2V0KHN0cnVjdCBudmttX3Ro ZXJtICp0aGVybSwgaW50IGxpbmUsIHUzMiBkaXZzLCB1MzIgZHV0eSkKIAlyZXR1cm4gMDsKIH0K IAotc3RhdGljIGludAoraW50CiBnZjExOV9mYW5fcHdtX2Nsb2NrKHN0cnVjdCBudmttX3RoZXJt ICp0aGVybSwgaW50IGxpbmUpCiB7CiAJc3RydWN0IG52a21fZGV2aWNlICpkZXZpY2UgPSB0aGVy bS0+c3ViZGV2LmRldmljZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252 a20vc3ViZGV2L3RoZXJtL2drMTA0LmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1 YmRldi90aGVybS9nazEwNC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uNzk4MDZhNzU3ODkzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2sxMDQuYwpAQCAtMCwwICsxLDEzNSBAQAorLyoKKyAqIENv cHlyaWdodCAyMDE4IFJlZCBIYXQgSW5jLgorICoKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdy YW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCisgKiBjb3B5 IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhl ICJTb2Z0d2FyZSIpLAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmlj dGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJpZ2h0cyB0byB1c2Us IGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCisg KiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNv bnMgdG8gd2hvbSB0aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVj dCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdo dCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4K KyAqIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgor ICoKKyAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZ IE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCisgKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBM SU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKKyAqIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVO VCBTSEFMTAorICogVEhFIENPUFlSSUdIVCBIT0xERVIoUykgT1IgQVVUSE9SKFMpIEJFIExJQUJM RSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SCisgKiBPVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwKKyAqIEFSSVNJTkcg RlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVT RSBPUgorICogT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgorICoKKyAqIEF1dGhvcnM6 IEx5dWRlIFBhdWwKKyAqLworI2luY2x1ZGUgPGNvcmUvZGV2aWNlLmg+CisKKyNpbmNsdWRlICJw cml2LmgiCisjaW5jbHVkZSAiZ2sxMDQuaCIKKwordm9pZAorZ2sxMDRfY2xrZ2F0ZV9lbmFibGUo c3RydWN0IG52a21fdGhlcm0gKmJhc2UpCit7CisJc3RydWN0IGdrMTA0X3RoZXJtICp0aGVybSA9 IGdrMTA0X3RoZXJtKGJhc2UpOworCXN0cnVjdCBudmttX2RldmljZSAqZGV2ID0gdGhlcm0tPmJh c2Uuc3ViZGV2LmRldmljZTsKKwljb25zdCBzdHJ1Y3QgZ2sxMDRfY2xrZ2F0ZV9lbmdpbmVfaW5m byAqb3JkZXIgPSB0aGVybS0+Y2xrZ2F0ZV9vcmRlcjsKKwlpbnQgaTsKKworCS8qIFByb2dyYW0g RU5HX01BTlQsIEVOR19GSUxURVIgKi8KKwlmb3IgKGkgPSAwOyBvcmRlcltpXS5lbmdpbmUgIT0g TlZLTV9TVUJERVZfTlI7IGkrKykgeworCQlpZiAoIW52a21fZGV2aWNlX3N1YmRldihkZXYsIG9y ZGVyW2ldLmVuZ2luZSkpCisJCQljb250aW51ZTsKKworCQludmttX21hc2soZGV2LCAweDIwMjAw ICsgb3JkZXJbaV0ub2Zmc2V0LCAweGZmMDAsIDB4NDUwMCk7CisJfQorCisJLyogbWFnaWMgKi8K KwludmttX3dyMzIoZGV2LCAweDAyMDI4OCwgdGhlcm0tPmlkbGVfZmlsdGVyLT5mZWNzKTsKKwlu dmttX3dyMzIoZGV2LCAweDAyMDI4YywgdGhlcm0tPmlkbGVfZmlsdGVyLT5odWJtbXUpOworCisJ LyogRW5hYmxlIGNsb2NrZ2F0aW5nIChFTkdfQ0xLID0gUlVOLT5BVVRPKSAqLworCWZvciAoaSA9 IDA7IG9yZGVyW2ldLmVuZ2luZSAhPSBOVktNX1NVQkRFVl9OUjsgaSsrKSB7CisJCWlmICghbnZr bV9kZXZpY2Vfc3ViZGV2KGRldiwgb3JkZXJbaV0uZW5naW5lKSkKKwkJCWNvbnRpbnVlOworCisJ CW52a21fbWFzayhkZXYsIDB4MjAyMDAgKyBvcmRlcltpXS5vZmZzZXQsIDB4MDBmZiwgMHgwMDQ1 KTsKKwl9Cit9CisKK3ZvaWQKK2drMTA0X2Nsa2dhdGVfZmluaShzdHJ1Y3QgbnZrbV90aGVybSAq YmFzZSwgYm9vbCBzdXNwZW5kKQoreworCXN0cnVjdCBnazEwNF90aGVybSAqdGhlcm0gPSBnazEw NF90aGVybShiYXNlKTsKKwlzdHJ1Y3QgbnZrbV9kZXZpY2UgKmRldiA9IHRoZXJtLT5iYXNlLnN1 YmRldi5kZXZpY2U7CisJY29uc3Qgc3RydWN0IGdrMTA0X2Nsa2dhdGVfZW5naW5lX2luZm8gKm9y ZGVyID0gdGhlcm0tPmNsa2dhdGVfb3JkZXI7CisJaW50IGk7CisKKwkvKiBFTkdfQ0xLID0gQVVU Ty0+UlVOLCBFTkdfUFdSID0gUlVOLT5BVVRPICovCisJZm9yIChpID0gMDsgb3JkZXJbaV0uZW5n aW5lICE9IE5WS01fU1VCREVWX05SOyBpKyspIHsKKwkJaWYgKCFudmttX2RldmljZV9zdWJkZXYo ZGV2LCBvcmRlcltpXS5lbmdpbmUpKQorCQkJY29udGludWU7CisKKwkJbnZrbV9tYXNrKGRldiwg MHgyMDIwMCArIG9yZGVyW2ldLm9mZnNldCwgMHhmZiwgMHg1NCk7CisJfQorfQorCitjb25zdCBz dHJ1Y3QgZ2sxMDRfY2xrZ2F0ZV9lbmdpbmVfaW5mbyBnazEwNF9jbGtnYXRlX2VuZ2luZV9pbmZv W10gPSB7CisJeyBOVktNX0VOR0lORV9HUiwgICAgIDB4MDAgfSwKKwl7IE5WS01fRU5HSU5FX01T UERFQywgMHgwNCB9LAorCXsgTlZLTV9FTkdJTkVfTVNQUFAsICAweDA4IH0sCisJeyBOVktNX0VO R0lORV9NU1ZMRCwgIDB4MGMgfSwKKwl7IE5WS01fRU5HSU5FX0NFMCwgICAgMHgxMCB9LAorCXsg TlZLTV9FTkdJTkVfQ0UxLCAgICAweDE0IH0sCisJeyBOVktNX0VOR0lORV9NU0VOQywgIDB4MTgg fSwKKwl7IE5WS01fRU5HSU5FX0NFMiwgICAgMHgxYyB9LAorCXsgTlZLTV9TVUJERVZfTlIsIDAg fSwKK307CisKK2NvbnN0IHN0cnVjdCBnZjEwMF9pZGxlX2ZpbHRlciBnazEwNF9pZGxlX2ZpbHRl ciA9IHsKKwkuZmVjcyA9IDB4MDAwMDEwMDAsCisJLmh1Ym1tdSA9IDB4MDAwMDEwMDAsCit9Owor CitzdGF0aWMgY29uc3Qgc3RydWN0IG52a21fdGhlcm1fZnVuYworZ2sxMDRfdGhlcm1fZnVuYyA9 IHsKKwkuaW5pdCA9IGdmMTE5X3RoZXJtX2luaXQsCisJLmZpbmkgPSBnODRfdGhlcm1fZmluaSwK KwkucHdtX2N0cmwgPSBnZjExOV9mYW5fcHdtX2N0cmwsCisJLnB3bV9nZXQgPSBnZjExOV9mYW5f cHdtX2dldCwKKwkucHdtX3NldCA9IGdmMTE5X2Zhbl9wd21fc2V0LAorCS5wd21fY2xvY2sgPSBn ZjExOV9mYW5fcHdtX2Nsb2NrLAorCS50ZW1wX2dldCA9IGc4NF90ZW1wX2dldCwKKwkuZmFuX3Nl bnNlID0gZ3QyMTVfdGhlcm1fZmFuX3NlbnNlLAorCS5wcm9ncmFtX2FsYXJtcyA9IG52a21fdGhl cm1fcHJvZ3JhbV9hbGFybXNfcG9sbGluZywKKwkuY2xrZ2F0ZV9lbmFibGUgPSBnazEwNF9jbGtn YXRlX2VuYWJsZSwKKwkuY2xrZ2F0ZV9maW5pID0gZ2sxMDRfY2xrZ2F0ZV9maW5pLAorfTsKKwor c3RhdGljIGludAorZ2sxMDRfdGhlcm1fbmV3Xyhjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9mdW5j ICpmdW5jLAorCQkgc3RydWN0IG52a21fZGV2aWNlICpkZXZpY2UsCisJCSBpbnQgaW5kZXgsCisJ CSBjb25zdCBzdHJ1Y3QgZ2sxMDRfY2xrZ2F0ZV9lbmdpbmVfaW5mbyAqY2xrZ2F0ZV9vcmRlciwK KwkJIGNvbnN0IHN0cnVjdCBnZjEwMF9pZGxlX2ZpbHRlciAqaWRsZV9maWx0ZXIsCisJCSBzdHJ1 Y3QgbnZrbV90aGVybSAqKnB0aGVybSkKK3sKKwlzdHJ1Y3QgZ2sxMDRfdGhlcm0gKnRoZXJtID0g a3phbGxvYyhzaXplb2YoKnRoZXJtKSwgR0ZQX0tFUk5FTCk7CisKKwlpZiAoIXRoZXJtKQorCQly ZXR1cm4gLUVOT01FTTsKKworCW52a21fdGhlcm1fY3RvcigmdGhlcm0tPmJhc2UsIGRldmljZSwg aW5kZXgsIGZ1bmMpOworCSpwdGhlcm0gPSAmdGhlcm0tPmJhc2U7CisJdGhlcm0tPmNsa2dhdGVf b3JkZXIgPSBjbGtnYXRlX29yZGVyOworCXRoZXJtLT5pZGxlX2ZpbHRlciA9IGlkbGVfZmlsdGVy OworCisJcmV0dXJuIDA7Cit9CisKK2ludAorZ2sxMDRfdGhlcm1fbmV3KHN0cnVjdCBudmttX2Rl dmljZSAqZGV2aWNlLAorCQlpbnQgaW5kZXgsIHN0cnVjdCBudmttX3RoZXJtICoqcHRoZXJtKQor eworCXJldHVybiBnazEwNF90aGVybV9uZXdfKCZnazEwNF90aGVybV9mdW5jLCBkZXZpY2UsIGlu ZGV4LAorCQkJCWdrMTA0X2Nsa2dhdGVfZW5naW5lX2luZm8sICZnazEwNF9pZGxlX2ZpbHRlciwK KwkJCQlwdGhlcm0pOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZr bS9zdWJkZXYvdGhlcm0vZ2sxMDQuaCBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3Vi ZGV2L3RoZXJtL2drMTA0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li4yOTNlNzc0M2IxOWIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVh dS9udmttL3N1YmRldi90aGVybS9nazEwNC5oCkBAIC0wLDAgKzEsNDggQEAKKy8qCisgKiBDb3B5 cmlnaHQgMjAxOCBSZWQgSGF0IEluYy4KKyAqCisgKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFu dGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQorICogY29weSBv ZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAi U29mdHdhcmUiKSwKKyAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rp b24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KKyAqIHRoZSByaWdodHMgdG8gdXNlLCBj b3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLAorICog YW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25z IHRvIHdob20gdGhlCisgKiBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3Qg dG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQg bm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCisg KiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KKyAq CisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBP RiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElN SVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisgKiBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiAgSU4gTk8gRVZFTlQg U0hBTEwKKyAqIFRIRSBDT1BZUklHSFQgSE9MREVSKFMpIE9SIEFVVEhPUihTKSBCRSBMSUFCTEUg Rk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUgorICogT1RIRVIgTElBQklMSVRZLCBXSEVUSEVSIElO IEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsCisgKiBBUklTSU5HIEZS T00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0Ug T1IKKyAqIE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KKyAqCisgKiBBdXRob3JzOiBM eXVkZSBQYXVsCisgKi8KKworI2lmbmRlZiBfX0dLMTA0X1RIRVJNX0hfXworI2RlZmluZSBfX0dL MTA0X1RIRVJNX0hfXworI2RlZmluZSBnazEwNF90aGVybShwKSAoY29udGFpbmVyX29mKChwKSwg c3RydWN0IGdrMTA0X3RoZXJtLCBiYXNlKSkKKworI2luY2x1ZGUgPHN1YmRldi90aGVybS5oPgor I2luY2x1ZGUgInByaXYuaCIKKyNpbmNsdWRlICJnZjEwMC5oIgorCitzdHJ1Y3QgZ2sxMDRfY2xr Z2F0ZV9lbmdpbmVfaW5mbyB7CisJZW51bSBudmttX2RldmlkeCBlbmdpbmU7CisJdTggb2Zmc2V0 OworfTsKKworc3RydWN0IGdrMTA0X3RoZXJtIHsKKwlzdHJ1Y3QgbnZrbV90aGVybSBiYXNlOwor CisJY29uc3Qgc3RydWN0IGdrMTA0X2Nsa2dhdGVfZW5naW5lX2luZm8gKmNsa2dhdGVfb3JkZXI7 CisJY29uc3Qgc3RydWN0IGdmMTAwX2lkbGVfZmlsdGVyICppZGxlX2ZpbHRlcjsKK307CisKK2V4 dGVybiBjb25zdCBzdHJ1Y3QgZ2sxMDRfY2xrZ2F0ZV9lbmdpbmVfaW5mbyBnazEwNF9jbGtnYXRl X2VuZ2luZV9pbmZvW107CitleHRlcm4gY29uc3Qgc3RydWN0IGdmMTAwX2lkbGVfZmlsdGVyIGdr MTA0X2lkbGVfZmlsdGVyOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9u b3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL3ByaXYuaCBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1 L252a20vc3ViZGV2L3RoZXJtL3ByaXYuaAppbmRleCAxZjQ2ZTM3MWQ3YzQuLmYzMDIwMmRkODhl NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0v cHJpdi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL3By aXYuaApAQCAtMzIsNiArMzIsOCBAQAogCiBpbnQgbnZrbV90aGVybV9uZXdfKGNvbnN0IHN0cnVj dCBudmttX3RoZXJtX2Z1bmMgKiwgc3RydWN0IG52a21fZGV2aWNlICosCiAJCSAgICBpbnQgaW5k ZXgsIHN0cnVjdCBudmttX3RoZXJtICoqKTsKK3ZvaWQgbnZrbV90aGVybV9jdG9yKHN0cnVjdCBu dmttX3RoZXJtICp0aGVybSwgc3RydWN0IG52a21fZGV2aWNlICpkZXZpY2UsCisJCSAgICAgaW50 IGluZGV4LCBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9mdW5jICpmdW5jKTsKIAogc3RydWN0IG52 a21fZmFuIHsKIAlzdHJ1Y3QgbnZrbV90aGVybSAqcGFyZW50OwpAQCAtNjYsOCArNjgsNiBAQCBp bnQgbnZrbV90aGVybV9mYW5fc2V0KHN0cnVjdCBudmttX3RoZXJtICosIGJvb2wgbm93LCBpbnQg cGVyY2VudCk7CiBpbnQgbnZrbV90aGVybV9mYW5fdXNlcl9nZXQoc3RydWN0IG52a21fdGhlcm0g Kik7CiBpbnQgbnZrbV90aGVybV9mYW5fdXNlcl9zZXQoc3RydWN0IG52a21fdGhlcm0gKiwgaW50 IHBlcmNlbnQpOwogCi1pbnQgbnZrbV90aGVybV9wcmVpbml0KHN0cnVjdCBudmttX3RoZXJtICop OwotCiBpbnQgIG52a21fdGhlcm1fc2Vuc29yX2luaXQoc3RydWN0IG52a21fdGhlcm0gKik7CiBp bnQgIG52a21fdGhlcm1fc2Vuc29yX2Zpbmkoc3RydWN0IG52a21fdGhlcm0gKiwgYm9vbCBzdXNw ZW5kKTsKIHZvaWQgbnZrbV90aGVybV9zZW5zb3JfcHJlaW5pdChzdHJ1Y3QgbnZrbV90aGVybSAq KTsKQEAgLTk2LDYgKzk2LDkgQEAgc3RydWN0IG52a21fdGhlcm1fZnVuYyB7CiAJaW50ICgqZmFu X3NlbnNlKShzdHJ1Y3QgbnZrbV90aGVybSAqKTsKIAogCXZvaWQgKCpwcm9ncmFtX2FsYXJtcyko c3RydWN0IG52a21fdGhlcm0gKik7CisKKwl2b2lkICgqY2xrZ2F0ZV9lbmFibGUpKHN0cnVjdCBu dmttX3RoZXJtICopOworCXZvaWQgKCpjbGtnYXRlX2ZpbmkpKHN0cnVjdCBudmttX3RoZXJtICos IGJvb2wpOwogfTsKIAogdm9pZCBudjQwX3RoZXJtX2ludHIoc3RydWN0IG52a21fdGhlcm0gKik7 CkBAIC0xMTIsOCArMTE1LDE2IEBAIHZvaWQgZzg0X3RoZXJtX2Zpbmkoc3RydWN0IG52a21fdGhl cm0gKik7CiBpbnQgZ3QyMTVfdGhlcm1fZmFuX3NlbnNlKHN0cnVjdCBudmttX3RoZXJtICopOwog CiB2b2lkIGc4NF90aGVybV9pbml0KHN0cnVjdCBudmttX3RoZXJtICopOworCitpbnQgZ2YxMTlf ZmFuX3B3bV9jdHJsKHN0cnVjdCBudmttX3RoZXJtICosIGludCwgYm9vbCk7CitpbnQgZ2YxMTlf ZmFuX3B3bV9nZXQoc3RydWN0IG52a21fdGhlcm0gKiwgaW50LCB1MzIgKiwgdTMyICopOworaW50 IGdmMTE5X2Zhbl9wd21fc2V0KHN0cnVjdCBudmttX3RoZXJtICosIGludCwgdTMyLCB1MzIpOwor aW50IGdmMTE5X2Zhbl9wd21fY2xvY2soc3RydWN0IG52a21fdGhlcm0gKiwgaW50KTsKIHZvaWQg Z2YxMTlfdGhlcm1faW5pdChzdHJ1Y3QgbnZrbV90aGVybSAqKTsKIAordm9pZCBnazEwNF9jbGtn YXRlX2VuYWJsZShzdHJ1Y3QgbnZrbV90aGVybSAqKTsKK3ZvaWQgZ2sxMDRfY2xrZ2F0ZV9maW5p KHN0cnVjdCBudmttX3RoZXJtICosIGJvb2wpOworCiBpbnQgbnZrbV9mYW5wd21fY3JlYXRlKHN0 cnVjdCBudmttX3RoZXJtICosIHN0cnVjdCBkY2JfZ3Bpb19mdW5jICopOwogaW50IG52a21fZmFu dG9nX2NyZWF0ZShzdHJ1Y3QgbnZrbV90aGVybSAqLCBzdHJ1Y3QgZGNiX2dwaW9fZnVuYyAqKTsK IGludCBudmttX2Zhbm5pbF9jcmVhdGUoc3RydWN0IG52a21fdGhlcm0gKik7Ci0tIAoyLjE0LjMK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCk5vdXZlYXUg bWFpbGluZyBsaXN0Ck5vdXZlYXVAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMu ZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vbm91dmVhdQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AH8x227JbbA6x+CdvoMuRO0HVYK8/PiYCE2oDih4nSwomPvv9fsR7CxixXTs0ObAwCP7ddOatdWp ARC-Seal: i=1; a=rsa-sha256; t=1516937836; cv=none; d=google.com; s=arc-20160816; b=cMdiQE82i0vKUlYcu7MSrF9o//a6O8J//XYVCAADmB4y5bUiItlHMK8vUFg8fAf9zj OD5Qd8x40icQ31bq5OHGC/4fbxzc/9COa5GgJq0s080pIjgR22RvQ5N7KSi22SDXThz1 SWeYZ4RvhhtSpsm6y6znBdVTKfJPJb9XnleNolfeYHAr9IwvW1oDXD85guBJ+WhJCrCG pFgc332c2NhTDicgt6+EGgrbAleb61LwFvDc2j5FRGaA7nYerTSQD9Av4Wif+2Szvlse ICnWuzp5A/61V2PV3eaQZdkNT1iOT/L/YdVxwh3G9hXU1ex5pZ9PbvTu3Fswx0iUzhUY +Ypg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :arc-authentication-results; bh=X6H9LvzxIa4s+TOZHjM16GIw9CEepoXG8w2Nt8AZhj4=; b=t9rTHWvWrWGvHD0iRcTHe+PH0rTMtnixMobl6NSvqYqVgtMyYoFutPTP6/iSvnLM9Z XQVpZIWZPZ5bnpmhGTOfdm3nRyEuVSPONZB8KcaxMa/WC0RKkdEYmkQz/01a5mBwA/PM YN3rOX66K2kg/PCWIDUUslxz3Nqn+8IhbUV4l90Iwv16sNei3/2h6F1tcBPnj5Yq4VyG /y0q6KJQckiYV13AAGl7Nr/qK1d3Tjtz4qLEpDS1Z5DUdlq8gSQwJUrjorJMGGg+zr3o PfHY8DOtuCCFWKPxXvX0LDuEY/0+pccRm9fYVtJCCeEGnv6GOSgRIGqKSghSUQ14cTxd 2pzg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of lyude@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=lyude@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Authentication-Results: mx.google.com; spf=pass (google.com: domain of lyude@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=lyude@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com From: Lyude Paul To: nouveau@lists.freedesktop.org Cc: Ben Skeggs , David Airlie , Rhys Kidd , Greg Kroah-Hartman , Karol Herbst , Alexandre Courbot , Ilia Mirkin , Martin Peres , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [RFC v2 1/4] drm/nouveau: Add support for basic clockgating on Kepler1 Date: Thu, 25 Jan 2018 22:35:03 -0500 Message-Id: <20180126033607.7682-2-lyude@redhat.com> In-Reply-To: <20180126033607.7682-1-lyude@redhat.com> References: <20180126033607.7682-1-lyude@redhat.com> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1590624608745566093?= X-GMAIL-MSGID: =?utf-8?q?1590624608745566093?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: This adds support for enabling automatic clockgating on nvidia GPUs for Kepler1. While this is not technically a clockgating level, it does enable clockgating using the clockgating values initially set by the vbios (which should be safe to use). This introduces two therm helpers for controlling basic clockgating: nvkm_therm_clkgate_enable() - enables clockgating through CG_CTRL, done after initializing the GPU fully nvkm_therm_clkgate_fini() - prepares clockgating for suspend or driver unload As well, we add the nouveau kernel config parameter NvPmEnableGating, which can be toggled on or off in order to enable/disable clockgating. Since we've only had limited testing on this thus far, we disable this by default. A lot of this code was originally going to be based off of fermi; however it turns out that while Fermi's the first line of GPUs that introduced this kind of power saving, Fermi requires more fine tuned control of the CG_CTRL registers from the driver while reclocking that we don't entirely understand yet. For the simple parts we will be sharing with Fermi for certain however, we at least add those into a new subdev/therm/gf100.h header. Signed-off-by: Lyude Paul --- .../gpu/drm/nouveau/include/nvkm/subdev/therm.h | 5 + drivers/gpu/drm/nouveau/nvkm/engine/device/base.c | 17 +-- drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild | 1 + drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c | 60 +++++++-- drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.h | 35 ++++++ drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf119.c | 8 +- drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c | 135 +++++++++++++++++++++ drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.h | 48 ++++++++ drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h | 15 ++- 9 files changed, 303 insertions(+), 21 deletions(-) create mode 100644 drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.h create mode 100644 drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c create mode 100644 drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.h diff --git a/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h b/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h index b1ac47eb786e..240b19bb4667 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h @@ -85,17 +85,22 @@ struct nvkm_therm { int (*attr_get)(struct nvkm_therm *, enum nvkm_therm_attr_type); int (*attr_set)(struct nvkm_therm *, enum nvkm_therm_attr_type, int); + + bool clkgating_enabled; }; int nvkm_therm_temp_get(struct nvkm_therm *); int nvkm_therm_fan_sense(struct nvkm_therm *); int nvkm_therm_cstate(struct nvkm_therm *, int, int); +void nvkm_therm_clkgate_enable(struct nvkm_therm *); +void nvkm_therm_clkgate_fini(struct nvkm_therm *, bool); int nv40_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int nv50_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int g84_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int gt215_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int gf119_therm_new(struct nvkm_device *, int, struct nvkm_therm **); +int gk104_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int gm107_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int gm200_therm_new(struct nvkm_device *, int, struct nvkm_therm **); int gp100_therm_new(struct nvkm_device *, int, struct nvkm_therm **); diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c b/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c index 08e77cd55e6e..74bd09b1c893 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c @@ -28,6 +28,7 @@ #include #include +#include static DEFINE_MUTEX(nv_devices_mutex); static LIST_HEAD(nv_devices); @@ -1682,7 +1683,7 @@ nve4_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk104_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -1721,7 +1722,7 @@ nve6_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk104_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -1760,7 +1761,7 @@ nve7_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk104_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -1824,7 +1825,7 @@ nvf0_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk110_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -1862,7 +1863,7 @@ nvf1_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk110_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -1900,7 +1901,7 @@ nv106_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk208_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -1938,7 +1939,7 @@ nv108_chipset = { .mxm = nv50_mxm_new, .pci = gk104_pci_new, .pmu = gk208_pmu_new, - .therm = gf119_therm_new, + .therm = gk104_therm_new, .timer = nv41_timer_new, .top = gk104_top_new, .volt = gk104_volt_new, @@ -2508,6 +2509,7 @@ nvkm_device_fini(struct nvkm_device *device, bool suspend) } } + nvkm_therm_clkgate_fini(device->therm, suspend); if (device->func->fini) device->func->fini(device, suspend); @@ -2597,6 +2599,7 @@ nvkm_device_init(struct nvkm_device *device) } nvkm_acpi_init(device); + nvkm_therm_clkgate_enable(device->therm); time = ktime_to_us(ktime_get()) - time; nvdev_trace(device, "init completed in %lldus\n", time); diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild index 7ba56b12badd..4bac4772d8ed 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild @@ -10,6 +10,7 @@ nvkm-y += nvkm/subdev/therm/nv50.o nvkm-y += nvkm/subdev/therm/g84.o nvkm-y += nvkm/subdev/therm/gt215.o nvkm-y += nvkm/subdev/therm/gf119.o +nvkm-y += nvkm/subdev/therm/gk104.o nvkm-y += nvkm/subdev/therm/gm107.o nvkm-y += nvkm/subdev/therm/gm200.o nvkm-y += nvkm/subdev/therm/gp100.o diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c index f27fc6d0d4c6..e4c96e46db8f 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c @@ -21,6 +21,7 @@ * * Authors: Martin Peres */ +#include #include "priv.h" int @@ -297,6 +298,38 @@ nvkm_therm_attr_set(struct nvkm_therm *therm, return -EINVAL; } +void +nvkm_therm_clkgate_enable(struct nvkm_therm *therm) +{ + if (!therm->func->clkgate_enable || !therm->clkgating_enabled) + return; + + nvkm_debug(&therm->subdev, + "Enabling clockgating\n"); + therm->func->clkgate_enable(therm); +} + +void +nvkm_therm_clkgate_fini(struct nvkm_therm *therm, bool suspend) +{ + if (!therm->func->clkgate_fini || !therm->clkgating_enabled) + return; + + nvkm_debug(&therm->subdev, + "Preparing clockgating for %s\n", + suspend ? "suspend" : "fini"); + therm->func->clkgate_fini(therm, suspend); +} + +static void +nvkm_therm_clkgate_oneinit(struct nvkm_therm *therm) +{ + if (!therm->func->clkgate_enable || !therm->clkgating_enabled) + return; + + nvkm_info(&therm->subdev, "Clockgating enabled\n"); +} + static void nvkm_therm_intr(struct nvkm_subdev *subdev) { @@ -333,6 +366,7 @@ nvkm_therm_oneinit(struct nvkm_subdev *subdev) nvkm_therm_fan_ctor(therm); nvkm_therm_fan_mode(therm, NVKM_THERM_CTRL_AUTO); nvkm_therm_sensor_preinit(therm); + nvkm_therm_clkgate_oneinit(therm); return 0; } @@ -374,15 +408,10 @@ nvkm_therm = { .intr = nvkm_therm_intr, }; -int -nvkm_therm_new_(const struct nvkm_therm_func *func, struct nvkm_device *device, - int index, struct nvkm_therm **ptherm) +void +nvkm_therm_ctor(struct nvkm_therm *therm, struct nvkm_device *device, + int index, const struct nvkm_therm_func *func) { - struct nvkm_therm *therm; - - if (!(therm = *ptherm = kzalloc(sizeof(*therm), GFP_KERNEL))) - return -ENOMEM; - nvkm_subdev_ctor(&nvkm_therm, device, index, &therm->subdev); therm->func = func; @@ -395,5 +424,20 @@ nvkm_therm_new_(const struct nvkm_therm_func *func, struct nvkm_device *device, therm->attr_get = nvkm_therm_attr_get; therm->attr_set = nvkm_therm_attr_set; therm->mode = therm->suspend = -1; /* undefined */ + + therm->clkgating_enabled = nvkm_boolopt(device->cfgopt, + "NvPmEnableGating", false); +} + +int +nvkm_therm_new_(const struct nvkm_therm_func *func, struct nvkm_device *device, + int index, struct nvkm_therm **ptherm) +{ + struct nvkm_therm *therm; + + if (!(therm = *ptherm = kzalloc(sizeof(*therm), GFP_KERNEL))) + return -ENOMEM; + + nvkm_therm_ctor(therm, device, index, func); return 0; } diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.h b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.h new file mode 100644 index 000000000000..cfb25af77c60 --- /dev/null +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.h @@ -0,0 +1,35 @@ +/* + * Copyright 2018 Red Hat Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: Lyude Paul + */ + +#ifndef __GF100_THERM_H__ +#define __GF100_THERM_H__ + +#include + +struct gf100_idle_filter { + u32 fecs; + u32 hubmmu; +}; + +#endif diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf119.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf119.c index 06dcfd6ee966..0981b02790e2 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf119.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf119.c @@ -49,7 +49,7 @@ pwm_info(struct nvkm_therm *therm, int line) return -ENODEV; } -static int +int gf119_fan_pwm_ctrl(struct nvkm_therm *therm, int line, bool enable) { struct nvkm_device *device = therm->subdev.device; @@ -63,7 +63,7 @@ gf119_fan_pwm_ctrl(struct nvkm_therm *therm, int line, bool enable) return 0; } -static int +int gf119_fan_pwm_get(struct nvkm_therm *therm, int line, u32 *divs, u32 *duty) { struct nvkm_device *device = therm->subdev.device; @@ -85,7 +85,7 @@ gf119_fan_pwm_get(struct nvkm_therm *therm, int line, u32 *divs, u32 *duty) return -EINVAL; } -static int +int gf119_fan_pwm_set(struct nvkm_therm *therm, int line, u32 divs, u32 duty) { struct nvkm_device *device = therm->subdev.device; @@ -102,7 +102,7 @@ gf119_fan_pwm_set(struct nvkm_therm *therm, int line, u32 divs, u32 duty) return 0; } -static int +int gf119_fan_pwm_clock(struct nvkm_therm *therm, int line) { struct nvkm_device *device = therm->subdev.device; diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c new file mode 100644 index 000000000000..79806a757893 --- /dev/null +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c @@ -0,0 +1,135 @@ +/* + * Copyright 2018 Red Hat Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: Lyude Paul + */ +#include + +#include "priv.h" +#include "gk104.h" + +void +gk104_clkgate_enable(struct nvkm_therm *base) +{ + struct gk104_therm *therm = gk104_therm(base); + struct nvkm_device *dev = therm->base.subdev.device; + const struct gk104_clkgate_engine_info *order = therm->clkgate_order; + int i; + + /* Program ENG_MANT, ENG_FILTER */ + for (i = 0; order[i].engine != NVKM_SUBDEV_NR; i++) { + if (!nvkm_device_subdev(dev, order[i].engine)) + continue; + + nvkm_mask(dev, 0x20200 + order[i].offset, 0xff00, 0x4500); + } + + /* magic */ + nvkm_wr32(dev, 0x020288, therm->idle_filter->fecs); + nvkm_wr32(dev, 0x02028c, therm->idle_filter->hubmmu); + + /* Enable clockgating (ENG_CLK = RUN->AUTO) */ + for (i = 0; order[i].engine != NVKM_SUBDEV_NR; i++) { + if (!nvkm_device_subdev(dev, order[i].engine)) + continue; + + nvkm_mask(dev, 0x20200 + order[i].offset, 0x00ff, 0x0045); + } +} + +void +gk104_clkgate_fini(struct nvkm_therm *base, bool suspend) +{ + struct gk104_therm *therm = gk104_therm(base); + struct nvkm_device *dev = therm->base.subdev.device; + const struct gk104_clkgate_engine_info *order = therm->clkgate_order; + int i; + + /* ENG_CLK = AUTO->RUN, ENG_PWR = RUN->AUTO */ + for (i = 0; order[i].engine != NVKM_SUBDEV_NR; i++) { + if (!nvkm_device_subdev(dev, order[i].engine)) + continue; + + nvkm_mask(dev, 0x20200 + order[i].offset, 0xff, 0x54); + } +} + +const struct gk104_clkgate_engine_info gk104_clkgate_engine_info[] = { + { NVKM_ENGINE_GR, 0x00 }, + { NVKM_ENGINE_MSPDEC, 0x04 }, + { NVKM_ENGINE_MSPPP, 0x08 }, + { NVKM_ENGINE_MSVLD, 0x0c }, + { NVKM_ENGINE_CE0, 0x10 }, + { NVKM_ENGINE_CE1, 0x14 }, + { NVKM_ENGINE_MSENC, 0x18 }, + { NVKM_ENGINE_CE2, 0x1c }, + { NVKM_SUBDEV_NR, 0 }, +}; + +const struct gf100_idle_filter gk104_idle_filter = { + .fecs = 0x00001000, + .hubmmu = 0x00001000, +}; + +static const struct nvkm_therm_func +gk104_therm_func = { + .init = gf119_therm_init, + .fini = g84_therm_fini, + .pwm_ctrl = gf119_fan_pwm_ctrl, + .pwm_get = gf119_fan_pwm_get, + .pwm_set = gf119_fan_pwm_set, + .pwm_clock = gf119_fan_pwm_clock, + .temp_get = g84_temp_get, + .fan_sense = gt215_therm_fan_sense, + .program_alarms = nvkm_therm_program_alarms_polling, + .clkgate_enable = gk104_clkgate_enable, + .clkgate_fini = gk104_clkgate_fini, +}; + +static int +gk104_therm_new_(const struct nvkm_therm_func *func, + struct nvkm_device *device, + int index, + const struct gk104_clkgate_engine_info *clkgate_order, + const struct gf100_idle_filter *idle_filter, + struct nvkm_therm **ptherm) +{ + struct gk104_therm *therm = kzalloc(sizeof(*therm), GFP_KERNEL); + + if (!therm) + return -ENOMEM; + + nvkm_therm_ctor(&therm->base, device, index, func); + *ptherm = &therm->base; + therm->clkgate_order = clkgate_order; + therm->idle_filter = idle_filter; + + return 0; +} + +int +gk104_therm_new(struct nvkm_device *device, + int index, struct nvkm_therm **ptherm) +{ + return gk104_therm_new_(&gk104_therm_func, device, index, + gk104_clkgate_engine_info, &gk104_idle_filter, + ptherm); +} diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.h b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.h new file mode 100644 index 000000000000..293e7743b19b --- /dev/null +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.h @@ -0,0 +1,48 @@ +/* + * Copyright 2018 Red Hat Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: Lyude Paul + */ + +#ifndef __GK104_THERM_H__ +#define __GK104_THERM_H__ +#define gk104_therm(p) (container_of((p), struct gk104_therm, base)) + +#include +#include "priv.h" +#include "gf100.h" + +struct gk104_clkgate_engine_info { + enum nvkm_devidx engine; + u8 offset; +}; + +struct gk104_therm { + struct nvkm_therm base; + + const struct gk104_clkgate_engine_info *clkgate_order; + const struct gf100_idle_filter *idle_filter; +}; + +extern const struct gk104_clkgate_engine_info gk104_clkgate_engine_info[]; +extern const struct gf100_idle_filter gk104_idle_filter; + +#endif diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h index 1f46e371d7c4..f30202dd88e7 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h @@ -32,6 +32,8 @@ int nvkm_therm_new_(const struct nvkm_therm_func *, struct nvkm_device *, int index, struct nvkm_therm **); +void nvkm_therm_ctor(struct nvkm_therm *therm, struct nvkm_device *device, + int index, const struct nvkm_therm_func *func); struct nvkm_fan { struct nvkm_therm *parent; @@ -66,8 +68,6 @@ int nvkm_therm_fan_set(struct nvkm_therm *, bool now, int percent); int nvkm_therm_fan_user_get(struct nvkm_therm *); int nvkm_therm_fan_user_set(struct nvkm_therm *, int percent); -int nvkm_therm_preinit(struct nvkm_therm *); - int nvkm_therm_sensor_init(struct nvkm_therm *); int nvkm_therm_sensor_fini(struct nvkm_therm *, bool suspend); void nvkm_therm_sensor_preinit(struct nvkm_therm *); @@ -96,6 +96,9 @@ struct nvkm_therm_func { int (*fan_sense)(struct nvkm_therm *); void (*program_alarms)(struct nvkm_therm *); + + void (*clkgate_enable)(struct nvkm_therm *); + void (*clkgate_fini)(struct nvkm_therm *, bool); }; void nv40_therm_intr(struct nvkm_therm *); @@ -112,8 +115,16 @@ void g84_therm_fini(struct nvkm_therm *); int gt215_therm_fan_sense(struct nvkm_therm *); void g84_therm_init(struct nvkm_therm *); + +int gf119_fan_pwm_ctrl(struct nvkm_therm *, int, bool); +int gf119_fan_pwm_get(struct nvkm_therm *, int, u32 *, u32 *); +int gf119_fan_pwm_set(struct nvkm_therm *, int, u32, u32); +int gf119_fan_pwm_clock(struct nvkm_therm *, int); void gf119_therm_init(struct nvkm_therm *); +void gk104_clkgate_enable(struct nvkm_therm *); +void gk104_clkgate_fini(struct nvkm_therm *, bool); + int nvkm_fanpwm_create(struct nvkm_therm *, struct dcb_gpio_func *); int nvkm_fantog_create(struct nvkm_therm *, struct dcb_gpio_func *); int nvkm_fannil_create(struct nvkm_therm *); -- 2.14.3